都是血的教訓(xùn)啊，為什么沒早點(diǎn)刷點(diǎn)面試題......

數(shù)組扁平化

1. 遞歸

    const flatten1 = (arr) => {
        let temp = [];
        for(let item of arr) {
            if(item instanceof Array) {
                temp = [...temp, ...(fn1(item))];
            } else {
                temp.push(item)
            }
        }
        return temp;
    }

2. toString()和split()

    let arr1 = [1, 2, [3, [4, [5, 6, 7, 'haha', 8]], [9, 10, [11, 12]]]]
    const flatten2 = (arr) => {
        let str = arr.toString();
        return str.split(',')
    }
    console.log(flatten2(arr1))
    // [ '1', '2', '3', '4', '5', '6', '7', 'haha', '8', '9', '10', '11', '12' ]
    // 可以看出來這種方法的缺陷在于把所有的元素都變成string了

3. reduce

    const flatten3 = (arr) => {
        return arr.reduce((previous, current) => {
            return previous.concat(Array.isArray(current) ? fn3(current) : current)
        }, []);
    }

4. concat結(jié)合解構(gòu)

    const flatten4 = (arr) => {
        while(arr.some(item => Array.isArray(item))) {
            arr = [].concat(...arr); // 這里其實(shí)相當(dāng)于給concat傳了多個(gè)參數(shù)，如果是數(shù)組的參數(shù)就解構(gòu)
        }
        return arr;
    }

數(shù)組去重

1. indexOf

這種方法在使用時(shí)，每一個(gè)元素都要使用indexOf去判斷一下，這就依賴于indexOf的效率了，如果indexOf是遍歷res數(shù)組的話，那么效率就是O(n)，整體就是O(n^2)

    let array = [1, 1, '1'];

    const unique1 = (array) => {
        var res = [];
        for (let i = 0, len = array.length; i < len; i++) {
            var current = array[i];
            if (res.indexOf(current) === -1) {
                res.push(current)
            }
        }
        return res;
    }

    console.log(unique1(array));

2. 排序后去重

取決于排序的效率，如果采用內(nèi)置的sort可以達(dá)到O(nlogn)

    const unique2 = (array) => {
        var res = [];
        var sortedArray = array.concat().sort();
        var pre; // pre存儲(chǔ)著前一項(xiàng)的值
        for (var i = 0, len = sortedArray.length; i < len; i++) {
            // 如果是第一個(gè)元素或者相鄰的元素不相同
            if (!i || pre !== sortedArray[i]) {
                res.push(sortedArray[i])
            }
            pre = sortedArray[i];
        }
        return res;
    }

3. 利用filter

    const unique3 = (arr) => {
        return arr.filter((item, index, array) => {
            return arr.indexOf(item) === index; // 此處可以保證是第一次出現(xiàn)的
        })
    }

    const unique4 = (arr) => {
        return arr.concat().sort().filter((item, index, array) => {
            return !index || item != array[index - 1];
        })
    }

4. 利用map鍵值對(duì)

    
    const unique5 = (array) => {
        var obj = {};
        return array.filter(function(item, index, array){
            return obj.hasOwnProperty(item) ? false : (obj[item] = true)
        })
    }

    // 缺陷在于對(duì)于[1, '1', 2, '2']這種會(huì)判斷失誤，但是可以通過優(yōu)化來解決

5. Set

    const unique6 = (array) => {
        return [...new Set(array)];
    }

找出缺少的數(shù)組項(xiàng)

一個(gè)數(shù)組length = 99,里面的數(shù)組項(xiàng)是1~100的值，且無重復(fù)，找出缺少的那一個(gè)值

    const fn = arr => {
        const sum = (1 + 100) * 50;
        let sum1 = 0;
        for(let num of arr) {
            sum1 += num;
        }
        return sum - sum1;  // 利用求和來求得缺少的那個(gè)值
    }


    const fn1 = arr => {
        let res = arr[0];
        for(let i = 1; i < arr.length; i++) {
            res = res ^ arr[i];
        }
        for(let i = 1; i <= 100; i++) {
            res = res ^ i;
        }
        // 利用異或運(yùn)算來求
        return res;
    }

    // 創(chuàng)建hash表，初始值都為0，遍歷數(shù)組，出現(xiàn)的數(shù)字將hash表中的值改為1，再遍歷一遍hash表，找出值為0的就是缺少的值

如果length = 98，找出缺少的兩個(gè)

    // hash表

更好的辦法是將各個(gè)數(shù)組項(xiàng)歸位，詳細(xì)代碼下班后再寫。