1. 技术文章
  2. PHP 数组用法

PHP 数组用法

由 ☆樱花仙子☆ 提交于 2019-12-09 15:41:01

array() 函数用于创建数组。在 PHP 中，有三种类型的数组：

索引数组 - 带有数字索引的数组

关联数组 - 带有指定的键的数组

多维数组 - 包含一个或多个数组的数组

list(var1,var2...)      

var1 必需。第一个需要赋值的变量。var2... 可选。更多需要赋值的变量。

在一次操作中给一组变量赋值。该函数只用于数字索引的数组，且假定数字索引从 0 开始。      

$my_array = array("Dog","Cat","Horse");
list($a, , $c) = $my_array;
echo "我在这里只用了 $a 和 $c 变量。";
//我在这里只用了 Dog 和 Horse 变量。

shuffle(array)        

array 必需。规定要使用的数组。

把数组中的元素按随机顺序重新排列。该函数为数组中的元素分配新的键名。已有键名将被删除 。

$my_array = array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow","e"=>"purple");
shuffle($my_array);
print_r($my_array);
//Array ( [0] => green [1] => purple [2] => yellow [3] => red [4] => blue )

array_rand(array,number)     

array 必需。规定数组。 number 可选。规定返回多少随机键名。

返回数组中的随机键名，或者如果您规定函数返回不只一个键名，则返回包含随机键名的数组。

array_rand() 函数从数组中随机选出一个或多个元素，并返回。

第二个参数用来确定要选出几个元素。如果选出的元素不止一个，则返回包含随机键名的数组，否则返回该元素的键名。

注释：自 PHP 4.2.0 起，不再需要用 srand() 或 mt_srand() 函数给随机数发生器播种，现已被自动完成。

$a=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
print_r(array_rand($a,1));
//d

$a=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
print_r(array_rand($a,2));
//Array ( [0] => a [1] => d )

range(low,high,step)        

low 必需。规定数组的最低值 high 必需。规定数组的最高值。step 可选。规定元素之间的步进制。默认是 1。

创建一个包含指定范围的元素的数组。该函数返回一个包含从low到high之间的元素的数组。注释：如果low参数大于 high 参数，则创建的数组将是从 high 到 low。

$letter = range("a","d");
print_r ($letter);
//Array ( [0] => a [1] => b [2] => c [3] => d )

$number = range(0,50,10);
print_r ($number);
//Array ( [0] => 0 [1] => 10 [2] => 20 [3] => 30 [4] => 40 [5] => 50 )

 array_keys(array,value,strict)

array 必需。规定数组。value 可选。您可以指定键值，然后只有该键值对应的键名会被返回。

strict 可选。与 value 参数一起使用。可能的值：true - 返回带有指定键值的键名。依赖类型，数字 5 与字符串 "5" 是不同的。false - 默认值。不依赖类型，数字 5 与字符串 "5" 是相同的。

返回包含数组中所有键名的一个新数组。如果提供了第二个参数，则只返回键值为该值的键名。如果 strict参数指定为 true，则 PHP 会使用全等比较 (===) 来严格检查键值的数据类型。

$a=array("Volvo"=>"XC90","BMW"=>"X5","Toyota"=>"Highlander");
print_r(array_keys($a));
//Array ( [0] => Volvo [1] => BMW [2] => Toyota )

$a=array(10,20,30,"10");
print_r(array_keys($a,"10",true));
//Array ( [0] => 3 )

$a=array(10,20,30,"10");
print_r(array_keys($a,"10",false));
//Array ( [0] => 0 [1] => 3 )

array_values(array)    

array 必需。规定数组。

返回一个包含给定数组中所有键值的数组，但不保留键名。被返回的数组将使用数值键，从 0 开始并以 1 递增。

$a=array("Name"=>"Bill","Age"=>"60","Country"=>"USA");
print_r(array_values($a));
//Array ( [0] => Bill [1] => 60 [2] => USA )

array_key_exists(key,array)

key 必需。规定键名。    array 必需。规定数组。

检查某个数组中是否存在指定的键名，如果键名存在则返回 true，如果键名不存在则返回 false。

请记住，如果您指定数组的时候省略了键名，将会生成从 0 开始并且每个键值对应以 1 递增的整数键名。

$a=array("Volvo"=>"XC90","BMW"=>"X5");
if (key_exists("Toyota",$a))
  {
  echo "键存在！";
  }
else
  {
  echo "键不存在！";
  }
//键不存在！

$a=array("Volvo","BMW");
if (array_key_exists(0,$a))
  {
  echo "键存在！";
  }
else
  {
  echo "键不存在！";
  }
//键存在！

array_fill(index,number,value)  

index 必需。被返回数组的第一个索引。 number 必需。规定要插入的元素数。 value 必需。规定供填充数组所使用的值。

用键值填充数组。array_fill() 函数用给定的值填充数组，返回的数组有 number  个元素，值为 value。返回的数组使用数字索引，从 start 位置开始并递增。如果 number 为 0 或小于 0，就会出错。

$a1=array_fill(3,4,"blue");
print_r($a1);
//Array ( [3] => blue [4] => blue [5] => blue [6] => blue )

array_fill_keys(keys,value)  

keys 必需。使用该数组的值作为键。非法值将被转换为字符串。value 必需。填充数组所使用的值。

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

$keys=array("a","b","c","d");
$a1=array_fill_keys($keys,"blue");
print_r($a1);
//Array ( [a] => blue [b] => blue [c] => blue [d] => blue )

array_filter(array,callbackfunction)  

array 必需。规定要过滤的数组。callbackfunction 必需。规定要使用的回调函数。

用回调函数过滤数组中的值。该函数把输入数组中的每个键值传给回调函数。如果回调函数返回 true，则把输入数组中的当前键值返回结果数组中。数组键名保持不变。

function test_odd($var)
{
return($var & 1);
}

$a1=array("a","b",2,3,4);
print_r(array_filter($a1,"test_odd"));
//Array ( [3] => 3 )

array_flip(array)    

array 必需。规定需进行键/值对反转的数组。

反转/交换数组中所有的键名以及它们关联的键值。返回一个反转后的数组，如果同一值出现了多次，则最后一个键名将作为它的值，所有其他的键名都将丢失。如果原数组中的值的数据类型不是字符串或整数，函数将报错。

$a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
$result=array_flip($a1);
print_r($result);
//Array ( [red] => a [green] => b [blue] => c [yellow] => d )

array_change_key_case(array,case)

array 必需。规定要使用的数组。case 可选。可能的值:CASE_LOWER - 默认值。将数组的键转换为小写字母。CASE_UPPER - 将数组的键转换为大写字母。

将数组的所有的键都转换为大写字母或小写字母。数组的数字索引不发生变化。如果未提供可选参数（即第二个参数），则默认转换为小写字母。如果在运行该函数时两个或多个键相同，则最后的元素会覆盖其他元素。

$age=array("Bill"=>"60","Steve"=>"56","Mark"=>"31");
print_r(array_change_key_case($age,CASE_UPPER));
//Array ( [BILL] => 60 [STEVE] => 56 [MARK] => 31 )

$pets=array("a"=>"Cat","B"=>"Dog","c"=>"Horse","b"=>"Bird");
print_r(array_change_key_case($pets,CASE_UPPER));
//Array ( [A] => Cat [B] => Bird [C] => Horse )

array_chunk(array,size,preserve_key)

array 必需。规定要使用的数组。    size 必需。整数值，规定每个新数组包含多少个元素。

preserve_key 可选。可能的值：true - 保留原始数组中的键名。false - 默认。每个结果数组使用从零开始的新数组索引。

把数组分割为新的数组块。其中每个数组的单元数目由 size 参数决定。最后一个数组的单元数目可能会少几个。可选参数 preserve_key是一个布尔值，它指定新数组的元素是否有和原数组相同的键（用于关联数组），还是从 0 开始的新数字键（用于索引数组）。默认是分配新的键。

$cars=array("Volvo","BMW","Toyota","Honda","Mercedes","Opel");
print_r(array_chunk($cars,2));
//Array ( [0] => Array ( [0] => Volvo [1] => BMW ) [1] => Array ( [0] => Toyota [1] => Honda ) [2] => Array ( [0] => Mercedes [1] => Opel ) )

$age=array("Bill"=>"60","Steve"=>"56","Mark"=>"31","David"=>"35");
print_r(array_chunk($age,2,true));
//Array ( [0] => Array ( [Bill] => 60 [Steve] => 56 ) [1] => Array ( [Mark] => 31 [David] => 35 ) )

array_column(array,column_key,index_key)

array 必需。规定要使用的多维数组（记录集）。

column_key 必需。需要返回值的列。可以是索引数组的列的整数索引，或者是关联数组的列的字符串键值。该参数也可以是 NULL，此时将返回整个数组（配合 index_key 参数来重置数组键的时候，非常有用）。

index_key 可选。用作返回数组的索引/键的列。

返回输入数组中某个单一列的值。

$a = array(
  array(
    'id' => 5698,
    'first_name' => 'Bill',
    'last_name' => 'Gates',
  ),
  array(
    'id' => 4767,
    'first_name' => 'Steve',
    'last_name' => 'Jobs',
  ),
  array(
    'id' => 3809,
    'first_name' => 'Mark',
    'last_name' => 'Zuckerberg',
  )
);

$last_names = array_column($a, 'last_name');
print_r($last_names);
//Array([0] => Gates [1] => Jobs [2] => Zuckerberg)

$a = array(
  array(
    'id' => 5698,
    'first_name' => 'Bill',
    'last_name' => 'Gates',
  ),
  array(
    'id' => 4767,
    'first_name' => 'Steve',
    'last_name' => 'Jobs',
  )
  array(
    'id' => 3809,
    'first_name' => 'Mark',
    'last_name' => 'Zuckerberg',
  )
);
$last_names = array_column($a, 'last_name', 'id');
print_r($last_names);
//Array( [5698] => Gates [4767] => Jobs [3809] => Zuckerberg)

array_combine(keys,values)

keys    必需。键名数组。        values    必需。键值数组。

通过合并两个数组来创建一个新数组，其中的一个数组是键名，另一个数组的值为键值。键名数组和键值数组的元素个数必须相同！如果其中一个数组为空，或者两个数组的元素个数不同，则该函数返回 false。

$fname=array("Bill","Steve","Mark");
$age=array("60","56","31");

$c=array_combine($fname,$age);
print_r($c);
//Array ( [Bill] => 60 [Steve] => 56 [Mark] => 31 )

array_count_values(array)

array    必需。规定需要对值进行计数的数组。

对数组中的所有值进行计数。用于统计数组中所有值出现的次数。本函数返回一个数组，其元素的键名是原数组的值，键值是该值在原数组中出现的次数。

$a=array("A","Cat","Dog","A","Dog");
print_r(array_count_values($a));
//Array ( [A] => 2 [Cat] => 1 [Dog] => 2 )

array_map(myfunction,array1,array2,array3...)

myfunction    必需。用户自定义函数的名称，或者是 null。

array1    必需。规定数组。          array2    可选。规定数组。        array3    可选。规定数组。

将用户自定义函数作用到数组中的每个值上，并返回用户自定义函数作用后的带有新值的数组。

回调函数接受的参数数目应该和传递给 array_map() 函数的数组数目一致。您可以向函数输入一个或者多个数组。

function myfunction($v)
{
  return($v*$v);
}

$a=array(1,2,3,4,5);
print_r(array_map("myfunction",$a));
//Array ( [0] => 1 [1] => 4 [2] => 9 [3] => 16 [4] => 25 )

function myfunction($v1,$v2)
{
if ($v1===$v2)
  {
  return "same";
  }
return "different";
}

$a1=array("Horse","Dog","Cat");
$a2=array("Cow","Dog","Rat");
print_r(array_map("myfunction",$a1,$a2));
//Array ( [0] => different [1] => same [2] => different )

function myfunction($v)
{
$v=strtoupper($v);
  return $v;
}

$a=array("Animal" => "horse", "Type" => "mammal");
print_r(array_map("myfunction",$a));
//Array ( [Animal] => HORSE [Type] => MAMMAL )

$a1=array("Dog","Cat");
$a2=array("Puppy","Kitten");
print_r(array_map(null,$a1,$a2));
//Array ( [0] => Array ( [0] => Dog [1] => Puppy ) [1] => Array ( [0] => Cat [1] => Kitten ) )

array_multisort(array1,sorting order,sorting type,array2,array3...)

array1    必需。规定数组。

sorting order    可选。规定排列顺序。可能的值：SORT_ASC - 默认。按升序排列 (A-Z)。    SORT_DESC - 按降序排列 (Z-A)。

sorting type    可选。规定排序类型。可能的值：

                SORT_REGULAR - 默认。把每一项按常规顺序排列（Standard ASCII，不改变类型）。

                SORT_NUMERIC - 把每一项作为数字来处理。

                SORT_STRING - 把每一项作为字符串来处理。

               SORT_LOCALE_STRING - 把每一项作为字符串来处理，基于当前区域设置（可通过 setlocale() 进行更改）。

                SORT_NATURAL - 把每一项作为字符串来处理，使用类似 natsort() 的自然排序。

               SORT_FLAG_CASE - 可以结合（按位或）SORT_STRING 或 SORT_NATURAL 对字符串进行排序，不区分大小写。

array2    可选。规定数组。

array3    可选。规定数组。

返回排序数组。您可以输入一个或多个数组。函数先对第一个数组进行排序，接着是其他数组，如果两个或多个值相同，它将对下一个数组进行排序。 注释：字符串键名将被保留，但是数字键名将被重新索引，从 0 开始，并以 1 递增。 您可以在每个数组后设置排序顺序和排序类型参数。如果没有设置，每个数组参数会使用默认值。

对多个数组或多维数组进行排序。参数中的数组被当成一个表的列并以行来进行排序 - 这类似 SQL 的 ORDER BY 子句的功能。第一个数组是要排序的主要数组。数组中的行（值）比较为相同的话，就会按照下一个输入数组中相应值的大小进行排序，依此类推。

第一个参数是数组，随后的每一个参数可能是数组，也可能是下面的排序顺序标志（排序标志用于更改默认的排列顺序）之一：SORT_ASC - 默认，按升序排列。(A-Z)    SORT_DESC - 按降序排列。(Z-A)

随后可以指定排序的类型：SORT_REGULAR - 默认。将每一项按常规顺序排列。SORT_NUMERIC - 将每一项按数字顺序排列。SORT_STRING - 将每一项按字母顺序排列。

count(array,mode)    sizeof(array,mode)

array    必需。规定数组。    mode    可选。规定模式。可能的值：0 - 默认。不对多维数组中的所有元素进行计数。1 - 递归地计数数组中元素的数目（计算多维数组中的所有元素）

返回数组中元素的数目。sizeof() 函数是count() 函数的别名。

计算数组中的单元数目或对象中的属性个数。对于数组，返回其元素的个数，对于其他值，返回 1。如果参数是变量而变量没有定义，则返回 0。如果 mode 被设置为 COUNT_RECURSIVE（或 1），则会递归底计算多维数组中的数组的元素个数。

$cars=array("Volvo","BMW","Toyota");
echo count($cars);
//3

$cars=array
  (
  "Volvo"=>array
  (
  "XC60",
  "XC90"
  ),
  "BMW"=>array
  (
  "X3",
  "X5"
  ),
  "Toyota"=>array
  (
  "Highlander"
  )
  );

echo "常规计数：" . count($cars)." ";
echo "递归计数：" . count($cars,1);
//3 8

compact(var1,var2...)    

var1    必需。可以是带有变量名的字符串，或者是变量数组。

var2，…    可选。可以是带有变量名的字符串，或者是变量数组。允许多个参数。

创建包含变量名和它们的值的数组。任何没有变量名与之对应的字符串都被略过。

compact() 函数创建一个由参数所带变量组成的数组。如果参数中存在数组，该数组中变量的值也会被获取。

本函数返回的数组是一个关联数组，键名为函数的参数，键值为参数中变量的值。

$firstname = "Bill";
$lastname = "Gates";
$age = "60";
$result = compact("firstname", "lastname", "age");
print_r($result);
//Array ( [firstname] => Bill [lastname] => Gates [age] => 60 )

$firstname = "Bill";
$lastname = "Gates";
$age = "60";
$name = array("firstname", "lastname");
$result = compact($name, "location", "age");
print_r($result);
//Array ( [firstname] => Bill [lastname] => Gates [age] => 60 )

extract(array,extract_rules,prefix)

array    必需。规定要使用的数组。

extract_rules    可选。extract() 函数将检查每个键名是否为合法的变量名，同时也检查和符号表中已存在的变量名是否冲突。对不合法和冲突的键名的处理将根据此参数决定。可能的值：

       EXTR_OVERWRITE - 默认。如果有冲突，则覆盖已有的变量。

       EXTR_SKIP - 如果有冲突，不覆盖已有的变量。

       EXTR_PREFIX_SAME - 如果有冲突，在变量名前加上前缀 prefix。

       EXTR_PREFIX_ALL - 给所有变量名加上前缀 prefix。

       EXTR_PREFIX_INVALID - 仅在不合法或数字变量名前加上前缀 prefix。

       EXTR_IF_EXISTS - 仅在当前符号表中已有同名变量时，覆盖它们的值。其它的都不处理。

       EXTR_PREFIX_IF_EXISTS - 仅在当前符号表中已有同名变量时，建立附加了前缀的变量名，其它的都不处理。

       EXTR_REFS - 将变量作为引用提取。导入的变量仍然引用了数组参数的值。

prefix    可选。请注意 prefix 仅在 extract_type 的值是 EXTR_PREFIX_SAME，EXTR_PREFIX_ALL，EXTR_PREFIX_INVALID 或 EXTR_PREFIX_IF_EXISTS 时需要。如果附加了前缀后的结果不是合法的变量名，将不会导入到符号表中。前缀和数组键名之间会自动加上一个下划线。

从数组中将变量导入到当前的符号表。该函数使用数组键名作为变量名，使用数组键值作为变量值。针对数组中的每个元素，将在当前符号表中创建对应的一个变量。第二个参数type 用于指定当某个变量已经存在，而数组中又有同名元素时，extract() 函数如何对待这样的冲突。该函数返回成功导入到符号表中的变量数目。

$a = "Original";
$my_array = array("a" => "Cat","b" => "Dog", "c" => "Horse");
extract($my_array);
echo "\$a = $a; \$b = $b; \$c = $c";
//$a = Cat; $b = Dog; $c = Horse

$a = "Original";
$my_array = array("a" => "Cat", "b" => "Dog", "c" => "Horse");
extract($my_array, EXTR_PREFIX_SAME, "dup");
echo "\$a = $a; \$b = $b; \$c = $c; \$dup_a = $dup_a";
//$a = Original; $b = Dog; $c = Horse; $dup_a = Cat

in_array(search,array,type)

search      必需。规定要在数组搜索的值。

array    必需。规定要搜索的数组。

type    可选。如果设置该参数为 true，则检查搜索的数据与数组的值的类型是否相同。

搜索数组中是否存在指定的值。如果search参数是字符串且type参数被设置为 TRUE，则搜索区分大小写。

如果给定的值 search存在于数组 array 中则返回 true。如果第三个参数设置为 true，函数只有在元素存在于数组中且数据类型与给定值相同时才返回 true。如果没有在数组中找到参数，函数返回 false。

$people = array("Bill", "Steve", "Mark", "David");
if (in_array("Mark", $people))
  {
  echo "匹配已找到";
  }
else
  {
  echo "匹配未找到";
  }
//匹配已找到

$people = array("Bill", "Steve", "Mark", "David");
if (in_array("23", $people, TRUE))
  {
  echo "匹配已找到 ";
  }
else
  {
  echo "匹配未找到 ";
  }
if (in_array("Mark",$people, TRUE))
  {
  echo "匹配已找到 ";
  }
else
  {
  echo "匹配未找到 ";
  }

if (in_array(23,$people, TRUE))
  {
  echo "匹配已找到 ";
  }
else
  {
  echo "匹配未找到 ";
  }
//匹配未找到 匹配已找到 匹配未找到

array_merge(array1,array2,array3...)

array1    必需。规定数组。array2   可选。规定数组。    array3   可选。规定数组。

把一个或多个数组合并为一个数组。您可以向函数输入一个或者多个数组。如果两个或更多个数组元素有相同的键名，则最后的元素会覆盖其他元素。如果您仅向 array_merge() 函数输入一个数组，且键名是整数，则该函数将返回带有整数键名的新数组，其键名以 0 开始进行重新索引。

$a1=array("a"=>"red","b"=>"green");
$a2=array("c"=>"blue","b"=>"yellow");
print_r(array_merge($a1,$a2));
//Array ( [a] => red [b] => yellow [c] => blue )

$a=array(3=>"red",4=>"green");
print_r(array_merge($a));
//Array ( [0] => red [1] => green )

array_merge_recursive(array1,array2,array3...) 

array1    必需。规定数组。array2   可选。规定数组。    array3   可选。规定数组。

把一个或多个数组合并为一个数组。

该函数与 array_merge()  函数的区别在于处理两个或更多个数组元素有相同的键名时。array_merge_recursive() 不会进行键名覆盖，而是将多个相同键名的值递归组成一个数组。

如果您仅仅向 array_merge_recursive() 函数输入一个数组，结果与 array_merge() 相同，函数将返回带有整数键名的新数组，其键名以 0 开始进行重新索引。

$a1=array("a"=>"red","b"=>"green");
$a2=array("c"=>"blue","b"=>"yellow");
print_r(array_merge_recursive($a1,$a2));
//Array ( [a] => red [b] => Array ( [0] => green [1] => yellow ) [c] => blue )

array_pad(array,size,value)     

array    必需。规定数组。size  必需。规定从函数返回的数组中元素的个数。    value   必需。规定从函数返回的数组中新元素的值。

将指定数量的带有指定值的元素插入到数组中。如果您将size参数设置为负数，该函数会在原始数组之前插入新的元素 。如果 size参数小于原始数组的长度，该函数不会删除任何元素。

$a=array("red","green");
print_r(array_pad($a,5,"blue"));
//Array ( [0] => red [1] => green [2] => blue [3] => blue [4] => blue )

$a=array("red","green");
print_r(array_pad($a,-5,"blue"));
//Array ( [0] => blue [1] => blue [2] => blue [3] => red [4] => green )

array_product(array)

array    必需。规定数组。

计算并返回数组的乘积。

$a=array(5,5);
echo(array_product($a));
//25

array_sum(array)

array    必需。规定数组。

返回数组中所有值的和。如果所有值都是整数，则返回一个整数值。如果其中有一个或多个值是浮点数，则返回浮点数。

$a=array(5,15,25);
echo array_sum($a);
//45

array_pop(array)    出栈

array    必需。规定数组。

删除数组中的最后一个元素。

$a=array("red","green","blue");
array_pop($a);
print_r($a);
//Array ( [0] => red [1] => green )

array_push(array,value1,value2...)    入栈

array    必需。规定数组。    value1    必需。规定要添加的值。     value2    可选。规定要添加的值。

向第一个参数的数组尾部添加一个或多个元素（入栈），然后返回新数组的长度。该函数等于多次调用 $array[] = $value。

即使数组中有字符串键名，您添加的元素也始终是数字键。

如果用 array_push() 来给数组增加一个单元，还不如用 $array[] =，因为这样没有调用函数的额外负担。

如果第一个参数不是数组，array_push() 将发出一条警告。这和 $var[] 的行为不同，后者会新建一个数组。

$a=array("red","green");
array_push($a,"blue","yellow");
print_r($a);
//Array ( [0] => red [1] => green [2] => blue [3] => yellow )

$a=array("a"=>"red","b"=>"green");
array_push($a,"blue","yellow");
print_r($a)
//Array ( [a] => red [b] => green [0] => blue [1] => yellow )

array_shift(array)     

array    必需。规定数组。 

删除数组中第一个元素，并返回被删除元素的值。

如果键名是数字的，所有元素都会获得新的键名，从 0 开始，并以 1 递增。

$a=array("a"=>"red","b"=>"green","c"=>"blue");
echo array_shift($a);
print_r ($a);
//redArray ( [b] => green [c] => blue )

$a=array(0=>"red",1=>"green",2=>"blue");
echo array_shift($a);
print_r ($a);
//redArray ( [0] => green [1] => blue )

array_unshift(array,value1,value2,value3...)    

array    必需。规定数组。     value1    必需。规定要插入的值。

value2    可选。规定要插入的值。    value3    可选。规定要插入的值。

用于向数组插入新元素。新数组的值将被插入到数组的开头。 

被加上的元素作为一个整体添加，这些元素在数组中的顺序和在参数中的顺序一样。

该函数会返回数组中元素的个数。数值键名将从 0 开始，以 1 递增。字符串键名将保持不变。

$a=array("a"=>"red","b"=>"green");
array_unshift($a,"blue");
print_r($a);
//Array ( [0] => blue [a] => red [b] => green )

$a=array("a"=>"red","b"=>"green");
print_r(array_unshift($a,"blue"));
//3

$a=array(0=>"red",1=>"green");
array_unshift($a,"blue");
print_r($a);
//Array ( [0] => blue [1] => red [2] => green )

array_reduce(array,myfunction,initial)    

array  必需。规定数组。  myfunction  必需。规定函数的名称。 initial  可选。规定发送到函数的初始值。

向用户自定义函数发送数组中的值，并返回一个字符串。

如果数组是空的且未传递 initial 参数，该函数返回 NULL。

array_reduce() 函数用回调函数迭代地将数组简化为单一的值。如果指定第三个参数，则该参数将被当成是数组中的第一个值来处理，或者如果数组为空的话就作为最终返回值。

function myfunction($v1,$v2)
{
return $v1 . "-" . $v2;
}
$a=array("Dog","Cat","Horse");
print_r(array_reduce($a,"myfunction"));
//-Dog-Cat-Horse

function myfunction($v1,$v2)
{
return $v1 . "-" . $v2;
}
$a=array("Dog","Cat","Horse");
print_r(array_reduce($a,"myfunction",5));
//5-Dog-Cat-Horse

function myfunction($v1,$v2)
{
return $v1+$v2;
}
$a=array(10,15,20);
print_r(array_reduce($a,"myfunction",5));
//50

array_replace(array1,array2,array3...)    

array1  必需。规定数组。  array2  可选。指定要替换 array1 的值的数组。array3… 可选。指定多个要替换array1和 array2, ... 的值的数组。后面数组的值将覆盖之前数组的值。

使用后面数组的值替换第一个数组的值。

您可以向函数传递一个数组，或者多个数组。如果一个键存在于第一个数组 array1 同时也存在于第二个数组 array2，第一个数组 array1 中的值将被第二个数组 array2 中的值替换。如果一个键仅存在于第一个数组 array1，它将保持不变。如果一个键存在于第二个数组 array2，但是不存在于第一个数组 array1，则会在第一个数组 array1 中创建这个元素。如果传递了多个替换数组，它们将被按顺序依次处理，后面数组的值将覆盖之前数组的值。

 

$a1=array("red","green");
$a2=array("blue","yellow");
print_r(array_replace($a1,$a2));
//Array ( [0] => blue [1] => yellow )

$a1=array("a"=>"red","b"=>"green");
$a2=array("a"=>"orange","burgundy");
print_r(array_replace($a1,$a2));
//Array ( [a] => orange [b] => green [0] => burgundy )

array_replace_recursive(array1,array2,array3...)

array1  必需。规定数组。  array2  可选。指定要替换 array1 的值的数组。array3… 可选。指定多个要替换array1和 array2, ... 的值的数组。后面数组的值将覆盖之前数组的值。

递归地使用后面数组的值替换第一个数组的值。

$a1=array("a"=>array("red"),"b"=>array("green","blue"),);
$a2=array("a"=>array("yellow"),"b"=>array("black"));
print_r(array_replace_recursive($a1,$a2));
//Array ( [a] => Array ( [0] => yellow ) [b] => Array ( [0] => black [1] => blue ) )

$a1=array("a"=>array("red"),"b"=>array("green","blue"));
$a2=array("a"=>array("yellow"),"b"=>array("black"));
$a3=array("a"=>array("orange"),"b"=>array("burgundy"));
print_r(array_replace_recursive($a1,$a2,$a3));
//Array ( [a] => Array ( [0] => orange ) [b] => Array ( [0] => burgundy [1] => blue ) )

$a1=array("a"=>array("red"),"b"=>array("green","blue"),);
$a2=array("a"=>array("yellow"),"b"=>array("black"));
$result=array_replace_recursive($a1,$a2);
print_r($result);
$result=array_replace($a1,$a2);
print_r($result);
//Array ( [a] => Array ( [0] => yellow ) [b] => Array ( [0] => black [1] => blue ) ) Array ( [a] => Array ( [0] => yellow ) [b] => Array ( [0] => black ) )

 array_reverse(array,preserve)       

array1  必需。规定数组。preserve    可选。规定是否保留原始数组的键名。这个参数是 PHP 4.0.3 中新加的。可能的值：true/false

以相反的元素顺序返回数组。将原数组中的元素顺序翻转，创建新的数组并返回。如果第二个参数指定为 true，则元素的键名保持不变，否则键名将丢失。

$a=array("a"=>"Volvo","b"=>"BMW","c"=>"Toyota");
print_r(array_reverse($a));
//Array ( [c] => Toyota [b] => BMW [a] => Volvo )

$a=array("Volvo","XC90",array("BMW","Toyota"));
$reverse=array_reverse($a);
$preserve=array_reverse($a,true);
print_r($a);
print_r($reverse);
print_r($preserve);
//Array ( [0] => Volvo [1] => XC90 [2] => Array ( [0] => BMW [1] => Toyota ) ) 
//Array ( [0] => Array ( [0] => BMW [1] => Toyota ) [1] => XC90 [2] => Volvo )
//Array ( [2] => Array ( [0] => BMW [1] => Toyota ) [1] => XC90 [0] => Volvo )

以相反的顺序返回数组。对于整数键名，如果第二个参数指定为 true，则元素的键名保持不变，否则键名将丢失。

array_search(value,array,strict)

value  必需。规定需要搜素的键值。    array    必需。规定被搜索的数组。

strict    可选。如果该参数被设置为 TRUE，则函数在数组中搜索数据类型和值都一致的元素。可能的值：true/false（默认）如果设置为 true，则在数组中检查给定值的类型，数字 5 和字符串 5 是不同的。

在数组中搜索某个键值，并返回对应的键名。在数组中查找一个键值。如果找到了该值，匹配元素的键名会被返回。如果没找到，则返回 false。如果在数组中找到键值超过一次，则返回第一次找到的键值所匹配的键名。

$a=array("a"=>"red","b"=>"green","c"=>"blue");
echo array_search("red",$a);
//a

$a=array("a"=>"5","b"=>5,"c"=>"5");
echo array_search(5,$a,true);
//b

array_slice(array,start,length,preserve)

array    必需。规定数组。    

start    必需。数值。规定取出元素的开始位置。 0 = 第一个元素。如果该值设置为正数，则从前往后开始取。如果该值设置为负数，则从后向前取 start 绝对值。 -2 意味着从数组的倒数第二个元素开始。

length    可选。数值。规定被返回数组的长度。如果该值设置为整数，则返回该数量的元素。如果该值设置为负数，则函数将在举例数组末端这么远的地方终止取出。如果该值未设置，则返回从 start 参数设置的位置开始直到数组末端的所有元素。

preserve    可选。规定函数是保留键名还是重置键名。可能的值：true - 保留键名。false - 默认。重置键名

在数组中根据条件取出一段值，并返回。如果数组有字符串键，所返回的数组将保留键名。

$a=array("red","green","blue","yellow","brown");
print_r(array_slice($a,2));
//Array ( [0] => blue [1] => yellow [2] => brown )

$a=array("red","green","blue","yellow","brown");
print_r(array_slice($a,1,2));
//Array ( [0] => green [1] => blue )

$a=array("red","green","blue","yellow","brown");
print_r(array_slice($a,-2,1));
//Array ( [0] => yellow )

$a=array("red","green","blue","yellow","brown");
print_r(array_slice($a,1,2,true));
//Array ( [1] => green [2] => blue )

$a=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow","e"=>"brown");
print_r(array_slice($a,1,2));
$a=array("0"=>"red","1"=>"green","2"=>"blue","3"=>"yellow","4"=>"brown");
print_r(array_slice($a,1,2));
//Array ( [b] => green [c] => blue ) Array ( [0] => green [1] => blue )

array_splice(array,start,length,array)

array    必需。规定数组。    

start    必需。数值。规定取出元素的开始位置。 0 = 第一个元素。如果该值设置为正数，则从前往后开始取。如果该值设置为负数，则从后向前取 start 绝对值。 -2 意味着从数组的倒数第二个元素开始。

length    可选。数值。规定被返回数组的长度。如果该值设置为整数，则返回该数量的元素。如果该值设置为负数，则函数将在举例数组末端这么远的地方终止取出。如果该值未设置，则返回从 start 参数设置的位置开始直到数组末端的所有元素。

array    可选。规定带有要插入原始数组中元素的数组。如果只有一个元素，则可以设置为字符串，不需要设置为数组。

从数组中移除选定的元素，并用新元素取代它。该函数也将返回包含被移除元素的数组。如果函数没有移除任何元素（length=0），则将从 start 参数的位置插入被替换数组。不保留被替换数组中的键名。

array_splice() 函数与 array_slice() 函数类似，选择数组中的一系列元素，但不返回，而是删除它们并用其它值代替。如果提供了第四个参数，则之前选中的那些元素将被第四个参数指定的数组取代。最后生成的数组将会返回。

$a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
$a2=array("a"=>"purple","b"=>"orange");
array_splice($a1,0,2,$a2);
print_r($a1);
//Array ( [0] => purple [1] => orange [c] => blue [d] => yellow )

$a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
$a2=array("a"=>"purple","b"=>"orange");
print_r(array_splice($a1,0,2,$a2));
//Array ( [a] => red [b] => green )

$a1=array("0"=>"red","1"=>"green");
$a2=array("0"=>"purple","1"=>"orange");
array_splice($a1,1,0,$a2);
print_r($a1);
//Array ( [0] => red [1] => purple [2] => orange [3] => green )

array_unique(array)

array    必需。规定数组。 

sortingtype    可选。规定如何比较数组元素/项目。可能的值：SORT_STRING - 默认。把项目作为字符串来比较。SORT_REGULAR - 把每一项按常规顺序排列（Standard ASCII，不改变类型）。SORT_NUMERIC - 把每一项作为数字来处理。SORT_LOCALE_STRING - 把每一项作为字符串来处理，基于当前区域设置（可通过 setlocale() 进行更改）。

移除数组中的重复的值，并返回结果数组。当几个数组元素的值相等时，只保留第一个元素，其他的元素被删除。返回的数组中键名不变。被保留的数组将保持第一个数组项的键名类型。

$a=array("a"=>"red","b"=>"green","c"=>"red");
print_r(array_unique($a));
//Array ( [a] => red [b] => green )

array_walk(array,myfunction,userdata...)    

array    必需。规定数组。 myfunction 必需。用户自定义函数的名称。

userdata…    可选。规定用户自定义函数的参数。您能够向此函数传递任意多参数。

对数组中的每个元素应用用户自定义函数。在函数中，数组的键名和键值是参数。您可以通过把用户自定义函数中的第一个参数指定为引用：&$value，来改变数组元素的值。如需操作更深的数组（一个数组中包含另一个数组），请使用array_walk_recursive() 函数。

array_walk() 函数对数组中的每个元素应用回调函数。如果成功则返回 TRUE，否则返回 FALSE。

典型情况下 myfunction 接受两个参数。array 参数的值作为第一个，键名作为第二个。如果提供了可选参数 userdata ，将被作为第三个参数传递给回调函数。

如果 myfunction 函数需要的参数比给出的多，则每次 array_walk() 调用 myfunction 时都会产生一个 E_WARNING 级的错误。这些警告可以通过在 array_walk() 调用前加上 PHP 的错误操作符 @ 来抑制，或者用 error_reporting()。

注释：如果回调函数需要直接作用于数组中的值，可以将回调函数的第一个参数指定为引用：&$value。

注释：将键名和 userdata 传递到 myfunction 中是 PHP 4.0 新增加的。

function myfunction($value,$key)
{
echo "The key $key has the value $value ";
}
$a=array("a"=>"red","b"=>"green","c"=>"blue");
array_walk($a,"myfunction");
//The key a has the value red The key b has the value green The key c has the value blue

function myfunction($value,$key,$p)
{
echo "$key $p $value<br>";
}
$a=array("a"=>"red","b"=>"green","c"=>"blue");
array_walk($a,"myfunction","has the value");
//a has the value red b has the value green c has the value blue

function myfunction(&$value,$key)
{
$value="yellow";
}
$a=array("a"=>"red","b"=>"green","c"=>"blue");
array_walk($a,"myfunction");
print_r($a);
//Array ( [a] => yellow [b] => yellow [c] => yellow )

array_walk_recursive(array,myfunction,parameter...)   

array    必需。规定数组。 myfunction 必需。用户自定义函数的名称。

userdata…    可选。规定用户自定义函数的参数。您能够向此函数传递任意多参数。

对数组中的每个元素应用用户自定义函数。在函数中，数组的键名和键值是参数。

该函数与 array_walk() 函数的不同在于可以操作更深的数组（一个数组中包含另一个数组）。

array_walk_recursive() 函数对数组中的每个元素应用回调函数。不一样的是，如果原数组中的元素也是数组，就会递归地调用回调函数，也就是说，会递归到更深层的数组中去。

典型情况下，myfunction 接受两个参数。array 参数的值作为第一个，键名作为第二个。如果提供了可选参数 userdata ，将被作为第三个参数传递给回调函数。

如果回调函数需要直接作用于数组中的值，可以将回调函数的第一个参数指定为引用，这样对这些单元的任何改变也将会改变原始数组本身。

function myfunction($value,$key)
{
echo "键 $key 的值是 $value 。<br>";
}
$a1=array("a"=>"red","b"=>"green");
$a2=array($a1,"1"=>"blue","2"=>"yellow");
array_walk_recursive($a2,"myfunction");
//键 a 的值是 red 。 键 b 的值是 green 。 键 1 的值是 blue 。 键 2 的值是 yellow 。

比较数组，返回差集

array_diff(array1,array2,array3...)     (只比较键值。在返回的数组中键名保持不变。)

array_diff_assoc(array1,array2,array3...)      （比较键名和键值）

array_diff_key(array1,array2,array3...)     （只比较键名）

array_diff_uassoc(array1,array2,array3...,myfunction)    （比较键名和键值，使用用户自定义的键名比较函数。返回的数组中键名保持不变）

array_diff_ukey(array1,array2,array3...,myfunction)   （只比较键名，使用用户自定义的键名比较函数）

array_udiff(array1,array2,array3...,myfunction)       （只比较值，使用一个用户自定义的键名比较函数）

array_udiff_assoc(array1,array2,array3...,myfunction)    （比较键和值，使用内建函数比较键名，使用用户自定义函数比较键值）

array_udiff_uassoc(array1,array2,array3...,myfunction_key,myfunction_value)        （比较键和值，使用两个用户自定义的键名比较函数）

array1    必需。与其他数组进行比较的第一个数组。

array2    必需。与第一个数组进行比较的数组。

array3    可选。与第一个数组进行比较的其他数组。

myfunction     必需。定义可调用比较函数的字符串。如果第一个参数小于、等于或大于第二个参数，则该比较函数必须返回小于、等于或大于 0 的整数。

//array_diff(array1,array2,array3...)     (只比较键值。在返回的数组中，键名保持不变。)
$a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
$a2=array("e"=>"red","f"=>"green","g"=>"blue");
$result=array_diff($a1,$a2);
print_r($result);
//Array ( [d] => yellow )

$a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
$a2=array("e"=>"red","f"=>"black","g"=>"purple");
$a3=array("a"=>"red","b"=>"black","h"=>"yellow");
$result=array_diff($a1,$a2,$a3);
print_r($result);
//Array ( [b] => green [c] => blue )

//array_diff_assoc(array1,array2,array3...)      （比较键名和键值）
$a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
$a2=array("a"=>"red","b"=>"green","c"=>"blue");
$result=array_diff_assoc($a1,$a2);
print_r($result);
//Array ( [d] => yellow )

$a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
$a2=array("e"=>"red","f"=>"green","g"=>"blue");
$result=array_diff_assoc($a1,$a2);
print_r($result);
//Array ( [a] => red [b] => green [c] => blue [d] => yellow )

$a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
$a2=array("a"=>"red","f"=>"green","g"=>"blue");
$a3=array("h"=>"red","b"=>"green","g"=>"blue");
$result=array_diff_assoc($a1,$a2,$a3);
print_r($result);
//Array ( [c] => blue [d] => yellow )

//array_diff_key(array1,array2,array3...)     （只比较键名）
$a1=array("a"=>"red","b"=>"green","c"=>"blue");
$a2=array("a"=>"red","c"=>"blue","d"=>"pink");
$result=array_diff_key($a1,$a2);
print_r($result);
//Array ( [b] => green )

$a1=array("a"=>"red","b"=>"green","c"=>"blue");
$a2=array("c"=>"yellow","d"=>"black","e"=>"brown");
$a3=array("f"=>"green","c"=>"purple","g"=>"red");
$result=array_diff_key($a1,$a2,$a3);
print_r($result);
//Array ( [a] => red [b] => green )

function myfunction($a,$b)
{
if ($a===$b)
  {
  return 0;
  }
  return ($a>$b)?1:-1;
}
$a1=array("a"=>"red","b"=>"green","c"=>"blue");
$a2=array("d"=>"red","b"=>"green","e"=>"blue");
$result=array_diff_uassoc($a1,$a2,"myfunction");
print_r($result);
//Array ( [a] => red [c] => blue )

//array_diff_uassoc(array1,array2,array3...,myfunction)    （比较键名和键值，使用用户自定义的键名比较函数）
function myfunction($a,$b)
{
if ($a===$b)
  {
  return 0;
  }
  return ($a>$b)?1:-1;
}
$a1=array("a"=>"red","b"=>"green","c"=>"blue");
$a2=array("a"=>"red","b"=>"green","d"=>"blue");
$a3=array("e"=>"yellow","a"=>"red","d"=>"blue");
$result=array_diff_uassoc($a1,$a2,$a3,"myfunction");
print_r($result);
//Array ( [c] => blue )

//array_diff_ukey(array1,array2,array3...,myfunction)   （只比较键名，使用用户自定义的键名比较函数）
function myfunction($a,$b)
{
if ($a===$b)
  {
  return 0;
  }
  return ($a>$b)?1:-1;
}
$a1=array("a"=>"red","b"=>"green","c"=>"blue");
$a2=array("a"=>"blue","b"=>"black","e"=>"blue");
$result=array_diff_ukey($a1,$a2,"myfunction");
print_r($result);
//Array ( [c] => blue )

function myfunction($a,$b)
{
if ($a===$b)
  {
  return 0;
  }
  return ($a>$b)?1:-1;
}
$a1=array("a"=>"red","b"=>"green","c"=>"blue");
$a2=array("a"=>"black","b"=>"yellow","d"=>"brown");
$a3=array("e"=>"purple","f"=>"white","a"=>"gold");
$result=array_diff_ukey($a1,$a2,$a3,"myfunction");
print_r($result);
//Array ( [c] => blue )

//array_udiff(array1,array2,array3...,myfunction)       （只比较值，使用一个用户自定义的键名比较函数）
function myfunction($a,$b)
{
if ($a===$b)
  {
  return 0;
  }
  return ($a>$b)?1:-1;
}
$a1=array("a"=>"red","b"=>"green","c"=>"blue");
$a2=array("a"=>"blue","b"=>"black","e"=>"blue");
$result=array_udiff($a1,$a2,"myfunction");
print_r($result);
//Array ( [a] => red [b] => green )

//array_udiff_assoc(array1,array2,array3...,myfunction)    （比较键和值，使用内建函数比较键名，使用用户自定义函数比较键值）
function myfunction($a,$b)
{
if ($a===$b)
  {
  return 0;
  }
  return ($a>$b)?1:-1;
}
$a1=array("a"=>"red","b"=>"green","c"=>"blue");
$a2=array("a"=>"red","b"=>"blue","c"=>"green");
$result=array_udiff_assoc($a1,$a2,"myfunction");
print_r($result);
//Array ( [b] => green [c] => blue )

//array_udiff_uassoc(array1,array2,array3...,myfunction_key,myfunction_value)        （比较键和值，使用两个用户自定义的键名比较函数）
function myfunction_key($a,$b)
{
if ($a===$b)
  {
  return 0;
  }
  return ($a>$b)?1:-1;
}
function myfunction_value($a,$b)
{
if ($a===$b)
  {
  return 0;
  }
  return ($a>$b)?1:-1;
}
$a1=array("a"=>"red","b"=>"green","c"=>"blue");
$a2=array("a"=>"red","b"=>"green","c"=>"green");
$result=array_udiff_uassoc($a1,$a2,"myfunction_key","myfunction_value");
print_r($result);
//Array ( [c] => blue )

比较数组，返回交集

array_intersect(array1,array2,array3...)     （只比较键值）。

array_intersect_assoc(array1,array2,array3...)      （比较键名和键值）。

array_intersect_key(array1,array2,array3...)      （只比较键名）。

array_intersect_uassoc(array1,array2,array3...,myfunction)      （比较键名和键值，使用用户自定义的键名比较函数）。

array_intersect_ukey(array1,array2,array3...,myfunction)   （只比较键名，使用用户自定义的键名比较函数）。

array_uintersect(array1,array2,array3...,myfunction)    （只比较值，使用一个用户自定义的键名比较函数）。

array_uintersect_assoc(array1,array2,array3...,myfunction)（比较键和值，使用内建函数比较键名，使用用户自定义函数比较键值）。

array_uintersect_uassoc(array1,array2,array3...,myfunction_key,myfunction_value)（比较键和值，使用两个用户自定义的键名比较函数）。

array1    必需。与其他数组进行比较的第一个数组。

array2    必需。与第一个数组进行比较的数组。

array3    可选。与第一个数组进行比较的其他数组。

myfunction     必需。定义可调用比较函数的字符串。如果第一个参数小于、等于或大于第二个参数，则该比较函数必须返回小于、等于或大于 0 的整数。

#array_intersect(array1,array2,array3...)     （只比较键值）。
$a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
$a2=array("e"=>"red","f"=>"green","g"=>"blue");
$result=array_intersect($a1,$a2);
print_r($result);
//Array ( [a] => red [b] => green [c] => blue )

$a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
$a2=array("e"=>"red","f"=>"black","g"=>"purple");
$a3=array("a"=>"red","b"=>"black","h"=>"yellow");
$result=array_intersect($a1,$a2,$a3);
print_r($result);
//Array ( [a] => red )

#array_intersect_assoc(array1,array2,array3...)      （比较键名和键值）。
$a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
$a2=array("a"=>"red","b"=>"green","g"=>"blue");
$a3=array("a"=>"red","b"=>"green","g"=>"blue");
$result=array_intersect_assoc($a1,$a2,$a3);
print_r($result);
//Array ( [a] => red [b] => green )

#array_intersect_key(array1,array2,array3...)      （只比较键名）。
$a1=array("a"=>"red","b"=>"green","c"=>"blue");
$a2=array("c"=>"yellow","d"=>"black","e"=>"brown");
$a3=array("f"=>"green","c"=>"purple","g"=>"red");
$result=array_intersect_key($a1,$a2,$a3);
print_r($result);
//Array ( [c] => blue )


#array_intersect_uassoc(array1,array2,array3...,myfunction)      （比较键名和键值，使用用户自定义的键名比较函数）。
function myfunction($a,$b)
{
if ($a===$b)
  {
  return 0;
  }
  return ($a>$b)?1:-1;
}
$a1=array("a"=>"red","b"=>"green","c"=>"blue");
$a2=array("a"=>"red","b"=>"green","d"=>"blue");
$a3=array("e"=>"yellow","a"=>"red","d"=>"blue");
$result=array_intersect_uassoc($a1,$a2,$a3,"myfunction");
print_r($result);
//Array ( [a] => red )

#array_intersect_ukey(array1,array2,array3...,myfunction)   （只比较键名，使用用户自定义的键名比较函数）。
function myfunction($a,$b)
{
if ($a===$b)
  {
  return 0;
  }
  return ($a>$b)?1:-1;
}
$a1=array("a"=>"red","b"=>"green","c"=>"blue");
$a2=array("a"=>"black","b"=>"yellow","d"=>"brown");
$a3=array("e"=>"purple","f"=>"white","a"=>"gold");
$result=array_intersect_ukey($a1,$a2,$a3,"myfunction");
print_r($result);
//Array ( [a] => red )


#array_uintersect(array1,array2,array3...,myfunction)    （只比较值，使用一个用户自定义的键名比较函数）。
function myfunction($a,$b)
{
if ($a===$b)
  {
  return 0;
  }
  return ($a>$b)?1:-1;
}
$a1=array("a"=>"red","b"=>"green","c"=>"blue","yellow");
$a2=array("A"=>"red","b"=>"GREEN","yellow","black");
$a3=array("a"=>"green","b"=>"red","yellow","black");
$result=array_uintersect($a1,$a2,$a3,"myfunction");
print_r($result);
//Array ( [a] => red [0] => yellow )

#array_uintersect_assoc(array1,array2,array3...,myfunction)（比较键和值，使用内建函数比较键名，使用用户自定义函数比较键值）。
function myfunction($a,$b)
{
if ($a===$b)
  {
  return 0;
  }
  return ($a>$b)?1:-1;
}
$a1=array("a"=>"red","b"=>"green","c"=>"blue");
$a2=array("a"=>"red","b"=>"blue","c"=>"green");
$result=array_uintersect_assoc($a1,$a2,"myfunction");
print_r($result);
//Array ( [a] => red )

#array_uintersect_uassoc(array1,array2,array3...,myfunction_key,myfunction_value)（比较键和值，使用两个用户自定义的键名比较函数）。
function myfunction_key($a,$b)
{
if ($a===$b)
  {
  return 0;
  }
  return ($a>$b)?1:-1;
}
function myfunction_value($a,$b)
{
if ($a===$b)
  {
  return 0;
  }
  return ($a>$b)?1:-1;
}
$a1=array("a"=>"red","b"=>"green","c"=>"blue");
$a2=array("a"=>"red","b"=>"green","c"=>"green");
$result=array_uintersect_uassoc($a1,$a2,"myfunction_key","myfunction_value");
print_r($result);
//Array ( [a] => red [b] => green )

数组排序

sort(array,sortingtype)    对索引数组进行升序排序。 本函数为数组中的单元赋予新的键名。原有的键名将被删除。

rsort(array,sortingtype)    对数值数组进行降序排序。该函数为 array 中的单元赋予新的键名。这将删除原有的键名而不仅是重新排序。

asort(array,sortingtype)    对关联数组按照键值进行升序排序。保持索引关系。（键，值沿用以前的）

arsort(array,sortingtype)    对关联数组按照键值进行降序排序。保持索引关系。（键，值沿用以前的）

ksort(array,sortingtype)    对数组按照键名排序。为数组值保留原来的键。（升序）

krsort(array,sortingtype)    对数组按照键名逆向排序。为数组值保留原来的键。（降序）

natsort(array)    用“自然排序”算法对数组排序。（升序。键值保留它们原始的键名。）

natcasesort(array)    用“自然排序”算法对数组进行不区分大小写字母的排序。（键值保留它们原始的键名。）

usort(array,myfunction)  通过用户自定义的比较函数对数组进行排序。如果两个元素比较结果相同，则它们在排序后的数组中的顺序未经定义。到 PHP 4.0.6 之前，用户自定义函数将保留这些元素的原有顺序。但是由于在 4.1.0 中引进了新的排序算法，结果将不是这样了，因为对此没有一个有效的解决方案。本函数为 array 中的元素赋予新的键名。这会删除原有的键名。

uasort(array,myfunction)   使用用户自定义的比较函数对数组排序。保持索引关联（不为元素分配新的键）

uksort(array,myfunction)     使用用户自定义的比较函数对数组中的键名进行排序。

array    必需。规定要进行排序的数组。

sortingtype    可选。规定如何排列数组的元素/项目。可能的值：

0=SORT_REGULAR - 默认。把每一项按常规顺序排列（Standard ASCII，不改变类型）

1 = SORT_NUMERIC - 把每一项作为数字来处理。

2 = SORT_STRING - 把每一项作为字符串来处理。

3 = SORT_LOCALE_STRING - 把每一项作为字符串来处理，基于当前区域设置（可通过 setlocale() 进行更改）。在 PHP 6 之前，使用了系统的区域设置，可以用 setlocale() 来改变。自 PHP 6 起，必须用 i18n_loc_set_default() 函数。

4 = SORT_NATURAL - 把每一项作为字符串来处理，使用类似 natsort() 的自然排序。

5 = SORT_FLAG_CASE - 可以结合（按位或）SORT_STRING 或 SORT_NATURAL 对字符串进行排序，不区分大小写。

myfunction    可选。定义可调用比较函数的字符串。如果第一个参数小于等于或大于第二个参数，那么比较函数必须返回一个小于等于或大于 0 的整数。

如果成功则返回 TRUE，否则返回 FALSE。

自然排序，即数字从 1 到 9 的排序方法，字母从 a 到 z 的排序方法，短者优先。数组的索引与单元值保持关联。

$cars=array("Volvo","BMW","Toyota");
sort($cars);
//BMW Toyota Volvo

$numbers=array(4,6,2,22,11);
rsort($numbers);
//22 11 6 4 2

$age=array("Bill"=>"60","Steve"=>"56","Mark"=>"31");
arsort($age);
foreach($age as $x=>$x_value)
    {
    echo "Key=" . $x . ", Value=" . $x_value;
    echo "<br>";
    }
//Key=Bill, Value=60 Key=Steve, Value=56 Key=Mark, Value=31

$age=array("Bill"=>"60","Steve"=>"56","Mark"=>"31");
asort($age);
foreach($age as $x=>$x_value)
    {
    echo "Key=" . $x . ", Value=" . $x_value;
    echo "<br>";
    }
//Key=Mark, Value=31 Key=Steve, Value=56 Key=Bill, Value=60

$age=array("Bill"=>"60","Steve"=>"56","mark"=>"31");
krsort($age);
foreach($age as $x=>$x_value)
    {
    echo "Key=" . $x . ", Value=" . $x_value;
    echo "<br>";
    }
//Key=mark, Value=31 Key=Steve, Value=56 Key=Bill, Value=60

$age=array("Bill"=>"60","Steve"=>"56","mark"=>"31");
ksort($age);
foreach($age as $x=>$x_value)
    {
    echo "Key=" . $x . ", Value=" . $x_value;
    echo "<br>";
    }
//Key=Bill, Value=60 Key=Steve, Value=56 Key=mark, Value=31

$temp_files = array("temp15.txt","temp10.txt","temp1.txt","temp22.txt","temp2.txt");
sort($temp_files);
echo "标准排序：";
print_r($temp_files);
echo "<br>";
natsort($temp_files);
echo "自然排序：";
print_r($temp_files);
//标准排序：Array ( [0] => temp1.txt [1] => temp10.txt [2] => temp15.txt [3] => temp2.txt [4] => temp22.txt ) 
//自然排序：Array ( [0] => temp1.txt [3] => temp2.txt [1] => temp10.txt [2] => temp15.txt [4] => temp22.txt )

$temp_files = array("temp15.txt","Temp10.txt",
"temp1.txt","Temp22.txt","temp2.txt");
natsort($temp_files);
echo "自然排序：";
print_r($temp_files);
echo "<br />";
natcasesort($temp_files);
echo "不区分大小写的自然排序：";
print_r($temp_files);
//自然排序：Array([0] => Temp10.txt [1] => Temp22.txt [2] => temp1.txt [4] => temp2.txt [3] => temp15.txt)
//不区分大小写的自然顺序：Array([2] => temp1.txt [4] => temp2.txt [0] => Temp10.txt [3] => temp15.txt [1] => Temp22.txt)

function my_sort($a,$b)
{
if ($a==$b) return 0;
   return ($a<$b)?-1:1;
}
$a=array(4,2,8,6);
usort($a,"my_sort");
$arrlength=count($a);
for($x=0;$x<$arrlength;$x++)
   {
   echo $a[$x];
   echo "<br>";
   }
//2 4 6 8

function my_sort($a,$b)
{
if ($a==$b) return 0;
return ($a<$b)?-1:1;
}
$arr=array("a"=>4,"b"=>2,"c"=>8,d=>"6");
uasort($arr,"my_sort");
foreach($arr as $x=>$x_value)
    {
    echo "Key=" . $x . ", Value=" . $x_value;
    echo "<br>";
    }
//Key=b, Value=2 Key=a, Value=4 Key=d, Value=6 Key=c, Value=8

function my_sort($a,$b)
{
if ($a==$b) return 0;
return ($a<$b)?-1:1;
}
$arr=array("a"=>4,"b"=>2,"c"=>8,d=>"6");
uksort($arr,"my_sort");
foreach($arr as $x=>$x_value)
    {
    echo "Key=" . $x . ", Value=" . $x_value;
    echo "<br>";
    }
//Key=a, Value=4 Key=b, Value=2 Key=c, Value=8 Key=d, Value=6

数组指针移动

current(array)   返回数组中的当前元素的值。该函数不会移动数组内部指针。

pos(array)    current() 的别名。

each(array)   返回当前元素的键名和键值，并将内部指针向前移动。该元素的键名和键值会被返回带有四个元素的数组中。两个元素（1 和 Value）包含键值，两个元素（0 和 Key）包含键名。

prev(array)    将内部指针指向数组中的上一个元素，并输出。如果数组包含空的单元，或者单元的值是 0 则该函数碰到这些单元也返回 FALSE。要正确遍历可能含有空单元或者单元值为 0 的数组，请参见 each() 函数。

next(array)    将内部指针指向数组中的下一个元素，并输出。如果移动指针的结果超出了数组单元的末端，则 next() 返回 FALSE。

reset(array)    将内部指针指向数组中的第一个元素，并输出。

end(array)    将数组内部指针指向最后一个元素，并返回该元素的值（如果成功）。

array    必需。规定要进行排序的数组。

每个数组中都有一个内部的指针指向它的"当前"元素，初始指向插入到数组中的第一个元素。

key(array)    返回数组内部指针当前指向元素的键名。该函数与 current() 类似，只是返回的结果不同。current() 函数返回的是元素的值，而 key() 函数返回的是元素的键名。   

$people = array("Bill", "Steve", "Mark", "David");
echo "键的当前位置是：" . key($people)
//键的当前位置是：0

$people = array("Bill", "Steve", "Mark", "David");
echo current($people) . "<br>"; // 当前元素是 Bill
echo next($people) . "<br>"; // Bill 的下一个元素是 Steve
echo current($people) . "<br>"; // 现在当前元素是 Steve
echo prev($people) . "<br>"; // Steve 的上一个元素是 Bill
echo end($people) . "<br>"; // 最后一个元素是 David
echo prev($people) . "<br>"; // David 之前的元素是 Mark
echo current($people) . "<br>"; // 目前的当前元素是 Mark
echo reset($people) . "<br>"; // 把内部指针移动到数组的首个元素，即 Bill
echo next($people) . "<br>"; // Bill 的下一个元素是 Steve
print_r (each($people)); // 返回当前元素的键名和键值（目前是 Steve），并向前移动内部指针
//Bill Steve Steve Bill David Mark Mark Bill Steve
//Array ( [1] => Steve [value] => Steve [0] => 1 [key] => 1 )

 

标签
php数组合并
php数组函数
php
易学教程内所有资源均来自网络或用户发布的内容，如有违反法律规定的内容欢迎反馈！
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!