PHP合并数组的四种方式

四种方式总结

• 1、array_merge()函数，最常用，相同字符串键，后者覆盖前者；
• 2、+号合并，相同数字索引和相同字符串键都会覆盖，但它是“前者覆盖后者”(而array_merge是后者覆盖前者)；
• 3、array_merge_recursive()函数，recursive表示递归，所以它是递归合并，相同字符串键，会以二维数组的方式给出两个值；
• 4、array_combine()，combine是组合、结合的意思，而不是“合并”，所以它并不是我们平常认为的“合并数组”，它是把数组1的值作为键，数组2的值作为值合并成一个新数组，所以它要求两个数组元素个数相同，否则会报Warning错误，并且忽略多出的元素。
• 5、foreach循环其中一个数组，把它array_push或直接用方括号的方式加入到另一个数组，这相当于手动合并数组了，因为php没有python/golang那种三个点打散数组的符号，所以只能循环一个一个添加到另一个数组。

速度上，+号的速度是最快的。

array_merge

array_merge()是最常用的，用于合并两个数组，相同索引，后者会加到前者后面，相同字符串键，后者会覆盖前者。

实例测试：

<?php
/**
 * array_merge合并数组测试
 * 结果：有相同的字符串键名，则后者会覆盖前者
 */

// 两个都是索引数组(键都是数字)，相同索引不会覆盖
$arr1 = [1,2,3];
$arr2 = [4,5,6];

// 两个都是关联数组，相同键，后者会覆盖前者
$arr3 = ['a'=>1,'b'=>2,'c'=>3];
$arr4 = ['a'=>4,'b'=>5,'c'=>6];

// 索引和关联数组合并，因为没有相同的键，所以不会覆盖
$arr5 = [1,2,3];
$arr6 = ['a'=>4,'b'=>5,'c'=>6];

$arrMerge1 = array_merge($arr1,$arr2);
$arrMerge2 = array_merge($arr3,$arr4);
$arrMerge3 = array_merge($arr5,$arr6);

print_r($arrMerge1);
print_r($arrMerge2);
print_r($arrMerge3);

/**
 * 三个合并后的数组打印结果如下
 * Array
 *(
 *    [0] => 1
 *    [1] => 2
 *    [2] => 3
 *    [3] => 4
 *    [4] => 5
 *    [5] => 6
 *)
 *Array
 *(
 *    [a] => 4
 *    [b] => 5
 *    [c] => 6
 *)
 *Array
 *(
 *    [0] => 1
 *    [1] => 2
 *    [2] => 3
 *    [a] => 4
 *    [b] => 5
 *    [c] => 6
 *)
 */

+号合并

在PHP中，两个数组是可以用+号相加的，它的规则就是，只要是相同键(无论键是索引还是字符串)，前者都会覆盖后者(注意array_merge是后者覆盖前者，而+号是前者覆盖后者)。

实例测试：

<?php
/**
 * “+”号合并数组测试
 * 结果：只要是相同键(无论键是索引还是字符串)，前者都会覆盖后者(array_merge是后者覆盖前者)
 */

// 两个都是索引数组(键都是数字)，相同索引不会覆盖
$arr1 = [1,2,3];
$arr2 = [4,5,6];

// 两个都是关联数组，相同键，后者会覆盖前者
$arr3 = ['a'=>1,'b'=>2,'c'=>3];
$arr4 = ['a'=>4,'b'=>5,'c'=>6];

// 索引和关联数组合并，因为没有相同的键，所以不会覆盖
$arr5 = [1,2,3];
$arr6 = ['a'=>4,'b'=>5,'c'=>6];

$arrMerge1 = $arr1 + $arr2;
$arrMerge2 = $arr3 + $arr4;
$arrMerge3 = $arr5 + $arr6;

print_r($arrMerge1);
print_r($arrMerge2);
print_r($arrMerge3);

/**
 * 三个合并后的数组打印结果如下
 * Array
 *(
 *    [0] => 1
 *    [1] => 2
 *    [2] => 3
 *)
 *Array
 *(
 *    [a] => 1
 *    [b] => 2
 *    [c] => 3
 *)
 *Array
 *(
 *    [0] => 1
 *    [1] => 2
 *    [2] => 3
 *    [a] => 4
 *    [b] => 5
 *    [c] => 6
 *)
 */

array_merge_recursive

recursive是递归、循环的意思，用这个函数合并数组，它会递归合并，即使相同的键也不会覆盖，相同索引，没什么好说的，后者加在前者后面，相同字符串键，则会以二维数组的方式给出

<?php
/**
 * array_merge_recursive合并数组测试
 * 结果：索引数组会直接加到后面，相同的字符串键，会以二维数组的形式给出两个值
 */

// 两个都是索引数组(键都是数字)，相同索引不会覆盖
$arr1 = [1,2,3];
$arr2 = [4,5,6];

// 两个都是关联数组，相同键，后者会覆盖前者
$arr3 = ['a'=>1,'b'=>2,'c'=>3];
$arr4 = ['a'=>4,'b'=>5,'c'=>6];

// 索引和关联数组合并，因为没有相同的键，所以不会覆盖
$arr5 = [1,2,3];
$arr6 = ['a'=>4,'b'=>5,'c'=>6];

$arrMerge1 = array_merge_recursive($arr1,$arr2);
$arrMerge2 = array_merge_recursive($arr3,$arr4);
$arrMerge3 = array_merge_recursive($arr5,$arr6);

print_r($arrMerge1);
print_r($arrMerge2);
print_r($arrMerge3);

/**
 * 三个合并后的数组打印结果如下
 *Array
 *(
 *    [0] => 1
 *    [1] => 2
 *    [2] => 3
 *    [3] => 4
 *    [4] => 5
 *    [5] => 6
 *)
 *Array
 *(
 *    [a] => Array
 *        (
 *            [0] => 1
 *            [1] => 4
 *        )
 *
 *    [b] => Array
 *        (
 *            [0] => 2
 *            [1] => 5
 *        )
 *
 *    [c] => Array
 *        (
 *            [0] => 3
 *            [1] => 6
 *        )
 *
 *)
 *Array
 *(
 *    [0] => 1
 *    [1] => 2
 *    [2] => 3
 *    [a] => 4
 *    [b] => 5
 *    [c] => 6
 *)
 */

array_combine

array_combine()是把前者的值作为后者的键，合并为一个数组，这种合并，不是我们平常认为的那种“值合并”。要求两个数组元素个数相同，否则报Warning错误，并且会忽略多出的那个元素。

测试实例

<?php
/**
 * array_combine合并数组测试
 * 结果：前者的值作为后者的键，要求两个数组元素个数相同，
 * 否则报Warning错误，并且会忽略多出的那个元素。
 */

// 两个都是索引数组(键都是数字)，相同索引不会覆盖
$arr1 = [4,5,6];
$arr2 = [1,2,3];


// 两个都是关联数组，相同键，后者会覆盖前者
$arr3 = ['a'=>7,'b'=>8,'c'=>9];
$arr4 = ['a'=>4,'b'=>5,'c'=>6];

// 索引和关联数组合并，因为没有相同的键，所以不会覆盖
$arr5 = [3,2,1];
$arr6 = ['a'=>4,'b'=>5,'c'=>6];

$arrMerge1 = array_combine($arr1,$arr2);
$arrMerge2 = array_combine($arr3,$arr4);
$arrMerge3 = array_combine($arr5,$arr6);

print_r($arrMerge1);
print_r($arrMerge2);
print_r($arrMerge3);

/**
 * 三个合并后的数组打印结果如下
 *Array
 *(
 *    [4] => 1
 *    [5] => 2
 *    [6] => 3
 *)
 *Array
 *(
 *    [7] => 4
 *    [8] => 5
 *    [9] => 6
 *)
 *Array
 *(
 *    [3] => 4
 *    [2] => 5
 *    [1] => 6
 *)
 */