array array_change_key_case (array$input [,int$case ] )将input数组中的所有键名改为全小写或大写。改变是根据后一个选项case参数来进行的。可以在这里用两个常量，CASE_UPPER 和CASE_LOWER。默认值是CASE_LOWER。本函数不改变数字索引。 如果一个数组中的多个键名经过本函数后变成一样的话（例如 "keY" 和 "kEY"），最后一个值将覆盖其它的值。
$input_array = array("FirSt" => 1, "SecOnd" => 4);
print_r(array_change_key_case($input_array, CASE_UPPER));
输出
Array
(
[FIRST] => 1
[SECOND] => 4
)
$input ,
int $size [,
bool $preserve_keys ] )
将一个数组分割成多个数组，其中每个数组的单元数目由 size 决定。最后一个数组的单元数目可能会少几个。得到的数组是一个多维数组中的单元，其索引从零开始。
将可选参数 preserve_keys 设为 TRUE，可以使 PHP 保留输入数组中原来的键名。如果你指定了 FALSE，那每个结果数组将用从零开始的新数字索引。默认值是FALSE。
$input_array = array('a', 'b', 'c', 'd', 'e');
print_r(array_chunk($input_array, 2));
print_r(array_chunk($input_array, 2, true));
输出
Array
(
[0] => Array
(
[0] => a
[1] => b
)
[1] => Array
(
[0] => c
[1] => d
)
[2] => Array
(
[0] => e
)
)
Array
(
[0] => Array
(
[0] => a
[1] => b
)
[1] => Array
(
[2] => c
[3] => d
)
[2] => Array
(
[4] => e
)
)
array
array_combine (
array$keys ,
array$values )
返回一个 array，用来自keys 数组的值作为键名，来自values 数组的值作为相应的值。
如果两个数组的单元数不同或者数组为空时返回 FALSE。
$a = array('green', 'red', 'yellow');
$b = array('avocado', 'apple', 'banana');
$c = array_combine($a, $b);
print_r($c);
输出
Array
(
[green] => avocado
[red] => apple
[yellow] => banana
)
array array_count_values ( array $input )
array_count_values() 返回一个数组，该数组用input数组中的值作为键名，该值在input 数组中出现的次数作为值。
$array = array(1, "hello", 1, "world", "hello");
print_r(array_count_values ($array));输出
Array
(
[1] => 2
[hello] => 2
[world] => 1
)
array array_diff_assoc(array$array1 ,array$array2 [,array$ ... ] )比较key和value
返回一个数组，该数组包括了所有在 array1 中但是不在任何其它参数数组中的值。注意和array_diff() 不同的是键名也用于比较。
$array1 = array ("a" => "green", "b" => "brown", "c" => "blue", "red");
$array2 = array ("a" => "green", "yellow", "red");
$result = array_diff_assoc($array1, $array2);
输出
Array
(
[b] => brown
[c] => blue
[0] => red
)
上面的例子中可以看到键值对 "a" => "green"在两个数组中都有，因此不在本函数的输出中。与此不同，键值对0 => "red" 出现在输出中是因为第二个参数中的"red" 的键名是1。
键值对 key => value中的两个值仅在(string) $elem1 === (string) $elem2时被认为相等。也就是说使用了严格检查，字符串的表达必须相同。
Note: 注意本函数只检查了多维数组中的一维。当然可以用 array_diff_assoc($array1[0], $array2[0]);检查更深的维度。
array array_diff_key (array$array1 ,array$array2 [,array$ ... ] )比较key
返回一个数组，该数组包括了所有出现在 array1中但是未出现在任何其它参数数组中的键名的值。注意关联关系保留不变。本函数和array_diff() 相同只除了比较是根据键名而不是值来进行的。
$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));输出
array(2) {
["red"]=>
int(2)
["purple"]=>
int(4)
}
$array1 ,
array $array2 [,
array $... ],
callback $key_compare_func )
比较key和value用自定义函数在用户自定义函数中，仅对键进行比较。
array_diff_uassoc() 返回一个数组，该数组包括了所有在array1 中但是不在任何其它参数数组中的值。注意和array_diff() 不同的是键名也用于比较。
此比较是通过用户提供的回调函数来进行的。如果认为第一个参数小于，等于，或大于第二个参数时必须分别返回一个小于零，等于零，或大于零的整数。这和array_diff_assoc()不同的是还使用了比较索引的内部函数。
function key_compare_func($a, $b)
{
if ($a === $b) {
return 0;//返回0则会相同执行结果中显示
}
return ($a > $b)? 1:-1;//返回非0则为不相同，执行结果中不显示
}
$array1 = array("a" => "green", "b" => "brown", "c" => "blue", "red");
$array2 = array("a" => "green", "yellow", "red");
$result = array_diff_uassoc($array1, $array2, "key_compare_func");
print_r($result);
array array_diff_ukey( array
$array1 ,
array$array2 [,
array$ ... ],
callback$key_compare_func )
比较key用自定义函数在用户自定义函数中，仅对键进行比较。
返回一个数组，该数组包括了所有出现在 array1中但是未出现在任何其它参数数组中的键名的值。注意关联关系保留不变。本函数和array_diff() 相同只除了比较是根据键名而不是值来进行的。
此比较是通过用户提供的回调函数来进行的。如果认为第一个参数小于，等于，或大于第二个参数时必须分别返回一个小于零，等于零，或大于零的整数。
function key_compare_func($key1, $key2)
{
if ($key1 == $key2)
return 0;
else if ($key1 > $key2)
return 1;
else
return -1;
}
$array1 = array('blue' => 1, 'red' => 2, 'green' => 3, 'purple' => 4);
$array2 = array('green' => 5, 'blue' => 6, 'yellow' => 7, 'cyan' => 8);
var_dump(array_diff_ukey($array1, $array2, 'key_compare_func'));
结果
array(2) {
["red"]=>
int(2)
["purple"]=>
int(4)
}
array array_diff(array $array1 , array$array2 [,array$ ... ] )比较value
array_diff() 返回一个数组，该数组包括了所有在 array1 中但是不在任何其它参数数组中的值。注意键名保留不变。
$array1 = array("a" => "green", "red", "blue", "red");
$array2 = array("b" => "green", "yellow", "red");
$result = array_diff($array1, $array2);
print_r($result);结果
在 $array1 中多次出现的值一样处理，输出结果为：
Array
(
[1] => blue
)
array array_fill_keys(array $keys , mixed$value )
使用 value 参数的值作为值，使用keys 数组的值作为键来填充一个数组。
参数
-
使用该数组的值作为键。非法值将被转换为字符串。
-
填充使用的值。
keys
value
返回值
返回填充后的数组。
$keys = array('foo', 5, 10, 'bar');
$a = array_fill_keys($keys, 'banana');
print_r($a);
返回值
Array
(
[foo] => banana
[5] => banana
[10] => banana
[bar] => banana
)
array array_fill(int $start_index ,int$num ,mixed$value )
开始下标 数组大小 值
用 value参数的值将一个数组填充 num 个条目，键名由start_index 参数指定的开始。注意num 必须是一个大于零的数值，否则 PHP 会发出一条警告。
$a = array_fill(5, 6, 'banana');
print_r($a);
返回值
Array
(
[5] => banana
[6] => banana
[7] => banana
[8] => banana
[9] => banana
[10] => banana
)
array array_filter(array $input [, callback$callback ] ) callback函数为空则为过滤数组中的空value元素
依次将 input 数组中的每个值传递到 callback 函数。如果callback 函数返回TRUE，则input数组的当前值会被包含在返回的结果数组中。数组的键名保留不变。
用户不应在回调函数中修改数组本身。例如增加／删除单元或者对 array_filter() 正在作用的数组进行 unset。如果数组改变了，此函数的行为没有定义。
如果没有提供 callback函数，array_filter()将删除input 中所有等值为FALSE 的条目。
function odd($var)
{
return($var % 2 == 1);
}
function even($var)
{
return($var % 2 == 0);
}
$array1 = array("a"=>1, "b"=>2, "c"=>3, "d"=>4, "e"=>5);
$array2 = array(6, 7, 8, 9, 10, 11, 12);
echo "Odd :\n";
print_r(array_filter($array1, "odd"));
echo "Even:\n";
print_r(array_filter($array2, "even"));
结果
Odd :
Array
(
[a] => 1
[c] => 3
[e] => 5
)
Even:
Array
(
[0] => 6
[2] => 8
[4] => 10
[6] => 12
)
array array_flip(array $trans )
返回一个反转后的 array，例如trans 中的键名变成了值，而trans 中的值成了键名。
注意 trans 中的值需要能够作为合法的键名，例如需要是integer 或者string。如果值的类型不对将发出一个警告，并且有问题的键／值对将不会反转。
如果同一个值出现了多次，则最后一个键名将作为它的值，所有其它的都丢失了。
array_flip() 如果失败返回FALSE。
$trans = array_flip($trans);
$original = strtr($str, $trans);
$trans = array("a" => 1, "b" => 1, "c" => 2);
$trans = array_flip($trans);
print_r($trans);
返回值
Array
(
[1] => b
[2] => c
)
array array_intersect_assoc(array $array1 , array$array2 [,array$ ... ] ) 比较key和value都一致则返回（第一个数组中的值）
返回一个数组，该数组包含了所有在 array1 中也同时出现在所有其它参数数组中的值。注意和array_intersect() 不同的是键名也用于比较。
$array1 = array("a" => "green", "b" => "brown", "c" => "blue", "red");
$array2 = array("a" => "green", "yellow", "red");
$result_array = array_intersect_assoc($array1, $array2);
返回值
Array
(
[a] => green
)
array array_intersect_key( array $array1 , array$array2 [, array$ ... ] )比较key一致则返回（第一个数组中的值）
返回一个数组，该数组包含了所有出现在 array1 中并同时出现在所有其它参数数组中的键名的值。
$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));
array(2) {
["blue"]=>
int(1)
["green"]=>
int(3)
})
array array_intersect_uassoc( array $array1 , array$array2 [, array$ ... ], callback$key_compare_func ) 在用户自定义函数中，仅对键进行比较。
返回一个数组，该数组包含了所有在 array1 中也同时出现在所有其它参数数组中的值。注意和array_intersect() 不同的是键名也用于比较。
此比较是通过用户提供的回调函数来进行的。如果认为第一个参数小于，等于，或大于第二个参数时必须分别返回一个小于零，等于零，或大于零的整数。
array1
Initial array for comparison of the arrays.
array2
First array to compare keys against.
array
Variable list of array arguments to compare values against.
key_compare_func
在第一个参数小于,等于或大于第二个参数时,该比较函数必须返回一个小于,等于或大于0的整数
$array1 = array("a" => "green", "b" => "brown", "c" => "blue", "red");
$array2 = array("a" => "GREEN", "B" => "brown", "yellow", "red");
print_r(array_intersect_uassoc($array1, $array2, "strcasecmp"));
返回值
Array
(
[b] => brown
)
array array_intersect_ukey( array $array1 , array$array2 [, array$... ], callback$key_compare_func )在用户自定义函数中，仅对键进行比较。
返回一个数组，该数组包含了所有出现在 array1 中并同时出现在所有其它参数数组中的键名的值。
此比较是通过用户提供的回调函数来进行的。如果认为第一个参数小于，等于，或大于第二个参数时必须分别返回一个小于零，等于零，或大于零的整数。
function key_compare_func($key1, $key2)
{
if ($key1 == $key2)
return 0;
else if ($key1 > $key2)
return 1;
else
return -1;
}
$array1 = array('blue' => 1, 'red' => 2, 'green' => 3, 'purple' => 4);
$array2 = array('green' => 5, 'blue' => 6, 'yellow' => 7, 'cyan' => 8);
var_dump(array_intersect_ukey($array1, $array2, 'key_compare_func'));
输出
array(2) {
["blue"]=>
int(1)
["green"]=>
int(3)
})
array array_intersect( array $array1 , array$array2 [, array$ ... ] )
返回一个数组，该数组包含了所有在 array1 中也同时出现在所有其它参数数组中的值。注意键名保留不变。
$array1 = array("a" => "green", "red", "blue");
$array2 = array("b" => "green", "yellow", "red");
$result = array_intersect($array1, $array2);
返回
Array
(
[a] => green
[0] => red
)
bool array_key_exists( mixed$key , array$search )
在给定的 key存在于数组中时返回 TRUE。key可以是任何能作为数组索引的值。array_key_exists()也可用于对象。
$search_array = array('first' => 1, 'second' => 4);
if (array_key_exists('first', $search_array)) {
echo "The 'first' element is in the array";
}
$input [,
mixed$search_value [,
bool $strict ]] )
目标数组 要返回key的值 第二个参数的值是否用全等比较===（true/false）
返回 input数组中的数字或者字符串的键名。
如果指定了可选参数 search_value，则只返回该值的键名。否则input 数组中的所有键名都会被返回。自 PHP 5 起，可以用 strict 参数来进行全等比较（===）。
$array = array(0 => 100, "color" => "red");
print_r(array_keys($array));
$array = array("blue", "red", "green", "blue", "blue", 0, '0');
print_r(array_keys($array, "blue"));//0,3,4
print_r(array_keys($array, "0"));// 5
print_r(array_keys($array, "0", true)); // 5,6
$array = array("color" => array("blue", "red", "green"),
"size" => array("small", "medium", "large"));
print_r(array_keys($array));
477
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
