多维数组对象、多维数组处理【多维转一维、获取多维层级/深度、多维数组简化、多维数组对象筛选、多维数组对象合并】

多维数组对象处理：

1. 多维数组对象转一维数组对象
2. 获取多维数组对象的层级/深度
3. 冗余多维数组对象简化
4. 多维数组对象根据对象里的值进行筛选
5. 结构类似的两个多维数组对象合并成一个多维数组对象

/*入参数组格式：[
    {
        id: 1, name: '一', age: 10, sex: 1,
        children: [
            {
                id: 11, name: '一-一', age: 11, sex: 0, children: []
            },
            {
                id: 12, name: '一-二', age: 12, sex: 1,
                children: [
                    {
                        id: 121, name: '一-二-一', age: 121, sex: 1, children: []
                    }
                ]
            }
        ]
    }
]*/
//多维数组对象转一维数组对象 
let multiArrayObjectToOne = (arr) => {
    let res = []; //保存最后的一维数组对象
    let fn = (arr) => {
        for (let i = 0; i < arr.length; i++) {
            let child = arr[i].children;
            res.push({ //只保存id和name
                id: arr[i].id,
                name: arr[i].name
            });
            if (child && child.length > 0) {
                fn(child);
            }
        }
    };
    fn(arr);
    return res;
};
//获取多维数组对象的层级/深度 以模拟入参输入返回：3
let arrayObjectDeep = (arr) => {
    let deep = (arr, flag) => {
        return arr.reduce(function (total, item) {
            let deepth = 0;
            let child = item.children;
            if (Array.isArray(child) && child.length > 0) {
                deepth = deep(child, flag + 1);
            }
            return deepth > total ? deepth : total;
        }, flag);
    };
    return deep(arr, 1);
};
//多维数组对象简化
let arrayObjectFormat = (arr) => {
    let fn = (arr) => {
        return arr.map(item => {
            return { //只保留id和name
                id: item.id,
                name: item.name,
                children: fn(item.children || [])
            };
        })
    };
    return fn(arr);
};
//多维数组对象根据对象里的值进行筛选
let arrayObjectFilter = (arr) => {
    let fn = (arr) => {
        return arr.filter(item => {
            return item.sex === 1;
        }).map(item => {
            let children = item.children;
            if (children && children.length > 0) {
                item.children = fn(children);
            }
            return item;
        });
    };
    return fn(arr);
}
/*let arr1 = [
   {
        label: '1',
        children: [
            {
                label: '11',
                children: [
                    {label: '111'},
                    {label: '112'},
                ]
            }
        ]
    }
];
let arr2 = [
    {
        name: '1',
        children: [
            {
                name: '11',
                children: [
                    {name: '111'},
                    {name: '112'},
                ]
            }
        ]
    }
];

合并结果：[
    {
        "label": "1",
        "children": [
            {
                "label": "11",
                "children": [
                    {
                        "label": "111",
                        "name": "111"
                    },
                    {
                        "label": "112",
                        "name": "112"
                    }
                ],
                "name": "11"
            }
        ],
        "name": "1"
    }
]*/
//多维数组合并
let multiArrayObjectMerge = (arr1, arr2) => {
    return arr1.map((item, index) => {
        if (item.children && item.children.length > 0) {
            return {...item, ...arr2[index], children: multiArrayObjectMerge(item.children, (arr2[index] && arr2[index].children) || [])};
        } else {
            return {...item, ...arr2[index]};
        }
    });
}

多维数组处理：

1. 多维数组转一维数组
2. 获取多维数组的层级/深度

/*入参数组格式：[1, [12, [121, 122], 13], 2];*/
//多维数组转一维数组
let multiArrayToOne = (arr) => {
    let res = []; //保存最后的一维数组
    let fn = (arr) => {
        for (let i = 0; i < arr.length; i++) {
            let child = arr[i];
            if (child && child.length > 0) {
                fn(child);
            } else {
                res.push(arr[i]);
            }
        }
    };
    fn(arr);
    return res;
};
//获取多维数组的层级/深度
let arrayDeep = (arr) => {
    let deep = (arr, flag) => {
        return arr.reduce(function (total, item) {
            let deepth = 0;
            if (Array.isArray(item) && item.length > 0) {
                deepth = deep(item, flag + 1);
            }
            return deepth > total ? deepth : total;
        }, flag);
    };
    return deep(arr, 1);
};