PHP数组差异对比方法详解

想知道PHP如何对比两个数组的差异？本文将深入探讨PHP中用于数组差异比较的关键函数：`array_diff()`、`array_diff_assoc()`和`array_diff_key()`。这些函数分别从值、键值对和键名三个维度，帮助开发者高效地找出数组间的不同之处。掌握它们各自的比较逻辑，能让你在数据处理和分析中游刃有余。本文将通过实例代码，详细解析这些函数的用法和区别，助你轻松应对各种数组差异比较场景，提升PHP开发技能。无论是查找新增、删除元素，还是同步配置，都能找到合适的解决方案。

答案：PHP通过array_diff、array_diff_assoc和array_diff_key函数从值、键值对或键名维度比较数组差异，适用于不同场景的差异分析与数据处理。

PHP要比较两个数组的差异，核心就是利用它内置的一系列array_diff家族函数。这些函数能帮助我们从不同维度——比如只看值、同时看键和值，或者只看键——来找出两个或多个数组之间的不同之处。理解它们各自的侧重点，是高效处理数组差异的关键。

解决方案

我们在PHP里处理数组差异，通常会用到array_diff、array_diff_assoc和array_diff_key这几个函数。它们各自有不同的比较逻辑，所以搞清楚它们的区别，才能在实际开发中用对地方。

1. array_diff()：只比较值，不看键名

这个函数是最基础的，它会返回在第一个数组中存在，但在其他任何数组中都不存在的值。简单来说，就是找出第一个数组独有的“值”。键名在这里是被忽略的。

<?php
$array1 = ["a" => "apple", "b" => "banana", "c" => "cherry"];
$array2 = ["d" => "apple", "e" => "banana", "f" => "date"];

$diff = array_diff($array1, $array2);
print_r($diff);
// 输出：
// Array
// (
//     [c] => cherry
// )
?>

你看，虽然"apple"和"banana"在$array2里也有，但因为它们的值相同，array_diff就觉得它们“不差异”。只有"cherry"是$array1独有的值，所以它被返回了。键c之所以还在，是因为array_diff会保留第一个数组的键。

2. array_diff_assoc()：同时比较键和值

当你的数组里，键名和值都同样重要时，array_diff_assoc()就派上用场了。它会返回在第一个数组中存在，但在其他任何数组中，无论是键还是值，都与第一个数组不匹配的元素。这意味着，如果一个键在两个数组中都存在，但它们对应的值不同，或者一个键只存在于第一个数组，它都会被认为是差异。

<?php
$array1 = ["a" => "apple", "b" => "banana", "c" => "cherry"];
$array2 = ["a" => "apple", "b" => "grape", "d" => "date"];

$diff = array_diff_assoc($array1, $array2);
print_r($diff);
// 输出：
// Array
// (
//     [b] => banana
//     [c] => cherry
// )
?>

这里"a" => "apple"在两个数组里键和值都一样，所以没差异。"b" => "banana"和"b" => "grape"，虽然键都是b，但值不同了，所以$array1里的"b" => "banana"被认为是差异。"c" => "cherry"更是$array1独有的键值对，自然也算差异。

3. array_diff_key()：只比较键名，不看值

有时候，我们只关心数组的结构，也就是键名是否一致，而对键对应的值不那么在意。array_diff_key()就是为这种情况设计的。它会返回在第一个数组中存在，但在其他任何数组中都不存在的键名对应的元素。

<?php
$array1 = ["a" => "apple", "b" => "banana", "c" => "cherry"];
$array2 = ["a" => "orange", "d" => "date"];

$diff = array_diff_key($array1, $array2);
print_r($diff);
// 输出：
// Array
// (
//     [b] => banana
//     [c] => cherry
// )
?>

看这个例子，"a"键在两个数组中都存在，尽管它们的值不同，但array_diff_key只看键，所以"a"不被认为是差异。而"b"和"c"只存在于$array1中，因此它们被返回了。

在什么场景下，我应该选择array_diff而非array_diff_assoc？

这个问题其实挺常见的，我的经验是，这主要取决于你对“差异”的定义有多严格。

array_diff，在我看来，它更像是一种“内容比对”。你只关心数组里有什么“东西”，至于这个“东西”是放在哪个“抽屉”里（键名），它并不在乎。比如，你有一批商品列表，$listA = ['apple', 'banana', 'orange']，另一批是$listB = ['banana', 'grape']。如果你想知道$listA里有哪些商品是$listB没有的，那么array_diff($listA, $listB)就足够了，它会告诉你['apple', 'orange']。键名在这种场景下往往是数字索引，没什么实际意义，或者说，你压根就不关心。

而array_diff_assoc则严格得多，它要求“抽屉”和“抽屉里的东西”都得一致才算不差异。这更适用于那些结构化数据，比如用户配置、数据库行记录之类的。假设你有一个用户设置数组$userSettingsA = ['theme' => 'dark', 'font_size' => 'medium']，另一个是$userSettingsB = ['theme' => 'dark', 'font_size' => 'large']。如果你用array_diff($userSettingsA, $userSettingsB)，它会告诉你['medium']，这可能不是你想要的，因为你真正想知道的是font_size这个设置变了。这时候，array_diff_assoc($userSettingsA, $userSettingsB)就会返回['font_size' => 'medium']，这才能准确地指出哪个设置项发生了变化。

所以，如果你的数组是简单的值列表，或者键名本身没有业务含义，只是一个索引，那就用array_diff。但如果键名是数据的一部分，有明确的业务意义，且你关心的是键值对的完整匹配，那么array_diff_assoc才是正确的选择。选择哪个，说白了，就是看你对“相同”的定义是“值相同”还是“键值对都相同”。

处理多维数组的差异，这些函数还能用吗？有没有更灵活的办法？

哎，说到多维数组，array_diff家族的这些函数就有点力不从心了。它们设计之初就是为了处理一维数组的差异，也就是说，它们只会比较数组的“第一层”元素。如果你尝试用它们去比较包含数组的数组，结果往往不是你想要的。它们会把内层数组当作一个普通的值来比较，而PHP在默认情况下，会认为两个不同的数组实例（即使内容完全一样）也是不相等的。

举个例子：

<?php
$array1 = [
    'user1' => ['name' => 'Alice', 'age' => 30],
    'user2' => ['name' => 'Bob', 'age' => 25]
];
$array2 = [
    'user1' => ['name' => 'Alice', 'age' => 30],
    'user3' => ['name' => 'Charlie', 'age' => 35]
];

$diff_assoc = array_diff_assoc($array1, $array2);
print_r($diff_assoc);
// 输出：
// Array
// (
//     [user1] => Array
//         (
//             [name] => Alice
//             [age] => 30
//         )
//     [user2] => Array
//         (
//             [name] => Bob
//             [age] => 25
//         )
// )
?>

看到没，即使user1的子数组内容完全一样，array_diff_assoc也认为它们不同。这是因为PHP默认的==操作符在比较数组时，会检查它们的键值对是否都相等，但在这里，array_diff_assoc内部的比较逻辑可能不是我们期望的递归比较。

所以，对于多维数组的差异比较，我们通常需要自己写递归函数。这听起来可能有点复杂，但核心思想就是遍历数组的每一层，如果遇到子数组，就递归调用自身去比较。

这是一个简单的递归差异函数示例，可以找出$array1中相对于$array2的差异：

<?php
function recursive_array_diff(array $array1, array $array2): array
{
    $difference = [];
    foreach ($array1 as $key => $value) {
        if (!array_key_exists($key, $array2)) {
            // 键在 array2 中不存在
            $difference[$key] = $value;
        } elseif (is_array($value) && is_array($array2[$key])) {
            // 都是数组，递归比较
            $subDiff = recursive_array_diff($value, $array2[$key]);
            if (!empty($subDiff)) {
                $difference[$key] = $subDiff;
            }
        } elseif ($value !== $array2[$key]) {
            // 值不同
            $difference[$key] = $value;
        }
    }
    return $difference;
}

$array1 = [
    'id' => 1,
    'name' => 'Alice',
    'details' => ['age' => 30, 'city' => 'New York'],
    'tags' => ['php', 'dev']
];
$array2 = [
    'id' => 1,
    'name' => 'Alice Smith', // 名字不同
    'details' => ['age' => 30, 'city' => 'London'], // 城市不同
    'tags' => ['php', 'js'] // 标签不同
];

$diff = recursive_array_diff($array1, $array2);
print_r($diff);
// 输出：
// Array
// (
//     [name] => Alice
//     [details] => Array
//         (
//             [city] => New York
//         )
//     [tags] => Array
//         (
//             [1] => dev
//         )
// )
?>

这个recursive_array_diff函数会深入到每一层，找出$array1中与$array2不同的部分。它会返回$array1中那些要么键在$array2中不存在，要么键存在但值不同（包括子数组递归后的差异）的元素。这种方式就灵活多了，可以根据你的具体需求进行调整，比如是只比较值，还是同时比较键和值。

除了找出差异，我还能怎么利用这些函数来合并或更新数组？

找出差异只是第一步，更实际的用途是基于这些差异来执行后续操作，比如合并、更新或同步数组。array_diff家族的函数在这里能发挥挺大的作用。

1. 找出需要新增的元素： 如果你有一个“旧”数组和一个“新”数组，想知道“新”数组里有哪些是“旧”数组没有的（也就是新增的），你可以这样做：

<?php
$oldData = ['apple', 'banana'];
$newData = ['apple', 'banana', 'cherry'];

$toAdd = array_diff($newData, $oldData);
print_r($toAdd); // Array ( [2] => cherry )
?>

这样你就知道cherry是需要添加到oldData中的新元素了。

2. 找出需要删除的元素： 反过来，如果你想知道“旧”数组里有哪些是“新”数组不再有的（也就是需要删除的）：

<?php
$oldData = ['apple', 'banana', 'grape'];
$newData = ['apple', 'banana'];

$toRemove = array_diff($oldData, $newData);
print_r($toRemove); // Array ( [2] => grape )
?>

grape就是需要从oldData中移除的。

3. 更新或同步配置： 当涉及到配置或设置时，array_diff_assoc就非常有用。你可以比较当前配置和默认配置，找出哪些项是用户修改过的，或者比较两个版本的配置，找出哪些项发生了变化。

<?php
$defaultConfig = [
    'theme' => 'light',
    'font_size' => 'medium',
    'language' => 'en'
];
$userConfig = [
    'theme' => 'dark',
    'font_size' => 'medium',
    'language' => 'zh'
];

// 找出用户修改过的配置项
$changedConfig = array_diff_assoc($userConfig, $defaultConfig);
print_r($changedConfig);
// 输出：
// Array
// (
//     [theme] => dark
//     [language] => zh
// )

// 找出用户删除了的（或者说，恢复到默认值的）配置项
// 这需要更复杂的逻辑，比如先找出所有键，再比较值
// 或者，如果用户配置只是覆盖默认配置，那么array_replace_recursive更直接
?>

通过array_diff_assoc，我们能清晰地看到用户具体修改了哪些配置项。这对于保存用户设置，或者生成更新SQL语句都很有帮助。

4. 结合其他数组函数实现更复杂的逻辑： 比如，你可能想找出$array1中所有在$array2中键值都不同的元素，然后用$array2中的对应值去更新它们。这通常会涉及到array_diff_assoc找到差异后，再结合array_intersect_key或者手动遍历来实现。

举个例子，假设你有一个商品列表，你想更新它的库存和价格，但只更新那些在更新数据中存在且值不同的项：

<?php
$currentProducts = [
    'prod_A' => ['stock' => 10, 'price' => 100],
    'prod_B' => ['stock' => 5, 'price' => 50],
];
$updatedProducts = [
    'prod_A' => ['stock' => 8, 'price' => 100], // stock changed
    'prod_C' => ['stock' => 20, 'price' => 120], // new product
];

// 找出需要更新的现有产品（这里需要递归比较）
// 简化处理：假设我们只是想用 $updatedProducts 覆盖 $currentProducts 中的同名产品
$mergedProducts = array_replace_recursive($currentProducts, $updatedProducts);
print_r($mergedProducts);
// 输出：
// Array
// (
//     [prod_A] => Array
//         (
//             [stock] => 8
//             [price] => 100
//         )
//     [prod_B] => Array
//         (
//             [stock] => 5
//             [price] => 50
//         )
//     [prod_C] => Array
//         (
//             [stock] => 20
//             [price] => 120
//         )
// )
?>

array_replace_recursive在这里提供了一个更直接的更新/合并多维数组的方案，它会递归地用第二个数组的值覆盖第一个数组的值。虽然它不是直接找出差异，但它利用了“差异”的概念，通过覆盖来实现更新。如果你需要精确知道哪些字段被更新了，还是得回到递归的差异比较函数上。

总之，array_diff系列函数是PHP数组操作的基石，理解它们的工作原理并结合实际场景灵活运用，能大大提高我们处理数组数据的效率和准确性。

今天关于《PHP数组差异对比方法详解》的内容介绍就到此结束，如果有什么疑问或者建议，可以在golang学习网公众号下多多回复交流；文中若有不正之处，也希望回复留言以告知！