PHP 학습 배열 요약 [경험]_php 스킬

PHP에는 배열 작업을 용이하게 하기 위해 배열에 대한 많은 기능이 있습니다.

정의:

배열의 각 항목에는 키와 값이라는 두 가지 항목이 포함되어 있으며 해당 값은 키를 쿼리하여 얻을 수 있습니다. 이러한 키는 숫자 키 또는 연관 키일 수 있습니다. 숫자 키는 값과 실제로 연결되어 있지 않으며 단지 배열에 있는 값의 위치일 뿐입니다.

PHP는 관련 키를 사용하든 숫자 키를 사용하든 배열을 탐색하는 다양한 방법을 제공합니다. 이 방법은 모두 배열 포인터라는 기능에 의존합니다.

배열 생성

PHP는 배열을 생성할 때 배열의 크기를 지정할 필요가 없습니다. PHP는 느슨한 언어이기 때문에 배열을 사용하기 전에 선언할 필요가 없습니다. 제한은 없지만 PHP는 배열 선언의 공식 및 비공식 방법을 제공합니다.

대괄호 쌍으로 표시된 PHP 배열의 각 요소를 참조합니다. 배열에는 크기 제한이 없으므로 참조를 설정하여 간단히 배열을 만들 수 있습니다. 예:

$state[0]= ‘111';

$state[1]= ‘222';

인덱스 값이 숫자 인덱스이고 증가하는 경우 생성 시 인덱스 값을 생략할 수도 있습니다.

$state[] =‘111';

$state[] =‘222';

array()를 사용하여 다음과 같은 배열을 만들 수 있습니다.

$state =array(‘111', ‘222');

$state =array(‘one'=>'111', ‘two'=>'222');

list()를 사용하여 배열을 추출합니다. 예:

$state= array(‘one', ‘two', ‘three');

list($one,$two, $three) = $state;

배열의 세 값은 각각 $1, $2, $3에 할당되어 있으며 직접 출력할 수 있습니다.

미리 정의된 값 범위로 배열을 채웁니다. 예:

$num= range(1, 6);

//类似于$num =array(1, 2, 3, 4, 5, 6);

可选择奇偶：$num =range(1, 6, 2);

//$num= array(1, 3, 5);

可选择字母：$ch =range(“A”, “F”);

//$ch= array(“A”, “B”, “C”, “D”, “E”, “F”);

출력 배열

배열의 내용을 출력하는 가장 일반적인 방법은 각 배열 키를 반복하여 해당 값을 출력하는 것입니다.

foreach() 함수는 배열을 쉽게 순회하여 각 값과 키를 가져올 수 있습니다.

print_r() 함수는 배열의 내용을 화면에 출력할 때 매우 편리합니다. prinf_r() 함수는 변수를 받아들이고 그 내용을 표준 출력으로 보내고, 성공하면 TRUE를 반환하고, 그렇지 않으면 FALSE를 반환합니다.

배열 테스트

is_array() 함수를 통해 특정 변수가 배열인지 알아보세요.

is_array() 함수는 변수가 배열인지 확인합니다. 그렇다면 TRUE를 반환하고, 그렇지 않으면 FALSE를 반환합니다. 배열에 값이 하나만 포함되어 있어도 배열로 간주됩니다.

배열 요소 추가 및 제거

PHP는 다양한 대기열 구현의 모방을 용이하게 하는 배열 확장 및 축소를 위한 몇 가지 기능을 제공합니다.

배열 헤드에 요소 추가:

array_unshift() 함수는 배열의 헤드에 요소를 추가합니다. 모든 기존 숫자 키는 배열의 새 위치를 반영하도록 수정되지만 관련 키는 영향을 받지 않습니다.

$state= array(‘11', ‘22', ‘33');

array_unshift($state,‘00');

//$state= array(‘00', ‘11', ‘22', ‘33');

배열 끝에 요소 추가:

array_push() 함수는 배열의 끝에 값을 추가하고 새 값을 추가한 후 배열의 전체 요소 수를 반환합니다. 동시에 이 변수를 이 함수에 대한 입력 매개변수로 전달하면 여러 변수(요소)가 다음 형식으로 배열에 푸시됩니다.

$state= array(‘1', ‘2');

array_push($state,‘3');

//$state= array(‘1', ‘2', ‘3');

배열 헤드에서 요소 제거:

array_shift() 함수는 배열에서 발견된 첫 번째 요소를 제거하고 반환합니다. 결과적으로 숫자 키를 사용하면 해당 값이 모두 아래로 이동하는 반면 연관 키를 사용하는 배열은 영향을 받지 않습니다.

$state= array(‘1', ‘2');

array_shift($state);

//$state= array(‘2');

배열 끝에서 요소 삭제:

array_pop() 함수는 배열의 마지막 요소를 삭제하고 반환하며 형식은 다음과 같습니다.

$state= array(‘1', ‘2');

array_pop($state);

//$state= array(‘1');

배열 요소 위치 지정

검색 배열:

in_array() 함수는 배열에서 특정 값을 검색합니다. 값이 발견되면 TRUE를 반환하고, 그렇지 않으면 FALSE를 반환합니다.

$user= array(‘111', ‘222', ‘333');

$str= ‘111';

if(in_array($str,$user)){

echo‘yes';

}else{

echo ‘no';

}

세 번째 매개변수 strict는 선택사항이며 검색 시 in_array()가 유형을 고려하도록 강제합니다.

연관 배열 검색:

지정된 키가 배열에서 발견되면 array_key_exists() 함수는 TRUE를 반환하고, 그렇지 않으면 FALSE를 반환합니다. 형태는 다음과 같습니다.

$arr= array('one'=>'1', 'two'=>'2', 'three'=>'3');

if(array_key_exists('two',$arr)){

echo'yes';

}else{

echo‘no';

}

연관 배열 검색:

array_search() 함수는 배열에서 지정된 값을 검색합니다. 발견되면 해당 값을 반환하고, 그렇지 않으면 FALSE를 반환합니다.

$arr= array('one'=>'1', 'two'=>'2', 'three'=>'3');

if(array_search('1',$arr)){

echo'yes';

}else{

echo‘no';

}

배열 키 가져오기:

array_key() 함수는 검색된 배열에서 찾은 모든 키가 포함된 배열을 다음 형식으로 반환합니다.

$arr= array('one'=>'1', 'two'=>'2', 'three'=>'3');

$keys= array_keys($arr);

var_dump($keys);

//array(3) {[0]=> string(3) "one" [1]=> string(3) "two" [2]=>string(5) "three" }

배열 값 가져오기:

array_values() 함수는 배열의 모든 값을 반환하고 반환된 배열에 대해 다음 형식의 배열 인덱스를 자동으로 제공합니다.

$arr= array('one'=>'1', 'two'=>'2', 'three'=>'3');

$values= array_values($arr);

var_dump($values);

//array(3) {[0]=> string(1) "1" [1]=> string(1) "2" [2]=>string(1) "3" }

遍历数组

通常需要遍历数组并获得各个键或值(或者同时获得键和值)，PHP提供了一些函数来满足需求。许多函数能完成两项任务，不仅能获取当前指针位置的键或值，还能将指针移向下一个适当的位置。

获取当前数组键：

key()函数返回数组中当前指针所在位置的键，其形式如下：

$arr= array('one'=>'1', 'two'=>'2', 'three'=>'3');

$key= key($arr);

var_dump($key);

//string(3) "one"

注意：每次调用key()时不会移动指针。

获取当前数组值：

current()函数返回数组中当前指针所在位置的数组值。其形式如下：

$arr= array('one'=>'1', 'two'=>'2', 'three'=>'3');

$value= current($arr);

var_dump($value);

//string(1)“1”

获取当前数组键和值：

each()函数返回数组的当前键/值对，并将指针推进一个位置，其形式如下：

$arr =array('one'=>'1', 'two'=>'2', 'three'=>'3');

var_dump(each($arr));

//array(4) {[1]=> string(1) "1" ["value"]=> string(1)"1" [0]=> string(3) "one" ["key"]=>string(3) "one" }

返回的数组包含4个键，键0和key键包含键名，而键1和value包含相应的数据。如果执行each()前指针位于数组末尾，则返回FALSE。

移动数组指针：

1) 将指针移动到下一个数组位置

next()函数返回紧接着放在当前数组指针下一个位置的数组值，如果指针本来就位于数组的最后一个位置，则返回FALSE

$arr= array('one'=>'1', 'two'=>'2', 'three'=>'3');

echo next($arr); //输出2

echo next($arr); //输出3

2) 将指针移动到前一个数组位置

prev()函数返回位于当前指针前一个位置的数组值，如果指针本来就位于数组的第一个位置，则返回FALSE

3) 将指针移动到第一个数组位置

reset()函数用于将数组指针设置回数组的开始位置，如果需要在脚本中多次查看或处理一个数组，经常使用这个函数，另外这个函数还经常在排序结束时使用。

4) 将指针移动到最后一个数组位置

end()函数将指针移动到数组的最后一个位置，并返回最后一个元素。

向函数传递数组值：

array_walk()函数将数组中的各个元素传递到用户自定义函数。如果需要对各个数组元素完成某个特定动作，这个函数将起作用。其形式如下：

functiontest($value ,$key){

echo$value.' '.$key."
";

}

$arr= array('one'=>'1', 'two'=>'2', 'three'=>'3');

array_walk($arr,'test');

//1 one

//2 two

//3 three

如果使用多维数组，PHP5中引入的array_walk_recursive()函数可以递归地对数组中的每一个元素应用一个用户定义函数。

确定数组大小和元素唯一性

确定数组的大小：

count()函数返回数组中值的总数

如果启动了可选的mode参数(设置为1)，数组将进行递归计数统计元素。count(array(), 1);

注意：sizeof()函数是count()的别名。功能一致。

统计数组元素出现的频率：

array_count_values()函数返回一个包含关联键/值对的数组，其形式如下：

$arr= array('A', 'B', 'C', 'A');

$res= array_count_values($arr);

print_r($res);

//Array( [A] => 2 [B] => 1 [C] => 1 )

值表示出现的频率。

确定唯一的数组元素：

array_unique()函数会删除数组中所有重复的值，返回一个由唯一值组成的数组，其形式如下：

$arr= array('A', 'B', 'C', 'A');

$res= array_unique($arr);

print_r($res);

//Array( [0] => A [1] => B [2] => C )

可选参数sort_flags(PHP5.2.9中新增)可以确定如何对数组键排序。默认地，值会被作为字符串排序，不过也可以按数值对值排序(SORT_NUMERIC)，或使用PHP默认的排序方法(SORT_REGULAR)，还可以根据本地化环境排序(SORT_LOCALE_STRING)。

数组排序

逆置数组元素排序：

array_reverse()函数将数组中元素的顺序逆置，其形式如下：

$arr= array('A', 'B', 'C');

$res= array_reverse($arr);

print_r($res);

//Array( [0] => C [1] => B [2] => A )

如果可选参数preserve_keys设置为TRUE，则保持键映射，否则重新摆放后的各个值将对应于先前该位置上的相应键。

$arr= array('A', 'B', 'C');

$res= array_reverse($arr, true);

print_r($res);

//Array( [2] => C [1] => B [0] => A )

置换数组键和值：

array_flip()函数将置换数组中键及其相应值的角色，其形式如下：

$arr= array('A', 'B', 'C');

$res= array_flip($arr);

print_r($res);

//Array( [A] => 0 [B] => 1 [C] => 2 )

数组排序：

sort()函数对数组进行排序，各元素按值由低到高的顺序排列，其形式如下：

sort()函数不返回排序后的数组，相反它只是“就地”对数组排序，不论结果如何都不返回任何值。sort_flags参数可选，将根据这个参数指定的值修改该函数的默认行为。

1) SORT_NUMERIC，按数值排序。对整数和浮点数排序很有用。

2) SORT_REGULAR，按照相应的ASCII值对元素排序。

3) SORT_STRING，按接近于人所认知的正确顺序对元素排序。

要保持初始键/值对应条件下的数组排序需要用到asort()函数。

assort()函数与sort()函数相同，以升序对数组排序，只不过它将保持键/值的关联，其形式如下：

$arr= array('C', 'B', 'A');

$res= $arr;

print_r($arr);

sort($arr);

print_r($arr);

asort($res);

print_r($res);

//Array ( [0]=> C [1] => B [2] => A ) Array ( [0] => A [1] => B [2] => C )Array ( [2] => A [1] => B [0] => C )

以逆序对数组排序

rsort()函数与sort()函数相同，只不过它以相反的顺序(降序)对数组元素排序。

如果使用可选的sort_flags参数，具体的排序行为将由这个值确定。

保持键/值对的条件下以逆序对数组排序

与asort()一样，arsort()函数会保持键/值的关联，但是它以逆序对数组up

$arr= array('C', 'B', 'A', 'D');

arsort($arr);

print_r($arr);

//Array( [3] => D [0] => C [1] => B [2] => A )

如果使用可选的sort_flags参数，具体的排序行为将由这个值确定。

数组自然排序

natsort()函数提供了一种相当于人们平常使用的排序机制。

典型算法排序如下：

p1.jpg,p10.jpg, p2.jpg, p20.jpg

使用natsort()函数如下：

p1.jpg,p2.jpg, p10.jpg, p20.jpg

不区分大小写的自然排序

如：

Picture1.jpg,PICTURE10.jpg, picture2.jpg, picture20.jpg

按键值对数组排序

ksort()函数按键对数组排序，如果成功则返回TRUE，失败将返回FALSE

以逆序对数组键排序

krsort()函数的操作与ksort()相同，也按键排序，将以逆序排序。

根据用户自定义规则排序

usort()函数提供了另一种排序方法，可以使用在该函数中指定的用户自定义比较算法对数组排序。如果需要以某种方法对数据排序，而PHP的任何内置排序函数没有提供相应支持，就需要该函数。

数组合并、拆分、接合和分解

合并数组

array_merge()函数将数组合并到一起，返回一个联合的数组。所得到的数组以第一个输入数组参数开始，按后面数组参数出现的顺序依次追加。其形式如下：

$arr= array('C', 'B', 'A', 'D');

$arr1= array('1', '2', '3', '4');

$arr2= array_merge($arr, $arr1);

print_r($arr2);

//Array( [0] => C [1] => B [2] => A [3] => D [4] => 1 [5] => 2 [6]=> 3 [7] => 4 )

递归追加数组

array_merge_recursive()函数与array_merge()相同，可以将两个或多个数组合并到一起，形成一个联合的数组。两者之间的区别在于，当某个输入数组中的某个键已经存在于结果数组中时该函数会采取不同的处理方法。array_merge()会覆盖前面存在的键/值对，将其替换为当前输入数组中的键/值对，而array_merge_recursive()将两个值合并在一起，形成一个新的数组并以原有的键作为数组名。其形式为：

$arr= array('one'=>'C', 'one'=>'B');

$arr1= array('three'=>'1', 'one'=>'2');

$arr2= array_merge_recursive($arr, $arr1);

print_r($arr2);

//Array( [one] => Array ( [0] => B [1] => 2 ) [three] => 1 )

合并两个数组

array_combine()函数会生成一个新数组，这个数组由一组提交的键和对应的值组成，其形式为：

$arr= array('A', 'B');

$arr1= array('1', '2');

$arr2= array_combine($arr, $arr1);

print_r($arr2);

//Array( [A] => 1 [B] => 2 )

拆分数组

array_slice()函数将返回数组中的一部分，从键offset开始，到offset+length位置结束。

offset为正值时，拆分将从距数组开头的offset位置开始;如果offset为负值，则拆分从距数组末尾的offset位置开始。如果省略了可选参数length，则拆分将从offset开始，一直到数组的最后一个元素。如果给出了length且为正数，则会在距数组开头的offset+length位置结束。相反，如果给出了length且为负数，则在距数组开头的count(array) - |length|位置结束。其形式如下：

$arr= array('A', 'B', 'C', 'D');

$arr1= array_slice($arr, 2, 1);

print_r($arr1);

//Array( [0] => C )

求数组的交集

array_intersect()函数返回一个保留了键的数组，这个数组只由第一个数组中出现的且在其他每个输入数组中都出现的值组成。其形式如下：

$arr= array('A', 'B', 'C', 'D');

$arr1= array('A', 'B', 'E');

$arr2= array('A', 'F', 'D');

$arr3= array_intersect($arr, $arr1, $arr2);

print_r($arr3);

//Array( [0] => A )

注意：只有在两个元素有相同的数据类型时，array_intersect()才会认为它们相等。

求关联数组的交集

array_intersect_assoc()与array_intersect()基本相同，只不过它在比较中还考虑了数组的键。因此，只有在第一个数组中出现，且在所有其他输入数组中也出现的键/值对才被返回到结果数组中。其形式如下：

$arr= array('a'=>'A', 'b'=>'B', 'c'=>'C', 'd'=>'D');

$arr1= array('a'=>'A', 'c'=>'B', 'E');

$arr2= array('a'=>'A', 'b'=>'F', 'd'=>'B');

$arr3= array_intersect_assoc($arr, $arr1, $arr2);

print_r($arr3);

//Array( [a] => A )

求关联数组的差集

函数array_diff_assoc()与array_diff()基本相同，只是它在比较时还考虑了数组的键，因此，只在第一个数组中出现而不在其他输入数组中出现的键/值对才会被返回到结果数组中。其形式如下：

$arr= array('a'=>'A', 'b'=>'B', 'c'=>'C', 'd'=>'D');

$arr1= array('a'=>'A', 'b'=>'B', 'e'=>'E');

$arr3= array_diff_assoc($arr, $arr1);

print_r($arr3);

//Array( [c] => C [d] => D )

其他有用的数组函数

返回一组随机的键

array_rand()函数将返回数组中的一个或多个键。其形式为：

$arr= array('a'=>'A', 'b'=>'B', 'c'=>'C', 'd'=>'D');

$arr1= array_rand($arr, 2);

print_r($arr1);

//Array( [0] => b [1] => d )

随机洗牌数组元素

shuffle()函数随机地对数组元素重新排序。

对数组中的值求和

array_sum()函数将数组内的所有值加在一起，返回最终的和，其形式如下：

$arr= array('A', 32, 12, 'B');

$count= array_sum($arr);

print_r($count);

//44

如果数组中包含其他数据类型(例如字符串)，这些值将被忽略。

划分数组

array_chunk()函数将数组分解为一个多维数组，这个多维数组由多个包含size个元素的数组所组成。其形式如下：

$arr= array('A', 'B', 'C', 'D');

$arr1= array_chunk($arr, 2);

print_r($arr1);

//Array( [0] => Array ( [0] => A [1] => B ) [1] => Array ( [0] => C [1]=> D ) )