【JavaScript笔记 · 特殊篇】Array.prototype.sort()方法的进阶实例（数值升序，不区分大小写字母升序，自定义条件排序）

Array.prototype.sort()方法几乎是算法必会的。我们会遇到各种各样的排序问题，记得之前学过很底层的一些排序方法，什么快速排序，冒泡排序等等，需要敲很多代码，还很费头发…
这时候弄懂Array原型中给我们提供的sort()方法就显得尤为重要了。

一. 基础用法

sort()方法对数组成员进行排序，默认是按照字典顺序（ASCII码值）排序。数值会被先转成字符串，再按照字典顺序进行比较，排序后，原数组将被改变。

['d', 'c', 'b', 'a'].sort()
// ['a', 'b', 'c', 'd']

[4, 3, 2, 1].sort()
// [1, 2, 3, 4]

[11, 101].sort()
// [101, 11]

个位数的数值按照默认sort()排序可以正确达到升序的目的，一旦存在更多位数的数值，排序结果就不是我们想要的了，比如第三组的101就排在了11的前边。

二. 进阶用法（比较器函数）

sort()方法也可以接受一个比较器函数作为参数，来自定义排序的规则。

• 参数：比较器函数（必须要有返回值，推荐返回Number类型）
• 返回值：重新排序后的数组
• 原数组：改变

比较器函数需要接收两个形参用来确定顺序。

2.1 数值的升序，降序排列

使用默认的sort()方法无法真正达到对数值的排序，可以传入一个简单的比较器函数来搞定，也算是一个小技巧~

var arr = [12,15,2,345,64];
arr.sort( ( a , b ) => a - b );
console.log("升序：",arr);

arr.sort( ( a , b ) => b - a );
console.log("降序：",arr);


——————OUTPUT——————
升序： [ 2, 12, 15, 64, 345 ]
降序： [ 345, 64, 15, 12, 2 ]

2.2 不区分大小写的字母排序

当数组元素均为大小写不同的英文字母时，按照sort()默认的字典顺序（ASCII码值）会出现大写在前，小写在后的顺序。如何进行不区分大小写的正确排序呢 ？

var arr = ['Z','e','V','I','n'];
console.log(arr.sort());


——————OUTPUT——————
[ 'I', 'V', 'Z', 'e', 'n' ]

不区分大小写就需要我们在比较器函数中多写一步全大写（小写）的转换过程，然后再按值排序。

var arr = ['Z','e','V','I','n'];
arr.sort(function(a, b){
    var x = a.toLowerCase(), y = b.toLowerCase();
    return x < y ? -1 : x > y ? 1 : 0;
});
console.log(arr);


——————OUTPUT——————
[ 'e', 'I', 'n', 'V', 'Z' ]

2.3 自定义条件排序

当数组元素为多属性的对象时，我们可能需要根据不同的属性来具体排序，比如以下数组中，我们想按照年龄降序排列：

var arr = [{
    name:"code",age:19,grade:98
},{
    name:"zevin",age:12,grade:94
},{
    name:"j",age:15,grade:91
}];

arr.sort(function(a,b){
    if(a.age > b.age){
        return 1;
    }else{
        return -1;
    };
});
console.log(arr);


——————OUTPUT——————
[
  { name: 'zevin', age: 12, grade: 94 },
  { name: 'j', age: 15, grade: 91 },
  { name: 'code', age: 19, grade: 98 }
]

这样写是可以完成年龄降序的排序需求，但是这还不是真正的自定义。

生活中大家可能会见到各种各样的排行榜：
比如我们在京东APP上搜索某个商品，搜索结果列表可以按照销量来排序，或者价格升序 / 降序来排序，这样的需求我们也可以用sort()方法简单模拟一下：

这里我们可以封装一个函数sort，接收两个形参：需要排序的数组arr以及排序依据的属性键名property。其中用到了闭包的写法：

sort()方法中本来应该传入的是一个比较器函数，但是我们这里还需要再传入一个属性键名的自定义值，就需要在比较器函数的外部再包裹上一个匿名函数，通过匿名函数调用属性键名property，以形参prop的形式传给内部的比较器函数，最后让匿名函数返回这个比较器函数即可。

var arr = [{
    name:"code",age:19,grade:98
},{
    name:"zevin",age:12,grade:94
},{
    name:"j",age:15,grade:91
}];

function sort(arr,property){
    arr.sort((function(prop){
        return function(a,b){
            return a[prop] > b[prop] ? -1 : a[prop] < b[prop] ? 1 : 0;
        }
    })(property));
};

sort(arr,"grade");
console.log(arr);


——————OUTPUT——————
[
  { name: 'code', age: 19, grade: 98 },
  { name: 'zevin', age: 12, grade: 94 },
  { name: 'j', age: 15, grade: 91 }
]

这样我们就可以通过调用sort函数，修改传入的属性键名即可快速完成自定义排序。

---

拓展：sort()方法的"黑历史"

在ECMA官方规范中，并没有明确说明Array.prototype.sort()方法具体使用的哪种排序算法，只是说这种方法并不稳定！言外之意就是我不规定Array.prototype.sort()方法的具体排序算法，由你们浏览器自身引擎决定。

所以各大引擎就开始自由发挥了：

浏览器	JavaScript引擎	sort()排序算法
Google Chrome	Google V8	6.0.0内核： 数组长度 < 11 插入排序 数组长度 > 11 快速排序 7.0.0内核及以上 Timsort排序
Mozilla Firefox	SpiderMonkey	归并排序
Microsoft Edge和IE	Chakra	快速排序
Safari	Nitro	桶排序和归并排序

我详细贴出了Google V8引擎的sort()排序算法，6.0.0的内核版本才是"大坑"所在！！
可以看到Google V8 6.0.0的版本对于sort()排序算法的使用取决于数组长度。以下为官方源码的第239行到254行：

function InnerArraySort(array, length, comparefn) {
    // In-place QuickSort algorithm.
    // For short (length <= 10) arrays, insertion sort is used for efficiency.
    if (!IS_CALLABLE(comparefn)) {
        comparefn = function (x, y) {
        if (x === y) return 0;
        if (%_IsSmi(x) && %_IsSmi(y)) {
            return %SmiLexicographicCompare(x, y);
        }
        x = TO_STRING(x);
        y = TO_STRING(y);
        if (x == y) return 0;
        else return x < y ? -1 : 1;
        };
};

代码中的注释明确写着：
这个地方使用快速排序，但是当长度小于11的数组，使用的是插入排序。
从算法性能来看，这样安排是合理的：因为插入排序在数组长度小于一定值的时候是会比快速排序速度更快，快速排序在大规模数据的时候更有优势。插入排序是稳定的，快速排序是不稳定的。

这么安排确实很独到，但是由于快速排序的特性，会存在一个隐藏的问题：
当进行数组长度大于10的不区分大小写字母排序时，快速排序就会出现同一字母的大小写之间顺序错乱的问题，这种情况其他大部分排序算法都会默认按照原先顺序排列，而快速排序就会出现不稳定的乱序。请看以下的例子：

var arr = ['Z','A','e','V','I','n','a','E','A','A','n'];

arr.sort(function(a, b){
    var x = a.toLowerCase(), y = b.toLowerCase();
    return x < y ? -1 : x > y ? 1 : 0;
});
console.log(arr);


——————OUTPUT——————
[ 'A', 'a', 'A', 'A', 'e', 'E', 'I', 'n', 'n', 'V', 'Z' ]

正常输出应该是AaAA的顺序，可以看到下图中牛客网的Google V8 6.0.0环境下实际输出是AAaA。

首先说明这个问题在7.0.0内核版本以上算法更新后就不存在这个问题了。

有一起研究算法的可以再看我另一篇博客，其中会有详细的解决方案：

【JavaScript笔记 · 特殊篇】Array.sort()方法在Google V8 6.0.0环境下存在的同值乱序BUG的详细解决方法