Question

我有以下对象，我想将所有id放在一个数组中。

let obj = {
    _id: 1,
    children: [
      {
        id: 2,
        children: [
          {
            id: 21,
            children: [],
          },
          {
            id: 22,
            children: [],
          },
          {
            id: 23,
            children: [
              {
                id: 231,
                children: [],
              }
            ]
          }
        ]
      },
      {
        id: 3,
        children: [
          {
            id: 31,
            children: [],
          },
          {
            id: 32,
            children: [],
            isCriteria: true
          },
          {
            id: 33,
            isCriteria: true
          }
        ]
      }
    ]
  }

我想要结果：

[1, 2, 21, 22, 23, 231, 3, 31, 32, 33]

PS：该对象是动态设置的，因此我们不知道子级有多深。

Answer 1

您将需要递归迭代。快速示例：

List<int>

Answer 2

这个比较丑陋，但是在垃圾收集器上也要轻一些，因为它不会创建和传播临时数组。

/**
 * @param {number[]} arr Target array to which numbers will be appended
 * @param {object}   obj Source data
 * @return {number[]} arr mutated with additional numbers (if any found)
 */
function arrayAppendIdsFrom (arr, obj) {
  arr.push(obj.id);
  if (Array.isArray(obj.children) && obj.children.length > 0) {
    obj.children.forEach(child => arrayAppendIdsFrom(arr, child));
  }
      
  return arr;
}

/*
 * Example data
 */
let obj = {
  id: 1,
  children: [
    {
      id: 2,
      children: [
        {
          id: 21,
          children: [],
        },
        {
          id: 22,
          children: [],
        },
        {
          id: 23,
          children: [
            {
              id: 231,
              children: [],
            }
          ]
        }
      ]
    },
    {
      id: 3,
      children: [
        {
          id: 31,
          children: [],
        },
        {
          id: 32,
          children: [],
          isCriteria: true
        },
        {
          id: 33,
          isCriteria: true
        }
      ]
    }
  ]
};

// Example use
console.log(arrayAppendIdsFrom([], obj));

Answer 3

您可以使用像这样的递归函数：

const myObj =  obj = {
    _id: 1,
    children: [
      {
        id: 2,
        children: [
          {
            id: 21,
            children: [],
          },
          {
            id: 22,
            children: [],
          },
          {
            id: 23,
            children: [
              {
                id: 231,
                children: [],
              }
            ]
          }
        ]
      },
      {
        id: 3,
        children: [
          {
            id: 31,
            children: [],
          },
          {
            id: 32,
            children: [],
            isCriteria: true
          },
          {
            id: 33,
            isCriteria: true
          }
        ]
      }
    ]
  }

var idArray = []

function func(obj) {
  idArray.push(obj._id ? obj._id : obj.id)
  if (!obj.children) {
    return
  }

  obj.children.forEach(child => func(child))
}

func(myObj)
console.log(idArray)

Answer 4

您可以创建一个函数（fill_ids），该函数循环obj的每个属性，并将键为ids或{的值推入数组（_id）中。 {1}}，例如

id

Answer 5

您可以使用flatMap

使用flatDeep

查看另一个示例

    
let obj = {
    _id: 1,
    children: [
      {
        id: 2,
        children: [
          {
            id: 21,
            children: [],
          },
          {
            id: 22,
            children: [],
          },
          {
            id: 23,
            children: [
              {
                id: 231,
                children: [],
              }
            ]
          }
        ]
      },
      {
        id: 3,
        children: [
          {
            id: 31,
            children: [],
          },
          {
            id: 32,
            children: [],
            isCriteria: true
          },
          {
            id: 33,
            isCriteria: true
          }
        ]
      }
    ]
  }

function flatDeep(o) {
    return [o.id||o._id].concat( (o.children||[]).flatMap(flatDeep) );
};

console.log(flatDeep(obj));

您可以删除||o._id和o.children||[]，具体取决于您的样本输入是正确的还是近似的：）

从嵌套对象到数组的字段

5 个答案: