数组和字符串的排序

字符串比较 string.localeCompare(that)

如果 string 比 that 字符串小，结果为负数，如果相等结果为0，类似于 array.sort() 比较函数的约定：

// n = ['AAA', 'A', 'aa', 'a', 'Aa', 'aaa'];
n.sort(function (a, b) {
  return a.localeCompare(b);
});
// n = ['a', 'A', 'aa', 'Aa', 'aaa', 'AAA']

只包含数字的数组排序

一、升序
array.sort() 接受一个比较函数，该比较函数接收两个参数 a 和 b，a=b 则返回0，a>b 则返回一个负数，a<b 则返回一个正数。

// n = [8, 4, 16, 15]
n.sort(function (a, b) {
  return a - b;
});
// n = [4, 8, 15, 16]

二、降序
将升序中的“return a - b” 换成 “return b - a” 即可；

包含字符串和数字的数组

// n = ['aa', 'bb', 'a', 8, 4, 16, 15]
n.sort(function (a, b) {
  if (a === b) {
    return 0;
  }
  if (typeof a === typeof b) {
    return a < b ? -1 : 1;
  }
  return typeof a < typeof b ? -1 : 1;
})
// n = [4, 8, 15, 16, 'a', 'aa', 'bb']

如果大小写不重要，比较函数应该在比较前将两个运算数转化为小写。

对象数组排序

var n = [
  {first: 'Joe', last: 'Besser'},
  {first: 'Moe', last: 'Howard'},
  {first: 'Joe', last: 'DeRita'},
  {first: 'Shemp', last: 'Howard'},
  {first: 'Larry', last: 'Fine'},
  {first: 'Curly', last: 'Howard'},
]

// by 函数接受一个key(成员名)字符串作为参数
// 返回一个可以用来对包含该成员的对象数组进行排序的比较函数
var by = function (name) {
  return function (o, p) {
    var a, b;
    if (typeof o === 'object' && typeof p === 'object' && o && p) {
      a = o[name];
      b = p[name];
      if (a === b) {
        return 0;
      }
      if (typeof a === typeof b) {
        return a < b ? -1 : 1;
      }
      return typeof a < typeof b ? -1 : 1;
    } else {
      throw {
        name: 'Error',
        message: 'Expected an object when sorting by ' + name
      };
    }
  }
}

n.sort(by('first'));
// 排序后：
// n = [
//   {first: 'Curly', last: 'Howard'},
//   {first: 'Joe', last: 'Besser'},
//   {first: 'Joe', last: 'DeRita'},
//   {first: 'Larry', last: 'Fine'},
//   {first: 'Moe', last: 'Howard'},
//   {first: 'Shemp', last: 'Howard'},
// ]

改进版：可以接受两个参数，根据两个键值进行排序，当主要键值产生匹配时，另一个匹配将被调用：

// by 函数接受一个成员名字符串和一个可选的次要比较函数作为参数，
// 返回一个可以用来对包含该成员的对象数组进行排序的比较函数
// 当 o[name] 和 p[name] 相等时，次要比较函数被用来比较
var by = function (name, minor) {
  return function (o, p) {
    var a, b;
    if (typeof o === 'object' && typeof p === 'object' && o && p) {
      a = o[name];
      b = p[name];
      if (a === b) {
        return typeof minor === 'function' ? minor(o,p) : 0;
      }
      if (typeof a === typeof b) {
        return a < b ? -1 : 1;
      }
      return typeof a < typeof b ? -1 : 1;
    } else {
      throw {
        name: 'Error',
        message: 'Expected an object when sorting by ' + name
      };
    }
  }
};

调用：

 n.sort(by('last'), by('first'));
 
 // n = [
 //   {first: 'Joe', last: 'Besser'},
 //   {first: 'Joe', last: 'DeRita'},
 //   {first: 'Larry', last: 'Fine'},
 //   {first: 'Curly', last: 'Howard'},
 //   {first: 'Moe', last: 'Howard'},
 //   {first: 'Shemp', last: 'Howard'},
 // ]