sort

(PHP 3, PHP 4, PHP 5)

sort -- 对数组排序

说明

bool sort ( array &array [, int sort_flags] )

本函数对数组进行排序。当本函数结束时数组单元将被从最低到最高重新安排。

注: 本函数为 array 中的单元赋予新的键名。这将删除原有的键名而不仅是重新排序。

如果成功则返回 TRUE,失败则返回 FALSE

例子 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

fruits 被按照字母顺序排序。

可选的第二个参数 sort_flags 可以用以下值改变排序的行为:

排序类型标记:

  • SORT_REGULAR - 正常比较单元(不改变类型)

  • SORT_NUMERIC - 单元被作为数字来比较

  • SORT_STRING - 单元被作为字符串来比较

  • SORT_LOCALE_STRING - 根据当前的 locale 设置来把单元当作字符串比较。PHP 4.4.0 和 5.0.2 新加

注: 第二个参数是 PHP 4 新加的。

警告

在对含有混合类型值的数组排序时要小心,因为 sort() 可能会产生不可预知的结果。

参见 arsort()asort()ksort()krsort()natsort()natcasesort()rsort()usort()array_multisort()uksort()


add a note add a note User Contributed Notes
memzap at gmail dot com
22-Jul-2006 01:31
Here is how you would open a file, and put each line into an array. This sorts by the first field $title field.  The next thing I would like to figure out is how to do this same sort but with the ability to skip the first word of the title. Like if the title has an "a" or "the" it would skip that portion of the sort.

$currentfile = "file.txt";
$fp = fopen( $currentfile, "r" ) or die("Couldn't open $currentfile");
while ( ! feof( $fp ) ) {
   $line[] = fgets( $fp, 1024 );

   foreach ( $line as $newarray ) {
}
   $newline[] = trim($newarray);
   sort($newline);
   list($title1, $titleurl1, $rating1) = split ('\|',
$newline[0]);
   list($title2, $titleurl2, $rating2) = split ('\|',
$newline[1]);
   list($title3, $titleurl3, $rating3) = split ('\|',
$newline[2]);
   list($title4, $titleurl4, $rating4) = split ('\|',
$newline[3]);
g8z at yahoo dot com
15-Jul-2006 07:28
<?php
/**
This sort function allows you to sort an associative array while "sticking" some fields.

$sticky_fields = an array of fields that should not be re-sorted. This is a method of achieving sub-sorts within contiguous groups of records that have common data in some fields.

For example:

$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 ) );

OUTPUT:

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
       )
)

Here's why this is the correct output - the "name" field is sticky, so it cannot change its sort order. Thus, the "age" field is only sorted as a sub-sort within records where "name" is identical. Thus, the "Sam" records are reversed, because 44 > 23, but Samantha remains at the bottom, even though her age is 50. This is a way of achieving "sub-sorts" and "sub-sub-sorts" (and so on) within records of identical data for specific fields.

Courtesy of the $5 Script Archive: 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;
}
?>
g8z at yahoo dot com
10-Jul-2006 11:58
<?php
/**
This sort function allows you to sort an associative array while "sticking" some fields.

$sticky_fields = an array of fields that should not be re-sorted. This is a method of achieving sub-sorts within contiguous groups of records that have common data in some fields.

Courtesy of the $5 Script Archive: 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;
}
?>
g8z at yahoo dot com
10-Jul-2006 11:57
<?php
/**
This sort function allows you to sort an associative array while "sticking" some fields.

$sticky_fields = an array of fields that should not be re-sorted. This is a method of achieving sub-sorts within contiguous groups of records that have common data in some fields.

Courtesy of the $5 Script Archive: 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
29-Mar-2006 11:41
#This is a function that will sort an array...
function sort_by($array,  $keyname = null, $sortby) {
   $myarray = $inarray = array();   
   # First store the keyvalues in a seperate array
   foreach ($array as $i => $befree) {
       $myarray[$i] = $array[$i][$keyname];
   }
   # Sort the new array by
   switch ($sortby) {
   case 'asc':
   # Sort an array and maintain index association...
   asort($myarray);
   break;
   case 'arsort':
   # Sort an array in reverse order and maintain index association
   arsort($myarray);
   break;
   case 'natcasesor':
   # Sort an array using a case insensitive "natural order" algorithm
   natcasesort($myarray);
   break;
   }
   # Rebuild the old array
   foreach ( $myarray as $key=> $befree) {
       $inarray[$key] = $array[$key];
   }
   return $inarray;
}
sort_by(); example...
$info = sort_by($myarray, 'name', $use = 'asc');   
print_r($info);
ludvig dot ericson at gmail dot com
26-Feb-2006 01:48
A tip for those who like "raul at jimi dot com dot mx" need to preserve keys after changing stuff in the middle of an array:
array_values.

Example:
<?php
$array
= array(1, 2, 5, 9, 3);
unset(
$array[3]); // Remove index 3, which is 9.
$array = array_values($array);
?>

Hint: array_values can be fine for removing keys and reindex them by number instead, too (applies to functions like posix_pwgetuid which returns an associative array, unlike C and others, call array_values on it, and it'll be the same format IIRC.)
jesper at snt dot utwente dot nl
25-Feb-2006 05:26
If you sort an array of objects, the first variable in the object will be used for sorting:

<?php
class foo
{
  var
$value; //First variable: Used for sorting
 
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));
}

// This will sort on value
sort($bar);
print_r($bar);
?>

Compare the piece of code above with the following:

<?php
class foo
{
  var
$id; //First variable: Used for sorting
 
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));
}

// This will sort on id
sort($bar);
print_r($bar);
?>

As you can see the location of declaration of the variables matter!
If you want to sort on both or on a combination of variables, use ksort()
jerome a-t+ yamafoto d*o*t com
23-Feb-2006 01:39
when sorting an array, beware of variable type from elements you put in this array

Example:

$a = 2; // $a is an integer
$b = 'item';
$arr = array($a, $b);
sort($arr);

print_r($arr);

this will output:
$arr[0] = 'item';
$arr[1] = 2;

$a = '2'; // $a is a string
$b = 'item';
$arr = array($a, $b);
sort($arr);

print_r($arr);

this will output:
$arr[0] = '2';
$arr[1] = 'item'

to avoid this problem use:

sort($arr, SORT_STRING)
nm at thenoodleman dot com
31-Jan-2006 09:18
Faster, more effective function:

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

Second parameter specifies whether to order ascending or descending. Default is ascending.

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;
}

Works for ordering by integers or strings, no need to specify which.

Example:

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

Returns:
Array
(
[b] => 25
[a] => 50
[c] => 75
)
james at miicro dot net
25-Jan-2006 02:26
Further to john dot dutcher at highmark dot com's comments - padding the name could cause a problem if you get abnormally long names, it might be better to rebuild the array thus:

Array (
[0] => Array ( [sortname_01] => Dutcher [sortname_02] => F [sortname_03] => John [name] => Dutcher, John F )
[1] => Array ( [sortname_01] => Dutch [sortname_02] => A [sortname_03] => Roger [name] => Dutch, Roger A )
[2] => Array ( [sortname_01] => Dut [sortname_02] => H [sortname_03] => Maurice [name] => Dut, Maurice H )
[3] => Array ( [sortname_01] => Dut [sortname_02] => S [sortname_03] => Mildred [name] => Dut, Mildred S )
)

which should give:

Array (
[0] => Array ( [sortname_01] => Dut [sortname_02] => H [sortname_03] => Maurice [name] => Dut, Maurice H )
[1] => Array ( [sortname_01] => Dut [sortname_02] => S [sortname_03] => Mildred [name] => Dut, Mildred S )
[2] => Array ( [sortname_01] => Dutch [sortname_02] => A [sortname_03] => Roger [name] => Dutch, Roger A )
[3] => Array ( [sortname_01] => Dutcher [sortname_02] => F [sortname_03] => John [name] => Dutcher, John F )
)
john dot dutcher at highmark dot com
11-Jan-2006 08:58
Regarding the array sorting of names by 'whatever' ....

That post addresses a nearly identical issue with sorting that I also have.

I just wanted to inquire though.........wouldn't the building of the 'sortname'  value require that the last name and first name be padded to their full size as they are placed into the
'sortname' field in order to get proper sorting/alignment ?

Otherwise would one have .......

   dutcherjohnf                  (Dutcher, John F)
   dutchrogera                  (Dutch, Roger A)
   dutmauriceh                  (Dut, Maurice H)

Instead of:

   dut          maurice        h   
   dutch        roger          a
   dutcher      john            f

John D.
raul at jimi dot com dot mx
02-Dec-2005 01:50
I had an array like this:
$arr=array (1,4,3,6,5);

which returns this:
$arr[0]=1
$arr[1]=4
$arr[2]=3
$arr[3]=6
$arr[4]=5

But lets say i remove [2] which is number 3, i get:

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

And i want to reindex without doing a sort because i dont want to lose the order of the numbers (like a pop in a stack but in the middle of the list), i do this:

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

the result is:

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

This can be applied mostly for tree sorting, when you only have the id and the parent values of the node, and you want to have N levels.
phillip dot metzger at gmail dot com
10-Nov-2005 01:36
For a case insensitive sort use this array_multisort().

<?php
$array_var
= Array("Cheery", "zap", "Banana", "apple", "Zing");

array_multisort((strtolower($array_var)), SORT_ASC, SORT_STRING, $array_var);
?>

Result order:
apple
Banana
Cheery
zap
Zing
james at miicro dot net
19-Jul-2005 05:49
It's useful to know that if you're using this function on a multidimensional array, php will sort the first key, then the second and so on. This is similar to being able to use SQL to order by field1, field2 etc.

So:

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

will become:

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

Hope it helps someone.
whatever at toposphere dot com
03-Jul-2005 04:12
The usort solution below still has problems when sorting strings of different lengths, just like the other flavors of sort that I've tried.

Here's a solution that I came up with -- it's kinda ugly, and it might not be practical for large arrays, but it's works great for me.

I'm getting some people's names out of mySQL and placing them in an array like this: "$lastname, $firstname $middlename". Because some people don't have middle names, "sort" screws up the alphabetization. So what I've done is this:

$index = 0;
while ($rows = mysql_fetch_array($sqlResult)) {
   extract($rows);
   $my_array[$index]['sortname'] = strtolower(preg_replace("/[^a-zA-Z]/", "", "$lastname$firstname$middlename"));
   $my_array[$index]['name'] = trim("$lastname, $firstname $middlename");
   $index++;
}
sort($my_array); // now in perfect alpha order

My "hack" is in the fourth line -- I take the entire name, last name first, and use preg_replace() to take out all non-letter characters, and then used strtolower() to make it all lowercase to ensure all letters would be treated equally by PHP. This goes into the ['sortname'] key within the array.

(The ['sortname'] value has to come before ['name'], or else the array will be sorted by ['name'] instead.)

This gives me:

Array
(
   [0] => Array ( [sortname] => shmojoe [name] => Shmo, Joe )
   [1] => Array ( [sortname] => shmojoem [name] => Shmo, Joe M )
)
... and so on

So the array gets sorted by ['sortname'], which never needs to be displayed, and the associated ['name'] can be displayed in perfect alphabetical order, whether there is one name, two names or three. And because ['sortname'] is letters only, it works great for hyphenated last names or ones with apostrophes, like Smith-Jones or O'Donnell.

I feel that the dual preg_replace() and strtolower() may not be the best theoretical solution, and I don't know how it would run on a really large array, but as I said, it's a great solution for my little site.
dwatson at planandgrow dot com
19-Mar-2005 09:55
Here is a recursive use of sort for multi-dim arrays:

<?php

/*Mulsort function recursively sorts a  multi-dimensional, numeric array in place,
regardless of how many dimensions it has.  The array can be ragged -- not a matrix. 
*/

function mulsort(&$a)
{
  
sort($a);
  
$c = count($a);
   for(
$i = 0; $i < $c; $i++)
       if (
is_array($a[$i]))
          
mulsort($a[$i]);
}

//The following array is just used to demo the mulsort function.
$array_demo = array ( array ( array (333,1,9,8,7,6,5), array (array(1, 'x', 22), 99, 88 ), -10 ),
       array ( array (
11, 12, 'a', 'b', 'c'), array (8, 1, 2,-5) ) );

echo
"Array before sorting:<br /><pre>";
var_dump($array_demo);
echo
"</pre></ br></ br>";

mulsort($array_demo);

echo
"Array after sorting:<br /><pre>";
var_dump($array_demo);
echo
"</pre>";

?>
timc at hlyw dot com
18-Feb-2005 08:04
I dig the multi_sort function(s) from above.  But, they don't work for hash arrays.  I added a keys variable to keep track of the key value as the array gets sorted.  Feed back welcome.

<?php
function array_qsort (&$array, $column=0, $order=SORT_ASC, $first=0, $last= -2)
{
 
// $array  - the array to be sorted
  // $column - index (column) on which to sort
  //          can be a string if using an associative array
  // $order  - SORT_ASC (default) for ascending or SORT_DESC for descending
  // $first  - start index (row) for partial array sort
  // $last  - stop  index (row) for partial array sort
  // $keys  - array of key values for hash array sort
 
 
$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);
  }
}
?>
anthony at ectrolinux dot com
09-Sep-2004 07:39
In a brief addition to the previous poster's message, the ascending sorting order used by PHP directly corresponds to ISO-8859-1 (ASCII). Therefore the character \48 (numeral 0) would be placed before the character \82 (R), which would be placed before the character \110 (n), and so forth.
teunkloosterman at hotmail dot com
30-Aug-2004 04:14
Just to show how it sorts:

<?php
$array
= Array("1", "2", "3", "4", "5", "6", "7", "8", "9", "0", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", " ", "!", "@", "#", "\\\$", "%", "^", "&", "*", "(", ")", "_", "-", "=", "+", "\\\\", "|", ",", "<", ".", ">", "?", "'", "\\\"", "`", "~");
sort($array);
echo
implode("", $array);
?>

returns:

 !"#$%&'()*+,-.0123456789<=>?
@ABCDEFGHIJKLMNOPQRSTUVWXYZ
\^_`abcdefghijklmnopqrstuvwxyz|~

note: the result begins with a space
Gerhard Conradi
10-Mar-2004 04:49
Hi @all,

to my previous author: thanks, thanks, thanks! Works great and saved me lot of time. I added an extension for ascending/descending order. Here are the changes:

// first i defined two constants for asc and desc
// you can skip that, but then you have to change the switch command at the end of the function
define("ORDER_ASC", "asc");
define("ORDER_DESC", "desc");

function mu_sort($array, $key_sort, $asc_desc) { // start function
      
// check input parameters
if (func_num_args()<2 || func_num_args()>3) die("Wrong number of parameters for the call of mu_sort()");
      
   $array = func_get_arg(0);
   $key_sort = func_get_arg(1);
   if (func_num_args()==3)
     $asc_desc = func_get_arg(2);
   else
     $asc_desc = ORDER_ASC;

   $key_sorta = explode(",", $key_sort);
   .... // from here it's exactly the same

   ... // until here
     } // end loop #2
   } // end loop #1

   // sort
   // if you don't want to use the constants defined at the top, change here to whatever you're using
   switch($asc_desc) {
     case ORDER_DESC:
         rsort($output); break;
     default:
         sort($output);
   }

   // return sorted array
   return $output;
} // end function

Now you can call the function like this:
mu_sort($array, $key_sort, ORDER_DESC);
or even:
mu_sort($array, $key_sort); // This will sort the array by default ascending

Have fun...
matias at arenasoftware dot com
24-Mar-2003 09:36
Lets say you have the following array:
$array1 = Array(third => "Some text 3", second => "Some text 2", first => "Some text 1", fourth => "Some text 4" );
and you want to sort it by first,second,third, fourth.
Very easy! Just create a second array:
$array2 = Array(first => "", second => "", third => "", fourth => "");
and do:
$result = array_merge($array2,$array1);

now $result = Array(first => "Some text 1",second => "Some text 2",third => "Some text 3",fourth => "Some text 4");

This is very usefull when you want to print data out of a database table for example, but you would like to give it a custom order.
arjan321 at hotmail dot com
01-Feb-2003 04:23
Ik you want to sort case insensitive, use the natcasesort()
shailu_agrawal at yahoo dot no_spam dot com
13-Nov-2002 10:05
if 2nd parameter is "SORT_REGULAR" it will compare characters by ASCII values.
For ex: if unsorted values are:  B , a , A
with SORT_REGULAR sorted result will be: A , B , a
and with SORT_STRING sorted result will be: a , A , B
whit at transpect dot com
26-Oct-2002 05:06
fmmarzoa's qsort_multiarray gets the last record with the removal of a "-1" from the 3rd line of the function definition. Here's a routine using it that takes a tab-delimited table with the column names in the first row, and displays it from an arbitrary column on the left to the last on the right with option to sort by any one column:

<?php                                                                                         
//tab-delimited ASCII file to sort - no more than one linefeed at end                         
$infile="members.txt";
//first column on left to display - count from 0
$firstcol="1";

function
qsort_multiarray($array, $num = 0, $order = "ASC", $left = 0, $right = -1) {
       if(
$right == -1) {
              
$right = count($array);
       }
      
$links = $left;
      
$rechts = $right;
      
$mitte = $array[($left + $right) / 2][$num];
       if(
$rechts > $links) {
               do {
                       if(
$order == "ASC") {
                               while(
$array[$links][$num]<$mitte) $links++;
                               while(
$array[$rechts][$num]>$mitte) $rechts--;
                       } else {
                               while(
$array[$links][$num]>$mitte) $links++;
                               while(
$array[$rechts][$num]<$mitte) $rechts--;
                       }
                       if(
$links <= $rechts) {
                              
$tmp = $array[$links];
                              
$array[$links++] = $array[$rechts];
                              
$array[$rechts--] = $tmp;
                       }
               } while(
$links <= $rechts);
               if (
$left < $rechts) $array = qsort_multiarray($array,$num,$order,$left, $rechts);
               if (
$links < $right) $array = qsort_multiarray($array,$num,$order,$links,$right);
       }
       return
$array;
}

$mem=file("$infile");
$line=explode("\t","$mem[0]");
$cnt=count($line);
echo
"<html><head><title>$infile</title></head><body>";
echo
"<table border=\"1\"><tr>";
for (
$i=$firstcol;$i<$cnt;$i++) {
       echo
"<td><a href=\"$PHP_SELF?col=$i\">$line[$i]</a></td>";
}
echo
"</tr>";
$cnt=count($mem);
for (
$i=$firstcol;$i<$cnt;$i++) {
      
$line=explode("\t","$mem[$i]");
      
$cnt2=count($line); 
       for (
$j=$firstcol;$j<$cnt2;$j++) {
              
$mem2[$i][$j]=$line[$j];
       }
}
if(!isset(
$col)) $col=$firstcol;
$mem2=qsort_multiarray($mem2,$col);
for (
$i=0;$i<$cnt;$i++) {
       echo
"<tr>";
       for (
$j=$firstcol;$j<$cnt2;$j++) {
              
$show=$mem2[$i][$j];
               echo
"<td>$show</td>";
       }
       echo
"</tr>";
}
echo
"</table></body></html>";
?>
15-Mar-2002 06:09
If you want to sort an array according to your locale do the following:
(de_DE as example)

setlocale("LC_ALL","de_DE");
usort($arraytobesorted, 'strcoll');

--ed: In PHP 4.4 and PHP 5.0 you can do:
setlocale("LC_ALL", "de_DE");
sort($arraytobesorted, SORT_LOCALE_STRNG);
RunMaster at gmx dot de
30-Aug-2001 01:11
Note that sort() is void, so an assignment like

$foo_array = sort( $foo_array );

wont work. In result you cannot combine sort() for use with other array-related functions just like array_unique() or array_values(). None of the following statements works:

sort( array_unique( $foo_array ) );
// returns empty string

$foo_array = array_unique( sort( $foo_array) );
// returns parameter failure

The only way to combine those functions is to apply sort() in a single line statement.

So please dont waste your time with hours of debugging like me before I found out, its void... ;-)
phpdotnetNO_SPAM at electronic-strategy dot com
06-Jul-2001 12:34
/*
Small function to Alphabetically sort Multidimensional arrays by index values of an n dimension array.

I have only tested this for sorting an array of up to 6 dimensions by a value within the second dimension. This code is very rough and works for my purposes, but has not been tested beyond my needs.

Although a little clunky and not a mathematical type algorithm, it get's the job done. It theoretically overcomes many of the problems I have seen with multidimensional arrays in that it is possible to specify within the function, not by reference :-(, which index you wish to sort by, no matter how many dimensions down.

call function by assigning it to a new / existing array:

$row_array = multidimsort($row_array);
*/

function multidimsort($array_in) {
     $multiarray = array();
   $array_out = array();
   $loopvalue = 0;
  
   /* -1 as traversal of array starts from 0, count() starts from 1 */
   $multicount = count($array_in) - 1;

   /* add the indexes you wish to sort array by to a new array in this case index is two levels down, but shouldn't make a difference if it goes further indexes down. (Not tested!) */
   for($i = 0; $i <= $multicount; $i++) {
       array_push($multiarray, $array_in[$i][2]);
       //array_push($multiarray, $array_in[$i][2][4]);
       //array_push($multiarray, $array_in[$i][1][3][7]);
   }
  
   /* alphabetically sort the new array (Ascending in this case) can chage sort to whatever type you like. Even apply user-defined sort. */
   asort($multiarray);
  
   /* reset internal pointer to beginning of array after above sort */
   reset($multiarray);
  
   /* traverse new array of index values and add the corresponding element of the input array to the correct position in the output array */
   while (list ($key, $val) = each ($multiarray)) {
      
       $array_out[$loopvalue] = $array_in[$key];
      
       $loopvalue++;
   }

   /* return the output array which is all nicely sorted by the index you wanted! */
   return $array_out;
}
Richard dot C dot Mitchell at Boeing dot com
24-Apr-2001 12:59
The usort function can be used to sort multi-dimension arrays, also.

To do a case-insensitive sort on the 7th column of a two-dimensional array:
usort($listing, create_function('$a,$b','return strcasecmp($a[7],$b[7]);'));

When using associative arrays:
usort($listing, create_function('$a,$b','return strcasecmp($a["name"],$b["name"]);'));

Case-sensitive, descending (just change '$a,$b' to '$b,$a'):
usort($listing, create_function('$b,$a','return strcmp($a["name"],$b["name"]);'));

A two-dimensional array of numbers (7th column, ascending):
usort($listing, create_function('$a,$b','return $a[7]==$b[7]?0:($a[7]<$b[7]?-1:1);'));
peek at mailandnews dot com
07-Apr-2001 07:06
I ran into the same problem with case insensitive sorting. Actually I think there should be a SORT_STRING_CASE flag but I tried the following:

usort($listing, 'strcasecmp');

This didn't work (why not?), but you can do a proper case insensitive sort like this:

usort($listing, create_function('$a,$b','return strcasecmp($a,$b);'));
ultrafunkula at mad dot scientist dot com
31-Mar-2000 02:08
What you really want is asort(). The neat thing about PHP arrays is that even though they have a traditional numerical index, they are not defined by it. What I mean by this is if you define an array $data[], then $data[2] does not necessarily exist between $data[1] and $data[3].
So if you asort() by the artist name and then use each() to recover the array elements in the order they exist(rather than an incremental loop which ties you to their arbitrary numerical key), you can sort your data by any dimension of your array. Try this out:
$data[0][1]='Title 2';
$data[0][2]='Title 1';
$data[0][0]='Title 3';
$data[1][1]='Barney';
$data[1][0]='Charlie';
$data[1][2]='Al';
$data[2][2]='Sing the song of Al';
$data[2][1]='Jam with Barney';
$data[2][0]='Charlie Rocks';

while (list($key) = each($data[1])) {
print $data[0][$key].",".$data[1][$key].",".$data[2][$key]."<p>";
}

asort($data[1]);

while (list($key) = each($data[1])) {
print $data[0][$key].",".$data[1][$key].",".$data[2][$key]."<p>";
}

The interesting part is that the first, UNSORTED array doesn't come out in numerical order, because it wasn't put in that way.  If you asort($data[2]) you'll sort by lyrics, and so on. Just make sure you remember to each() by the same dimension as you asort().
misillet at tin dot it
18-Mar-2000 02:58
Note that using sort() it seems to sort by ASCII code, because "AC" is before "Ab" in the result array