2024 年 PHP 日本大会

数组

PHP 中的数组实际上是有序映射。映射是一种将关联的类型。这种类型针对多种不同的用途进行了优化;它可以被视为数组、列表(向量)、哈希表(映射的实现)、字典、集合、栈、队列,以及可能更多。由于数组的值可以是其他数组,因此树和多维数组也是可能的。

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

语法

使用array()指定

可以使用array()语言结构创建数组。它接受任意数量以逗号分隔的 => 对作为参数。

array(
    key  => value,
    key2 => value2,
    key3 => value3,
    ...
)

最后一个数组元素后面的逗号是可选的,可以省略。这通常用于单行数组,即array(1, 2)优于array(1, 2, )。对于多行数组,通常使用尾随逗号,因为它允许更容易地在末尾添加新元素。

注意:

存在简短的数组语法,它用[]替换array()

示例 #1 一个简单的数组

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

// 使用简短的数组语法
$array = [
"foo" => "bar",
"bar" => "foo",
];
?>

可以是整数字符串可以是任何类型。

此外,还会发生以下转换

  • 包含有效十进制整数字符串,除非数字前面有+符号,否则将转换为整数类型。例如,键"8"实际上将存储在8下。另一方面,"08"不会转换,因为它不是有效的十进制整数。
  • 浮点数也转换为整数,这意味着小数部分将被截断。例如,键8.7实际上将存储在8下。
  • 布尔值也转换为整数,即键true实际上将存储在1下,键false存储在0下。
  • 空值将转换为空字符串,即键null实际上将存储在""下。
  • 数组对象不能用作键。这样做会导致警告:非法偏移类型

如果数组声明中的多个元素使用相同的键,则只会使用最后一个键,因为所有其他键都被覆盖。

示例 #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 数组可以同时包含整数字符串键,因为 PHP 不区分索引数组和关联数组。

示例 #3 混合整数字符串

<?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)
}

是可选的。如果未指定,PHP 将使用之前使用的最大整数键的增量。

示例 #4 没有键的索引数组

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

上面的示例将输出

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

可以只为某些元素指定键,而为其他元素保留键。

示例 #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

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

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

<?php
$array
= array(
1 => 'a',
'1' => 'b', // 值 "a" 将被 "b" 覆盖
1.5 => 'c', // 值 "b" 将被 "c" 覆盖
-1 => 'd',
'01' => 'e', // 由于这不是整数字符串,因此不会覆盖键 1
'1.5' => 'f', // 由于这不是整数字符串,因此不会覆盖键 1
true => 'g', // 值 "c" 将被 "g" 覆盖
false => 'h',
'' => 'i',
null => 'j', // 值 "i" 将被 "j" 覆盖
'k', // 值 "k" 被赋予键 2。这是因为之前最大的整数键是 1
2 => 'l', // 值 "k" 将被 "l" 覆盖
);

var_dump($array);
?>

上面的示例将输出

array(7) {
  [1]=>
  string(1) "g"
  [-1]=>
  string(1) "d"
  ["01"]=>
  string(1) "e"
  ["1.5"]=>
  string(1) "f"
  [0]=>
  string(1) "h"
  [""]=>
  string(1) "j"
  [2]=>
  string(1) "l"
}

示例 #7 负索引示例

当赋值一个负整数键 n 时,PHP 会将下一个键赋值为 n+1

<?php
$array
= [];

$array[-5] = 1;
$array[] = 2;

var_dump($array);
?>

上面的示例将输出

array(2) {
  [-5]=>
  int(1)
  [-4]=>
  int(2)
}
警告

在 PHP 8.3.0 之前,赋值一个负整数键 n 会将下一个键赋值为 0,因此之前的示例将输出

array(2) {
  [-5]=>
  int(1)
  [0]=>
  int(2)
}

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

可以使用 array[key] 语法访问数组元素。

示例 #8 访问数组元素

<?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"

注意:

在 PHP 8.0.0 之前,方括号和花括号可以互换使用来访问数组元素(例如,$array[42]$array{42} 在上面的示例中都执行相同的操作)。从 PHP 7.4.0 开始,花括号语法已被弃用,并且从 PHP 8.0.0 开始不再支持。

示例 #9 数组解引用

<?php
function getArray() {
return array(
1, 2, 3);
}

$secondElement = getArray()[1];
?>

注意:

尝试访问尚未定义的数组键与访问任何其他未定义变量相同:将发出E_WARNING级别的错误消息(在 PHP 8.0.0 之前为E_NOTICE级别),结果将为null

注意:

对不是字符串的标量值进行数组解引用会产生null。在 PHP 7.4.0 之前,不会发出错误消息。从 PHP 7.4.0 开始,这会发出E_NOTICE;从 PHP 8.0.0 开始,这会发出E_WARNING

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

可以通过显式设置其中的值来修改现有的数组

这是通过为数组赋值来完成的,在方括号中指定键。也可以省略键,导致出现一对空括号([])。

$arr[key] = value;
$arr[] = value;
// key may be an int or string
// value may be any value of any type

如果$arr尚不存在或设置为nullfalse,它将被创建,因此这也是创建数组的另一种方法。但是,不鼓励这种做法,因为如果$arr已经包含某些值(例如,来自请求变量的字符串),则该值将保留在原位,而[]实际上可能代表字符串访问运算符。始终最好通过直接赋值来初始化变量。

注意 从 PHP 7.1.0 开始,对字符串应用空索引运算符会引发致命错误。以前,字符串会静默转换为数组。

注意 从 PHP 8.1.0 开始,从false值创建新数组已被弃用。仍然允许从null和未定义的值创建新数组。

要更改某个值,请使用其键为该元素赋予新值。要删除键值对,请在其上调用unset() 函数。

<?php
$arr
= array(5 => 1, 12 => 2);

$arr[] = 56; // 这与 $arr[13] = 56; 相同
// 在脚本的这一点上

$arr["x"] = 42; // 这将一个新元素添加到
// 数组中,键为 "x"

unset($arr[5]); // 这将从数组中删除元素

unset($arr); // 这将删除整个数组
?>

注意:

如上所述,如果未指定键,则采用现有整数索引的最大值,新键将是该最大值加 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
)

数组解构

可以使用 [](PHP 7.1.0 起)或 list() 语言结构来解构数组。这些结构可以用于将数组解构为不同的变量。

<?php
$source_array
= ['foo', 'bar', 'baz'];

[
$foo, $bar, $baz] = $source_array;

echo
$foo; // 输出 "foo"
echo $bar; // 输出 "bar"
echo $baz; // 输出 "baz"
?>

数组解构可以用于 foreach 中,在迭代多维数组时对其进行解构。

<?php
$source_array
= [
[
1, 'John'],
[
2, 'Jane'],
];

foreach (
$source_array as [$id, $name]) {
// 使用 $id 和 $name 的逻辑
}
?>

如果未提供变量,则将忽略数组元素。数组解构始终从索引 0 开始。

<?php
$source_array
= ['foo', 'bar', 'baz'];

// 将索引 2 处的元素赋值给变量 $baz
[, , $baz] = $source_array;

echo
$baz; // 输出 "baz"
?>

从 PHP 7.1.0 开始,也可以解构关联数组。这还可以更轻松地在数字索引数组中选择正确的元素,因为可以显式指定索引。

<?php
$source_array
= ['foo' => 1, 'bar' => 2, 'baz' => 3];

// 将索引 'baz' 处的元素赋值给变量 $three
['baz' => $three] = $source_array;

echo
$three; // 输出 3

$source_array = ['foo', 'bar', 'baz'];

// 将索引 2 处的元素赋值给变量 $baz
[2 => $baz] = $source_array;

echo
$baz; // 输出 "baz"
?>

数组解构可以轻松交换两个变量。

<?php
$a
= 1;
$b = 2;

[
$b, $a] = [$a, $b];

echo
$a; // 输出 2
echo $b; // 输出 1
?>

注意:

赋值中不支持扩展运算符 (...)。

注意:

尝试访问尚未定义的数组键与访问任何其他未定义变量相同:将发出E_WARNING级别的错误消息(在 PHP 8.0.0 之前为E_NOTICE级别),结果将为null

有用的函数

有很多有用的函数可以用于处理数组。请参阅 数组函数 部分。

注意:

unset() 函数允许从 数组 中删除键。请注意,数组 *不会* 被重新索引。如果需要真正的“删除并移动”行为,可以使用 array_values() 函数重新索引 数组

<?php
$a
= array(1 => 'one', 2 => 'two', 3 => 'three');
unset(
$a[2]);
/* 将产生一个数组,该数组本应定义为
$a = array(1 => 'one', 3 => 'three');
而不是
$a = array(1 => 'one', 2 =>'three');
*/

$b = array_values($a);
// 现在 $b 是 array(0 => 'one', 1 =>'three')
?>

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

数组的注意事项

为什么 $foo[bar] 是错误的?

始终在字符串字面量数组索引周围使用引号。例如,$foo['bar'] 是正确的,而 $foo[bar] 是错误的。但是为什么呢?在旧脚本中经常会遇到这种语法。

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

这是错误的,但它有效。原因是这段代码包含一个未定义的常量 (bar),而不是一个 字符串 ('bar' - 注意引号)。它之所以有效,是因为 PHP 会自动将 *裸字符串*(一个未加引号的 字符串,它不对应任何已知的符号)转换为包含裸 字符串字符串。例如,如果没有名为 bar 的已定义常量,则 PHP 将替换为 字符串 'bar' 并使用它。

警告

将未定义的常量作为裸字符串处理的回退会发出级别为 E_NOTICE 的错误。从 PHP 7.2.0 开始,这已被弃用,并发出级别为 E_WARNING 的错误。从 PHP 8.0.0 开始,它已被删除,并抛出一个 Error 异常。

注意 这并不意味着 *始终* 为键加引号。不要为是 常量变量 的键加引号,因为这会阻止 PHP 解释它们。

<?php
error_reporting
(E_ALL);
ini_set('display_errors', true);
ini_set('html_errors', false);
// 简单数组:
$array = array(1, 2);
$count = count($array);
for (
$i = 0; $i < $count; $i++) {
echo
"\n正在检查 $i:\n";
echo
"错误: ". $array['$i'] . "\n";
echo
"正确: ". $array[$i] . "\n";
echo
"错误: {$array['$i']} \n";
echo
"正确: {$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
// 显示所有错误
error_reporting(E_ALL);

$arr = array('fruit' => 'apple', 'veggie' => 'carrot');

// 正确的
print $arr['fruit']; // apple
print $arr['veggie']; // carrot

// 错误的。这段代码可以运行,但是会抛出一个 E_NOTICE 级别的 PHP 错误,因为
// 未定义名为 fruit 的常量
//
// Notice: Use of undefined constant fruit - assumed 'fruit' in...
print $arr[fruit]; // apple

// 此处定义一个常量来演示正在发生的事情。值 'veggie'
// 被赋值给名为 fruit 的常量。
define('fruit', 'veggie');

// 现在注意区别
print $arr['fruit']; // apple
print $arr[fruit]; // carrot

// 下面这段代码没问题,因为它在字符串内部。字符串内部不会查找常量,
// 因此此处不会发生 E_NOTICE
print "Hello $arr[fruit]"; // Hello apple

// 一个例外:字符串中包围数组的花括号允许解释常量
print "Hello {$arr[fruit]}"; // Hello carrot

print
"Hello {$arr['fruit']}"; // Hello apple

// 这段代码无法运行,会产生解析错误,例如:
// Parse error: parse error, expecting T_STRING' or T_VARIABLE' or T_NUM_STRING'
// 这当然也适用于在字符串中使用超全局变量
print "Hello $arr['fruit']";
print
"Hello $_GET['foo']";

// 连接是另一种选择
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] = "发生了致命错误";
$error_descriptions[E_WARNING] = "PHP 发出了警告";
$error_descriptions[E_NOTICE] = "这只是一个非正式的通知";
?>

注意,E_ERROR也是一个有效的标识符,就像第一个示例中的bar一样。但最后一个示例实际上与编写以下代码相同

<?php
$error_descriptions
[1] = "发生了致命错误";
$error_descriptions[2] = "PHP 发出了警告";
$error_descriptions[8] = "这只是一个非正式的通知";
?>

因为E_ERROR等于1等。

那么为什么不好呢?

将来某个时候,PHP 团队可能想要添加另一个常量或关键字,或者其他代码中的常量可能会发生冲突。例如,以这种方式使用emptydefault这两个词就已经是错误的了,因为它们是保留关键字

注意 重申一下,在双引号字符串内,不需要用引号包围数组索引,所以"$foo[bar]"是有效的。请参见上面的示例,了解原因以及关于字符串中变量解析的部分。

转换为数组

对于任何intfloatstringboolresource类型,将值转换为数组会得到一个只有一个元素的数组,索引为零,值为转换的标量。换句话说,(array) $scalarValuearray($scalarValue)完全相同。

如果将对象转换为数组,结果是一个数组,其元素是对象的属性。键是成员变量名,但有一些显著的例外:整数属性无法访问;私有变量的类名前缀为变量名;受保护的变量名前缀为 '*'。这些前缀值的两侧都有NUL字节。未初始化的类型化属性会被静默丢弃。

<?php

class A {
private
$B;
protected
$C;
public
$D;
function
__construct()
{
$this->{1} = null;
}
}

var_export((array) new A());
?>

上面的示例将输出

array (
  '' . "\0" . 'A' . "\0" . 'B' => NULL,
  '' . "\0" . '*' . "\0" . 'C' => NULL,
  'D' => NULL,
  1 => NULL,
)

这些NUL字符可能导致一些意想不到的行为。

<?php

class A {
private
$A; // 这将变成 '\0A\0A'
}

class
B extends A {
private
$A; // 这将变成 '\0B\0A'
public $AA; // 这将变成 'AA'
}

var_dump((array) new B());
?>

上面的示例将输出

array(3) {
  ["BA"]=>
  NULL
  ["AA"]=>
  NULL
  ["AA"]=>
  NULL
}

上面代码看起来有两个名为'AA'的键,但其中一个实际上名为'\0A\0A'。

将**null**转换为数组将得到一个空数组

数组比较

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

数组解包

...为前缀的数组将在数组定义期间就地展开。只有实现Traversable接口的数组和对象才能展开。... 的数组解包功能自 PHP 7.4.0 起可用。

可以多次展开,并在...运算符之前或之后添加普通元素。

示例 #10 简单的数组解包

<?php
// 使用简短数组语法。
// 也适用于 array() 语法。
$arr1 = [1, 2, 3];
$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]

function getArr() {
return [
'a', 'b'];
}
$arr6 = [...getArr(), 'c' => 'd']; //['a', 'b', 'c' => 'd']
?>

使用...运算符解包数组遵循array_merge()函数的语义。也就是说,后面的字符串键会覆盖前面的字符串键,整数键将被重新编号。

示例 #11 带有重复键的数组解包

<?php
// 字符串键
$arr1 = ["a" => 1];
$arr2 = ["a" => 2];
$arr3 = ["a" => 0, ...$arr1, ...$arr2];
var_dump($arr3); // ["a" => 2]

// 整数键
$arr4 = [1, 2, 3];
$arr5 = [4, 5, 6];
$arr6 = [...$arr4, ...$arr5];
var_dump($arr6); // [1, 2, 3, 4, 5, 6]
// 即 [0 => 1, 1 => 2, 2 => 3, 3 => 4, 4 => 5, 5 => 6]
// 其中原始整数键未保留。
?>

注意:

既不是整数也不是字符串的键会抛出TypeError异常。此类键只能由Traversable对象生成。

注意:

在 PHP 8.1 之前,不支持解包具有字符串键的数组。

<?php

$arr1
= [1, 2, 3];
$arr2 = ['a' => 4];
$arr3 = [...$arr1, ...$arr2];
// Fatal error: Uncaught Error: Cannot unpack array with string keys in example.php:5

$arr4 = [1, 2, 3];
$arr5 = [4, 5];
$arr6 = [...$arr4, ...$arr5]; // 可行。 [1, 2, 3, 4, 5]
?>

示例

PHP 中的数组类型非常灵活。以下是一些示例:

<?php
// 这段代码:
$a = array( 'color' => 'red',
'taste' => 'sweet',
'shape' => 'round',
'name' => 'apple',
4 // 键将为 0
);

$b = array('a', 'b', 'c');

// ... 与这段代码完全等效:
$a = array();
$a['color'] = 'red';
$a['taste'] = 'sweet';
$a['shape'] = 'round';
$a['name'] = 'apple';
$a[] = 4; // 键将为 0

$b = array();
$b[] = 'a';
$b[] = 'b';
$b[] = 'c';

// 代码执行完毕后,$a 将是数组
// array('color' => 'red', 'taste' => 'sweet', 'shape' => 'round',
// 'name' => 'apple', 0 => 4),而 $b 将是数组
// array(0 => 'a', 1 => 'b', 2 => 'c'),或者简写为 array('a', 'b', 'c')。
?>

示例 #12 使用 array()

<?php
// 数组作为 (属性) 映射
$map = array( 'version' => 4,
'OS' => 'Linux',
'lang' => 'english',
'short_tags' => true
);

// 严格的数字键
$array = array( 7,
8,
0,
156,
-
10
);
// 这与 array(0 => 7, 1 => 8, ...) 相同

$switching = array( 10, // 键 = 0
5 => 6,
3 => 7,
'a' => 4,
11, // 键 = 6 (整数索引的最大值为 5)
'8' => 2, // 键 = 8 (整数!)
'02' => 77, // 键 = '02'
0 => 12 // 值 10 将被 12 覆盖
);

// 空数组
$empty = array();
?>

示例 #13 集合

<?php
$colors
= array('red', 'blue', 'green', 'yellow');

foreach (
$colors as $color) {
echo
"你喜欢 "$color" 吗?\n";
}

?>

上面的示例将输出

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

可以通过引用传递直接更改数组的值。

示例 #14 循环中更改元素

<?php
foreach ($colors as &$color) {
$color = mb_strtoupper($color);
}
unset(
$color); /* 确保随后写入
$color 将不会修改最后一个数组元素 */

print_r($colors);
?>

上面的示例将输出

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

此示例创建一个从1开始的数组。

示例 #15 从1开始的索引

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

上面的示例将输出

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

示例 #16 填充数组

<?php
// 用目录中的所有项目填充数组
$handle = opendir('.');
while (
false !== ($file = readdir($handle))) {
$files[] = $file;
}
closedir($handle);
?>

数组是有序的。可以使用各种排序函数更改顺序。有关更多信息,请参见数组函数部分。count()函数可用于计算数组中项目的数量。

示例 #17 排序数组

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

因为数组的值可以是任何东西,所以它也可以是另一个数组。这使得创建递归和多维数组成为可能。

示例 #18 递归和多维数组

<?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"
)
);

// 一些访问上面数组中值的示例
echo $fruits["holes"][5]; // 输出 "second"
echo $fruits["fruits"]["a"]; // 输出 "orange"
unset($fruits["holes"][0]); // 删除 "first"

// 创建一个新的多维数组
$juices["apple"]["green"] = "good";
?>

数组赋值总是涉及值复制。使用引用运算符按引用复制数组

<?php
$arr1
= array(2, 3);
$arr2 = $arr1;
$arr2[] = 4; // $arr2 已更改,
// $arr1 仍然是 array(2, 3)

$arr3 = &$arr1;
$arr3[] = 4; // 现在 $arr1 和 $arr3 相同
?>
添加注释

用户贡献的注释 5 条注释

mlvljr
13 年前
请注意,当复制数组时,其成员的“引用状态”将被保留(https://php.net/manual/en/language.references.whatdo.php).
thomas tulinsky
8 年前
我认为你的第一个主要示例不必要地令人困惑,对于新手来说非常令人困惑

$array = array(
"foo" => "bar",
"bar" => "foo",
);

它应该被删除。

对于新手
数组索引可以是任何字符串值,甚至是数组中的值。
array["foo"] 的值为 "bar"。
array["bar"] 的值为 "foo"

以下表达式均为真
$array["foo"] == "bar"
$array["bar"] == "foo"
[email protected]
16年前
“如果将NULL值转换为数组,则得到一个空数组。”

事实证明这是一个有用的特性。假设您有一个搜索函数,它在成功时返回一个值数组,如果未找到任何内容则返回NULL。

<?php $values = search(...); ?>

现在您想将该数组与另一个数组合并。如果$values为NULL怎么办?没问题

<?php $combined = array_merge((array)$values, $other); ?>

瞧。
[email protected]
19年前
注意,如果在$_POST数组中使用字符串作为索引,则句点将转换为下划线

<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>

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

POST: Array ( [Windows3_1] => Sux )
[email protected]
11年前
请注意,即使通过序列化,数组值桶也是引用安全的。

<?php
$x
='initial';
$test=array('A'=>&$x,'B'=>&$x);
$test=unserialize(serialize($test));
$test['A']='changed';
echo
$test['B']; // 输出 "changed"
?>

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