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()在处理标量类型（整数、浮点数、字符串、布尔值）时表现得非常出色，几乎是无脑好用。但当我们遇到复杂数据类型，比如对象（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()，最后再反序列化回去。
动态WEB网站中的PHP和MySQL：直观的QuickPro指南第2版
下载
动态WEB网站中的PHP和MySQL详细反映实际程序的需求，仔细地探讨外部数据的验证(例如信用卡卡号的格式)、用户登录以及如何使用模板建立网页的标准外观。动态WEB网站中的PHP和MySQL的内容不仅仅是这些。书中还提到如何串联JavaScript与PHP让用户操作时更快、更方便。还有正确处理用户输入错误的方法，让网站看起来更专业。另外还引入大量来自PEAR外挂函数库的强大功能，对常用的、强大的包
$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. 对反转后的数组去重，会保留现在是“第一个”的元素（即原 
