（四）数组——PHP

第四章 数组

1 数组创建

1.1 使用array()函数创建数组

PHP中的数组可以是一维数组，也可以是多维数组。创建数组可以使用array()函数，语法格式如下：

array($keys=>$values,…)
1

 	
	// 1. array()函数创建一维数组
    $array1=array(1,2,3,4);                           // 定义不带键名的数组
    $array2=array("color1"=>"blue","color2"=>"red");  // 定义带键名的数组
    $array3=array(1=>2,2=>4,5=>6,8,10);               // 定义省略某些键名的数组

    echo $array1[0];							   // 输出数组元素
    echo $array1["color2"];
    echo $array1[5];

    print_r($array1);							   // 打印数组
    print_r($array2);
    print_r($array3);
    /*
		自定义键名可以是字符串或数字。如果省略了键名，则会自动产生从0开始的整数作为键名。如果只对某个给出的值没有指定键名，则取该值前面最大的整数键名加1后的值。
		注意：
			如果定义了两个完全一样的键名，则后面一个会覆盖前面一个。

    */



	// 2. array()函数创建多维数组
	
    $array4=array(
		"color"=>array("红色","蓝色","白色"),
		"number"=>array(1,2,3,4,5,6)
	);                        				
    echo $array["color"][2];              // 输出数组元素，输出结果为"白色"
    print_r($array);                      // 打印二维数组

 ?>
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
27
28
29
30
31
32

1.2 使用变量创建数组

通过使用compact()函数，可以把一个或多个变量甚至数组，建立成数组元素，这些数组元素的键名就是变量的变量名，值是变量的值。语法格式如下：

array compact(mixed $varname [, mixed ...])
1

对每个参数，compact()函数在当前的符号表中查找该变量名并将它添加到输出的数组中，变量名成为键名，而变量的内容成为该键的值。

    $num=10;
    $str="string";
    $array=array(1,2,3);
    $newarray=compact("num","str","array"); // 使用变量名创建数组
    print_r($newarray); 				  // 打印数组
?>
1
2
3
4
5
6
7

与compact()函数相对应的是extract()函数，其作用是将数组中的单元转化为变量，例如：

  //  (要带自定义键名的数组，默认下标的数组不能转化为变量)
    $array=array("key1"=>1, "key2"=>2, "key3"=>3);
    extract($array);
    echo $key1."
";    // 1
    echo $key2."
";    // 2 
    echo $key3."
";    // 3 
?>
1
2
3
4
5
6
7
8

1.3 使用两个数组创建一个数组

使用array_combine()函数可以使用两个数组创建另外一个数组，语法格式如下：

array array_combine(array $keys, array $values)
1

array_combine()函数用来自$keys数组的值作为键名，用来自$values数组的值作为相应的值，最后返回一个新的数组。

    $array1=array('color1', 'color2', 'color3');
    $array2=array('yellow', 'blue', 'red');
    $array3=array_combine($array1, $array2);
    print_r($c);    //输出：Array ( [color1] => yellow  [color2] => blue  [color3] => red )
?>
1
2
3
4
5
6

1.4 建立指定范围的数组

使用range()函数可以自动建立一个值在指定范围的数组，语法格式如下：

array range(mixed $low, mixed $high [, number $step ])
1

$low为数组开始元素的值，$high为数组结束元素的值。如果$low>$high，则序列将从$high到$low。$step是单元之间的步进值，$step应该为正值，如果未指定则默认为1。range()函数将返回一个数组，数组元素的值就是从$low到$high之间的值。

    $array1=range(1,5);
    $array2=range(2,10,2);
    $array3=range("a","e");
    print_r($array1);                   //输出：Array ( [0] => 1 [1] => 2 [2] => 3 [3] => 4 [4] => 5 )
    print_r($array2);                   //输出：Array ( [0] => 2 [1] => 4 [2] => 6 [3] => 8 [4] => 10 )
    print_r($array3);                   //输出：Array ( [0] => a [1] => b [2] => c [3] => d [4] => e )
?>
1
2
3
4
5
6
7
8

1.5 自动建立数组

数组还可以不用预先初始化或创建，在第一次使用它的时候，数组就已经创建，例如：

    $arr[0]="a";
    $arr[1]="b";
    $arr[2]="c";
    print_r($arr);                    	//输出：Array ( [0] => a [1] => b [2] => c )
?>
1
2
3
4
5
6

2 键名和值的操作

2.1 存在性检查

2.1.1 array_key_exists()函数和in_array()函数

检查数组中是否存在某个键名和值，可以使用array_key_exists()函数和in_array()函数，array_key_ exists()和in_array()函数都为布尔型，若存在则返回TRUE，若不存在则返回FASLE。

    $array=array(1,2,3,8=>4,5);
    
    if(in_array(5, $array))              	
        echo "数组中存在值：5";      	

    if(!array_key_exists(3, $array))      	
        echo "数组中不存在键名：3";  	

?>
1
2
3
4
5
6
7
8
9
10

2.1.2 array_search()函数

array_search()函数也可以用于检查数组中的值是否存在，与in_array()函数不同的是**：**in_array()函数返回的是TRUE或FALSE，而array_search()函数当值存在时返回这个值的键名，若值不存在则返回NULL。

    $array=array(1, 2, 3, 5, "b");
    $key=array_search("b", $array);        //  查找"b"是否在数组$array中
    if($key){              				  //  存在则输出对应的键名
         echo $key;		
    }
    else{
        echo "数组中不存在这个值";                 			
    }
?>
1
2
3
4
5
6
7
8
9
10

2.2 获取和输出

2.2.1 array_keys()函数和array_values()函数

使用array_keys()函数和array_values()函数函数可以取得数组中所有的键名和值，并保存到一个新的数组中。

    $arr=array("red"=>"红色","blue"=>"蓝色","white"=>"白色");
    $keys=array_keys($arr);        	// 取得数组中的所有键名
    $values=array_values($arr);     // 取得数组中的所有值
    print_r($key);                	// 输出结果：Array ( [0] => red [1] => blue [2] => white )
    print_r($values);               // 输出结果：Array ( [0] => 红色 [1] => 蓝色 [2] => 白色 )
?>
1
2
3
4
5
6
7

2.2.2 key()函数

使用key()函数可以取得数组当前单元的键名

    $array=array("a"=>1, "b"=>2, "c"=>3, "d"=>4);
    echo key($array);                	// 输出"a"
    next($array);                    	// 将数组中的内部指针向后移动一位
    echo key($array);                	// 输出"b"
?>
1
2
3
4
5
6

“next($array)”：表示将数组中的内部指针指向下一个单元

“end($array)”：表示将数组中的内部指针指向最后一个单元；

“reset($array)”：表示将数组中的内部指针指向第一个单元，即重置数组的指针；

“each($array)”：表示返回当前的键名和值，并将数组指针向下移动一位，这个函数非常适合在数组遍历时使用。

2.2.3 list()函数

list()函数：可以将数组中的值赋给指定的变量。这样就可以将数组中的值输出显示出来了，这个函数在数组遍历的时候将非常有用。

    $arr=array("a","b","c");
    list(1, 2, 3)=$arr;     		// 将数组$arr中的值赋给3个变量
    echo $1;                        // 输出a
    echo $2;                       	// 输出b
    echo $3;                    	// 输出c
?>
1
2
3
4
5
6
7

2.3 填充数组

2.3.1 array_fill()函数和array_fill_keys()函数

使用array_fill()函数和array_fill_keys()函数可以用给定的值填充数组的值和键名。

array_fill()函数的语法格式如下：

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

​ **说明：**array_fill()函数用参数$value的值将一个数组从第$start_index个单元开始，填充$num个单元。$num必须是一个大于零的数值，否则PHP会发出一条警告信息。

array_fill_keys()函数的语法格式如下：

array array_fill_keys(array $keys, mixed $value)
1

​ **说明：**array_fill_keys函数用给定的数组$keys中的值作为键名，$value作为值，并返回新数组。

    $array1=array_fill(2, 3, "red");// 从下标为2的数组单元开始，填充3个值"red"
    print_r($array1);               // 输出结果：Array ( [2] => red [3] => red [4] => red )

    $keys=array("a", 3, "b");
    $array2=array_fill_keys($keys, "数组值");// 使用$keys数组中的值作为键名
    print_r($array2);                       // 输出结果：Array ( [a] =>数组值 [3] =>数组值 [b]=>数组值)
?>
1
2
3
4
5
6
7
8

2.4 键值交换

2.4.1 array_flip()函数

array_flip()函数：可以交换数组中的键名和值

    $array=array("a"=>1, "b"=>2, "c"=>3);
    $array=array_flip($array);                	//交换键名和值
    print_r($array);                        	//输出结果：Array ( [1] => a [2] => b [3] => c )
?>
1
2
3
4
5

2.5 删除替换

2.5.1 array_splice()函数

array_splice()函数可以将数组中的一个或多个单元删除并用其他值代替。语法格式如下：

array array_splice(array &$input, int $offset [, int $length [, array $replacement ]])
1

$offset是指定的偏移量，如果$offset为正，则从$input数组中该值指定的偏移量开始移除。如果$offset为负，则从$input末尾倒数该值指定的偏移量开始移除。

$length是指定删除的单元数，如果省略$length，则移除数组中从$offset到结尾的所有部分。

如果指定了$length并且为正值，则移除$offset后的$length个单元。

如果指定了$length并且为负值，则移除从$offset到数组末尾倒数$length个为止的所有的单元。

当给出了$replacement后要移除从$offset到数组末尾所有单元时，可以用count($input)作为$length。

如果给出了$replacement数组，则被移除的单元被此数组中的单元替代。如果指定的$offset和$length的组合结果不会移除任何值，则$replacement数组中的单元将被插入到$offset指定的位置。如果用来替换的值只是一个单元，那么不需要给它加上“array”，除非该单元本身就是一个数组。

    $input1=array(1,2,3,4,5,6);                
    $input2=array(1,2,3,4,5,6);                	
    $input3=array(1,2,3,4,5,6);     


    $output1=array_splice($input1, 3, 2);// 删除$input1数组第三个单元后面的两个单元
    print_r($input1);                    // 输出结果：Array ( [0] => 1 [1] => 2 [2] => 3 [3] => 6 )
    print_r($output1);     			    // 输出结果：Array ( [0] => 4 [1] => 5 )


    $output2=array_splice($input2, 4, 0, 7);//在$input2数组中第四个单元添加值7
    print_r($input2); //输出结果：Array ( [0] => 1 [1] => 2 [2] => 3 [3] => 4 [4] => 7 [5] => 5 [6] => 6 )


    $output3=array_splice($input3, 3, 2, array(7,8));//删除数组$input3第三个单元后面的两个单元并用值7和8代替
    print_r($input3);//输出结果：Array ( [0] => 1 [1] => 2 [2] => 3 [3] => 7 [4] => 8 [5] => 6 )
?>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

2.5.2 array_unique()函数

array_unique()函数可以移除数组中重复的值，返回一个新数组，并不会破坏原来的数组。

    $array=array(1,1,1,2,3,4,4);
    $output=array_unique($array);// 移除$array数组中重复的值
	print_r($array)			    // 原数组
    print_r($output);            // 输出结果：Array ( [0] => 1 [3] => 2 [4] => 3 [5] => 4 )
?>
1
2
3
4
5
6

2.5.3 array_replace()函数

array_replace()函数可以以传递的数组替换第一个数组的元素。

array_replace ()函数的语法格式如下：

array array_replace ( array $array , array $array1 [, array $... ] )
1

​ **说明：**array_replace()函数使用后面数组$array1元素的值替换第一个$array数组的值。

​ 如果一个键同时存在于第一个数组和第二个数组，则它的值将被第二个数组中的值替换。

​ 如果一个键存在于第二个数组，但是不存在于第一个数组，则会在第一个数组中创建这个元素。

​ 如果一个键仅存在于第一个数组，则它保持不变。如果传递了多个替换数组，它们则被按顺序依次处理，后面的数组将覆盖之前的值。

"pineapple", 4=>"cherry");
    $replacements2=array(0=>"grape", 9=>"lenmon");
    $basket=array_replace($base, $replacements1, $replacements2);
    print_r($basket);
    //输出结果：Array ( [0] => grape [1] => banana [2] => apple [3] => raspberry [4] => cherry [9] => lenmon)
?>
1
2
3
4
5
6
7
8

3 数组的遍历和输出

3.1 使用while循环访问数组

1

3.2 使用for循环访问数组

 
	$arr=[1,2,3,4,5,'x'=>6,7,8,9,10];
	for ($i=0; $i<count($arr); $i++) { 
		echo $arr[$i]."
";
	}
 ?>
1
2
3
4
5
6

3.3 使用foreach循环访问数组

 <?php 
    $arr=[1,2,3,4,5,'x'=>6,7,8,9,10];
 	foreach ($arr as $key => $value) {
 		echo $key."------".$value."
";
 	}
  ?>
1
2
3
4
5
6

4 数组的排序

4.1 升序排序

使用sort()函数可以对已经定义的数组进行排序，使得数组单元按照数组值从低到高重新索引。语法格式如下：

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

**说明：**sort()函数如果排序成功则返回TRUE，失败则返回FALSE。两个参数中，$array是需要排序的数组；$sort_flags的值可以影响排序的行为，$sort_flags可以取以下6个值。

• SORT_REGULAR：正常比较单元（不改变类型），这是默认值。
• SORT_NUMERIC：单元被作为数字来比较。
• SORT_STRING：单元被作为字符串来比较。
• SORT_LOCALE_STRING：根据当前的区域设置把单元作为字符串来比较。
• SORT_NATURAL：对每个单元以“自然的顺序”对字符串进行排序。
• SORT_FLAG_CASE：能够与SORT_STRING或SORT_NATURAL合并（OR位运算），不区分大小写排序字符串。

sort()函数不仅对数组进行排序，而且还删除了原来的键名，并重新分配自动索引的键名，例如：

    $array1=array("a"=>5, "x"=>3, 5=>7, "c"=>1);
    if(sort($array1))
        print_r($array1);       // 输出：Array ([0] => 1 [1] => 3 [2] => 5 [3] => 7 )
    else
        echo "排序\$array1失败"; // 不输出
?>
1
2
3
4
5
6
7

asort()函数也可以对数组的值进行升序排序，语法格式和sort()类似，但使用asort()函数排序后的数组还保持键名和值之间的关联，例如：

  
    $fruits=array("d"=>"lemon", "a"=>"orange", "b"=>"banana", "c"=>"apple");
    asort($fruits);
    print_r($fruits);     //输出：Array ( [c] => apple [b] => banana [d] => lemon [a] => orange )
?>
1
2
3
4
5

ksort()函数用于对数组的键名进行排序，排序后键名和值之间的关联不改变，例如：

    $fruits=array("d"=>"lemon", "a"=>"orange", "b"=>"banana", "c"=>"apple");
    ksort($fruits);
    print_r($fruits);    //输出：Array ( [a] => orange [b] => banana [c] => apple [d] => lemon )
?>
1
2
3
4
5

4.2 降序排序

rsort()函数不仅对数组进行排序，而且还删除了原来的键名，并重新分配自动索引的键名，例如：

    $array1=array("a"=>5, "x"=>3, 5=>7, "c"=>1);
    if(sort($array1))
        print_r($array1);       // 输出：Array ([0] => 7 [1] => 5 [2] => 3 [3] => 1 )
    else
        echo "排序\$array1失败"; // 不输出
?>
1
2
3
4
5
6
7

arsort()函数也可以对数组的值进行降序排序，语法格式和rsort()类似，但使用arsort()函数排序后的数组还保持键名和值之间的关联，例如：

  
    $fruits=array("d"=>"lemon", "a"=>"orange", "b"=>"banana", "c"=>"apple");
    asort($fruits);
    print_r($fruits);     //输出：Array ( [a] => orange [d] => lemon [b] => banana [c] => apple )
?>
1
2
3
4
5

krsort()函数用于对数组的键名进行排序，排序后键名和值之间的关联不改变，例如：

    $fruits=array("d"=>"lemon", "a"=>"orange", "b"=>"banana", "c"=>"apple");
    ksort($fruits);
    print_r($fruits);    //输出：Array ( [d] => lemon [c] => apple [b] => banana [a] => "orange )
?>
1
2
3
4
5

4.3 对数组随机排序

shuffle()函数：将数组元素按随机的顺序排列，并删除原有的键名，建立自动索引。例如：

    $arr=range(1,10);                    	// 产生有序数组
    foreach($arr as $value)
        echo $value. " ";                	// 输出有序数组，结果为1 2 3 4 5 6 7 8 9 10
    echo "
";
    
    shuffle($arr);                    		// 打乱数组顺序
    foreach($arr as $value)
        echo $value. "
";            	// 输出新的数组顺序，每次运行，结果都不一样
?>

1
2
3
4
5
6
7
8
9
10
11

4.4 反向排序

array_reverse()函数：将一个数组单元的元素按相反顺序排序，语法格式如下：

array array_reverse(array $array [ , bool $preserve_keys ])
1

如果$preserve_keys值为TRUE则保留原来的键名，为FALSE则为数组重新建立索引，默认为FALSE。例如：

    $array=array("a"=>1,3,2,4);
    $ar1=array_reverse($array);
    $ar2=array_reverse($array,TRUE);
    print_r($ar1);        // 输出：Array ( [0] => 4 [1] => 2 [2] => 3 [a] => 1 )
    print_r($ar2);        // 输出：Array ( [2] => 4 [1] => 2 [0] => 3 [a] => 1 )
?>
1
2
3
4
5
6
7

4.5 自然排序

natsort()函数实现了一个和人们通常对字母、数字、字符串进行排序的方法一样的排序算法，并保持原有键/值的关联，这被称为“自然排序”。natsort()函数对大小写敏感，它与sort()函数的排序方法不同。例如：

    $array1=$array2=array("img12", "img10", "img2", "img1");

    sort($array1);      //使用sort函数排序
    print_r($array1);	//输出：Array ( [0] => img1 [1] => img10 [2] => img12 [3] => img2 )

    natsort($array2);   //自然排序
    print_r($array2);	//输出：Array ( [3] => img1 [2] => img2 [1] => img10 [0] => img12 )
?>
1
2
3
4
5
6
7
8
9

5 数组的集合操作

5.1 数组的差集

所谓“差集”是指在一个数组（集合）中而不在另一个数组（集合）中值的集合，该集合本身也成为一个新数组。

使用array_diff()函数计算数组的差集，语法格式如下：

array array_diff ( array $array1, array $array2 [, array $... ] )
    
1
2

**说明：**对比返回在$array1中但是不在$array2及任何其他参数数组中的值。注意键名保持不变。例如：

    $array1=array("a"=>"green", "red", "blue", "red");
    $array2=array("b"=>"green", "yellow", "red");
    $result=array_diff($array1, $array2);
    print_r($result);      //输出：Array ( [1] => blue )
?>
1
2
3
4
5
6

此外，还可以使用键名比较计算数组的差集，使用array_diff_key()函数，例如：

    $array1=array('blue'=>1, 'red'=>2, 'green'=>3, 'purple'=>4);
    $array2=array('green'=>5, 'blue'=>6, 'yellow'=>7, 'cyan'=>8);
    var_dump(array_diff_key($array1, $array2));
    /*
    	打印结果如下：
		array (size=2)
		    'red' => int 2
  			'purple' => int 4

    */
?> 
1
2
3
4
5
6
7
8
9
10
11
12

5.2 数组的交集

所谓“交集”是指同时出现在两个数组（集合）中的值的集合，该集合本身也成为一个新数组。

使用array_intersect ()函数计算数组的交集，语法格式如下：

array array_intersect ( array $array1, array $array2 [, array $ ... ] )
1

说明：返回一个数组，该数组包含了所有同时出现在$array1、$array2及任何其他参数数组中的值。注意键名保持不变。例如：

    $array1=array("a"=>"green", "red", "blue");
    $array2=array("b"=>"green", "yellow", "red");
    $result=array_intersect($array1, $array2);
    print_r($result);    //输出：Array ( [a] => green [0] => red )
?>
1
2
3
4
5
6

此外，还可以使用键名比较计算数组的交集，用array_intersect_key 函数，例如：

    $array1=array('blue'=>1, 'red'=>2, 'green'=>3, 'purple'=>4);
    $array2=array('green'=>5, 'blue'=>6, 'yellow'=>7, 'cyan'=>8);
    var_dump(array_intersect_key($array1, $array2));
  /*
    	打印结果如下：
		array (size=2)
  			'blue' => int 1
  			'green' => int 3
    */
?>
1
2
3
4
5
6
7
8
9
10
11

5.3 数组的并集

array_merge()函数可以将一个或多个数组合并，一个数组中的值附加在前一个数组的后面，返回作为结果的数组。语法格式如下：

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

如果输入的数组中有相同的字符串键名，则该键名后面的值将覆盖前面的一个值。然而，如果数组包含数字键名，后面的值将不会覆盖原来的值，而是附加到后面。如果只给了一个数组且该数组是数字索引的，则键名会以连续方式重新索引。例如：

    $array1=array("color"=>"red",2,4);
    $array2=array("a","color" => "green",4);
    $result=array_merge($array1, $array2);	//合并两个数组
    print_r($result);
    //输出：Array ( [color] => green [0] => 2 [1] => 4 [2] => a [3] => 4 )
?>
1
2
3
4
5
6
7

6 其它方法

6.1 数组的栈操作

根据“后进先出”的特点，出栈操作实际上删除了数组最后一个单元，使用array_pop()函数实现，例如：

    $arr=array(1,2,3,4,5);
    $result=array_pop($arr);            	//删除数组$arr的最后一个单元
    print_r($arr);                    		//输出：Array ( [0] => 1 [1] => 2 [2] => 3 [3] => 4 )
?>
1
2
3
4
5

数组的入栈操作是将新单元添加到数组尾部，使用array_push()函数实现，语法格式如下：

int array_push(array &$array, mixed $var [, mixed $... ])
1

array_push()函数将数组$array当成一个栈，并将传入的变量$var加到$array的末尾。$array的长度将根据入栈变量的数目而增加。例如：

    $arr=range(1,5);
    array_push($arr,6,7);                	//将6和7加入数组尾部
    $arr[]=8;                        		//将8加入数组尾部，和array_push()函数实现的功能一样
    print_r($arr);
    //输出：Array ( [0] => 1 [1] => 2 [2] => 3 [3] => 4 [4] => 5 [5] => 6 [6] => 7 [7] => 8 )
?>
1
2
3
4
5
6
7

6.2 取得数组当前单元

和each()函数不同，current()函数能够获取数组内部指针指向的单元的值，但不移动数组的内部指针。例如：

    $arr=array("a","b","c","d");
    $a=current($arr);              // 取得当前单元
    echo $a;                       // 输出'a'

    next($arr);                    // 将指针移到下一个单元
    $b=current($arr);
    echo $b;                       // 输出'b'

    end($arr);                     // 将指针移到尾部
    $d=current($arr);
    echo $d;                       // 输出'd'
?>
1
2
3
4
5
6
7
8
9
10
11
12
13

6.3 数组计算

使用count()、sizeof()函数可以计算数组中的元素个数，而使用array_count_values()函数可以计算数组中一个值出现的次数。语法格式如下：

count(array $input)
1

sizeof(array $input)
1

array array_count_values(array $input)
1

array_count_values()函数返回一个数组，该数组用$input数组中的值作为键名，以该值在$input数组中出现的次数作为值。例如：

    $arr=array(1,2,3,1,3,1,4,1,1,4,2);
    $result=array_count_values($arr);
    print_r($result);                    //输出：Array ( [1] => 5 [2] => 2 [3] => 2 [4] => 2 )
?>
1
2
3
4
5

array_product()函数以整数或浮点数返回一个数组中所有值的乘积，语法格式如下：

number array_product ( array $array )
1

    $a=array(2, 4, 6, 8);
    echo "product(a) = " . array_product($a) . "\n";
    echo "product(array()) = " . array_product(array()) . "\n";
    //输出：product(a) = 384 product(array()) = 1
?>
1
2
3
4
5
6