js常用技巧一

r囧r小猫 2022-02-05 06:59 202阅读 0赞

> **小编推荐：[Fundebug][]提供JS错误监控、微信小程序错误监控、微信小游戏错误监控，Node.j错误监控和Java错误监控。真的是一个很好用的错误监控费服务，众多大佬公司都在使用。**

## 目录 ##

### 一.JS中判断字符串中出现次数最多的字符及出现的次数 ###

### 二.JS数组去重 ###

### 三.类的继承 ###

### 四.排序算法 ###

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

一.JS中判断字符串中出现次数最多的字符及出现的次数

### 二.JS数组去重 ###

**方法1：简单粗暴的ES6方法Set，Set数据结构，它类似于数组，其成员的值都是唯一的。**  
Set对象用于存储唯一值，无论是值类型还是引用类型。但是使用new Set后将返回Set实例，而Set本身只是一个集合类的对象，并非数组，所以如果使用此方法去重后没办法继续使用数组本身的方法，如map, reduce, filter, indexOf等，因此，建议在使用new Set去重后将其转化为数组。

var arr = [1, 2, 3, 2, 1, 3];
    console.log(Array.from(new Set(arr)))//打印结果：Set(3) {1, 2, 3}

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

var arr = [];
    (new Set([1, 2, 3, 1, 2, 3, 4, 6])).forEach(v => { arr.push(v) })

**方法2：使用filter过滤函数去重。**

var arr = [1, 2, 3, 2, 1, 3];
    console.log(arr.filter((v, i, arr) => arr.indexOf(v) === i))//打印结果：(3) [1, 2, 3]

**方法3：遍历数组法。**  
实现的思路：新建一个数组，遍历传入的数组，值不在新数组中就加入到该新数组；  
`注意`：判断值是否在数组中可以用indexOf是ES5 方法，IE9以下不支持，需兼容低版本浏览器。

function unique(array) {
           var n = []; //一个新的临时数组 
            //遍历当前数组 
            for (var i = 0; i < array.length; i++) {
                if (n.indexOf(array[i]) == -1) n.push(array[i]);
                //如果当前数组的第i已经保存进了临时数组，那么跳过， 
                //否则把当前项push到临时数组里面 
            }
            return n;
        }
     console.log(unique([1, 2, 3, 1, 2, 3])) //打印结果：(3) [1, 2, 3]

解决indexOf的兼容方法：

原生JS兼容：

if (!Array.prototype.indexOf) {
        Array.prototype.indexOf = function (el) {
            for (var i = 0, n = this.length; i < n; i++) {
                if (this[i] === el) {
                    return i;
                }
            }
            return -1;
        }
    }

用Jquery中inArray方法兼容：

if ($.inArray(randIndex, appearAnimals) == -1) {}

**方法4：利用splice()方法直接在原数组进行操作。**  
双层循环，外层循环元素，内层循环时比较值。

值相同时，则删去这个值。

`注意`:删除元素之后，需要将数组的长度也减1。

优点：简单易懂。

缺点：占用内存高，速度慢。

Array.prototype.unique = function () {
        var arr = this,
            i,
            j,
            len = arr.length;
        for (i = 0; i < len; i++) {
            for (j = i + 1; j < len; j++) {
                if (arr[i] == arr[j]) {
                    arr.splice(j, 1);
                    len--;
                    j--;
                }
            }
        }
        return arr;
    };
    var a = [1, 2, 3, 1, 2, 3];
    var b = a.unique();
    console.log(b); //打印结果：(3) [1, 2, 3]

**方法5：利用对象的属性不能相同的特点进行去重**

Array.prototype.unique = function () {
        var arr = this,
            i,
            obj = {},
            result = [],
            len = arr.length;
        for (i = 0; i < arr.length; i++) {
            if (!obj[arr[i]]) { //如果能查找到，证明数组元素重复了
                obj[arr[i]] = 1;
                result.push(arr[i]);
            }
        }
        return result;
    };
    var a = [1, 2, 3, 1, 2, 3];
    var b = a.unique();
    console.log(b); //打印结果：(3) [1, 2, 3]

**方法6：数组递归去重**

Array.prototype.unique = function () {
        var arr = this,
            len = arr.length;
        arr.sort(function (a, b) { //对数组进行排序才能方便比较
            return a - b;
        })
    
        function loop(index) {
            if (index >= 1) {
                if (arr[index] === arr[index - 1]) {
                    arr.splice(index, 1);
                }
                loop(index - 1); //递归loop函数进行去重
            }
        }
        loop(len - 1);
        return arr;
    };
    var a = [1, 2, 3, 1, 2, 3];
    var b = a.unique();
    console.log(b); //打印结果：(3) [1, 2, 3]

待续。。。

作者：我跟你蒋  
链接：https://www.jianshu.com/p/c3225aa8d28e

[Fundebug]: https://www.fundebug.com/