【数组方法大合集】原生js数组array常用工具方法大合集

array: {
    // 判断数组是否为多维数组
    isMultiDimensionalArray(arr) {
        return Array.isArray(arr) && arr.some(item => Array.isArray(item));
    },
    // 间隔count个元素新建一个数组
    splitArray(arr, count = 3) {
        return arr.reduce((prevResult, current, i) => {
            if (i % count === 0) {
                prevResult.push([current]); // 新增一个小数组 
            } else {
                prevResult[prevResult.length - 1].push(current); // 将当前元素加入最后一个小数组中
            } return prevResult;
        }, []);
    },
    //【递归】说明：递归方法清空多维数组中的指定元素为对应值（对象）
    clearNullElementsInArrayByProps(arr, {
        props = {
            fieldName: `removed`,
            fieldValue: true,
        },
    } = {}) {
        return (arr || []).filter(v => {
            if (v[props.fieldName] === props.fieldValue) {
                return false;
            } else {
                if (v.children) {
                    v.children = this.clearNullElementsInArrayByProps(v.children, { props });
                    return v.children.length > 0
                } else {
                    return true;
                }
            }
        });
    },
    //【递归】说明：递归方法清空多维数组中的null元素（对象）
    clearNullElementsInArray(arr) {
        return (arr || []).filter(v => {
            if (v == null) {
                return false;
            } else {
                if (v.children) {
                    v.children = this.clearNullElementsInArray(v.children);
                    return v.children.length > 0
                } else {
                    return true;
                }
            }
        });
    },
    // 从数组A移出包含数组B的元素
    removeElementsFromArray(arrayA, arrayB) {
        return arrayA.filter(item => !arrayB.includes(item));
    },
    //将数组指定索引位置的元素 移动到 目标索引位置
    moveArrayElement(arr, fromIndex, toIndex) {
        toIndex < 0 && (toIndex = 0), toIndex > arr.length - 1 && (toIndex = arr.length - 1);
        fromIndex < 0 && (fromIndex = 0), fromIndex > arr.length - 1 && (fromIndex = arr.length - 1);
        arr.splice(toIndex, 0, arr.splice(fromIndex, 1)[0]); return arr
    },

    // 筛选出新数组中和旧数组的重复项，并和旧数组合并
    unshiftData({ oldArr, newArr, mainKey = 'ID' } = {}) {
        return newArr.filter((v) => !oldArr.some((ov) => v[mainKey] == ov[mainKey])).concat(oldArr); // 筛选出新数组中和旧数组的重复项，并和旧数组合并（新的放在前面）
    },
    pushData({ oldArr, newArr, mainKey = 'ID' } = {}) {
        return oldArr.concat(newArr.filter((v) => !oldArr.some((ov) => v[mainKey] == ov[mainKey]))); // 筛选出新数组中和旧数组的重复项，并和旧数组合并（新的放在后面）
    },

    // 将扁平化的一维对象数组通过PID或parentId转换为有逻辑关系的树形结构数组
    flatArray2TreeArrayByPID(arr) {
        const r = [], map = {};
        arr.forEach(v => map[v.ID] = v);
        arr.forEach(v => {
            const p = map[v.PID || v.pid || v.parentId];
            (p ? p.children || (p.children = []) : r).push(v);
        })
        return r;
    },
    // 将有逻辑关系的树形结构数组转换为扁平化的一维对象数组
    treeStructure2flatArray(arr) {
        let r = [], r_ = (ar, PID = 'root') => ar.forEach(v => (v.children && (r_(v.children, v.ID), delete v.children), (v.PID = PID, r.push(v))));
        r_(JSON.parse(JSON.stringify(arr)));
        return r;
    },

    //最短代码实现随机打乱数组各个元素的顺序
    randomSortArr(arr = []) {
        return [...Array(arr.length)].map(
            (v, i) => arr.splice(Math.round(Math.random() * (arr.length - 1)), 1)[0]
        );
    },
    /* 数组求和*/
    sum: arr => eval(arr.join("+")),
    /* 判断一个数组(支持一个字符串)里面的是否有任何一个元素被包含在了某个字符串里面 */
    isStringContain(str, arr) {
        Array.isArray(arr) || (arr = [arr]);
        for (var i = 0, len = arr.length; i < len; i++) {
            if (str.includes(arr[i])) return true //只要有一个元素被包含了就终止循环
        }
        return false;
    },
    /**获取数组最大值*/
    getMax(arr) {
        // 利用apply 将数组元素拆成一个个参数让Math.max去计算
        // return Math.max.apply(null, arr);  // ES5写法;
        return Math.max(...arr); // ES6写法;
    },
    /**获取数组最小值*/
    getMin(arr) {
        // 利用apply 将数组元素拆成一个个参数让Math.min去计算
        // return Math.min.apply(null, arr);// ES5写法
        return Math.min(...arr); // ES6写法;
    },
    /** es6语法：过滤JS数组中的空值,假值等(es6语法) */
    filterNullUndefined: arr => arr.filter(item => item),
    /**判断是否为数组类型*/
    isArray: function (o) {
        return Object.prototype.toString.call(o) == "[object Array]";
    },
    /**删除数组中指定元素*/
    removeFirstByValue: function (val) {
        for (var i = 0, len = arr.length; i < len; i++) {
            var a = arr[i];
            if (a == val) {
                arr.splice(i, 1);
                break;
            }
        }
        return arr;
        /*测试用例*/
        /*var arr = ["mon", "tue", "wed", "thur"];
        alert(removeFirstByValue(arr, "wed"));*/
    },
    /**删除数组中指定匹配的所有元素*/
    removeAllByValue: function (val) {
        var newArr = [];
        for (var i = 0, len = arr.length; i < len; i++) {
            var a = arr[i];
            a != val && newArr.push(a);
        }
        return newArr;
        /*测试用例*/
        /*var arr = ["mon", "tue", "wed","wed","wed", "thur"];
        alert(removeAllByValue(arr, "wed"));*/
    },
    /**删除对应键值的→第一个元素*/
    removeFirstByMatchKey: function (arr, macthKey, matchKeyValue) {
        for (var i = 0, len = arr.length; i < len; i++) {
            var a = arr[i];
            if (a[macthKey] == matchKeyValue) {
                arr.splice(i, 1);
                break;
            }
        }
        return arr;
    },
    /**删除对应键值的→所有元素*/
    removeAllByMatchKey: function (arr, macthKey, matchKeyValue) {
        var newArr = [];
        for (var i = 0, len = arr.length; i < len; i++) {
            var a = arr[i];
            a[macthKey] != matchKeyValue && newArr.push(a);
        }
        return newArr;
    },
    /**移动数组里面的对应元素step个位置，注意！！！会直接修改原数组*/
    moveArray: function (arr, index, step) {
        /*如step为负数，则往前面移动对应步数。如：-2往前移动两步，3往后移动三步*/
        var moveToIndex = index + step;
        moveToIndex < 0 && (moveToIndex = arr.length - 1);
        moveToIndex > arr.length - 1 && (moveToIndex = 0);
        arr.splice(moveToIndex, 0, arr.splice(index, 1)[0]);
        return arr;
        /*测试用例*/
        /*var arr = ['第一个', '第二个', '第三个', '第四个']; array.moveArray(arr, 1, -2); /!*第二个元素往前移动2步，将会移动到数组最后一个位置*!/ console.log(arr);*/
    },
    /**对比两个数组不同元素，从第一个数组里面排除第二个数组里面相同元素,isAddBdiffPart为true时加入第二个数组不同部分返回结果*/
    getdiffarr: function (A, B, isAddBdiffPart) {
        var C = [];
        var D = [];
        var Astr = "," + A.toString() + ",";
        var Bstr = "," + B.toString() + ",";
        for (var i in A) {
            if (Bstr.indexOf("," + A[i] + ",") < 0) {
                C.push(A[i]);
            }
        }
        for (var p in B) {
            if (Astr.indexOf("," + B[p] + ",") < 0) {
                D.push(B[p]);
            }
        }
        return isAddBdiffPart ? C.concat(D) : C;
        /*测试用例*/
        /*var F = array.getdiffarr([9, 7, 1, 2, 3, 4], [3, 4, 1, 8], true); console.log(F);*/
    },
    /**数组排序：isAsc=true升序；isAsc=false降序*/
    getSort: function (arr, isAsc) {
        var arr = arr.concat();
        arr.sort(function (a, b) {
            return isAsc ? a - b : b - a;
        });
        return arr;
    },
    /**关联数组排序：isAsc=true升序；isAsc=false降序*/
    getSortByKey: function (arr, key, isAsc) {
        var o = arr.concat();
        o.sort(function (a, b) {
            return isAsc ? a[key] - b[key] : b[key] - a[key];
        });
        return o;
    },
    /**数组对象根据某个值相同合并分组（collectKeyName是用于比对合并的键值，addOtherKeys是附加的键值）*/
    collect: function (arr, collectKeyName, addOtherKeys) {
        var map = {},
            arr2 = [];
        for (var i = 0, len = arr.length; i < len; i++) {
            var a = arr[i];
            if (!map[a[collectKeyName]]) {
                var obj = { collectName: a[collectKeyName], collectValue: [a] };
                /*追加可选键值*/
                var arr3 = addOtherKeys || [];
                for (var k = 0, len3 = arr3.length; k < len3; k++) {
                    var c = arr3[k];
                    obj[c] = a[c];
                }
                arr2.push(obj);
                map[a[collectKeyName]] = a;
            } else {
                for (var j = 0, len2 = arr2.length; j < len2; j++) {
                    var b = arr2[j];
                    if (b.collectName == a[collectKeyName]) {
                        b.collectValue.push(a);
                        break;
                    }
                }
            }
        }
        return arr2;
    },
    /**获取ID→对应的记录*/
    getById: function (arr, id) {
        return this.getByMatchKey(arr, 'id', id);
    },
    /**获取ID→对应的值*/
    getValueById: function (arr, id) {
        var re = this.getById(arr, id);
        return re ? re.value : null;
    },
    /**获取对应值的→ID*/
    getIdByValue: function (arr, value) {
        var re = this.getByMatchKey(arr, 'value', value);
        return re ? re.id : null;
    },
    /**获取对应值的→记录*/
    getByMatchKey: function (arr, matchKey, matchKeyValue) {
        for (var k in arr) {
            var a = arr[k];
            if (a[matchKey] == matchKeyValue) {
                return a;
            }
        }
    },
    /**获取对应值的→键的值*/
    getValueByMatchKey: function (arr, matchKey, matchKeyValue, keyName) {
        var re = this.getByMatchKey(arr, matchKey, matchKeyValue);
        return re ? re[keyName] : null;
    },
    /**设置数组对应ID→对应的key值*/
    setKeyValueById: function (arr, id, keyName, keyValue) {
        this.setValueByMatchKey(arr, 'id', id, keyName, keyValue);
    },
    /**设置数组对应自定义匹配key→对应的值keyValue*/
    setValueByMatchKey: function (arr, matchKey, matchKeyValue, keyName, keyValue) {
        for (var k in arr) {
            var a = arr[k];
            if (a[matchKey] == matchKeyValue) {
                a[keyName] = keyValue;
            }
        }
    },
    /**根据对应自定义匹配key→对应的值index*/
    getIndexByMatchKey: function (arr, matchKey, matchKeyValue) {
        for (var k in arr) {
            var a = arr[k];
            if (a[matchKey] == matchKeyValue) {
                return k; //返回值记得用parseInt()转换为int类型，如果搜索的arr是一个object对象则不用转换值类型，返回的就是key的字符串
            }
        }
    },
    /**根据value的值获取元素索引值index*/
    getIndexByValue: function (arr, value) {
        return this.getIndexByMatchKey(arr, 'value', value);
    },
    /**根据id的值获取元素索引值index*/
    getIndexById: function (arr, id) {
        return this.getIndexByMatchKey(arr, 'id', id);
    },
    /**获取数组对应key→对应的valueKey值（key的格式{key: "id", value: 2, valueKey: "b"}），指定对应id等于2的b字段返回值;valueKey为空时返回整个元素记录*/
    getkeyValueByKeyValue: function (arr, key) {
        for (var k in arr) {
            var a = arr[k];
            if (a[key.key] == key.value) {
                return key.valueKey ? a[key.valueKey] : a;
            }
        }
    },
    /**设置数组对应key→对应的valueKey值（key的格式{key: "id", value: 2, setKey: "b", setValue: "999"}），设置对应id等于2的b字段的值为999*/
    setkeyValueByKeyValue: function (arr, key) {
        for (var k in arr) {
            var a = arr[k];
            if (a[key.key] == key.value) {
                a[key.setKey] = key.setValue;
            }
        }
        return arr;
    },
    /**根据by数组的key对应的值→去from的arr数组里面查询key对应的值相同的项并返回数组*/
    /**o的结构： { from: { arr: arr1, key: "value", }, by: { arr: arr2, key: "id", } } */
    getArrayByTwoKey: function (o) {
        var reArr = [];
        var arr1 = o.from.arr,
            k1 = o.from.key,
            arr2 = o.by.arr,
            k2 = o.by.key;
        for (var i = 0, len = arr2.length; i < len; i++) {
            var b = arr2[i];
            arr1.forEach(function (a) {
                a[k1] == (k2 ? b[k2] : b) && reArr.push(a);
            });
        }
        return reArr;
    },
    __convertToKeyValueObject: function (obj) {
        for (var i in obj) {
            var a = obj[i];
            return { "key": i, "value": a };
        }
    },
    /**模糊搜索key→对应的value值（obj的格式{keyName:keyValue}）*/
    searchArrayByKey: function (arr, obj) {
        var reArr = [];
        obj = this.__convertToKeyValueObject(obj);
        for (var k in arr) {
            var a = arr[k];
            if (a[obj.key].toString().indexOf(obj.value) > -1) {
                reArr.push(a);
            }
        }
        return reArr;
    },
    /**模糊搜索→全字段值匹配*/
    searchArrayByValue: function (arr, value) {
        var reArr = [];
        for (var i = 0, len = arr.length; i < len; i++) {
            var a = arr[i];
            for (var k in a) {
                var b = a[k];
                if (b.toString().toLowerCase().indexOf(value.toLowerCase()) > -1) {
                    reArr.push(a);
                    break;
                }
            }
        }
        return reArr;
    },
    /**获取longString字符串中被startStr和end重复夹住的字符串*/
    getBetween: function (longString, startStr, endStr) {
        var arr = longString.split(startStr),
            reArr = [];
        arr.shift();
        for (var i = 0, len = arr.length; i < len; i++) {
            var a = arr[i];
            reArr.push(a.split(endStr)[0]);
        }
        return reArr;
    },
    /**用指定字符串分割将相同元素归类，并返回新的数组*/
    getSortOutArrayBySplit: function (arr, splitStr) {
        var retArr = [],
            ind = -1,
            oldValue;
        for (var i = 0, len = arr.length; i < len; i++) {
            var newValue = arr[i];
            oldValue == newValue ? (retArr[ind] = retArr[ind] + (splitStr || "/") + newValue) : (oldValue = newValue, ind++, retArr[ind] = newValue);
        }
        return retArr;
    }
},