对数组对象进行一些操作的工具方法，如排序、树状结构转化、查找父级属性等

一个由对象组成的数组，对数组根据对象的某一个属性进行排序处理

function objSort(objArr, objParamName, type) {
    switch (type) {
        case 'sb':
            objArr.sort((obj1, obj2) => {
                var value1 = obj1[`${objParamName}`]
                var value2 = obj2[`${objParamName}`]
                if (value1 < value2) return -1 //想要value1 < value2的话就返回-1
                else if (value1 > value2) return 1 //想要value1 > value2的话就返回1
                else return 0
            })
            break;
        case 'bs':
            objArr.sort((obj1, obj2) => {
                var value1 = obj1[`${objParamName}`]
                var value2 = obj2[`${objParamName}`]
                if (value1 < value2) return 1 //想要value1 < value2的话就返回-1
                else if (value1 > value2) return -1 //想要value1 > value2的话就返回1
                else return 0
            })
            break;
    }
}

在展现一些场景，如多级菜单、多级部门等，通常需要树状结构的数据进行展示，要是后端返回的数据是扁平化结构的，格式如下

let array = [
	{id: '1', parentId: null, ...},
	{id: '2', parentId: null, ...},
	{id: '1_1', parentId: '1', ...},
	{id: '2_1', parentId: '2', ...},
	{id: '2_2', parentId: '2', ...},
	......
]

需要经过处理转化成树状结构，格式如下

[
	{id: '1', parentId: null, children: [{id: '1_1', parentId: '1'}]},
	{id: '2', parentId: null, children: [{id: '2_1', parentId: '2'}, {id: '2_2', parentId: '2']
]

function transformTree(originList, options = {}) {
    const {
        key = 'id',
        parentKey = 'parentId',
        childrenKey = 'children'
    } = options
    function transformTree(list) {
        let tree = [];
        list.forEach((item, index) => {
            if (!item[parentKey]) {
                const temp = queryChildren(item, list);
                tree.push(temp);
            }
        });
        return tree;
    }
    function queryChildren(parent, list) {
        const children = [];
        list.forEach((item, index) => {
            if (parent[key] == item[parentKey]) {
                const temp = queryChildren(item, list);
                children.push(temp);
            }
        });
        if (children.length) parent[childrenKey] = children;
        return parent;
    }
    return transformTree(originList)
}

// 使用
let treeList = transformTree(array)
console.log(treeList)

现在有一个数组，数据如下，查找id是2_1_1的所有父级id

let array = [{
    id: '1', children: [
        {
            id: '1_1', children: [
                { id: '1_1_1', children: [{ id: '1_1_1_1' }] }
            ]
        }
    ]
},
{
    id: '2', children: [
        {
            id: '2_1', children: [
                { id: '2_1_1' },
                { id: '2_1_2' },
                { id: '2_1_3' },
            ]
        },
        { id: '2_2' },
        { id: '2_3' },
    ]
}]

function jsonQueryParentByChild(data, value, paramName, arr = []) {
    data.find(item => {
        if (item[paramName] == value) {
            arr.unshift(item[paramName]);
            return true;
        } else if (item.children && item.children.length) {
            arr = util.jsonQueryParentByChild(
                item.children,
                value,
                paramName,
                arr
            );
            if (arr.length) {
                arr.unshift(item.id);
                return true;
            } else return false;
        }
        return false;
    });
    return arr;
}

// 使用
let result = jsonQueryParentByChild(array, '2_1_1', 'id')
console.log(result) // ['2', '2_1', '2_1_1']