请问如何遍历对象获取里面id？

Question

a = {
    id:1,
    name:"sd",
    children:[
        {id:2,name:"gg",children:[
            {id:"4",name:"hh"},
            {id:"5",name:"jj"}    
        ]},
        {id:3,name:"ff",children:[
            {id:"6",name:"tt"},
            {id:"7",name:"yy"}    
        ]}
    ]
}

a对象有时children为null，有时只有一层children
获取对象里面所有的id

Answer 1

常规操作就是递归遍历，下面说个利用JSON.stringify的特性的

let ids = []
JSON.stringify(a, function(key, value){
    key === 'id' && ids.push(value)
    return value
})

ids // [1, 2, '4', '5', 3, '6', '7']

Answer 2

可以使用递归遍历所有嵌套的children数组。代码如下：

function getAllIds(obj, ids = []) {
  if (obj && obj.id) {
    ids.push(obj.id);
  }

  if (obj && obj.children && Array.isArray(obj.children)) {
    obj.children.forEach(child => {
      getAllIds(child, ids);
    });
  }

  return ids;
}

const a = {
  id: 1,
  name: "sd",
  children: [
    {
      id: 2,
      name: "gg",
      children: [
        { id: "4", name: "hh" },
        { id: "5", name: "jj" }
      ]
    },
    {
      id: 3,
      name: "ff",
      children: [
        { id: "6", name: "tt" },
        { id: "7", name: "yy" }
      ]
    }
  ]
};

const ids = getAllIds(a);
console.log(ids); // 输出: [1, 2, 4, 5, 3, 6, 7]

Answer 3

  let a = {
    id: 1,
    name: "sd",
    children: [
      {
        id: 2, name: "gg", children: [
          { id: "4", name: "hh" },
          { id: "5", name: "jj" }
        ]
      },
      {
        id: 3, name: "ff", children: [
          { id: "6", name: "tt" },
          { id: "7", name: "yy" }
        ]
      }
    ]
  }
  let list = []
  function loop (tree) {
    tree.forEach(t => {
      list.push(t.id)
      if (t.children && Array.isArray(t.children)) {
        loop(t.children);
      }
    })
    return
  }
  list.push(a.id)
  loop(a.children)
  console.log(list);

Answer 4

要遍历对象并获取其中所有的 id，你可以使用递归函数：

function getAllIds(obj) {
  let ids = [];

  function traverse(node) {
    if (node.id) {
      ids.push(node.id);
    }

    if (node.children) {
      for (const child of node.children) {
        traverse(child);
      }
    }
  }

  traverse(obj);

  return ids;
}

const a = {
  id: 1,
  name: "sd",
  children: [
    {
      id: 2,
      name: "gg",
      children: [
        { id: "4", name: "hh" },
        { id: "5", name: "jj" },
      ],
    },
    {
      id: 3,
      name: "ff",
      children: [
        { id: "6", name: "tt" },
        { id: "7", name: "yy" },
      ],
    },
  ],
};

console.log(getAllIds(a)); // 输出：[1, 2, 4, 5, 3, 6, 7]

Answer 5

使用递归的方式是最好理解的，当然最好使用尾递归优化

interface NodeLike {
    children?: NodeLike[] | null
    id: string
}

const getAllIds = (node: NodeLike) => {
    const drill = (node: NodeLike, result: string[] => {
        result.push(node.id)
        node?.children?.forEach(child => drill(child, result))
        return result
    }
    return drill(node, [])
}

Answer 6

function find(obj, key, deep) {
    var ret = [];
    if (obj instanceof Array) {
        for (var i = 0; i < obj.length; ++i) {
            ret.push.apply(ret, find(obj[i], key));
        }
    } else if (typeof obj === "object" && obj) {
        for (var prop in obj) {
            var value = obj[prop];
            if (key === prop) {
                ret.push(value);
            } else if (deep || deep === undefined){
                ret.push.apply(ret, find(value, key));
            }
        }
    }
    return ret;
}
console.log(find(a, "id"));

Answer 7

递归循环 获取id

    const a = {
        id: 1,
        name: "sd",
        children: [
            {
                id: 2, name: "gg", children: [
                    { id: "4", name: "hh", },
                    { id: "5", name: "jj" }
                ]
            },
            {
                id: 3, name: "ff", children: [
                    { id: "6", name: "tt" },
                    { id: "7", name: "yy" }
                ]
            }
        ]
    }

    
    function getIds(param) {
        let ids = []
        if (!param) {
            return ids
        } else if (Array.isArray(param)) {   // 数组
            param.forEach(item => { ids = ids.concat(getIds(item)) });
            return ids
        }

        param.id && ids.push(param.id)

        if (param.children) { // 对象
            param.children.forEach(item => { ids = ids.concat(getIds(item)) });
            return ids
        }

        return ids
    }


    console.log(getIds(a)); // [1, 2, '4', '5', 3, '6', '7']