键值操作

　　数组的每个元素都是由键值对组成，通过元素的键名来访问对应的键值。关于键值操作有array_values()、array_keys()、in_array()、array_flip()和array_reverse()这5个常用函数

array_values

　　array_values() 返回 input 数组中所有的值并给其建立数字索引

array array_values ( array $input )

<?php$array = array("size" => "XL", "color" => "gold");//Array ( [0] => XL [1] => gold )print_r(array_values($array));?>

array_keys

　　array_keys() 返回 input 数组中的数字或者字符串的键名

array array_keys ( array $array [, mixed $search_value [, bool $strict = false ]] )

　　如果指定了可选参数 search_value，则只返回该值的键名。否则 input 数组中的所有键名都会被返回

　　如果指定了可选参数 strict，表示判断在搜索的时候是否该使用严格的比较（===）

<?php$array = array(0 => 100, "color" => "red");//Array ( [0] => 0 [1] => color ) print_r(array_keys($array));$array = array("blue", "red", "green", "blue", "blue");// Array ( [0] => 0 [1] => 3 [2] => 4 ) print_r(array_keys($array, "blue"));$array = array("color" => array("blue", "red", "green"),
               "size"  => array("small", "medium", "large"));Array ( [0] => color [1] => size )print_r(array_keys($array));?>

in_array

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

bool in_array ( mixed $needle , array $haystack [, bool $strict = FALSE ] )

　　如果第三个参数 strict 的值为 TRUE 则 in_array() 函数还会检查 needle 的类型是否和 haystack 中的相同

<?php$os = array("Mac", "NT", "Irix", "Linux");if (in_array("Irix", $os)) {    //Got Irix
    echo "Got Irix";
}if (in_array("mac", $os)) {    echo "Got mac";
}?>

array_flip

　　array_flip — 交换数组中的键和值，成功时返回交换后的数组，如果失败返回 NULL

array array_flip ( array $trans )

　　array_flip() 返回一个反转后的 array，例如 trans 中的键名变成了值，而 trans 中的值成了键名

　　如果同一个值出现了多次，则最后一个键名将作为它的值，所有其它的都丢失了

　　[注意]trans中的值需要能够作为合法的键名，例如需要是 integer 或者 string。如果值的类型不对将发出一个警告，并且有问题的键／值对将不会反转

<?php$trans = array("a" => 1, "b" => 1, "c" => 2);$trans = array_flip($trans);//Array ( [1] => b [2] => c )print_r($trans);?>

array_reverse

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

array array_reverse ( array $array [, bool $preserve_keys = false ] )

　　如果参数preserve_keys设置为 TRUE 会保留数字的键。非数字的键则不受这个设置的影响，总是会被保留

<?php$input  = array("php", 4.0, array("green", "red"));$result = array_reverse($input);/*array (size=3)
  0 => 
    array (size=2)
      0 => string ‘green‘ (length=5)
      1 => string ‘red‘ (length=3)
  1 => float 4
  2 => string ‘php‘ (length=3) */var_dump($result);$result_keyed = array_reverse($input, true);/*array (size=3)
  2 => 
    array (size=2)
      0 => string ‘green‘ (length=5)
      1 => string ‘red‘ (length=3)
  1 => float 4
  0 => string ‘php‘ (length=3) */var_dump($result_keyed);?>

记数

count

　　count — 计算数组中的单元数目或对象中的属性个数

int count ( mixed $var [, int $mode = COUNT_NORMAL ] )

　　如果可选的 mode 参数设为 COUNT_RECURSIVE（或 1），count() 将递归地对数组计数。对计算多维数组的所有单元尤其有用。mode 的默认值是 0。count() 识别不了无限递归

<?php$a[0] = 1;$a[1] = 3;$a[2] = 5;$result = count($a);// $result == 3$b[0]  = 7;$b[5]  = 9;$b[10] = 11;$result = count($b);// $result == 3$result = count(null);// $result == 0$result = count(false);// $result == 1?>

<?php$food = array(‘fruits‘ => array(‘orange‘, ‘banana‘, ‘apple‘),
              ‘veggie‘ => array(‘carrot‘, ‘collard‘, ‘pea‘));echo count($food, COUNT_RECURSIVE); // output 8echo count($food); // output 2?>

array_count_values

　　array_count_values — 统计数组中所有的值出现的次数

array array_count_values ( array $input )

<?php$array = array(1, "hello", 1, "world", "hello");//Array ( [1] => 2 [hello] => 2 [world] => 1 )print_r(array_count_values($array));?>

array_unique

　　array_unique — 移除数组中重复的值

array array_unique ( array $array [, int $sort_flags = SORT_STRING ] )

　　[注意]键名保留不变。array_unique() 先将值作为字符串排序，然后对每个值只保留第一个遇到的键名，接着忽略所有后面的键名。这并不意味着在未排序的 array 中同一个值的第一个出现的键名会被保留

<?php$input = array("a" => "green", "red", "b" => "green", "blue", "red");$result = array_unique($input);//Array ( [a] => green [0] => red [1] => blue )print_r($result);?>

array_sum

　　array_sum — 计算数组中所有值的和

　　array_sum() 将数组中的所有值的和以整数或浮点数的结果返回

<?php$a = array(2, 4, 6, 8);//sum(a) = 20echo "sum(a) = " . array_sum($a) . "\n";$b = array("a" => 1.2, "b" => 2.3, "c" => 3.4);//sum(b) = 6.9echo "sum(b) = " . array_sum($b) . "\n";?>

回调函数

array_filter

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

array array_filter ( array $array [, callable $callback [, int $flag = 0 ]] )

　　依次将 array 数组中的每个值传递到 callback 函数。如果 callback 函数返回 TRUE，则 input 数组的当前值会被包含在返回的结果数组中。数组的键名保留不变

　　[注意]如果没有提供 callback 函数， 将删除 input 中所有等值为 FALSE 的条目

<?php$entry = array(0 => ‘foo‘,1 => false,2 => -1,3 => null,4 => ‘‘);//Array ( [0] => foo [2] => -1 )print_r(array_filter($entry));?>

<?phpfunction 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);//Odd : Array ( [a] => 1 [c] => 3 [e] => 5 ) echo "Odd :\n";print_r(array_filter($array1, "odd"));//Even: Array ( [0] => 6 [2] => 8 [4] => 10 [6] => 12 )echo "Even:\n";print_r(array_filter($array2, "even"));?>

array_walk

　　array_walk — 使用用户自定义函数对数组中的每个元素做回调处理

bool array_walk ( array &$array , callable $callback [, mixed $userdata = NULL ] )

　　将用户自定义函数 funcname 应用到 array 数组中的每个单元。array_walk() 不会受到 array 内部数组指针的影响。array_walk() 会遍历整个数组而不管指针的位置

　　典型情况下 callback 接受两个参数。array 参数的值作为第一个，键名作为第二个

　　如果提供了可选参数 userdata，将被作为第三个参数传递给 callback funcname

<?php$fruits = array("d" => "lemon", "a" => "orange", "b" => "banana", "c" => "apple");function test_alter(&$item1, $key, $prefix)
{    $item1 = "$prefix: $item1";
}function test_print($item2, $key)
{    echo "$key. $item2\n";
}//Before ...: d. lemon a. orange b. banana c. appleecho "Before ...:\n";array_walk($fruits, ‘test_print‘);array_walk($fruits, ‘test_alter‘, ‘fruit‘);echo "... and after:\n";//... and after: d. fruit: lemon a. fruit: orange b. fruit: banana c. fruit: applearray_walk($fruits, ‘test_print‘);?>

array_map

　　array_map — 将回调函数作用到给定数组的单元上

array array_map ( callable $callback , array $arr1 [, array $... ] )

　　array_map() 返回一个数组，该数组包含了 arr1 中的所有单元经过 callback 作用过之后的单元。callback 接受的参数数目应该和传递给 array_map() 函数的数组数目一致

<?phpfunction cube($n)
{    return($n * $n * $n);
}$a = array(1, 2, 3, 4, 5);$b = array_map("cube", $a);//Array ( [0] => 1 [1] => 8 [2] => 27 [3] => 64 [4] => 125 )print_r($b);?>

组合

array_slice

　　array_slice — 从数组中取出一段

array array_slice ( array $array , int $offset [, int $length = NULL [, bool $preserve_keys = false ]] )

　　array_slice() 返回根据 offset 和 length 参数所指定的 array 数组中的一段序列

　　[注意]array_slice()默认会重新排序并重置数组的数字索引。可以通过将 preserve_keys 设为 TRUE 来改变此行为

<?php$input = array("a", "b", "c", "d", "e");// returns "c", "d", and "e"$output = array_slice($input, 2);  

// returns "d" $output = array_slice($input, -2, 1); 

// returns "a", "b", and "c"$output = array_slice($input, 0, 3); 

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

array_splice

　　array_splice — 把数组中的一部分去掉并用其它值取代，返回一个包含有被移除单元的数组，而原数组为变化后的数组

array array_splice ( array &$input , int $offset [, int $length = 0 [, mixed $replacement ]] )

　　把 input 数组中由 offset 和 length 指定的单元去掉，如果提供了 replacement 参数，则用其中的单元取代

　　[注意]input 中的数字键名不被保留

<?php$input = array("red", "green", "blue", "yellow");print_r(array_splice($input, 2));//Array ( [0] => blue [1] => yellow )print_r($input);//Array ( [0] => red [1] => green )$input = array("red", "green", "blue", "yellow");print_r(array_splice($input, -1, 1, array("black", "maroon")));// Array ( [0] => yellow )print_r($input);//Array ( [0] => red [1] => green [2] => blue [3] => black [4] => maroon )?>

array_combine

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

array array_combine ( array $keys , array $values )

　　[注意]如果作为keys的数组和作为values的数组的元素个数不一样，将会抛出一个警告错误

<?php$a = array(‘green‘, ‘red‘, ‘yellow‘);$b = array(‘avocado‘, ‘apple‘, ‘banana‘);$c = array_combine($a, $b);//Array ( [green] => avocado [red] => apple [yellow] => banana )print_r($c);?>

array_merge

　　array_merge — 合并一个或多个数组

array array_merge ( array $array1 [, array $... ] )

　　array_merge() 将一个或多个数组的单元合并起来，一个数组中的值附加在前一个数组的后面。返回作为结果的数组

　　如果输入的数组中有相同的字符串键名，则该键名后面的值将覆盖前一个值。然而，如果数组包含数字键名，后面的值将不会覆盖原来的值，而是附加到后面

　　如果只给了一个数组并且该数组是数字索引的，则键名会以连续方式重新索引

<?php$array1 = array("color" => "red", 2, 4);$array2 = array("a", "b", "color" => "green", "shape" => "trapezoid", 4);$result = array_merge($array1, $array2);//Array ( [color] => green [0] => 2 [1] => 4 [2] => a [3] => b [shape] => trapezoid [4] => 4 )print_r($result);?>

【+】

　　如果想完全保留原有数组并只想新的数组附加到后面，用 + 运算符

　　[注意]如果输入的数组中有相同的字符串键名，则该键名前面的值将覆盖后面的值

<?php$array1 = array(0 => ‘zero_a‘, 2 => ‘two_a‘, 3 => ‘three_a‘);$array2 = array(1 => ‘one_a‘, 2 => ‘three_a‘, 3 => ‘four_a‘);$result = $array1 + $array2;//Array ( [0] => zero_a [2] => two_a [3] => three_a [1] => one_a )print_r($result);?>

array_intersect

　　array_intersect — 计算数组的交集

array array_intersect ( array $array1 , array $array2 [, array $ ... ] )

　　array_intersect() 返回一个数组，该数组包含了所有在 array1 中也同时出现在所有其它参数数组中的值

　　[注意]键名保留不变

<?php$array1 = array("a" => "green", "red", "blue");$array2 = array("b" => "green", "yellow", "red");$result = array_intersect($array1, $array2);//Array ( [a] => green [0] => red )print_r($result);?>

array_diff

　　array_diff — 计算数组的差集

array array_diff ( array $array1 , array $array2 [, array $... ] )

　　对比返回在 array1 中但是不在 array2 及任何其它参数数组中的值

<?php$array1 = array("a" => "green", "red", "blue", "red");$array2 = array("b" => "green", "yellow", "red");$result = array_diff($array1, $array2);//Array ( [1] => blue )print_r($result);?>

array_fill

　　array_fill — 用给定的值填充数组，返回填充后的数组

array array_fill ( int $start_index , int $num , mixed $value )

　　array_fill() 用 value 参数的值将一个数组填充 num 个条目，键名由 start_index 参数指定的开始

?php$a = array_fill(5, 6, ‘banana‘);$b = array_fill(-2, 4, ‘pear‘);//Array ( [5] => banana [6] => banana [7] => banana [8] => banana [9] => banana [10] => banana )print_r($a);//Array ( [-2] => pear [0] => pear [1] => pear [2] => pear )print_r($b);?>

range

　　range — 建立一个包含指定范围单元的数组，返回的数组中从 start 到 limit 的单元，包括它们本身

array range ( mixed $start , mixed $limit [, number $step = 1 ] )

　　如果给出了 step 的值，它将被作为单元之间的步进值。step 应该为正值。如果未指定，step 则默认为 1

<?php// array(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)foreach (range(0, 12) as $number) {    echo $number;
}// array(0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100)foreach (range(0, 100, 10) as $number) {    echo $number;
}// array(‘a‘, ‘b‘, ‘c‘, ‘d‘, ‘e‘, ‘f‘, ‘g‘, ‘h‘, ‘i‘);foreach (range(‘a‘, ‘i‘) as $letter) {    echo $letter;
}// array(‘c‘, ‘b‘, ‘a‘);foreach (range(‘c‘, ‘a‘) as $letter) {    echo $letter;
}?>

栈和队列

array_pop

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

mixed array_pop ( array &$array )

　　array_pop() 弹出并返回 array 数组的最后一个单元，并将数组 array 的长度减一。如果 array 为空（或者不是数组）将返回 NULL

<?php$stack = array("orange", "banana", "apple", "raspberry");$fruit = array_pop($stack);//Array ( [0] => orange [1] => banana [2] => apple )print_r($stack);?>

array_push

　　array_push — 将一个或多个单元压入数组的末尾（入栈），返回处理之后数组的元素个数

int array_push ( array &$array , mixed $var [, mixed $... ] )

　　array_push() 将 array 当成一个栈，并将传入的变量压入 array 的末尾。array 的长度将根据入栈变量的数目增加

<?php$stack = array("orange", "banana");array_push($stack, "apple", "raspberry");//Array ( [0] => orange [1] => banana [2] => apple [3] => raspberry )print_r($stack);?>

array_shift

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

mixed array_shift ( array &$array )

　　array_shift() 将 array 的第一个单元移出并作为结果返回，将 array 的长度减一并将所有其它单元向前移动一位。所有的数字键名将改为从零开始计数，文字键名将不变

<?php$stack = array("orange", "banana", "apple", "raspberry");$fruit = array_shift($stack);//Array ( [0] => banana [1] => apple [2] => raspberry )print_r($stack);?>

array_unshift

　　array_unshift — 在数组开头插入一个或多个单元，返回 array 数组新的单元数目

int array_unshift ( array &$array , mixed $var [, mixed $... ] )

　　array_unshift() 将传入的单元插入到 array 数组的开头。注意单元是作为整体被插入的，因此传入单元将保持同样的顺序。所有的数值键名将修改为从零开始重新计数，所有的文字键名保持不变

<?php$queue = array("orange", "banana");array_unshift($queue, "apple", "raspberry");//Array ( [0] => apple [1] => raspberry [2] => orange [3] => banana )print_r($queue);?>

顺序

array_rand

　　array_rand — 从数组中随机取出一个或多个单元，并返回随机条目的一个或多个键

mixed array_rand ( array $input [, int $num_req = 1 ] )

　　[注意]如果只取出一个，array_rand() 返回一个随机单元的键名，否则就返回一个包含随机键名的数组

<?php$input = array("Neo", "Morpheus", "Trinity", "Cypher", "Tank");$rand_keys = array_rand($input, 2);//Neo echo $input[$rand_keys[0]] . "\n";//Cypherecho $input[$rand_keys[1]] . "\n";?>

shuffle

　　shuffle — 将数组打乱，成功时返回 TRUE， 或者在失败时返回 FALSE

bool shuffle ( array &$array )

<?php$numbers = range(1, 20);shuffle($numbers);//20 11 19 4 7 13 16 8 12 1 9 6 15 3 2 18 10 14 17 5foreach ($numbers as $number) {    echo "$number ";
}?>

PHP之数组函数