数组乱序、数组去重、filter实现

数组乱序

function shuffle(arr) {
    // 1.随机找一个元素与最后一个元素交换
    // 2.随机找一个除最后一个元素的元素与最后一个元素交换
    // 3.以此类推
    let len = arr.length;
    while (len) {
        const randomIndex = Math.floor(Math.random() * len--);
        // 交换
        let temp = arr[randomIndex];
        arr[randomIndex] = arr[len];
        arr[len] = temp;
    }
}

数组去重

function removeDup(arr) {
    const result = [];
    const map = new Set();
    // 1.遍历arr，存进hashMap,后续比较看是否存在
    for (let i = 0; i < arr.length; i++) {
        // 2.不存在就push
        if (!map.has(arr[i])) {
            map.add(arr[i]);
            result.push(arr[i]);
        } // 3.存在就过
    }
    return result;
}

用对象去重，不推荐(‘1’ 和 1 会重复)

function removeDup(arr) {
    const result = [];
    const map = {};
    // 1.遍历arr，存进hashMap,后续比较看是否存在
    for (let i = 0; i < arr.length; i++) {
        // 2.不存在就push
        if (!map[arr[i]]) {
            map[arr[i]] = true;
            result.push(arr[i]);
        } // 3.存在就过
    }
    return result;
}

利用数组indexOf去重

// 利用数组indexOf去重
function removeDup2(arr) {
    const newArray = [];
    const n = arr.length;
    for (let i = 0; i < n; i++) {
        const current = arr[i];
        if (newArray.indexOf(current) === -1) {
            newArray.push(current);
        }
    }

    return newArray;
}

用filter函数实现

// 利用filter去重
function removeDup3(arr) {
    return arr.filter((item, index) => {
        return arr.indexOf(item) === index;
    });
}

filter实现

Array.prototype.filter = function(callback, thisArg) {
    if (typeof callback !== 'function') {
        throw new TypeError(`${callback} is not a fucntion`);
    }

    let arr = this;
    let result = [];
    for (let i = 0; i < arr.length; i++) {
        const that = thisArg || this;
        const temp = callback.call(that, arr[i], i, arr);
        if (temp) {
            result.push(arr[i]);
        }
    }
    return result;
}