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

如果我对您的理解正确，下面的函数应该接受一个对象并返回一个包含所有第二级mods的数组

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]
    },
})

它将返回

[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和map所得的数组返回mods，然后用depth中的2 flat返回：

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);

遍历多级对象？

5 个答案: