array_merge_recursive

(PHP 4 >= 4.0.1, PHP 5, PHP 7, PHP 8)

array_merge_recursive — 递归合并一个或多个数组

描述

array_merge_recursive(数组 ...$arrays): 数组

array_merge_recursive() 将一个或多个数组的元素合并在一起，以便一个数组的值附加到前一个数组的末尾。它返回结果数组。

如果输入数组具有相同的字符串键，则这些键的值将合并到一个数组中，并且此操作是递归进行的，因此，如果其中一个值本身就是一个数组，则该函数也会将其与另一个数组中的对应项合并。但是，如果数组具有相同的数字键，则后面的值不会覆盖原始值，而是会被附加。

参数

arrays: 要递归合并的数组的可变列表。

返回值

将参数合并在一起产生的值数组。如果在不带任何参数的情况下调用，则返回一个空的数组。

变更日志

版本	描述
7.4.0	此函数现在可以在不带任何参数的情况下调用。以前，至少需要一个参数。

示例

示例 #1 array_merge_recursive() 示例

<?php
$ar1 = array("color" => array("favorite" => "red"), 5);
$ar2 = array(10, "color" => array("favorite" => "green", "blue"));
$result = array_merge_recursive($ar1, $ar2);
print_r($result);
?>

以上示例将输出

Array
(
    [color] => Array
        (
            [favorite] => Array
                (
                    [0] => red
                    [1] => green
                )

            [0] => blue
        )

    [0] => 5
    [1] => 10
)

参见

array_merge() - 合并一个或多个数组
array_replace_recursive() - 递归地将来自传递数组的元素替换到第一个数组中

发现问题？

了解如何改进此页面 • 提交拉取请求 • 报告错误

＋添加注释

用户贡献的注释 38 条注释

上移

下移

168

gabriel dot sobrinho at gmail dot com ¶

15 年前

我重构了 Daniel 的函数，得到了它

<?php
/**
 * array_merge_recursive 确实合并了数组，但它将具有重复
 * 键的值转换为数组，而不是像 array_merge 那样用第二个数组中的重复
 * 值覆盖第一个数组中的值。即，使用 array_merge_recursive，
 * 会发生这种情况（已记录的行为）：
 *
 * array_merge_recursive(array('key' => 'org value'), array('key' => 'new value'));
 * => array('key' => array('org value', 'new value'));
 *
 * array_merge_recursive_distinct 不会更改数组中值的类型。
 * 第二个数组中匹配键的值会覆盖第一个数组中的值，就像
 * array_merge 一样，即：
 *
 * array_merge_recursive_distinct(array('key' => 'org value'), array('key' => 'new value'));
 * => array('key' => array('new value'));
 *
 * 参数通过引用传递，但仅出于性能原因。此函数不会
 * 更改它们。
 *
 * @param array $array1
 * @param array $array2
 * @return array
 * @author Daniel <daniel (at) danielsmedegaardbuus (dot) dk>
 * @author Gabriel Sobrinho <gabriel (dot) sobrinho (at) gmail (dot) com>
 */
function array_merge_recursive_distinct ( array &$array1, array &$array2 )
{
 $merged = $array1;

 foreach ( $array2 as $key => &$value )
 {
 if ( is_array ( $value ) && isset ( $merged [$key] ) && is_array ( $merged [$key] ) )
 {
 $merged [$key] = array_merge_recursive_distinct ( $merged [$key], $value );
 }
 else
 {
 $merged [$key] = $value;
 }
 }

 return $merged;
}
?>

这修复了当第一个数组没有键并且第二个数组有一个值为数组时的 E_NOTICE。

上移

下移

martyniuk dot vasyl at gmail dot com ¶

12 年前

这是我的 array_merge_recursive 版本，不覆盖数字键
<?php
function array_merge_recursive_new() {

 $arrays = func_get_args();
 $base = array_shift($arrays);

 foreach ($arrays as $array) {
 reset($base); //重要
 while (list($key, $value) = @each($array)) {
 if (is_array($value) && @is_array($base[$key])) {
 $base[$key] = array_merge_recursive_new($base[$key], $value);
 } else {
 $base[$key] = $value;
 }
 }
 }

 return $base;
 }
?>

上移

下移

daniel at danielsmedegaardbuus dot dk ¶

15 年前

<?php
/**
 * array_merge_recursive 确实合并了数组，但它会将具有重复
 * 键的值转换为数组，而不是像 array_merge 那样用第二个数组中重复的
 * 值覆盖第一个数组中的值。即，使用 array_merge_recursive，
 * 会发生这种情况（已记录的行为）：
 * 
 * array_merge_recursive(array('key' => 'org value'), array('key' => 'new value'));
 * => array('key' => array('org value', 'new value'));
 * 
 * array_merge_recursive_distinct 不会更改数组中值的 数据类型。
 * 第二个数组中匹配键的值会覆盖第一个数组中的值，就像
 * array_merge 一样，即：
 * 
 * array_merge_recursive_distinct(array('key' => 'org value'), array('key' => 'new value'));
 * => array('key' => array('new value'));
 * 
 * 参数通过引用传递，尽管仅出于性能原因。它们不会
 * 被此函数更改。
 * 
 * @param array $array1
 * @param mixed $array2
 * @return array
 * @author [email protected]
 */
function &array_merge_recursive_distinct(array &$array1, &$array2 = null)
{
 $merged = $array1;
 
 if (is_array($array2))
 foreach ($array2 as $key => $val)
 if (is_array($array2[$key]))
 $merged[$key] = is_array($merged[$key]) ? array_merge_recursive_distinct($merged[$key], $array2[$key]) : $array2[$key];
 else
 $merged[$key] = $val;
 
 return $merged;
}
?>

上移

下移

walf ¶

13年前

这里有很多递归的例子，它们旨在表现得更像 array_merge()，但它们并没有完全做到这一点，或者非常定制。我认为这个版本最相似，接受超过 2 个参数，并且可以在一个地方重命名

<?php

function array_merge_recursive_simple() {

 if (func_num_args() < 2) {
 trigger_error(__FUNCTION__ .' needs two or more array arguments', E_USER_WARNING);
 return;
 }
 $arrays = func_get_args();
 $merged = array();
 while ($arrays) {
 $array = array_shift($arrays);
 if (!is_array($array)) {
 trigger_error(__FUNCTION__ .' encountered a non array argument', E_USER_WARNING);
 return;
 }
 if (!$array)
 continue;
 foreach ($array as $key => $value)
 if (is_string($key))
 if (is_array($value) && array_key_exists($key, $merged) && is_array($merged[$key]))
 $merged[$key] = call_user_func(__FUNCTION__, $merged[$key], $value);
 else
 $merged[$key] = $value;
 else
 $merged[] = $value;
 }
 return $merged;
}

$a1 = array(
 88 => 1,
 'foo' => 2,
 'bar' => array(4),
 'x' => 5,
 'z' => array(
 6,
 'm' => 'hi',
 ),
);
$a2 = array(
 99 => 7,
 'foo' => array(8),
 'bar' => 9,
 'y' => 10,
 'z' => array(
 'm' => 'bye',
 11,
 ),
);
$a3 = array(
 'z' => array(
 'm' => 'ciao',
 ),
);
var_dump(array_merge($a1, $a2, $a3));
var_dump(array_merge_recursive_simple($array1, $array2, $array3));
var_dump(array_merge_recursive($a1, $a2, $a3));
?>

给出

array(7) { array(7) { array(7) {
int(1) int(1) int(1)
["foo"]=> ["foo"]=> ["foo"]=>
array(1) { array(1) { array(2) {
    [0]=>                   [0]=>                   [0]=>
int(8) int(8) int(2)
  }                       }                         [1]=>
["bar"]=> ["bar"]=> int(8)
int(9) int(9) }
["x"]=> ["x"]=> ["bar"]=>
int(5) int(5) array(2) {
["z"]=> ["z"]=> [0]=>
array(1) { array(3) { int(4)
["m"]=> [0]=> [1]=>
string(4) "ciao" int(6) int(9)
} ["m"]=> }
[1]=> string(4) "ciao" ["x"]=>
int(7) [1]=> int(5)
["y"]=> int(11) ["z"]=>
int(10) } array(3) {
}                         [1]=>                     [0]=>
int(7) int(6)
["y"]=> ["m"]=>
int(10) array(3) {
                        }                             [0]=>
string(2) "hi"
                                                      [1]=>
string(3) "bye"
                                                      [2]=>
string(4) "ciao"
                                                    }
                                                    [1]=>
int(11)
                                                  }
                                                  [1]=>
int(7)
["y"]=>
int(10)
                                                }

上移

下移

fantomx1 at gmail dot com ¶

8年前

我稍微改进了一下 daniel 和 gabriel 的贡献，使其更像原始的 array_merge 函数，以追加数字键而不是覆盖它们，并添加了指定要合并哪些元素的有用选项，因为您通常需要合并数组树的特定部分，而数组的某些部分只需要覆盖以前的。通过指定辅助元素 mergeWithParent=true，该部分数组将被合并，否则后面的数组部分将覆盖前面的。数组的第一级表现为经典的 array_merge。

function array_merge_recursive_distinct ( array &$array1, array &$array2 )
    {
static $level=0;
$merged = [];
if (!empty($array2["mergeWithParent"]) || $level == 0) {
$merged = $array1;
        }

foreach ( $array2 as $key => &$value )
        {
if (is_numeric($key)) {
$merged [] = $value;
} else {
$merged[$key] = $value;
            }

if ( is_array ( $value ) && isset ( $array1 [$key] ) && is_array ( $array1 [$key] )
            ) {
$level++;
$merged [$key] = array_merge_recursive_distinct($array1 [$key], $value);
$level--;
            }
        }
unset($merged["mergeWithParent"]);
return $merged;
    }

上移

下移

thomas at n-o-s-p-a-m dot thoftware dot de ¶

16年前

这是一个简单的三行方法。

简短描述：如果其中一个参数不是数组，则返回第一个参数。如果两个数组中都存在一个元素是数组，则递归合并数组，否则 $ins 中的元素将覆盖 $arr 中的元素（无论键是数字还是非数字）。如果 $arr 中的元素是数组，而 $ins 中的元素是标量，则同样适用（与之前的方法不同）。

function array_insert($arr,$ins) {
# 遍历 $ins 中的所有元素
if (is_array($arr) && is_array($ins)) foreach ($ins as $k => $v) {
# $arr 中存在键且两个元素都是数组：递归合并。
if (isset($arr[$k]) && is_array($v) && is_array($arr[$k])) $arr[$k] = array_insert($arr[$k],$v);
# 在此处添加更多条件（请参见下文）
      # ...
# 否则用 $ins 中的元素替换 $arr 中的元素
else $arr[$k] = $v;
    }
# 返回合并后的数组
return($arr);
  }

除了我个人认为 felix dot ospald at gmx dot de 的观点外，不需要用类型转换来比较键，因为如果键可以是整数，它总是会被转换为整数。只需尝试

$a = array('1'=>'1');
echo gettype(key($a));

它将输出 'integer'。因此，要简单地追加而不是替换整数键，请添加以下行

elseif (is_int($k)) $arr[] = $v;

我使用的条件是

elseif (is_null($v)) unset($arr[$k]);

$ins 中的 NULL 值将取消设置 $arr 中相应的元素（这与将其设置为 NULL 不同！）。这可能是对 felix dot ospald at gmx dot de 的另一个补充：检查数组中是否存在键的绝对正确方法是使用 array_key_exists()（在当前上下文中不需要，因为 isset() 与 is_array() 结合使用）。即使元素的值为 NULL，array_key_exists() 也会返回 TRUE。

最后一个：如果要将此方法用于多个数组，只需使用以下方法

function array_insert_mult($arr) {
# 多于 1 个参数：追加所有参数。
if (func_num_args() > 1) foreach (array_slice(func_get_args(),1) as $ins) $arr = array_insert($arr,$ins);
# 返回合并后的数组
return($arr);
  }

如果担心维护引用：在赋值/使用值作为参数时，只需使用 $ins[$k] 而不是 $v。

上移

下移

remy dot damour at -please-no-spam-laposte dot net ¶

15 年前

如果想要合并数组中所有本身就是数组的值以获得深度为 1 的结果数组，那么您更倾向于使用 array_flatten 函数。

不幸的是，我在 php 中没有找到这样的原生函数，这是我编写的函数

<?php
/**
 * 将数组扁平化，使结果数组的深度为 1。
 * 如果任何值为数组本身，则通过父数组合并，依此类推。
 *
 * @param array $array
 * @param bool $preserver_keys 可选 当为 true 时，在合并嵌套数组时保留键（=> 具有相同键的值会被覆盖）
 * @return array
 */
function array_flatten($array, $preserve_keys = false)
{
 if (!$preserve_keys) {
 // 确保键为数字值，以避免在调用 array_merge 时覆盖
 $array = array_values($array);
 }
 
 $flattened_array = array();
 foreach ($array as $k => $v) {
 if (is_array($v)) {
 $flattened_array = array_merge($flattened_array, call_user_func(__FUNCTION__, $v, $preserve_keys));
 } elseif ($preserve_keys) {
 $flattened_array[$k] = $v;
 } else {
 $flattened_array[] = $v;
 }
 }
 return $flattened_array;
}

// 示例
$a = array ('k1' => 'a', 'k2' => array('k1' => 'b', 'k4' => array('k3' => 'c')));
var_export(array_flatten($a)); // 输出：array(0 => 'a', 1 => 'b', 2 => 'c')
var_export(array_flatten($a, true)); // 输出：array('k1' => 'b', 'k3' => 'c') // 第一个 'k1' 值被嵌套的 'k1' 值覆盖
?>

上移

下移

jonnybergstrom at googles mail domain dot comm ¶

15 年前

此函数对我无效 - 或者它没有做我想让它做的事情。因此，我编写了以下函数，该函数合并两个数组并返回结果数组。基本数组是左侧的数组（$a1），如果两个数组中都设置了键，则右侧的值优先。如果左侧的值是数组，并且右侧的值也是数组，则该函数会调用自身（递归）。如果左侧是数组，而右侧存在但不是数组，则将使用右侧的非数组值。

*仅出现在右侧的任何键都将被忽略*
- 因为在我的实现中不需要仅出现在右侧的值，但是如果您需要，可以快速修复。

function array_merge_recursive_leftsource(&$a1, &$a2) {
$newArray = array();
foreach ($a1 as $key => $v) {
if (!isset($a2[$key])) {
$newArray[$key] = $v;
continue;
        }

if (is_array($v)) {
if (!is_array($a2[$key])) {
$newArray[$key] = $a2[$key];
continue;
            }
$newArray[$key] = array_merge_recursive_leftsource($a1[$key], $a2[$key]);
continue;
        }

$newArray[$key] = $a2[$key];
    }
return $newArray;
}

上移

下移

spambegone at cratemedia dot com ¶

16年前

我尝试过这些 array_merge_recursive 函数，但没有取得太大成功。也许只是我，但它们似乎实际上并没有深入超过一层？与所有事情一样，通常自己编写更容易，我确实这样做了，它似乎完全按照我想要的方式工作。无论如何，我的函数尚未经过广泛测试，但它是一个简单的函数，因此希望这对其他人有用，我将分享。

此外，PHP 函数 array_merge_recursive() 无法满足我的目的，因为它没有像我需要的那样覆盖值。您知道它是如何工作的，它只是将其转换为具有多个值的数组……如果您的代码期望一个字符串，这并没有帮助。

function array_merge_recursive_unique($array1, $array2) {
    
// 策略
    /*
合并 array1 和 array2，用第二个数组的值覆盖第一个数组的值
它们重叠的地方。使用 array1 作为基本数组，然后添加
array2 中的值，因为它们存在。
    
遍历 array2 中的每个值，并查看 array1 中是否存在相应的值
。如果存在，则用第二个数组的值覆盖。如果它是一个
数组，则递归执行此函数并返回值。如果它是一个
字符串，则用 array2 中的值覆盖 array1 中的值。
    
如果 array2 中存在 array1 中不存在的值，则将其添加到 array1 中。
    */

// 遍历 $array2
foreach($array2 AS $k => $v) {
        
// 检查 $array1 中是否存在值
if(!empty($array1[$k])) {
// 如果值存在，检查它是数组还是字符串
if(!is_array($array2[$k])) {
// 如果是字符串，则覆盖
$array1[$k]=$array2[$k];
} else {
// 如果是数组，则递归
$array1[$k] = array_merge_recursive_unique($array1[$k], $array2[$k]);
            }
} else {
// 如果 $array1 中不存在值，则使用 $array2 值
$array1[$k]=$v;
        }
    }
unset($k, $v);
    
    
return $array1;
}

上移

下移

brian at vermonster dot com ¶

20 年前

这是一个相当简单的函数，它在递归时替换。

<?php
/**
 * array_merge_recursive2()
 *
 * 类似于 array_merge_recursive，但键值始终会被覆盖。
 * 优先级高于第二个数组。
 *
 * @static 是
 * @public 是
 * @param $paArray1 array
 * @param $paArray2 array
 * @return array
 */
function array_merge_recursive2($paArray1, $paArray2)
{
 if (!is_array($paArray1) or !is_array($paArray2)) { return $paArray2; }
 foreach ($paArray2 AS $sKey2 => $sValue2)
 {
 $paArray1[$sKey2] = array_merge_recursive2(@$paArray1[$sKey2], $sValue2);
 }
 return $paArray1;
}

?>

示例
<?php

$array1 = array(
 'liquids' => array(
 'water' => array('cold', 'fizzy', 'clean')
 ,'beer' => 'warm'
 )
);

$array2 = array(
 'liquids' => array(
 'water' => 'hot'
 ,'milk' => 'wet'
 )
);

$result1 = array_merge_recursive2($array1, $array2);
$result2 = array_merge_recursive2($array2, $array1);
?>

结果 1 是
数组
(
[liquids] => 数组
        (
[water] => hot
[beer] => warm
[milk] => wet
        )
)

结果 2 是
数组
(
[liquids] => 数组
        (
[water] => 数组
                (
[0] => cold
[1] => fizzy
[2] => clean
                )

[milk] => wet
[beer] => warm
        )
)

上移

下移

mark dot roduner at gmail dot com ¶

14 年前

<?php
/**
 * 递归合并任意数量的数组/参数，用后面数组中的值替换具有字符串键的条目。
 * 如果要赋值的条目或下一个值是数组，则它
 * 会自动将两个参数都视为数组。
 * 数字条目会被追加，而不是替换，但前提是它们是
 * 唯一的
 *
 * 调用方式：result = array_merge_recursive_distinct(a1, a2, ... aN)
**/

function array_merge_recursive_distinct () {
 $arrays = func_get_args();
 $base = array_shift($arrays);
 if(!is_array($base)) $base = empty($base) ? array() : array($base);
 foreach($arrays as $append) {
 if(!is_array($append)) $append = array($append);
 foreach($append as $key => $value) {
 if(!array_key_exists($key, $base) and !is_numeric($key)) {
 $base[$key] = $append[$key];
 continue;
 }
 if(is_array($value) or is_array($base[$key])) {
 $base[$key] = array_merge_recursive_distinct($base[$key], $append[$key]);
 } else if(is_numeric($key)) {
 if(!in_array($value, $base)) $base[] = $value;
 } else {
 $base[$key] = $value;
 }
 }
 }
 return $base;
}
?>

上移

下移

andyidol at gmail dot com ¶

13年前

这是一个递归合并两个数组并覆盖值的函数。非常适合合并配置。

<?php

function MergeArrays($Arr1, $Arr2)
{
 foreach($Arr2 as $key => $Value)
 {
 if(array_key_exists($key, $Arr1) && is_array($Value))
 $Arr1[$key] = MergeArrays($Arr1[$key], $Arr2[$key]);

 else
 $Arr1[$key] = $Value;

 }

 return $Arr1;

}

?>

上移

下移

andrew at indigo - sphere dot co dot uk ¶

4 年前

另一种解决方案，当此函数无法产生预期输出时：将自定义递归函数传递给 array_reduce()

例如（使用 PHP 7 的功能来创建递归匿名函数）

<?php
function array_merge_recursive(...$arrays): ?array {
 return array_reduce($arrays, new class {
 public function __invoke($carry, $item) {
 if (is_array($carry) && is_array($item)) {
 return $this($carry, $item);
 }
 return $item ?: $carry;
 }
 }
}
?>
在这种情况下，真值会覆盖前一个数组中的值。
当然，这只是一个简单的示例，并不是一个通用的解决方案。

上移

下移

robert dot schlak at alcatel-lucent dot com ¶

12 年前

NULL 值的存在；这是一个问题示例和修复方法。虽然可能不明显，但如果在循环中使用 array_merge_recursive 来组合数据库查询或其他某些函数的结果，当数据中存在 NULL 值时，可能会损坏结果。我在从 Oracle 数据库迁移到 MySQL 数据库时发现了这一点。我不得不匹配从调用数据库的 PHP 函数返回的数组结构，结果就出问题了。array_walk 调用为我解决了这个问题。
这是一个简单的示例，没有任何数据库调用和循环。假设你的数组包含数据库列名（first、last 和 age），你需要将数据组合到一个多维数组中，其中列名是数组键，所有行都在其下方。损坏发生在 $a3 中。如果使用元素位置 2，由于元素的折叠，可以创建虚构的“pete johnson”。


<?php 
print "<pre>显示损坏\\n"; 
$a1 = array('first'=>'bob', 'last'=>'jones', 'age'=>'48'); 
$a2 = array('first'=>'sam', 'last'=>'smith', 'age'=>'41'); 
$a3 = array('first'=>'pete', 'last'=>null, 'age'=>'3'); 
$a4 = array('first'=>'joe', 'last'=>'johnson', 'age'=>'33'); 
$a5 = array_merge_recursive($a1,$a2,$a3,$a4); 
print_r($a5); 
 
print "显示修复\\n"; 
$a1 = array('first'=>'bob', 'last'=>'jones', 'age'=>'48'); 
$a2 = array('first'=>'sam', 'last'=>'smith', 'age'=>'41'); 
$a3 = array('first'=>'pete', 'last'=>null, 'age'=>'3'); 
array_walk($a3, 'null_to_empty'); 
$a4 = array('first'=>'joe', 'last'=>'johnson', 'age'=>'33'); 
$a5 = array_merge_recursive($a1,$a2,$a3,$a4); 
print_r($a5); 
print "</pre>\\n"; 
 
function null_to_empty(&$item) { 
 
 $item = is_null($item) ? '' : $item; 
} 
?>

上移

下移

miniscalope at gmail dot com ¶

15 年前

我想合并两个数组，但保持结果数组中的值唯一。
希望这能有所帮助…
<?php 

function array_merge_recursive_unique($array1, $array2) {
 
 foreach($array2 AS $k => $v) {
 if(!isset($array1[$k]))
 {
 $array1[$k] = $v;
 }
 else
 {
 if(!is_array($v)){
 if(is_array($array1[$k]))
 {
 if(!in_array($v,$array1[$k]))
 {
 $array1[$k][] = $v;
 }
 }
 else
 {
 if($array1[$k] != $v)
 $array1[$k] = array($array1[$k], $v);
 }
 }
 else
 {
 $array1[$k] = array_merge_recursive_unique($array1,$array2[$k]);
 }
 
 }
 
 }
 unset($k, $v);
 return $array1;
}

?>

上移

下移

paha at paha dot hu ¶

17 年前

在此版本中，仅当值不是数组时才会覆盖值。如果值为数组，则其元素将被合并/覆盖。

// array_merge_recursive 会用后续值覆盖值。
// 基于：https://php.net/manual/hu/function.array-merge-recursive.php 2006 年 12 月 9 日 03:38
function array_merge_recursive_unique($array0, $array1)
{
$arrays = func_get_args();
$remains = $arrays;

// 我们遍历每个数组并将值放入结果中（不考虑先前的值）。
// 考虑先前的值）。
$result = array();

// 循环可用的数组
foreach($arrays as $array) {

// 第一个剩余数组是 $array。我们正在处理它。所以
// 我们将其从剩余数组中移除。
array_shift($remains);

// 我们不关心非数组参数，例如 array_merge 自 PHP 5.0 以来。
if(is_array($array)) {
// 循环值
foreach($array as $key => $value) {
if(is_array($value)) {
// 我们收集所有具有此键可用的剩余数组
$args = array();
foreach($remains as $remain) {
if(array_key_exists($key, $remain)) {
array_push($args, $remain[$key]);
                        }
                    }

if(count($args) > 2) {
// 放入递归
$result[$key] = call_user_func_array(__FUNCTION__, $args);
} else {
foreach($value as $vkey => $vval) {
$result[$key][$vkey] = $vval;
                        }
                    }
} else {
// 简单地放入值
$result[$key] = $value;
                }
            }
        }
    }
return $result;
}

上移

下移

phil dot kemmeter at gmail dot com ¶

15 年前

我对这个版本进行了稍微更多的编辑，以便该函数不会覆盖任何值，而是在数组中插入到一个空闲键中。

function my_array_merge ($arr,$ins) {
if(is_array($arr))
    {
if(is_array($ins)) foreach($ins as $k=>$v)
        {
if(isset($arr[$k])&&is_array($v)&&is_array($arr[$k]))
            {
$arr[$k] = my_array_merge($arr[$k],$v);
            }
else {
// 这是新的循环 :)
while (isset($arr[$k]))
$k++;
$arr[$k] = $v;
            }
        }
    }
elseif(!is_array($arr)&&(strlen($arr)==0||$arr==0))
    {
$arr=$ins;
    }
return($arr);
}

示例

$array1 = array(
100 => array(30),
200 => array(20, 30)
);

$array2 = array(
100 => array(40),
201 => array(60, 30)
);

print_r(my_array_merge($array1,$array2));

使用 array_merge_recursive 的输出
数组
(
[0] => 数组
        (
            [0] => 30
        )

[1] => 数组
        (
            [0] => 20
            [1] => 30
        )

[2] => 数组
        (
            [0] => 40
        )

)
这不是我期望从 MERGE 例程中得到的结果……

使用当前函数的输出

数组
(
[100] => 数组
        (
            [0] => 30
            [1] => 40
        )

[200] => 数组
        (
            [0] => 20
            [1] => 30
        )

)

这就是我想要的 :)

上移

下移

dev at oove dot blue ¶

2 年前

我正在寻找像这样的函数
合并一个或多个数组而不追加值，只需在需要时覆盖和扩展数组。
用于合并配置或合并要保存在数据库中的 JSON 数据（我的情况）

类似于 javascript 中的 Object.assign

public static function array_merge()
    {
// 保存所有传递的数组
$params = func_get_args ();
// 第一个数组用作基础，其他所有内容都覆盖它
$return = array_shift ( $params );

if(!is_array($return))
$return = [];
// 将所有数组合并到第一个数组上
foreach ( $params as $array ) {
foreach ( $array as $key => $value ) {

if(!isset($return[$key]) || !is_array($value)) {
$return[$key] = $value;
                }
else
                {
$return[$key] = ArrayTools::array_merge( $return[$key], $value );
                }
            }
        }

return $return;

    }

上移

下移

hailongzh at hotmail dot com ¶

5 年前

分享我的代码以保留数字键

function revise_keys($source)
    {
if (!is_array($source)) {
return $source;
        }

$target = [];

foreach ($source as $key => $value) {
$target['S' . $key] = revise_keys($value);
        }

return $target;
    }

function revert_keys($source)
    {
if (!is_array($source)) {
return $source;
        }

$target = [];

foreach ($source as $key => $value) {
$target[substr($key, 1 - strlen($key))] = revert_keys($value);
        }

return $target;
    }

function enhanced_array_merge_recursive(...$candidates)
    {
$merged = [];

foreach ($candidates as $candidate) {
if (!is_array($candidate)) {
continue;
            }

$merged = array_merge_recursive($merged, revise_keys($candidate));
        }

return revert_keys($merged);
    }

上移

下移

gullevek at gullevek dot org ¶

5 年前

walfs 的版本非常好，但它始终假设我们希望数字键作为数字键。在某些情况下，数字键实际上是字符串“123”。

为此，我修改了该函数，以便最后一个参数是 true 开关以打开键可以是数字。默认情况下，所有键都是字符串。

<?php
function array_merge_recursive_simple()
{
 // 如果参数不足则报错（我们需要至少两个）
 if (func_num_args() < 2) {
 trigger_error(__FUNCTION__ .' needs two or more array arguments', E_USER_WARNING);
 return;
 }
 // 默认键不是字符串
 $key_is_string = false;
 $arrays = func_get_args();
 // 如果最后一个不是数组，则假设它是触发器，表示键始终为字符串
 if (!is_array(end($arrays))) {
 if (array_pop($arrays)) {
 $key_is_string = true;
 }
 }
 // 检查数组数量是否至少为两个，否则我们没有足够的
 if (count($arrays) < 2) {
 trigger_error(__FUNCTION__.' needs two or more array arguments', E_USER_WARNING);
 return;
 }
 $merged = array();
 while ($arrays) {
 $array = array_shift($arrays);
 if (!is_array($array)) {
 trigger_error(__FUNCTION__ .' encountered a non array argument', E_USER_WARNING);
 return;
 }
 if (!$array) {
 continue;
 }
 foreach ($array as $key => $value) {
 if (is_string($key) || $key_is_string === false) {
 if (is_array($value) && array_key_exists($key, $merged) && is_array($merged[$key])) {
 $merged[$key] = call_user_func(__FUNCTION__, $merged[$key], $value, $key_is_string);
 } else {
 $merged[$key] = $value;
 }
 } else {
 $merged[] = $value;
 }
 }
 }
 return $merged;
}
?>

上移

下移

匿名用户 ¶

9 年前

注意。
（使用 PHP 5.4。XAMPP）

具有数字键的值始终会被追加。合并数组的索引由第一个数组的起始索引决定。具有数字键的值似乎总是被追加。
如果键看起来像整数，则 array_merge_recursive 将字符串解释为数字。

在示例 $arr['farbe']['22'] = 'grün' 中，将在 array_merge_recursive 后在 $res['farbe'][33] 中找到。

$ar1 = array("farbe" => array (31 => 'holla', "rot", "favorit" => "gelb2"), "favorit" => "gelb1", 5); 

$ar2 = array(10, "farbe" => array ('22' => "grün", "favorit" => 2, "blau"));
$result = array_merge_recursive ($ar1, $ar2);
var_dump($result);
echo('<hr>');

// var_dump
数组(4) {
["farbe"]=>
数组(5) {
    [31]=>
字符串(5) "holla"
    [32]=>
字符串(3) "rot"
["favorit"]=>
数组(2) {
      [0]=>
字符串(5) "gelb2"
      [1]=>
整数(2)
    }
    [33]=>
字符串(5) "grün"
    [34]=>
字符串(4) "blau"
  }
["favorit"]=>
字符串(5) "gelb1"
  [0]=>
整数(5)
  [1]=>
int(10)
}

上移

下移

-1

zubkov dot rabota at gmail dot com ¶

7年前

这个递归数组合并函数不会重新编号整数键，而是将新值附加到现有值上，或者如果键值对不存在，则添加一个新的[键 => 值]对。

function array_merge_recursive_adv(array &$array1, $array2) {
if(!empty($array2) && is_array($array2))
foreach ($array2 as $key => $value) {
if(array_key_exists($key,$array1)) {
if(is_array($value)){
array_merge_recursive_adv($array1[$key], $value);
} else {
if(!empty($array1[$key])) {
if(is_array($array1[$key])){
array_push($array1[$key], $value);
} else {
$array1[$key] = [$array1[$key]];
$array1[$key][] = $value;
                                }
} else if(empty($array1[$key])) {
$array1[$key] = $value;
                             }
                        }
} else {
$array1[$key] = $value;
                    }
            }
return $array1;
    }

上移

下移

-2

zubkov dot rabota at gmail dot com ¶

7年前

这个递归数组合并函数不会重新编号整数键，而是将新值附加到现有值上，或者如果键值对不存在，则添加一个新的[键 => 值]对。

function array_merge_recursive_adv(array &$array1, $array2) {
if(!empty($array2) && is_array($array2))
foreach ($array2 as $key => $value) {
if(array_key_exists($key,$array1)) {
if(is_array($value)){
array_merge_recursive_adv($array1[$key], $value);
} else {
if(!empty($array1[$key])) {
if(is_array($array1[$key])){
array_push($array1[$key], $value);
} else {
$array1[$key] = [$array1[$key]];
$array1[$key][] = $value;
                                }
} else if(empty($array1[$key])) {
$array1[$key] = $value;
                             }
                        }
} else {
$array1[$key] = $value;
                    }
            }
return $array1;
    }

上移

下移

-1

匿名用户 ¶

9 年前

正确的简单示例

<?php

$Array1 = [1, 2];
$Array2 = [3, 4];

echo implode("<br>", array_merge_recursive($Array1, $Array2));

?>

输出
1
2
3
4

上移

下移

php at metehanarslan dot com ¶

10年前

有时您需要使用另一个数组修改数组，这是我递归替换数组内容并带有删除选项的方法。在这里，我使用“::delete::”作为保留字来删除项目。

<?php
$person= array(
 "name" => "Metehan",
 "surname"=>"Arslan",
 "age"=>27,
 "mail"=>"hidden",
 "favs" => array(
 "language"=>"php",
 "planet"=>"mercury",
 "city"=>"istanbul")
);

$newdata = array(
 "age"=>28,
 "mail"=>"::delete::",
 "favs" => array(
 "language"=>"js",
 "planet"=>"mercury",
 "city"=>"shanghai")
);

print_r(array_overlay($person,$newdata));
// 结果：数组 ( [name] => Metehan [surname] => Arslan [age] => 28 [favs] => 数组 ( [language] => js [planet] => mercury [city] => shanghai ) )

function array_overlay($a1,$a2)
{
 foreach($a1 as $k => $v) {
 if ($a2[$k]=="::delete::"){
 unset($a1[$k]);
 continue;
 };
 if(!array_key_exists($k,$a2)) continue;
 if(is_array($v) && is_array($a2[$k])){
 $a1[$k] = array_overlay($v,$a2[$k]);
 }else{
 $a1[$k] = $a2[$k];
 }
 
 }
 return $a1;
}
?>

上移

下移

lsiq at papotam com ¶

14 年前

<?php

// 此函数将数组与 $_SESSION 合并
// 如果省略第二个参数，则合并到根目录
// 如果给出一个 'path' 数组，则会深度合并

function arr2sess($arr, $path=array()){
 if (!is_array($arr)) return false;
 foreach($arr as $k => $v){
 if(is_array($arr[$k])) {
 $path[] = $k;
 arr2sess($arr[$k], $path);
 }else{
 $ref = &$_SESSION;
 if($path){
 foreach($path as $val){
 if(!$ref[$val]) $ref[$val] = array();
 $ref = &$ref[$val];
 }
 }
 $ref[$k] = $v;
 }
 }
}

session_start();
$x = array(k1=>12, k2=>array(kxx=>'forget me', kyy=>'I was allways here')); // 您在 $_SESSION 中是否有任何此类内容
$rpl = array(k2=>array(kxx=>'I am a replaced value',kzz=>'I am a new value'));
arr2sess($x, array('deep','deep','in_session')); // 您可以使用此方式 
arr2sess($x); // 或此
arr2sess($rpl); // 合并部分与 $_SESSION

$w = array(120, q=>array(199,100)); // 对数字键也以相同的方式工作
arr2sess($w, array('one','two'));
arr2sess($w);

echo '<pre>';
print_r($_SESSION);

?>

上移

下移

drvali at hotmail dot com ¶

15 年前

<?php
/**
 * 合并任意数量的任意维度的数组，后面的数组覆盖前面的键，
 * 除非键是数字，在这种情况下，重复的值不会被添加。
 *
 * 要合并的数组作为参数传递给函数。
 *
 * @access public
 * @return array 合并后的结果数组
 */
function array_merge_replace_recursive() {
 // 保存所有传递的数组
 $params = & func_get_args ();
 
 // 第一个数组用作基础，其他所有数组都覆盖它
 $return = array_shift ( $params );
 
 // 将所有数组合并到第一个数组上
 foreach ( $params as $array ) {
 foreach ( $array as $key => $value ) {
 // 添加数字键值（除非已存在）
 if (is_numeric ( $key ) && (! in_array ( $value, $return ))) {
 if (is_array ( $value )) {
 $return [] = $this->array_merge_replace_recursive ( $return [$$key], $value );
 } else {
 $return [] = $value;
 }
 
 // 替换字符串键值
 } else {
 if (isset ( $return [$key] ) && is_array ( $value ) && is_array ( $return [$key] )) {
 $return [$key] = $this->array_merge_replace_recursive ( $return [$$key], $value );
 } else {
 $return [$key] = $value;
 }
 }
 }
 }
 
 return $return;
}

$a = array (
 "a" => 1, 
 "b" => 2, 
 'foo', 
 'bar' 
);
$b = array (
 "a" => 2, 
 "c" => 3, 
 'foo' 
);

$c = array_merge_replace_recursive ( $a, $b );
print_r ( $a );
print_r ( $b );
print_r ( $c );
?>

输出
数组
(
[a] => 1
[b] => 2
[0] => foo
[1] => bar
)
数组
(
[a] => 2
[c] => 3
[0] => foo
)
数组
(
[a] => 2
[b] => 2
[0] => foo
[1] => bar
[c] => 3
)

上移

下移

michiel at synetic dot nl ¶

15 年前

对之前发布的 array_merge_recursive_distinct 函数（基于 daniel 的版本）进行了一点改进。此实现保留了原始的参数输入，您可以传递无限数量的数组进行合并。

<?php
function &array_merge_recursive_distinct()
{
 $aArrays = func_get_args();
 $aMerged = $aArrays[0];
 
 for($i = 1; $i < count($aArrays); $i++)
 {
 if (is_array($aArrays[$i]))
 {
 foreach ($aArrays[$i] as $key => $val)
 {
 if (is_array($aArrays[$i][$key]))
 {
 $aMerged[$key] = is_array($aMerged[$key]) ? PR::array_merge_recursive_distinct($aMerged[$key], $aArrays[$i][$key]) : $aArrays[$i][$key];
 }
 else
 {
 $aMerged[$key] = $val;
 }
 }
 }
 }
 
 return $aMerged;
}
?>

上移

下移

randallgirard at hotmail dot com ¶

18年前

我为合并数组编写了以下代码，在我的项目中主要用于配置……希望其他人也能发现它有用。

function array_merge_recursive_keys( $first, $second, $greedy=false) {
$inter = array_intersect_assoc(array_keys($first), array_keys($second)); # 共享键
# 下面的想法是将 $second 中的键值剥离并追加到 $first 中
foreach ( $inter as $key ) {
# 如果两者都是数组，则进行递归
if ( is_array($first[$key]) && is_array($second[$key]) ) {
$first[$key] = array_merge_recursive_keys($first[$key], $second[$key]);
      }
# 非贪婪数组合并
else if ( is_array($first[$key] && !$greedy ) ) {
$first[$key][] = $second[$key];
      }
else if ( is_array($second[$key]) && !$greedy ) {
$second[$key][] = $first[$key];
$first[$key] = $second[$key];
      }
# 覆盖...
else {
$first[$key] = $second[$key];
      }
unset($second[$key]);
   }
# 将不匹配的键合并到第一个数组中
return array_merge($first, $second);
}

上移

下移

thiago dot mata at yahoo dot com dot br ¶

18年前

<?php
 function array_merge_recursive_keep_keys( $arrElement1 , $arrElement2 , $intCount = 0 )
 {

 $arrNew = array();
 
 $arrElement1Keys = array_keys( $arrElement1 );
 $arrElement2Keys = array_keys( $arrElement2 );
 
 $arrDifKeys1 = array_diff( $arrElement1Keys, $arrElement2Keys );
 $arrDifKeys2 = array_diff( $arrElement2Keys, $arrElement1Keys );
 $arrInter = array_intersect( $arrElement1Keys , $arrElement2Keys );

 foreach( $arrDifKeys1 as $strKey1)
 {
 $arrNew[ $strKey1 ] = $arrElement1[ $strKey1 ];
 }
 foreach( $arrDifKeys2 as $strKey2)
 {
 $arrNew[ $strKey2 ] = $arrElement2[ $strKey2 ];
 }
 foreach( $arrInter as $strInterKey )
 {
 if( is_array( $arrElement1[ $strInterKey ] ) && is_array( $arrElement2[ $strInterKey ] ) )
 {
 $intCount++;
 $arrNew[ $strInterKey ] = array_merge_recursive_keep_keys( $arrElement1[ $strInterKey ] , $arrElement2[ $strInterKey ] , $intCount );
 }
 elseif( is_array( $arrElement1[ $strInterKey ] ) || is_array( $arrElement2[ $strInterKey ] ) )
 {
 $arrNew[ $strInterKey ][] = $arrElement1[ $strInterKey ];
 $arrNew[ $strInterKey ][] = $arrElement2[ $strInterKey ];
 }
 else
 {
 $arrNew[ $strInterKey ] = array();
 $arrNew[ $strInterKey ][] = $arrElement1[ $strInterKey ];
 $arrNew[ $strInterKey ][] = $arrElement2[ $strInterKey ];
 }
 }
 return $arrNew;
 } 
?>

上移

下移

paska at kios dot sk ¶

20 年前

此函数模拟根据 variable_order=GPC 替换 $_REQUEST 的行为。
<?
function array_merge_replace($array, $newValues) {
foreach ($newValues as $key => $value ) {
if (is_array($value)) {
if (!isset($array[$key])) {
$array[$key] = array();
                }
$array[$key] = array_merge_replace($array[$key], $value);
} else {
$array[$key] = $value;
            }
        }
return $array;
    }

$_REQUEST = array_merge_replace($_REQUEST, $_GET);
$_REQUEST = array_merge_replace($_REQUEST, $_POST);
$_REQUEST = array_merge_replace($_REQUEST, $_COOKIE);
?>

在主包含文件开头去除反斜杠很有用
<?
if (get_magic_quotes_gpc() == 1) {

function stripMagicSlashes($element) {
if (is_array($element)) {
return array_map("stripMagicSlashes", $element);
} else {
return stripslashes($element);
        }
    }

function array_merge_replace($array, $newValues) {
foreach ($newValues as $key => $value ) {
if (is_array($value)) {
if (!isset($array[$key])) {
$array[$key] = array();
                }
$array[$key] = array_merge_replace($array[$key], $value);
} else {
$array[$key] = $value;
            }
        }
return $array;
    }

$_GET = array_map("stripMagicSlashes", $_GET);
$_POST = array_map("stripMagicSlashes", $_POST);
$_COOKIE = array_map("stripMagicSlashes", $_COOKIE);

$_REQUEST = array_merge_replace($_REQUEST, $_GET);
$_REQUEST = array_merge_replace($_REQUEST, $_POST);
$_REQUEST = array_merge_replace($_REQUEST, $_COOKIE);

}

$GLOBALS['stripped'] = true;
?>

基于本网站用户提供的示例。

上移

下移

-1

manicdepressive at mindless dot com ¶

20 年前

请注意，在以下情况下：
两个数组在给定节点上同时具有相同的键和值，
如果该值为 NULL，则 array_merge_recursive() 的行为将有所不同，
与非空值相反。

例如，我期望下面前两部分的结果
具有相同的结构，但它们并不相同。
如果这可能适用于您，请自行查看。

<pre><?php

$a1 = array('a'=>'b');
$a2 = array('a'=>'b');
$a3 = array_merge_recursive($a1,$a2);
var_export($a3); 
echo "\n\n";

$a1 = array('a'=>NULL);
$a2 = array('a'=>NULL);
$a3 = array_merge_recursive($a1,$a2);
var_export($a3);
echo "\n\n";

$a1 = array('a'=>'b');
$a2 = array('a'=>NULL);
$a3 = array_merge_recursive($a1,$a2);
var_export($a3);
echo "\n\n";

?></pre>

如果值为空数组，也会出现此行为。
事实上，在上面的例子中，用空数组替换
NULL 的任何和所有出现将产生相同的结果。

编码到天亮！-mark

上移

下移

-1

felix dot ospald at gmx dot de ¶

16年前

如果您希望获得正确且高效的行为（与其他帖子相反），请使用此代码。它按上面记录的方式工作。
如果您希望始终保留键，并且如果键为数字则不追加或重新编号，请注释掉 "if (((string) $key) === ((string) intval($key)))"  的情况。
@spambegone at cratemedia dot com: 使用 empty 不是检查数组中是否存在项的正确方法，请使用 isset！ 


<?php

function array_merge_recursive2($array1, $array2)
{
 $arrays = func_get_args();
 $narrays = count($arrays);
 
 // 检查参数
 // 如果需要更高性能，可以注释掉（在这种情况下，如果参数不是数组，foreach 循环将触发警告）
 for ($i = 0; $i < $narrays; $i ++) {
 if (!is_array($arrays[$i])) {
 // array_merge_recursive 在这种情况下也会返回空
 trigger_error('参数 #' . ($i+1) . ' 不是数组 - 尝试合并数组和标量！返回 null！', E_USER_WARNING);
 return;
 }
 }
 
 // 第一个数组在任何情况下都包含在输出集中
 $ret = $arrays[0];
 
 // 将 $ret 与其余数组合并
 for ($i = 1; $i < $narrays; $i ++) {
 foreach ($arrays[$i] as $key => $value) {
 if (((string) $key) === ((string) intval($key))) { // 整数或字符串作为整数键 - 追加
 $ret[] = $value;
 }
 else { // 字符串键 - 合并
 if (is_array($value) && isset($ret[$key])) {
 // 如果 $ret[$key] 不是数组，则尝试将标量值与数组合并 - 结果未定义（不兼容的数组）
 // 在这种情况下，调用将触发 E_USER_WARNING，并且 $ret[$key] 将为 null。
 $ret[$key] = array_merge_recursive2($ret[$key], $value);
 }
 else {
 $ret[$key] = $value;
 }
 }
 } 
 }
 
 return $ret;
}

// 示例：

print_r(array_merge_recursive2(array('A','B','C' => array(1,2,3)), array('D','C' => array(1,4))));
/*
Array
(
 [0] => A
 [1] => B
 [C] => Array
 (
 [0] => 1
 [1] => 2
 [2] => 3
 [3] => 1
 [4] => 4
 )
 [2] => D
)*/

print_r(array_merge_recursive2(array('A','B','0' => array(1,2,3)), array('D','0' => array(1,array(4)))));
/*
Array
(
 [0] => Array
 (
 [0] => 1
 [1] => 2
 [2] => 3
 )
 [1] => B
 [2] => Array
 (
 [0] => 1
 [1] => Array
 (
 [0] => 4
 )
 )
)*/

print_r(array_merge_recursive2(array('A' => array('A' => 1)), array('A' => array('A' => array(2)))));
/*
Warning: 参数 #1 不是数组 - 尝试合并数组和标量！返回 null! in ... on line ...
*/

var_dump(array_merge_recursive2(array('A' => array('A' => 2)), array('A' => array('A' => null))));
/*
array(1) { ["A"]=> array(1) { ["A"]=> NULL } }
*/

?>

上移

下移

-1

Orhan POLAT ¶

9 年前

递归合并数组时，关于现有键存在一些问题，因此我像上面这样编写了该函数

function merge($array0, $array1) {
// 结果
$merged = array();

foreach (func_get_args() as $array) {
// 检查传入的参数是否为数组
if (is_array($array)) {
foreach ($array as $key => $value) {
// 检查是否存在一个键为 $key 的数组
if (isset($merged[$key])) {
// 检查值是否为数组
if (is_array($value)) {
// 因此我们必须将当前值与现有数组合并
$merged[$key] = call_user_func_array(__FUNCTION__, $merged[$key], $value);
} else {
if (!is_array($merged[$key])) {
// 如果键为 $key 的现有数组不是数组
// 我们将其转换为数组
$merged[$key] = array($merged[$key]);
       }

// 并添加当前值
$merged[$key][] = $value;
      }
} else {
// 如果不存在，则创建数组
$merged[$key] = $value;
     }
    }
   }
  }

return $merged;
 }

上移

下移

-1

scott dot clark at vizioninteractive dot com ¶

16年前

需要一种将两个数组融合在一起的方法，在这里找到一个函数（下面来自 thomas），并决定进一步更新它，使其更智能一些。


<?php 
function my_array_merge ($arr,$ins) 
 { 
 if(is_array($arr)) 
 { 
 if(is_array($ins)) foreach($ins as $k=>$v) 
 { 
 if(isset($arr[$k])&&is_array($v)&&is_array($arr[$k])) 
 { 
 $arr[$k] = my_array_merge($arr[$k],$v); 
 } 
 else $arr[$k] = $v; 
 } 
 } 
 elseif(!is_array($arr)&&(strlen($arr)==0||$arr==0)) 
 { 
 $arr=$ins; 
 } 
 return($arr); 
 } 
?>

上移

下移

-2

smilingrasta ¶

18年前

此函数倾向于重新索引数组，这在函数描述中未提及。

我尝试在一个包含错误消息的三维数组上运行该函数。
第一维包含错误的严重程度（'warn'、'crit'），第二维包含行号（数字），第三维包含错误消息

<?php
# 数组打印：
Array
 (
 [warn] => Array // 严重程度（关联）
 (
 [2] => Array // 行号（数字）
 (
 [0] => "Category does not exist" 
 [1] => "Manufacturer does not exist"
 )
 )
 )

?>

如果我现在使用 array_merge_recursive() 合并两个或多个这样的数组，行号将不会被保留。相反，它们都将重新编号，从 0 开始。

只是想让任何人都知道这一点。 :)
此致，smilingrasta

上移

下移

-3

cezarion at cezarion dot net ¶

10年前

来自 martyniuk 的 array_merge_recursive 的更新版本，不会覆盖数字键
function array_merge_recursive_new()
 {
$arrays = func_get_args();
$base = array_shift($arrays);

foreach ($arrays as $array) {
reset($base); // 重要
while (list($key, $value) = @each($array)) {
if (is_array($value) && @is_array($base[$key])) {
$base[$key] = array_merge_recursive_new($base[$key], $value);
} else {
if(isset($base[$key]) && is_int($key)) {
$key++;
                    }
$base[$key] = $value;
                }
            }
        }

return $base;
  }

上移

下移

-4

karl (dot) hepler (at) gmail (dot) com ¶

8年前

我遇到了一种相当独特的情况，其中 array_merge_recursive 几乎满足了我的需求，但并不完全如此。我阅读了所有评论，但没有找到任何真正帮助我的内容。我看到了很多提交的函数，它们只是试图重新创建 array_replace_recursive。这不是那个。

查看代码并试一试。希望它能帮助有需要的人！

class Arr
{
    /**
* 合并多个数组。
     *
* 这类似于 array_merge_recursive，但略有不同。
* 主要区别在于它将合并子数组中的类似键，
* 而不是简单地将它们推入输出数组。
     *
* @param array ...$array
     *
* @return array
     */
public static function merge()
    {
/** 初始化输出数组 */
$merged = [];

/** 遍历每个参数 */
foreach (func_get_args() as $array) {
/** 遍历此数组的每个键/值 */
foreach ($array as $key => $value) {
                /**
* 如果此键未在 merged 中设置，
* 则需要首次设置它
                 */
if (! isset($merged[$key])) {
                    /**
* 在我们设置它之前，我们必须确保
* 进入此值（如果它是数组），
* 以便处理其所有子项。
                     */
if (is_array($value)) {
$value = static::merge($value);
                    }

                    /**
* 现在我们对这个值感到满意了，
* 并且我们确定，如果它是一个数组，
* 它的所有子元素都已经被处理过了，
* 让我们继续设置它。
                     */
$merged[$key] = $value;

/** 我们可以跳过循环的其余部分 */
continue;
                }

                /**
* 我们在这里是因为我们想要设置一个
* 已经在 merged 中设置的键。我们不想
* 覆盖任何东西 - 我们想要添加到它。
* 所以，我们需要确保我们正在使用一个数组。
                 */
如果 (! is_array($merged[$key])) {
$merged[$key] = [$merged[$key]];
                }

                /**
* 在我们将值推入数组之前，
* 我们需要检查它本身是否是一个数组。
* 如果是，那么我们需要确保它的所有子元素
* 都被处理了。我们通过合并所有子元素来做到这一点
* 在一起。这与 array_merge_recursive 不同，
* 它只会将子元素推到数组的末尾。
                 */
if (is_array($value)) {
$value = forward_static_call_array([Arr::class, 'merge'], $value);
                }

/** 现在我们准备将值推入 merged */
$merged[$key][] = $value;
            }
        }

/** 返回合并后的数组 */
return $merged;
    }
}

＋添加注释