创建数组

PHP不需要在创建数组时指定其大小，因为PHP是一种松散的语言，所以不需要在使用数组前先行声明。尽管没有限制，PHP仍提供了正式和非正式的数组声明方法。

<?php 
// 引用PHP数组的各个元素，用一对中括号来指示。数组没有大小限制，所以只需建立引用就可以创建数组，例如：
$state[0] = '111';
$state[1] = '222';

// 如果索引值是数值索引而且是递增的，还可以在创建时省略索引值。
$state[] = '111';
$state[] = '222';

// 可以使用array()创建数组,如：
$state =array('one'=>'111', 'two'=>'222');
$state =array('111', '222');

// 使用list()提取数组,例如：
$state= array('one', 'two', 'three');
list($one,$two, $three) = $state;
// 数组内的三个值分别赋给了$one, $two,$three, 可直接输出。
echo $one,$two,$three;

// 用预定义的值范围填充数组，例如：
$num = range(1, 6);
//类似于$num =array(1, 2, 3, 4, 5, 6);
$num = range(1, 6, 2); // 可以设置步进制

$ch =range('A', 'F'); // 可选择字母
//类似于$ch = array('A', 'B', 'C', 'D', 'E', 'F');
?>

输出数组
输出数组内容最常用的方法就是迭代处理各个数组键，并输出相应的值。
foreach()函数可以很方便的遍历一个数组，得到每个value和key。

print_r()函数很方便将数组的内容输出到屏幕上。prinf_r()函数接受一个变量，并将其内容发送给标准输出，成功时返回TRUE，否则返回FALSE。

测试数组
通过is_array()函数知道某个特定变量是否一个数组。
is_array()函数确定某变量是否为数组，如果是则返回TRUE，否则返回FALSE。即使数组只包含一个值，也将被认为是一个数组。

<?php 
$state[0] = '111';
$state[1] = '222';
$bool = is_array($state);
var_dump($bool); // boolean true

$state2 = '123';
$bool = is_array($state2);
var_dump($bool); // boolean false
?>

添加和删除数组元素
PHP为扩大和缩小数组提供了一些函数，对模仿各种队列实现提供便利。

<?php 
// 在数组头添加元素：
// array_unshift()函数在数组头添加元素。所有已有的数值键都会相应地修改，以反映其在数组中的新位置，但是关联键不受影响。
$state = array('11', '22', '33');
array_unshift($state,'00');
print_r($state); // Array ( [0] => 00 [1] => 11 [2] => 22 [3] => 33 )

// 在数组尾添加元素：
// array_push()函数将值添加到数组的末尾，添加新的值之后返回数组中的元素总数。同时通过将这个变量作为输入参数传递给此函数，向数组压入多个变量(元素)，其形式为：
$state = array('1', '2');
array_push($state,'3');
print_r($state); // Array ( [0] => 1 [1] => 2 [2] => 3 )

// 从数组头删除元素：
// array_shift()函数删除并返回数组中找到的第一个元素。其结果是，如果使用的是数值键，则所有相应的值都会下移，而使用关联键的数组不受影响，其形式为：
$state= array('1', '2');
array_shift($state);
print_r($state); // Array ( [0] => 2 )

// 从数组尾删除元素：
// array_pop()函数删除并返回数组的最后一个元素，其形式为：
$state= array('1', '2');
array_pop($state);
print_r($state); // Array ( [0] => 1 )
?>

搜索数组

<?php 
// 搜索数组值：
// in_array()函数在数组中搜索一个特定值，如果找到这个值则返回TRUE，否则返回FALSE，其形式如下：
// in_array(search,array,type)
// type可选。如果设置该参数为 true，则检查搜索的数据与数组的值的类型是否相同。
// 如果 search 参数是字符串，且 type 参数设置为 true，则搜索区分大小写。
$user = array('111', '222', '333');
$str = '111';
if(in_array($str, $user)){
    echo 'yes';
}else{
	echo 'no';
} 
// 搜索关联数组键：
// 如果在一个数组中找到一个指定的键，函数array_key_exists()返回TRUE，否则返回FALSE。其形式如下：
$arr = array('one'=>'1', 'two'=>'2', 'three'=>'3');
if(array_key_exists('two',$arr)){
	echo 'yes';
}else{
	echo 'no';
}
// 搜索数组值：跟in_array功能一样，不知道什么区别
// array_search() 函数在数组中搜索某个键值，并返回对应的键名。
$arr = array('one'=>'1', 'two'=>'2', 'three'=>'3');
var_dump(array_search('1',$arr)); // 输出string 'one' (length=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);
print_r($keys); // Array ( [0] => one [1] => two [2] => three )

// 获取数组值：
// array_values()函数返回一个数组中的所有值，并自动为返回的数组提供数组索引，其形式如下：
$arr = array('one'=>'1', 'two'=>'2', 'three'=>'3');
$values = array_values($arr);
print_r($values); // Array ( [0] => 1 [1] => 2 [2] => 3 )
?>

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

<?php 
// 获取当前数组键：
// key()函数返回数组中当前指针所在位置的键，其形式如下：
// 注意：每次调用key()时不会移动指针。
$arr = array('one'=>'1', 'two'=>'2', 'three'=>'3');
$key = key($arr);
var_dump($key); // string 'one' (length=3)

// 获取当前数组值：
// current()函数返回数组中当前指针所在位置的数组值。其形式如下：
$arr = array('one'=>'1', 'two'=>'2', 'three'=>'3');
$value = current($arr);
var_dump($value); // string '1' (length=1)

// 获取当前数组键和值：
// each()函数返回数组的当前键/值对，并将指针推进一个位置，其形式如下：
// 返回的数组包含4个键，键0和key键包含键名，而键1和value包含相应的数据。如果执行each()前指针位于数组末尾，则返回FALSE。
$arr = array('one'=>'1', 'two'=>'2', 'three'=>'3');
print_r(each($arr)); // Array ( [1] => 1 [value] => 1 [0] => one [key] => one )
?>

移动数组指针：

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

<?php 
$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() 函数对数组中的每个元素应用用户自定义函数。在函数中，数组的键名和键值是参数。

<?php
function test($value , $key) {
    echo $value . ' ' . $key . "<br>";
} 
$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()函数返回一个包含关联键/值对的数组，其形式如下：

<?php
$arr = array('A', 'B', 'C', 'A');
$res = array_count_values($arr);
print_r($res); // Array ( [A] => 2 [B] => 1 [C] => 1 )  值表示出现的频率。
?>

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

<?php
$arr = array('A', 'B', 'C', 'A');
$res = array_unique($arr);
print_r($res); // Array ( [0] => A [1] => B [2] => C )
?>

数组排序

<?php
// 逆置数组元素排序：
// 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 )
?>

<?php
// sort() 函数对索引数组进行升序排序。
// 注释：本函数为数组中的单元赋予新的键名。原有的键名将被删除。
// 如果成功则返回 TRUE，否则返回 FALSE。
// sortingtype可选。规定如何比较数组的元素/项目。可能的值：
// SORT_REGULAR - 默认。把每一项按常规顺序排列（Standard ASCII，不改变类型）
// SORT_NUMERIC - 把每一项作为数字来处理。
// SORT_STRING - 把每一项作为字符串来处理。
// SORT_LOCALE_STRING - 把每一项作为字符串来处理，基于当前区域设置（可通过 setlocale() 进行更改）。
// SORT_NATURAL - 把每一项作为字符串来处理，使用类似 natsort() 的自然排序。
// SORT_FLAG_CASE - 可以结合（按位或）SORT_STRING 或 SORT_NATURAL 对字符串进行排序，不区分大小写。
$numbers=array(4,6,2,22,11);
sort($numbers);
print_r($numbers); // Array ( [0] => 2 [1] => 4 [2] => 6 [3] => 11 [4] => 22 ) 

// 要保持初始键/值对应条件下的数组排序需要用到asort()函数。
// assort()函数与sort()函数相同，以升序对数组排序，只不过它将保持键/值的关联，其形式如下：
$numbers=array(4,6,2,22,11);
asort($numbers);
print_r($numbers); // Array ( [2] => 2 [0] => 4 [1] => 6 [4] => 11 [3] => 22 )

// rsort()函数与sort()函数相同，只不过它以相反的顺序(降序)对数组元素排序。
$numbers=array(4,6,2,22,11);
rsort($numbers);
print_r($numbers); // Array ( [0] => 22 [1] => 11 [2] => 6 [3] => 4 [4] => 2 )

// arsort()函数保持键/值对的条件下以逆序对数组排序
$numbers=array(4,6,2,22,11);
arsort($numbers);
print_r($numbers); // Array ( [3] => 22 [4] => 11 [1] => 6 [0] => 4 [2] => 2 )
?>

<?php
// natsort() 函数用"自然排序"算法对数组进行排序。键值保留它们原始的键名。
// 在自然排序算法中，数字 2 小于 数字 10。在计算机排序算法中，10 小于 2，因为 "10" 中的第一个数字小于 2。
$temp_files = array("temp15.txt","temp10.txt","temp1.txt","temp22.txt","temp2.txt");
sort($temp_files);
echo "标准排序：";
print_r($temp_files); // 标准排序：Array ( [0] => temp1.txt [1] => temp10.txt [2] => temp15.txt [3] => temp2.txt [4] => temp22.txt ) 
echo "<br>";

natsort($temp_files);
echo "自然排序：";
print_r($temp_files); // 自然排序：Array ( [0] => temp1.txt [3] => temp2.txt [1] => temp10.txt [2] => temp15.txt [4] => temp22.txt )
?>

<?php
// ksort() 函数对关联数组按照键名进行升序排序
$age = array("Bill"=>"60","steve"=>"56","mark"=>"31");
// echo ord('B') . ' ',ord('b') . ' ',ord('S') . ' ',ord('s') . ' ',ord('M') . ' ',ord('m') . ' ';
// 输出对应的ascii码66 98 83 115 77 109 
// 大小字母的ascii码值小于小写字母的值
ksort($age);
print_r($age); // Array ( [Bill] => 60 [mark] => 31 [steve] => 56 )

// krsort() 函数对关联数组按照键名进行降序排序
$age = array("Bill"=>"60","steve"=>"56","mark"=>"31");
krsort($age);
print_r($age); // Array ( [steve] => 56 [mark] => 31 [Bill] => 60 )

// usort() 通过用户自定义的比较函数对数组进行排序。
// usort(array,myfunction);
// array 必需。规定要进行排序的数组。
// myfunction 可选。定义可调用比较函数的字符串。如果第一个参数小于等于或大于第二个参数，那么比较函数必须返回一个小于等于或大于 0 的整数。
function my_sort($a,$b){
	if ($a == $b) return 0;
	return ($a < $b) ? -1 : 1;
}
$a = array(4,2,8,6);
usort($a,"my_sort");
print_r($a); // Array ( [0] => 2 [1] => 4 [2] => 6 [3] => 8 )
?>

合并数组

<?php
// array_merge() 函数把一个或多个数组合并为一个数组。
// 注释：如果两个或更多个数组元素有相同的键名，则最后的元素会覆盖其他元素。
// 注释：如果您仅向 array_merge() 函数输入一个数组，且键名是整数，则该函数将返回带有整数键名的新数组，其键名以 0 开始进行重新索引（参见下面的实例 1）。

$a1=array("a"=>"red","b"=>"green");
$a2=array("c"=>"blue","b"=>"yellow");
print_r(array_merge($a1,$a2)); // Array ( [a] => red [b] => yellow [c] => blue )

// array_merge_recursive() 函数把一个或多个数组合并为一个数组。
// 该函数与 array_merge() 函数的区别在于处理两个或更多个数组元素有相同的键名时。array_merge_recursive() 不会进行键名覆盖，而是将多个相同键名的值递归组成一个数组。
$a1=array("a"=>"red","b"=>"green");
$a2=array("c"=>"blue","b"=>"yellow");
print_r(array_merge_recursive($a1,$a2)); // Array ( [a] => red [b] => Array ( [0] => green [1] => yellow ) [c] => blue )

// array_combine() 函数通过合并两个数组来创建一个新数组，其中的一个数组是键名，另一个数组的值为键值。
// 注释：键名数组和键值数组的元素个数必须相同！
// 如果其中一个数组为空，或者两个数组的元素个数不同，则该函数返回 false。
$fname = array("Bill","Steve","Mark");
$age = array("60","56","31");
$c = array_combine($fname,$age);
print_r($c); // Array ( [Bill] => 60 [Steve] => 56 [Mark] => 31 )
?>

拆分数组

<?php
// 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 )
?>

求数组的交集

<?php
// array_intersect()函数返回一个保留了键的数组，这个数组只由第一个数组中出现的且在其他每个输入数组中都出现的值组成。其形式如下：
// 注意：只有在两个元素有相同的数据类型时，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_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 )
?>

求关联数组的差集

<?php
// array_diff() 函数返回两个数组的差集数组。该数组包括了所有在被比较的数组中，但是不在任何其他参数数组中的键值。
$arr = array('a'=>'A', 'b'=>'B', 'c'=>'C', 'd'=>'D');
$arr1 = array('a'=>'A', 'c'=>'B', 'e'=>'E');
$arr3 = array_diff($arr, $arr1);
print_r($arr3); // Array ( [c] => C [d] => D )

// 函数array_diff_assoc()与array_diff()基本相同，只是它在比较时还考虑了数组的键，因此，只在第一个数组中出现而不在其他输入数组中出现的键/值对才会被返回到结果数组中。其形式如下：
$arr = array('a'=>'A', 'b'=>'B', 'c'=>'C', 'd'=>'D');
$arr1 = array('a'=>'A', 'c'=>'B', 'e'=>'E');
$arr3 = array_diff_assoc($arr, $arr1);
print_r($arr3); // Array ( [b] => B [c] => C [d] => D )
?>

其他有用的数组函数

<?php
// 返回一组随机的键
// 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()函数随机地对数组元素重新排序。
$arr = array('a'=>'A', 'b'=>'B', 'c'=>'C', 'd'=>'D');
shuffle($arr);
print_r($arr); // Array ( [0] => D [1] => A [2] => B [3] => C ) 随机出现

// 对数组中的值求和
// 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, 3);
print_r($arr1); // Array ( [0] => Array ( [0] => A [1] => B [2] => C ) [1] => Array ( [0] => D ) )
?>