eleven-methods/utils/ElevenArr.js

常用方法累计

module.exports = class ElevenArr {
    constructor() {}
    // 动态插入方法
    filterData(selData, datas, field) {
        return datas.filter(d => selData.includes(d[field]))
    }
    splitArr(data, senArrLen) {
        //处理成len个一组的数据
        let data_len = data.length;
        let arrOuter_len = data_len % senArrLen === 0 ? data_len / senArrLen : parseInt((data_len /
            senArrLen) + '') + 1;
        let arrSec_len = data_len > senArrLen ? senArrLen : data_len; //内层数组的长度
        let arrOuter = new Array(arrOuter_len); //最外层数组
        let arrOuter_index = 0; //外层数组的子元素下标
        // console.log(data_len % len);
        for (let i = 0; i < data_len; i++) {
            if (i % senArrLen === 0) {
                arrOuter_index++;
                let len = arrSec_len * arrOuter_index;
                //将内层数组的长度最小取决于数据长度对len取余，平时最内层由下面赋值决定
                arrOuter[arrOuter_index - 1] = new Array(data_len % senArrLen);
                if (arrOuter_index === arrOuter_len) //最后一组
                    data_len % senArrLen === 0 ?
                    len = data_len % senArrLen + senArrLen * arrOuter_index :
                    len = data_len % senArrLen + senArrLen * (arrOuter_index - 1);
                let arrSec_index = 0; //第二层数组的索引
                for (let k = i; k < len; k++) { //第一层数组的开始取决于第二层数组长度*当前第一层的索引
                    arrOuter[arrOuter_index - 1][arrSec_index] = data[k];
                    arrSec_index++;
                }
            }
        }
        return arrOuter
    }
    // filter 不兼容情况调用
    compatibleWithTheFilter() {
        // 当某些环境不兼容filter的情况下使用
        // filter 被添加到 ECMA-262 标准第 5 版中，因此在某些实现环境中不被支持。 例如 ie8 等等
        if (!Array.prototype.filter) {
            Array.prototype.filter = function (func, thisArg) {
                'use strict';
                if (!((typeof func === 'Function' || typeof func === 'function') && this))
                    throw new TypeError();

                var len = this.length >>> 0,
                    res = new Array(len), // preallocate array
                    t = this,
                    c = 0,
                    i = -1;
                if (thisArg === undefined) {
                    while (++i !== len) {
                        // checks to see if the key was set
                        if (i in this) {
                            if (func(t[i], i, t)) {
                                res[c++] = t[i];
                            }
                        }
                    }
                } else {
                    while (++i !== len) {
                        // checks to see if the key was set
                        if (i in this) {
                            if (func.call(thisArg, t[i], i, t)) {
                                res[c++] = t[i];
                            }
                        }
                    }
                }

                res.length = c; // shrink down array to proper size
                return res;
            };
        }
    }
    // flat 合并 reduce  concat 加 递归实现无限多层嵌套数组的扁平化
    flatDeep(arr, d = 1, field = undefined) {
        // 默认为1 只扁平化一次
        return d > 0 ? arr.reduce((acc, val) => {
                return acc.concat(val !== field ? (Array.isArray(val) ? this.flatDeep(val, d - 1, field) : val) : [])
            }, []) :
            arr.slice()
    }
}