第4章数据组：使用数组

作者 651

数组是相关值的集合，例如从表格提交的数据，班级中的学生姓名或城市列表的人口。在第2章中，您了解到变量是一个包含值的命名容器。数组是一个容纳多个值的容器。

本章介绍如何使用数组。下一节“数组基础知识”介绍了如何创建数组和操作元素等基础知识。通常，您需要对数组中的每个元素执行某些操作，例如打印它或在某些条件下检查它。“循环遍历阵列”解释了如何使用foreach()和for()构造来完成这些事情。“修改阵列”介绍了 implode()与explode() 功能，转阵列成字符串和字符串成阵列。另一种数组修改是排序，在“排序数组”中讨论 。最后，“使用多维数组”探索包含其他数组的数组。

使用数组是一项常见的PHP编程任务。第7章介绍如何处理表单数据，PHP引擎会自动将其放入数组中。当您按照第8章中的描述从数据库中检索信息时，该数据通常会打包到一个数组中。熟悉数组使您可以轻松操作这些类型的数据。

数组基础知识

一个数组是 由元素组成。每个元素有钥匙 和价值。例如，一个包含有关蔬菜颜色信息的数组，其中包含键的颜色和颜色的蔬菜名称，如图4-1所示。

图4-1。包含蔬菜颜色信息的数组中的键和值
数组只能有一个具有给定键的元素。在蔬菜颜色数组中，corn即使其值为，也不能有其他具有键的元素blue。但是，相同的值可以在一个数组中出现多次。你可以吃青椒，绿色西兰花和绿色芹菜。

任何字符串或数字值可以是一个数组元素键，如 corn，4， -36，或Salt Baked Squid。数组和其他非标量1值不能是键，但它们可以是元素值。一个元素的值可以是任何东西：一个字符串，一个数字，true，false，或一个非标量类型，如另一个阵列。

创建一个数组

创建一个 数组，使用array()语言结构。指定以逗号分隔的键/值对列表，键和值之间用=>。这显示在例4-1中。

例4-1。创建一个数组

1
2
3
4
5
6
7
8
9
10
11
$vegetables = array('corn' => 'yellow',
'beet' => 'red',
'carrot' => 'orange');
 
$dinner = array(0 => 'Sweet Corn and Asparagus',
1 => 'Lemon Chicken',
2 => 'Braised Bamboo Fungus');
 
$computers = array('trs-80' => 'Radio Shack',
2600 => 'Atari',
'Adam' => 'Coleco');

在阵列的键和值实施例4-1都是字符串（例如corn，Braised Bamboo Fungus和Coleco）和数字（例如0，1和 2600）。它们的编写方式与PHP程序中的其他字符串和数字一样：字符串周围的引号但不包括数字。

捷径 对于array()语言结构是一对方括号（称为短数组语法）。例4-2创建了与例4-1相同的数组，但是使用了短数组语法。

例4-2。使用短数组语法

1
2
3
4
5
6
7
$vegetables = ['corn' => 'yellow', 'beet' => 'red', 'carrot' => 'orange'];
 
$dinner = [0 => 'Sweet Corn and Asparagus',
1 => 'Lemon Chicken',
2 => 'Braised Bamboo Fungus'];
 
$computers = ['trs-80' => 'Radio Shack', 2600 => 'Atari', 'Adam' => 'Coleco'];

警告
PHP 5.4中引入了短数组语法。如果您使用的是早期版本的PHP，则需要坚持使用array()。

您还可以通过为特定数组键分配值，一次向一个数组添加元素。例4-3构建与前两个示例相同的数组，但是逐个元素。

例4-3。按元素创建数组元素

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// An array called $vegetables with string keys
$vegetables['corn'] = 'yellow';
$vegetables['beet'] = 'red';
$vegetables['carrot'] = 'orange';
 
// An array called $dinner with numeric keys
$dinner[0] = 'Sweet Corn and Asparagus';
$dinner[1] = 'Lemon Chicken';
$dinner[2] = 'Braised Bamboo Fungus';
 
// An array called $computers with numeric and string keys
$computers['trs-80'] = 'Radio Shack';
$computers[2600] = 'Atari';
$computers['Adam'] = 'Coleco';

在例4-3中，数组变量名后面的方括号引用数组中的特定键。 通过为该键指定值，可以在数组中创建一个元素。

选择一个好的数组名称

包含数组的变量的名称 遵循与任何其他变量的名称相同的规则。数组和标量变量的名称来自相同的可能名称池，因此您不能同时调用一个数组 $vegetables和一个标量 $vegetables。如果为数组指定标量值（反之亦然），则会以静默方式清除旧值，变量将成为新值。在例4-4中，$vegetables变为标量，并$fruits成为一个数组。

例4-4。数组和标量碰撞

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// This makes $vegetables an array
$vegetables['corn'] = 'yellow';
 
// This removes any trace of "corn" and "yellow" and makes $vegetables a scalar
$vegetables = 'delicious';
 
// This makes $fruits a scalar
$fruits = 283;
 
// This doesn't work -- $fruits stays 283 and the PHP engine
// issues a warning
$fruits['potassium'] = 'banana';
 
// But this overwrites $fruits and it becomes an array
$fruits = array('potassium' => 'banana');

在示例4-1中，每个$vegetables 和$computers数组都存储一个关系列表。该$vegetables阵列涉及蔬菜和颜色，而$computers阵列涉及计算机名称和制造商。$dinner但是，在 数组中，我们只关心作为数组值的菜肴的名称。数组键只是区分一个元素与另一个元素的数字。

创建数值数组

PHP提供了一些使用数组的快捷方式 只有数字作为键。 如果使用[]或array()仅通过指定值列表而不是键/值对来创建数组，PHP引擎自动为每个值分配一个数字键。键从0每个元素开始并增加一个。例4-5使用此技术创建 $dinner数组。

例4-5。使用array（）创建数值数组

1
2
3
4
$dinner = array('Sweet Corn and Asparagus',
'Lemon Chicken',
'Braised Bamboo Fungus');
print "I want $dinner[0] and $dinner[1].";

例4-5打印：

1
I want Sweet Corn and Asparagus and Lemon Chicken.

在内部，PHP引擎使用数字键处理数组，使用字符串键（以及混合使用数字和字符串键的数组）处理数组。由于与其他编程语言中的功能相似，程序员通常将仅使用数字键的数组称为“数字”，“索引”或“有序”数组，并将字符串键控数组称为“关联”数组。一个 关联数组，换句话说，是一个其键表示比该阵列中的值的位置以外的内容。每个键都与其值相关联。

当您创建数组或添加元素时，PHP会自动为数组键使用递增数字 使用示例4-6中显示的空括号语法的数组。

例4-6。用[]添加元素

1
2
3
4
5
6
7
8
9
10
11
12
// Create $lunch array with two elements
// This sets $lunch[0]
$lunch[] = 'Dried Mushrooms in Brown Sauce';
// This sets $lunch[1]
$lunch[] = 'Pineapple and Yu Fungus';
 
// Create $dinner with three elements
$dinner = array('Sweet Corn and Asparagus', 'Lemon Chicken',
'Braised Bamboo Fungus');
// Add an element to the end of $dinner
// This sets $dinner[3]
$dinner[] = 'Flank Skin with Spiced Flavor';

空括号向数组添加元素。新元素的数字键比数组中已有的最大数字键多一个。如果数组尚不存在，则空括号添加一个键为的元素 0。

查找数组的大小
该count() 功能告诉 你是数组中元素的数量。例4-7 说明count()。

例4-7。查找数组的大小

1
2
3
4
5
6
7
$dinner = array('Sweet Corn and Asparagus',
'Lemon Chicken',
'Braised Bamboo Fungus');
 
$dishes = count($dinner);
 
print "There are $dishes things for dinner.";

例4-7打印：

1
There are 3 things for dinner.

当你 传递一个空数组（即一个没有元素的数组），count()返回0。空数组也计算为false在if()测试表达。

循环遍历数组

之一 与数组最常见的事情是分别考虑数组中的每个元素并以某种方式处理它。 这可能涉及将其合并到HTML表的一行中或将其值添加到运行总计中。

迭代每个元素的最简单方法 一个数组是 foreach()。该foreach() 构造允许您为数组中的每个元素运行一次代码块。例4-8用于foreach()打印包含数组中每个元素的HTML表。

例4-8。循环使用foreach（）

1
2
3
4
5
6
7
8
9
$meal = array('breakfast' => 'Walnut Bun',
'lunch' => 'Cashew Nuts and White Mushrooms',
'snack' => 'Dried Mulberries',
'dinner' => 'Eggplant with Chili Sauce');
print "<table>\n";
foreach ($meal as $key => $value) {
print "<tr><td>$key</td><td>$value</td></tr>\n";
}
print '</table>';

例4-8打印：

1
2
3
4
5
6
<table>
<tr><td>breakfast</td><td>Walnut Bun</td></tr>
<tr><td>lunch</td><td>Cashew Nuts and White Mushrooms</td></tr>
<tr><td>snack</td><td>Dried Mulberries</td></tr>
<tr><td>dinner</td><td>Eggplant with Chili Sauce</td></tr>
</table>

对于每个元素$meal，foreach()将元素的键复制到 $key值中$value。然后，它运行花括号内的代码。在例4-8中，代码打印$key并 $value使用一些HTML来创建表行。您可以使用所需的任何变量名称作为代码块内的键和值。但是，如果变量名在之前使用 foreach()，则它们会被数组中的值覆盖。

当您foreach()用于在HTML表中打印数据时，通常需要将交替的CSS类应用于每个表行。将交替的类名存储在单独的数组中时，这很容易实现。然后，在每次之间0和之间切换一个变量1，foreach()以打印相应的类名。例4-9在其$row_styles数组中的两个类名之间交替。

例4-9。交替表行类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
$row_styles = array('even','odd');
$style_index = 0;
$meal = array('breakfast' => 'Walnut Bun',
'lunch' => 'Cashew Nuts and White Mushrooms',
'snack' => 'Dried Mulberries',
'dinner' => 'Eggplant with Chili Sauce');
print "<table>\n";
foreach ($meal as $key => $value) {
print '<tr class="' . $row_styles[$style_index] . '">';
print "<td>$key</td><td>$value</td></tr>\n";
// This switches $style_index between 0 and 1
$style_index = 1 - $style_index;
}
print '</table>';

例4-9打印：

1
2
3
4
5
6
<table>
<tr class="even"><td>breakfast</td><td>Walnut Bun</td></tr>
<tr class="odd"><td>lunch</td><td>Cashew Nuts and White Mushrooms</td></tr>
<tr class="even"><td>snack</td><td>Dried Mulberries</td></tr>
<tr class="odd"><td>dinner</td><td>Eggplant with Chili Sauce</td></tr>
</table>

内的foreach()代码块，改变等循环变量的值$key和 $value不影响实际的数组中的元素。如果要更改数组元素值，请使用该 $key变量作为数组的索引。例4-10使用此技术将数组中的每个元素加倍。

例4-10。使用foreach（）修改数组

1
2
3
4
5
6
7
8
9
10
11
12
13
14
$meals = array('Walnut Bun' => 1,
'Cashew Nuts and White Mushrooms' => 4.95,
'Dried Mulberries' => 3.00,
'Eggplant with Chili Sauce' => 6.50);
 
foreach ($meals as $dish => $price) {
// $price = $price * 2 does NOT work
$meals[$dish] = $meals[$dish] * 2;
}
 
// Iterate over the array again and print the changed values
foreach ($meals as $dish => $price) {
printf("The new price of %s is \$%.2f.\n",$dish,$price);
}

例4-10打印：

1
2
3
4
The new price of Walnut Bun is $2.00.
The new price of Cashew Nuts and White Mushrooms is $9.90.
The new price of Dried Mulberries is $6.00.
The new price of Eggplant with Chili Sauce is $13.00.

有一个更简洁的foreach()使用形式使用数字数组，如例4-11所示。

例4-11。将foreach（）与数字数组一起使用

1
2
3
4
5
6
$dinner = array('Sweet Corn and Asparagus',
'Lemon Chicken',
'Braised Bamboo Fungus');
foreach ($dinner as $dish) {
print "You can eat: $dish\n";
}

例4-11打印：

1
2
3
You can eat: Sweet Corn and Asparagus
You can eat: Lemon Chicken
You can eat: Braised Bamboo Fungus

使用这种形式foreach()，只需在之后指定一个变量名称as，并将每个元素值复制到代码块内的该变量中。但是，您无法访问代码块内的元素键。

要跟踪数组中的位置foreach()，必须使用每次foreach()代码块运行时递增的单独变量。使用 for()，您可以在循环变量中明确获得位置。该foreach()循环为您提供每个阵列元素的值，但 for()循环提供了各阵列元件的位置。没有循环结构可以同时为您提供这两种结构。

因此，如果您想知道在迭代数字数组时您所处的元素，请使用 for()而不是foreach()。你的for()循环应该依赖于一个循环变量，该循环变量从0数组中的元素数量开始并继续减少一个。这显示在例4-12中。

例4-12。使用for（）遍历数值数组

1
2
3
4
5
6
$dinner = array('Sweet Corn and Asparagus',
'Lemon Chicken',
'Braised Bamboo Fungus');
for ($i = 0, $num_dishes = count($dinner); $i < $num_dishes; $i++) {
print "Dish number $i is $dinner[$i]\n";
}

例4-12打印：

1
2
3
Dish number 0 is Sweet Corn and Asparagus
Dish number 1 is Lemon Chicken
Dish number 2 is Braised Bamboo Fungus

当使用迭代遍历数组时for()，您有一个运行计数器可用于您所在的数组元素。使用此计数器和modulus运算符（%）来交替表行类，如例4-13所示。

例4-13。带for（）的交替表行类

1
2
3
4
5
6
7
8
9
10
11
$row_styles = array('even','odd');
$dinner = array('Sweet Corn and Asparagus',
'Lemon Chicken',
'Braised Bamboo Fungus');
print "<table>\n";
 
for ($i = 0, $num_dishes = count($dinner); $i < $num_dishes; $i++) {
print '<tr class="' . $row_styles[$i % 2] . '">';
print "<td>Element $i</td><td>$dinner[$i]</td></tr>\n";
}
print '</table>';

例4-13用计算正确的表行类$i % 2。之间的这种交替值0和1 作为$i偶数和奇数之间交替。没有必要使用单独的变量，例如 $style_index，如例4-9所示，以保存适当的行类名。例4-13打印：

1
2
3
4
5
<table>
<tr class="even"><td>Element 0</td><td>Sweet Corn and Asparagus</td></tr>
<tr class="odd"><td>Element 1</td><td>Lemon Chicken</td></tr>
<tr class="even"><td>Element 2</td><td>Braised Bamboo Fungus</td></tr>
</table>

使用迭代数组时foreach()，将按照将数组添加到数组的顺序访问元素。首先访问添加的第一个元素，然后访问添加的第二个元素，依此类推。如果您有一个数字数组，其元素的添加顺序与其键通常的顺序不同，这可能会产生意外结果。示例4-14不按数字或字母顺序打印数组元素。

例4-14。数组元素顺序和foreach（）

1
2
3
4
5
6
7
8
$letters[0] = 'A';
$letters[1] = 'B';
$letters[3] = 'D';
$letters[2] = 'C';
 
foreach ($letters as $letter) {
print $letter;
}

例4-14打印：

1
ABDC

为了保证以数字键顺序访问元素，请使用 for()迭代循环：

1
2
3
for ($i = 0, $num_letters = count($letters); $i &lt; $num_letters; $i++) {
print $letters[$i];
}

这打印：

1
ABCD

如果您正在寻找数组中的特定元素，则无需遍历整个数组来查找它。有更有效的方法来定位特定元素。要检查具有某个键的元素，请使用 array_key_exists()，例4-15中所示。true如果提供的数组中存在具有提供的键的元素，则此函数返回。

例4-15。检查具有特定键的元素

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
$meals = array('Walnut Bun' => 1,
'Cashew Nuts and White Mushrooms' => 4.95,
'Dried Mulberries' => 3.00,
'Eggplant with Chili Sauce' => 6.50,
'Shrimp Puffs' => 0); // Shrimp Puffs are free!
$books = array("The Eater's Guide to Chinese Characters",
'How to Cook and Eat in Chinese');
 
// This is true
if (array_key_exists('Shrimp Puffs',$meals)) {
print "Yes, we have Shrimp Puffs";
}
// This is false
if (array_key_exists('Steak Sandwich',$meals)) {
print "We have a Steak Sandwich";
}
// This is true
if (array_key_exists(1, $books)) {
print "Element 1 is How to Cook and Eat in Chinese";
}

要检查具有特定值的元素，使用 in_array()，如例4-16所示。

例4-16。检查具有特定值的元素

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
$meals = array('Walnut Bun' =&gt; 1,
'Cashew Nuts and White Mushrooms' =&gt; 4.95,
'Dried Mulberries' =&gt; 3.00,
'Eggplant with Chili Sauce' =&gt; 6.50,
'Shrimp Puffs' =&gt; 0);
$books = array("The Eater's Guide to Chinese Characters",
'How to Cook and Eat in Chinese');
 
// This is true: key Dried Mulberries has value 3.00
if (in_array(3, $meals)) {
print 'There is a $3 item.';
}
// This is true
if (in_array('How to Cook and Eat in Chinese', $books)) {
print "We have How to Cook and Eat in Chinese";
}
// This is false: in_array() is case-sensitive
if (in_array("the eater's guide to chinese characters", $books)) {
print "We have the Eater's Guide to Chinese Characters.";
}

如果找到具有给定值的元素，则in_array()返回该函数 true。比较字符串时区分大小写。该 array_search()函数类似于in_array()，但如果找到一个元素，则返回元素键而不是 true。在例4-17中， array_search()返回价格为6.50美元的菜肴名称。

例4-17。查找具有特定值的元素

1
2
3
4
5
6
7
8
9
10
$meals = array('Walnut Bun' => 1,
'Cashew Nuts and White Mushrooms' => 4.95,
'Dried Mulberries' => 3.00,
'Eggplant with Chili Sauce' => 6.50,
'Shrimp Puffs' => 0);
 
$dish = array_search(6.50, $meals);
if ($dish) {
print "$dish costs \$6.50";
}

例4-17打印：

1
Eggplant with Chili Sauce costs $6.50

修改数组

你可以对个人进行操作 数组元素 就像常规标量一样 变量，使用算术，逻辑和其他运算符。例4-18显示了对数组元素的一些操作。

例4-18。在数组元素上操作

1
2
3
4
5
6
7
8
9
10
11
$dishes['Beef Chow Foon'] = 12;
$dishes['Beef Chow Foon']++;
$dishes['Roast Duck'] = 3;
 
$dishes['total'] = $dishes['Beef Chow Foon'] + $dishes['Roast Duck'];
 
if ($dishes['total'] &gt; 15) {
print "You ate a lot: ";
}
 
print 'You ate ' . $dishes['Beef Chow Foon'] . ' dishes of Beef Chow Foon.';

例4-18打印：

1
You ate a lot: You ate 13 dishes of Beef Chow Foon.

在双引号字符串或此处文档中插值数组元素值类似于内插数字或字符串。最简单的方法是在数组中包含数组元素，但不要在元素键周围加上引号。这显示在例4-19中。

例4-19。以双引号字符串插值数组元素值

1
2
3
4
5
6
7
$meals['breakfast'] = 'Walnut Bun';
$meals['lunch'] = 'Eggplant with Chili Sauce';
$amounts = array(3, 6);
 
print "For breakfast, I'd like $meals[breakfast] and for lunch,\n";
print "I'd like $meals[lunch]. I want $amounts[0] at breakfast and\n";
print "$amounts[1] at lunch.";

例4-19打印：

1
2
3
For breakfast, I'd like Walnut Bun and for lunch,
I'd like Eggplant with Chili Sauce. I want 3 at breakfast and
6 at lunch.

例4-19中的插值仅适用于仅由字母，数字和下划线组成的数组键。如果您有一个包含空格或其他 标点符号的数组键，请使用花括号进行插值，如例4-20所示。

例4-20。使用花括号插值数组元素值

1
2
3
4
5
$meals['Walnut Bun'] = '$3.95';
$hosts['www.example.com'] = 'website';
 
print "A Walnut Bun costs {$meals['Walnut Bun']}.\n";
print "www.example.com is a {$hosts['www.example.com']}.";

例4-20打印：

1
2
A Walnut Bun costs $3.95.
www.example.com is a website.

在双引号字符串或此处文档中，计算花括号内的表达式，然后将其值放入字符串中。在例4-20中，使用的表达式是单个数组元素，因此元素值被插入到字符串中。

从中删除元素 一个数组，使用unset()：

1
unset($dishes['Roast Duck']);

删除元素unset()不仅仅是将元素值设置0为空字符串。使用时unset()，当您遍历数组或计算数组中的元素数时，元素不再存在。unset()在代表商店库存的数组上使用就像是说商店不再带有产品。将元素的值设置为0空字符串表示该项目暂时缺货。

如果要一次打印数组中的所有值，最快的方法是使用该implode()函数。它通过组合数组中的所有值来生成一个字符串，在每个值之间放置一个字符串分隔符。例4-21打印以逗号分隔的点心选项列表。

例4-21。使用implode（）从数组中创建一个字符串

1
2
3
$dimsum = array('Chicken Bun','Stuffed Duck Web','Turnip Cake');
$menu = implode(', ', $dimsum);
print $menu;

例4-21打印：

1
Chicken Bun, Stuffed Duck Web, Turnip Cake

要破坏没有分隔符的数组，请使用空字符串作为第一个参数implode()：

1
2
$letters = array('A','B','C','D');
print implode('',$letters);

这打印：

1
ABCD

使用implode()简化印刷HTML表中的行，如图实施例4-22。

例4-22。使用implode（）打印HTML表行

1
2
$dimsum = array('Chicken Bun','Stuffed Duck Web','Turnip Cake');
print '<tr><td>' . implode('</td><td>',$dimsum) . '</td></tr>';

例4-22打印：

1
<tr><td>Chicken Bun</td><td>Stuffed Duck Web</td><td>Turnip Cake</td></tr>

该implode()函数在每个值之间放置分隔符，因此要创建一个完整的表行，还必须打印在第一个元素之前的开始标记和在最后一个元素之后的结束标记。

implode()被称为对应物explode()。它将一个字符串分成一个数组。delimiter参数 explode()是它应该寻找的用于分隔数组元素的字符串。例4-23说明 explode()。

例4-23。使用explode（）将字符串转换为数组

1
2
3
$fish = 'Bass, Carp, Pike, Flounder';
$fish_list = explode(', ', $fish);
print "The second fish is $fish_list[1]";

例4-23打印：

1
The second fish is Carp

排序数组

有几种方法可以对数组进行排序。 使用哪种功能取决于方式 你想要对数组进行排序以及它是什么类型的数组。

该sort()函数按其元素值对数组进行排序。 它只应用于数值数组，因为它会重置数组的键 什么时候排序。例4-24显示了排序前后的一些数组。

例4-24。使用sort（）排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
$dinner = array('Sweet Corn and Asparagus',
'Lemon Chicken',
'Braised Bamboo Fungus');
$meal = array('breakfast' => 'Walnut Bun',
'lunch' => 'Cashew Nuts and White Mushrooms',
'snack' => 'Dried Mulberries',
'dinner' => 'Eggplant with Chili Sauce');
 
print "Before Sorting:\n";
foreach ($dinner as $key => $value) {
print " \$dinner: $key $value\n";
}
foreach ($meal as $key => $value) {
print " \$meal: $key $value\n";
}
 
sort($dinner);
sort($meal);
 
print "After Sorting:\n";
foreach ($dinner as $key => $value) {
print " \$dinner: $key $value\n";
}
foreach ($meal as $key => $value) {
print " \$meal: $key $value\n";
}

例4-24打印：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
Before Sorting:
$dinner: 0 Sweet Corn and Asparagus
$dinner: 1 Lemon Chicken
$dinner: 2 Braised Bamboo Fungus
   $meal: breakfast Walnut Bun
   $meal: lunch Cashew Nuts and White Mushrooms
   $meal: snack Dried Mulberries
   $meal: dinner Eggplant with Chili Sauce
After Sorting:
$dinner: 0 Braised Bamboo Fungus
$dinner: 1 Lemon Chicken
$dinner: 2 Sweet Corn and Asparagus
   $meal: 0 Cashew Nuts and White Mushrooms
   $meal: 1 Dried Mulberries
   $meal: 2 Eggplant with Chili Sauce
   $meal: 3 Walnut Bun

两个数组都按元素值按升序重新排列。在第一个值$dinner是现在 Braised Bamboo Fungus，而在第一个值 $meal是Cashew Nuts and White Mushrooms。$dinner在我们排序之前，键 没有改变，因为它是一个数字数组。在这些键 $meal，但是，已经从换成数字 0来3。

排序关联数组按元素值，使用 asort()。这会将键与其值保持在一起。例4-25 显示了用例子排序的例4-24的$meal数组。asort()

例4-25。用asort（）排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
$meal = array('breakfast' =&gt; 'Walnut Bun',
'lunch' =&gt; 'Cashew Nuts and White Mushrooms',
'snack' =&gt; 'Dried Mulberries',
'dinner' =&gt; 'Eggplant with Chili Sauce');
 
print "Before Sorting:\n";
foreach ($meal as $key =&gt; $value) {
print " \$meal: $key $value\n";
}
 
asort($meal);
 
print "After Sorting:\n";
foreach ($meal as $key =&gt; $value) {
print " \$meal: $key $value\n";
}

例4-25打印：

1
2
3
4
5
6
7
8
9
10
Before Sorting:
   $meal: breakfast Walnut Bun
   $meal: lunch Cashew Nuts and White Mushrooms
   $meal: snack Dried Mulberries
   $meal: dinner Eggplant with Chili Sauce
After Sorting:
   $meal: lunch Cashew Nuts and White Mushrooms
   $meal: snack Dried Mulberries
   $meal: dinner Eggplant with Chili Sauce
   $meal: breakfast Walnut Bun

该值以同样的方式与分类asort()与sort()，但是这一次，按键坚持。

虽然sort()和asort()排序元素值数组，你也可以通过与主要排序列 ksort()。这会将键/值对保持在一起，但是按键对它们进行排序。例4-26显示已$meal 排序与ksort()。

例4-26。使用kso​​rt（）排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
$meal = array('breakfast' =&gt; 'Walnut Bun',
'lunch' =&gt; 'Cashew Nuts and White Mushrooms',
'snack' =&gt; 'Dried Mulberries',
'dinner' =&gt; 'Eggplant with Chili Sauce');
 
print "Before Sorting:\n";
foreach ($meal as $key =&gt; $value) {
print " \$meal: $key $value\n";
}
 
ksort($meal);
 
print "After Sorting:\n";
foreach ($meal as $key =&gt; $value) {
print " \$meal: $key $value\n";
}

例4-26打印：

1
2
3
4
5
6
7
8
9
10
Before Sorting:
   $meal: breakfast Walnut Bun
   $meal: lunch Cashew Nuts and White Mushrooms
   $meal: snack Dried Mulberries
   $meal: dinner Eggplant with Chili Sauce
After Sorting:
   $meal: breakfast Walnut Bun
   $meal: dinner Eggplant with Chili Sauce
   $meal: lunch Cashew Nuts and White Mushrooms
   $meal: snack Dried Mulberries

数组被重新排序，因此键现在按升序字母顺序排列。每个元素都保持不变，因此在排序之前，每个键的值在排序之后仍然附加到同一个键。如果对数字数组进行排序ksort()，则对元素进行排序，以使键按升序排列。这与使用array()或 创建数字数组时开始的顺序相同[]。

数组排序函数sort()， asort()并ksort()具有按降序排序的对应项。 该 反向排序功能 被命名为rsort()，arsort()和krsort()。他们工作完全一样sort()， asort()和ksort()，除了它们的排列，因此排序最大（或字母顺序最后）键或值在排序数组中是第一个，后续元素按降序排列。例4-27显示 arsort()了实际操作。

例4-27。使用arsort（）排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
$meal = array('breakfast' =&gt; 'Walnut Bun',
'lunch' =&gt; 'Cashew Nuts and White Mushrooms',
'snack' =&gt; 'Dried Mulberries',
'dinner' =&gt; 'Eggplant with Chili Sauce');
 
print "Before Sorting:\n";
foreach ($meal as $key =&gt; $value) {
print " \$meal: $key $value\n";
}
 
arsort($meal);
 
print "After Sorting:\n";
foreach ($meal as $key =&gt; $value) {
print " \$meal: $key $value\n";
}

例4-27 打印：

1
2
3
4
5
6
7
8
9
10
Before Sorting:
   $meal: breakfast Walnut Bun
   $meal: lunch Cashew Nuts and White Mushrooms
   $meal: snack Dried Mulberries
   $meal: dinner Eggplant with Chili Sauce
After Sorting:
   $meal: breakfast Walnut Bun
   $meal: dinner Eggplant with Chili Sauce
   $meal: snack Dried Mulberries
   $meal: lunch Cashew Nuts and White Mushrooms

该arsort()函数保持键和值之间的关联，就像asort()，但将元素放在相反的顺序（按值）。值以值开头的元素W现在是第一个，而值以值开头的元素C是最后一个。

使用多维数组

正如提到的“数组基础”中，数组元素的值可以是另一个数组。当您想要存储结构比仅包含键和单个值更复杂的数据时，这非常有用。标准的键/值对可以用于将餐名（例如breakfast或 lunch）与单个菜肴（例如 Walnut Bun或 Chicken with Cashew Nuts）匹配，但是当每餐由多个菜组成时呢？然后，元素值应该是数组，而不是字符串。

使用 array() 构造或[]短数组语法创建具有更多数组的数组 元素值，如例4-28所示。

例4-28。使用array（）和[]创建多维数组

1
2
3
4
5
6
7
8
9
10
11
12
$meals = array('breakfast' => ['Walnut Bun','Coffee'],
'lunch' => ['Cashew Nuts', 'White Mushrooms'],
'snack' => ['Dried Mulberries','Salted Sesame Crab']);
 
$lunches = [ ['Chicken','Eggplant','Rice'],
['Beef','Scallions','Noodles'],
['Eggplant','Tofu'] ];
 
$flavors = array('Japanese' => array('hot' => 'wasabi',
'salty' => 'soy sauce'),
'Chinese' => array('hot' => 'mustard',
'pepper-salty' => 'prickly ash'));

通过使用更多方括号来识别元素，从而访问这些数组数组中的元素。每组方括号都进入整个数组。 例4-29演示了如何访问例4-28中定义的数组元素。

例4-29。访问多维数组元素

1
2
3
4
5
6
print $meals['lunch'][1]; // White Mushrooms
print $meals['snack'][0]; // Dried Mulberries
print $lunches[0][0]; // Chicken
print $lunches[2][1]; // Tofu
print $flavors['Japanese']['salty']; // soy sauce
print $flavors['Chinese']['hot']; // mustard

数组的每个级别称为维度。在本节之前，本章中的所有数组都是 一维数组。它们每个都有一个级别的键。阵列如 $meals，$lunches，和 $flavors，在所示实施例4-29，被称为多维数组，因为它们每个都具有一个以上的尺寸。

您还可以使用方括号语法创建或修改多维数组。例4-30显示了一些多维数组操作。

例4-30。操纵多维数组

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
$prices['dinner']['Sweet Corn and Asparagus'] = 12.50;
$prices['lunch']['Cashew Nuts and White Mushrooms'] = 4.95;
$prices['dinner']['Braised Bamboo Fungus'] = 8.95;
 
$prices['dinner']['total'] = $prices['dinner']['Sweet Corn and Asparagus'] +
$prices['dinner']['Braised Bamboo Fungus'];
 
$specials[0][0] = 'Chestnut Bun';
$specials[0][1] = 'Walnut Bun';
$specials[0][2] = 'Peanut Bun';
$specials[1][0] = 'Chestnut Salad';
$specials[1][1] = 'Walnut Salad';
// Leaving out the index adds it to the end of the array
// This creates $specials[1][2]
$specials[1][] = 'Peanut Salad';

迭代每个维度 多维数组，使用嵌套foreach()或 for()循环。例4-31用于 foreach()迭代通过多维关联 阵列。

例4-31。使用foreach（）迭代多维数组

1
2
3
4
5
6
7
8
9
10
11
12
$flavors = array('Japanese' => array('hot' => 'wasabi',
'salty' => 'soy sauce'),
'Chinese' => array('hot' => 'mustard',
'pepper-salty' => 'prickly ash'));
 
// $culture is the key and $culture_flavors is the value (an array)
foreach ($flavors as $culture => $culture_flavors) {
// $flavor is the key and $example is the value
foreach ($culture_flavors as $flavor => $example) {
print "A $culture $flavor flavor is $example.\n";
}
}

例4-31打印：

1
2
3
4
A Japanese hot flavor is wasabi.
A Japanese salty flavor is soy sauce.
A Chinese hot flavor is mustard.
A Chinese pepper-salty flavor is prickly ash.

例4-31中的第一个foreach()循环遍历第一个维度 。存储在密钥 是字符串 和，并存储在值被认为是该尺寸的元素值的阵列。下一 对这些元件值阵列进行迭代，复印键，如和 进入，和值，诸如和成。第二个代码块使用两个语句中的变量来打印出完整的消息。$flavors$cultureJapaneseChinese$culture_flavorsforeach()hotsalty$flavorwasabisoy sauce$exampleforeach()foreach()

就像嵌套foreach()循环遍历多维一样关联数组，嵌套 for() 循环遍历一个多维数字数组，如例4-32所示 。

例4-32。使用for（）迭代多维数组

1
2
3
4
5
6
7
8
9
10
$specials = array( array('Chestnut Bun', 'Walnut Bun', 'Peanut Bun'),
array('Chestnut Salad','Walnut Salad', 'Peanut Salad') );
 
// $num_specials is 2: the number of elements in the first dimension of $specials
for ($i = 0, $num_specials = count($specials); $i &lt; $num_specials; $i++) {
// $num_sub is 3: the number of elements in each subarray
for ($m = 0, $num_sub = count($specials[$i]); $m &lt; $num_sub; $m++) {
print "Element [$i][$m] is " . $specials[$i][$m] . "\n";
}
}

例4-32打印：

1
2
3
4
5
6
Element [0][0] is Chestnut Bun
Element [0][1] is Walnut Bun
Element [0][2] is Peanut Bun
Element [1][0] is Chestnut Salad
Element [1][1] is Walnut Salad
Element [1][2] is Peanut Salad

在例4-32中，外for() 循环遍历两个元素$specials。内for()循环遍历包含不同字符串的子数组的每个元素。在 print语句中，$i是第一维中的索引（元素 $specials），并且$m是第二维（子数组）中的索引。

从多维数组中插入值 进入双引号字符串或此处文档，使用 例4-20中的大括号语法。例4-33使用花括号进行插值，以产生与例4-32相同的输出。事实上，例4-33中唯一不同的是print 声明。

例4-33。多维数组元素值插值

1
2
3
4
5
6
7
8
9
10
$specials = array( array('Chestnut Bun', 'Walnut Bun', 'Peanut Bun'),
array('Chestnut Salad','Walnut Salad', 'Peanut Salad') );
 
// $num_specials is 2: the number of elements in the first dimension of $specials
for ($i = 0, $num_specials = count($specials); $i &lt; $num_specials; $i++) {
// $num_sub is 3: the number of elements in each subarray
for ($m = 0, $num_sub = count($specials[$i]); $m &lt; $num_sub; $m++) {
print "Element [$i][$m] is {$specials[$i][$m]}\n";
}
}

章节总结

这个 章节 覆盖：

  • 了解数组的组件：元素，键和值
  • 在程序中以两种方式定义数组：with array()和with short array syntax
  • 使用方括号将数组添加到数组中
  • 了解PHP为带有数字键的数组提供的快捷方式
  • 计算数组中的元素数
  • 使用访问数组的每个元素 foreach()
  • 交替表行CSS类名foreach()和类名数组
  • 修改foreach() 代码块 内的数组元素值
  • 使用访问数值数组的每个元素 for()
  • 使用for()和模运算符（%） 交替表行CSS类名
  • 了解数组元素的顺序foreach()和 for()访问数组元素
  • 检查具有特定键的数组元素
  • 检查具有特定值的数组元素
  • 以字符串形式插入数组元素值
  • 从数组中删除元素
  • 使用生成数组的字符串 implode()
  • 从字符串生成数组 explode()
  • 对数组排序用sort()，asort()或ksort()
  • 反向排序数组
  • 定义多维数组
  • 访问多维数组的各个元素
  • 使用foreach()或访问多维数组中的每个元素 for()
  • 在字符串中插入多维数组元素

演习

1. 根据美国人口普查局的数据，2010年美国10个最大的城市（按人口计算）如下：

  • 纽约州纽约市（8,175,133人）
  • 加利福尼亚州洛杉矶（3,792,621）
  • 伊利诺伊州芝加哥（2,695,598）
  • 德克萨斯州休斯顿（2,100,263）
  • 宾夕法尼亚州费城（1,526,006）
  • 亚利桑那州凤凰城（1,445,632）
  • 德克萨斯州圣安东尼奥（1,327,407）
  • 加利福尼亚州圣地亚哥（1,307,402）
  • 德克萨斯州达拉斯（1,197,816）
  • 加利福尼亚州圣何塞（945,942）

定义一个包含有关位置和总体的信息的数组（或数组）。打印包含所有10个城市总人口的位置和人口信息表。

2. 将解决方案修改为上一个练习，以便结果表中的行按填充排序。然后修改您的解决方案，以便按城市名称排序行。

3. 将解决方案修改为第一个练习，以便该表还包含保存城市列表中表示的每个州的州人口总数的行。

4. 对于以下每种信息，请说明如何将其存储在数组中，然后提供创建具有少量元素的此类数组的示例代码。例如，对于第一个项目，您可能会说，“一个关联数组，其键是学生的名称，其值是成绩和ID号的关联数组”，如下所示：

1
2
$students = [ 'James D. McCawley' => [ 'grade' => 'A+','id' => 271231 ],
'Buwei Yang Chao' => [ 'grade' => 'A', 'id' => 818211] ];

  1. 班级学生的成绩和身份证号码
  2. 商店库存中每件商品的数量有多少
  3. 学校午餐一周：每餐的不同部分（主菜，配菜，饮料等）和每天的费用
  4. 你家里人的名字
  5. 中国人的姓名，年龄和与你的关系 你的家人

如果有不懂的地方请留言，SKY8G网站编辑者专注于研究IT源代码研究与开发。希望你下次光临，你的认可和留言是对我们最大的支持，谢谢！

上一篇: 第3章逻辑：做出决定并重复自己

下一篇: 第5章逻辑组：函数和文件

请 登录 评论
avatar