常用数组相关方法

作为前端开发工作者，工作中离不开对数据进行操作，尤其对数组的转化，这里简单放一些拿来即用的数组方法。

1.将普通数组转换成树类型格式

function handleTree(data, id, parentId, children) {
            let config = {
                id: id || 'id',
                parentId: parentId || 'parentId',
                childrenList: children || 'children'
            };
            var childrenListMap = {};
            var nodeIds = {};
            var tree = [];
            for (let d of data) {
                let parentId = d[config.parentId];
                if (childrenListMap[parentId] == null) {
                    childrenListMap[parentId] = [];
                }
                nodeIds[d[config.id]] = d;
                childrenListMap[parentId].push(d);
            }
            for (let d of data) {
                let parentId = d[config.parentId];
                if (nodeIds[parentId] == null) {
                    tree.push(d);
                }
            }
            for (let t of tree) {
                adaptToChildrenList(t);
            }
            function adaptToChildrenList(o) {
                if (childrenListMap[o[config.id]] !== null) {
                    o[config.childrenList] = childrenListMap[o[config.id]];
                }
                if (o[config.childrenList]) {
                    for (let c of o[config.childrenList]) {
                        adaptToChildrenList(c);
                    }
                }
            }
            return tree;
        }

2.将树形格式的数据平铺

 function handleList(arr, id, parentId, children) {
            let result = []
            let config = {
                id: id || 'id',
                parentId: parentId || 'parentId',
                childrenList: children || 'children'
            };
            function flatten(arr) {
                arr.forEach(item => {
                    if (item[config.childrenList] && item[config.childrenList].length > 0) {
                        //   如果有子级数据
                        // 子级别操作一下,把本身放到数组里
                        flatten(item[config.childrenList])
                        delete item[config.childrenList]
                        result.push(item)
                    } else {
                        // 如果没有子级数据了直接放到数组里面
                        result.push(item)
                    }
                });
            }
            flatten(arr)
            return result
        }

3.两个数组取交集

 function handleIntersect(arr1, arr2, id) {
            let config = {
                id: id || 'id'
            }
            let result = []
            let idlist = arr1.map(item => item[config.id])
            arr2.forEach(item => {
                if (idlist.some(i => i == item[config.id])) {
                    result.push(item)
                }
            })
            return result
        }

4.两个数组取并集

function handleMerge(arr1, arr2, id) {
            let config = {
                id: id || 'id'
            }
            let result = arr1
            let idlist = arr1.map(item => item[config.id])
            arr2.forEach(item => {
                if (!idlist.some(i => i == item[config.id])) {
                    result.push(item)
                }
            })
            return result
        }