php--数组相关

               
               
               
               
               
               
               
               
               
               
               
               
               
               
               
               
               
                .array   array_change_key_case(array  input [, int case])
返回字符串键名全为小写或大写的数组
case  ： CASE_UPPER           键名全改为大写
               CASE_LOWER          键名全改为小写
$arr = array_change_key_case($array, CASE_UPPER);
.array   array_chunk(array  input,  int  size [, bool  preserve_keys])
将一个数组分割成多个数组，  其中每个数组的单元数目由size决定。
最后一个数组的单元数目可能会少几个， 得到的数组是一个多维数组中的单元， 其索引从零开始
$arr = array(1,2,3,4,5);
print_r(array_chunk($arr, 2));
print_r(array_chunk($arr,2, true));   //保留键名
Array
(
      [0] => Array(
                              [0] => 1
                              [1] => 2
                   )
      [1] => Array(
                              [0] => 3
                              [1] => 4
                   )
      [2] => Array(
                              [0] => 5
                   )
)
Array
(
      [0] => Array(
                              [0] => 1
                              [1] => 2
                   )
      [1] => Array(
                              [2] => 3
                              [3] => 4
                   )
      [2] => Array(
                              [4] => 5
                   )
)
.array  array_combine(array  keys,  array  values)
创建一个数组，  用一个数组的值做为其键名,  另一个数组的值做为其值
如果两个数组的单元数不同或数组为空时返回FALSE

$a = array('a','b','c');
$b = array('d','e','f');
$c = array_combine($a, $b);
Array(
               [a] => d
                => e
               [c] => f
)

               
               
               
               
               
.array  array_count_values(array  input)
统计数组中所有的值出现的次数
$arr = array(1, 2, 1.2.3,2);
print_r(array_count_values($arr));
Array
(
    [1]=>2
    [2]=>3
    [3]=>1   
)
.array  array_diff_assoc(array  array1,  array  array2[, array ...])
返回一个数组， 该数组包括了所有在array1中但不在任何其它参数数组中的值。
键名也参与比较
$arr1 = array("a" => "green",  "b"=>"brown", "c"=>"blue", "red")
$arr2 = array("a"=> "green", "yellow", "red");
$result = array_diff_assoc($array1,  $array2);
Array
(
       => brown
      [c] => blue
      [0] => red
)
               
               
               
               
.array  array_diff_key(array  array1,  array  array2 [,  array ...])
返回一个数组， 该数组包括了所有出现在array1中但未出现在任何其它参数数组中的键名的值。  注意关联关系保留不变。 本函数和array_diff()相同只除了比较是根据键名而不是值来进行的
$arr1 = array('blue' => 1, 'red'=>2, 'green'=>e, 'purple'=>4);
$arr2 = array('green'=>5,  'blue' => 6, 'yellow'=>7, 'cyan'=>8);
var_dump(array_diff_key($arr1, $arr2);
array(2) {
         ["red"] => int(2)
         ["purple"]=> int(4)
}
.array array_filter ( array input [, callback callback] )  //用回调函数过滤数组中的单元
array_filter() 依次将 input 数组中的每个值传递到 callback 函数。如果 callback 函数返回 TRUE，则 input 数组的当前值会被包含在返回的结果数组中。数组的键名保留不变。
function odd($var)
{
   return($var % 2 == 1);
}
function even($var)
{
   return($var % 2 == 0);
}
$array1 = array("a"=>1, "b"=>2, "c"=>3, "d"=>4, "e"=>5);
$array2 = array(6, 7, 8, 9, 10, 11, 12);
print_r(array_filter($array1, "odd"));
print_r(array_filter($array2, "even"));
上例将输出：
Array
(
   [a] => 1
   [c] => 3
   [e] => 5
)
Array
(
   [0] => 6
   [2] => 8
   [4] => 10
   [6] => 12
)
用户不应在回调函数中修改数组本身。例如增加／删除单元或者对 array_filter() 正在作用的数组进行 unset。如果数组改变了，此函数的行为没有定义。
如果没有提供 callback 函数，array_filter() 将删除 input 中所有等值为 FALSE 的条目。更多信息见转换为布尔值。
$entry = array(
             0 => 'foo',
             1 => false,
             2 => -1,
             3 => null,
             4 => ''
         );
print_r(array_filter($entry));
Array
(
    [0] => foo
    [2] => -1
)
.array array_flip ( array trans )  //交换数组中的键和值
返回一个反转后的 array，例如 trans 中的键名变成了值，而 trans 中的值成了键名。
注意 trans 中的值需要能够作为合法的键名，例如需要是 integer 或者 string。如果值的类型不对将发出一个警告，并且有问题的键／值对将不会反转。
如果同一个值出现了多次，则最后一个键名将作为它的值，所有其它的都丢失了。
array_flip() 如果失败返回 FALSE。
$trans = array_flip($trans);
$original = strtr($str, $trans);
例子：冲突
$trans = array("a" => 1, "b" => 1, "c" => 2);
$trans = array_flip($trans);
print_r($trans);
Array
(
    [1] => b
    [2] => c
)
.array array_intersect_assoc ( array array1, array array2 [, array ...] )  //带索引检查计算数组的交集
返回一个数组，该数组包含了所有在 array1 中也同时出现在所有其它参数数组中的值。注意和 array_intersect() 不同的是键名也用于比较。
$array1 = array("a" => "green", "b" => "brown", "c" => "blue", "red");
$array2 = array("a" => "green", "yellow", "red");
$result_array = array_intersect_assoc($array1, $array2);
$result_array 将是：
Array
(
    [a] => green
)
上面例子中可以看到只有键值对 "a" => "green" 在两个数组中都存在从而被返回。值 "red" 没有被返回是因为在 $array1 中它的键名是 0 而在 $array2 中 "red" 的键名是 1。
键值对 key => value 中的两个值仅在 (string) $elem1 === (string) $elem2 时被认为相等。也就是说使用了严格检查，字符串的表达必须相同。
.array array_intersect_key ( array array1, array array2 [, array ...] )  //使用键名比较计算数组的交集
返回一个数组，该数组包含了所有出现在 array1 中并同时出现在所有其它参数数组中的键名的值。
$array1 = array('blue'  => 1, 'red'  => 2, 'green'  => 3, 'purple' => 4);
$array2 = array('green' => 5, 'blue' => 6, 'yellow' => 7, 'cyan'  => 8);
var_dump(array_intersect_key($array1, $array2));
上例将输出：
array(2) {
  ["blue"]=>
  int(1)
  ["green"]=>
  int(3)
}
上例中可以看到只有 'blue' 和 'green' 两个键名出现在两个数组中，因此被返回。此外注意 'blue' 和 'green' 的值在两个数组中是不同的。但因为只检查键名，因此还是匹配。返回的值只是 array1 中的。
在 key => value 对中的两个键名仅在 (string) $key1 === (string) $key2 时被认为相等。换句话说，执行的是严格类型检查，因此字符串的表达必须完全一样。  
.bool  array_key_exists(mixed key,  array search)   //检查给定的索引或键名是否存在于数组中
成功： 返回TRUE
失败： 返回FALSE
if(array_key_exists("first",  $arr))
{
       echo  "exists...";
｝
               
               
               
               
               
               
               
                .array  array_keys(array  input [, mixed  search_value [, bool  strict]])   //返回数组中的所有键名
如果指定了可选参数search_value, 则只返回该值的键名。 否则返回数组的所有銉名。 从PHP5起可以用strict参数来进行全等比较 ===
$arr = array(0=>100, "color"=>"red");
print_r(array_keys($arr, “red"));
.array  array_map(callback  callback,  array arr1 [, array ...])  //将回调函数做用到给定的数组单元上
返回一个数组， 该数组包含了arr1中的所有单元经过callback作用过之后 的单元。。
callbacck接受的参数数目应和传递给arraay_map()函数的数组数目一致
1)
function  cube($n)
{
    return($n*$n*$n);
}
$a = array(1,2,3,4,5);
$b = array_map("cube", $a);
print_r($b);
Array
(
     [0] => 1
     [1] => 8
     [2] => 27
     [3] => 64
     [4] => 125
)
2)
$_POST = array_map("addslashes", $_POST);
.bool  array_multisort(array  arr1 [, mixed  arg [, mixed ... [, array ...]]])   //对多个数组或多维数组进行排序, 关联键名保持不变， 但数字键名会重新索引
成功： 返回TRUE
失败： 返回FALSE
输入数组被当成一个表的列并以行来排序 --- 这类似于SQL的ORDER BY 子句的功能。 第一个数组是要排序的主要数组。 数组中的行(值)比较为相同的话就按下一个输入数组中相应值的大小来排序， 依此类推
排序标志：
       SORT_ASC      按上升顺序排序 （默认）
       SORT_DESC    按下降顺序排序
排序类型标志：
       SORT_REGULAR         将项目按通常方法比较 （默认）
       SORT_NUMERIC          将项目按数值比较
       SORT_STRING              将项目按字符串比较
$arr1 = array("10", 100, 100, "a");
$arr2 = array(1,3,"2",1);
array_multisort($arr1,  $arr2);
array(4)
(
       ［0］=>  string(2)  "10"
         [1]   =>  string(1)   "a"
         [2]   =>  int(100)
         [3]   =>  int(100)
)
array(4)
(
       [0] =>  int(1)
       [1] =>  int(1)
       [2] =>  string(1) "2"
       [3] =>  int(3)
)
$arr = array(array("10", 100, 100, "a"),  array(1,3,"2"));
array_multisort($arr[0], SORT_ASC,  SORT_STRING,  $arr[1], SORT_NUMERIC, SORT_DESC);
array(2) {
  [0]=> array(5) {
    [0]=> string(2) "10"
    [1]=> int(100)
    [2]=> int(100)
    [3]=> int(11)
    [4]=> string(1) "a"
  }
  [1]=> array(5) {
    [0]=> int(1)
    [1]=> int(3)
    [2]=> string(1) "2"
    [3]=> int(2)
    [4]=> int(1)
  }
}
对数据库结果进行排序
本例中 data 数组中的每个单元表示一个表中的一行。这是典型的数据库记录的数据集合。
volume | edition
-------+--------
    67 |       2
    86 |       1
    85 |       6
    98 |       2
    86 |       6
    67 |       7
数据全都存放在名为 data 的数组中。这通常是通过循环从数据库取得的结果，例如 mysql_fetch_assoc()。
67, 'edition' => 2);
$data[] = array('volume' => 86, 'edition' => 1);
$data[] = array('volume' => 85, 'edition' => 6);
$data[] = array('volume' => 98, 'edition' => 2);
$data[] = array('volume' => 86, 'edition' => 6);
$data[] = array('volume' => 67, 'edition' => 7);
?>
本例中将把 volume 降序排列，把 edition 升序排列。
现在有了包含有行的数组，但是 array_multisort() 需要一个包含列的数组，因此用以下代码来取得列，然后排序。
$row) {
   $volume[$key]  = $row['volume'];
   $edition[$key] = $row['edition'];
}
// 将数据根据 volume 降序排列，根据 edition 升序排列
// 把 $data 作为最后一个参数，以通用键排序
array_multisort($volume, SORT_DESC, $edition, SORT_ASC, $data);
?>
数据集合现在排好序了，结果如下：
volume | edition
-------+--------
    98 |       2
    86 |       1
    86 |       6
    85 |       6
    67 |       2
    67 |       7

               
               
               
               
               
               
.mixed  array_search(mixed  needle,  array  haystack [, bool  strict])  //在数组中搜索给定的值，如果成功则返回相应的键名， 否则返回FALSE
如果strict为TRUE， 则array_search()还将在haystack中检查needle的类型
如果needle在haystack中出现不止一次，则返回第一个匹配的键名。
要返回所有匹配值的键， 应用array_key()加上可选参数search_value来代替
$array = array( 0=>"blue",  1=>"red", 2=>"green", 3=>"red");
$key = array_search("green",  $array);
.mixed  array_shift(array  $array)    //将数组开头的单元移出数组
array_shift()将array的第一个单元移出并做为结果返回， 将array的长度减一并将所有其它单元向前移动一位。 所有的数字键名将改为从零开始计数，文字键名将不变。 如果array为空（或不是数组）， 则返回NULL
使用本函数后会重置(reset())数组指针
$arr = array("a", "b", "c", "d");
$result = array_shift($arr);
print_r($arr);
Array
(
    ［0］=> b
      [1]   ＝>c
      [2]   => d
）
.array  array_slice(array  array,  int  offset [, int length[, bool preserve_keys]])  //从数组中取出一段
函数默认将重置数组的键， 从PHP 5.0.2 起， 可通过将preserve_keys设置为TRUE来改变此行为
$arr = array("a","b","c","d","e");
$arr2 = array_slice($arr, 2);              //array("c","d","e")
$arr2 = array_slice($arr, -2,1);         //array("d")
$arr2 = array_slice($arr, 0,3);          //array("a","b","c")
$arr2 = array_slice($arr, 2,-1);        //array("c","d")
$arr2 = array_slice($arr, 2,-1, true);     //array("c","d")
.array   array_unique(array   array)   //移除数组中重复的值， 键名保留不变
.int    array_unshift(array &array,  mixed  var [,  mixed ... ])   //在数组开头插入一个或多个单元
注意单元是做为整体被插入的， 因此传入单元将保持同样的顺序。 所有的数值键名将修改为从零开始重新计数， 所有的文字键名保持不变
返回array数组新的单元数组
$arr = array("orange", "banana");
array_unshift($arr,  "apple", "raspberry");
Array
(
    ［0］ => apple
      [1]    =>  raspberry
      [2]    =>  orange
      [3]    =>  banana
）
.array   array_values(array  array)    //返回数组中所有的值， 并建立数字索引
$array =  array("size"=> "XL",  "color"=>"gold");
print_r(array_values($array));
.bool  array_walk_recursive(array  &array,  callback  funcname [,  mixed  userdata])  //对数组中的每个成员递归地应用用户函数
将用户自定义函数funcname应用到array数组中的每个单元。
本函数会递归到更深层的数组中去。
$sweet = array("a"=>"apple",  "b"=>"banana");
$fruits  = array("sweet"=>$sweet, "sour"=>"lemon");
function test_print($item, $key)
{
     echo  "$key  holds  $item \n";
}
array_walk_recursive($fruits, "test_print");
输出
a  holds  apple
b  holds  banana
sour holds lemon
               
               
.bool  array_wal(array  &array,   callback,  funcname [, mixed  userdata])  //对数组中的每个成员应用用户函数
成功： 返回TRUE
失败： 返回FALSE
将用户自字义函数funcname应用到array数组中的每个单元。
如果提供了可选参数userdata, 将被做为第三个参数传递给callback  funcname
如果funcname函数需要的参数比给出的多， 则每次array_walk()调用funcname时都会产生一个E_WARNING级的错误。 这些警告可以通过在array_walk()调用前加上PHP的错误操作符@来抑制， 或用error_reporting()
array_walk()不会受到array内部数组指针的影响。  
array_walk()会遍历整个数组而不管指针的位置
则回调用 函数不应改变数组本身。 如增加／删除单元
$fruits = array("d"=>"lemon", "a"=>"orange", "b"=>"banana", "c"=>"apple");
function   test_alter(&$item1, $key, $prefix)
{
    $item1="$prefix : $item1";
}
function  test_print($item2, $key)
{
    echo  "$key.$item2
\n";
}
array_walk($fruits, 'test_print');
array_walk($fruits, 'test_alter', 'fruit');
array_walk($fruits, "test_print");
.bool  asort(array  &array [,  int  sort_flags])  //对数组进行排序，并保持索引关系
.bool arsort ( array &array [, int sort_flags] )   //对数组进行逆向排序并保持索引关系
本函数对数组进行排序，数组的索引保持和单元的关联。主要用于对那些单元顺序很重要的结合数组进行排序。
如果成功则返回 TRUE，失败则返回 FALSE
.array compact ( mixed varname [, mixed ...] )   //建立一个数组，包括变量名和它们的值
compact() 接受可变的参数数目。每个参数可以是一个包括变量名的字符串或者是一个包含变量名的数组，该数组中还可以包含其它单元内容为变量名的数组， compact() 可以递归处理。
对每个参数，compact() 在当前的符号表中查找该变量名并将它添加到输出的数组中，变量名成为键名而变量的内容成为该键的值。简单说，它做的事和 extract() 正好相反。返回将所有变量添加进去后的数组。
任何没有变量名与之对应的字符串都被略过。
Gotcha: 因为可变变量也许不能在函数内部用于 PHP 的超全局数组，此时不能将超全局数组传递入 compact() 中。
例子 1. compact() 例子
经过处理后，$result 为：
Array
(
   [event] => SIGGRAPH
   [city] => San Francisco
   [state] => CA
)
.int  count(mixed  var [,  int  mode])  //计算数组中的单元数目或对象中的属性个数
参数mode设为COUNT_RECURSIVE(或1),  count()将递归地对数组计数。 对计算多维数组的所有单元尤其有用， 默认值是0。
. mixed  current(array  &array)   //返回数组中的当前单元, 并不移动指针
$arr = array("a","b","c");
$mode = current($arr);    // $mode = "a'
$mode = next($arr);        // $mode = "b"
$mode = current($arr);   // $mode = "b"
$mode = prev($arr);       //  $mode = "a"
$mode = end($arr);        //  $mode = "c"
$mode = current($arr);    // $mode = "c"
$mode = current($arr);    // $mode = "b'
.bool  in_array(mixed  needle,   array  haystack [, bool  strict])  //检查数组中是否存在某个值
如果第三个参数 strict 的值为 TRUE 则 in_array() 函数还会检查 needle 的类型是否和 haystack 中的相同
成功： 返回TRUE
失败： 返回FALSE
.mixed key ( array &array )    //取得数组中当前单元的键名。

$array = array(
'fruit1' => 'apple',
'fruit2' => 'orange',
'fruit3' => 'grape',
'fruit4' => 'apple',
'fruit5' => 'apple');
// this cycle echoes all associative array
// key where value equals "apple"
while ($fruit_name = current($array)) {
   if ($fruit_name == 'apple') {
       echo key($array).'
';
   }
   next($array);
}
.bool krsort ( array &array [, int sort_flags] )    //对数组按照键名逆向排序，保留键名到数据的关联。主要用于结合数组。
如果成功则返回 TRUE，失败则返回 FALSE。
$fruits = array("d"=>"lemon", "a"=>"orange", "b"=>"banana", "c"=>"apple");
krsort($fruits);
foreach ($fruits as $key => $val) {
   echo "$key = $val\n";
}
上例将输出：
d = lemon
c = apple
b = banana
a = orange
.bool ksort ( array &array [, int sort_flags] )   //对数组按照键名排序，保留键名到数据的关联。本函数主要用于关联数组。
如果成功则返回 TRUE，失败则返回 FALSE。
$fruits = array("d"=>"lemon", "a"=>"orange", "b"=>"banana", "c"=>"apple");
ksort($fruits);
foreach ($fruits as $key => $val) {
   echo "$key = $val\n";
}
上例将输出：
a = orange
b = banana
c = apple
d = lemon
.void list ( mixed varname, mixed ... )    //把数组中的值赋给一些变量， list()
     用一步操作给一组变量进行赋值。
注:
      list() 仅能用于数字索引的数组并假定数字索引从 0 开始。
     
     $info = array('coffee', 'brown', 'caffeine');
// Listing all the variables
list($drink, $color, $power) = $info;
echo "$drink is $color and $power makes it special.\n";
// Listing some of them
list($drink, , $power) = $info;
echo "$drink has $power.\n";
// Or let's skip to only the third one
list( , , $power) = $info;
echo "I need $power!\n";
.array range ( mixed low, mixed high [, number step] )   //建立一个包含指定范围单元的数组
返回数组中从 low 到 high 的单元，包括它们本身。如果 low > high，则序列将从 high 到 low。
新参数: 可选的 step 参数是 PHP 5.0.0 新加的。
如果给出了 step 的值，它将被作为单元之间的步进值。step 应该为正值。如果未指定，step 则默认为 1。
// array(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)
foreach (range(0, 12) as $number) {
   echo $number;
}
// The step parameter was introduced in 5.0.0
// array(0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100)
foreach (range(0, 100, 10) as $number) {
   echo $number;
}
// Use of character sequences introduced in 4.1.0
// array('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i');
foreach (range('a', 'i') as $letter) {
   echo $letter;
}
// array('c', 'b', 'a');
foreach (range('c', 'a') as $letter) {
   echo $letter;
}
               
               
.mixed reset ( array &array )  //将数组的内部指针指向第一个单元
将 array 的内部指针倒回到第一个单元并返回第一个数组单元的值，如果数组为空则返回 FALSE。
$array = array('step one', 'step two', 'step three', 'step four');
// by default, the pointer is on the first element
echo current($array) . "
\n"; // "step one"
// skip two steps
next($array);
next($array);
echo current($array) . "
\n"; // "step three"
// reset pointer, start again on step one
reset($array);
echo current($array) . "
\n"; // "step one"
.bool rsort ( array &array [, int sort_flags] )   //对数组逆向排序
本函数对数组进行逆向排序（最高到最低）。
注: 本函数为 array 中的单元赋予新的键名。这将删除原有的键名而不仅是重新排序。
       如果成功则返回 TRUE，失败则返回 FALSE。
$fruits = array("lemon", "orange", "banana", "apple");
rsort($fruits);
foreach ($fruits as $key => $val) {
   echo "$key = $val\n";
}
上例将输出：
0 = orange
1 = lemon
2 = banana
3 = apple
fruits 被按照字母顺序逆向排序。
.bool sort ( array &array [, int sort_flags] )   //对数组排序
本函数对数组进行排序。当本函数结束时数组单元将被从最低到最高重新安排。
注: 本函数为 array 中的单元赋予新的键名。这将删除原有的键名而不仅是重新排序。
如果成功则返回 TRUE，失败则返回 FALSE。
$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 新加
.bool uasort ( array &array, callback cmp_function )  //使用用户自定义的比较函数对数组中的值进行排序并保持索引关联
本函数对数组排序并保持索引和单元之间的关联。主要用于对那些单元顺序很重要的结合数组进行排序。比较函数是用户自定义的。
如果成功则返回 TRUE，失败则返回 FALSE
.bool uksort ( array &array, callback cmp_function )  //使用用户自定义的比较函数对数组中的键名进行排序
本函数将使用用户提供的比较函数对数组中的键名进行排序。如果要排序的数组需要用一种不寻常的标准进行排序，那么应该使用此函数。
cmp_function 函数应接受两个参数，该参数将被 array 中的一对键名填充。比较函数在第一个参数小于，等于，或大于第二个参数时必须分别返回一个小于零，等于零，或大于零的整数。
如果成功则返回 TRUE，失败则返回 FALSE。
例子 1. uksort() 例子
function cmp($a, $b)
{
   if ($a == $b) {
       return 0;
   }
   return ($a > $b) ? -1 : 1;
}
$a = array(4 => "four", 3 => "three", 20 => "twenty", 10 => "ten");
uksort($a, "cmp");
foreach ($a as $key => $value) {
   echo "$key: $value\n";
}
上例将输出：
20: twenty
10: ten
4: four
3: three
.bool usort ( array &array, callback cmp_function )  //使用用户自定义的比较函数对数组中的值进行排序
本函数将用用户自定义的比较函数对一个数组中的值进行排序。如果要排序的数组需要用一种不寻常的标准进行排序，那么应该使用此函数。
比较函数必须在第一个参数被认为小于，等于或大于第二个参数时分别返回一个小于，等于或大于零的整数。
    注: 如果两个成员比较结果相同，则它们在排序后的数组中的顺序未经定义。到 PHP 4.0.6 之前，用户自定义函数将保留这些单元的原有顺序。但是由于在 4.1.0 中引进了新的排序算法，结果将不是这样了，因为对此没有一个有效的解决方案。
    注: 本函数为 array 中的单元赋予新的键名。这将删除原有的键名而不仅是重新排序。
如果成功则返回 TRUE，失败则返回 FALSE。
例子 1. usort() 例子
$value) {
   echo "$key: $value\n";
}
?>
上例将输出：
0: 1
1: 2
2: 3
3: 5
4: 6
    注: 很明显在这个小例子中用 sort() 函数更合适。
例子 2. 使用多维数组的 usort() 例子
当排序多维数组时，$a 和 $b 包含到数组第一个索引的引用。
上例将输出：
$fruits[0]: apples
$fruits[1]: grapes
$fruits[2]: lemons
例子 3. 使用对象的成员函数的 usort() 例子
name = $name;
   }
   /* This is the static comparing function: */
   function cmp_obj($a, $b)
   {
       $al = strtolower($a->name);
       $bl = strtolower($b->name);
       if ($al == $bl) {
           return 0;
       }
       return ($al > $bl) ? +1 : -1;
   }
}
$a[] = new TestObj("c");
$a[] = new TestObj("b");
$a[] = new TestObj("d");
usort($a, array("TestObj", "cmp_obj"));
foreach ($a as $item) {
   echo $item->name . "\n";
}
?>
上例将输出：
b
c
d