• 首页
  • vue
  • TypeScript
  • JavaScript
  • scss
  • css3
  • html5
  • php
  • MySQL
  • redis
  • jQuery
  • Array 数组

    PHP 中的数组实际上是一个有序映射。映射是一种把values关联到keys的类型。此类型在很多方面做了优化,因此可以把它当成真正的数组,或列表(向量),散列表(是映射的一种实现),字典,集合,栈,队列以及更多可能性。由于数组元素的值也可以是另一个数组,树形结构和多维数组也是允许的。

    解释这些结构超出了本手册的范围,但对于每种结构至少会提供一个例子。要得到这些结构的更多信息,建议参考有关此广阔主题的其它著作。

    语法

    定义数组array()

    可以用array()语言结构来新建一个数组。它接受任意数量用逗号分隔的键(key)=>值(value)对。

    array(  key =>  value     , ...
         )
    // 键(key)可是是一个整数 integer 或字符串 string// 值(value)可以是任意类型的值

    最后一个数组单元之后的逗号可以省略。通常用于单行数组定义中,例如常用array(1, 2)而不是array(1, 2,)。对多行数组定义通常保留最后一个逗号,这样要添加一个新单元时更方便。

    自 5.4 起可以使用短数组定义语法,用[]替代array()

    Example #1 一个简单数组

    <?php
    $array = array(
        "foo" => "bar",
        "bar" => "foo",
    );
    // 自 PHP 5.4 起
    $array = [
        "foo" => "bar",
        "bar" => "foo",
    ];
    ?>
    

    key可以是integer或者string。value可以是任意类型。

    此外key会有如下的强制转换:

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

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

    Example #2 类型强制与覆盖示例

    <?php
    $array = array(
        1    => "a",
        "1"  => "b",
        1.5  => "c",
        true => "d",
    );
    var_dump($array);
    ?>
    

    以上例程会输出:

    array(1) {
      [1]=>
      string(1) "d"
    }
    

    上例中所有的键名都被强制转换为1,则每一个新单元都会覆盖前一个的值,最后剩下的只有一个"d"

    PHP 数组可以同时含有integer和string类型的键名,因为 PHP 实际并不区分索引数组和关联数组。

    如果对给出的值没有指定键名,则取当前最大的整数索引值,而新的键名将是该值加一。如果指定的键名已经有了值,则该值会被覆盖。

    Example #3 混合integer和string键名

    <?php
    $array = array(
        "foo" => "bar",
        "bar" => "foo",
        100   => -100,
        -100  => 100,
    );
    var_dump($array);
    ?>
    

    以上例程会输出:

    array(4) {
      ["foo"]=>
      string(3) "bar"
      ["bar"]=>
      string(3) "foo"
      [100]=>
      int(-100)
      [-100]=>
      int(100)
    }
    

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

    Example #4 没有键名的索引数组

    <?php
    $array = array("foo", "bar", "hallo", "world");
    var_dump($array);
    ?>
    

    以上例程会输出:

    array(4) {
      [0]=>
      string(3) "foo"
      [1]=>
      string(3) "bar"
      [2]=>
      string(5) "hallo"
      [3]=>
      string(5) "world"
    }
    

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

    Example #5 仅对部分单元指定键名

    <?php
    $array = array(
             "a",
             "b",
        6 => "c",
             "d",
    );
    var_dump($array);
    ?>
    

    以上例程会输出:

    array(4) {
      [0]=>
      string(1) "a"
      [1]=>
      string(1) "b"
      [6]=>
      string(1) "c"
      [7]=>
      string(1) "d"
    }
    

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

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

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

    Example #6 访问数组单元

    <?php
    $array = array(
        "foo" => "bar",
        42    => 24,
        "multi" => array(
             "dimensional" => array(
                 "array" => "foo"
             )
        )
    );
    var_dump($array["foo"]);
    var_dump($array[42]);
    var_dump($array["multi"]["dimensional"]["array"]);
    ?>
    

    以上例程会输出:

    string(3) "bar"
    int(24)
    string(3) "foo"
    
    Note:

    方括号和花括号可以互换使用来访问数组单元(例如$array[42]和$array{42}在上例中效果相同)。

    自 PHP 5.4 起可以用直接对函数或方法调用的结果进行数组解引用,在此之前只能通过一个临时变量。

    自 PHP 5.5 起可以直接对一个数组原型进行数组解引用。

    Example #7 数组解引用

    <?php
    function getArray() {
        return array(1, 2, 3);
    }
    // on PHP 5.4
    $secondElement = getArray()[1];
    // previously
    $tmp = getArray();
    $secondElement = $tmp[1];
    // or
    list(, $secondElement) = getArray();
    ?>
    
    Note:

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

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

    可以通过明示地设定其中的值来修改一个已有数组。

    这是通过在方括号内指定键名来给数组赋值实现的。也可以省略键名,在这种情况下给变量名加上一对空的方括号([])。

    $arr[key] = value;
    $arr[] = value;
    // key 可以是 integer 或 string// value 可以是任意类型的值

    如果$arr还不存在,将会新建一个,这也是另一种新建数组的方法。不过并不鼓励这样做,因为如果$arr已经包含有值(例如来自请求变量的string)则此值会保留而[]实际上代表着字符串访问运算符。初始化变量的最好方式是直接给其赋值。。

    要修改某个值,通过其键名给该单元赋一个新值。要删除某键值对,对其调用unset()函数。

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

    Note:

    如上所述,如果给出方括号但没有指定键名,则取当前最大整数索引值,新的键名将是该值加上 1(但是最小为 0)。如果当前还没有整数索引,则键名将为0

    注意这里所使用的最大整数键名不一定当前就在数组中。它只要在上次数组重新生成索引后曾经存在过就行了。以下面的例子来说明:

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

    以上例程会输出:

    Array ( [0] => 1 [1] => 2 [2] => 3 [3] => 4 [4] => 5 ) Array ( ) Array ( [5] => 6 ) Array ( [0] => 6 [1] => 7 )

    实用函数

    有很多操作数组的函数,参见数组函数一节。

    Note:

    unset()函数允许删除数组中的某个键。但要注意数组将不会重建索引。如果需要删除后重建索引,可以用array_values()函数。

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

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

    数组做什么和不做什么

    为什么$foo[bar]错了?

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

    <?php
    $foo[bar] = 'enemy';
    echo $foo[bar];
    // etc
    ?>
    

    这样是错的,但可以正常运行。那么为什么错了呢?原因是此代码中有一个未定义的常量(bar)而不是字符串('bar'-注意引号),而 PHP 可能会在以后定义此常量,不幸的是你的代码中有同样的名字。它能运行,是因为 PHP 自动将裸字符串(没有引号的字符串且不对应于任何已知符号)转换成一个其值为该裸字符串的正常字符串。例如,如果没有常量定义为bar,PHP 将把它替代为'bar'并使用之。

    Note:这并不意味着总是给键名加上引号。用不着给键名为常量或变量的加上引号,否则会使 PHP 不能解析它们。<?php error_reporting(E_ALL); ini_set('display_errors', true); ini_set('html_errors', false); // Simple array: $array = array(1, 2); $count = count($array); for ($i = 0; $i < $count; $i++) { echo "\nChecking $i: \n"; echo "Bad: " . $array['$i'] . "\n"; echo "Good: " . $array[$i] . "\n"; echo "Bad: {$array['$i']}\n"; echo "Good: {$array[$i]}\n"; } ?>

    以上例程会输出:

    Checking 0: Notice: Undefined index: $i in /path/to/script.html on line 9 Bad: Good: 1 Notice: Undefined index: $i in /path/to/script.html on line 11 Bad: Good: 1 Checking 1: Notice: Undefined index: $i in /path/to/script.html on line 9 Bad: Good: 2 Notice: Undefined index: $i in /path/to/script.html on line 11 Bad: Good: 2

    演示此行为的更多例子:

    <?php
    // Show all errors
    error_reporting(E_ALL);
    $arr = array('fruit' => 'apple', 'veggie' => 'carrot');
    // Correct
    print $arr['fruit'];  // apple
    print $arr['veggie']; // carrot
    // Incorrect.  This works but also throws a PHP error of level E_NOTICE because
    // of an undefined constant named fruit
    // 
    // Notice: Use of undefined constant fruit - assumed 'fruit' in...
    print $arr[fruit];    // apple
    // This defines a constant to demonstrate what's going on.  The value 'veggie'
    // is assigned to a constant named fruit.
    define('fruit', 'veggie');
    // Notice the difference now
    print $arr['fruit'];  // apple
    print $arr[fruit];    // carrot
    // The following is okay, as it's inside a string. Constants are not looked for
    // within strings, so no E_NOTICE occurs here
    print "Hello $arr[fruit]";      // Hello apple
    // With one exception: braces surrounding arrays within strings allows constants
    // to be interpreted
    print "Hello {$arr[fruit]}";    // Hello carrot
    print "Hello {$arr['fruit']}";  // Hello apple
    // This will not work, and will result in a parse error, such as:
    // Parse error: parse error, expecting T_STRING' or T_VARIABLE' or T_NUM_STRING'
    // This of course applies to using superglobals in strings as well
    print "Hello $arr['fruit']";
    print "Hello $_GET['foo']";
    // Concatenation is another option
    print "Hello " . $arr['fruit']; // Hello apple
    ?>
    

    当打开error_reporting来显示E_NOTICE级别的错误(将其设为E_ALL)时将看到这些错误。默认情况下error_reporting被关闭不显示这些。

    和在语法一节中规定的一样,在方括号(“[”和“]”)之间必须有一个表达式。这意味着可以这样写:

    <?php
    echo $arr[somefunc($bar)];
    ?>
    

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

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

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

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

    因为E_ERROR等于1,等等。

    那么为什么这样做不好?

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

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

    转换为数组

    对于任意integer,float,string,boolean和resource类型,如果将一个值转换为数组,将得到一个仅有一个元素的数组,其下标为 0,该元素即为此标量的值。换句话说,(array)$scalarValuearray($scalarValue)完全一样。

    如果一个object类型转换为array,则结果为一个数组,其单元为该对象的属性。键名将为成员变量名,不过有几点例外:整数属性不可访问;私有变量前会加上类名作前缀;保护变量前会加上一个'*'做前缀。这些前缀的前后都各有一个 NULL 字符。这会导致一些不可预知的行为:

    <?php
    class A {
        private $A; // This will become '\0A\0A'
    }
    class B extends A {
        private $A; // This will become '\0B\0A'
        public $AA; // This will become 'AA'
    }
    var_dump((array) new B());
    ?>
    

    上例会有两个键名为'AA',不过其中一个实际上是'0A0A'。

    NULL转换为array会得到一个空的数组。

    比较

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

    示例

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

    <?php
    // This:
    $a = array( 'color' => 'red',
                'taste' => 'sweet',
                'shape' => 'round',
                'name'  => 'apple',
                4        // key will be 0
              );
    $b = array('a', 'b', 'c');
    // . . .is completely equivalent with this:
    $a = array();
    $a['color'] = 'red';
    $a['taste'] = 'sweet';
    $a['shape'] = 'round';
    $a['name']  = 'apple';
    $a[]        = 4;        // key will be 0
    $b = array();
    $b[] = 'a';
    $b[] = 'b';
    $b[] = 'c';
    // After the above code is executed, $a will be the array
    // array('color' => 'red', 'taste' => 'sweet', 'shape' => 'round', 
    // 'name' => 'apple', 0 => 4), and $b will be the array 
    // array(0 => 'a', 1 => 'b', 2 => 'c'), or simply array('a', 'b', 'c').
    ?>
    

    Example #8 使用 array()

    <?php
    // Array as (property-)map
    $map = array( 'version'    => 4,
                  'OS'         => 'Linux',
                  'lang'       => 'english',
                  'short_tags' => true
                );
                
    // strictly numerical keys
    $array = array( 7,
                    8,
                    0,
                    156,
                    -10
                  );
    // this is the same as array(0 => 7, 1 => 8, ...)
    $switching = array(         10, // key = 0
                        5    =>  6,
                        3    =>  7, 
                        'a'  =>  4,
                                11, // key = 6 (maximum of integer-indices was 5)
                        '8'  =>  2, // key = 8 (integer!)
                        '02' => 77, // key = '02'
                        0    => 12  // the value 10 will be overwritten by 12
                      );
                      
    // empty array
    $empty = array();         
    ?>
    

    Example #9 集合

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

    以上例程会输出:

    Do you like red?
    Do you like blue?
    Do you like green?
    Do you like yellow?
    

    直接改变数组的值自 PHP 5 起可以通过引用传递来做到。之前的版本需要需要采取变通的方法:

    Example #10 在循环中改变单元

    <?php
    // PHP 5
    foreach ($colors as &$color) {
        $color = strtoupper($color);
    }
    unset($color); /* ensure that following writes to
    $color will not modify the last array element */
    // Workaround for older versions
    foreach ($colors as $key => $color) {
        $colors[$key] = strtoupper($color);
    }
    print_r($colors);
    ?>
    

    以上例程会输出:

    Array
    (
        [0] => RED
        [1] => BLUE
        [2] => GREEN
        [3] => YELLOW
    )
    

    本例生成一个下标从 1 开始的数组。

    Example #11 下标从 1 开始的数组

    <?php
    $firstquarter  = array(1 => 'January', 'February', 'March');
    print_r($firstquarter);
    ?>
    

    以上例程会输出:

    Array 
    (
        [1] => 'January'
        [2] => 'February'
        [3] => 'March'
    )
    

    Example #12 填充数组

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

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

    Example #13 数组排序

    <?php
    sort($files);
    print_r($files);
    ?>
    

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

    Example #14 递归和多维数组

    <?php
    $fruits = array ( "fruits"  => array ( "a" => "orange",
                                           "b" => "banana",
                                           "c" => "apple"
                                         ),
                      "numbers" => array ( 1,
                                           2,
                                           3,
                                           4,
                                           5,
                                           6
                                         ),
                      "holes"   => array (      "first",
                                           5 => "second",
                                                "third"
                                         )
                    );
    // Some examples to address values in the array above 
    echo $fruits["holes"][5];    // prints "second"
    echo $fruits["fruits"]["a"]; // prints "orange"
    unset($fruits["holes"][0]);  // remove "first"
    // Create a new multi-dimensional array
    $juices["apple"]["green"] = "good"; 
    ?>
    

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

    <?php
    $arr1 = array(2, 3);
    $arr2 = $arr1;
    $arr2[] = 4; // $arr2 is changed,
                 // $arr1 is still array(2, 3)
                 
    $arr3 = &$arr1;
    $arr3[] = 4; // now $arr1 and $arr3 are the same
    ?>
    
    please note that when arrays are copied, the "reference status" of their members is preserved (http://www.php.net/manual/en/language.references.whatdo.php).
    I think your first, main example is needlessly confusing, very confusing to newbies:
    $array = array(
      "foo" => "bar",
      "bar" => "foo",
    );
    It should be removed.
     
    For newbies:
    An array index can be any string value, even a value that is also a value in the array. 
    The value of array["foo"] is "bar".
    The value of array["bar"] is "foo"
    The following expressions are both true:
    $array["foo"] == "bar"
    $array["bar"] == "foo"
    Beware that if you're using strings as indices in the $_POST array, that periods are transformed into underscores:
    <html>
    <body>
    <?php
      printf("POST: "); print_r($_POST); printf("<br/>");
    ?>
    <form method="post" action="<?php echo $_SERVER['PHP_SELF']; ?>">
      <input type="hidden" name="Windows3.1" value="Sux">
      <input type="submit" value="Click" />
    </form>
    </body>
    </html>
    Once you click on the button, the page displays the following:
    POST: Array ( [Windows3_1] => Sux )
    Since PHP 7.1, the string will not be converted to array automatically.
    Below codes will fail:
    $a=array();
    $a['a']='';
    $a['a']['b']=''; 
    //Warning: Illegal string offset 'b'
    //Warning: Cannot assign an empty string to a string offset
    You have to change to as below:
    $a=array();
    $a['a']=array(); // Declare it is an array first
    $a['a']['b']='';
    "If you convert a NULL value to an array, you get an empty array."
    This turns out to be a useful property. Say you have a search function that returns an array of values on success or NULL if nothing found.
    <?php $values = search(...); ?>
    Now you want to merge the array with another array. What do we do if $values is NULL? No problem:
    <?php $combined = array_merge((array)$values, $other); ?>
    Voila.
    Note that array value buckets are reference-safe, even through serialization.
    <?php
    $x='initial';
    $test=array('A'=>&$x,'B'=>&$x);
    $test=unserialize(serialize($test));
    $test['A']='changed';
    echo $test['B']; // Outputs "changed"
    ?>
    This can be useful in some cases, for example saving RAM within complex structures.
    //array keys are always integer and string data type and array values are all data type
    //type casting and overwriting(data type of array key)
    //----------------------------------------------------
    $arr = array(
    1=>"a",//int(1)
    "3"=>"b",//int(3)
    "08"=>"c",//string(2)"08"
    "80"=>"d",//int(80)
    "0"=>"e",//int(0)
    "Hellow"=>"f",//string(6)"Hellow"
    "10Hellow"=>"h",//string(8)"10Hellow"
    1.5=>"j",//int(1.5)
    "1.5"=>"k",//string(3)"1.5"
    0.0=>"l",//int(0)
    false=>"m",//int(false)
    true=>"n",//int(true)
    "true"=>"o",//string(4)"true"
    "false"=>"p",//string(5)"false"
    null=>"q",//string(0)""
    NULL=>"r",//string(0)"" note null and NULL are same
    "NULL"=>"s",//string(4)"NULL" ,,,In last element of multiline array,comma is better to used.
    );
    //check the data type name of key
    foreach ($arr as $key => $value) {
    var_dump($key);
    echo "<br>";
    }
    //NOte : array and object data type in keys are Illegal ofset.......
    --- quote ---
    Note:
    Both square brackets and curly braces can be used interchangeably for accessing array elements
    --- quote end ---
    At least for php 5.4 and 5.6; if function returns an array, the curly brackets does not work directly accessing function result, eg. WillReturnArray(){1} . This will give "syntax error, unexpected '{' in...".
    Personally I use only square brackets, expect for accessing single char in string. Old habits...
    Used to creating arrays like this in Perl?
    @array = ("All", "A".."Z");
    Looks like we need the range() function in PHP:
    <?php
    $array = array_merge(array('All'), range('A', 'Z'));
    ?>
    You don't need to array_merge if it's just one range:
    <?php
    $array = range('A', 'Z');
    ?>
    
    When creating arrays , if we have an element with the same value as another element from the same array, we would expect PHP instead of creating new zval container to increase the refcount and point the duplicate symbol to the same zval. This is true except for value type integer. 
    Example:
    $arr = ['bebe' => 'Bob', 'age' => 23, 'too' => 23 ];
    xdebug_debug_zval( 'arr' );
    Output:
    arr:
    (refcount=2, is_ref=0)
    array (size=3)
     'bebe' => (refcount=1, is_ref=0)string 'Bob' (length=3)
     'age' => (refcount=0, is_ref=0)int 23
     'too' => (refcount=0, is_ref=0)int 23
    but :
    $arr = ['bebe' => 'Bob', 'age' => 23, 'too' => '23' ];
    xdebug_debug_zval( 'arr' );
    will produce:
    arr:
    (refcount=2, is_ref=0)
    array (size=3)
     'bebe' => (refcount=1, is_ref=0)string 'Bob' (length=3)
     'age' => (refcount=0, is_ref=0)int 23
     'too' => (refcount=1, is_ref=0)string '23' (length=2)
    or :
    $arr = ['bebe' => 'Bob', 'age' => [1,2], 'too' => [1,2] ];
    xdebug_debug_zval( 'arr' );
    Output:
    arr:
    (refcount=2, is_ref=0)
    array (size=3)
     'bebe' => (refcount=1, is_ref=0)string 'Bob' (length=3)
     'age' => (refcount=2, is_ref=0)
      array (size=2)
       0 => (refcount=0, is_ref=0)int 1
       1 => (refcount=0, is_ref=0)int 2
     'too' => (refcount=2, is_ref=0)
      array (size=2)
       0 => (refcount=0, is_ref=0)int 1
       1 => (refcount=0, is_ref=0)int 2
    Regarding the previous comment, beware of the fact that reference to the last value of the array remains stored in $value after the foreach:
    <?php
    foreach ( $arr as $key => &$value )
    {
      $value = 1;
    }
    // without next line you can get bad results...
    //unset( $value );
    $value = 159;
    ?>
    Now the last element of $arr has the value of '159'. If we remove the comment in the unset() line, everything works as expected ($arr has all values of '1').
    Bad results can also appear in nested foreach loops (the same reason as above).
    So either unset $value after each foreach or better use the longer form:
    <?php
    foreach ( $arr as $key => $value )
    {
      $arr[ $key ] = 1;
    }
    ?>
    
    In array(key=>value) construct key is also an expression.
    This works fine:
     $a = array(
      1   =>0,
      1+1  =>1,
      $k  =>2,
      $x.'4'=>3
     );
    [Editor's note: You can achieve what you're looking for by referencing $single, rather than copying it by value in your foreach statement. See http://php.net/foreach for more details.]
    Don't know if this is known or not, but it did eat some of my time and maybe it won't eat your time now...
    I tried to add something to a multidimensional array, but that didn't work at first, look at the code below to see what I mean:
    <?php
    $a1 = array( "a" => 0, "b" => 1 );
    $a2 = array( "aa" => 00, "bb" => 11 );
    $together = array( $a1, $a2 );
    foreach( $together as $single ) {
      $single[ "c" ] = 3 ;
    }
    print_r( $together ); 
    /* nothing changed result is:
    Array
    (
      [0] => Array
        (
          [a] => 0
          [b] => 1
        )
      [1] => Array
        (
          [aa] => 0
          [bb] => 11
        )
    ) */
    foreach( $together as $key => $value ) {
      $together[$key]["c"] = 3 ;
    }
    print_r( $together );
    /* now it works, this prints
    Array
    (
      [0] => Array
        (
          [a] => 0
          [b] => 1
          [c] => 3
        )
      [1] => Array
        (
          [aa] => 0
          [bb] => 11
          [c] => 3
        )
    )
    */
    ?>
    
    There is another kind of array (php>= 5.3.0) produced by 
    $array = new SplFixedArray(5);
    Standard arrays, as documented here, are marvellously flexible and, due to the underlying hashtable, extremely fast for certain kinds of lookup operation. 
    Supposing a large string-keyed array 
    $arr=['string1'=>$data1, 'string2'=>$data2 etc....]
    when getting the keyed data with 
    $data=$arr['string1'];
    php does *not* have to search through the array comparing each key string to the given key ('string1') one by one, which could take a long time with a large array. Instead the hashtable means that php takes the given key string and computes from it the memory location of the keyed data, and then instantly retrieves the data. Marvellous! And so quick. And no need to know anything about hashtables as it's all hidden away.
    However, there is a lot of overhead in that. It uses lots of memory, as hashtables tend to (also nearly doubling on a 64bit server), and should be significantly slower for integer keyed arrays than old-fashioned (non-hashtable) integer-keyed arrays. For that see more on SplFixedArray :
    http://uk3.php.net/SplFixedArray
    Unlike a standard php (hashtabled) array, if you lookup by integer then the integer itself denotes the memory location of the data, no hashtable computation on the integer key needed. This is much quicker. It's also quicker to build the array compared to the complex operations needed for hashtables. And it uses a lot less memory as there is no hashtable data structure. This is really an optimisation decision, but in some cases of large integer keyed arrays it may significantly reduce server memory and increase performance (including the avoiding of expensive memory deallocation of hashtable arrays at the exiting of the script).
    Note that objects of classes extending ArrayObject SPL class are treated as arrays, and not as objects when converting to array.
    <?php
    class ArrayObjectExtended extends ArrayObject
    {
      private $private = 'private';
      public $hello = 'world';
    }
    $object = new ArrayObjectExtended();
    $array = (array) $object;
    // This will not expose $private and $hello properties of $object,
    // but return an empty array instead.
    var_export($array);
    ?>
    
    <?php
    function getArray() {
      return array(1, 2, 3);
    }
    // on PHP 5.4
    $secondElement = getArray()[1];
    // previously
    $tmp = getArray();
    $secondElement = $tmp[1];
    // or
    list(, $secondElement) = getArray();
    ?>
    Here list(, $secondElement) = getArray(); 
    and list($secondElement) = getArray(); is the same thing
    so you can avoid the "comma" to avoid the confusion.
    It is true that "array assignment always involves value copying", but the copy is a "lazy copy". This means that the data of the two variables occupy the same memory as long as no array element changes.
    E.g., if you have to pass an array to a function that only needs to read it, there is no advantage at all in passing it by reference.
    Wrappers for (array), returns array with normalize keys (without prefix):
    <?php
    function to_array_recursive($value): array
    {
        if (! is_object($value)) {
            return (array) $value;
        }
        $class = get_class($value);
        $arr = [];
        foreact ((array) $value as $key => $val) {
            $key = str_replace(["\0*\0", "\0{$class}\0"], '', $key);
            $arr[$key] = is_object($val) ? to_array_recursive($val) : $val;
        }
        return $arr;
    }
    function to_array($value): array
    {
        $arr = (array) $value;
        if (! is_object($value)) {
            return $arr;
        }
        $class = get_class($value);
        $keys = str_replace(["\0*\0", "\0{$class}\0"], '', array_keys($arr));
        return array_combine($keys, $arr);
    }
    ?>
    Demo:
    <?php
    class Test
    {
        protected $var = 1;
        protected $var2;
        private $TestVar = 3;
        
      public function __construct($isParent = true)
      {
        if ($isParent) {
          $this->var2 = new self(! $isParent);
        }
      }
    }
    $obj = new Test();
    var_dump((array) $obj, to_array_recursive($obj));
    ?>
    

    上篇:String 字符串

    下篇:Object 对象