PHP:数组-手册

阵列

安阵列PHP中实际上是一个有序映射。地图是一种联系值到钥匙。此类型针对多种不同用途进行了优化；它可以被视为数组，列表（向量）、散列表（映射的实现）、字典、，收集、堆栈、队列等。作为阵列值可以成为其他人阵列s、树与多维阵列秒也有可能。

这些数据结构的解释超出了本手册的范围，但为每个示例提供了至少一个示例。有关更多信息，请参阅针对这一广泛主题的大量文献。

语法

使用指定数组（）

安阵列可以使用数组（）语言结构。它需要任意数量的逗号分隔钥匙=>价值对作为参数。

阵列(钥匙=>价值,键2=>值2,键3=>值3,...)

最后一个数组元素后面的逗号是可选的，可以省略。通常会这样做对于单线阵列，即。数组（1,2）优先于数组（1，2，）。另一方面，对于多行数组，后面的逗号通常使用，因为它允许在末尾更容易地添加新元素。

注释:
存在替换的短数组语法数组（）具有[].

示例#1一个简单数组

<?php（电话）
$数组=数组(
    “foo”=>“酒吧”,
    “酒吧”=>“foo”,
);

//使用短数组语法
$数组= [
    “foo”=>“酒吧”,
    “酒吧”=>“foo”,
];
？>

这个钥匙可以是整数或一串. The价值可以是任何类型的。

此外，还包括以下内容钥匙将发生强制转换：

字符串s包含有效小数整数s、除非数字前面有+标志，将被投射到整数类型。例如，钥匙"8"实际上是存储在8另一方面"08"将不能强制转换，因为它不是有效的十进制整数。
浮子s也被强制转换为整数s、这意味着小数部分将被截断。例如，钥匙8.7实际上存放在8.
布尔s被强制转换为整数s、也就是钥匙真的将实际存储在1和钥匙假在下面0.
无效的将强制转换为空字符串，即键无效的将实际存储在"".
阵列s和对象秒不能用作钥匙。这样做将导致警告：偏移类型非法.

如果数组声明中的多个元素使用相同的键，则只使用最后一个将在覆盖所有其他内容时使用。

示例#2类型转换和覆盖示例

<?php（电话）
$数组=数组(
    1=>“a”,
    "1"=>“b”,
    1.5=>“c”,
    真的=>“d”,
);
变量转储($数组);
？>

上述示例将输出：

数组（1）{[1]=>字符串（1）“d”}

由于上述示例中的所有键都被强制转换为1，该值将被覆盖每个新元素和最后一个赋值“d”是唯一剩下的。

PHP数组可以包含整数和一串同时输入键因为PHP不区分索引数组和关联数组。

示例#3混合整数和一串钥匙

<?php（电话）
$数组=数组(
    “foo”=>“酒吧”,
    “酒吧”=>“foo”,
    100=> -100,
-100=>100,
);
变量转储($数组);
？>

上述示例将输出：

数组（4）{[“foo”]=>字符串（3）“bar”[“bar”]=>字符串（3）“foo”[100]=>整数（-100）[-100]=>整数（100）}

这个钥匙是可选的。如果未指定，PHP将使用以前使用的最大值的增量整数键。

示例#4无键的索引数组

<?php（电话）
$数组=数组(“foo”,“酒吧”,“你好”,“世界”);
变量转储($数组);
？>

上述示例将输出：

数组（4）{[0]=>字符串（3）“foo”[1]=>字符串（3）“bar”[2]=>字符串（5）“hello”[3]=>字符串（5）“世界”}

可以只为某些元素指定键，而不为其他元素指定键：

示例#5键不在所有元素上

<?php（电话）
$数组=数组(
         “a”,
         “b”,
    6=>“c”,
         “d”,
);
变量转储($数组);
？>

上述示例将输出：

数组（4）{[0]=>字符串（1）“a”[1]=>字符串（1）“b”[6]=>字符串（1）“c”[7]=>字符串（1）“d”}

正如您看到的最后一个值“d”被分配了钥匙7。这是因为之前的最大整数键是6.

示例#6复杂类型转换和覆盖示例

此示例包括键的类型转换和覆盖的所有变体元素的。

<?php（电话）
$数组=数组(
    1=>“a”,
    '1'=>“b”,//值“a”将被“b”覆盖
    1.5=>“c”,//值“b”将被“c”覆盖
    -1=>“d”,
    '01'=>“e”,//由于这不是整数字符串，因此不会覆盖1的键
    '1.5'=>“f”,//由于这不是整数字符串，因此不会覆盖1的键
    真的=>“g”,//值“c”将被“g”覆盖
    假=>“h”,
    ''=>“i”,
    无效的=>“j”,//值“i”将被“j”覆盖
    “k”,//值“k”被指定为键2。这是因为在此之前最大的整数键是1
    2=>“我”,//值“k”将被“l”覆盖
);

变量转储($数组);
？>

上述示例将输出：

数组（7）{[1]=>字符串（1）“g”[-1]=>字符串（1）“d”["01"]=>字符串（1）“e”["1.5"]=>字符串（1）“f”[0]=>字符串（1）“h”[“”]=>字符串（1）“j”[2]=>字符串（1）“l”}

使用方括号语法访问数组元素

可以使用数组[键]语法。

示例#7访问数组元素

<?php（电话）
$数组=数组(
    “foo”=>“酒吧”,
    42=>24,
    “多个”=>数组(
         “维度”=>数组(
             “数组”=>“foo”
         )
)
);

变量转储($数组[“foo”]);
变量转储($数组[42]);
变量转储($数组[“多个”][“维度”][“数组”]);
？>

上述示例将输出：

字符串（3）“bar”整数（24）字符串（3）“foo”

注释:
在PHP 8.0.0之前，方括号和花括号可以互换使用用于访问数组元素（例如。$数组[42]和$数组{42}都会在上面的示例中执行相同的操作）。从PHP 7.4.0开始，花括号语法已被弃用，从PHP 8.0.0开始不再受支持。

示例#8阵列取消引用

<?php（电话）
功能获取数组() {
返回数组(1,2,三);
}

$second元素=获取数组()[1];
？>

注释:
试图访问尚未定义的数组键是与访问任何其他未定义变量相同：一个E_警告-级别错误消息(E_通知-PHP 8.0.0之前的级别）将是发布，结果将为无效的.

注释:
数组取消引用不是一串产量无效的。在PHP 7.4.0之前，它没有发出错误消息。从PHP 7.4.0开始E_通知；从PHP 8.0.0开始，此问题E_警告.

使用方括号语法创建/修改

现有的阵列可以通过显式设置值进行修改在其中。

这是通过将值分配给阵列，指定在括号中键入。也可以省略该键，从而导致一对空的支架([]).

$arr（美元）[钥匙] =价值；$arr[]=价值；//钥匙可能是整数或一串//价值可以是任何类型的任何值

如果$arr（美元）尚不存在或设置为无效的或假，它将被创建，所以这是也是创建阵列。这种做法是然而，如果$arr（美元）已包含一些值（例如。一串从请求变量），则此价值将留在原处[]可能真的站着对于字符串访问操作人员。最好通过直接转让。

注释:从PHP7.1.0开始，对字符串应用空索引操作符会引发致命错误错误。以前，字符串被静默转换为数组。

注释:从PHP8.1.0开始，从假值已弃用。从创建新阵列无效的仍然允许使用未定义的值。

要更改特定值，使用其键为该元素指定一个新值。删除键/值对，调用取消设置（）功能。

<?php（电话）
$arr（美元）=数组(5=>1,12=>2);

$arr（美元）[] =56；//这与$arr[13]=56相同；
//在脚本的这一点上

$arr（美元）[“x”] =42；//这将向添加新元素
//键为“x”的数组
                
未设置($arr（美元）[5]);//这将从数组中删除元素

未设置($arr（美元）);//这将删除整个数组
？>

注释:
如上所述，如果未指定键，则现有整数索引，新的密钥将是最大值值加1（但至少为0）。如果没有整数指数仍然存在，关键是是0（零）。

请注意，用于此操作的最大整数键不需要当前存在于阵列.只需要有存在于阵列在上一次阵列重新诱导。以下示例说明了：
<?php（电话） //创建一个简单的数组。 $数组=数组(1,2,三,4,5); 打印（r）($数组); //现在删除所有项，但保持数组本身不变： foreach公司($数组作为1美元=>价值$){ 未设置($数组[1美元]); } 打印（r）($数组); //附加一个项（请注意，新键是5，而不是0）。 $数组[] =6；打印（r）($数组); //Re-index公司： $数组=数组_值($数组); $数组[] =7；打印（r）($数组); ？>

上述示例将输出：
阵列([0] => 1[1] => 2[2] => 3[3] => 4[4] => 5)阵列()阵列([5] => 6)阵列([0] => 6[1] => 7)

数组破坏

可以使用[]（截至PHP 7.1.0）或列表（）语言结构。这些构造可用于将数组分解为不同的变量。

<?php（电话）
$source_array（源阵列）= [“foo”,“bar”,“呸”];

[$foo美元,$巴,美元baz] =$source_array（源阵列）；

回声$foo美元；//打印“foo”
回声$巴；//打印“bar”
回声美元baz；//打印“baz”
？>

数组析构化可用于foreach公司破坏一个多维数组，同时对其进行迭代。

<?php（电话）
$source_array（源阵列）= [
[1,“约翰”],
[2,“简”],
];

foreach公司($source_array（源阵列）作为[$id美元,$名称]){
    //此处使用$id和$name的逻辑
}
？>

如果未提供变量，将忽略数组元素。阵列破坏总是从索引开始0.

<?php（电话）
$source_array（源阵列）= [“foo”,“bar”,“呸”];

//将索引2处的元素赋给变量$baz
[,美元baz] =$source_array（源阵列）；

回声美元baz；//打印“baz”
？>

从PHP7.1.0开始，关联数组也可以被破坏。这也是允许在数字索引中更容易地选择正确的元素数组作为索引可以显式指定。

<?php（电话）
$source_array（源阵列）= [“foo”=>1,“bar”=>2,“呸”=>三];

//将索引为“baz”的元素赋给变量$three
[“呸”=>三美元] =$source_array（源阵列）；

回声三美元；//打印3

$source_array（源阵列）= [“foo”,“bar”,“呸”];

//将索引2处的元素分配给变量$baz
[2=>美元baz] =$source_array（源阵列）；

回声美元baz；//打印“baz”
？>

数组析构化可用于轻松交换两个变量。

<?php（电话）
美元=1；
十亿美元=2；

[十亿美元,美元] = [美元,十亿美元];

回声美元；//打印2
回声十亿美元；//打印1
？>

注释:
扩散运算符(...)分配中不支持。

注释:
试图访问尚未定义的数组键是与访问任何其他未定义的变量相同：一个E_警告-电平错误消息(E_通知-PHP 8.0.0之前的级别）将是发布，结果将为无效的.

有用的功能

使用数组有很多有用的函数。请参阅数组函数第节。

注释:
这个取消设置（）函数允许从阵列。请注意阵列将不是重新编制索引。如果需要真正的“移除并移动”行为阵列可以使用数组值（）功能。

<?php（电话）美元=数组(1=>“一个”,2=>“两个”,三=>“三个”); 未设置(美元[2]); /*将生成一个定义为 $a=数组（1=>“一”，3=>“三”）；而不是 $a=数组（1=>“一”，2=>“三”）； */ 十亿美元=数组_值(美元); //现在$b是数组（0=>“one”，1=>“tree”）？>

这个foreach公司控制结构专门用于阵列s.它提供了一个简单的穿越阵列.

数组的注意事项

为什么是`$foo[bar]`错了吗？

始终在字符串文字数组索引周围使用引号。例如，$foo['bar']是正确的，而$foo[bar]不是。但为什么？遇到这种情况很常见旧脚本中的语法类型：

<?php（电话）
$foo美元[酒吧] =“敌人”；
回声$foo美元[酒吧];
//等
？>

这是错误的，但它有效。原因是此代码具有未定义的常数(酒吧)而不是一串(“bar”-请注意引号）。它之所以有效，是因为PHP自动转换裸串（未引用一串哪个是与任何已知符号不对应）转换为一串哪一个包含裸体一串例如，如果没有定义命名的常量酒吧，则PHP将在一串 “bar”并使用它。

警告

将未定义常量视为裸字符串的回退会发出错误级别的E_通知.从PHP7.2.0开始，这已被弃用，并发出错误级别的E_警告.从PHP 8.0.0开始，它已经被删除，并抛出一个错误例外。

注释:这并不意味着总是引用密钥。不要引号键常数或变量，因为这将阻止PHP来解释它们。

<?php（电话）错误_报告(全部（_ALL）); ini_集('显示错误',真的); ini_集('html_errors',假); //简单数组： $数组=数组(1,2); $count个=计数($数组); 对于(1美元=0；1美元<$count个；1美元++) { 回声“”正在检查“1美元：\n“；回声“错误：”.$数组[“$i”] .“\n”；回声“好：”.$数组[1美元] .“\n”；回声“错误：{$数组[“$i”]}\n“；回声“好：{$数组[1美元]}\n“； } ？>

上述示例将输出：
正在检查0:注意：未定义索引：第9行的/path/to/script.html中的$i错误：好：1注意：未定义索引：第11行/path/to/script.html中的$i错误：好：1检查1：注意：未定义索引：第9行的/path/to/script.html中的$i错误：好：2注意：未定义索引：第11行/path/to/script.html中的$i错误：好：2

更多示例来证明这种行为：

<?php（电话）
//显示所有错误
错误_报告(全部（_A）);

$arr（美元）=数组(“水果”=>“苹果”,“素食”=>“胡萝卜”);

//正确
打印$arr（美元）[“水果”];//苹果
打印$arr（美元）[“蔬菜”];//胡萝卜

//不正确。这可以工作，但也会抛出一个E_NOTICE级别的PHP错误，因为
//一个名为fruit的未定义常量
//
//注意：使用未定义的常量水果-假定“水果”在。。。
打印$arr（美元）[水果];//苹果

//这定义了一个常数来演示发生了什么。值“veggie”
//分配给一个名为fruit的常量。
定义(“水果”,“素食”);

//现在请注意区别
打印$arr（美元）[“水果”];//苹果
打印$arr（美元）[水果];//胡萝卜

//以下是可以的，因为它位于字符串中。不查找常量
//在字符串中，因此此处不出现E_NOTICE
打印“你好$arr（美元）[水果]"；//你好，苹果

//有一个例外：字符串中围绕数组的大括号允许常量
//待解释
打印“你好{$arr（美元）[水果]}"；//你好，胡萝卜
打印“你好{$arr（美元）[“水果”]}"；//你好，苹果

//这将不起作用，并将导致分析错误，例如：
//分析错误：分析错误，应为T_STRING“或T_VARIABLE”或T_NUM_STRING“
//当然，这也适用于在字符串中使用超全局变量
打印“你好$arr（美元）[“水果”]“；
打印“你好$_GET（获取）['foo']“；

//级联是另一种选择
打印“你好”.$arr（美元）[“水果”];//你好，苹果
？>

什么时候？错误_报告设置为显示E_通知级别错误（通过将其设置为全部（_ALL）例如），此类用途将立即可见。默认情况下，错误_报告设置为不显示通知。

如中所述语法部分，方括号内的内容（'['和']'）必须是表达式。这意味着代码这项工作：

<?php（电话）
回声$arr（美元）[一些功能($巴)];
？>

这是一个使用函数返回值作为数组索引的示例。菲律宾比索也知道常数：

<?php（电话）
$error_descriptions（错误描述）[E_ERROR（错误）]   =“发生致命错误”；
$error_descriptions（错误描述）[E_警告] =“PHP发出警告”；
$errordescriptions[E_通知]=“这只是一个非正式通知”；
？>

请注意E_ERROR（错误）也是有效的标识符，就像酒吧在第一个示例中。但最后一个例子是与书写相同：

<?php（电话）
$error_descriptions（错误描述）[1] =“发生致命错误”；
$error_descriptions（错误描述）[2] =“PHP发出警告”；
$errordescriptions[8] =“这只是一个非正式通知”；
？>

因为E_ERROR（错误）等于1等。

那么，为什么它不好呢？

在将来的某个时候，PHP团队可能希望添加另一个常量、关键字或其他代码中的常量可能会产生干扰。对于例如，使用这些词已经是错误的空的和违约这样，因为他们保留关键字.

注释:重申一下，在双引号内一串，有效期至不使用引号将数组索引括起来，所以“$foo[bar]”有效。有关原因和部分的详细信息，请参见上述示例在变量解析串.

转换为数组

对于任何类型整数,浮动,一串,布尔和资源,将值转换为阵列结果是一个具有单个索引为零的元素和转换的标量的值。在换句话说，（数组）$scalarValue与数组（$scalarValue）.

如果对象转换为阵列，结果是一个阵列其元素是对象的属性。键是成员变量名，有几个值得注意的例外：整数属性不可访问；私有变量在变量前面加上类名名称；受保护的变量在变量名前加了一个“*”。这些预设值具有无核字节。未初始化类型化属性被默默丢弃。

<?php（电话）

班一个{
私有的十亿美元；
受保护的加元；
公众的$D美元；
功能__构造()
{
        $这个->{1} =无效的；
}
}

变量导出（_E）（（数组）新建一个（））；
？>

上述示例将输出：

阵列('' . "\0" . 'A’。"\0" . 'B'=>空，'' . "\0" . '*' . "\0" . 'C'=>空，'D'=>空，1=>空，)

这些无核可能会导致一些意外行为：

<?php（电话）

班一个{
私有的美元；//这将成为“\0A\0A”
}

班B类延伸一个{
私有的美元；//这将成为“\0B\0A”
    公众的AA美元；//这将成为“AA”
}

变量转储（（数组）新建B类（））；
？>

上述示例将输出：

数组（3）{[“BA”]=>无效的[“AA”]=>无效的[“AA”]=>无效的}

上面似乎有两个名为“AA”的密钥，尽管其中一个是实际命名为“\0A\0A”。

正在转换无效的到阵列结果为空阵列.

比较

可以将数组与array_diff（）功能和具有数组运算符.

阵列解包

前缀为的数组...将在数组定义期间就地展开。仅实现的数组和对象可穿越的可以展开。阵列拆包...从PHP 7.4.0开始提供。

可以多次展开，并在...操作员：

示例#9简单阵列解包

<?php（电话）
//使用短数组语法。
//此外，还可以使用array（）语法。
$arr1（美元）= [1,2,三];
$arr2（美元）= [...$arr1（美元）];//[1, 2, 3]
$arr3美元= [0, ...$arr1（美元）];//[0, 1, 2, 3]
$arr4美元= [...$arr1（美元）, ...$arr2（美元）,111];//[1, 2, 3, 1, 2, 3, 111]
$arr5美元= [...$arr1（美元）, ...$arr1（美元）];//[1，2，3，1，2，3]

功能获取箭头() {
返回[“a”,“b”];
}
$arr6美元= [...获取箭头(),“c”=>“d”];//['a'，'b'，'c'=>'d']
？>

使用...运算符遵循数组_合并（）功能。也就是说，后面的字符串键覆盖前面的字符串键，整数键重新编号：

示例#10使用重复密钥解包阵列

<?php（电话）
//字符串键
$arr1美元= [“a”=>1];
$arr2（美元）= [“a”=>2];
$arr3美元= [“a”=>0, ...$arr1（美元）, ...$arr2（美元）];
变量转储($arr3美元);//[“a”=>2]

//整数键
$arr4美元= [1,2,三];
$arr5美元= [4,5,6];
$arr6美元= [...$arr4美元, ...$arr5美元];
变量转储($arr6美元);// [1, 2, 3, 4, 5, 6]
//即[0=>1，1=>2，2=>3，3=>4，4=>5，5=>6]
//其中未保留原始整数键。
？>

注释:
既不是整数也不是字符串的键将引发类型错误.此类密钥只能由可穿越的对象。

注释:
在PHP 8.1之前，不支持解包具有字符串键的数组：

<?php（电话） $arr1（美元）= [1,2,三]; $arr2（美元）= [“a”=>4]; $arr3美元=[。。。$arr1（美元）, ...$arr2（美元）]; //致命错误：未捕获错误：无法解包example.php:5中包含字符串键的数组 $arr4美元= [1,2,三]; $arr5美元= [4,5]; $arr6美元= [...$arr4美元, ...$arr5美元];//工程。[1，2，3，4，5] ？>

示例

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

<?php（电话）
//这：
美元=数组(“颜色”=>“红色”,
            “味道”=>“甜蜜的”,
            “形状”=>“圆形”,
            “名称”=>“苹果”,
            4//键将为0
          );

十亿美元=数组(“a”,“b”,“c”);

// . . .与此完全等价：
美元=阵列（）；
美元[“颜色”] =“红色”；
美元[“味道”] =“甜蜜的”；
美元[“形状”] =“圆形”；
美元[“名称”]=“苹果”；
美元[]        =4；//键将为0

十亿美元=阵列（）；
十亿美元[] =“a”；
十亿美元[] =“b”；
十亿美元[] =“c”；

//执行上述代码后，$a将成为数组
//数组（‘color’=>‘red’，‘味觉’=>’sweet’，‘shape’=>“round”，
//“name”=>“apple”，0=>4），$b将是数组
//数组（0=>“a”，1=>“b”，2=>“c”），或简单地数组（“a”、“b”、“c”。
？>

示例#11使用array（）

<?php（电话）
//数组作为（属性-）映射
$地图=数组('版本'=>4,
              “操作系统”=>“Linux”,
              “lang”（语言）=>“英语”,
              '短标签'=>真的
            );
            
//严格数字键
$数组=数组(7,
                8,
                0,
                156,
-10
              );
//这与数组相同（0=>7，1=>8，…）

$切换=数组(10,//键=0
                    5=>6,
                    三=>7,
                    “a”=>4,
                            11,//key=6（整数诱导的最大值为5）
                    '8'=>2,//键=8（整数！）
                    '02'=>77,//键='02'
                    0=>12//值10将被12覆盖
                  );
                  
//空数组
$空=阵列（）；
？>

示例#12集合

<?php（电话）
$种颜色=数组(“红色”,“蓝色”,“绿色”,“黄色”);

foreach公司($种颜色作为$颜色){
回声“你喜欢吗$颜色？\n“；
}

？>

上述示例将输出：

你喜欢红色吗？你喜欢蓝色吗？你喜欢绿色吗？你喜欢黄色吗？

更改的值阵列直接是可能的通过引用传递它们。

示例#13更改循环中的元素

<?php（电话）
foreach公司($种颜色作为&$颜色){
    $颜色=mb_strtoupper（mb _ strtoupper）($颜色);
}
未设置($颜色);/*确保以下写入
$color不会修改最后一个数组元素*/

打印（r）($种颜色);
？>

上述示例将输出：

阵列([0]=>红色[1] =>蓝色[2] =>绿色[3] =>黄色)

此示例创建一个基于一的数组。

示例#14基于一的索引

<?php（电话）
第一季度$=数组(1=>“一月”,“二月”,“三月”);
打印（r）(第一季度$);
？>

上述示例将输出：

阵列([1] =>“一月”[2] =>“二月”[3] =>“三月”)

示例#15填充数组

<?php（电话）
//用目录中的所有项填充数组
$句柄=打开目录('.');
同时(假!== ($文件=读目录($句柄))) {
    $个文件[] =$文件；
}
closedir（关闭目录）($句柄);
？>

阵列已订购。可以使用以下各项更改顺序排序功能。请参阅数组函数部分了解更多信息。这个count（）函数可以是用于计算阵列.

示例#16排序数组

<?php（电话）
分类($个文件);
打印（r）($个文件);
？>

因为阵列可以是任何东西，也可以是另一个阵列。这允许创建递归和多维的阵列第条。

示例#17递归和多维数组

<?php（电话）
$个水果=数组(“水果”=>数组(“a”=>“橙色”,
                                       “b”=>“香蕉”,
                                       “c”=>“苹果”
                                     ),
                  “数字”=>数组(1,
                                       2,
                                       三,
                                       4,
                                       5,
                                       6
                                     ),
                  “孔洞”=>数组(“第一个”,
                                       5=>“第二个”,
                                            “第三个”
                                     )
);

//上面数组中寻址值的一些示例
回声$个水果[“孔洞”][5];//打印“秒”
回声$个水果[“水果”][“a”];//打印“橙色”
未设置($个水果[“孔洞”][0]);//删除“第一个”

//创建新的多维数组
$果汁[“苹果”][“绿色”] =“很好”；
？>

阵列赋值总是涉及到值复制。使用参考运算符复制阵列通过引用。

<?php（电话）
$arr1（美元）=数组(2,三);
$arr2（美元）=$arr1（美元）；
$arr2（美元）[] =4；//$arr2已更改，
//$arr1仍然是数组（2，3）
             
$arr3美元= &$arr1（美元）；
$arr3美元[] =4；//现在$arr1和$arr3是相同的
？>

改进此页面

了解如何改进此页面•提交拉取请求•报告Bug

＋添加注释

用户贡献的笔记5条注释

向上的

向下

125

mlvljr公司¶

13年前

请注意，当复制数组时，会保留其成员的“引用状态”(http://www.php.net/manual/en/language.references.whatdo.php).

向上的

向下

托马斯·图林斯基¶

8年前

我认为您的第一个主要示例对新手来说是不必要的，非常混乱的：

$array=数组(
“foo”=>“bar”，
“bar”=>“foo”，
);

应将其拆下。
 
对于新手：
数组索引可以是任何字符串值，甚至可以是数组中的值。
数组[“foo”]的值为“bar”。
数组[“bar”]的值为“foo”

以下表达式均为真：
$array[“foo”]==“bar”
$array[“bar”]==“foo”

向上的

向下

ken下划线yap atsign电子邮件dot-com¶

16年前

如果将NULL值转换为数组，则会得到一个空数组


这是一个有用的属性。假设您有一个搜索函数，它在成功时返回一个值数组，如果没有找到，则返回NULL。


<?php$值=搜索(...);？>


现在要将该数组与另一个数组合并。如果$values为NULL，我们该怎么办？没问题：


<?php$组合=阵列_合并（（数组）$值,$其他);？>


瞧。

向上的

向下

jeff splat codedeard splot com公司¶

19年前

请注意，如果在$_POST数组中使用字符串作为索引，则句点将转换为下划线：

<html>
<body>
<?php（电话）
打印(“帖子：”);打印（r）($_POST（发送）);打印(“<br/>”);
？>
<form method=“post”action=“<?php（电话）回声$_服务器[“PHP_SELF”];？>">
<input type=“hidden”name=“Windows3.1”value=“Sux”>
<input type=“submit”value=“Click”/>
</form>
</body>
</html>

单击按钮后，页面显示以下内容：

POST：数组（[Windows3_1]=>Sux）

向上的

向下

ocportal网站的chris¶

11年前

请注意，即使通过序列化，数组值桶也是引用安全的。


<?php（电话）
$x美元='初始'；
$测试=数组(“A”=>&$x美元,“B”=>&$x美元);
$测试=序列化(序列化($测试));
$测试[“A”]=“已更改”；
回声$测试[“B”];//输出“已更改”
？>


这在某些情况下可能很有用，例如在复杂结构中节省RAM。

＋添加注释

阵列

语法

使用指定数组（）

使用方括号语法访问数组元素

使用方括号语法创建/修改

数组破坏

有用的功能

数组的注意事项

为什么是$foo[bar]错了吗？

那么，为什么它不好呢？

转换为数组

比较

阵列解包

示例

改进此页面

用户贡献的笔记5条注释

为什么是`$foo[bar]`错了吗？