如何在PHP中对数组去重？array_unique()函数的实际应用-php教程-PHP中文网

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

如何在php中对数组去重？array_unique()函数的实际应用

在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

登录后复制

，它决定了如何比较数组元素。这在处理不同数据类型或需要特定比较行为时非常有用。

立即学习“PHP免费学习笔记（深入）”；

```
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()

登录后复制

，最后再反序列化回去。

怪兽AI数字人

数字人短视频创作，数字人直播，实时驱动数字人

查看详情

$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中其实还有一些其他的去重“土法炼钢”或者说变通方案。它们各有优劣，适用于不同的场景，了解它们能让你在面对各种去重需求时更加游刃有余。

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. 重新索引数组： 这是最常见的需求之一。如果你根本不关心原始键名，只想得到一个从

登录后复制

开始连续索引的去重数组，那么结合

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()函数的实际应用的详细内容，更多请关注php中文网其它相关文章！