(PHP 4, PHP 5, PHP 7, PHP 8)
asort — 按升序对数组进行排序并保持索引关联
对 array 进行就地升序排序，使其键保持与其关联的值的相关性。
这主要用于对关联数组进行排序，其中实际元素的顺序很重要。
注意:
如果两个成员比较相等，它们将保留其原始顺序。在 PHP 8.0.0 之前，它们在排序数组中的相对顺序是不确定的。
注意:
将数组的内部指针重置为第一个元素。
array输入数组。
flags可选的第二个参数 flags 可用于使用以下值修改排序行为
排序类型标志
SORT_REGULAR - 按正常方式比较项目；详细信息在 比较运算符 部分中描述
SORT_NUMERIC - 按数值比较项目
SORT_STRING - 按字符串比较项目
SORT_LOCALE_STRING - 按字符串比较项目，基于当前区域设置。它使用区域设置，可以使用 setlocale() 更改
SORT_NATURAL - 使用“自然排序”按字符串比较项目，如 natsort()
SORT_FLAG_CASE - 可以与 SORT_STRING 或 SORT_NATURAL 组合（按位或）以不区分大小写地排序字符串
始终返回 true。
示例 #1 asort() 示例
<?php
$fruits = array("d" => "lemon", "a" => "orange", "b" => "banana", "c" => "apple");
asort($fruits);
foreach ($fruits as $key => $val) {
echo "$key = $val\n";
}
?>上面的示例将输出
c = apple b = banana d = lemon a = orange
水果已按字母顺序排序，并且与每个元素关联的索引已保留。
此函数可用于对多维数组进行排序，几乎无需任何工作，只需在自定义排序函数中使用单个值即可。
此函数传递整个子元素，即使它不是字符串。如果它是数组，就像在多维数组中的情况一样，它将传递整个子数组作为参数。
因此，做一些优雅的事情，比如这样
<?php
// 对多维数组进行排序
usort($results, "custom_sort");
// 定义自定义排序函数
function custom_sort($a,$b) {
return $a['some_sub_var']>$b['some_sub_var'];
}
?>
这在 4 行中完成其他函数需要 40 到 50 行才能完成的操作。这不需要你创建临时数组或任何东西。对我来说，这是一个非常理想的解决方案。
希望它能帮助你！/*
* 姓名：Aditya Mehrotra
* 电子邮件：[email protected]
*/
// 对也包含区分大小写数据的字母数字数组按值排序的示例
$exampleArray1 = $exampleArray2 = array(
0 => 'example1',
1 => 'Example10',
2 => 'example12',
3 => 'Example2',
4 => 'example3',
5 => 'EXAMPLE10',
6 => 'example10'
);
// 默认排序
asort($exampleArray1);
// 按值排序的区分大小写字母数字数据
asort($exampleArray2, SORT_STRING | SORT_FLAG_CASE | SORT_NATURAL);
// 默认排序的输出
print_r($exampleArray1);
/*
* 默认排序的输出
Array
(
[5] => EXAMPLE10
[1] => Example10
[3] => Example2
[0] => example1
[6] => example10
[2] => example12
[4] => example3
)
*/
print_r($exampleArray2);
/*
* 按值排序的区分大小写字母数字数据的输出
Array
(
[0] => example1
[3] => Example2
[4] => example3
[5] => EXAMPLE10
[1] => Example10
[6] => example10
[2] => example12
)
*/这是一个按指定子数组键对索引为二维数组进行排序的函数，可以按升序或降序排序。
它对于在查询返回后按特定字段对数据库查询结果进行排序很有用
此函数可能很贪婪。它将数组重新创建为哈希以使用 ksort()，然后再次重新创建
默认情况下，它将按升序排序，但如果您将 $reverse 指定为 true，它将返回按降序排序的记录
<?php
function record_sort($records, $field, $reverse=false)
{
$hash = array();
foreach($records as $record)
{
$hash[$record[$field]] = $record;
}
($reverse)? krsort($hash) : ksort($hash);
$records = array();
foreach($hash as $record)
{
$records []= $record;
}
return $records;
}
// 以下为示例代码
$airports = array
(
array( "code" => "LHR", "name" => "Heathrow" ),
array( "code" => "LGW", "name" => "Gatwick" ),
);
printf("Before: <pre>%s</pre>", print_r($airports, true));
$airports = record_sort($airports, "name");
printf("After: <pre>%s</pre>", print_r($airports, true));
?>
示例输出
Before: Array
(
[0] => Array ( [code] => LHR, [name] => Heathrow )
[1] => Array ( [code] => LGW, [name] => Gatwick )
)
After: Array
(
[0] => Array ( [code] => LGW, [name] => Gatwick )
[1] => Array ( [code] => LHR, [name] => Heathrow )
)在最近的一个项目中，我需要先按值排序一个关联数组，然后如果某个特定值出现多次，就按键排序。我编写了这个函数来完成这个任务。注意，参数默认情况下是按键和值升序排序，但允许对每个参数进行精细控制。
<?php
function aksort(&$array,$valrev=false,$keyrev=false) {
if ($valrev) { arsort($array); } else { asort($array); }
$vals = array_count_values($array);
$i = 0;
foreach ($vals AS $val=>$num) {
$first = array_splice($array,0,$i);
$tmp = array_splice($array,0,$num);
if ($keyrev) { krsort($tmp); } else { ksort($tmp); }
$array = array_merge($first,$tmp,$array);
unset($tmp);
$i = $num;
}
}
// 示例
$tmp = array('ca'=>1,'cb'=>2,'ce'=>1,'pa'=>2,'pe'=>1);
// 标准 asort
asort($tmp);
print_r($tmp);
// 按值升序排序，按键升序排序
aksort($tmp);
print_r($tmp);
// 按值降序排序，按键升序排序
aksort($tmp,true);
print_r($tmp);
// 按值降序排序，按键降序排序
aksort($tmp,true,true);
print_r($tmp);
// 结果
Array
(
[pe] => 1
[ca] => 1
[ce] => 1
[cb] => 2
[pa] => 2
)
Array
(
[ca] => 1
[ce] => 1
[pe] => 1
[cb] => 2
[pa] => 2
)
Array
(
[cb] => 2
[pa] => 2
[ca] => 1
[ce] => 1
[pe] => 1
)
Array
(
[pa] => 2
[cb] => 2
[pe] => 1
[ce] => 1
[ca] => 1
)这是一个我编写的用来对多维数组进行排序的小程序
<?php
/**
** comesafter ($s1, $s2)
**
** 返回 1 如果 $s1 在字母顺序上排在 $s2 之后，否则返回 0。
**/
function comesafter ($s1, $s2) {
/**
** 我们不想越过其中一个字符串的边界并导致段错误，
** 所以让我们看看哪个字符串更短。
**/
$order = 1;
if (strlen ($s1) > strlen ($s2)) {
$temp = $s1;
$s1 = $s2;
$s2 = $temp;
$order = 0;
}
for ($index = 0; $index < strlen ($s1); $index++) {
/**
** $s1 排在 $s2 之后
**/
if ($s1[$index] > $s2[$index]) return ($order);
/**
** $s1 排在 $s2 之前
**/
if ($s1[$index] < $s2[$index]) return (1 - $order);
}
/**
** 特殊情况，其中 $s1 是 $s2 的子字符串
**/
return ($order);
}
/**
** asortbyindex ($sortarray, $index)
**
** 按二级索引对多维数组进行排序。例如，组和用户数组的第 I 个成员的第 0 个索引
** 都是一个字符串标识符。在用户数组的情况下，这是用户名；在组数组中，这是组名。
** asortby
**/
function asortbyindex ($sortarray, $index) {
$lastindex = count ($sortarray) - 1;
for ($subindex = 0; $subindex < $lastindex; $subindex++) {
$lastiteration = $lastindex - $subindex;
for ($iteration = 0; $iteration < $lastiteration; $iteration++) {
$nextchar = 0;
if (comesafter ($sortarray[$iteration][$index], $sortarray[$iteration + 1][$index])) {
$temp = $sortarray[$iteration];
$sortarray[$iteration] = $sortarray[$iteration + 1];
$sortarray[$iteration + 1] = $temp;
}
}
}
return ($sortarray);
}
?>
它有点长，因为有所有注释，但我希望它有帮助。acecream 的函数运行良好，尤其是在使用 spectre 扩展时。
但是，有时必须保留索引值。要实现这一点，只需替换
$sorted_arr[] = $array[$arr_key];
为
$sorted_arr[$arr_key] = $array[$arr_key];我刚刚提交的 aksort 函数中有一个小错误。以下是完整的函数，其中已修正了错误
<?php
function aksort(&$array,$valrev=false,$keyrev=false) {
if ($valrev) { arsort($array); } else { asort($array); }
$vals = array_count_values($array);
$i = 0;
foreach ($vals AS $val=>$num) {
$first = array_splice($array,0,$i);
$tmp = array_splice($array,0,$num);
if ($keyrev) { krsort($tmp); } else { ksort($tmp); }
$array = array_merge($first,$tmp,$array);
unset($tmp);
$i = $i+$num;
// 从之前的帖子中修复：$i = $num;
}
}
?>不用管了……使用我的最后一条笔记作为快速提示：如果你想保留键，请使用 asort() 和 arsort() 来代替 sort() 和 rsort()。asort 有一个令人讨厌的功能，它会忽略数据中的任何默认或隐式顺序。例如，如果数组中的两个元素都包含“banana”，则在排序后，第一个元素不一定仍然是第一个。
这使得 Burrows-Wheeler 块排序的实现有点痛苦，需要在排序之前将尾随字符串附加到所有字符串，并在排序之后将其删除。为了保持所谓的“banana”顺序。这是我在下面发布的相同函数的修正版本。现在它将处理排序字段中的重复条目。例如：如果有两条记录的名称都是 Heathrow，它仍然可以工作。
<?php
function record_sort($records, $field, $reverse=false)
{
$hash = array();
foreach($records as $key => $record)
{
$hash[$record[$field].$key] = $record;
}
($reverse)? krsort($hash) : ksort($hash);
$records = array();
foreach($hash as $record)
{
$records []= $record;
}
return $records;
}
?>asortbyindex($sortarray, $index) 看起来像是 sort 而不是 asort。$sortarray 的键发生了变化。通过第二个索引对高级排序数组进行排序的函数，它生成升序（默认）或降序输出，并使用可选的自然不区分大小写的排序（可选的区分大小写）。
只需要前两个参数。
<?php
function sabsi ($array, $index, $order='asc', $natsort=FALSE, $case_sensitive=FALSE) {
if(is_array($array) && count($array)>0) {
foreach(array_keys($array) as $key) $temp[$key]=$array[$key][$index];
if(!$natsort) ($order=='asc')? asort($temp) : arsort($temp);
else {
($case_sensitive)? natsort($temp) : natcasesort($temp);
if($order!='asc') $temp=array_reverse($temp,TRUE);
}
foreach(array_keys($temp) as $key) (is_numeric($key))? $sorted[]=$array[$key] : $sorted[$key]=$array[$key];
return $sorted;
}
return $array;
}
?>这是我根据第二个索引对多维数组进行排序的版本。
您可以随意更改代码以满足您的需求。
<?php
function aSortBySecondIndex($multiArray, $secondIndex) {
while (list($firstIndex, ) = each($multiArray))
$indexMap[$firstIndex] = $multiArray[$firstIndex][$secondIndex];
asort($indexMap);
while (list($firstIndex, ) = each($indexMap))
if (is_numeric($firstIndex))
$sortedArray[] = $multiArray[$firstIndex];
else $sortedArray[$firstIndex] = $multiArray[$firstIndex];
return $sortedArray;
}
?>这是我编写的一个函数，允许您根据成员或函数对特定类的数组进行排序。
<?php
// 按类的成员进行排序（即使是小写）！
function casort($arr, $var) {
$tarr = array();
$rarr = array();
for($i = 0; $i < count($arr); $i++) {
$element = $arr[$i];
$tarr[] = strtolower($element->{$var});
}
reset($tarr);
asort($tarr);
$karr = array_keys($tarr);
for($i = 0; $i < count($tarr); $i++) {
$rarr[] = $arr[intval($karr[$i])];
}
return $rarr;
}
?>
它工作得很好。例如，我有一个 Room 类，它有 title、isActive()、date 等成员。我可以通过 casort($rooms, "title") 或 casort($rooms, "isActive()") 对数组进行排序，它可以正常工作。'asort' 适用于对英文数组进行排序，但如果数组中存在重音字符，则最好使用 PHP Collator 类的 'asort' 方法。
https://php.net/manual/en/class.collator.php
$collator = new \Collator('fr_CA');
$collator->asort($french_list);
可以使用 `setlocale()` 来控制 `asort` 的行为，但这在不同系统上不可靠。
例如，在我的开发环境中，我只访问以下本地设置
$ locale -a
C
C.UTF-8
POSIX与上面类似，但用于数组的数组而不是对象的数组。
<?php
function aasort($x,$var,$cmp='strcasecmp'){
if ( is_string($var) ) $var = "'$var'";
uasort($x,
create_function('$a,$b',
'return '.$cmp.'( $a['.$var.'],$b['.$var.']);')
);
return $x;
}
?>"此函数对数组进行排序，使数组索引保持与其关联的数组元素的关联关系。"
请注意描述中的这句话，当您处理最初未索引（或说整数索引）的数组并进行 JSON 编码/解码时，这句话有非常重要的意义。
我不将其报告为错误，因为最终结果符合描述。
<?php
$myArray = ['small_image', 'image'];
var_dump(json_encode($myArray)); // string(23) "["small_image","image"]"
var_dump(is_object($myArray)); // bool(false)
asort($myArray);
$myJson = json_encode($myArray);
var_dump($myJson); // string(31) "{"1":"image","0":"small_image"}"
var_dump(is_object($myArray)); // bool(false)
/*
* class stdClass#1 (2) {
* public $1 =>
* string(5) "image"
* public $0 =>
* string(11) "small_image"
* }
*/
var_dump(json_decode($myJson));
?>显然需要记录使用的键，这样我们才不会覆盖数组中的先前条目；o)
注意，这也会影响时间，但仍然比其他方法快
* int：0.00159（毫秒）
* str：0.00092（毫秒）
<?php
private function _keySort(Array $data)
{
$keys = array();
foreach($data as $row) {
$keyIncrement =
(!isset($keys[$row[$this->_orderField]]))
? $keys[$row[$this->_orderField]] = 0
: ++$keys[$row[$this->_orderField]];
$tempArray[$row[$this->_orderField].$keyIncrement] = $row;
}
if ($this->_orderDirection == 'DESC') {
krsort($tempArray, SORT_NATURAL | SORT_FLAG_CASE );
} else {
ksort($tempArray, SORT_NATURAL | SORT_FLAG_CASE);
}
return $tempArray;
}
?>dot brandon at chello dot nl 编写的函数存在错误 - 变量名错误。应该是
if($rev) arsort($named_hash,$flags=0) ;
而不是
if($reverse) arsort($named_hash,$flags=0) ;for ($i=0;$i<5;$i++)
$values[] = $i;
asort($values);
有效，但是
for ($i=0;$i<5;$i++)
$values[$i] =$i;
asort($values);
无效！好的，我弄错了，重新阅读了之前的帖子后，"."$key" 是很重要的。导致我排序出现问题的原因并不是这个，而是其他的原因。
在返回之前执行：asort($records, $flags); 可以修复排序问题。
我提到的排序问题会导致对数值数据进行基于字符的排序。
所以不是
1
2
3
...
10
12
20
而是被返回为
1
10
12
2
20
3
...
这基本上是我一开始想要修复的东西。我为一个需要从文本文件读取行而不是使用 sql - order by 语句的人创建了这个多维数组排序示例。
这个想法是获取键并对特定列进行排序（排列），然后根据选定列的 asort 返回结果对整个数组进行排序。
<?php
/**
*
* 此示例读取文本数据
* 并对二维数组执行排序
* 就像普通的 sql 对 "order by asc" 所做的那样
*
*/
$foo = array();
/*
# SORT_REGULAR - 按正常方式比较项（不改变类型）
# SORT_NUMERIC - 按数值比较项
# SORT_STRING - 按字符串比较项
*/
$sort_by = SORT_REGULAR;
/*
# 0 - 按 name 列排序
# 1 - 按 age 列排序
# 2 - 按 rank 列排序
# 3 - 按 color 列排序
*/
$order_by = 1;
// 源文件
$line_of_text[1] = 'a1name|f2age|h3rank|jcolor';
$line_of_text[2] = 'b1name|d2age|i3rank|k4color';
$line_of_text[0] = 'c1name|e2age|g3rank|l4color';
// 创建数组
for ($x=0; $x<=2; $x++)
{
$line = explode('|',$line_of_text[$x]);
// 按列保存，否则将按行保存
for ($i=0; $i<=3; $i++) {
$foo[$i][$x] = $line[$i];
}
}
// 获取键顺序
$a = $foo[$order_by];
// 排序
asort($a, $sort_by);
// 开始打印
echo "<table cellpudding=0 cellspacing=0 border=1>\n";
echo "<tr>\n";
echo "<td>key</td>\n";
echo "<td>name</td>\n";
echo "<td>age</td>\n";
echo "<td>rank</td>\n";
echo "<td>color</td>\n";
echo "</tr>\n";
// 按键顺序打印
foreach ($a as $k => $v) {
echo "<tr>\n";
echo "<td>$k</td>\n";
// 可以在此处打印一个 for 循环（0 到列数 [=3]）
echo "<td>".$foo[0][$k]."</td>\n";
echo "<td>".$foo[1][$k]."</td>\n";
echo "<td>".$foo[2][$k]."</td>\n";
echo "<td>".$foo[3][$k]."</td>\n";
echo "</tr>\n";
}
echo "</table>\n";
?>这个工作效果很好，但是如果在一个或多个数组索引在排序之前被删除，它会破坏结果数组。这个应该可以修复它
修改
for ($i = 0; $i < sizeof($array); $i++) {
为
foreach ($array as $i => $k) {我将这个用于类似 SQL 的 orderby。松散地基于 smileaf。对你们这些极客有用吗？
<?
function named_records_sort($named_recs, $order_by, $rev=false, $flags=0)
{// 创建一个仅包含排序字段（而不是记录）值的、一维的命名数组
// 排序字段（而不是记录）值
$named_hash = array();
foreach($named_recs as $key=>$fields)
$named_hash["$key"] = $fields[$order_by];
// 对一维数组进行排序，
// 保持键值关系
if($reverse) arsort($named_hash,$flags=0) ;
else asort($named_hash, $flags=0);
// 创建命名记录数组的副本
// 按排序数组的顺序排列
$sorted_records = array();
foreach($named_hash as $key=>$val)
$sorted_records["$key"]= $named_recs[$key];
return $sorted_records;} // named_recs_sort()
function show_sorted_records($named_recs, $order_by, $rev=false, $flags=0)
{$sorted_records=named_records_sort($named_recs, $order_by, $rev, $flags);
foreach($sorted_records as $name=>$fields)
{echo "<b>$name</b> ";
foreach($fields as $field=>$val)
echo "$field = $val "; echo "<br>";}
} // show_sorted_records()
$girl_friends=array();
$girl_friends["Anna"]=
array("born"=>'1989-08-22',"cupsize"=>'B-',"IQ"=>105, "daddy"=>'rich');
$girl_friends["Zoe"]
=array("born"=>'1978-03-11',"cupsize"=>'C#',"IQ"=>130, "daddy"=>'poor');
$girl_friends["Lilly"]
=array("born"=>'1985-06-16',"cupsize"=>'DD',"IQ"=>90, "daddy"=>'nasty');
$order_by="cupsize"; echo "And the winners are: <br>";
show_sorted_records($girl_friends, $order_by, true);
?>嗯，实际上，asort 有两个令人讨厌的功能。
它在对哈希（或关联数组，你可以这样理解）进行排序时工作得很好，但是顽固地拒绝对常规数组进行排序，同时保持索引关联。这有点说得通，但是文档中没有明确说明不能这样做。
Ugh。关于先按值排序，再按键排序（参见 2008-01-31 由 mike at clear-link dot com 撰写的笔记）
我想到的解决这个问题的方法是将键和值提取到单独的数组中，然后使用 array_multisort 来获得所需的顺序
例如
<?php
$kvpairs = array('noun' => 'thought', 'animal' => 'fish', 'abstract' => 'thought', 'food' => 'fish', 'verb' => 'fish');
print "before:\n";
print_r($kvpairs);
// 实际上，只需要一行代码就可以进行排序：
array_multisort(array_values($kvpairs), array_keys($kvpairs), $kvpairs);
print "after:\n";
print_r($kvpairs);
?>
之前
Array
(
[noun] => thought
[animal] => fish
[abstract] => thought
[food] => fish
[verb] => fish
)
之后
Array
(
[animal] => fish
[food] => fish
[verb] => fish
[abstract] => thought
[noun] => thought
)
当然，array_multisort 允许你为传递给它的每个数组指定排序顺序（SORT_ASC、SORT_DESC）和排序类型（SORT_REGULAR、SORT_STRING、SORT_NUMERIC）。与上面类似，但用于数组的数组而不是对象的数组。
<?php
function aasort($x,$var,$cmp='strcasecmp'){
if ( is_string($var) ) $var = "\'$var\'";
uasort($x,
create_function('$a,$b',
'return '.$cmp.'( $a['.$var.'],$b['.$var.']);')
);
return $x;
}
?>我写了这个函数，它可以对具有特定键的多维数组进行排序。
<?php
function sort_array($array, $sort_value, $reverse = false){
$value = $result = array();
foreach($array as $key => $rows){
$value[$key] = strtolower($rows[$sort_value]);
}
if($reverse == true){
arsort($value);
}else{
asort($value);
}
foreach($value as $keys => $null){
$result[] = $array[$keys];
}
return $result;
}
?>
示例
<?php
$array = array(array('a' => 'foo'), array('a' => 'foo4'), array('a' => 'foo2'), array('a' => 'foo3'));
print_r($array);
//Array ( [0] => Array ( [a] => foo ) [1] => Array ( [a] => foo4 ) [2] => Array ( [a] => foo2 ) [3] => Array ( [a] => foo3 ) )
print_r(sort_array($array, 'a'));
//Array ( [0] => Array ( [a] => foo ) [1] => Array ( [a] => foo2 ) [2] => Array ( [a] => foo3 ) [3] => Array ( [a] => foo4 ) )
print_r(sort_array($array, 'a', true));
//Array ( [0] => Array ( [a] => foo4 ) [1] => Array ( [a] => foo3 ) [2] => Array ( [a] => foo2 ) [3] => Array ( [a] => foo ) )
?>亲爱的 mike at clear-link dot com!
我需要一个不区分大小写的函数版本。它仍然不完美，因为我需要对特定国家/地区的字符（öüóőúéáűíÖÜÓŐÚÉÁŰÍ）进行一些操作。
function akisort(&$array,$valrev=false,$keyrev=false)
{
if ($valrev)
{
arsort($array);
}
else
{
asort($array);
};
$vals = array_count_values($array);
$i = 0;
foreach ($vals AS $val=>$num)
{
$first = array_splice($array,0,$i);
$tmp = array_splice($array,0,$num);
$tmp2 = array();
foreach($tmp as $key => $value)
{
$tmp2[] = $key;
$number = $value;
};
natcasesort($tmp2);
reset($tmp2);
print_r($tmp2);
unset($tmp);
foreach($tmp2 as $key => $value)
{
$tmp[$value] = $number;
};
if($keyrev)
{
$tmp = array_reverse($tmp, true);
};
$array = array_merge($first,$tmp,$array);
unset($tmp);
$i = $i+$num;
};
};我注意到我之前提到的函数非常具有误导性——请有人删除该注释！
这是你排序的方式
<?php
setlocale (LC_ALL, 'czech');
$array = array("a", "č", "c");
usort ($array, 'strcoll');
print_r($array);
?>