常用的关于数组数据的处理方法

 //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