PHP 中的 数组 实际上是一个有序映射。映射是一种把 values 关联到 keys 的类型。此类型在很多方面做了优化，因此可以把它当成真正的数组，或列表（向量），散列表（是映射的一种实现），字典，集合，栈，队列以及更多可能性。由于数组元素的值也可以是另一个数组，树形结构和多维数组也是允许的。
解释这些结构超出了本手册的范围，但对于每种结构至少会提供一个例子。要得到这些结构的更多信息，建议参考有关此广阔主题的其它著作。

语法

定义数组 array()

可以用 array() 语言结构来新建一个数组。它接受任意数量用逗号分隔的 键（key）** => 值（value） **对。
array( key => value , … ) // 键（key）可是是一个整数 integer 或字符串 string // 值（value）可以是任意类型的值
最后一个数组单元之后的逗号可以省略。通常用于单行数组定义中，例如常用 array(1, 2) 而不是 array(1, 2, )。对多行数组定义通常保留最后一个逗号，这样要添加一个新单元时更方便。
自 5.4 起可以使用短数组定义语法，用 [] 替代 array()。

  1. <?php
  2. $array  = array(
  3.      "foo"  =>  "bar" ,
  4.      "bar"  =>  "foo" ,
  5. );
  7. // 自 PHP 5.4 起
  8. $array  = [
  9.      "foo"  =>  "bar" ,
  10.      "bar"  =>  "foo" ,
  11. ];
  12. ?>

key 可以是 integer 或者 string 。value 可以是任意类型。
此外 key 会有如下的强制转换：

  • 包含有合法整型值的字符串会被转换为整型。例如键名 “8” 实际会被储存为 8。但是 “08” 则不会强制转换，因为其不是一个合法的十进制数值。
  • 浮点数也会被转换为整型，意味着其小数部分会被舍去。例如键名 8.7 实际会被储存为 8。
  • 布尔值也会被转换成整型。即键名 true 实际会被储存为 1 而键名 false 会被储存为 0。
  • Null 会被转换为空字符串，即键名 null 实际会被储存为 “”。
  • 数组和对象不能被用为键名。坚持这么做会导致警告：Illegal offset type。

如果在数组定义中多个单元都使用了同一个键名，则只使用了最后一个，之前的都被覆盖了。

  1. <?php
  2. $array  = array(
  3.      1     =>  "a" ,
  4.      "1"   =>  "b" ,
  5.      1.5   =>  "c" ,
  6.      true  =>  "d" ,
  7. );
  8. var_dump ( $array );
  9. ?>

以上例程会输出：
array(1) { [1]=> string(1) “d” }
上例中所有的键名都被强制转换为 1，则每一个新单元都会覆盖前一个的值，最后剩下的只有一个 “d”。
PHP 数组可以同时含有 integer 和 string 类型的键名，因为 PHP 实际并不区分索引数组和关联数组。
如果对给出的值没有指定键名，则取当前最大的整数索引值，而新的键名将是该值加一。如果指定的键名已经有了值，则该值会被覆盖。

  1. <?php
  2. $array  = array(
  3.      "foo"  =>  "bar" ,
  4.      "bar"  =>  "foo" ,
  5.      100    => - 100 ,
  6.     - 100   =>  100 ,
  7. );
  8. var_dump ( $array );
  9. ?>

以上例程会输出：

  1. array(4) {
  2.   ["foo"]=>
  3.   string(3) "bar"
  4.   ["bar"]=>
  5.   string(3) "foo"
  6.   [100]=>
  7.   int(-100)
  8.   [-100]=>
  9.   int(100)
  10. }

key 为可选项。如果未指定，PHP 将自动使用之前用过的最大 integer 键名加上 1 作为新的键名。

  1. <?php
  2. $array  = array( "foo" ,  "bar" ,  "hallo" ,  "world" );
  3. var_dump ( $array );
  4. ?>

以上例程会输出：

  1. array(4) {
  2.   [0]=>
  3.   string(3) "foo"
  4.   [1]=>
  5.   string(3) "bar"
  6.   [2]=>
  7.   string(5) "hallo"
  8.   [3]=>
  9.   string(5) "world"
  10. }

还可以只对某些单元指定键名而对其它的空置：

  1. <?php
  2. $array  = array(
  3.           "a" ,
  4.           "b" ,
  5.      6  =>  "c" ,
  6.           "d" ,
  7. );
  8. var_dump ( $array );
  9. ?>

以上例程会输出：

  1. array(4) {
  2.   [0]=>
  3.   string(1) "a"
  4.   [1]=>
  5.   string(1) "b"
  6.   [6]=>
  7.   string(1) "c"
  8.   [7]=>
  9.   string(1) "d"
  10. }

可以看到最后一个值 “d” 被自动赋予了键名 7。这是由于之前最大的整数键名是 6。

用方括号语法访问数组单元

数组单元可以通过 array[key] 语法来访问。

  1. <?php
  2. $array  = array(
  3.      "foo"  =>  "bar" ,
  4.      42     =>  24 ,
  5.      "multi"  => array(
  6.           "dimensional"  => array(
  7.               "array"  =>  "foo"
  8.           )
  9.     )
  10. );
  12. var_dump ( $array [ "foo" ]);
  13. var_dump ( $array [ 42 ]);
  14. var_dump ( $array [ "multi" ][ "dimensional" ][ "array" ]);
  15. ?>

以上例程会输出：

  1. string(3) "bar"
  2. int(24)
  3. string(3) "foo"

Note:
方括号和花括号可以互换使用来访问数组单元（例如 $array[42] 和 $array{42} 在上例中效果相同）。
自 PHP 5.4 起可以用数组间接引用函数或方法调用的结果。之前只能通过一个临时变量。
自 PHP 5.5 起可以用数组间接引用一个数组原型。
Example #7 数组间接引用

  1. <?php
  2. function  getArray () {
  3.     return array( 1 ,  2 ,  3 );
  4. }
  6. // on PHP 5.4
  7. $secondElement  =  getArray ()[ 1 ];
  9. // previously
  10. $tmp  =  getArray ();
  11. $secondElement  =  $tmp [ 1 ];
  13. // or
  14. list(,  $secondElement ) =  getArray ();
  15. ?>

Note:
试图访问一个未定义的数组键名与访问任何未定义变量一样：会导致 E_NOTICE 级别错误信息，其结果为 NULL 。

用方括号的语法新建／修改

可以通过明示地设定其中的值来修改一个已有数组。
这是通过在方括号内指定键名来给数组赋值实现的。也可以省略键名，在这种情况下给变量名加上一对空的方括号（[]）。
$arr[key] = value; $arr[] = value; // key 可以是 integer 或 string // value 可以是任意类型的值
如果 $arr 还不存在，将会新建一个，这也是另一种新建数组的方法。不过并不鼓励这样做，因为如果 $arr 已经包含有值（例如来自请求变量的 string ）则此值会保留而 [] 实际上代表着字符串访问运算符。初始化变量的最好方式是直接给其赋值。。
要修改某个值，通过其键名给该单元赋一个新值。要删除某键值对，对其调用 unset() 函数。

  1. <?php
  2. $arr  = array( 5  =>  1 ,  12  =>  2 );
  4. $arr [] =  56 ;     // This is the same as $arr[13] = 56;
  5.                 // at this point of the script
  7. $arr [ "x" ] =  42 ;  // This adds a new element to
  8.                 // the array with key "x"
  10. unset( $arr [ 5 ]);  // This removes the element from the array
  12. unset( $arr );     // This deletes the whole array
  13. ?>


Note:
如上所述，如果给出方括号但没有指定键名，则取当前最大整数索引值，新的键名将是该值加上 1（但是最小为 0）。如果当前还没有整数索引，则键名将为 0。
注意这里所使用的最大整数键名不一定当前就在数组中。它只要在上次数组重新生成索引后曾经存在过就行了。以下面的例子来说明：

  1. <?php
  2. // 创建一个简单的数组
  3. $array  = array( 1 ,  2 ,  3 ,  4 ,  5 );
  4. print_r ( $array );
  6. // 现在删除其中的所有元素，但保持数组本身不变:
  7. foreach ( $array  as  $i  =>  $value ) {
  8.     unset( $array [ $i ]);
  9. }
  10. print_r ( $array );
  12. // 添加一个单元（注意新的键名是 5，而不是你可能以为的 0）
  13. $array [] =  6 ;
  14. print_r ( $array );
  16. // 重新索引：
  17. $array  =  array_values ( $array );
  18. $array [] =  7 ;
  19. print_r ( $array );
  20. ?>

以上例程会输出：

  1. Array
  2. (
  3.     [0] => 1
  4.     [1] => 2
  5.     [2] => 3
  6.     [3] => 4
  7.     [4] => 5
  8. )
  9. Array
  10. (
  11. )
  12. Array
  13. (
  14.     [5] => 6
  15. )
  16. Array
  17. (
  18.     [0] => 6
  19.     [1] => 7
  20. )

实用函数

有很多操作数组的函数，参见数组函数一节。
Note:
unset() 函数允许删除数组中的某个键。但要注意数组将不会重建索引。如果需要删除后重建索引，可以用 array_values()函数。

  1. <?php
  2. $a  = array( 1  =>  'one' ,  2  =>  'two' ,  3  =>  'three' );
  3. unset( $a [ 2 ]);
  4. /* will produce an array that would have been defined as
  5.    $a = array(1 => 'one', 3 => 'three');
  6.    and NOT
  7.    $a = array(1 => 'one', 2 =>'three');
  8. */
  10. $b  =  array_values ( $a );
  11. // Now $b is array(0 => 'one', 1 =>'three')
  12. ?>

foreach 控制结构是专门用于数组的。它提供了一个简单的方法来遍历数组。

数组做什么和不做什么

为什么 $foo[bar] 错了？

应该始终在用字符串表示的数组索引上加上引号。例如用 $foo[‘bar’] 而不是 $foo[bar]。但是为什么呢？可能在老的脚本中见过如下语法：

  1. <?php
  2. $foo [ bar ] =  'enemy' ;
  3. echo  $foo [ bar ];
  4. // etc
  5. ?>

这样是错的，但可以正常运行。那么为什么错了呢？原因是此代码中有一个未定义的常量（bar）而不是字符串（’bar’－注意引号），而 PHP 可能会在以后定义此常量，不幸的是你的代码中有同样的名字。它能运行，是因为 PHP 自动将裸字符串（没有引号的字符串且不对应于任何已知符号）转换成一个其值为该裸字符串的正常字符串。例如，如果没有常量定义为 bar ，PHP 将把它替代为 ‘bar’ 并使用之。
Note: 这并不意味着总是给键名加上引号。用不着给键名为常量或变量的加上引号，否则会使 PHP 不能解析它们。

  1. <?php
  2. error_reporting ( E_ALL );
  3. ini_set ( 'display_errors' ,  true );
  4. ini_set ( 'html_errors' ,  false );
  5. // Simple array:
  6. $array  = array( 1 ,  2 );
  7. $count  =  count ( $array );
  8. for ( $i  =  0 ;  $i  <  $count ;  $i ++) {
  9.     echo  "\nChecking  $i : \n" ;
  10.     echo  "Bad: "  .  $array [ '$i' ] .  "\n" ;
  11.     echo  "Good: "  .  $array [ $i ] .  "\n" ;
  12.     echo  "Bad:  { $array [ '$i' ]} \n" ;
  13.     echo  "Good:  { $array [ $i ]} \n" ;
  14. }
  15. ?>

以上例程会输出：

  1. Checking 0: 
  2. Notice: Undefined index:  $i in /path/to/script.html on line 9
  3. Bad: 
  4. Good: 1
  5. Notice: Undefined index:  $i in /path/to/script.html on line 11
  6. Bad: 
  7. Good: 1Checking 1: 
  8. Notice: Undefined index:  $i in /path/to/script.html on line 9
  9. Bad: 
  10. Good: 2
  11. Notice: Undefined index:  $i in /path/to/script.html on line 11
  12. Bad: 
  13. Good: 2


演示此行为的更多例子：

  1. <?php
  2. // Show all errors
  3. error_reporting ( E_ALL );
  5. $arr  = array( 'fruit'  =>  'apple' ,  'veggie'  =>  'carrot' );
  7. // Correct
  8. print  $arr [ 'fruit' ];   // apple
  9. print  $arr [ 'veggie' ];  // carrot
  11. // Incorrect.  This works but also throws a PHP error of level E_NOTICE because
  12. // of an undefined constant named fruit
  13. // 
  14. // Notice: Use of undefined constant fruit - assumed 'fruit' in...
  15. print  $arr [ fruit ];     // apple
  17. // This defines a constant to demonstrate what's going on.  The value 'veggie'
  18. // is assigned to a constant named fruit.
  19. define ( 'fruit' ,  'veggie' );
  21. // Notice the difference now
  22. print  $arr [ 'fruit' ];   // apple
  23. print  $arr [ fruit ];     // carrot
  25. // The following is okay, as it's inside a string. Constants are not looked for
  26. // within strings, so no E_NOTICE occurs here
  27. print  "Hello  $arr [ fruit ] " ;       // Hello apple
  29. // With one exception: braces surrounding arrays within strings allows constants
  30. // to be interpreted
  31. print  "Hello  { $arr [ fruit ]} " ;     // Hello carrot
  32. print  "Hello  { $arr [ 'fruit' ]} " ;   // Hello apple
  34. // This will not work, and will result in a parse error, such as:
  35. // Parse error: parse error, expecting T_STRING' or T_VARIABLE' or T_NUM_STRING'
  36. // This of course applies to using superglobals in strings as well
  37. print  "Hello  $arr [ 'fruit']" ;
  38. print  "Hello  $_GET [ 'foo']" ;
  40. // Concatenation is another option
  41. print  "Hello "  .  $arr [ 'fruit' ];  // Hello apple
  42. ?>


当打开 errorreporting 来显示 E_NOTICE 级别的错误（将其设为 E_ALL ）时将看到这些错误。默认情况下error_reporting 被关闭不显示这些。
和在语法一节中规定的一样，在方括号（“[”和“]_”）之间必须有一个表达式。这意味着可以这样写：

  1. <?php
  2. echo  $arr [ somefunc ( $bar )];
  3. ?>

这是一个用函数返回值作为数组索引的例子。PHP 也可以用已知常量，可能之前已经见过：

  1. <?php
  2. $error_descriptions [ E_ERROR ]   =  "A fatal error has occured" ;
  3. $error_descriptions [ E_WARNING ] =  "PHP issued a warning" ;
  4. $error_descriptions [ E_NOTICE ]  =  "This is just an informal notice" ;
  5. ?>

注意 E_ERROR 也是个合法的标识符，就和第一个例子中的 bar 一样。但是上一个例子实际上和如下写法是一样的：

  1. <?php
  2. $error_descriptions [ 1 ] =  "A fatal error has occured" ;
  3. $error_descriptions [ 2 ] =  "PHP issued a warning" ;
  4. $error_descriptions [ 8 ] =  "This is just an informal notice" ;
  5. ?>

因为 E_ERROR 等于 1，等等。

那么为什么这样做不好？


也许有一天，PHP 开发小组可能会想新增一个常量或者关键字，或者用户可能希望以后在自己的程序中引入新的常量，那就有麻烦了。例如已经不能这样用 empty 和 default 这两个词了，因为他们是保留字。

Note: 重申一次，在双引号字符串中，不给索引加上引号是合法的因此 “$foo[bar]” 是合法的（“合法”的原文为 valid。在实际测试中，这么做确实可以访问数组的该元素，但是会报一个常量未定义的 notice。无论如何，强烈建议不要使用 $foo[bar]这样的写法，而要使用 $foo[‘bar’] 来访问数组中元素。—haohappy 注）。至于为什么参见以上的例子和字符串中的变量解析中的解释。

转换为数组


对于任意 integer ， float ， string ， boolean 和 resource 类型，如果将一个值转换为数组，将得到一个仅有一个元素的数组，其下标为 0，该元素即为此标量的值。换句话说，(array)$scalarValue 与 array($scalarValue) 完全一样。
如果一个 object 类型转换为 array ，则结果为一个数组，其单元为该对象的属性。键名将为成员变量名，不过有几点例外：整数属性不可访问；私有变量前会加上类名作前缀；保护变量前会加上一个 ‘*’ 做前缀。这些前缀的前后都各有一个 NULL 字符。这会导致一些不可预知的行为：

  1. <?php
  3. class  A  {
  4.     private  $A ;  // This will become '\0A\0A'
  5. }
  7. class  B  extends  A  {
  8.     private  $A ;  // This will become '\0B\0A'
  9.      public  $AA ;  // This will become 'AA'
  10. }
  12. var_dump ((array) new  B ());
  13. ?>

上例会有两个键名为 ‘AA’，不过其中一个实际上是 ‘\0A\0A’。
将 NULL 转换为 array 会得到一个空的数组。

比较

可以用 array_diff() 和数组运算符来比较数组。

示例

PHP 中的数组类型有非常多的用途。以下是一些示例：

  1. <?php
  2. // This:
  3. $a  = array(  'color'  =>  'red' ,
  4.              'taste'  =>  'sweet' ,
  5.              'shape'  =>  'round' ,
  6.              'name'   =>  'apple' ,
  7.              4         // key will be 0
  8.            );
  10. $b  = array( 'a' ,  'b' ,  'c' );
  12. // . . .is completely equivalent with this:
  13. $a  = array();
  14. $a [ 'color' ] =  'red' ;
  15. $a [ 'taste' ] =  'sweet' ;
  16. $a [ 'shape' ] =  'round' ;
  17. $a [ 'name' ]  =  'apple' ;
  18. $a []        =  4 ;         // key will be 0
  20. $b  = array();
  21. $b [] =  'a' ;
  22. $b [] =  'b' ;
  23. $b [] =  'c' ;
  25. // After the above code is executed, $a will be the array
  26. // array('color' => 'red', 'taste' => 'sweet', 'shape' => 'round', 
  27. // 'name' => 'apple', 0 => 4), and $b will be the array 
  28. // array(0 => 'a', 1 => 'b', 2 => 'c'), or simply array('a', 'b', 'c').
  29. ?>

Example #8 使用 array()

  1. <?php
  2. // Array as (property-)map
  3. $map  = array(  'version'     =>  4 ,
  4.                'OS'          =>  'Linux' ,
  5.                'lang'        =>  'english' ,
  6.                'short_tags'  =>  true
  7.              );
  9. // strictly numerical keys
  10. $array  = array(  7 ,
  11.                  8 ,
  12.                  0 ,
  13.                  156 ,
  14.                 - 10
  15.                );
  16. // this is the same as array(0 => 7, 1 => 8, ...)
  18. $switching  = array(          10 ,  // key = 0
  19.                      5     =>   6 ,
  20.                      3     =>   7 , 
  21.                      'a'   =>   4 ,
  22.                              11 ,  // key = 6 (maximum of integer-indices was 5)
  23.                      '8'   =>   2 ,  // key = 8 (integer!)
  24.                      '02'  =>  77 ,  // key = '02'
  25.                      0     =>  12   // the value 10 will be overwritten by 12
  26.                    );
  28. // empty array
  29. $empty  = array();         
  30. ?>

Example #9 集合

  1. <?php
  2. $colors  = array( 'red' ,  'blue' ,  'green' ,  'yellow' );
  4. foreach ( $colors  as  $color ) {
  5.     echo  "Do you like  $color ?\n" ;
  6. }
  8. ?>

以上例程会输出：

  1. Do you like red?
  2. Do you like blue?
  3. Do you like green?
  4. Do you like yellow?

直接改变数组的值自 PHP 5 起可以通过引用传递来做到。之前的版本需要需要采取变通的方法：
Example #10 在循环中改变单元

  1. <?php
  2. // PHP 5
  3. foreach ( $colors  as & $color ) {
  4.      $color  =  strtoupper ( $color );
  5. }
  6. unset( $color );  /* ensure that following writes to
  7. $color will not modify the last array element */
  9. // Workaround for older versions
  10. foreach ( $colors  as  $key  =>  $color ) {
  11.      $colors [ $key ] =  strtoupper ( $color );
  12. }
  14. print_r ( $colors );
  15. ?>

以上例程会输出：

  1. Array
  2. (
  3.     [0] => RED
  4.     [1] => BLUE
  5.     [2] => GREEN
  6.     [3] => YELLOW
  7. )

本例生成一个下标从 1 开始的数组。
Example #11 下标从 1 开始的数组
<?php
$firstquarter = array( 1 => ‘January’ , ‘February’ , ‘March’ );
print_r ( $firstquarter );
?>
以上例程会输出：

  1. Array 
  2. (
  3.     [1] => 'January'
  4.     [2] => 'February'
  5.     [3] => 'March'
  6. )

Example #12 填充数组

  1. <?php
  2. // fill an array with all items from a directory
  3. $handle  =  opendir ( '.' );
  4. while ( false  !== ( $file  =  readdir ( $handle ))) {
  5.      $files [] =  $file ;
  6. }
  7. closedir ( $handle ); 
  8. ?>

数组是有序的。也可以使用不同的排序函数来改变顺序。更多信息参见数组函数。可以用 count() 函数来数出数组中元素的个数。
Example #13 数组排序

  1. <?php
  2. sort ( $files );
  3. print_r ( $files );
  4. ?>

因为数组中的值可以为任意值，也可是另一个数组。这样可以产生递归或多维数组。
Example #14 递归和多维数组

  1. <?php
  2. $fruits  = array (  "fruits"   => array (  "a"  =>  "orange" ,
  3.                                         "b"  =>  "banana" ,
  4.                                         "c"  =>  "apple"
  5.                                       ),
  6.                    "numbers"  => array (  1 ,
  7.                                         2 ,
  8.                                         3 ,
  9.                                         4 ,
  10.                                         5 ,
  11.                                         6
  12.                                       ),
  13.                    "holes"    => array (       "first" ,
  14.                                         5  =>  "second" ,
  15.                                              "third"
  16.                                       )
  17.                 );
  19. // Some examples to address values in the array above 
  20. echo  $fruits [ "holes" ][ 5 ];     // prints "second"
  21. echo  $fruits [ "fruits" ][ "a" ];  // prints "orange"
  22. unset( $fruits [ "holes" ][ 0 ]);   // remove "first"
  24. // Create a new multi-dimensional array
  25. $juices [ "apple" ][ "green" ] =  "good" ; 
  26. ?>

数组(Array) 的赋值总是会涉及到值的拷贝。使用引用运算符通过引用来拷贝数组。

  1. <?php
  2. $arr1  = array( 2 ,  3 );
  3. $arr2  =  $arr1 ;
  4. $arr2 [] =  4 ;  // $arr2 is changed,
  5.              // $arr1 is still array(2, 3)
  7. $arr3  = & $arr1 ;
  8. $arr3 [] =  4 ;  // now $arr1 and $arr3 are the same
  9. ?>