遍历多级对象？

Question

我有一个多级对象，它具有动态名称并且大约有 2 级深。如果只有一个动态对象，我想出了一个可行的解决方案，但是我在为多个对象编写循环时遇到了问题。这是基础知识。

我的对象是这样的：

{ 
  dynamic_name1: { 
    mods: [ 
      [Object], [Object] 
    ] 
  }, 

  dynamic_name2: { 
    mods: [ 
      [Object], [Object]
    ] 
   }, 

  dynamic_name3: { 
    mods: [ 
      [Object], [Object]
    ] 
  } 
}

基本上，我想迭代这个对象，并从每个相应的 mods 数组中获取对象，然后将它们推送到不同的数组。

我正在获取这个对象，变量为 container，然后结构如下：

const [objectKeys] = Object.keys(container);
const modsList = container[objectKeys].mods;

这个解决方案非常有效，因为我只是像这样将它添加到我的新数组中：

const myMods = [...modsList]

但是，当我尝试循环播放时，整个功能似乎无法正常工作。这是我目前所拥有的：

for (j = 0; j < container.length; j++){
  const [objectKeys] = Object.keys(container);
}

但是在尝试记录 [objectKeys] 时，我得到了未定义的信息。知道我该怎么做吗？

Answer 1

我会让所有的 mod 减少动态子对象上的贴图，比如：

const container = { 
  dynamic_name1: { 
    mods: [ 
      1, 2
    ] 
  }, 

  dynamic_name2: { 
    mods: [ 
      3, 4
    ] 
   }, 

  dynamic_name3: { 
    mods: [ 
      5, 6
    ] 
  } 
}

const mods = Object.values(container)
                   .map(sub => sub.mods)
                   .reduce(
                     (result, mods) => [...result, ...mods],
                     []
                   )

console.log(mods)
// [1, 2, 3, 4, 5, 6]

这样就可以在最后循环了。

Answer 2

如果我没理解错的话，下面的函数应该接受一个对象和return一个包含所有二级模组的数组

function extractMods(container) {
    return Object.keys(container).reduce((r, c) => [...r, ...container[c].mods], [])
}

像下面这样称呼它

extractMods({
    a: {
        mods: [0,1,2,3,4]
    },
    b: {
        mods: [5,6,7,8,9]
    },
    c: {
        mods: [10,11,12,13,14]
    },
})

会return

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]

Answer 3

我为什么不喜欢动态属性名称的好例子。一个包含以下内容的数组：[{"name":"dynamic_name1","mods":[{},{}]},{"name":"dynamic_name2","mods":[{},{}]}] 让您轻松循环。

但是为了帮助解决这个问题，Object.keys() 有一些兄弟姐妹：Object.entries() 和 Object.values() 。

const data = { 
  dynamic_name1: { 
    mods: [ 
      { id: 1 },
      { id: 2}
    ] 
  }, 

  dynamic_name2: { 
    mods: [ 
      { id: 3 },
      { id: 4 }
    ] 
   }, 

  dynamic_name3: { 
    mods: [ 
      { id: 5 },
      { id: 6 }
    ] 
  } 
};

const modsList = Object.values( data ).flatMap( entry => entry.mods );

console.log( modsList );

如果您的浏览器尚不支持 flatMap()，您可以使用 map() 或 reduce() 执行相同的操作。

Answer 4

let obj = {
    dynamic_name1: { mods: [{x:1}, {x:2}] },
    dynamic_name2: { mods: [{x:3}, {x:4}] },
    dynamic_name3: { mods: [{x:5}, {x:6}] }
}

let result = Object.values(obj).reduce((a, b) => (a.push(...b.mods), a), []);
console.log( result )

Answer 5

的问题

for (j = 0; j < container.length; j++){
  const [objectKeys] = Object.keys(container);
}

是 container.length 未定义，因此，迭代次数为零，并且 objectKeys 从未分配。

将 Object.values and map the resulting array to return the mods, then flat 与 depth 一起使用 2 :

const container = {
  dynamic_name1: {
    mods: [
      [Object],
      [Object]
    ]
  },

  dynamic_name2: {
    mods: [
      [Object],
      [Object]
    ]
  },

  dynamic_name3: {
    mods: [
      [Object],
      [Object]
    ]
  }
}

const myMods = Object.values(container).map(e => e.mods).flat(2);

console.log(myMods);

遍历多级对象？

Iterating over a multi-level object?

javascript

object

destructuring