array

array_change_key_case — 将数组中的所有键名修改为全大写或小写

// 错误／异常 : 输入值（array）不是一个数组，就会抛出一个错误警告（E_WARNING）
$input_array = array("FirSt" => 1, "SecOnd" => 4);
// [1] array 需要操作的数组 [2] CASE_UPPER 或 CASE_LOWER（默认值）
print_r(array_change_key_case($input_array, CASE_UPPER));
// [ ['FIRST' => 1], ['SECOND' => 4] ]

array_chunk — 将一个数组分割成多个

// 错误／异常 : 如果 size 小于 1，会抛出一个 E_WARNING 错误并返回 NULL。
$input_array = array('a', 'b', 'c', 'd', 'e');
// [1] array 需要操作的数组 [2] size 每个数组的单元数目 [3] TRUE，保留输入数组中原来的键名 FALSE，每个结果数组将用从零开始的新数字索引。默认值是 FALSE。
print_r(array_chunk($input_array, 2));
// [ ['a', 'b'], ['c', 'd'], ['e'] ]
print_r(array_chunk($input_array, 2, true));
// [ [0 => 'a', 1 => 'b'], [2 => 'c', 3 => 'd'], [4 => 'e'] ]

array_column — 返回数组中指定的一列

$records = array(
    array('id' => 2135,'name' => 'John'),
    array('id' => 3245,'name' => 'Smith'),
    array('id' => 5342,'name' => 'Peter')
);
//从结果集中取出 name 列
$names = array_column($records, 'name');
print_r($names); // [ 'John', 'Smith', 'Peter' ]

//从结果集中总取出 name 列，用相应的 id 作为键值
$names = array_column($records, 'name', 'id');
print_r($names); // [ 2135 => 'John', 3245 => 'Smith', 5342 => 'Peter' ]

array_combine — 创建一个数组，用一个数组的值作为其键名，另一个数组的值作为其值

// 错误／异常 : 两个数组的元素个数不一样，将会抛出一个警告错误（E_WARNING）
// [1] 将被作为新数组的键 [2] 将被作为 Array 的值
$a = array('green', 'red', 'yellow');
$b = array('avocado', 'apple', 'banana');
$c = array_combine($a, $b);
print_r($c); // [ 'green' => 'avocado' ... ]

array_count_values — 统计数组中所有的值

// 错误／异常 : 对数组里面的每个不是 string 和 integer 类型的元素抛出一个警告错误（E_WARNING）
$array = array(1, "hello", 1, "world", "hello");
print_r(array_count_values($array));
// [ 1 => 2, 'hello' => 2, 'world' => 1 ]

array_diff_assoc — 带索引检查计算数组的差集

$array1 = array("a" => "green", "b" => "brown", "c" => "blue", "red"); // '0' => 'red'
$array2 = array("a" => "green", "yellow", "red"); // '1' => 'red'
// [1] 从这个数组进行比较 [2] 被比较的数组 [3] ...更多被比较的数组
$result = array_diff_assoc($array1, $array2);
print_r($result); // [ 'b' => 'brown', 'c' => 'blue', '0' => 'red' ]

$array1 = array(0, 1, 2);
$array2 = array("00", "01", "2");
$result = array_diff_assoc($array1, $array2);
print_r($result); // [ 0, 1 ]

array_diff_key — 使用键名比较计算数组的差集 (比较键名)

// 返回一个数组，该数组包括了所有出现在 array1 中但是未出现在任何其它参数数组中的键名的值
$array1 = array('blue'  => 1, 'red'  => 2, 'green'  => 3, 'purple' => 4);
$array2 = array('green' => 5, 'blue' => 6, 'yellow' => 7, 'cyan'   => 8);
// [1] 从这个数组进行比较 [2] 针对此数组进行比较 [3] ...更多比较数组
var_dump(array_diff_key($array1, $array2)); // [ 'red' => 2, 'purple' => 4 ]

array_diff — 计算数组的差集（比较键值）

// 返回一个数组，该数组包括了所有在 array1 中但是不在任何其它参数数组中的值。[[注意键名保留不变]]
$array1 = array("a" => "green", "red", "blue", "red");
$array2 = array("b" => "green", "yellow", "red");
// [1] 要被对比的数组 [2] 和这个数组进行比较 [3] ...更多比较数组
$result = array_diff($array1, $array2);
print_r($result); // [ '1' => 'blue' ]

array_fill_keys — 使用指定的键和值填充数组

$keys = array('foo', 5, 10, 'bar');
// [1] 使用该数组的值作为键。非法值将被转换为字符串 [2] 填充使用的值
$a = array_fill_keys($keys, 'banana');
print_r($a); // [ 'foo' => 'banana', '5' => 'banana', '10' => 'banana', 'bar' => 'banana' ]

array_fill — 用给定的值填充数组

// 错误／异常 : 如果 num 小于零，将会抛出 E_WARNING
// [1] 返回的数组的第一个索引值 [2] 插入元素的数量。 必须大于或等于 0 [3] 用来填充的值
$a = array_fill(5, 3, 'banana');
$b = array_fill(-2, 3, 'pear');
print_r($a); // [ '5' => 'banana', '6' => 'banana', '7' => 'banana' ]
print_r($b); // [ -2 => 'pear', 0 => 'pear', 1 => 'pear' ]

array_filter — 用回调函数过滤数组中的单元

// array_filter — 用回调函数过滤数组中的单元 [用户不应在回调函数中修改数组本身]
$max_comparator = function ($max) {
  return function ($v) use ($max) { return $v > $max; };
};
$input = array(1, 2, 3, 4, 5);
// [1] 要循环的数组 [2] 使用的回调函数
$output = array_filter($input, $max_comparator(2)); // 返回大于 2 的
print_r($output);

$arr = ['a' => 1, 'b' => 2, 'c' => 3, 'd' => 4];
var_dump(array_filter($arr, function($k) {
    return $k == 'b';
}, ARRAY_FILTER_USE_KEY)); // ARRAY_FILTER_USE_KEY - callback 接受键名作为的唯一参数

var_dump(array_filter($arr, function($v, $k) {
    return $k == 'b' || $v == 4;
}, ARRAY_FILTER_USE_BOTH)); // ARRAY_FILTER_USE_BOTH - callback 同时接受键名和键值

array_flip — 交换数组中的键和值

// array_flip — 交换数组中的键和值
$array = array('green','blue','orange','blue');
$array = array_flip($array); // [ 'green' => 0, 'blue' => '3', 'orange' => 2 ]
$array = array_flip($array); // [ 0 => 'green', 3 => 'blue', 2 => 'orange']

/* 使用 array_values() 函数修复键值*/
$array = array_values($array);
print_r($array); // [ 0 => 'green', 1 => 'blue', 2 => 'orange']

$array = array('green','blue','orange','blue');
$array = array_flip($array);
/* 跟第一个例子一样，但是现在我们先提取数组的键值 */
$array = array_keys($array); // array_keys — 返回数组中部分的或所有的键名
print_r($array);

array_key_exists — 检查数组里是否有指定的键名或索引

// array_key_exists — 检查数组里是否有指定的键名或索引
$search_array = array('first' => null, 'second' => 4);
isset($search_array['first']); // returns false
array_key_exists('first', $search_array); // returns true

function array_check(...) {
    return (isset(..) || array_key_exists(...))
}

array_keys — 返回数组中部分的或所有的键名

// array_keys — 返回数组中部分的或所有的键名
// [1] 数组 [2] 只有包含这些值的键才会返回 [3] 默认 false，true 严格的比较（===）
$array = array(0 => 100, "color" => "red");
print_r(array_keys($array)); // [ 0, 'color' ]

$array = array("blue", "red", "green", "blue", "blue");
print_r(array_keys($array, "blue")); // [ 0, 3, 4 ]

array_map — 为数组的每个元素应用回调函数,返回数组

// array_map — 为数组的每个元素应用回调函数,返回数组
function arraysSum(array ...$arrays) {
    // [1] 回调函数 [2] 数组 [3]...数组列表
    return array_map(function(array $array) {
        return array_sum($array);
    }, $arrays);
}
print_r(arraysSum([1, 2, 3], [4, 5, 6], [7, 8, 9])); // [6, 15, 24]

$a = array(1, 2, 3);
$b = array("uno", "dos", "tres");
function show_Spanish($n, $m) {
    return("$n is $m");
}
$c = array_map("show_Spanish", $a, $b);
print_r($c); // [ '1 is uno', '2 is dos', '3 is tres' ]

array_merge_recursive — 递归地合并一个或多个数组

// array_merge_recursive — 递归地合并一个或多个数组
$ar1 = array("color" => array("favorite" => "red"), 5);
$ar2 = array(10, "color" => array("favorite" => "green", "blue"));
// [1] 要合并的初始数组 [2] 数组变量列表，进行递归合并
$result = array_merge_recursive($ar1, $ar2);
print_r($result);
// [ 'color' => [ 'favorte' => [ 'red', 'green' ], 'blue' ], 5, 10 ]

array_merge — 合并一个或多个数组

// array_merge — 合并一个或多个数组
$array1 = array("color" => "red", 2);
$array2 = array("a", "color" => "green", "shape" => "trape", 4);
// [1] 要合并的第一个数组 [2] 要合并的数组列表
$result = array_merge($array1, $array2);
print_r($result); // [ 'color' => 'green', 2, 'a', 'shape' => 'trape', 4 ]

// 如果你想完全保留原有数组并只想新的数组附加到后面，用 + 运算符：
$array1 = array(0 => 'zero_a', 2 => 'two_a', 3 => 'three_a');
$array2 = array(1 => 'one_b', 3 => 'three_b', 4 => 'four_b');
$result = $array1 + $array2;
var_dump($result);
// 第一个数组的键名将会被保留。在两个数组中存在相同的键名时，
// 第一个数组中的同键名的元素将会被保留，第二个数组中的元素将会被忽略
// [ 'zero_a', 'two_a', 'three_a', 'one_b', 'four_b' ]

array_multisort — 对多个数组或多维数组进行排序

// array_multisort — 对多个数组或多维数组进行排序
$ar1 = array(10, 100, 100, 0);
$ar2 = array(1, 3, 2, 4);
// [1] 要排序的 array
// [2] (默认)SORT_ASC 按照上升顺序排序， SORT_DESC 按照下降顺序排序
// [3] 排序类型标志：
//     1. SORT_REGULAR - 将项目按照通常方法比较（不修改类型）默认
//     2. SORT_NUMERIC - 按照数字大小比较
//     3. SORT_STRING - 按照字符串比较
//     4. SORT_LOCALE_STRING - 根据当前的本地化设置，按照字符串比较
//     5. SORT_NATURAL - 以字符串的"自然排序"，类似 natsort()
//     6. SORT_FLAG_CASE - 可以组合 (按位或 OR) SORT_STRING 或者 SORT_NATURAL 大小写不敏感的方式排序字符串
array_multisort($ar1, $ar2);
var_dump($ar1); // [ 0, 10, 100, 100 ]
// 第二个数组对应第一个数组后进行了排序
var_dump($ar2); // [ 4, 1, 2, 3 ]

$arr = array (array(1, 2, 3, 4), array("a", "b", "b", "d"));
array_multisort($arr[0], SORT_DESC, $arr[1], SORT_ASC);
print_r($arr); // [ [ 4, 3, 2, 1 ], [ 'd', 'b', 'b', 'a' ] ]

$arr = array("d" => 100, "c" => 22, "f" => 22, "e" => 22);
array_multisort($arr, array_keys($arr));
//先按值排序，如果值相同的，按其键排序。
var_dump($arr); // [ 'c' => 22, 'e' => 22, 'f' => 22, 'd' => 100 ]

array_pad — 以指定长度将一个值填充进数组

// array_pad — 以指定长度将一个值填充进数组
$input = array(12, 10, 9);
$result = array_pad($input, 5, 0);
// result is array(12, 10, 9, 0, 0)
$result = array_pad($input, -7, -1);
// result is array(-1, -1, -1, -1, 12, 10, 9)

array_pop — 弹出数组最后一个单元（出栈）

// array_pop — 弹出数组最后一个单元（出栈）
$stack = array("orange", "banana", "apple", "raspberry");
// 返回 array 的最后一个值。如果 array 是空（如果不是一个数组），将会返回 NULL
$fruit = array_pop($stack);
print_r($stack); // [ 'orange', 'banana', 'apple' ]

array_push — 将一个或多个单元压入数组的末尾（入栈）

// array_push — 将一个或多个单元压入数组的末尾（入栈）
$stack = array("orange", "banana");
// [1] 输入的数组 [2] 要压入 array 末尾的第一个值
array_push($stack, "apple", "raspberry");
print_r($stack); // [ 'orange', 'banana', 'apple', 'respberry' ]

array_product — 计算数组中所有值的乘积

// array_product — 计算数组中所有值的乘积
$a = array(2, 4, 6, 8);
echo array_product($a); // 384
echo array_product(array()); // 1

array_rand — 从数组中随机取出一个或多个单元

// array_rand — 从数组中随机取出一个或多个单元
$input = array("Neo", "Morpheus", "Trinity", "Cypher", "Tank");
// [1] 输入的数组 [2] 指明了你想取出多少个单元
// 取出数量如果超过 array 的长度，就会导致 E_WARNING 错误，并返回 NULL
$rand_keys = array_rand($input, 2);
echo $input[$rand_keys[0]];
echo $input[$rand_keys[1]];

array_reduce — 用回调函数迭代地将数组简化为单一的值

// array_reduce — 用回调函数迭代地将数组简化为单一的值
/**
因为第一个参数是保存的结果，第二个参数才是每次取的数组中的一个元素。
第一次返回0+0+1+1=2,第二次是2+2+2+1=7，所以最终返回结果是7.
*/
echo array_reduce(array(1,2),'f'); // 7
function f($x, $y) {
  // var_dump($x, $y);
  return $x + $x + $y + 1;
}
// 结果是 51，array_reduce 第三个参数作为数组第一个值，所以这里就是 23+23+4+1=51.
var_dump(array_reduce(array(4), 'f', 23)); // 51

array_replace_recursive — 使用传递的数组递归替换第一个数组的元素

// array_replace_recursive — 使用传递的数组递归替换第一个数组的元素
$base = array('citrus' => array( "orange") , 'berries' => array("blackberry", "raspberry"));
$replacements = array('citrus' => array('pineapple'), 'berries' => array('blueberry'));
$basket = array_replace_recursive($base, $replacements);
print_r($basket);
// [ 'citrus' => [ 'pineapple' ], 'berries' => [ 'blueberry', 'raspberry' ] ]

array_replace — 使用传递的数组替换第一个数组的元素

// array_replace — 使用传递的数组替换第一个数组的元素
$base = array("orange", "banana", "apple", "raspberry");
$replacements = array(0 => "pineapple", 4 => "cherry");
$replacements2 = array(0 => "grape");
$basket = array_replace($base, $replacements, $replacements2);
print_r($basket);
// [ 'grape', 'banana', 'apple', 'raspberry', 'cherry' ]

array_reverse — 返回单元顺序相反的数组

// array_reverse — 返回单元顺序相反的数组
$input  = array("php", 4.0, array("green", "red"));
// [1] 输入的数组 [2] TRUE 会保留数字的键。 非数字的键则不受这个设置的影响，总是会被保留。
$reversed = array_reverse($input);
$preserved = array_reverse($input, true);
print_r($reversed); // [ [ 'green', 'red' ], 4, 'php' ]
print_r($preserved); // [ 2 => [ 'green', 'red' ], 1 => 4, 0 => 'php' ]

array_search — 在数组中搜索给定的值，如果成功则返回首个相应的键名

// array_search — 在数组中搜索给定的值，如果成功则返回首个相应的键名
$array = array(0 => 'blue', 1 => 'red', 2 => 'green', 3 => 'red');
$key = array_search('green', $array); // $key = 2;
$key = array_search('red', $array);   // $key = 1;

array_shift — 将数组开头的单元移出数组

// array_shift — 将数组开头的单元移出数组
$stack = array("orange", "banana", "apple", "raspberry");
// 返回移出的值，如果 array 为 空或不是一个数组则返回 NULL
$fruit = array_shift($stack);
print_r($stack); // [ 'banana', 'apple', 'raspberry' ]

array_slice — 从数组中取出一段

// array_slice — 从数组中取出一段
$input = array("a", "b", "c", "d", "e");
// [1] 输入的数组
// [2] 如果非负，则序列将从 array 中的此偏移量开始。如果为负，则序列将从 array 中距离末端这么远的地方开始。
// [3] 为正，则序列中将具有这么多的单元。为负，则序列将终止在距离数组末端这么远的地方
// [4] 默认会重新排序并重置数组的数字索引。设为 TRUE 来改变此行为。
$output = array_slice($input, 2);      // [ 'c', 'd', 'e' ]
$output = array_slice($input, -2, 1);  // [ 'd' ]
$output = array_slice($input, 0, 3);   // [ 'a', 'b', 'c' ]

print_r(array_slice($input, 2, -1)); // [ 0 => 'c', 1 => 'd' ]
print_r(array_slice($input, 2, -1, true)); // [ 2 => 'c', 3 => 'd' ]

array_splice — 去掉数组中的某一部分并用其它值取代

// array_splice — 去掉数组中的某一部分并用其它值取代
$input = array("red", "green", "blue", "yellow");
// [1] 输入的数组
// [2] 如果为正，则从 input 数组中该值指定的偏移量开始移除。如果为负，则从 input 末尾倒数该值指定的偏移量开始移除。
// [3] 没有值，移除至结尾。整数，移除这么多单元。负数，从结尾开始移除几个。0，不移除
// [4] 有值，插入到第二个参数的指定位置。注意替换数组中的键名不保留。
array_splice($input, 2);
// $input is now array("red", "green")

$input = array("red", "green", "blue", "yellow");
array_splice($input, 1, -1);
// $input is now array("red", "yellow")

$input = array("red", "green", "blue", "yellow");
array_splice($input, 1, count($input), "orange");
// $input is now array("red", "orange")

$input = array("red", "green", "blue", "yellow");
array_splice($input, -1, 1, array("black", "maroon"));
// $input is now array("red", "green",
//          "blue", "black", "maroon")

$input = array("red", "green", "blue", "yellow");
array_splice($input, 3, 0, "purple");
// $input is now array("red", "green",
//          "blue", "purple", "yellow");

array_sum — 对数组中所有值求和

// array_sum — 对数组中所有值求和
// array 为空时则返回 0
$a = array(2, 4, 6, 8);
echo array_sum($a); // 20

$b = array("a" => 1.2, "b" => 2.3, "c" => 3.4);
echo array_sum($b); // 6.9

array_udiff — 用回调函数比较数据来计算数组的差集

// array_udiff — 用回调函数比较数据来计算数组的差集
$array1 = array(
    array('n3'=>'v3', 'n4'=>'v4'),
    array('n1'=>'v1', 'n2'=>'v2')
);

$array2 = array(
    array('n1'=>'v1', 'n2'=>'v2')
);

$result = array_udiff(
    $array1,
    $array2,
    function ($v1, $v2) {
    // 在第一个参数小于，等于或大于第二个参数时，该比较函数必须相应地返回一个小于，等于或大于 0 的整数。
        print_r($v1);
        print_r($v2);
        // 如果 str1 小于 str2 返回 < 0； 如果 str1 大于 str2 返回 > 0；如果两者相等，返回 0。
        return strcmp(serialize($v1), serialize($v2));
    }
);
print_r($result); // array( array('n3'=>'v3', 'n4'=>'v4') )

$result = array_filter($array1, function($v) use ($array2) {
    return in_array($v, $array2);
});
print_r($result); // array( array('n1'=>'v1', 'n2'=>'v2') )


$arr1 = array('cat', 'mouse', 'horse');
$arr2 = array('cat', 'mouse');
print_r(array_udiff($arr1, $arr2, function($a, $b){
        print_r($a);echo  '<br/>';
        print_r($b);echo  '<br/>';
        return strcmp(serialize($a), serialize($b));
})); // [ 2 => 'horse' ]

array_unique — 移除数组中重复的值

$input = array("a" => "green", "red", "b" => "green", "blue", "red");
// [1] 输入的数组
// [2] 排序类型标记：
//     1. SORT_REGULAR - 按照通常方法比较（不修改类型）
//     2. SORT_NUMERIC - 按照数字形式比较
//     3. SORT_STRING - 按照字符串形式比较
//     4. SORT_LOCALE_STRING - 根据当前的本地化设置，按照字符串比较。
$result = array_unique($input);
print_r($result);
// [ 'a' => 'green', 0 => 'red', 1 => 'blue' ]

array_uintersect — 计算数组的交集，用回调函数比较数据

// array_uintersect — 计算数组的交集，用回调函数比较数据
$array1 = array("a" => "green", "b" => "brown", "c" => "blue", "red");
$array2 = array("a" => "GREEN", "B" => "brown", "yellow", "red");
// strcasecmp — 二进制安全比较字符串（不区分大小写）
print_r(array_uintersect($array1, $array2, "strcasecmp"));
// [ 'a' => 'green', 'b' => 'brown', 0 => 'red' ]

array_unshift — 在数组开头插入一个或多个单元

// array_unshift — 在数组开头插入一个或多个单元
$queue = array("orange", "banana");
array_unshift($queue, "apple");
print_r($queue); // [ 'apple', 'orange', 'banana' ]

array_values — 返回数组中所有的值

// array_values — 返回数组中所有的值
$array = array("size" => "XL", "color" => "gold");
print_r(array_values($array)); // [ 0 => 'XL', 1 => 'gold' ]

array_walk — 使用用户自定义函数对数组中的每个元素做回调处理,成功时返回 TRUE

// array_walk — 使用用户自定义函数对数组中的每个元素做回调处理,成功时返回 TRUE
function trim_value(&$value, $k, $tmp) {
    var_dump($value, $k, $tmp);
    $value = trim($value);
}

$fruit = array('a' => 'apple','b' => 'banana', 'c' => 'cranberry ');
$a = array_walk($fruit, 'trim_value', [1, 2, 3]); // TRUE
var_dump($a, $fruit);
// [ 'a' => 'apple', 'b' => 'banana', 'c' => 'cranberry' ]

asort — 对数组进行排序并保持索引关系

// asort — 对数组进行排序并保持索引关系
$fruits = array("d" => "lemon", "a" => "orange", "b" => "banana", "c" => "apple");
asort($fruits);
foreach ($fruits as $key => $val) {
    echo "$key = $val\n";
}
// c = apple
// b = banana
// d = lemon
// a = orange

sort — 对数组排序

// sort — 对数组排序
$fruits = array(
    "Orange1", "orange2", "Orange3", "orange20"
);
// [1] 要排序的数组
// [2] 排序类型标记：
//     1. SORT_REGULAR - 正常比较单元（不改变类型）
//     2. SORT_NUMERIC - 单元被作为数字来比较
//     3. SORT_STRING - 单元被作为字符串来比较
//     4. SORT_LOCALE_STRING - 根据当前的区域（locale）设置来把单元当作字符串比较
//     5. SORT_NATURAL - 和 natsort() 类似对每个单元以“自然的顺序”对字符串进行排序
//     6. SORT_FLAG_CASE - 能够与 SORT_STRING 或 SORT_NATURAL 合并（OR 位运算），不区分大小写排序字符串
sort($fruits, SORT_NATURAL | SORT_FLAG_CASE);
foreach ($fruits as $key => $val) {
    echo "fruits[" . $key . "] = " . $val . "\n";
}
// fruits[0] = Orange1
// fruits[1] = orange2
// fruits[2] = Orange3
// fruits[3] = orange20

in_array — 检查数组中是否存在某个值

// in_array — 检查数组中是否存在某个值
$os = array("Mac", "NT", "Irix", "Linux");
if (in_array("Irix", $os)) {
    echo "Got Irix";
} // Got Irix
if (in_array("mac", $os)) {
    echo "Got mac";
} // in_array() 是区分大小写的

$a = array('1.10', 12.4, 1.13);

if (in_array('12.4', $a, true)) {
    echo "'12.4' found with strict check\n";
} // 严格类型检查例子

if (in_array(1.13, $a, true)) {
    echo "1.13 found with strict check\n";
} // 1.13 found with strict check

ksort — 对数组按照键名排序

$fruits = array("d"=>"lemon", "a"=>"orange", "b"=>"banana", "c"=>"apple");
ksort($fruits);
foreach ($fruits as $key => $val) {
    echo "$key = $val\n";
}
// a = orange
// b = banana
// c = apple
// d = lemon

shuffle — 打乱数组

// shuffle — 打乱数组
$numbers = range(1, 20);
// 此函数为 array 中的元素赋与新的键名。这将删除原有的键名，而不是仅仅将键名重新排序。
shuffle($numbers);
foreach ($numbers as $number) {
    echo "$number ";
}