PHP 数组的合并与运算

array_combine() 创建一个数组，用一个数组的值作为其键名，另一个数组的值作为其值

array array_combine ( array $keys , array $values )

$a1=array("OS","WebServer","DataBase","Language"); //声明第一个数组作为参数1
$a2=array("Linux","Apache","MySQL","PHP"); //声明第二个数组作为参数2
print_r(array_combine($a1,$a2)); //使用arrray_combine()将两个数组合并
//输出：Array ( [OS] => Linux [WebServer] => Apache [DataBase] => MySQL [Language] => PHP )           

array_merge() 合并一个或多个数组

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

array_merge() 将一个或多个数组的单元合并起来, 一个数组中的值附加在前一个数组的后面。返回作为结果的数组。

在数组值相同的情况下, 如果输入的数组中有相同的字符串键名，则该键名后面的值将覆盖前一个值。

然而, 如果数组包含数字键名, 后面的值将不会覆盖原来的值, 而是附加到后面, 并为其重建数字索引。

如果只给了一个数组并且该数组是数字索引的, 则键名会以连续方式重新索引。 如果是唯一的字符串键名, 则保留键名。

如果关联数组和索引数组混合的, 则为索引数组重建索引, 关联数组的则保留键名；

//关联数组的键名相同的,则后面的值覆盖前一个值
$a1=array("a"=>"Linux","b"=>"Apache");
$a2=array("c"=>"MySQL","b"=>"PHP");
print_r(array_merge($a1,$a2)); //输出： Array ( [a] => Linux [b] => PHP [c] => MySQL )
           

//没有键名的数组,则为其重建索引
$a1=array("a"=>"Linux","Apache");
$a2=array("c"=>"MySQL","PHP");
print_r(array_merge($a1,$a2)); //输出:Array ( [a] => Linux [0] => Apache [c] => MySQL [1] => PHP )
           

//没有键名的数组且值相同,则为其重建索引,保留重复的值
$a1=array("a"=>"Linux","Apache");
$a2=array("c"=>"MySQL","php","Apache");
print_r(array_merge($a1,$a2)); //输出:Array ( [a] => Linux [0] => Apache [c] => MySQL [1] => php [2] => Apache )           

//仅使用一个数组参数则键名以0开始进行重新索引
$a=array(3=>"PHP",4=>"MySQL");
print_r(array_merge($a)); //输出：Array ( [0] => PHP [1] => MySQL )           

//索引数组的键名相同的,则重建索引
$a1=array("a"=>"Linux",1=>"Apache");
$a2=array("c"=>"MySQL",1=>"PHP");
print_r(array_merge($a1,$a2)); //输出：Array ( [a] => Linux [0] => Apache [c] => MySQL [1] => PHP )           

//索引数组的键名相同的且键名相同的,则不会覆盖,重建索引
$a1=array("a"=>"Linux",1=>"Apache");
$a2=array("c"=>"MySQL",1=>"Apache");
print_r(array_merge($a1,$a2));//输出:Array ( [a] => Linux [0] => Apache [c] => MySQL [1] => Apache )
           

归纳: 关联数组的键名相同的, 后者覆盖前者, 且后者的键名保留;

索引数组的键名相同的, 会重建索引(原索引键名不保留), 不会出现覆盖;

索引名相同的情况下如何合并数组(避免同一个键名相同的情况下, 直接修改键值的问题)?

<?php
function array_add($a,$b){
$arr = array_intersect_key($a, $b);
foreach($b as $key=>$value){
if(!array_key_exists($key, $a)){
$a[$key]=$value;
}
}
foreach($arr as $key=>$value){
$a[$key]=$a[$key]+$b[$key];
}
return $a;
}
$a = array('0'=>'2','1'=>'4','3'=>'8','a'=>'100');
$b = array('0'=>'5','2'=>'4','b'=>'33','a'=>'22');
$arr=array_add($a,$b);
echo "<pre>";
print_r($arr);
echo "</pre>";
Array
(
[0] => 7
[1] => 4
[3] => 8
[a] => 122
[2] => 4
[b] => 33
)           

注意：array_merge(array_merge(array1,array2,array3...))

三个参数必须为数组否则的话, 出现会错误, 因此在使用之前必须向判断是否是数组is_array();

使用运算符对数组进行合并

<?php
//声明两个数组，前两个元素下标相同，测试是否后面的会覆盖前面的
$a = array( "a"=>"Linux", "b"=>"Apache");
$b = array( "a"=>"PHP", "b"=>"MySQL", "c"=>"web" );

$c = $a + $b; //使用“+”合并两个数组，$a在前， $b在后，因为前两个下标相同， $b会覆盖
echo "合并后的 \$a 和 \$b: \n";
print_r($c); //结果： Array ( [a] => Linux [b] => Apache [c] => web )

$c = $b + $a; //使用“+”合并两个数组，$b在前， $a在后，因为前两个下标相同, $a会覆盖
echo "合并后的 \$a 和 \$b: \n";
print_r($c); //结果： Array ( [a] => PHP [b] => MySQL [c] => web )           

归纳：对于索引数组, 不会重建索引(原键名保留);

对于关联数组, 键名也会保留;

键名相同的(索引数组和关联数组), 前者覆盖后者;

实例：array_merge()和运算符号"+"的比较

<?php
$a = array(1=>"a", 2=>"b", 3=>"c", "min"=>"f", "max"=>"j");
$b = array(2=>"e", 4=>"d", 5=>"c", "min"=>"h", "max"=>"j");
$c = $a + $b;
print_r($c);
echo "<br>";
$d = array_merge($a, $b);
print_r($d);
?>           

输出结果：

Array ( [1] => a [2] => b [3] => c [min] => f [max] => j [4] => d [5] => c )
Array ( [0] => a [1] => b [2] => c [min] => h [max] => j [3] => e [4] => d [5] => c )           

注意: print_r()函数在输出时, 自动为没有键名的元素添加数组索引后再输出;

数组的比较(==或===)

== 等于：

判断数组的长度是否相等

判断数组的索引下标是否相等

判断数组的值是否相等(不判断数据类型)

=== 恒等于：

判断数组的长度是否相等

判断数组的索引下标与索引顺序是否相等

判断数组的值是否相等, 还需要判断数据类型

<?php
$arr1 = array(1, 2, 3, 4);
$arr2 = array('a'=>1, 'b'=>2, 'c'=>3, 'd'=>4);
$arr3 = array('10'=>'1,2,3,4');
$arr4 = array('3'=>4,'2'=>3,'1'=>2,'0'=>1);
$arr5 = array('0'=>1,'1'=>2,'2'=>3,'3'=>4);
var_dump($arr1 == $arr2); //false
echo "<hr/>";
var_dump($arr1 == $arr4); //true
echo "<hr/>";
var_dump($arr1 == $arr5); //true
echo "<hr/>";
var_dump($arr1 === $arr4); //false
echo "<hr/>";
var_dump($arr1 === $arr5); //true

?>           

拆分、分解函数见array_slice()和array_splice()的区别

array_intersect() 计算数组的交集

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

array_intersect() 返回一个数组, 该数组包含了所有在 array1 中也同时出现在所有其它参数数组中的值。注意键名保留不变。

$array1 = array("a" => "green", "red", "blue");
$array2 = array("b" => "green", "yellow", "red");
$result = array_intersect($array1, $array2);
Array
(
[a] => green
[0] => red
)           

array_diff() 计算数组的差集

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

array_diff() 返回一个数组，该数组包括了所有在 array1 中但是不在任何其它参数数组中的值。注意键名保留不变。

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

array_intersect_assoc() 带索引检查计算数组的交集

array array_intersect_assoc ( array $array1 , array $array2 [, array $ ... ] )

注意: 此函数为没有键名的元素重建数字索引,其返回值为键名相同的元素(包括数字索引的键名不相同的,则不返回)

<?php
$array1 = array("a" => "green", "b" => "brown", "c" => "blue", "red");
$array2 = array("a" => "green", "b" => "yellow", "blue", "red");
$result_array = array_intersect_assoc($array1, $array2);
print_r($result_array);
?>           

输出结果:

Array
(
[a] => green
)           

array_diff_assoc() 带索引检查计算数组的差集

array array_diff_assoc ( array $array1 , array $array2 [, array $... ] )

注意: 此函数为没有键名的元素重建数字索引,其返回值为键名不相同的元素(包括数字索引的键名不相同的,则也返回)

<?php
$array1 = array("a" => "green", "b" => "brown", "c" => "blue", "red");
$array2 = array("a" => "green", "yellow", "red");
$result = array_diff_assoc($array1, $array2);
print_r($result);
?>           

输出结果:

Array
(
[b] => brown
[c] => blue
[0] => red //包含重建数字索引的键名
)           

以上计算数组的交集和差集返回值会保留原有的键名(包括为其重建数字索引元素的键名也保留)