sort

(PHP 4, PHP 5, PHP 7, PHP 8)

sort — 按升序对数组进行排序

描述

sort(array &$array, int $flags = SORT_REGULAR): true

按升序对 array 中的值进行就地排序。

注意:
如果两个成员比较相等，它们将保留其原始顺序。在 PHP 8.0.0 之前，它们在排序后的数组中的相对顺序是不确定的。

注意: 此函数会为 array 中的元素分配新的键。它会删除可能已被分配的任何现有键，而不是仅仅重新排序键。

注意:
将数组的内部指针重置为第一个元素。

参数

array

输入数组。

flags

可选的第二个参数 flags 可用于使用以下值修改排序行为

排序类型标志

SORT_REGULAR - 通常比较项；详细信息在比较运算符部分中描述
SORT_NUMERIC - 按数值比较项
SORT_STRING - 按字符串比较项
SORT_LOCALE_STRING - 按字符串比较项，基于当前区域设置。它使用区域设置，可以使用 setlocale() 更改
SORT_NATURAL - 使用“自然排序”按字符串比较项，类似于 natsort()
SORT_FLAG_CASE - 可以与 SORT_STRING 或 SORT_NATURAL 组合（按位或）以不区分大小写地对字符串进行排序

返回值

始终返回 true。

变更日志

版本	描述
8.2.0	返回值类型现在为 `true`；之前为 bool.

示例

示例 #1 sort() 示例

<?php

$fruits = array("lemon", "orange", "banana", "apple");
sort($fruits);
foreach ($fruits as $key => $val) {
 echo "fruits[" . $key . "] = " . $val . "\n";
}

?>

上面的示例将输出

fruits[0] = apple
fruits[1] = banana
fruits[2] = lemon
fruits[3] = orange

水果已按字母顺序排序。

示例 #2 使用不区分大小写的自然排序的 sort() 示例

<?php

$fruits = array(
 "Orange1", "orange2", "Orange3", "orange20"
);
sort($fruits, SORT_NATURAL | SORT_FLAG_CASE);
foreach ($fruits as $key => $val) {
 echo "fruits[" . $key . "] = " . $val . "\n";
}

?>

上面的示例将输出

fruits[0] = Orange1
fruits[1] = orange2
fruits[2] = Orange3
fruits[3] = orange20

水果已按 natcasesort() 的方式排序。

注释

注意: 与大多数 PHP 排序函数一样，sort() 使用 » 快速排序的实现。枢轴选择在分区中间，这使得已经排序的数组能够实现最佳时间。但这只是一个实现细节，你不应该依赖它。

警告

在对包含混合类型值的数组进行排序时要小心，因为如果 flags 为 SORT_REGULAR，sort() 会产生意想不到的结果。

参见

rsort() - 按降序对数组进行排序
数组排序函数的比较

改进此页面

了解如何改进此页面 • 提交拉取请求 • 报告错误

＋添加注释

用户贡献的注释 36 个注释

上

下

221

phpdotnet at m4tt dot co dot uk ¶

13 年前

对数组按特定键进行排序的简单函数。保持索引关联。

<?php

function array_sort($array, $on, $order=SORT_ASC)
{
 $new_array = array();
 $sortable_array = array();

 if (count($array) > 0) {
 foreach ($array as $k => $v) {
 if (is_array($v)) {
 foreach ($v as $k2 => $v2) {
 if ($k2 == $on) {
 $sortable_array[$k] = $v2;
 }
 }
 } else {
 $sortable_array[$k] = $v;
 }
 }

 switch ($order) {
 case SORT_ASC:
 asort($sortable_array);
 break;
 case SORT_DESC:
 arsort($sortable_array);
 break;
 }

 foreach ($sortable_array as $k => $v) {
 $new_array[$k] = $array[$k];
 }
 }

 return $new_array;
}

$people = array(
 12345 => array(
 'id' => 12345,
 'first_name' => 'Joe',
 'surname' => 'Bloggs',
 'age' => 23,
 'sex' => 'm'
 ),
 12346 => array(
 'id' => 12346,
 'first_name' => 'Adam',
 'surname' => 'Smith',
 'age' => 18,
 'sex' => 'm'
 ),
 12347 => array(
 'id' => 12347,
 'first_name' => 'Amy',
 'surname' => 'Jones',
 'age' => 21,
 'sex' => 'f'
 )
);

print_r(array_sort($people, 'age', SORT_DESC)); // Sort by oldest first
print_r(array_sort($people, 'surname', SORT_ASC)); // Sort by surname

/*
Array
(
 [12345] => Array
 (
 [id] => 12345
 [first_name] => Joe
 [surname] => Bloggs
 [age] => 23
 [sex] => m
 )
 
 [12347] => Array
 (
 [id] => 12347
 [first_name] => Amy
 [surname] => Jones
 [age] => 21
 [sex] => f
 )
 
 [12346] => Array
 (
 [id] => 12346
 [first_name] => Adam
 [surname] => Smith
 [age] => 18
 [sex] => m
 )
 
)
Array
(
 [12345] => Array
 (
 [id] => 12345
 [first_name] => Joe
 [surname] => Bloggs
 [age] => 23
 [sex] => m
 )
 
 [12347] => Array
 (
 [id] => 12347
 [first_name] => Amy
 [surname] => Jones
 [age] => 21
 [sex] => f
 )
 
 [12346] => Array
 (
 [id] => 12346
 [first_name] => Adam
 [surname] => Smith
 [age] => 18
 [sex] => m
 )
 
)
*/

?>

上

下

Walter Tross ¶

12 年前

除非您指定第二个参数，否则将使用“常规”比较。我引用了比较运算符页面
“如果您将数字与字符串进行比较，或者比较涉及数字字符串，则每个字符串将被转换为数字，然后进行数值比较。”
这意味着“10” < “1a”，并且“1a” < “2”，但“10” > “2”。换句话说，常规 PHP 字符串比较不是传递的。
这意味着 sort() 的输出在极少数情况下可能取决于输入数组的顺序
<?php
function echo_sorted($a)
{
 echo "{$a[0]} {$a[1]} {$a[2]}";
 sort($a);
 echo " => {$a[0]} {$a[1]} {$a[2]}\n";
}
// on PHP 5.2.6:
echo_sorted(array( "10", "1a", "2")); // => 10 1a 2
echo_sorted(array( "10", "2", "1a")); // => 1a 2 10
echo_sorted(array( "1a", "10", "2")); // => 2 10 1a
echo_sorted(array( "1a", "2", "10")); // => 1a 2 10
echo_sorted(array( "2", "10", "1a")); // => 2 10 1a
echo_sorted(array( "2", "1a", "10")); // => 10 1a 2
?>

上

下

aminkhoshzahmat at gmail dot com ¶

4 年前

假设我们有一份姓名列表，并且它没有排序。

<?php

$names = array('Amin', 'amir', 'sarah', 'Somayeh', 'armita', 'Armin');

sort($names); // 简单字母排序
print_r($names);
?>
结果是
数组
(
[0] => Amin
[1] => Armin
[2] => Somayeh // 实际上，从这里开始它不是按字母顺序排序的！
[3] => amir // 比较基于 ASCII 值。
[4] => armita
[5] => sarah
)

如果要按字母顺序排序，无论大小写如何

<?php

sort($names, SORT_STRING | SORT_FLAG_CASE);
print_r($names);
?>

结果是
数组
(
[0] => Amin
[1] => amir
[2] => Armin
[3] => armita
[4] => sarah
[5] => Somayeh
)

上

下

danm68 at gmail dot com ¶

14 年前

sort() 用于字符串时，不会仅仅按字母顺序排序。它首先按字母顺序排序所有大写字符串，然后按字母顺序排序小写字符串。
以防有人像我一样困惑，而且我从未在任何地方见过它。

上

下

Abhishek Banerjee ¶

8 年前

编辑：“phpdotnet at m4tt dot co dot uk”的原始说明
使用 array_push 而不是 $new_array[$k]，因为它出于某种原因
给了我字符串索引。

对数组按特定键进行排序的简单函数。保持索引关联。

<?php

function array_sort($array, $on, $order=SORT_ASC)
{
 $new_array = array();
 $sortable_array = array();

 if (count($array) > 0) {
 foreach ($array as $k => $v) {
 if (is_array($v)) {
 foreach ($v as $k2 => $v2) {
 if ($k2 == $on) {
 $sortable_array[$k] = $v2;
 }
 }
 } else {
 $sortable_array[$k] = $v;
 }
 }

 switch ($order) {
 case SORT_ASC:
 asort($sortable_array);
 break;
 case SORT_DESC:
 arsort($sortable_array);
 break;
 }

 foreach ($sortable_array as $k => $v) {
 array_push($new_array, $array[$k]);
 }
 }

 return $new_array;
}

$people = array(
 12345 => array(
 'id' => 12345,
 'first_name' => 'Joe',
 'surname' => 'Bloggs',
 'age' => 23,
 'sex' => 'm'
 ),
 12346 => array(
 'id' => 12346,
 'first_name' => 'Adam',
 'surname' => 'Smith',
 'age' => 18,
 'sex' => 'm'
 ),
 12347 => array(
 'id' => 12347,
 'first_name' => 'Amy',
 'surname' => 'Jones',
 'age' => 21,
 'sex' => 'f'
 )
);

print_r(array_sort($people, 'age', SORT_DESC)); // Sort by oldest first
print_r(array_sort($people, 'surname', SORT_ASC)); // Sort by surname

/*
Array
(
 [12345] => Array
 (
 [id] => 12345
 [first_name] => Joe
 [surname] => Bloggs
 [age] => 23
 [sex] => m
 )

 [12347] => Array
 (
 [id] => 12347
 [first_name] => Amy
 [surname] => Jones
 [age] => 21
 [sex] => f
 )

 [12346] => Array
 (
 [id] => 12346
 [first_name] => Adam
 [surname] => Smith
 [age] => 18
 [sex] => m
 )

)
Array
(
 [12345] => Array
 (
 [id] => 12345
 [first_name] => Joe
 [surname] => Bloggs
 [age] => 23
 [sex] => m
 )

 [12347] => Array
 (
 [id] => 12347
 [first_name] => Amy
 [surname] => Jones
 [age] => 21
 [sex] => f
 )

 [12346] => Array
 (
 [id] => 12346
 [first_name] => Adam
 [surname] => Smith
 [age] => 18
 [sex] => m
 )

)
*/

?>

上

下

eriewave at hotmail dot com ¶

14 年前

如果您需要对包含一些等效值的数组进行排序，并且希望这些等效值在整体排序中彼此相邻（类似于 MySQL 的 ORDER BY 输出），而不是破坏函数，请执行以下操作

<?php

sort($array, ksort($array))

?>

-当 sort() 函数找到两个等效值时，它将通过它们的键号（作为第二个参数）以任意顺序对其进行排序。

-Dirk

上

下

matpatnik at hotmail dot com ¶

16 年前

此函数将对实体字母（如：&eacute;）进行排序

我希望这对某人有帮助

function sort_entity($array) {
$total = count($array);
for ($i=0;$i<$total;$i++) {
if ($array[$i]{0} == '&') {
$array[$i] = $array[$i]{1}.$array[$i];
} else {
$array[$i] = $array[$i]{0}.$array[$i];
        }
    }
sort($array);
    
for ($i=0;$i<$total;$i++) {
$array[$i] = substr($array[$i],1);
    }
    
return $array;
}

上

下

ajanata at gmail dot com ¶

12 年前

我花了比预期的更长的时间才弄明白，但是如果您希望 sort($array, SORT_STRING) 的行为（也就是说，不像 natcasesort 那样重新索引数组）以不区分大小写的方式进行，那么只需执行 usort($array, strcasecmp) 即可。

上

下

joris at mangrove dot nl ¶

17 年前

对笔记 https://php.net/manual/en/function.sort.php#62311 的评论

对对象数组进行排序并不总是能得到您想要的结果。

如上所述，sort() 按第一个成员变量的值对数组进行排序。但是，您不能总是假设成员变量的顺序！您必须考虑类层次结构！

默认情况下，PHP 将继承的成员变量放在顶部，这意味着您的第一个成员变量不是类定义中的第一个变量！
但是，如果您使用代码分析器或编译缓存，情况可能大不相同。例如，在 eAccelerator 中，继承的成员变量位于末尾，这意味着开启或关闭缓存会导致不同的排序结果。

结论
不要对值类型不是标量或数组的数组使用 sort。

上

下

Md. Abutaleb ¶

4 年前

<?php 
/*
我发现 sort() 函数通常按照以下优先级顺序工作：
1. NULL
2. 空
3. 布尔值 FALSE
4. 字符串
5. 浮点数
6. 整数
7. 数组
8. 对象

考虑以下数组：
*/

$a = ['fruit'=> 'apple', 'A' => 10, 20, 5, 2.5, 5=>'A new value', 'last' => 'value', TRUE, NULL, "", FALSE, array(), new StdClass];
sort($a);
var_dump($a);

#输出结果是：

array(13) {
 [0]=>NULL
 [1]=> string(0) ""
 [2]=>bool(false)
 [3]=>string(11) "A new value"
 [4]=>string(5) "apple"
 [5]=>string(5) "value"
 [6]=> float(2.5)
 [7]=> int(5)
 [8]=>int(10)
 [9]=>int(20)
 [10]=>array(0) { }
 [11]=> bool(true)
 [12]=>object(stdClass)#1 (0) {}
}

//希望这能消除您在对混合类型数据数组进行排序时的困惑。
?>

上

下

peek at mailandnews dot com ¶

23 年前

我在不区分大小写排序时遇到了同样的问题。实际上我认为应该有一个 SORT_STRING_CASE 标志，但我尝试了以下操作


usort($listing, 'strcasecmp');


这不起作用（为什么？），但您可以像这样执行正确的区分大小写排序


usort($listing, create_function('$a,$b','return strcasecmp($a,$b);'));

上

下

r at rcse dot de ¶

5 年前

这里没有关于按任何排序规则对 UTF-8 字符串进行排序的说明。这应该不是那么罕见吧？

上

下

stepmuel at ee dot ethz dot ch ¶

15 年前

对对象数组进行排序的简短方法；使用回调函数。

<?php 
function objSort(&$objArray,$indexFunction,$sort_flags=0) {
 $indices = array();
 foreach($objArray as $obj) {
 $indeces[] = $indexFunction($obj);
 }
 return array_multisort($indeces,$objArray,$sort_flags);
}

function getIndex($obj) {
 return $obj->getPosition();
}

objSort($objArray,'getIndex'); 
?>

上

下

aditycse at gmail dot com ¶

9 年前

/*
* 姓名：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);
/*
* 默认排序的输出
数组
  (
[5] => EXAMPLE10
[1] => Example10
[3] => Example2
[0] => example1
[6] => example10
[2] => example12
[4] => example3
  )
 */

print_r($exampleArray2);
/*
* 字母数字，按值排序，大小写敏感数据的输出
数组
(
[0] => example1
[3] => Example2
[4] => example3
[5] => EXAMPLE10
[1] => Example10
[6] => example10
[2] => example12
)
 */

上

下

williamprogphp at[pleaseNOTSPAM] yahoo d ¶

10 年前

为了实现一些多维快速排序，利用这些东西

<?php
 function quickSortMultiDimensional($array, $chave) {
 if( count( $array ) < 2 ) {
 return $array;
 }
 $left = $right = array( );
 reset( $array );
 $pivot_key = key( $array );
 $pivot = array_shift( $array );
 foreach( $array as $k => $v ) {
 if( $v[$chave] < $pivot[$chave] )
 $left[$k][$chave] = $v[$chave];
 else
 $right[$k][$chave] = $v[$chave];
 }
 return array_merge(
 quickSortMultiDimensional($left, $chave), 
 array($pivot_key => $pivot), 
 quickSortMultiDimensional($right, $chave)
 ); 
 }
?>

我使用 pageconfig dot com 中的想法来实现它

感谢您的观看

上

下

me[ at ]szczepan[ dot ]info ¶

11 年前

排序键，但保持值的顺序是不可能的，因为这会导致一个新的数组。这也是解决方案：创建一个新的数组

<?php
$a = array(9=>"a",8=>"c",5=>"d");

$keys = array_keys($a);
sort($keys);
$result = array_combine($keys, array_values($a));

// 结果：array(5=>"a",8=>"c",9=>"d");
?>

上

下

cmarshall at gmx dot de ¶

13 年前

我阅读了关于 sort() 和德语变音字符的各种问题，我很快就头晕目眩 - sort() 中有错误还是没有，使用区域设置解决还是没有，等等......（我是一个新手）。

对我来说，显而易见的解决方案既快捷又肮脏：将变音字符（在我的情况下以 HTML 代码的形式出现）转换为它们的正常等价物（'ä' = 'ae'，'ö' = 'oe'，'ü' = 'ue'，'ß' = 'ss' 等），对数组进行排序，然后转换回来。但是，在某些情况下，'Mueller' 确实是 'Mueller'，不需要之后转换为 'Müller'。因此，例如，我用正常等价物加上一个字符串中未使用的字符（例如 '_'）来替换变音字符本身，这样只有在某些组合下才能转换回变音字符。

当然，除了 '_' 之外，任何其他字符都可以用作附加字符（影响排序结果）。我知道我的解决方案粗糙，可能会导致其他排序问题，但它足以满足我的目的。

本示例中的数组 '$dat' 填充了德国城镇名称（实际上我使用的是多维数组 ('$dat[][]')，但我将其简化为这个代码，因为它更容易理解）

<?php
// 开始预排序（变音符 -> 普通字母）
$max = count($dat);
for($totcnt = 0; $totcnt < $max; $totcnt++){
 $dat[$totcnt]=str_replace('&szlig;','ss_',$dat[$totcnt]);
 $dat[$totcnt]=str_replace('&Auml;','Ae_',$dat[$totcnt]);
 $dat[$totcnt]=str_replace('&auml;','ae_',$dat[$totcnt]);
 $dat[$totcnt]=str_replace('&Ouml;','Oe_',$dat[$totcnt]);
 $dat[$totcnt]=str_replace('&ouml;','oe_',$dat[$totcnt]);
 $dat[$totcnt]=str_replace('&Uuml;','Ue_',$dat[$totcnt]);
 $dat[$totcnt]=str_replace('&uuml;','ue_',$dat[$totcnt]);
}
// 结束预排序（变音符 -> 普通字母）

// 开始排序 //
function compare_towns($a, $b)
{
return strnatcmp($a, $b);
}
usort($dat, 'compare_towns');
// 结束排序 //

// 开始后排序（普通字母 -> 变音符）
for($totcnt = 0; $totcnt < $max; $totcnt++){
 $dat[$totcnt]=str_replace('ss_','&szlig;',$dat[$totcnt]);
 $dat[$totcnt]=str_replace('Ae_','&Auml;',$dat[$totcnt]);
 $dat[$totcnt]=str_replace('ae_','&auml;',$dat[$totcnt]);
 $dat[$totcnt]=str_replace('Oe_','&Ouml;',$dat[$totcnt]);
 $dat[$totcnt]=str_replace('oe_','&ouml;',$dat[$totcnt]);
 $dat[$totcnt]=str_replace('Ue_','&Uuml;',$dat[$totcnt]);
 $dat[$totcnt]=str_replace('ue_','&uuml;',$dat[$totcnt]);
}
// 结束后排序（普通字母 -> 变音符）
?>

上

下

alishahnovin at hotmail dot com ¶

17 年前

我有一个多维数组，需要按其中一个键进行排序。这是我的解决方案...

<?php
function msort($array, $id="id") {
 $temp_array = array();
 while(count($array)>0) {
 $lowest_id = 0;
 $index=0;
 foreach ($array as $item) {
 if ($item[$id]<$array[$lowest_id][$id]) {
 $lowest_id = $index;
 }
 $index++;
 }
 $temp_array[] = $array[$lowest_id];
 $array = array_merge(array_slice($array, 0,$lowest_id), array_slice($array, $lowest_id+1));
 }
 return $temp_array;
 }
?>

示例

<?php

// 糟糕，这没有按 id 排序！！
$data[] = array("item"=>"item 4", "id"=>4);
$data[] = array("item"=>"item 1", "id"=>1);
$data[] = array("item"=>"item 3", "id"=>3);
$data[] = array("item"=>"item 2", "id"=>2);

var_dump( msort($data) ); // 只需对它进行 msort 排序！

/* 输出 

array
 0 => 
 array
 'item' => 'item 1' (length=6)
 'id' => 1
 1 => 
 array
 'item' => 'item 2' (length=6)
 'id' => 2
 2 => 
 array
 'item' => 'item 3' (length=6)
 'id' => 3
 3 => 
 array
 'item' => 'item 4' (length=6)
 'id' => 4

*/

?>

上

下

alex [at] vkpb [dot] com ¶

17 年前

使用插入法对数组进行排序。

<?

  
function sortByField($multArray,$sortField,$desc=true){
$tmpKey='';
$ResArray=array();

$maIndex=array_keys($multArray);
$maSize=count($multArray)-1;

for($i=0; $i < $maSize ; $i++) {

$minElement=$i;
$tempMin=$multArray[$maIndex[$i]][$sortField];
$tmpKey=$maIndex[$i];

for($j=$i+1; $j <= $maSize; $j++)
if($multArray[$maIndex[$j]][$sortField] < $tempMin ) {
$minElement=$j;
$tmpKey=$maIndex[$j];
$tempMin=$multArray[$maIndex[$j]][$sortField];

                  }
$maIndex[$minElement]=$maIndex[$i];
$maIndex[$i]=$tmpKey;
            }

if($desc)
for($j=0;$j<=$maSize;$j++)
$ResArray[$maIndex[$j]]=$multArray[$maIndex[$j]];
else
for($j=$maSize;$j>=0;$j--)
$ResArray[$maIndex[$j]]=$multArray[$maIndex[$j]];

return $ResArray;
       }

// 创建数组
$array['aaa']=array("name"=>"vasia","order"=>1);
$array['bbb']=array("name"=>"petia","order"=>2);
$array['ccc']=array("name"=>"kolia","order"=>3);
$array['ddd']=array("name"=>"zenia","order"=>4);

// 设置排序
$SortOrder=0; // 默认降序，1- 升序

var_dump(sortByField($array,'order',$SortOrder));

array
'ddd' =>
array
'name' => 'zenia' (length=5)
'order' => 4
'aaa' =>
array
'name' => 'vasia' (length=5)
'order' => 1
'bbb' =>
array
'name' => 'petia' (length=5)
'order' => 2
'ccc' =>
array
'name' => 'kolia' (length=5)
'order' => 3

?>

上

下

g8z at yahoo dot com ¶

18 年前

<?php
/**
此排序函数允许您对关联数组进行排序，同时“粘贴”某些字段。

$sticky_fields 是一个包含不应重新排序的字段的数组。 这是在具有某些字段中通用数据的连续记录组内实现子排序的一种方法。

来自 $5 脚本存档：http://www.tufat.com
**/

define( 'ASC_AZ', 1000 );
define( 'DESC_AZ', 1001 );
define( 'ASC_NUM', 1002 );
define( 'DESC_NUM', 1003 );

function stickysort( $arr, $field, $sort_type, $sticky_fields = array() ) {
 $i = 0;
 foreach ($arr as $value) {
 $is_contiguous = true;
 if(!empty($grouped_arr)) {
 $last_value = end($grouped_arr[$i]);

 if(!($sticky_fields == array())) {
 foreach ($sticky_fields as $sticky_field) {
 if ($value[$sticky_field] <> $last_value[$sticky_field]) {
 $is_contiguous = false;
 break;
 }
 }
 }
 }
 if ($is_contiguous)
 $grouped_arr[$i][] = $value;
 else
 $grouped_arr[++$i][] = $value;
 }
 $code = '';
 switch($sort_type) {
 case ASC_AZ:
 $code .= 'return strcasecmp($a["'.$field.'"], $b["'.$field.'"]);';
 break;
 case DESC_AZ:
 $code .= 'return (-1*strcasecmp($a["'.$field.'"], $b["'.$field.'"]));';
 break;
 case ASC_NUM:
 $code .= 'return ($a["'.$field.'"] - $b["'.$field.'"]);';
 break;
 case DESC_NUM:
 $code .= 'return ($b["'.$field.'"] - $a["'.$field.'"]);';
 break;
 }

 $compare = create_function('$a, $b', $code);

 foreach($grouped_arr as $grouped_arr_key=>$grouped_arr_value)
 usort ( $grouped_arr[$grouped_arr_key], $compare );

 $arr = array();
 foreach($grouped_arr as $grouped_arr_key=>$grouped_arr_value)
 foreach($grouped_arr[$grouped_arr_key] as $grouped_arr_arr_key=>$grouped_arr_arr_value)
 $arr[] = $grouped_arr[$grouped_arr_key][$grouped_arr_arr_key];

 return $arr;
}
?>

上

下

Emiliyan at ServicesBG dot Com ¶

18 年前

#这是一个用于对数组进行排序的函数...
function sort_by($array, $keyname = null, $sortby) {
$myarray = $inarray = array();
# 首先将键值存储在单独的数组中
foreach ($array as $i => $befree) {
$myarray[$i] = $array[$i][$keyname];
    }
# 根据以下内容对新数组进行排序
switch ($sortby) {
case 'asc'
# 对数组进行排序并保持索引关联...
asort($myarray);
break;
case 'arsort'
# 以反序对数组进行排序并保持索引关联
arsort($myarray);
break;
case 'natcasesor'
# 使用不区分大小写的“自然顺序”算法对数组进行排序
natcasesort($myarray);
break;
    }
# 重建旧数组
foreach ( $myarray as $key=> $befree) {
$inarray[$key] = $array[$key];
    }
return $inarray;
} 
sort_by(); 示例...
$info = sort_by($myarray, 'name', $use = 'asc');
print_r($info);

上

下

nm at thenoodleman dot com ¶

18 年前

更快、更有效的函数

array_sort (array, ['asc'/'desc'])

第二个参数指定是升序还是降序排列。 默认为升序。

function array_sort($array, $type='asc'){
$result=array();
foreach($array as $var => $val){
$set=false;
foreach($result as $var2 => $val2){
if($set==false){
if($val>$val2 && $type=='desc' || $val<$val2 && $type=='asc'){
$temp=array();
foreach($result as $var3 => $val3){
if($var3==$var2) $set=true;
if($set){
$temp[$var3]=$val3;
unset($result[$var3]);
                        }
                    }
$result[$var]=$val;
foreach($temp as $var3 => $val3){
$result[$var3]=$val3;
                    }
                }
            }
        }
if(!$set){
$result[$var]=$val;
        }
    }
return $result;
}

适用于对整数或字符串进行排序，无需指定哪个。

示例

$array=array('a' => 50, 'b' => 25, 'c' => 75);
print_r(array_sort($array));

返回值
数组
(
[b] => 25
[a] => 50
[c] => 75
)

上

下

james at miicro dot net ¶

19 年前

了解一点很重要，如果您在多维数组上使用此函数，php 将对第一个键进行排序，然后对第二个键进行排序，依此类推。 这类似于使用 SQL 按 field1、field2 等进行排序。

所以

Array (
[0] => Array ( [category] => work [name] => Smith )
[1] => Array ( [category] => play [name] => Johnson )
[2] => Array ( [category] => work [name] => Berger )
)

将变为

Array (
[0] => Array ( [category] => play [name] => Johnson )
[1] => Array ( [category] => work [name] => Berger )
[2] => Array ( [category] => work [name] => Smith )
)

希望对某些人有所帮助。

上

下

timc at hlyw dot com ¶

19 年前

我喜欢上面的 multi_sort 函数。 但是，它们不适用于哈希数组。 我添加了一个 keys 变量来跟踪数组排序时的键值。 欢迎反馈。

<?php
function array_qsort (&$array, $column=0, $order=SORT_ASC, $first=0, $last= -2) 
{ 
 // $array - 要排序的数组 
 // $column - 排序的索引（列） 
 // 如果使用关联数组，可以是字符串 
 // $order - SORT_ASC（默认）表示升序，SORT_DESC 表示降序 
 // $first - 部分数组排序的起始索引（行） 
 // $last - 部分数组排序的结束索引（行） 
 // $keys - 用于哈希数组排序的键值数组 
 
 $keys = array_keys($array);
 if($last == -2) $last = count($array) - 1; 
 if($last > $first) { 
 $alpha = $first; 
 $omega = $last;
 $key_alpha = $keys[$alpha]; 
 $key_omega = $keys[$omega];
 $guess = $array[$key_alpha][$column]; 
 while($omega >= $alpha) { 
 if($order == SORT_ASC) { 
 while($array[$key_alpha][$column] < $guess) {$alpha++; $key_alpha = $keys[$alpha]; }
 while($array[$key_omega][$column] > $guess) {$omega--; $key_omega = $keys[$omega]; }
 } else { 
 while($array[$key_alpha][$column] > $guess) {$alpha++; $key_alpha = $keys[$alpha]; }
 while($array[$key_omega][$column] < $guess) {$omega--; $key_omega = $keys[$omega]; }
 } 
 if($alpha > $omega) break; 
 $temporary = $array[$key_alpha]; 
 $array[$key_alpha] = $array[$key_omega]; $alpha++;
 $key_alpha = $keys[$alpha];
 $array[$key_omega] = $temporary; $omega--;
 $key_omega = $keys[$omega];
 } 
 array_qsort ($array, $column, $order, $first, $omega); 
 array_qsort ($array, $column, $order, $alpha, $last); 
 } 
} 
?>

上

下

arjan321 at hotmail dot com ¶

21 年前

如果你想进行不区分大小写的排序，可以使用 natcasesort() 函数。

上

下

-1

alex dot hristov dot 88 at gmail dot com ¶

13 年前

正如一些人之前提到的，对多维数组进行排序可能有点棘手。我花了不少时间才搞定它，但它确实像魅力一样工作。

<?php
// $order 必须是 asc 或 desc
 function sortmulti ($array, $index, $order, $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) {
 if ($order=='asc')
 asort($temp);
 else 
 arsort($temp);
 }
 else 
 {
 if ($case_sensitive===true)
 natsort($temp);
 else
 natcasesort($temp);
 if($order!='asc') 
 $temp=array_reverse($temp,TRUE);
 }
 foreach(array_keys($temp) as $key) 
 if (is_numeric($key))
 $sorted[]=$array[$key];
 else 
 $sorted[$key]=$array[$key];
 return $sorted;
 }
 return $sorted;
}
?>

上

下

-1

petr dot biza at gmail dot com ¶

14 年前

这是一个根据子数组的键进行排序的函数，同时保持顶层键。


<?php 
function sksort(&$array, $subkey="id", $sort_descending=false, $keep_keys_in_sub = false) { 
 $temp_array = $array; 
 
 foreach ($temp_array as $key => &$value) { 
 
 $sort = array(); 
 foreach ($value as $index => $val) { 
 $sort[$index] = $val[$subkey]; 
 } 
 
 asort($sort); 
 
 $keys = array_keys($sort); 
 $newValue = array(); 
 foreach ($keys as $index) { 
 if($keep_keys_in_sub) 
 $newValue[$index] = $value[$index]; 
 else 
 $newValue[] = $value[$index]; 
 } 
 
 if($sort_descending) 
 $value = array_reverse($newValue, $keep_keys_in_sub); 
 else 
 $value = $newValue; 
 } 
 
 $array = $temp_array; 
 } 
?>

上

下

-1

raul at jimi dot com dot mx ¶

18 年前

我有一个这样的数组
$arr=array (1,4,3,6,5);

它返回如下结果
$arr[0]=1
$arr[1]=4
$arr[2]=3
$arr[3]=6
$arr[4]=5

但是，假设我删除了 [2]，也就是数字 3，我会得到

$arr[0]=1
$arr[1]=4
$arr[3]=6
$arr[4]=5

我想要重新索引，而不进行排序，因为我不想丢失数字的顺序（就像堆栈中的弹出操作，但在列表中间），我执行以下操作

$arr=array_chunk($arr,count($arr));
$arr=$arr[0];

结果是

$arr[0]=1
$arr[1]=4
$arr[2]=6
$arr[3]=5

这主要适用于树形排序，当你只有节点的 id 和父节点的值时，并且你想要有 N 个级别。

上

下

-1

poulou_0 at hotmail dot com ¶

13 年前

如果你对大小写排序不感兴趣

<?php
//where
$sortable_array[$k] = $v2; 
//put
$sortable_array[$k] = strtolower($v2);

//and where
$sortable_array[$k] = $v;
//put
$sortable_array[$k] = strtolower($v);
?>

上

下

-1

g8z at yahoo dot com ¶

18 年前

<?php
/**
此排序函数允许您对关联数组进行排序，同时“粘贴”一些字段。

$sticky_fields 是一个包含不应重新排序的字段的数组。这是一种在具有某些字段中的公共数据的连续记录组内实现子排序的方法。

例如：

$a = array();

$a []= array(
 'name' => 'Sam',
 'age' => 23,
 'hire_date' => '2004-01-01'
);
$a []= array(
 'name' => 'Sam',
 'age' => 44,
 'hire_date' => '2003-03-23'
);
$a []= array(
 'name' => 'Jenny',
 'age' => 20,
 'hire_date' => '2000-12-31'
);
$a []= array(
 'name' => 'Samantha',
 'age' => 50,
 'hire_date' => '2000-12-14'
);

$sticky_fields = array( 'name' );
print_r( stickysort( $a, 'age', DESC_NUM, $sticky_fields ) );

输出：

Array
(
 [0] => Array
 (
 [name] => Sam
 [age] => 44
 [hire_date] => 2003-03-23
 )
 [1] => Array
 (
 [name] => Sam
 [age] => 23
 [hire_date] => 2004-01-01
 )
 [2] => Array
 (
 [name] => Jenny
 [age] => 20
 [hire_date] => 2000-12-31
 )
 [3] => Array
 (
 [name] => Samantha
 [age] => 50
 [hire_date] => 2000-12-14
 )
)

这就是正确输出的原因 - "name" 字段是粘性的，因此它不能改变其排序顺序。因此，"age" 字段仅在 "name" 相同的记录内作为子排序进行排序。因此，"Sam" 记录被反转，因为 44 > 23，但 Samantha 仍然在底部，即使她的年龄是 50。这是一种在特定字段的相同数据记录内实现“子排序”和“子子排序”（等等）的方法。

由 $5 脚本存档提供： http://www.tufat.com
**/

define( 'ASC_AZ', 1000 );
define( 'DESC_AZ', 1001 );
define( 'ASC_NUM', 1002 );
define( 'DESC_NUM', 1003 );

function stickysort( $arr, $field, $sort_type, $sticky_fields = array() ) {
 $i = 0;
 foreach ($arr as $value) {
 $is_contiguous = true;
 if(!empty($grouped_arr)) {
 $last_value = end($grouped_arr[$i]);

 if(!($sticky_fields == array())) {
 foreach ($sticky_fields as $sticky_field) {
 if ($value[$sticky_field] <> $last_value[$sticky_field]) {
 $is_contiguous = false;
 break;
 }
 }
 }
 }
 if ($is_contiguous)
 $grouped_arr[$i][] = $value;
 else
 $grouped_arr[++$i][] = $value;
 }
 $code = '';
 switch($sort_type) {
 case ASC_AZ:
 $code .= 'return strcasecmp($a["'.$field.'"], $b["'.$field.'"]);';
 break;
 case DESC_AZ:
 $code .= 'return (-1*strcasecmp($a["'.$field.'"], $b["'.$field.'"]));';
 break;
 case ASC_NUM:
 $code .= 'return ($a["'.$field.'"] - $b["'.$field.'"]);';
 break;
 case DESC_NUM:
 $code .= 'return ($b["'.$field.'"] - $a["'.$field.'"]);';
 break;
 }

 $compare = create_function('$a, $b', $code);

 foreach($grouped_arr as $grouped_arr_key=>$grouped_arr_value)
 usort ( $grouped_arr[$grouped_arr_key], $compare );

 $arr = array();
 foreach($grouped_arr as $grouped_arr_key=>$grouped_arr_value)
 foreach($grouped_arr[$grouped_arr_key] as $grouped_arr_arr_key=>$grouped_arr_arr_value)
 $arr[] = $grouped_arr[$grouped_arr_key][$grouped_arr_arr_key];

 return $arr;
}
?>

上

下

-2

Brecht Cloetens ¶

14 年前

<?php
 
/**
 * 函数：array_columns
 * 作者：Brecht Cloetens
 * 参数：$a = array() // 原始数组
 * $c = int() // 列数
 */
function array_columns(&$a, $c=2)
{
 $m = ceil(count($a)/$c);
 $j = 0;
 for($i=0; $i<$m; $i++) {
 for($k=0; $k<$c; $k++) {
 $key = $i+($m*$k);
 settype($key,'integer');
 if(array_key_exists($key,$a)) {
 $b[$j] = $a[$key];
 $j++;
 }
 }
 }
 $a = $b;
}

$arr = range('a','z');
array_columns($arr,4);
print_r($arr);

?>

示例
array(1,2,3,4,5) 将被转换为 array(1,4,2,5,3);

如果你想将一个数组显示到指定的列数，这很简单。

<table>
<tr>
<td>$arr[0] => 1</td>
<td>$arr[1] => 4</td>
</tr>
<tr>
<td>$arr[2] => 2</td>
<td>$arr[3] => 5</td>
</tr>
<tr>
<td>$arr[4] => 3</td>
<td></td>
</tr>
</table>

上

下

-3

sinan at sinaneldem dot com ¶

17 年前

这里有一小段脚本，它将合并数组，删除重复项并按字母顺序排序

<?php

$array1 = array('apple', 'banana','pear');
$array2 = array('grape', 'pear','orange');

function array_unique_merge_sort($array1, $array2){
$array = array_unique(array_merge($array1, $array2));
sort($array);
foreach ($array as $key => $value) {
 $new[$key] = $value;
}
return $new;
}

print_r (array_unique_merge_sort($array1, $array2));

?>

这将输出

Array ( [0] => apple [1] => banana [2] => grape [3] => orange [4] => pear )

上

下

-3

anaz114119 at gmail dot com ¶

13 年前

按列对文本文件进行排序
例如 name||date||time||comments
如果你想按日期排序
$column = 2
<?php 
function array_sort($array,$column){ 
 $column = $column-1; 
 foreach($array as $line){ 
 $bits = explode("||",$line); 
 $bits ="$bits[$column]**$line"; 
 $array1[]=$bits; 
} 
 asort($array1); 
 foreach($array1 as $line){ 
 $bit = explode("**",$line); 
 $bit ="$bit[1]"; 
 $array2[]=$bit; 
} 
 return$array2; 
} 
?>

上

下

-3

anthony at ectrolinux dot com ¶

19 年前

简单补充一下前一位用户的留言，PHP 直接使用的升序排序对应于 ISO-8859-1 (ASCII)。因此，字符 \48（数字 0）将排在字符 \82（R）之前，字符 \82（R）将排在字符 \110（n）之前，依此类推。

上

下

-2

www at designdetector dot com ¶

15 年前

要按字母顺序对包含多个文本字段的数组进行排序，您需要在排序数组之前将文本转换为小写。否则，PHP 会将缩写放在单词之前。您可以在我的示例代码中看到这一点。只需将原始文本字段存储在数组行的末尾，并在稍后从那里调用它。您可以安全地忽略添加到数组行开头的 lowercase 版本。

<?php
echo '<pre>ORIGINAL DATA:
<br />';

$data = array(
'Saturn|7|8|9|0||',
'Hello|0|1|2|3||',
'SFX|5|3|2|4||',
'HP|9|0|5|6||'
);

print_r($data);

sort($data);
reset($data);

echo '<br />RAW SORT:
<br />';

print_r($data);

for ($c = 0; $c < count($data); $c++) {
 list ($letter,$g1,$g2,$g3,$g4,$end) = explode ('|', $data[$c]);
 $lowercase = strtolower($letter);
 $data2[$c] = array($lowercase,$g1,$g2,$g3,$g4,$letter);
}

sort($data2);
reset($data2);

echo '<br />LOWERCASE SORT:
<br />';

print_r($data2);

echo '</pre>';
?>

上

下

-6

jesper at snt dot utwente dot nl ¶

18 年前

如果您对对象数组进行排序，则将使用对象中的第一个变量进行排序

<?php
class foo
{
 var $value; //第一个变量：用于排序
 var $id;

 function foo($i, $v)
 {
 $this->id = $i;
 $this->value = $v;
 }

}

for ($i = 0; $i < 10; $i++)
{
 $bar[] = new foo($i,rand(1,10));
}

// 这将按 value 排序
sort($bar);
print_r($bar);
?>

将上面的代码片段与以下代码进行比较

<?php
class foo
{
 var $id; //第一个变量：用于排序
 var $value;

 function foo($i, $v)
 {
 $this->id = $i;
 $this->value = $v;
 }

}

for ($i = 0; $i = 10; $i++)
{
 $bar[] = new foo($i,rand(1,10));
}

// 这将按 id 排序
sort($bar);
print_r($bar);
?>

如您所见，变量声明的位置很重要！
如果您想按两个或多个变量或变量组合进行排序，请使用 ksort()

＋添加注释