array_chunk 函数：
// array_chunk — 将一个数组分割成多个
$input_array = array('a', 'b', 'c', 'd', 'e');
print_r(array_chunk($input_array, 2));
print_r(array_chunk($input_array, 2, true)); // 保留输入数组中原来的键名
array_column 函数：
// array_column — 返回数组中指定的一列
$records = array(
array(
'id' => 2135,
'first_name' => 'John',
'last_name' => 'Doe',
),
array(
'id' => 3245,
'first_name' => 'Sally',
'last_name' => 'Smith',
),
array(
'id' => 5342,
'first_name' => 'Jane',
'last_name' => 'Jones',
),
array(
'id' => 5623,
'first_name' => 'Peter',
'last_name' => 'Doe',
)
);
$first_names = array_column($records, 'first_name');
print_r($first_names);
array_count_values 函数：
// array_count_values — 统计数组中所有的值出现的次数
$array = array(1, "hello", 1, "world", "hello");
print_r(array_count_values($array));
array_diff_assoc 函数：
// array_diff_assoc — 带索引检查计算数组的差集
$array1 = array("a" => "green", "b" => "brown", "c" => "blue", "red");
$array2 = array("a" => "green", "yellow", "red");
$result = array_diff_assoc($array1, $array2); // array1不在array2中出现的元素值和key（key或值不相等即算）
print_r($result);
array_diff_key 函数：
// array_diff_key — 使用键名比较计算数组的差集
$array1 = array('blue' => 1, 'red' => 2, 'green' => 3, 'purple' => 4);
$array2 = array('green' => 5, 'blue' => 6, 'yellow' => 7, 'cyan' => 8);
var_dump(array_diff_key($array1, $array2)); // array1不在array2中出现的元素key（key不存在即算）
array_diff 函数：
// array_diff — 计算数组的差集
$array1 = array("a" => "green", "red", "blue", "red");
$array2 = array("b" => "green", "yellow", "red");
$result = array_diff($array1, $array2); // array1不在array2中出现的元素值（值不存在即算）
print_r($result);
array_fill_keys 函数：
// array_fill_keys — 使用指定的键和值填充数组
$keys = ['user_total','play_total'];
$a = array_fill_keys($keys, '0');
print_r($a);
array_fill 函数：
// array_fill — 用给定的值填充数组
$a = array_fill(0, 100, 0); // 相当于数组索引0~99的值初始化为0
print_r($a);
array_filter 函数：
// array_filter — 用回调函数过滤数组中的单元
function odd($var)
{
// 返回输入的整数是否为奇数
return($var & 1);
}
function even($var)
{
// 返回输入的整数是否为偶数
return(!($var & 1));
}
$array1 = array("a"=>1, "b"=>2, "c"=>3, "d"=>4, "e"=>5);
$array2 = array(6, 7, 8, 9, 10, 11, 12);
echo "奇数 :\n";
print_r(array_filter($array1, "odd"));
echo "偶数:\n";
print_r(array_filter($array2, "even"));
array_flip 函数：
// array_flip — 交换数组中的键和值
$input = array('oranges', 'apples', 'pears');
$flipped = array_flip($input);
print_r($flipped);
array_intersect_assoc 函数：
// array_intersect_assoc — 带索引检查计算数组的交集
$array1 = array("a" => "green", "b" => "brown", "c" => "blue", "red");
$array2 = array("a" => "green", "b" => "yellow", "blue", "red");
$result_array = array_intersect_assoc($array1, $array2); // array1同时存在array2中的元素key和值（key和值相等才算）
print_r($result_array);
array_intersect_key 函数：
// array_intersect_key — 使用键名比较计算数组的交集
$array1 = array('blue' => 1, 'red' => 2, 'green' => 3, 'purple' => 4);
$array2 = array('green' => 5, 'blue' => 6, 'yellow' => 7, 'cyan' => 8);
var_dump(array_intersect_key($array1, $array2)); // array1同时存在array2中的元素key（key存在即算）
array_intersect 函数：
// array_intersect — 计算数组的交集
$array1 = array("a" => "green", "red", "blue");
$array2 = array("b" => "green", "yellow", "red");
$result = array_intersect($array1, $array2); // array1同时存在array2中的元素（值存在即算）
print_r($result);
array_key_exists 函数：
// array_key_exists — 检查给定的键名或索引是否存在于数组中
$search_array = array('first' => 1, 'second' => 4);
if (array_key_exists('first', $search_array)) {
echo "存在元素key 'first'";
}
array_keys 函数：
// array_keys — 返回数组中部分的或所有的键名
$array = array(0 => 100, "color" => "red");
print_r(array_keys($array));
array_map 函数：
// array_map — 为数组的每个元素应用回调函数
$a = ['1', 2.01, 3, 4, 5];
$b = array_map('intval', $a);
array_merge 函数：
// array_merge — 合并一个或多个数组
$array1 = array("color" => "red", 2, 4);
$array2 = array("a", "b", "color" => "green", "shape" => "trapezoid", 4);
$result = array_merge($array1, $array2); // 如果key存在，则覆盖最新值
print_r($result);
array_multisort 函数：
// array_multisort — 对多个数组或多维数组进行排序
$ar = [
["10", 11, 100, 100, "a"],
[1, 2, "2", 3, 1]
];
array_multisort($ar[0], SORT_DESC, $ar[1]);
array_multisort($ar[0], SORT_ASC, SORT_STRING, $ar[1], SORT_NUMERIC, SORT_DESC);
var_dump($ar);
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)
$result = array_pad($input, 2, "noop");
array_pop 函数：
// array_pop — 将数组最后一个单元弹出（出栈）
$stack = array("orange", "banana", "apple", "raspberry");
$fruit = array_pop($stack);
print_r($stack);
array_product 函数：
// array_product — 计算数组中所有值的乘积
$a = array(2, 4, 6, 8);
echo "product(a) = " . array_product($a) . "\n";
echo "product(array()) = " . array_product(array()) . "\n";
array_push 函数：
// array_push — 将一个或多个单元压入数组的末尾（入栈）
$stack = array("orange", "banana");
array_push($stack, "apple", "raspberry");
print_r($stack);
array_rand 函数：
// array_rand — 从数组中随机取出一个或多个单元
$input = array("Neo", "Morpheus", "Trinity", "Cypher", "Tank");
$rand_keys = array_rand($input, 2);
echo $input[$rand_keys[0]] . "\n";
echo $input[$rand_keys[1]] . "\n";
array_reduce 函数：
// array_reduce — 用回调函数迭代地将数组简化为单一的值
function sum($carry, $item)
{
$carry += $item;
return $carry;
}
function product($carry, $item)
{
$carry *= $item;
return $carry;
}
$a = array(1, 2, 3, 4, 5);
$x = array();
var_dump(array_reduce($a, "sum")); // int(15)
var_dump(array_reduce($a, "product", 10)); // int(1200), because: 10*1*2*3*4*5
var_dump(array_reduce($x, "sum", "No data to reduce")); // string(17) "No data to reduce"
array_replace_recursive、array_replace 函数：
// array_replace_recursive — 使用传递的数组递归替换第一个数组的元素
// array_replace — 使用传递的数组替换第一个数组的元素
$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);
$basket = array_replace($base, $replacements);
print_r($basket);
array_reverse 函数：
// array_reverse — 返回一个单元顺序相反的数组
$input = array("php", 4.0, array("green", "red"));
$reversed = array_reverse($input);
print_r($reversed);
array_search 函数：
// array_search — 在数组中搜索给定的值，如果成功则返回相应的键名, 失败返回 === false
$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");
$fruit = array_shift($stack);
print_r($stack);
array_slice 函数：
// array_slice — 从数组中取出一段
$input = array("a", "b", "c", "d", "e");
$output = array_slice($input, 0, 3); // returns "a", "b", and "c"
array_sum 函数：
// array_sum — 计算数组中所有值的和
$a = array(2, 4, 6, 8);
echo "sum(a) = " . array_sum($a) . "\n";
array_unique 函数：
// array_unique — 移除数组中重复的值
$input = array("a" => "green", "red", "b" => "green", "blue", "red");
$result = array_unique($input);
print_r($result
array_unshift 函数：
// array_unshift — 在数组开头插入一个或多个单元
$queue = array("orange", "banana");
array_unshift($queue, "apple", "raspberry");
print_r($queue);
array_values 函数：
// array_values — 返回数组中所有的值
$array = array("size" => "XL", "color" => "gold");
print_r(array_values($array));
array_walk_recursive 函数：
// array_walk_recursive — 对数组中的每个成员递归地应用用户函数
$sweet = array('a' => 'apple', 'b' => 'banana');
$fruits = array('sweet' => $sweet, 'sour' => 'lemon');
function test_print($item, $key)
{
echo "$key holds $item\n";
}
array_walk_recursive($fruits, 'test_print');
arsort、asort 函数：
// arsort — 对数组进行 逆向 排序并保持索引关系（按值排序）
$fruits = array("d" => "lemon", "a" => "orange", "b" => "banana", "c" => "apple");
arsort($fruits);
foreach ($fruits as $key => $val) {
echo "$key = $val\n";
}
// asort — 对数组进行排序并保持索引关系（按值排序）
$fruits = array("d" => "lemon", "a" => "orange", "b" => "banana", "c" => "apple");
asort($fruits);
foreach ($fruits as $key => $val) {
echo "$key = $val\n";
}
count 函数：
// count — 计算数组中的单元数目或对象中的属性个数
$a[0] = 1;
$a[1] = 3;
$a[2] = 5;
var_dump(count($a));
current、next、prev、end、key、reset 函数：
// current — 返回数组中的当前单元
// next — 将数组中的内部指针向前移动一位
// prev — 将数组的内部指针倒回一位
// end — 将数组的内部指针指向最后一个单元
// key — 从关联数组中取得键名
// reset — 将数组的内部指针指向第一个单元
$transport = array('foot', 'bike', 'car', 'plane');
$mode = current($transport); // $mode = 'foot';
$mode = next($transport); // $mode = 'bike';
$mode = current($transport); // $mode = 'bike';
$mode = prev($transport); // $mode = 'foot';
$mode = end($transport); // $mode = 'plane';
$mode = key($transport); // $mode = 3;
$mode = current($transport); // $mode = 'plane';
extract 函数：
// extract — 从数组中将变量导入到当前的符号表
$var_array = [
"color" => "blue",
"shape" => "sphere"
];
extract($var_array);
echo "$color, $shape\n";
in_array 函数：
// in_array — 检查数组中是否存在某个值
$a = array('1.10', 12.4, 1.13);
if (in_array('12.4', $a)) {
echo "'12.4' 不进行类型验证\n";
}
if (in_array('1.13', $a, true)) {
echo "1.13 进行严格的类型验证\n";
}
krsort、ksort 函数：
// krsort — 对数组按照键名 逆向 排序
$fruits = array("d"=>"lemon", "a"=>"orange", "b"=>"banana", "c"=>"apple");
krsort($fruits);
foreach ($fruits as $key => $val) {
echo "$key = $val\n";
}
/*
d = lemon
c = apple
b = banana
a = orange
*/
// 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
*/
list 函数：
// list — 把数组中的值赋给一些变量
list($a, list($b, $c)) = array(1, array(2, 3));
var_dump($a, $b, $c);
natcasesort、natsort 函数：
// natcasesort — 用“自然排序”算法对数组进行不区分大小写字母的排序
$array1 = $array2 = [
'IMG0.png',
'img12.png',
'img10.png',
'img2.png',
'img1.png',
'IMG3.png'
];
sort($array1); // 标准的排序
print_r($array1);
natcasesort($array2);// 自然数的排序
print_r($array2);
// natsort — 用“自然排序”算法对数组排序
$array1 = $array2 = [
"img12.png",
"IMG10.png",
"IMG2.png",
"img1.png"
];
asort($array1);
print_r($array1);
natsort($array2);
print_r($array2);
range 函数：
// range — 建立一个包含指定范围单元的数组
var_dump(range(0, 10));
rsort 函数：
// rsort — 对数组逆向排序
$fruits = array("lemon", "orange", "banana", "apple");
rsort($fruits);
foreach ($fruits as $key => $val) {
echo "$key = $val\n";
}
shuffle 函数：
// shuffle — 将数组打乱
$numbers = range(1, 20);
shuffle($numbers);
foreach ($numbers as $number) {
echo "$number ";
}
sort 函数：
// sort — 对数组排序
$fruits = array("lemon", "orange", "banana", "apple");
sort($fruits);
foreach ($fruits as $key => $val) {
echo "fruits[" . $key . "] = " . $val . "\n";
}
537
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
