PHP中关于数组的函数

(1)sort/asort/ksort(&$array)

共同点：三个函数都是引用传值,对数组进行升序排序,成功返回true,失败返回false。

不同点：sort按数组中的值进行排序,为数组中的元素赋予新的键名,原有的键名将被删除,例如：

$test = array('c' => 'c', 'a', 'b');

sort($test);

var_dump($test);

输出：array(3) { [0]=> string(1) "a" [1]=> string(1) "b" [2]=> string(1) "c" }

asort按数组中的值进行排序,保持原来的键值关系,原有的键名不会被删除,例如：

$test = array('c' => 'c', 'a', 'b');

asort($test);

var_dump($test);

输出：array(3) { [0]=> string(1) "a" [1]=> string(1) "b" ["c"]=> string(1) "c" }

ksort按数组中的键进行排序,保持原来的键值关系,原有的键名不会被删除,例如：

$test = array('a', 'b', 'c' => 'c');

ksort($test);

var_dump($test);

输出：array(3) { [0]=> string(1) "a" ["c"]=> string(1) "c" [1]=> string(1) "b" }

(2)rsort/arsort/krsort(&$array)

共同点：三个函数都是引用传值,对数组进行降序排序,成功返回true,失败返回false。

不同点：rsort按数组中的值进行排序,为数组中的元素赋予新的键名,原有的键名将被删除,例如：

$test = array('c' => 'c', 'a', 'b');

rsort($test);

var_dump($test);

输出：array(3) { [0]=> string(1) "c" [1]=> string(1) "b" [2]=> string(1) "a" }

arsort按数组中的值进行排序,保持原来的键值关系,原有的键名不会被删除,例如：

$test = array('c' => 'c', 'a', 'b');

arsort($test);

var_dump($test);

输出：array(3) { ["c"]=> string(1) "c" [1]=> string(1) "b" [0]=> string(1) "a" }

krsort按数组中的键进行排序,保持原来的键值关系,原有的键名不会被删除,例如：

$test = array('a', 'b', 'c' => 'c');

krsort($test);

var_dump($test);

输出：array(3) { [1]=> string(1) "b" ["c"]=> string(1) "c" [0]=> string(1) "a" }

(3)shuffle(&$array)

按数组中的值随机排序,为数组中的元素赋予新的键名,原有的键名将被删除,成功返回true,失败返回false,例如：

$a = array('a' => 'c', 'b' => 'b', 'c' => 'a');

shuffle($a);

var_dump($a);

输出：array(3) { [0]=> string(1) "b" [1]=> string(1) "c" [2]=> string(1) "a" }

(4)array_merge(array1, array2, array3...)

把两个或两个以上的数组合并为一个数组,如果键名有重复,后边的值会覆盖前边的值,如果数组是数字索引的,则键名会以连续方式重新索引，例如：

$testa = array('a', 'b', 'c' => 'c');

$testb = array('d'=>'d', 'b' => 'b', 'c' => 'c', 'e');

$test = array_merge($testa, $testb);

var_dump($test);

输出：array(6) { [0]=> string(1) "a" [1]=> string(1) "b" ["c"]=> string(1) "c" ["d"]=> string(1) "d" ["b"]=> string(1) "b" [2]=> string(1) "e" }

(5)array_chunk(array, size, preserve_key)

分割数组,size标识分割后的数组中元素的个数,preserve_key标识是否保留原来的键名,true保留false不保留,默认是false,例如：

$a = array('a', 'c' => 'c', 'b', 'd' => 'd');

$a = array_chunk($a, 2);

var_dump($a);

输出：array(2) { [0]=> array(2) { [0]=> string(1) "a" [1]=> string(1) "c" } [1]=> array(2) { [0]=> string(1) "b" [1]=> string(1) "d" } }

(6)array_flip(array)

将数组的键和值交换,如果一个值出现了多次,最后一个键名将作为它的值,其他的键名都将丢失,例如：

$a = array('a', 'c' => 'c', 'b', 'd' => 'd', 'a', 'cc' => 'c');

$a = array_flip($a);

var_dump($a);

输出：array(4) { ["a"]=> int(2) ["c"]=> string(2) "cc" ["b"]=> int(1) ["d"]=> string(1) "d" }

(7)array_reverse(array, preserve)

将数组中的元素顺序翻转,创建新的数组并返回,第二个参数如果是true则保持原来的键名,否则重新索引,默认false,例如：

$a = array('a', 'c' => 'c', 'b', 'd' => 'd');

$a = array_reverse($a, true);

var_dump($a);

输出：array(4) { ["d"]=> string(1) "d" [1]=> string(1) "b" ["c"]=> string(1) "c" [0]=> string(1) "a" }

(8)array_slice(array, offset, length, preserve)

从数组中根据条件取出一段值并返回一个新数组,offset规定取出元素的开始位置,如果是正数,则从前往后开始取,如果是负值,从后向前取offset绝对值,length规定返回数组的长度,preserve规定是否保留键,true保留,false不保留,默认false,例如：

$a = array('a', 'c' => 'c', 'b', 'd' => 'd');

$a = array_slice($a, 1, 3);

var_dump($a);

输出：array(3) { ["c"]=> string(1) "c" [0]=> string(1) "b" ["d"]=> string(1) "d" }

(9)array_unique(array)

移除数组中的重复的值,数组元素的值相等时,只保留第一个元素,其他的元素被删除,例如：

$a = array('ab' => 'a', 'a' => 'a', 'bc' => 'b', 'b' => 'b');

$a = array_unique($a);

var_dump($a);

输出：array(2) { ["ab"]=> string(1) "a" ["bc"]=> string(1) "b" }

(10)array_key_exists(key, array)

判断某个数组中是否存在指定的key,如果存在返回true,否则返回false,例如：

$a = array('ab' => 'a', 'a' => 'a', 'bc' => 'b', 'b' => 'b');

$a = array_key_exists('bc', $a);

var_dump($a);

输出：bool(true)

(11)in_array(value, array, type)

判断某个数组中是否存在指定的value,如果存在返回true,否则返回false,如果第三个参数设置为true,只有在元素存在于数组中且数据类型与给定值相同时才返回true,例如：

$a = array(1,2,3);

$a = in_array('3', $a, true);

var_dump($a);

输出：bool(false)

(12)array_search(value, array, strict)

查找指点元素值的键名,找到了返回键名,找不到返回false,如果第三个参数strict被指定为true,则只有在数据类型和值都一致时才返回相应元素的键名,例如：

$a = array('a' => 1, 'b' => 2, 'c' => '3', 'd' => 3);

$b = array_search(3, $a, true);

var_dump($b);

输出：string(1) "d"

(13)array_change_key_case(array, case)

把数组的所有的KEY都转换为大写或小写,默认是小写,例如：

$a = array('a', 'c' => 'c', 'b', 'd' => 'd');

$a = array_change_key_case($a, CASE_UPPER);

var_dump($a);

输出：array(4) { [0]=> string(1) "a" ["C"]=> string(1) "c" [1]=> string(1) "b" ["D"]=> string(1) "d" }

(14)array_push(array, value1, value2...)

在数组的尾部添加一个或多个元素,返回数组的新长度,新加的元素都是以数字作为索引,例如：

$a = array(1,2,3);

$a = array_push($a, 4, 5);

var_dump($a);

输出：int(5)

(15)array_pop(array)

取出数组最后一个元素值并返回,同时数组的长度减一,例如：

$a = array(1,'a' => 2, 'b' => 3);

$b = array_pop($a);

var_dump($b);

输出：int(3)

(16)array_shift(array)

取出数组第一个元素值并返回,同时数组的长度减一,例如：

$a = array('c' => 1,'a' => 2, 'b' => 3);

$b = array_shift($a);

var_dump($b);

输出：int(1)

(17)range(first, second, step)

以特定的步长(默认步长为1)创建并返回一个包含指定范围的元素的数组,例如：

$a = range(10, 1, 2);

var_dump($a);

输出：array(5) { [0]=> int(10) [1]=> int(8) [2]=> int(6) [3]=> int(4) [4]=> int(2) }

(18)array_fill(start, number, value)

从start位置开始并递增填充number个以value为值的数组,例如：

$a = array_fill(0, 3, 'test');

var_dump($a);

输出：array(3) { [0]=> string(4) "test" [1]=> string(4) "test" [2]=> string(4) "test" }

(19)array_count_values(array)

统计数组中元素的个数,返回一个以元素值为键名个数为键值的数组,例如：

$a = array('a' => 'c', 'b' => 'b', 'c' => 'a', 'ab' => 'c', 'bc' => 'a');

$a = array_count_values($a);

var_dump($a);

输出：array(3) { ["c"]=> int(2) ["b"]=> int(1) ["a"]=> int(2) }

(20)array_values(array)

返回一个包含给定数组中所有键值的数组,但不保留键名,例如：

$a = array('a' => 'c', 'b' => 'b', 'c' => 'a', 'ab' => 'c', 'bc' => 'a', 'd');

$a = array_values($a);

var_dump($a);

输出：array(6) { [0]=> string(1) "c" [1]=> string(1) "b" [2]=> string(1) "a" [3]=> string(1) "c" [4]=> string(1) "a" [5]=> string(1) "d" }

(21)array_keys(array, value, strict)

返回一个包含给定数组中所有键名的数组,如果提供了第二个参数,则只返回键值为该值的键名,如果strict参数指定为true,则PHP会使用全等比较(===)来严格检查键值的数据类型,例如：

$a = array('a' => 1, 'b' => 2, 'c' => 3, '3', 4, '4');

$a = array_keys($a, 3, true);

var_dump($a);

输出：array(1) { [0]=> string(1) "c" }

(22)array_filter(array, function)

用回调函数过滤数组中的元素,如果自定义过滤函数返回true,则被操作的数组的当前值就会被包含在返回的结果数组中,并将结果组成一个新的数组,如果原数组是一个关联数组,键名保持不变,例如：

function filter($v){

if(($v['id']%2) == 0) return true;

}

$a = array(

'a' => array('id' => 1),

'b' => array('id' => 2),

);

$b = array_filter($a, "filter");

var_dump($b);

输出：array(1) { ["b"]=> array(1) { ["id"]=> int(2) } }

(23)array_map(function, array1, array2, array3...)

返回用户自定义函数作用后的数组,回调函数接受的参数数目和传递给array_map()函数的数组数目一致,例如：

function filter($v){

if(($v['k']%2) == 0){

$v['v'] = '可以';

}else{

$v['v'] = '不可以';

}

$v['v'] .= '被2整除';

return $v;

}

$a = array(

'a' => array('k' => 1),

'b' => array('k' => 2),

);

$b = array_map("filter", $a);

var_dump($b);

输出：array(2) { ["a"]=> array(2) { ["k"]=> int(1) ["v"]=> string(19) "不可以被2整除" } ["b"]=> array(2) { ["k"]=> int(2) ["v"]=> string(16) "可以被2整除" } }

(24)is_array (mixed $var)

判断是否是数组,true是,false不是,例如：

$a = 'a';

$a = is_array($a);

var_dump($a);

输出：bool(false)

(25)array_intersect/array_intersect_assoc(array1, array2, array3...)

共同点：求数组的交集,键名保持不变

不同点：array_intersect_assoc除了比较键值,还比较键名

例如：

$a = array('a' => 'a', 1, 2, 'b' => 'b');

$b = array(2, 1, 'a' => 'a', 'b' => 'b');

$c = array_intersect($a, $b);

var_dump($c);

输出：array(4) { ["a"]=> string(1) "a" [0]=> int(1) [1]=> int(2) ["b"]=> string(1) "b" }

$c = array_intersect_assoc($a, $b);

var_dump($c);

输出：array(2) { ["a"]=> string(1) "a" ["b"]=> string(1) "b" }

(26)array_diff/array_diff_assoc(array1, array2, array3...)

共同点：求数组的差集,键名保持不变

不同点：array_diff_assoc除了比较键值,还比较键名

例如：

$a = array('a' => 'a', 1, 2, 'b' => 'b', 'c' => 'c');

$b = array(2, 1, 'a' => 'a', 'b' => 'b');

$c = array_diff($a, $b);

var_dump($c);

输出：array(1) { ["c"]=> string(1) "c" }

$c = array_diff_assoc($a, $b);

var_dump($c);

输出：array(3) { [0]=> int(1) [1]=> int(2) ["c"]=> string(1) "c" }