常用的關於數組數據的處理方法

 //1.js連接兩個數組
    var ArrayConcat = function ArrayConcat(arr) {
        var _ref;
        for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
            args[_key - 1] = arguments[_key];
        }

        return (_ref = []).concat.apply(_ref, [arr].concat(args));
    };
    //    console.log(ArrayConcat([1,4,7], [1, 2, 3, [4]],[8,9,[0]]));//[1,4,7,1,2,3,[4],8,9,[0]]
    //    console.log([1,4,7].concat([1,2,3,[4]],[8,9,[0]])); //[1,4,7,1,2,3,[4],8,9,[0]]


    //2.從b創建一個Set，然后在a上使用Array.filter（）僅保留b中不包含的值。
    var difference = function difference(a, b) {
        var s = new Set(b);
        return a.filter(function (x) {
            return !s.has(x);
        });
    };
    //    console.log(difference([1, 2, 3], [1, 2])); //[3]
    function kk(age) {
        return age >= 3;
    }
    //    console.log([1,2,3].filter(kk)); //[3]

    //3.使用slice（）來偏移數組/字符串和indexOf（）以檢查是否包含該值。 省略最后一個參數fromIndex，檢查整個數組/字符串。
    var includes = function includes(collection, val) {
        var fromIndex = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
        return collection.slice(fromIndex).indexOf(val) != -1;
    };
    //    console.log(includes("i-love-China","China")); //true
    //    console.log(includes("[1,2,3,4]","[")); //true


    //4.從b創建一個Set，然后在a上使用Array.filter（）僅保留b中包含的值。
    var intersection = function intersection(a, b) {
        var s = new Set(b);
        return a.filter(function (x) {
            return s.has(x);
        });
    };
    //console.log(intersection([1,2,3,4],[3,4,5,6])); //[3,4]

    //5.使用Array.filter（）查找返回truthy值的數組元素和使用Array.splice（）刪除元素的Array.reduce（）。 使用三個參數（value，index，array）調用func。
    var remove = function remove(arr, func) {
        return Array.isArray(arr) ? arr.filter(func).reduce(function (acc, val) {
                arr.splice(arr.indexOf(val), 1);
                return acc.concat(val);
            }, []) : [];
    };
    function cc(n) {
        return n % 2 == 0;
    }
    //    console.log(remove([2,3,4,5,6],cc));//[2,4,6]

    //6.使用Math.random（）生成一個隨機數，將其與長度相乘，並使用Math.floor（）將其四舍五入到最接近的整數。 此方法也適用於字符串。
    var sample = function sample(arr) {
        return arr[Math.floor(Math.random() * arr.length)];
    };
    // console.log(sample([23,45,67,6,78]));//78

    //7.使用a和b的所有值創建一個Set並轉換為數組。
    //es6
    //const union = (a, b) => Array.from(new Set([...a, ...b]));
    function _toConsumableArray(arr) {
        return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread();
    }

    function _nonIterableSpread() {
        throw new TypeError("Invalid attempt to spread non-iterable instance");
    }

    function _iterableToArray(iter) {
        if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter);
    }

    function _arrayWithoutHoles(arr) {
        if (Array.isArray(arr)) {
            for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) {
                arr2[i] = arr[i];
            }
            return arr2;
        }
    }

    var union = function union(a, b) {
        return Array.from(new Set([].concat(_toConsumableArray(a), _toConsumableArray(b))));
    };

    //   console.log(union([1,2,3,4,5],[3,4,5,6,8])); //[1,2,3,4,5,6,8]

    //8.使用Array.filter（）創建一個排除所有給定值的數組。
    //es6
    //const without = (arr, ...args) => arr.filter(v => args.indexOf(v) === -1);
    var without = function without(arr) {
        for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
            args[_key - 1] = arguments[_key];
        }

        return arr.filter(function (v) {
            return args.indexOf(v) === -1;
        });
    };
    //console.log(without([2,2,3,5,7],2,5)); //[3,7]

    //9.使用Math.max.apply（）獲取參數中最長的數組。 創建一個長度為返回值的數組，並使用帶有map-function的Array.from（）創建一個分組元素數組。 如果參數數組的長度不同，則在未找到值的情況下使用undefined。
    var zip = function zip() {
        for (var _len = arguments.length, arrays = new Array(_len), _key = 0; _key < _len; _key++) {
            arrays[_key] = arguments[_key];
        }

        var maxLength = Math.max.apply(null, arrays.map(function (a) {
            return a.length;
        }));
        return Array.from({
            length: maxLength
        }).map(function (_, i) {
            return Array.from({
                length: arrays.length
            }, function (_, k) {
                return arrays[k][i];
            });
        });
    };
    //console.log(zip(['a','b','c'],[0,1,2],[true,false])); //[['a','0',true],['b',1,false],['c',2,undefined]]

    //10.使用Array.reduce（）將每個值添加到累加器，使用值0初始化，除以數組的長度。
    var average = function average(arr) {
        return arr.reduce(function (acc, val) {
                return acc + val;
            }, 0) / arr.length;
    };
    //console.log(average([4,5,6,7,8,9]));  //6.5

    //11.使用Array.from（）創建一個新數組，該數組符合將生成的塊數。 使用Array.slice（）將新數組的每個元素映射到一個大小的塊。 如果原始數組無法均勻分割，則最終的塊將包含其余元素。
    var chunk = function chunk(arr, size) {
        return Array.from({
            length: Math.ceil(arr.length / size)
        }, function (v, i) {
            return arr.slice(i * size, i * size + size);
        });
    };
    //console.log(chunk([1,2,3,4,5,6,7,8],3)); //[[1,2,3],[4,5,6],[7,8]];

    //12.使用Array.filter（）過濾掉falsey值（false，null，0，“”，undefined和NaN）。
    var compact = function compact(arr) {
        return arr.filter(function (v) {
            return v;
        });
    };
    //console.log(compact([0,1,false,3,'23',NaN,'lla',45])); //[1, 3, "23", "lla", 45]

    //13.每次遇到數組內的特定值時，使用Array.reduce（）遞增計數器。
    var countOccurrences = function countOccurrences(arr, value) {
        return arr.reduce(function (a, v) {
            return v === value ? a + 1 : a + 0;
        }, 0);
    };
    //console.log(countOccurrences([2,4,5,2,5,2,4,8],2)); //3

    //14.使用遞歸。 將Array.concat（）與空數組（[]）和擴展運算符（...）一起使用以展平數組。 遞歸地展平作為數組的每個元素。
    //ES6
    //const deepFlatten = arr => [].concat(...arr.map(v => Array.isArray(v) ? deepFlatten(v) : v));
    function _toConsumableArray(arr) {
        return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread();
    }

    function _nonIterableSpread() {
        throw new TypeError("Invalid attempt to spread non-iterable instance");
    }

    function _iterableToArray(iter) {
        if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter);
    }

    function _arrayWithoutHoles(arr) {
        if (Array.isArray(arr)) {
            for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) {
                arr2[i] = arr[i];
            }
            return arr2;
        }
    }

    var deepFlatten = function deepFlatten(arr) {
        var _ref;

        return (_ref = []).concat.apply(_ref, _toConsumableArray(arr.map(function (v) {
            return Array.isArray(v) ? deepFlatten(v) : v;
        })));
    };
    // console.log(deepFlatten([1,[2],[[3],4],5])); //[1, 2, 3, 4, 5]

    //15.循環遍歷數組，使用Array.shift（）刪除數組的第一個元素，直到函數返回的值為true。 返回剩余的元素。
    var dropElements = function dropElements(arr, func) {
        while (arr.length > 0 && !func(arr[0])) {
            arr.shift();
        }

        return arr;
    };
    function cc1(n) {
        return n >= 3;
    }
    //console.log(dropElements([2,3,4,5,6],cc1)); //[3,4,5,6]

    //16.使用Array.map（）將start（包含）和end（不包括）之間的值映射到value。 省略開始從第一個元素開始和/或結束到最后一個結束。
    //理解：
    //數組[1,2,3,4]對應i 0，1，2，3；如果滿足1=<i<3，就使用“8”對應，否則原值輸出
    var fillArray = function fillArray(arr, value) {
        var start = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
        var end = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : arr.length;
        return arr.map(function (v, i) {
            return i >= start && i < end ? value : v;
        });
    };
    //console.log(fillArray([1,2,3,4],'8',1,3));//[1,'8','8',4]

    //17.將Array.filter（）用於僅包含唯一值的數組。
    var filterNonUnique = function filterNonUnique(arr) {
        return arr.filter(function (i) {
            return arr.indexOf(i) === arr.lastIndexOf(i);
        });
    };
    //console.log(filterNonUnique([1,1,2,2,3,3,3,5,6,8]));//[5,6,8]

    //18.使用遞歸，每個深度級別將深度遞減1。 使用Array.reduce（）和Array.concat（）來合並元素或數組。 基本情況，深度等於1停止遞歸。 省略第二個元素，深度僅變平至1（單個展平）。
    var flattenDepth = function flattenDepth(arr) {
        var depth = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
        return depth != 1 ? arr.reduce(function (a, v) {
                return a.concat(Array.isArray(v) ? flattenDepth(v, depth - 1) : v);
            }, []) : arr.reduce(function (a, v) {
                return a.concat(v);
            }, []);
    };
    //console.log(flattenDepth([1,[2],[[[3],4],5]], 2));//[1,2,[3],4,5]

    //19.使用Array.reduce（）獲取數組中的所有元素，並使用concat（）來展平它們。
    var flatten = function flatten(arr) {
        return arr.reduce(function (a, v) {
            return a.concat(v);
        }, []);
    };
    //console.log(flatten([1,[2],3,4,[5,6,[7,8,9],10]]));//[1, 2, 3, 4, 5, 6, [7,8,9], 10]
    //console.log(flatten([1,[2],3,4,[5,6,7,8,9,10]]));//[1,2,3,4,5,6,7,8,9,10]

    //20.使用Math.max（）結合擴展運算符（...）來獲取數組中的最大值。
    //ES6
    //const arrayMax = arr => Math.max(...arr);
    function _toConsumableArray(arr) {
        return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread();
    }

    function _nonIterableSpread() {
        throw new TypeError("Invalid attempt to spread non-iterable instance");
    }

    function _iterableToArray(iter) {
        if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter);
    }

    function _arrayWithoutHoles(arr) {
        if (Array.isArray(arr)) {
            for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) {
                arr2[i] = arr[i];
            }
            return arr2;
        }
    }

    var arrayMax = function arrayMax(arr) {
        return Math.max.apply(Math, _toConsumableArray(arr));
    };
    //console.log(arrayMax([3,4,5,8,10]));//10

    //21.使用Math.min（）結合擴展運算符（...）來獲取數組中的最小值。
    function _toConsumableArray(arr) {
        return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread();
    }

    function _nonIterableSpread() {
        throw new TypeError("Invalid attempt to spread non-iterable instance");
    }

    function _iterableToArray(iter) {
        if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter);
    }

    function _arrayWithoutHoles(arr) {
        if (Array.isArray(arr)) {
            for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) {
                arr2[i] = arr[i];
            }
            return arr2;
        }
    }

    var arrayMin = function arrayMin(arr) {
        return Math.min.apply(Math, _toConsumableArray(arr));
    };
    //console.log(arrayMin([3,4,5,8,10])); //3

    //22.使用Array.map（）將數組的值映射到函數或屬性名稱。 使用Array.reduce（）創建一個對象，其中的鍵是從映射結果生成的。
    var groupBy = function groupBy(arr, func) {
        return arr.map(typeof func === 'function' ? func : function (val) {
                return val[func];
            }).reduce(function (acc, val, i) {
            acc[val] = (acc[val] || []).concat(arr[i]);
            return acc;
        }, {});
    };
    //console.log(groupBy([6.1, 4.2, 6.3], Math.floor));//{4: [4.2], 6: [6.1, 6.3]}

    //23.使用arr [0]返回傳遞的數組的第一個元素。
    var head = function head(arr) {
        return arr[0];
    };
    //console.log(head([3,4,5,6,7])); //3

    //24.使用arr.slice（0，-1）返回除數組的最后一個元素之外的所有元素。
    var initial = function initial(arr) {
        return arr.slice(0, -1);
    };
    //console.log(initial([1,3,5,7,9]));//[1, 3, 5, 7]

    //25.使用Array（end-start）創建所需長度的數組Array.map（）以填充范圍內的所需值。 您可以省略start以使用默認值0。
    var initializeArrayRange = function initializeArrayRange(end) {
        var start = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
        return Array.apply(null, Array(end - start)).map(function (v, i) {
            return i + start;
        });
    };
    //console.log(initializeArrayRange(6));//[0, 1, 2, 3, 4, 5]

    //26.使用Array（n）創建所需長度的數組，fill（v）以使用所需的值填充它。 您可以省略值以使用默認值0。
    var initializeArray = function initializeArray(n) {
        var value = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
        return Array(n).fill(value);
    };
    // console.log(initializeArray(7,5));//[5,5,5,5,5,5,5]

    //27.使用arr.slice（-1）[0]獲取給定數組的最后一個元素。
    var last = function last(arr) {
        return arr.slice(-1)[0];
    };
    //console.log(last([1,2,3,4,5])); //5

    //28.找到數組的中間部分，使用Array.sort（）對值進行排序。 如果長度為奇數，則返回中點處的數字，否則返回兩個中間數字的平均值。
    var median = function median(arr) {
        var mid = Math.floor(arr.length / 2),
            nums = arr.sort(function (a, b) {
                return a - b;
            });
        return arr.length % 2 !== 0 ? nums[mid] : (nums[mid - 1] + nums[mid]) / 2;
    };
    //console.log(median([-3,4,-2,0,4,7])); //2
    //console.log(median([-3,4,-2,0,4,7,2.5]));//2.5

    //29.使用Array.slice（）獲取包含第一個元素的第n個元素的數組。 如果索引超出范圍，則返回[]。 省略第二個參數n，得到數組的第一個元素。
    var nth = function nth(arr) {
        var n = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
        return (n > 0 ? arr.slice(n, n + 1) : arr.slice(n))[0];
    };
    //console.log(nth([2,3,4,5,6]));//2
    //console.log(nth([2,3,4,5,6],3));//5

    //30.如果obj中存在鍵，則使用Array.reduce（）將過濾/拾取的鍵轉換回具有相應鍵：值對的對象。
    var pick = function pick(obj, arr) {
        return arr.reduce(function (acc, curr) {
            return curr in obj && (acc[curr] = obj[curr]), acc;
        }, {});
    };
    //console.log(pick({ 'a': 1, 'b': '2', 'c': 3 }, ['a', 'c']));//{a: 1, c: 3}
    //console.log(pick({'a':1}, ['a', 'c']));//{a: 1}

    //31.使用Array.sort（）在比較器中使用Math.random（）重新排序元素。
    var shuffle = function shuffle(arr) {
        return arr.sort(function () {
            return Math.random() - 0.5;
        });
    };
    //console.log(shuffle([4,5,6,7,8,9])); //[5, 4, 7, 8, 9, 6] 隨機數不固定

    //32.使用filter（）刪除不屬於值的值，使用includes（）確定。
    var similarity = function similarity(arr, values) {
        return arr.filter(function (v) {
            return values.includes(v);
        });
    };
    //console.log(similarity([3,4,5,6,7,8],[6,7,8,9,0]));//[6,7,8]

    //33.使用Array.reduce（）將每個值添加到累加器，使用值0初始化。
    var sum = function sum(arr) {
        return arr.reduce(function (acc, val) {
            return acc + val;
        }, 0);
    };
    //console.log(sum([3, 4, 5, 6, 7]));//25

    //34.如果數組的長度大於1，則返回arr.slice（1），否則返回整個數組。
    var tail = function tail(arr) {
        return arr.length > 1 ? arr.slice(1) : arr;
    };
    //console.log(tail([2,3,4,5]));//[3,4,5]
    //console.log(tail([2]));//[2]

    //35.使用Array.slice（）創建一個數組切片，其中包含從末尾獲取的n個元素。
    var takeRight = function takeRight(arr) {
        var n = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
        return arr.slice(arr.length - n, arr.length);
    };
    //console.log(takeRight([1, 2, 3, 4, 5], 2));//[4,5]
    //console.log(takeRight([1, 2, 3]));//[3]

    //36.使用Array.slice（）創建一個數組切片，其中包含從頭開始的n個元素。
    var take = function take(arr) {
        var n = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
        return arr.slice(0, n);
    };
    //console.log(take([1,2,3,4,5,6],4)); //[1,2,3,4]
    //console.log(take([1,2,3,4,5],0)); //[]

    //-----------------------以上為ES5寫法-----------------------------------

    //37.使用ES6 Set和... rest運算符可以丟棄所有重復的值。
    const unique = arr => [...new Set(arr)];
    //console.log(unique([1,1,2,3,4,4,5,5,5,6,7,8,8,9])); //[1,2,3,4,5,6,7,8,9]

//###上述ES6中的寫法參考以下地址
//###https://www.awesomes.cn/repo/30-seconds/30-seconds-of-code#array-concatenation