PHP 笔记——Array 数组

要点	说明
数组构成	数组是由一个或多个数组元素组成的
数组元素	每个数组元素由键（Key）和值（Value）构成
键	元素的识别名称，也被称为数组下标
值	元素的内容
映射	键 和 值 之间存在一种对应关系，称之为映射
类型划分	根据键的数据类型，可以将数组划分为索引数组和关联数组

1、索引数组

索引数组是指键名为整数的数组。默认情况下，索引数组的键名是从0开始，并依次递增。它主要适用于利用位置（0、1、2……）来标识数组元素。另外，索引数组的键名也可以自己指定。

2、关联数组

关联数组是指键名为字符串的数组。关联数组的“键”“是字符串或数值的混合，并与“值”之间具有一一对应的关系。

3、定义数组

数组定义的方式

• array()语言结构法
• 赋值方式
• 短数组定义法（ [ ] ）

3.1、array()语言结构法

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

array()语言结构法：

array array([ mixed $...] );

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

3.2、赋值方式

使用赋值方式定义数组，实际上就是创建一个数组变量，然后使用赋值运算符直接给变量赋值。

$arr[] = 123; 			// 存储结果：$arr[0] = 123
$arr[] = 'hello'; 		// 存储结果：$arr[1] = 'hello'
$arr[4] = 'PHP'; 		// 存储结果：$arr[4] = 'PHP'
$arr['name'] = 'Tom'; 	// 存储结果：$arr['name'] = 'Tom'
$arr[] = 'Java'; 		// 存储结果：$arr[5] = 'Java'
echo '<pre>';
var_dump($arr);
// echo "<br>";
print_r($arr);
echo '</pre>';

赋值方式定义数组就是单独为数组元素赋值。

需要注意的是，赋值方式不能定义一个空数组。

3.3、短数组定义法（ [ ] ）

短数组定义法（[ ]）与array()语法结构相同，只需将array()替换为 [ ] 即可。

// 相当于：array('wind', 'fine')
$weather = ['wind', 'fine'];

// 相当于：array('id' => 12, 'name' => 'PHP')
$object = ['id' => 12, 'name' => 'PHP'];

// 相当于：array(array(1, 3), array(2, 4))
$num = [[1, 3], [2, 4]];

4、二维数组

$arr = array (
			"PHP类图书" => array ("PHP从入门到精通","PHP典型模块","PHP标准教程"),
			"JAVA类图书"=> array ("a"=>"JAVA范例手册","b"=>"JAVA WEB范例宝典"),
			"ASP类图书" => array ("ASP从入门到精通",2=>"ASP范例宝典","ASP典型模块")
		);
echo '<pre>';
var_dump($arr);
// echo "<br>";
print_r($arr);
echo '</pre>';

5、访问数组

数组定义完成后，若想要查看数组中某个具体的元素，则可以通过 “数组名[键]” 的方式获取。

$sub = ['PHP', 'Java', 'C', 'Android'];
$data = ['goods' => 'clothes', 'num' => 49.90, 'sales' => 500];
echo $sub[1]; 			// 输出结果：Java
echo $sub[3]; 			// 输出结果：Android
echo $data['goods']; 	// 输出结果：clothes
echo $data['sales']; 	// 输出结果：500

echo '<pre>';
print_r($sub); 			// print_r()函数打印数组变量$sub
var_dump($data);		// var_dump()函数打印数组变量$data
echo '</pre>';

// print_r()打印结果
Array
(
    [0] => PHP
    [1] => Java
    [2] => C
    [3] => Android
)

// var_dump()打印结果
array(3) {
    ["goods"]=>
    string(7) "clothes"
    ["num"]=>
    float(49.9)
    ["sales"]=>
    int(500)
}

6、遍历数组

• foreach
• each
• list
• list、each

6.1、foreach

通常情况下，使用 foreach() 语句完成数组的遍历。

foreach (数组名称 as 键 => 值){
// 处理语句
}
foreach (数组名称 as 值) {
// 处理语句
}

//实例：
$sub = ['PHP', 'Java', 'C', 'Android'];
$data = ['goods' => 'clothes', 'num' => 49.90, 'sales' => 500];

foreach ($data as $k => $v) {
echo $k . ': ' . $v . '<br>';
}

foreach ($sub as $v) {
echo $v . '<br>';
}

6.2、each

• each()函数返回一个包含数组当前元素键/值对应的数组，并将数组指针指向下一个数组元素。
• each()函数返回的数组包含4个元素，元素键依次为1、value、0和key。1和value对应元素为原数组元素的值，0和key对应元素为原数组元素的键。
• 如果数组指针指向了数组末尾（最后一个元素之后），则返回FALSE

$a = array("name" => "Mike", "sex" => "男", "age" => 30);
print_r($a);
echo "<br>";
while ($b = each($a)) {
	// var_dump($b);
	print_r($b);
	echo "<br>";
}

// 输出结果
Array ( [name] => Mike [sex] => 男 [age] => 30 )
Array ( [1] => Mike [value] => Mike [0] => name [key] => name )
Array ( [1] => 男 [value] => 男 [0] => sex [key] => sex )
Array ( [1] => 30 [value] => 30 [0] => age [key] => age )

6.3、list

list() 函数用于将数组中各个元素的值赋值给指定的变量。

list() 函数依次将下标为0、1、2…的数组元素赋值为指定的变量。

如果数组中的元素没有这些下标，变量值为NULL，PHP会产生一个Notice错误信息。

// 例一：
$a = array("one", "two", "three");
print_r($a);
list($x, $y, $z) = $a;
echo '<br>list($x, $y, $z) = $a'."<br>";
echo "\$x = $x &nbsp;&nbsp; \$y = $y &nbsp;&nbsp; \$z = $z";
// 输出结果
Array ( [0] => one [1] => two [2] => three )
list($x, $y, $z) = $a
$x = one    $y = two    $z = three

// 例二：
$a = array(2 => "one", 1 => "two", 0 => "three");
print_r($a);
list($x, $y, $z) = $a;
echo '<br>list($x, $y, $z) = $a'."<br>";
echo "\$x = $x &nbsp;&nbsp; \$y = $y &nbsp;&nbsp; \$z = $z";
// 输出结果
Array ( [2] => one [1] => two [0] => three )
list($x, $y, $z) = $a
$x = three    $y = two    $z = one

// 例三：
$a = array("one", "b" => "two", "three", "four");
print_r($a);
list($x, $y, $z) = $a;
echo '<br>list($x, $y, $z) = $a'."<br>";
echo "\$x = $x &nbsp;&nbsp; \$y = $y &nbsp;&nbsp; \$z = $z";
// 输出结果
Array ( [0] => one [b] => two [1] => three [2] => four )
list($x, $y, $z) = $a
$x = one    $y = three    $z = four

// 例四：
$a = array("one", "two", 3 => "three", "four");
print_r($a);
list($x, $y, $z) = $a;
echo '<br>list($x, $y, $z) = $a'."<br>";
echo "\$x = $x &nbsp;&nbsp; \$y = $y &nbsp;&nbsp; \$z = $z";
// 输出结果
Array ( [0] => one [1] => two [3] => three [4] => four )
Notice: Undefined offset: 2 in D:\Program File\PHPStudy\PHPTutorial\WWW\index.php on line 14
list($x, $y, $z) = $a
$x = one    $y = two    $z =

6.4、list、each

$array=array(0 =>'PHP自学视频教程', 1 =>'JAVA自学视频教程', 2 =>'VB自学视频教程',3=>"VC自学视频教程");
//遍历数组中的数据
while(list($name,$value)=each($array)){
	//输出遍历结果
	echo "$name = $value"."<br>";
}

// 输出结果
0 = PHP自学视频教程
1 = JAVA自学视频教程
2 = VB自学视频教程
3 = VC自学视频教程

7、创建数组的函数

• range() 函数
• array_combine() 函数：用两个数组创建一个新的数组
• array_merge() 函数：将多个数组连接成一个新的数组。
• + 运算符
• array_fill()函数

7.1、range() 函数

语法格式：

array range( mixed $start, mixed $end[, number $step = 1] )

• start：序列的第一个值。

• end：序列结束于 end 的值。

• step：如果设置了步长 step，会被作为单元之间的步进值。step 应该为正值。不设置step 则默认为 1。

$a = range(0, 5);
print_r($a);	echo "<br>";
$b = range(5, 0);
print_r($b);	echo "<br>";
$c = range(0.3, 5);
print_r($c);	echo "<br>";
$d = range(1, 8, 2);
print_r($d);	echo "<br>";
$e = range('a', 'e');
print_r($e);	echo "<br>";
$f = range('a', 'e', 2);
print_r($f);

// 输出结果
Array ( [0] => 0 [1] => 1 [2] => 2 [3] => 3 [4] => 4 [5] => 5 )
Array ( [0] => 5 [1] => 4 [2] => 3 [3] => 2 [4] => 1 [5] => 0 )
Array ( [0] => 0.3 [1] => 1.3 [2] => 2.3 [3] => 3.3 [4] => 4.3 )
Array ( [0] => 1 [1] => 3 [2] => 5 [3] => 7 )
Array ( [0] => a [1] => b [2] => c [3] => d [4] => e )
Array ( [0] => a [1] => c [2] => e )

7.2、array_combine() 函数

​用两个数组创建一个新的数组。一个数组的值作为其键名，另一个数组的值作为其值 。返回合并的 array，如果两个数组的单元数不同则返回 FALSE。

​语法格式：

array array_combine( array $keys, array $values)

​ 示例：

$a = array('green', 'red', 'yellow');
$b = array('avocado', 'apple', 'banana');
$c = array_combine($a, $b);

echo "<pre>";
print_r($c);
echo "</pre>";

// 输出结果
Array
(
    [green] => avocado
    [red] => apple
    [yellow] => banana
)

7.3、array_merge() 函数

​将多个数组连接成一个新的数组。一个数组中的值附加在前一个数组的后面。返回作为结果的数组。

如果输入的数组中有相同的字符串键名，则该键名后面的值将覆盖前一个值。然而，如果数组包含数字键名，后面的值将不会覆盖原来的值，而是附加到后面。

​如果只给了一个数组并且该数组是数字索引的，则键名会以连续方式重新索引。

语法格式：

array array_merge( array $array1[, array $...] )

​ 示例：

$array1 = array("color" => "red", 2, 4);
$array2 = array("a", "b", "color" => "green", "shape" => "trapezoid", 4);
$result = array_merge($array1, $array2);

echo "<pre>";
print_r($result);
echo "</pre>";

// 输出结果
Array
(
    [color] => green
    [0] => 2
    [1] => 4
    [2] => a
    [3] => b
    [shape] => trapezoid
    [4] => 4
)

$array1 = array();
$array2 = array(1 => "data");
$result = array_merge($array1, $array2);

echo "<pre>";
print_r($result);
echo "</pre>";

// 数字键名将会被重新编号！
// 输出结果
Array
(
    [0] => data
)

$array1 = array(1 => "data");
$array2 = array(1 => "data");
$result = array_merge($array1, $array2);

echo "<pre>";
print_r($result);
echo "</pre>";

// 数字键名，后面的值将不会覆盖原来的值，而是附加到后面。
// 输出结果
Array
(
    [0] => data
    [1] => data
)

7.4、 + 运算符

​ 第一个数组的键名将会被保留。在两个数组中存在相同的键名时，第一个数组中的同键名的元素将会被保留，第二个数组中的元素将会被忽略。

​ 示例：

$array1 = array("name" => 'Jom', "id" => '211606', "sex" => '男');
$array2 = array("lv" => '大学', "sex" => '女', "like" => 'swim');
$result1 = $array1 + $array2;
$result2 = array_merge($array1, $array2);

echo "<pre>";
print_r($result1);
print_r($result2);
echo "</pre>";

// 输出结果
Array
(
    [name] => Jom
    [id] => 211606
    [sex] => 男
    [lv] => 大学
    [like] => swim
)
Array
(
    [name] => Jom
    [id] => 211606
    [sex] => 女
    [lv] => 大学
    [like] => swim
)

7.5、array_fill() 函数

​ 用给定的值填充数组。

​ 语法格式：

array array_fill( int $start_index, int $num, mixed $value)

• start_index：返回的数组的第一个索引值。 如果 start_index 是负数，那么返回的数组的第一个索引将会是 start_index ，而后面索引则从0开始。

• num：插入元素的数量。 必须大于或等于 0。

• value：用来填充的值。

  示例：

$a = array_fill(5, 6, 'banana');
$b = array_fill(-2, 4, 'pear');

echo "<pre>";
print_r($a);
print_r($b);
echo "</pre>";

// 输出结果
Array
(
    [5] => banana
    [6] => banana
    [7] => banana
    [8] => banana
    [9] => banana
    [10] => banana
)
Array
(
    [-2] => pear
    [0] => pear
    [1] => pear
    [2] => pear
)

8、 数组函数

8.1、数组统计

• count() 函数：用于对数组中的元素个数进行统计。
• max() 函数：用于计算数组中元素的最大值。
• min() 函数：用于计算数组中元素的最小值。
• array_sum() 函数：用于计算数组中所有值的和。
• array_count_values() 函数：用于计算数组中所有元素的值出现次数。

8.1.1、count() 函数

​ 用于对数组中的元素个数进行统计。

int count( mixed $array_or_countable[, int $mode = COUNT_NORMAL] )

• array_or_countable： 数组或者 Countable 对象。

• mode：如果可选的 mode 参数设为 COUNT_RECURSIVE（或 1），count() 将递归地对数组计数。对计算多维数组的所有单元尤其有用。

  示例：

$a[0] = 1;
$a[1] = 3;
$a[2] = 5;
var_dump(count($a));

// 输出结果
int(3)

$food = array(
    'fruits' => array('orange', 'banana', 'apple'),
    'veggie' => array('carrot', 'collard', 'pea')
);

echo count($food, COUNT_RECURSIVE); // 输出 8
echo "<br>";
echo count($food); 					// 输出 2

8.1.2、max() 函数

​ 用于计算数组中元素的最大值。

mixed max( array $values)

​ 示例：

$a = array(3,6,9,5);
$b = array("a","b","c","d");
echo max($a);					// 输出 9
echo "<br>";
echo max($b);					// 输出 d

8.1.3、min() 函数

​ 用于计算数组中元素的最小值。

mixed min( array $values)

​ 示例：

$a = array(3,6,9,5);
$b = array("a","b","c","d");
echo min($a);					// 输出 3
echo "<br>";
echo min($b);					// 输出 a

$a = array(9,5,"a","b");
$b = array(-4,-1,"a","b");
echo min($a);					// 输出 a
echo "<br>";
echo max($a);					// 输出 9
echo "<br>";
echo min($b);					// 输出 -4
echo "<br>";
echo max($b);					// 输出 b

8.1.4、array_sum() 函数

​ 用于计算数组中所有值的和。

number array_sum( array $array)

​ 示例：

$a = array(2, 4, 6, 8);
echo "sum(a) = " . array_sum($a) . "<br>";

$b = array("a" => 1.2, "b" => 2.3, "c" => 3.4);
echo "sum(b) = " . array_sum($b) . "<br>";

$c = array(2, 4, 1.2, 2.3);
echo "sum(c) = " . array_sum($c) . "<br>";

$d = array("d", "c", "a", "b");
echo "sum(d) = " . array_sum($d) . "<br>";

$e = array(1, 1.2, "a", "b");
echo "sum(e) = " . array_sum($e) . "<br>";

// 输出结果
sum(a) = 20
sum(b) = 6.9
sum(c) = 9.5
sum(d) = 0
sum(e) = 2.2

8.1.5、array_count_values() 函数

​ 用于计算数组中元素出现次数。

array array_count_values( array $array )

​ 示例：

$array = array(1, "hello", 1, "world", "hello");
echo "<pre>";
print_r(array_count_values($array));
echo "</pre>";

// 输出结果
Array
(
    [1] => 2
    [hello] => 2
    [world] => 1
)

8.2、数组指针

函数	说明
next()	使数组指针指向下一个元素。
prev()	使数组指针指向前一个元素。
end()	使数组指针指向最后一个元素。
reset()	使数组指针指向第一个元素。
current()	返回当前数组元素的值。
key()	返回当前数组元素的键名。

$a = array('foot', 'bike', 'car', 'plane');
// Array ( [0] => foot [1] => bike [2] => car [3] => plane ) 

print_r($a);
echo "<br>";
echo key($a)."<br>";			// 0
echo next($a)."<br>";			// bike
echo key($a)."<br>";			// 1

echo "<br>";
echo key($a)."<br>"; 			// 1
echo prev($a)."<br>";			// foot
echo key($a)."<br>";			// 0

echo "<br>";
echo key($a)."<br>";			// 0
echo end($a)."<br>";			// plane
echo key($a)."<br>";			// 3

echo "<br>";
echo key($a)."<br>";			// 3
echo reset($a)."<br>";			// foot
echo key($a)."<br>";			// 0

8.3、数组和变量之间的转换

函数	说明
extract ()	使用数组定义一组变量
compact ()	使用变量建立数组。

8.3.1、extract() 函数：使用数组定义一组变量

int extract( array &$array[, int $flags = EXTR_OVERWRITE[, string $prefix = NULL]] )

• array：一个关联数组。此函数会将键名当作变量名，值作为变量的值。对每个键／值对都会在当前的符号表中建立变量，并受到 flags 和 prefix 参数的影响。
• flags：对待非法／数字和冲突的键名的方法将根据取出标记 flags 参数决定。可以是以下值之一：
  • EXTR_OVERWRITE：默认，如果有冲突，覆盖已有的变量。
  • EXTR_SKIP：如果有冲突，不覆盖已有的变量。
  • EXTR_PREFIX_SAME：如果有冲突，在变量名前加上前缀 prefix。
  • EXTR_PREFIX_ALL：给所有变量名加上前缀 prefix。
  • EXTR_PREFIX_INVALID：仅在非法／数字的变量名前加上前缀 prefix。
  • EXTR_IF_EXISTS：仅在当前符号表中已有同名变量时，覆盖它们的值。其它的都不处理。举个例子，以下情况非常有用：定义一些有效变量，然后从 $_REQUEST 中仅导入这些已定义的变量。
  • EXTR_PREFIX_IF_EXISTS：仅在当前符号表中已有同名变量时，建立附加了前缀的变量名，其它的都不处理。
  • EXTR_REFS：将变量作为引用提取。这有力地表明了导入的变量仍然引用了 array 参数的值。可以单独使用这个标志或者在 flags 中用 OR 与其它任何标志结合使用。
• prefix：仅在 flags 的值是 EXTR_PREFIX_SAME，EXTR_PREFIX_ALL，EXTR_PREFIX_INVALID 或 EXTR_PREFIX_IF_EXISTS 时需要。

$size = "large";
$var_array = array("color" => "blue", "size"  => "medium", "shape" => "sphere");
extract($var_array, EXTR_PREFIX_SAME, "wddx");

echo "$color, $size, $shape, $wddx_size\n";

// 输出结果
blue, large, sphere, medium

$arr = array("name"=>"张三","sex"=>"男","age"=>20);
extract($arr);
echo "$name, $sex, $age";

// 输出结果
张三, 男, 20

8.3.2、compact() 函数：使用变量建立数组

array compact( mixed $varname1[, mixed $...] )

$a = "asp";
$b = "php";
$c = "jsp";
$result = compact("a","b","c");

// 输出结果
Array ( [a] => asp [b] => php [c] => jsp )

8.4、数组检索函数

8.4.1、array_keys() 函数

​ 返回数组中部分的或所有的键名。

array array_keys( array $array[, mixed $search_value = null[, bool $strict = false]] )

• input：一个数组，包含了要返回的键。
• search_value：如果指定了这个参数，只有包含这些值的键才会返回。
• strict：判断在搜索的时候是否该使用严格的比较（===）。

$array = array(0 => 100, "color" => "red");
print_r(array_keys($array));			// Array ( [0] => 0 [1] => color )
echo "<br>";	

$array = array("blue", "red", "green", "blue", "blue");
print_r(array_keys($array, "blue"));	// Array ( [0] => 0 [1] => 3 [2] => 4 )
echo "<br>";	

$array = array("color" => array("blue", "red", "green"),
               "size"  => array("small", "medium", "large"));
print_r(array_keys($array));	 		// Array ( [0] => color [1] => size )

8.4.2、array_values() 函数

​ 获取数组中所有的值。

array array_values( array $array)

$array = array ("手册" => "php函数手册", "php基础应用",
"php" => "php函数手册", "php基础应用", "php典型案例");
$result = array_values($array);

echo "<pre>";
print_r($result);
echo "</pre>";

// 输出结果
Array
(
    [0] => php函数手册
    [1] => php基础应用
    [2] => php函数手册
    [3] => php基础应用
    [4] => php典型案例
)

8.4.3、in_array () 函数

​ 检查数组中是否存在某个值

bool in_array( mixed $needle, array $haystack[, bool $strict = FALSE] )

• needle：待搜索的值。 如果 needle 是字符串，则比较是区分大小写的。
• haystack：待搜索的数组。
• strict：如果第三个参数 strict 的值为 TRUE 则 in_array() 函数还会检查 needle 的类型是否和 haystack 中的相同。

$os = array("Mac", "NT", "Irix", "Linux");
if (in_array("Irix", $os)) {
    echo "Got Irix"."<br>";								// 没输出
}
if (in_array("mac", $os)) {
    echo "Got mac"."<br>"; 								// 输出
}

$a = array('1.10', 12.4, 1.13);
if (in_array('12.4', $a, true)) {
    echo "'12.4' found with strict check"."<br>"; 		// 没输出
}
if (in_array(1.13, $a, true)) {
    echo "1.13 found with strict check"."<br>"; 		// 输出
}

8.4.4、array_search () 函数

​ 在数组中搜索给定的值，如果成功则返回首个相应的键名。

mixed array_search( mixed $needle, array $haystack[, bool $strict = false] )

​ 参数说明同 in_array () 函数。

$array = array(0 => 'blue', 1 => 'red', 2 => 'green', 3 => 'red');

$key = array_search('green', $array); // $key = 2;
$key = array_search('red', $array);   // $key = 1;

8.4.5、array_key_exists () 函数

​ 检查数组里是否有指定的键名或索引。仅仅搜索第一维的键。多维数组里嵌套的键不会被搜索到。

bool array_key_exists( mixed $key, array $array)

$array = array("php" => 58, "ajax" => 54);
if (array_key_exists("php", $array)) {
	echo "php在数组中";					// 有输出
}

8.4.6、array_unique() 函数

​ 删除数组中重复的数。 注意键名保留不变。array_unique() 先将值作为字符串排序，然后对每个值只保留第一个遇到的键名，接着忽略所有后面的键名。这并不意味着在未排序的 array 中同一个值的第一个出现的键名会被保留。

array array_unique( array $array[, int $sort_flags = SORT_STRING] )

• array：输入的数组。
• sort_flags：第二个可选参数sort_flags 可用于修改排序行为：
  • 排序类型标记：
    
    ◦ SORT_REGULAR - 按照通常方法比较（不修改类型）
    
    ◦ SORT_NUMERIC - 按照数字形式比较
    
    ◦ SORT_STRING - 按照字符串形式比较
    
    ◦ SORT_LOCALE_STRING - 根据当前的本地化设置，按照字符串比较。

$input = array("a" => "green", "red", "b" => "green", "blue", "red");
$result = array_unique($input);
echo "<pre>";
print_r($result);
echo "</pre>";

// 输出结果
Array
(
    [a] => green
    [0] => red
    [1] => blue
)

8.5、数组排序

函数名称	功能描述
sort ()	根据元素值升序排序，排序后元素的下标按顺序为0、1、2…
asort ()	根据元素值升序排序，保持原有的键值
rsort ()	sort () 的逆序
arsort ()	asort () 的逆序
ksort ()	根据键升序排序，保持键值对
krsort ()	ksort () 的逆序
natsort ()	对值按照 “自然排序” 升序，保持键值对。
natcasesort ()	对值按照 “自然排序” 升序，不区分大小写，保持键值对。

8.5.1、sort () 函数

​ 根据元素值升序排序，排序后的数组赋予新的“整数”键名。

bool sort( array &$array[, int $sort_flags = SORT_REGULAR] )

• array：要排序的数组。
• sort_flags：可选的第二个参数 sort_flags 可以用以下值改变排序的行为：
  • 排序类型标记：
    
    ◦ SORT_REGULAR - 正常比较单元（不改变类型）
    
    ◦ SORT_NUMERIC - 单元被作为数字来比较
    
    ◦ SORT_STRING - 单元被作为字符串来比较
    
    ◦ SORT_LOCALE_STRING - 根据当前的区域（locale）设置来把单元当作字符串比较，可以用 setlocale() 来改变。
    
    ◦ SORT_NATURAL - 和 natsort() 类似对每个单元以"自然的顺序"对字符串进行排序。 PHP 5.4.0 中新增的。
    
    ◦ SORT_FLAG_CASE - 能够与 SORT_STRING 或 SORT_NATURAL 合并（OR 位运算），不区分大小写排序字符串。

$fruits = array("a" => "lemon", "b" => "orange", "d" => "banana", "h" => "apple");
print_r($fruits);
echo "<br>";
sort($fruits);

print_r($fruits);
echo "<br>";
foreach ($fruits as $key => $val) {
    echo "fruits[" . $key . "] = " . $val . "<br>";
}

// 输出结果
Array ( [a] => lemon [b] => orange [d] => banana [h] => apple )
Array ( [0] => apple [1] => banana [2] => lemon [3] => orange )
fruits[0] = apple
fruits[1] = banana
fruits[2] = lemon
fruits[3] = orange

8.5.2、asort () 函数

​ 对数组进行排序并保持索引关系。

bool asort( array &$array[, int $sort_flags = SORT_REGULAR] )

​ 参数说明与 sort () 函数一致。

$fruits = array("d" => "lemon", "a" => "orange", "b" => "banana", "c" => "apple");
asort($fruits);
foreach ($fruits as $key => $val) {
    echo "$key => $val"."<br>";
}

// 输出结果
c => apple
b => banana
d => lemon
a => orange

8.5.3、ksort () 函数

​ 根据数组元素的“键名”以升序排序。

bool ksort( array &$array[, int $sort_flags = SORT_REGULAR] )

​ 参数说明与 sort () 函数一致。

$fruits = array("d" => "lemon", "a" => "orange", "b" => "banana", "c" => "apple");
ksort($fruits);
foreach ($fruits as $key => $val) {
    echo "$key => $val"."<br>";
}

// 输出结果
a => orange
b => banana
c => apple
d => lemon

8.6、数组与数据结构

函数	说明
array_push ()	将一个或多个单元压入数组的末尾（入栈）
array_pop ()	弹出数组最后一个单元（出栈）
array_shift ()	将数组开头的单元移出数组
array_unshift ()	在数组开头插入一个或多个单元

int array_push( array &$array, mixed $value1[, mixed $...] );
mixed array_pop( array &$array);
mixed array_shift( array &$array);
int array_unshift( array &$array, mixed $value1[, mixed $...] )

$stack = array("orange", "banana");
array_push($stack, "apple", "raspberry");
print_r($stack);
// Array ( [0] => orange [1] => banana [2] => apple [3] => raspberry )
echo "<br>";

$stack = array("orange", "banana", "apple", "raspberry");
$fruit = array_pop($stack);			// $fruit = raspberry
print_r($stack);
// Array ( [0] => orange [1] => banana [2] => apple )
echo "<br>";

$stack = array("orange", "banana", "apple", "raspberry");
$fruit = array_shift($stack);		// $fruit = orange
print_r($stack);
// Array ( [0] => banana [1] => apple [2] => raspberry )
echo "<br>";

$queue = array("orange", "banana");
array_unshift($queue, "apple", "raspberry");
print_r($queue);
// Array ( [0] => apple [1] => raspberry [2] => orange [3] => banana )

8.7、数组集合

函数	说明
array_diff ()	用于求数组集合的差集
array_intersect ()	用于求数组集合的交集

array array_diff( array $array1, array $array2[, array $...] );
array array_intersect( array $array1, array $array2 [, array $...] )

$a = array("a" => "green", "red", "blue", "red");
$b = array("b" => "green", "yellow", "red");
$c = array_diff($a, $b);
print_r($c);	// Array ( [1] => blue )

$a = array("a" => "green", "red", "blue", "red");
$b = array("b" => "green", "yellow", "red");
$c = array_intersect($a, $b);
print_r($c);	// Array ( [a] => green [0] => red [2] => red )

8.8、反转数组

​ 返回单元顺序相反的数组 。

array array_reverse( array $array[, bool $preserve_keys = false] )

$input  = array("php", 4.0, array("green", "red"));
$reversed = array_reverse($input);
$preserved = array_reverse($input, true);

print_r($input);
print_r($reversed);
print_r($preserved);

// 输出结果
Array ( [0] => php [1] => 4 [2] => Array ( [0] => green [1] => red ) )
Array ( [0] => Array ( [0] => green [1] => red ) [1] => 4 [2] => php )
Array ( [2] => Array ( [0] => green [1] => red ) [1] => 4 [0] => php )