JavaScript去重和排序

使用数组的indexOf()方法可以很简单的达到目的。

Array.prototype.unique = function() {
    // 创建一个新的临时数组，用于保存输出结果
    var n = []; 
    // 遍历当前数组
    for (var i = 0; i < this.length; i++) {
        // 如果当前数组的第i个元素已经保存进了临时数组，那么跳过，否则把当前项push到临时数组里面
        if (n.indexOf(this[i]) === -1) n.push(this[i]);
    }
    return n;
}
var a = [1,3,5,4,3,3,1,4];
console.log(a.unique())

再列出一个变换一点的方式。

Array.prototype.unique = function() {
    // 创建一个新的临时数组，并且把当前数组的第一元素存入到数组中
    var n = [this[0]]; 
    // 从第二项开始遍历
    for (var i = 1; i < this.length; i++) 
    {
        // 如果当前数组的第i项在当前数组中第一次出现的位置不是i，那么表示第i项是重复的，忽略掉，否则存入结果数组
        if (this.indexOf(this[i]) === i) n.push(this[i]);
    }
    return n;
}
var a = [1,3,5,4,3,3,1,4];
console.log(a.unique())

JS引擎在实现indexOf()的时候会遍历数组直到找到目标为止，此函数会浪费掉很多时间。所有这两种方式都不是最优的解决方式。

es6

1.
Array.prototype.unique = function() {
    return this.filter((v, i) => this.indexOf(v) === i)
}
var a = [1,3,5,4,3,3,1,4];
console.log(a.unique())
2.
Array.prototype.unique = function() {
    return Array.from(new Set(this));
}
var a = [1,3,5,4,3,3,1,4];
console.log(a.unique())

3. 
[...new Set([1,1,2,3,4,5,5,5,1])]

[1,1,2,3,4,5,5,5,1].filter(function(ele,index,array){
    return index === array.indexOf(ele)
 })

把已经出现过的元素通过下标的形式存入一个Object内。下标的引用的实现原理利用的是哈希算法，要比用indexOf()搜索数组快的多。

Array.prototype.unique = function() {
    // n为hash表，r为临时数组
    var n = {}, r = [];
    for (var i = 0; i < this.length; i++) {
        // 如果hash表中没有当前项
        if (!n[this[i]]) {
            // 存入hash表
            n[this[i]] = true;
            // 把当前数组的当前项push到临时数组里面
            r.push(this[i]); 
        }
    }
    return r;
}
var a = [1,3,5,4,3,3,1,4];
console.log(a.unique())

但从耗时的角度来讲，这是最优的一种解决方式。但是从内存占用角度来说，这并不是最优的，因为多了一个hash表。这就是所谓的空间换时间

sort() 排序

var arr = [-4,1,3,18,12,22,9]
arr.sort()
console.log(arr) //[-4, 1, 12, 18, 22, 3, 9] 这是为什么呢。

var arr = [-4,1,3,18,12,22,9]
arr.sort(function(a,b){
 return a -b 
//return b-a
})
console.log(arr)

var students = [
  {name:'c',age:'14'},
  {name:'d',age:'11'},
  {name:'a',age:'12'},
  {name:'z',age:'20'},
  {name:'g',age:'7'},
]
//age排序
students.sort(function (s1, s2) {
    return s2.age - s1.age //从大到小
    //return s1.age - s2.age //从小到大
})
console.log(students)


//name排序
```bash
students.sort(function (s1, s2) {
    if (s1.name > s2.name) {
        return 1
    } else {
        return -1
    }
})
console.log(students)
/*[
  { name: 'a', age: '12' },
  { name: 'c', age: '14' },
  { name: 'd', age: '11' },
  { name: 'g', age: '7' },
  { name: 'z', age: '20' } 
]*/

这个方法的思路是先把数组排序，然后比较相邻的两个值。排序的时候用的JS原生的sort()方法，JS引擎内部应该是用的快速排序吧。