php提供了丰富的内置函数处理数组排序与去重，核心在于根据数据类型和需求选择合适方法。1. 对于简单数组排序，若不需保留键，使用sort()升序或rsort()降序；2. 关联数组按值排序且保留键用asort()或arsort()；3. 按键排序使用ksort()或krsort()；4. 复杂排序逻辑使用usort()、uasort()或uksort()配合自定义比较函数；5. 多维数组或多个数组同步排序使用array_multisort()；6. 去重首选array_unique()，但仅适用于标量值；7. 对象去重若基于实例唯一性可用splobjectstorage；8. 内容相同但实例不同的对象或复杂结构去重，可通过唯一键（如序列化或属性组合）手动去重。这些方法结合使用可高效处理各类数组操作需求。
PHP语言在处理数组的排序与去重方面，提供了相当丰富且灵活的内置函数，这使得我们能够高效地管理和操作数据。核心来看，无论是需要按值、按键，还是按自定义规则排序，亦或是移除重复元素，PHP都有成熟的解决方案。
解决方案
PHP提供了多种函数来满足数组排序和去重的需求。对于排序，最常用的是
sort()
、
rsort()
、
asort()
、
arsort()
、
ksort()
、
krsort()
，以及处理复杂场景的
usort()
、
uasort()
、
uksort()
和
array_multisort()
。去重方面，
array_unique()
是首选，但对于更复杂的数据类型，可能需要一些变通的方法。
数组排序：
立即学习“PHP免费学习笔记（深入）”；
-
: 对数组进行升序排序，并重新建立索引（数字键会被重置为0, 1, 2…）。
sort(array &$array, int $flags = SORT_REGULAR)
登录后复制$numbers = [3, 1, 4, 1, 5, 9]; sort($numbers); // $numbers 现在是 [1, 1, 3, 4, 5, 9]
登录后复制 -
: 与
rsort(array &$array, int $flags = SORT_REGULAR)
登录后复制sort()
登录后复制登录后复制登录后复制相反，进行降序排序，同样重新建立索引。
-
: 对关联数组按值进行升序排序，并保持键值关联。
asort(array &$array, int $flags = SORT_REGULAR)
登录后复制$grades = ['Math' => 90, 'Physics' => 85, 'English' => 92]; asort($grades); // $grades 现在是 ['Physics' => 85, 'Math' => 90, 'English' => 92]
登录后复制 -
: 与
arsort(array &$array, int $flags = SORT_REGULAR)
登录后复制asort()
登录后复制登录后复制登录后复制相反，按值降序排序并保持键值关联。
-
: 对关联数组按键进行升序排序。
ksort(array &$array, int $flags = SORT_REGULAR)
登录后复制$data = ['c' => 3, 'a' => 1, 'b' => 2]; ksort($data); // $data 现在是 ['a' => 1, 'b' => 2, 'c' => 3]
登录后复制 -
: 与
krsort(array &$array, int $flags = SORT_REGULAR)
登录后复制ksort()
登录后复制登录后复制登录后复制相反，按键降序排序。
-
: 使用用户自定义的比较函数对数组按值进行排序。这在需要复杂排序逻辑时非常有用，比如对对象数组按某个属性排序。它会重新建立索引。
usort(array &$array, callable $callback)
登录后复制$users = [ ['name' => 'Alice', 'age' => 30], ['name' => 'Bob', 'age' => 25], ['name' => 'Charlie', 'age' => 30] ]; usort($users, function($a, $b) { if ($a['age'] == $b['age']) { return $a['name'] <=> $b['name']; // 如果年龄相同，按名字排序 } return $a['age'] <=> $b['age']; // 否则按年龄排序 }); // $users 现在按年龄升序，年龄相同则按名字升序登录后复制 -
uasort()
登录后复制登录后复制登录后复制登录后复制/
: 分别是uksort()
登录后复制登录后复制usort()
登录后复制登录后复制登录后复制登录后复制登录后复制的关联数组版本（保持键值关联）和按键自定义排序版本。
-
: 用于对多个数组或多维数组的特定列进行排序。
array_multisort()
登录后复制登录后复制登录后复制登录后复制
数组去重：
-
: 移除数组中的重复值。默认情况下，它会保留第一次出现的键值对，并移除后续重复的。
array_unique(array $array, int $flags = SORT_REGULAR)
登录后复制$colors = ['red', 'green', 'blue', 'red', 'yellow', 'green']; $uniqueColors = array_unique($colors); // $uniqueColors 现在是 ['red', 'green', 'blue', 'yellow']
登录后复制
PHP数组排序，我究竟该选哪种方法？
选择正确的PHP数组排序方法，说实话，一开始确实有点让人眼花缭乱。但核心原则是：你关心的是“值”还是“键”？排序后是否需要保持原来的键？以及你的排序逻辑是不是非常个性化？
如果你的数组是简单的数字或字符串列表，且你不在乎原来的索引，
sort()
或
rsort()
无疑是最直接的选择。它们效率高，用起来也省心。比如，你有一堆考试分数，只想知道从低到高或从高到低排列，那它们就够了。
但如果你的数组是关联数组，比如用户ID对应用户名的那种，而你希望按用户名排序，同时又不想打乱ID和用户名的对应关系，那么
asort()
（升序）或
arsort()
（降序）就是你的救星。它们会保持键值对的“粘性”，只调整它们在数组中的位置。同理，如果你想按键名排序（比如按字母顺序排列配置项），
ksort()
和
krsort()
就派上用场了。
而当你的排序需求变得复杂，比如你有一个对象数组，每个对象都有名字、年龄、分数等属性，你想先按年龄排序，年龄相同再按分数排序，甚至分数相同再按名字排序……这种时候，内置的简单排序函数就力不从心了。这时，
usort()
（如果需要重置索引）或
uasort()
（如果需要保持键值关联）就成了不二之选。它们允许你传入一个自定义的比较函数，完全掌控排序逻辑。这个函数会接收两个元素作为参数，你只需要告诉PHP这两个元素谁应该排在前面（返回负数），谁排在后面（返回正数），或者它们是相等的（返回0）。这种灵活性是其他函数无法比拟的，虽然写起来多几行代码，但能解决绝大多数复杂排序问题。
// 假设有一个商品列表，需要先按价格降序，价格相同则按库存升序
$products = [
['name' => 'Laptop', 'price' => 1200, 'stock' => 50],
['name' => 'Mouse', 'price' => 25, 'stock' => 200],
['name' => 'Keyboard', 'price' => 1200, 'stock' => 30],
['name' => 'Monitor', 'price' => 300, 'stock' => 80]
];
uasort($products, function($a, $b) {
if ($a['price'] == $b['price']) {
return $a['stock'] <=> $b['stock']; // 价格相同，按库存升序
}
return $b['price'] <=> $a['price']; // 否则按价格降序
});
/*
$products 现在是：
[
['name' => 'Keyboard', 'price' => 1200, 'stock' => 30],
['name' => 'Laptop', 'price' => 1200, 'stock' => 50],
['name' => 'Monitor', 'price' => 300, 'stock' => 80],
['name' => 'Mouse', 'price' => 25, 'stock' => 200]
]
*/
这种自定义排序的能力，真的让PHP处理复杂数据变得游刃有余。
PHP数组去重，有哪些常见陷阱和高效技巧？
说起PHP数组去重，
array_unique()
无疑是第一个想到的，它简单直接，大多数时候也表现得很好。但就像所有看似简单的工具一样，它也有自己的“脾气”和“盲区”，尤其是在处理一些非标量数据类型时。
一个常见的陷阱是类型转换。
array_unique()
在比较元素时，默认会进行松散比较（
==
），这意味着它可能把
0
和
"0"
、
null
和
false
、甚至
"1"
和
1
视为相同的值。这在某些场景下可能是你想要的，但如果你的数据对类型非常敏感，这就会导致意想不到的去重结果。例如：
$data = [0, "0", false, null, 1, "1"]; $uniqueData = array_unique($data); // $uniqueData 可能是 [0, 1] 或类似的，具体取决于PHP版本和内部实现，但会把0, "0", false, null 视为相同
如果你需要严格的类型比较，
array_unique
本身无法直接做到，你可能需要手动遍历或者在去重前进行类型规范化。
另一个大陷阱是对象和多维数组。
array_unique()
对它们是“无能为力”的。它无法直接比较两个对象是否“相等”（除非对象实现了特定的比较魔术方法，但通常不是你想要的深层比较），也无法理解两个嵌套数组是否内容相同。当你把一个包含对象或多维数组的数组传给它时，它会发出警告（
E_NOTICE
）并返回一个未去重的数组，或者行为不符合预期。
那么，高效技巧呢？
对于大多数包含标量（数字、字符串）的数组，
array_unique()
是绝对的首选，因为它底层是C语言实现，效率非常高。你几乎不需要担心它的性能问题，除非你的数组有数百万甚至上千万个元素。
当涉及到对象去重时，就没有那么直接了。如果你想去重的是同一个对象的不同引用，PHP的
SplObjectStorage
类是神器。它专门用来存储对象并能快速判断对象是否存在，基于的是对象的唯一标识（而不是值）。
$obj1 = new stdClass(); $obj1->id = 1;
$obj2 = new stdClass(); $obj2->id = 2;
$obj3 = new stdClass(); $obj3->id = 1; // 内容相同，但这是不同的对象实例
$objects = [$obj1, $obj2, $obj3, $obj1]; // obj1出现了两次
$storage = new SplObjectStorage();
foreach ($objects as $obj) {
$storage->attach($obj);
}
$uniqueObjects = iterator_to_array($storage);
// $uniqueObjects 包含 $obj1, $obj2, $obj3 三个不同的对象实例，即使 $obj1 引用被重复添加，SplObjectStorage 也只存储一次
但如果你想去重的是“内容相同”但“实例不同”的对象，那就需要自定义逻辑了。通常的做法是给每个对象定义一个唯一的标识符（比如一个ID属性），然后把这个ID作为键存到一个临时数组里，或者在
usort
或
uasort
中自定义比较逻辑。
对于多维数组去重，一种常见的“黑科技”是序列化-去重-反序列化。你可以将每个子数组序列化成字符串，然后对这些字符串进行
array_unique()
，最后再反序列化回来。这种方法简单粗暴，但要注意序列化的开销和一些序列化可能带来的问题（比如对象属性的可见性）。
$nestedArrays = [
['a' => 1, 'b' => 2],
['c' => 3, 'd' => 4],
['a' => 1, 'b' => 2], // 重复项
['e' => 5, 'f' => 6]
];
$serializedArrays = array_map('serialize', $nestedArrays);
$uniqueSerializedArrays = array_unique($serializedArrays);
$uniqueNestedArrays = array_map('unserialize', $uniqueSerializedArrays);
/*
$uniqueNestedArrays 现在是：
[
['a' => 1, 'b' => 2],
['c' => 3, 'd' => 4],
['e' => 5, 'f' => 6]
]
*/
这方法虽然有效，但序列化和反序列化本身是有性能成本的，对于非常大的数组，需要权衡。
如何处理包含复杂数据类型（如对象或多维数组）的排序和去重？
当数组里装的不再是简单的数字或字符串，而是对象或者嵌套的数组时，排序和去重就变得有意思了，因为PHP内置的那些通用函数，很多时候就不那么“智能”了。
复杂数据类型的排序：
对于包含对象的数组，最常见也最强大的工具就是
usort()
或
uasort()
。你必须提供一个自定义的比较函数，告诉PHP如何判断两个对象谁大谁小。这个比较逻辑完全取决于你的业务需求。比如，你可能想按对象的某个属性值排序，或者根据多个属性的组合来排序。
class Product {
public $name;
public $price;
public $stock;
public function __construct($name, $price, $stock) {
$this->name = $name;
$this->price = $price;
$this->stock = $stock;
}
}
$products = [
new Product('Laptop', 1200, 50),
new Product('Mouse', 25, 200),
new Product('Keyboard', 1200, 30),
new Product('Monitor', 300, 80)
];
// 需求：先按价格降序，价格相同则按库存升序
usort($products, function(Product $a, Product $b) {
if ($a->price == $b->price) {
return $a->stock <=> $b->stock; // 价格相同，按库存升序
}
return $b->price <=> $a->price; // 否则按价格降序
});
// 此时 $products 数组中的对象已经按你定义的规则排序了
对于多维数组的排序，
usort()
同样适用，你只需在比较函数中访问子数组的对应键即可。此外，PHP还有一个
array_multisort()
函数，它能同时对多个数组进行排序，或者对多维数组的特定“列”进行排序。这在处理类似数据库查询结果的场景时特别有用。
$data = [
['name' => 'Alice', 'age' => 30, 'score' => 85],
['name' => 'Bob', 'age' => 25, 'score' => 90],
['name' => 'Charlie', 'age' => 30, 'score' => 92],
];
// 提取出需要排序的“列”
$ages = array_column($data, 'age');
$scores = array_column($data, 'score');
// 按照年龄升序，年龄相同则按分数降序
array_multisort($ages, SORT_ASC, SORT_NUMERIC,
$scores, SORT_DESC, SORT_NUMERIC,
$data);
// $data 现在按照年龄和分数排序了
array_multisort()
的用法稍微复杂一点，但它在处理表格数据或多个相关数组的同步排序时非常高效。
复杂数据类型的去重：
这才是真正考验你对数据结构理解的地方。
array_unique()
对对象和多维数组是无效的，因为它无法判断它们的“相等性”。
对于对象去重，如果你的“去重”指的是移除完全相同的对象实例（即同一个对象在内存中的不同引用），那么前面提到的
SplObjectStorage
是最佳选择。它基于对象在内存中的唯一标识符来判断是否重复。
然而，更常见的情况是，你希望移除的是“内容相同”但可能是不同实例的对象。例如，你有两个
Product
对象，它们的名字、价格、库存都一样，但它们是不同的
new Product()
出来的实例。这种情况下，你需要自己定义“相等”的逻辑。一种常见的做法是：
-
定义对象的唯一标识方法：在对象内部实现一个方法，比如
getUniqueKey()
登录后复制登录后复制，它返回一个能唯一代表该对象内容的字符串（比如
md5(serialize($this))
登录后复制，或者拼接关键属性）。
-
遍历去重：创建一个新的空数组，然后遍历原始数组。对于每个对象，调用
getUniqueKey()
登录后复制登录后复制获取其唯一键，然后用这个键作为临时数组的键，将对象存入。由于数组键的唯一性，重复的对象就会被覆盖，从而达到去重目的。
class Product {
public $name;
public $price;
public $stock;
public function __construct($name, $price, $stock) {
$this->name = $name;
$this->price = $price;
$this->stock = $stock;
}
// 定义一个方法来获取对象的唯一标识
public function getUniqueKey(): string {
return md5($this->name . '|' . $this->price . '|' . $this->stock);
}
}
$products = [
new Product('Laptop', 1200, 50),
new Product('Mouse', 25, 200),
new Product('Laptop', 1200, 50), // 内容重复
new Product('Monitor', 300, 80)
];
$uniqueProducts = [];
$seenKeys = [];
foreach ($products as $product) {
$key = $product->getUniqueKey();
if (!isset($seenKeys[$key])) {
$uniqueProducts[] = $product;
$seenKeys[$key] = true;
}
}
// $uniqueProducts 现在只包含内容唯一的Product对象
这种方法对于多维数组去重也同样适用，只需将子数组序列化成字符串作为唯一键即可。但要记住，序列化和反序列化操作会带来额外的性能开销，对于极大的数据集，需要仔细考虑。在实际开发中，理解这些方法的原理和适用场景，能帮助你更灵活、高效地处理PHP中的复杂数组操作。
以上就是php语言怎样实现数组的排序与去重功能 php语言数组排序去重的详细方法教程的详细内容，更多请关注php中文网其它相关文章！