通过键值搜索对象,并返回该对象包含所有父级,类似操作html节点效果可以访问每级对象的parent

通过键值搜索对象,以下demo只能返回搜索对象的本身, 我想返回对象的所有父级 有没办法，注意obj的数据里面的键值是不固定的，我这里的childs子对象只是演示，实际是任意的key

const obj={
    id:0,
    childs:[
        {
            id:1,
            childs:[
                {
                    id:12
                }
            ]
        },
        {
            id:2,
            childs:[
                {
                    id:21,
                    childs:[{
                        id:211
                    }]
                }
            ]
        }
    ]
}

const findObject = (obj = {}, key, value) => {
    const result = [];
    const recursiveSearch = (obj = {}) => {
        if (!obj || typeof obj !== 'object') {
            return;
        };
    if (obj[key] === value){
        result.push(obj);
    };
    Object.keys(obj).forEach(function (k) {
        recursiveSearch(obj[k]);
    });
} 
recursiveSearch(obj);
return result;
}
console.log(findObject(obj, 'id', 211)); //返回[{id:211}]

通过这段代码有没办法改造成返回值为可以向上溯源到根的所有父级对象, 例如[{id:211,parent:{id:21}}] 这样找到根

以下是我想返回的完整结果

//想要的console.log结果如下,注意以下的parent与childs属性可能是其他任意key,这里仅是演示
[{
    id:211,
    parent:{
        id:21,
        childs:[{
            id:211
        }],
        parent:{
            id:2,
            childs:[
                {
                    id:21,
                    childs:[{
                        id:211
                    }]
                }
            ],
            parent:{
                id:0,
                childs:[
                    {
                        id:1,
                        childs:[
                            {
                                id:12
                            }
                        ]
                    },
                    {
                        id:2,
                        childs:[
                            {
                                id:21,
                                childs:[{
                                    id:211
                                }]
                            }
                        ]
                    }
                ]
            }
        }
    }
}]

const findObject = (obj = {}, key, value) => {
    const result = [];
    const recursiveSearch = (obj = {}) => {
        if (!obj || typeof obj !== 'object') {
            return;
        };
        if (obj[key] === value){
            let res = {...obj}
            result.push(res)
            return res
        };
 
        let parent
        Object.keys(obj).forEach(function (k) {
            if(Array.isArray(obj[k])){
                obj[k].some(item => {
                    let res = recursiveSearch(item);
                    if(res){
                        parent = res.parent = {...obj}
                        return true
                    }
                })
            }else{
                let res = recursiveSearch(obj[k]);
                if(res){
                    parent = res.parent = {...obj}
                }
            }
        });
        return parent
    } 
    recursiveSearch(obj);
    return result;
}

希望有帮助
https://b23.tv/iwhsxcf

const obj = {
    id: 0,
    childs: [
        {
            id: 1,
            childs: [
                {
                    id: 12
                }
            ]
        },
        {
            id: 2,
            childs: [
                {
                    id: 21,
                    childs: [{
                        id: 211
                    }]
                }
            ]
        }
    ]
}

function find(node, attr, value) {
    if (node == null) {
        return null
    }
    if (node[attr] == value) {
        return [node[attr]]
    }
    if (node.childs == null || node.childs.length == 0) {
        return null
    }
    for (let i = 0; i < node.childs.length; i++) {
        let result = find(node.childs[i], attr, value);
        if (result != null) {
            result.push(node.id);
            return result
        }
    }
    return null;
}

function resultFun(params, depth, attr) {
    if (params.length == depth + 1) {
        let temp = {};
        temp[attr] = params[depth]
        return temp
    } else {
        let temp = {};
        temp[attr] = params[depth]
        temp.parent = resultFun(params, ++depth, attr)
        return temp;
    }
}

function findObject(obj, attr, value) {
    const result = find(obj, attr, value)
    if (result) {
        return resultFun(result, 0, attr);
    } else {
        return null;
    }
}

console.log(JSON.stringify(findObject(obj, 'id', 211))); //返回[{id:211}]

• 你可以看下这个问题的回答https://ask.csdn.net/questions/7734153