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
，它决定了如何比较数组元素。这在处理不同数据类型或需要特定比较行为时非常有用。
立即学习“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()
在处理复杂数据类型时有哪些注意事项？
说实话，
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()
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()
如何处理键名，以及在特定场景下如何灵活控制键名的保留？
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()函数的实际应用的详细内容，更多请关注php中文网其它相关文章！
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 chuangxiangniao@163.com 举报，一经查实，本站将立刻删除。
发布者：程序猿，转转请注明出处：https://www.chuangxiangniao.com/p/1293035.html
微信扫一扫 
支付宝扫一扫 
