PHP数组去重技巧：array_unique实战教程

学习知识要善于思考，思考，再思考！今天golang学习网小编就给大家带来《PHP数组去重技巧：array_unique()实战应用》，以下内容主要包含等知识点，如果你正在学习或准备学习文章，就都不要错过本文啦~让我们一起来看看吧，能帮助到你就更好了！

array_unique()函数可直接去重并保留首次出现的键值，结合array_values()可重新索引，处理复杂类型时需手动遍历或序列化，灵活应对对象和嵌套数组去重需求。

在PHP中，对数组进行去重，最直接、最常用的方式就是利用内置的 array_unique() 函数。这个函数会遍历数组，移除所有重复的值，并且在遇到重复值时，它会保留第一次出现的值及其对应的键。简单来说，它能帮你快速得到一个只包含独一无二元素的数组。

解决方案

array_unique() 函数是PHP提供的一个非常方便的工具，用于从数组中移除重复的值。它的基本用法非常直观：

$originalArray = [1, 2, 3, 2, 4, 1, 5];
$uniqueArray = array_unique($originalArray);
print_r($uniqueArray);
/*
输出：
Array
(
    [0] => 1
    [1] => 2
    [2] => 3
    [4] => 4
    [6] => 5
)
*/

从上面的例子可以看出，array_unique() 会保留每个唯一值第一次出现时的键名。如果不需要保留原始键名，只想得到一个从0开始索引的数组，可以结合 array_values() 使用：

$originalArray = [1, 2, 3, 2, 4, 1, 5];
$uniqueArray = array_values(array_unique($originalArray));
print_r($uniqueArray);
/*
输出：
Array
(
    [0] => 1
    [1] => 2
    [2] => 3
    [3] => 4
    [4] => 5
)
*/

array_unique() 还有一个可选参数 sort_flags，它决定了如何比较数组元素。这在处理不同数据类型或需要特定比较行为时非常有用。

• SORT_REGULAR (默认): 正常比较项目（不改变类型）。
• SORT_NUMERIC: 将项目作为数字进行比较。
• SORT_STRING: 将项目作为字符串进行比较。
• SORT_LOCALE_STRING: 根据当前区域设置，将项目作为字符串进行比较。
• SORT_NATURAL: 使用“自然顺序”算法比较项目，就像 natsort() 函数那样。

比如，如果你有一些字符串数字，但想按数值去重：

$numbersAsString = ["10", "2", "10", "3", "2"];
$uniqueNumeric = array_unique($numbersAsString, SORT_NUMERIC);
print_r($uniqueNumeric);
/*
输出：
Array
(
    [0] => 10
    [1] => 2
    [3] => 3
)
*/

这里 SORT_NUMERIC 确保了 "10" 和 "2" 是作为数值而不是字符串进行比较的。

array_unique()在处理复杂数据类型时有哪些注意事项？

说实话，array_unique()在处理标量类型（整数、浮点数、字符串、布尔值）时表现得非常出色，几乎是无脑好用。但当我们遇到复杂数据类型，比如对象（Objects）或嵌套数组（Nested Arrays）时，事情就变得有点意思了，或者说，有点棘手了。

处理对象： 默认情况下，array_unique()在比较对象时，会尝试将它们转换为字符串。这意味着，如果两个不同的对象，它们的 __toString() 方法返回相同的值，或者在没有 __toString() 方法时，PHP默认的“对象转字符串”行为（通常是 Object of class Foo could not be converted to string 或者一个简单的 stdClass 标识）导致它们字符串表示相同，那么它们就会被认为是重复的。这显然不是我们通常想要的“对象相等”的概念。我们通常希望比较的是对象的属性值，甚至是对象的引用。

如果你想基于对象的特定属性去重，或者更复杂的逻辑，array_unique()就帮不上忙了。这时候，你得自己动手写点代码。一个常见的做法是，遍历数组，然后根据某个唯一标识属性（比如ID）来构建一个新的去重数组：

class User {
    public $id;
    public $name;

    public function __construct($id, $name) {
        $this->id = $id;
        $this->name = $name;
    }
}

$users = [
    new User(1, 'Alice'),
    new User(2, 'Bob'),
    new User(1, 'Alicia'), // ID重复
    new User(3, 'Charlie'),
    new User(2, 'Robert')  // ID重复
];

$uniqueUsers = [];
$seenIds = [];

foreach ($users as $user) {
    if (!isset($seenIds[$user->id])) {
        $uniqueUsers[] = $user;
        $seenIds[$user->id] = true;
    }
}

print_r($uniqueUsers);
/*
输出会是：
Array
(
    [0] => User Object
        (
            [id] => 1
            [name] => Alice
        )
    [1] => User Object
        (
            [id] => 2
            [name] => Bob
        )
    [2] => User Object
        (
            [id] => 3
            [name] => Charlie
        )
)
*/

这种手动遍历的方式虽然稍微麻烦点，但能精确控制去重逻辑。

处理嵌套数组：array_unique() 同样不能直接处理包含数组的数组。它会抛出一个 Array to string conversion 的通知，并且会把所有子数组都当作 Array 字符串进行比较，结果就是，所有子数组都会被认为是相同的（因为它们都被转换成了字符串 "Array"），这显然不是我们想要的。

要对嵌套数组去重，一种比较巧妙的方法是，将每个子数组序列化成字符串，然后对这些字符串进行 array_unique()，最后再反序列化回去。

$nestedArrays = [
    ['a' => 1, 'b' => 2],
    ['x' => 1, 'y' => 2],
    ['a' => 1, 'b' => 2], // 重复
    ['c' => 3, 'd' => 4],
    ['b' => 2, 'a' => 1]  // 值相同但键序不同
];

// 先序列化每个子数组
$serializedArrays = array_map('serialize', $nestedArrays);
print_r($serializedArrays);

// 对序列化后的字符串去重
$uniqueSerializedArrays = array_unique($serializedArrays);
print_r($uniqueSerializedArrays);

// 再反序列化回数组
$uniqueNestedArrays = array_map('unserialize', $uniqueSerializedArrays);
print_r($uniqueNestedArrays);
/*
输出会是：
Array
(
    [0] => Array
        (
            [a] => 1
            [b] => 2
        )
    [1] => Array
        (
            [x] => 1
            [y] => 2
        )
    [3] => Array
        (
            [c] => 3
            [d] => 4
        )
)
*/

需要注意的是，serialize() 是对数组的键值对和它们的顺序都敏感的。所以 ['a' => 1, 'b' => 2] 和 ['b' => 2, 'a' => 1] 序列化后是不同的字符串，会被认为是两个不同的数组。如果你希望它们被认为是相同的，你可能需要在序列化之前对子数组进行排序（比如按键名排序 ksort()）。

除了array_unique()，还有哪些PHP数组去重的方法，各自的优缺点是什么？

除了 array_unique() 这个主力选手，PHP中其实还有一些其他的去重“土法炼钢”或者说变通方案。它们各有优劣，适用于不同的场景，了解它们能让你在面对各种去重需求时更加游刃有余。

1. array_flip() 结合 array_keys()： 这种方法利用了 array_flip() 函数的特性：它会交换数组的键和值。如果数组中有重复的值，那么在 array_flip() 过程中，后面的重复值会覆盖掉前面相同值对应的键，最终只保留一个。然后，再用 array_keys() 取出所有的键（也就是原始的去重后的值）。

$data = ['apple', 'banana', 'orange', 'apple', 'grape'];
$uniqueData = array_keys(array_flip($data));
print_r($uniqueData);
/*
输出：
Array
(
    [0] => apple
    [1] => banana
    [2] => orange
    [3] => grape
)
*/

• 优点： 对于简单的标量值数组，尤其是字符串，这种方法通常比 array_unique() 更快，因为它利用了哈希表的查找效率。
• 缺点：
  • 值必须能作为键： 这意味着数组的值必须是字符串或整数。如果数组包含对象、布尔值（true 和 false 都会被转换为 1 和 0，导致冲突）、null 或者其他不能作为键的数据类型，array_flip() 会报错或产生意想不到的结果。
  • 丢失原始键名： array_keys() 会重新索引数组，原始键名会完全丢失。
  • 不适用于复杂类型： 和 array_unique() 类似，不能直接处理对象或嵌套数组。

2. 手动遍历与哈希表（或临时数组）检查： 这是最基础，也是最灵活的方法。通过循环遍历原数组，将每个值放入一个临时数组（通常作为键），或者用 in_array() 检查值是否已存在于结果数组中。

// 方法A：使用临时数组作为哈希表
$data = ['apple', 'banana', 'orange', 'apple', 'grape'];
$seen = [];
$uniqueData = [];
foreach ($data as $value) {
    if (!isset($seen[$value])) { // 检查值是否已经存在
        $uniqueData[] = $value;
        $seen[$value] = true;
    }
}
print_r($uniqueData);

// 方法B：使用 in_array() (性能较低)
$data = ['apple', 'banana', 'orange', 'apple', 'grape'];
$uniqueData = [];
foreach ($data as $value) {
    if (!in_array($value, $uniqueData)) {
        $uniqueData[] = $value;
    }
}
print_r($uniqueData);

• 优点：
  • 极度灵活： 可以轻松实现基于自定义比较逻辑的去重，比如前面提到的对象去重，或者根据某个子数组的特定元素去重。
  • 完全控制： 你可以决定保留第一个、最后一个，或者根据其他条件来选择保留哪个重复项。
• 缺点：
  • 代码量大： 相比内置函数，需要更多的代码。
  • 性能考量： 对于非常大的数组，如果使用 in_array()，性能会比较差，因为 in_array() 每次调用都需要遍历已去重的部分。使用哈希表（isset($seen[$value])）则效率高得多。

3. 使用 array_reduce() 或 array_filter() 结合自定义回调： 这是一种更函数式编程风格的方法，可以实现自定义去重逻辑，尤其是在处理更复杂的数据结构时。

$data = [
    ['id' => 1, 'name' => 'A'],
    ['id' => 2, 'name' => 'B'],
    ['id' => 1, 'name' => 'C'], // id重复
    ['id' => 3, 'name' => 'D']
];

$uniqueData = array_reduce($data, function ($carry, $item) {
    // 使用 id 作为键，确保唯一性
    $carry[$item['id']] = $item;
    return $carry;
}, []);

// 如果需要重新索引，可以再 array_values
$uniqueData = array_values($uniqueData);
print_r($uniqueData);
/*
输出：
Array
(
    [0] => Array
        (
            [id] => 1
            [name] => C
        )
    [1] => Array
        (
            [id] => 2
            [name] => B
        )
    [2] => Array
        (
            [id] => 3
            [name] => D
        )
)
*/

这个例子中，array_reduce() 的好处是，它能让你在累积结果时，直接利用键的唯一性来处理重复项。这里 ['id' => 1, 'name' => 'C'] 覆盖了 ['id' => 1, 'name' => 'A']，保留了最后一个。如果想保留第一个，需要调整逻辑。

• 优点： 简洁、函数式，对于有特定累积逻辑的去重场景非常优雅。
• 缺点： 对于初学者来说，理解 array_reduce() 的工作原理可能需要一些时间。性能通常介于 array_unique() 和 in_array() 循环之间，取决于回调函数的复杂性。

在我看来，选择哪种方法，真的得看你的具体需求：是简单去重、性能优先、还是需要高度自定义的比较逻辑。大多数情况下，array_unique() 已经足够了。但当它不够用时，了解这些备选方案能让你少走弯路。

array_unique()如何处理键名，以及在特定场景下如何灵活控制键名的保留？

array_unique() 在处理键名这块，行为是比较明确的：它会保留每个唯一值第一次出现时的原始键名。这意味着，如果你有一个数组 ['a' => 'apple', 'b' => 'banana', 'c' => 'apple']，经过 array_unique() 处理后，你会得到 ['a' => 'apple', 'b' => 'banana']。键 'a' 和 'b' 被保留了下来，而键 'c' 因为其对应的值 'apple' 是重复的，并且 'a' 对应的 'apple' 先出现，所以 'c' 被丢弃了。这个默认行为在很多场景下都是非常合理的，因为它在去重的同时，尽可能地维持了原始数组的结构信息。

默认行为的演示：

$dataWithKeys = [
    'first' => 'red',
    'second' => 'blue',
    'third' => 'red',     // 值 'red' 重复
    'fourth' => 'green',
    'fifth' => 'blue'     // 值 'blue' 重复
];

$uniqueData = array_unique($dataWithKeys);
print_r($uniqueData);
/*
输出：
Array
(
    [first] => red
    [second] => blue
    [fourth] => green
)
*/

可以看到，'first' 和 'second' 这两个键被保留了下来，因为它们对应的值是第一次出现的。

何时这种默认行为是理想的？ 当你的数组键名本身就带有某种意义，并且你希望在去重后，依然能够通过这些有意义的键来访问数据时，array_unique() 的默认行为就非常完美。例如，如果你有一个用户ID到用户名的映射，即使有重复的用户名，你可能也希望保留第一个出现的用户ID。

如何灵活控制键名的保留？

虽然 array_unique() 的默认行为很棒，但总有些时候，我们会有不同的需求。

1. 重新索引数组： 这是最常见的需求之一。如果你根本不关心原始键名，只想得到一个从 0 开始连续索引的去重数组，那么结合 array_values() 是最简单直接的方法：

$dataWithKeys = ['a' => 'apple', 'b' => 'banana', 'c' => 'apple'];
$reindexedUniqueData = array_values(array_unique($dataWithKeys));
print_r($reindexedUniqueData);
/*
输出：
Array
(
    [0] => apple
    [1] => banana
)
*/

这基本上就是丢弃所有原始键名，然后重新生成新的数字键名。

2. 保留重复值的“最后一个”键：array_unique() 总是保留第一个。但如果你的业务逻辑要求保留最后一个重复值的键（例如，最新的数据覆盖旧数据），那么 array_unique() 就无能为力了。这时候，你可以使用 array_reverse() 结合 array_unique()，然后再 array_reverse() 回来：

$dataWithKeys = [
    'first' => 'red',
    'second' => 'blue',
    'third' => 'red',     // 最后一个 'red'
    'fourth' => 'green',
    'fifth' => 'blue'     // 最后一个 'blue'
];

// 1. 反转数组，这样原先的“最后一个”就成了“第一个”
$reversedData = array_reverse($dataWithKeys, true); // true 保留键名
print_r($reversedData);

// 2. 对反转后的数组去重，会保留现在是“第一个”的元素（即原

今天关于《PHP数组去重技巧：array_unique实战教程》的内容就介绍到这里了，是不是学起来一目了然！想要了解更多关于去重方法,数组去重,复杂数据类型,键名,array_unique()的内容请关注golang学习网公众号！