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" }