相信 有很多 同仁们，尤其是初学者，在记住 Array对象 sort() 方法的排序，规则上，有点困难； 其实sort()方法已经在实际工作中用到很多遍了，可当我仔细推敲，这个sort()方法，什么时候是升序排列，什么时候是倒序排列 的时候，还真是有点小懵圈；
先来看一下，官网上是怎么说的吧：
这是我在W3C上截来的一张图，起初，读这个说明的时候，大概理解，要表达的意思，可是当我细细琢磨红框框出来的部分的时候，就有点不太理解了；
然后在 W3C上看到，这样一个例子：
<script type="text/javascript">
function sortNumber(a,b)
{
return a - b
}
var arr = new Array(6)
arr[0] = "10"
arr[1] = "5"
arr[2] = "40"
arr[3] = "25"
arr[4] = "1000"
arr[5] = "1" document.write(arr + "<br />")
document.write(arr.sort(sortNumber)) </script>
用这个 sortNumber() 函数，可以做到 将数值数组做到 升序排列； 于是 我就做了一下测试，又得到了 可以倒序排列数组数组的函数(其实 这个东西网上一查有很多)；
function descSortNumber(a,b)
{
return b-a;
}
好，到此为止，我们可以对一个数值数组做 升序 和 降序 的排列； 可是由此 问题就来了，为什么, return a-b 就是升序， return b-a 就是降序，这到底是个什么规律呢？？？ 声明 一下，这里不解释该方法的底层实现原理，只是讲述一个 帮助记忆的规律方法。
于是，就有仔细读了一下 上边图片中的 红框的位置，得到下面的4个函数：
// 升序排列
function asc( a,b ){
return (a<b ? -1 : 1);
} function asc2(a,b){
return (a>b ? 1 : -1);
} // 降序排列
function desc( a, b ){
return (a<b ? 1 : -1);
} function desc2( a, b ){
return (a>b ? -1 : 1);
}
测试 之后，array.sort(asc) 可以升序排列，array.sort(desc) 可以降序排列；可是，在使用的时候，这四个函数 用起来的时候不免后有些错乱，当然，就四个函数返回xxx时，升序；返回yyy时，降序；完全可以凭记忆 强行记下来，可是本人 就是有个按总结规律，爱钻牛角的毛病；于是在冥思苦相之下，总结出了一套规律，与同仁们分享一下：
前提：
在return时，无论a>b 还是 a<b, 任选其一， 用（a-b）与 三项表达式 条件为true时的结果（即“？”后第一个结果）做 乘，得到的结果 为正数，则升序；为负数，则降序；
拿上边四个函数中的 desc(a,b) return （a<b ? 1 : -1）做例:
first: (a - b) 为 -abs(a-b) ， 即， -(a-b)的绝对值( 是一个负数)；
second: 三项表达式 条件true时，结果为 1（是一个正数）；
third: -abs(a-b) * 1 结果为一个 负数；
forth: 得到结果-->此函数可以达到 倒序 排列数组 的目的；
记忆规律 介绍完毕，下面，上一端我写的 关于各类数组排序 的代码，以待后用，也希望对同仁们 有用：
var _p = (function( _ ){
/********************************************************** ##.数组排序 Array.sort()类 *****************************************************/
/*
* @1. 按照字符编码的顺序进行排序，即：先转成字符串再排序
* applay: Array.sort( _.codeSort );
*/
_.codeSort = function(){
//do nothing....
};
/*
* @2. 按照数字 升序排序
* applay:Array.sort( _.numAscSort ); 适用于数字数组的排序
*/
_.numAscSort = function(){
return function(a,b){
return a - b;
};
};
/*
* @3. 按照数字 降序排序
* applay:Array.sort( _.numDescSort ); 适用于数字数组的排序
*/
_.numDescSort = function(){
return function(a,b){
return b - a;
};
};
/*
* @4. 对象数组 升序排列(object array asc)
* applay: Array.sort( _.objAscBy('name',fn) ); 适用于：[{},{},{},....]
* description: 先按对象数组中的obj的某个元素进行排序，如果其中两个相等的话，则这两个再按 minor（typeof==='function'）规则进行
*/
_.objAscBy = function(name, minor){ //object array asc (对象数组 升序排列)
return function(o,p){
var a,b;
if(o && p && typeof o === 'object' && typeof p === 'object'){
a = o[name];
b = p[name];
// 1.完全相等的时候 看自定义规则 minor,存在则按 minor进行比较；否则返回0，不排序；
if(a === b){
return typeof minor === 'function'?minor(o,p):0;
}
// 2.同类型 按 大小排序
if(typeof a === typeof b ){
return a < b ? -1 : 1;
}
// 3.按 类型排序
if( typeof a !== typeof b ){
return typeof a < typeof b ? -1 : 1;
}
}
else {
throw ("error");
}
};
};
/*
* @5. 对象数组 降序排列(object array desc)
* applay: Array.sort( _.objDescBy('name',fn) ); 适用于：[{},{},{},....]
* description: 先按对象数组中的obj的某个元素进行排序，如果其中两个相等的话，则这两个再按 minor（typeof==='function'）规则进行
*/
_.objDescBy = function(name, minor){
return function(o,p){
var a,b;
if(o && p && typeof o === 'object' && typeof p === 'object'){
a = o[name];
b = p[name];
// 1.完全相等的时候 看自定义规则 minor,存在则按 minor进行比较；否则返回0，不排序；
if(a === b){
return typeof minor === 'function' ? minor(o,p) : 0;
}
// 2.同类型 按 大小排序
if(typeof a === typeof b ){
return a < b ? 1 : -1;
}
// 3.按 类型排序
if( typeof a !== typeof b ){
return typeof a < typeof b ? 1 : -1;
}
}
else {
throw ("error");
}
};
};
/**
* @author: jcy
* @apply: Array.sort( _.arrAscBy(i,fn) ); 适用于：[ [x,xx,xxx,...], [x,xx,xxx,...], [x,xx,xxx,...], [x,xx,xxx,...], ... ]
* 适用于 要排序的对象是一个 包含n个子数组 的数组, 以这n个子数组中的某一个位置的元素 将这n个子数组 进行排序
* @eg: a = [ [x,xx,xxx,...], [x,xx,xxx,...], [x,xx,xxx,...], [x,xx,xxx,...], ... ]
* 将 a 数组中的所有子数组，以子数组中的第2个位置的元素，将所有子数组进行排序
*/
_.arrAscBy = function(i, minor){ //array array asc(数组数组 升序排列)
return function(o,p){
var a,b;
if( o && p && typeof o === 'object' && typeof p === 'object' ){
a = o[i];
b = p[i];
// 1.完全相等的时候 看自定义规则 minor,存在则按 minor进行比较；否则返回0，不排序；
if(a === b){
return typeof minor === 'function'?minor(o,p):0;
}
// 2.同类型 按 大小排序
if(typeof a === typeof b ){
return a < b ? -1 : 1;
}
// 3.按 类型排序
if( typeof a !== typeof b ){
return typeof a < typeof b ? -1 : 1;
}
}
else {
throw("error");
}
}
};
/**
* @author: jcy
* @apply: Array.sort( _.arrDescBy(i,fn) ); 适用于：[ [x,xx,xxx,...], [x,xx,xxx,...], [x,xx,xxx,...], [x,xx,xxx,...], ... ]
* 适用于 要排序的对象是一个 包含n个子数组 的数组, 以这n个子数组中的某一个位置的元素 将这n个子数组 进行排序
* @eg: a = [ [x,xx,xxx,...], [x,xx,xxx,...], [x,xx,xxx,...], [x,xx,xxx,...], ... ]
* 将 a 数组中的所有子数组，以子数组中的第2个位置的元素，将所有子数组进行排序
*/
_.arrDescBy = function(i, minor){ //array array desc(数组数组 降序排列)
return function(o,p){
var a,b;
if( o && p && typeof o === 'object' && typeof p === 'object' ){
a = o[i];
b = p[i];
// 1.完全相等的时候 看自定义规则 minor,存在则按 minor进行比较；否则返回0，不排序；
if(a === b){
return typeof minor === 'function' ? minor(o,p) : 0;
}
// 2.同类型 按 大小排序
if(typeof a === typeof b ){
return a < b ? 1 : -1;
}
// 3.按 类型排序
if( typeof a !== typeof b ){
return typeof a < typeof b ? 1 : -1;
}
}
else {
throw("error");
}
}
};
return _ ;
})(_p || {});
此段代码， 1.可作为插件直接使用；
2.调用的方式（在每个方法的头部说明中已经 做了说明）；
3.适用的情形（在每个方法的头部说明中已经 做了说明）；
为了直观展示用法，上个例子：
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>test</title>
</head>
<body>
<script type="text/javascript" src="plugin-jack.js"></script>
<script type="text/javascript">
var bigArr =
[
[1,"张家口市",4.07],
[13,"石家庄市",4.12],
[2,"承德市",5.21],
[10,"邯郸市",15.60],
[12,"保定市",11.09],
[4,"秦皇岛市",7.05],
[9,"唐山市",9.27],
[8,"衡水市",8.66],
[7,"沧州市",8.21],
[5,"天津市",17.48],
[6,"廊坊市",7.88],
[3,"北京市",16.15],
[11,"邢台市",10.92]
]; // 按 bigArr数组，每个子数组的索引项为2 的项，将bigArr数组的所有子数组进行 倒序 排序
var CompositeIndex = bigArr.sort( _p.arrDescBy(2) ).concat();
for(var i=0; i<CompositeIndex.length; i++){
document.write(CompositeIndex[i] +"<br>");
}; </script>
</body>
</html>
结果：
5,天津市,17.48
3,北京市,16.15
10,邯郸市,15.6
12,保定市,11.09
11,邢台市,10.92
9,唐山市,9.27
8,衡水市,8.66
7,沧州市,8.21
6,廊坊市,7.88
4,秦皇岛市,7.05
2,承德市,5.21
13,石家庄市,4.12
1,张家口市,4.07