javascript中sort()排序的一些理解

sort()方法对一个数组进行排序，并可以接受一个比较函数，最后返回一个排序的数组。

1.sort()有自身默认的比较函数，该函数把排序的元素都看作字符串。

var s = [5, 4, 3, 2, 1];
s.sort();
console.log(s);
//=>[ 1, 2, 3, 4, 5 ]

改变排序数组：

var s = [2, 4, 5, 1, 12, 3, 13];
s.sort();
console.log(s);
//=>[ 1, 12, 13, 2, 3, 4, 5 ]

明显地，大多数情况下sort()方法不能得到理想排序的数组。但是，可以通过为sort()方法传入不同的比较函数，以得到合适的排序结果。

2.为sort()方法传入新的比较函数。

var s = [2, 4, 5, 1, 12, 3, 13];
s.sort(function(a, b) {
    return a - b;
});
console.log(s);
//=>[ 1, 2, 3, 4, 5, 12, 13 ]

其中，比较函数接受两个参数a，b。当比较函数返回0时，表示a=b；返回正数时，表示a>b；返回负数时，表示a<b。

当然，以下方式也有相同的效果：

var s = [2, 4, 5, 1, 12, 3, 13];
s.sort(function(a, b) {
    if(a == b)
        return 0;
    else 
        return a < b ? -1 : 1;
});
console.log(s);
//=>[ 1, 2, 3, 4, 5, 12, 13 ]

再次改变排序数组，其包含不止一种数据：

var s = [2, 4, 5, 'b', 1, 'a', 12, 3, 13];
s.sort(function(a, b) {
    return a - b;
});
console.log(s);
//=>[ 2, 4, 5, 'b', 1, 'a', 3, 12, 13 ]

数组再次变得杂乱无章，因此，可以再修改比较函数，以达到预期效果。

3.使sort()适用于简单数据类型的数组排序。

var s = [2, 4, 5, 'b', 1, 'a', 12, 3, 13];
s.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;　　//确定不同类型数据的先后顺序，此例为Number在前，String在后
});
console.log(s);
//=>[ 1, 2, 3, 4, 5, 12, 13, 'a', 'b' ]

由本例可知，可先对传入参数进行类型判断，再进行排序，即可以得到一定排序方式的结果。

同样地，通过比较函数，我们可以对对象数组进行排序。

4.用sort()方法排序对象数组。

var s = [
    {'year': 1993, 'sex': 'man', 'name': '张三'},
    {'year': 1992, 'sex': 'woman', 'name': '李红'},
    {'year': 1991, 'sex': 'man', 'name': '赵四'},
    {'year': 1993, 'sex': 'woman', 'name': '吴用'}
];
var byRule = function(rule) {
    return function(a, b) {
        var i, j;
        if(typeof a === 'object' && typeof b === 'object') {
            i = a[rule];
            j = b[rule];
            if(i === j)
                return 0;
            if(typeof i === typeof j) {
                return i < j ? -1 : 1;
            }
            return typeof i < typeof j ? -1 : 1;
        }
    };
};
s.sort(byRule('year'));
console.log(s);
//=>[ { year: 1991, sex: 'man', name: '赵四' },
      { year: 1992, sex: 'woman', name: '李红' },
      { year: 1993, sex: 'man', name: '张三' },
      { year: 1993, sex: 'woman', name: '吴用' } ]

先定义了一个函数byRule，该函数返回一个排序函数，从而可以通过传入不同的排序规则至byRule函数来得到不同的排序函数。

观察26，27行代码，其中year相同：

26       { year: 1993, sex: 'man', name: '张三' },
27       { year: 1993, sex: 'woman', name: '吴用' } ]

可以再对byRule函数添加一个参数，使得第一个键值已派序时，对相同的元素进行下一个键值对的排序：

var s = [
    {'year': 1993, 'sex': 'man', 'name': '张三'},
    {'year': 1992, 'sex': 'woman', 'name': '李红'},
    {'year': 1991, 'sex': 'man', 'name': '赵四'},
    {'year': 1993, 'sex': 'woman', 'name': '吴用'}
];
var byRule = function(rule, next) {
    return function(a, b) {
        var i, j;
        if(typeof a === 'object' && typeof b === 'object') {
            i = a[rule];
            j = b[rule];
            if(i === j)
                return typeof next === 'function' ? next(a, b) : 0 ;　　//第一对键值相同时，继续比较第二对键值
            if(typeof i === typeof j) {
                return i < j ? -1 : 1;
            }
            return typeof i < typeof j ? -1 : 1;
        }
    };
};
s.sort(byRule('year', byRule('name')));　　　　//byRule函数接受两个参数，第二个参数为一个函数
console.log(s);
//=>[ { year: 1991, sex: 'man', name: '赵四' },
      { year: 1992, sex: 'woman', name: '李红' },
      { year: 1993, sex: 'woman', name: '吴用' },　　　　　　　　　　　　
      { year: 1993, sex: 'man', name: '张三' } ]

与上例对比，26，27行的顺序已改变。

5.讨论一下sort()的排序方式。

本例测试在sublime text 3 中进行。

• 当排序数组元素不大于10个时：

var s = [10, 9, 8, 7, 6, 5, 4, 3, 2, 1];
s.sort(function(a, b) {
    if(a == b) {
        console.log(a + "=" + b);
        return 0;
    }
    if(a < b) {
        console.log(a + "<" + b);
        return -1;
    }
    if(a > b) {
        console.log(a + ">" + b);
        return 1;
    }
});
console.log(s);

结果：

10>9
10>8
9>8
10>7
9>7
8>7
10>6
9>6
8>6
7>6
10>5
9>5
8>5
7>5
6>5
10>4
9>4
8>4
7>4
6>4
5>4
10>3
9>3
8>3
7>3
6>3
5>3
4>3
10>2
9>2
8>2
7>2
6>2
5>2
4>2
3>2
10>1
9>1
8>1
7>1
6>1
5>1
4>1
3>1
2>1
[ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]

可见，其排序方式为典型的插入排序。

• 当排序数组元素为11个（或11个以上）时：

var s = [11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1];
s.sort(function(a, b) {
    if(a == b) {
        console.log(a + "=" + b);
        return 0;
    }
    if(a < b) {
        console.log(a + "<" + b);
        return -1;
    }
    if(a > b) {
        console.log(a + ">" + b);
        return 1;
    }
});
console.log(s);

结果：

11>1
1<6
11>6
9>6
2<6
8>6
3<6
7>6
4<6
10>6
5<6
1<2
2<3
3<4
4<5
10>7
10>8
7<8
10>9
8<9
10<11
[ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 ]

可见，其排序方式为快速排序。

-------------------------------------------------------------------------------------------------------

注：本文为个人学习随笔，仅供个人学习使用，如有雷同，纯属巧合，敬请原谅！