Итерирование по многоуровневому объекту?

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

Проблема с

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

заключается в том, что container.length не определено, поэтому итераций нет, а objectKeys никогда не назначается.

Использование Object.values ​​ и map результирующий массив для возврата mods, затем flat it с 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);

Answer 2

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 3

Если я вас правильно понял, функция ниже должна принимать объект и возвращать массив со всеми модами 2-го уровня

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 4

Хороший пример того, почему мне не нравятся динамические имена свойств.Массив, состоящий из: [{"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 () или lower ().

Answer 5

Я бы получил все моды, уменьшающие карту над вашими динамическими подобъектами, что-то вроде:

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]

Таким образом, вы можете зацикливаться в конце.