Question

拥有下一个对象：

2018: {
    01: {
         01: { key: value }
         02: { key: value }
         03: { key: value }
        },
    02: { ...  }
    },
2019: {
    01: ...

如何简化用于将值输入每日对象的下一个代码？

   for (let yearIndex in obj) {
      const year = obj[yearIndex]
      for (let monthIndex in year) {
        const month = year[monthIndex]
        for (let dayIndex in month) {
          const day = month[dayIndex] {
              console.log(day)
          }
        }
      }
    }

理想的结果可能是每天都有一个对象的数组：

[{ key: value }, { key: value }, ...]

Answer 1

您可以通过检查递归调用的类型来平放对象。

function getFlat(object) {
    return [].concat(
        ...Object
            .values(object)
            .map(value => value && typeof value === 'object' ? getFlat(value) : object)
    );
}

var object = {2018: { '01': { '01': { key: 1 }, '02': { key: 2 }, '03': { key: 3 } }, '02': { '01': { key: 4 }, '02': { key: 5 }, '03': { key: 6 } } }, 2019: { '01': { '01': { key: 7 }, '02': { key: 8 }, '03': { key: 9 } } } };

console.log(getFlat(object));

Answer 2

如果您只是想获取树的叶子（换句话说，不是自身对象的值），您可以创建一个简单的递归函数。当您不确切知道嵌套的深度时，这种方法尤其有用。

这将查看每个值，如果它是一个对象传递回来。否则它会将它推送到一个数组：

let obj = {2018: {'01': { 01: 'test18_11', 02: 'test18_12', 03: 'test18_13',},'02': { 01: 'test18_21', 02: 'test18_22', 03: 'test18_23',}},2019: {'01': { 01: 'test19_11', 02: 'test19_12', 03: 'test19_13', },'02': { 01: 'test19_21', 02: 'test19_22', 03: 'test19_23',}}}

function recurse(obj, a = []) {
    Object.values(obj).forEach(value => {
        if (typeof value === 'object') return recurse(value, a)
        else  a.push(value)
    })
    return a
}

console.log(recurse(obj))

Answer 3

＆＃13;

const obj = {
  2018: {
    01: {
      01: '01 first',
      02: '01 second',
    },
    02: {
      01: '02 first'
    }
  },
  2019: {
    01: {}
  }
};

Object.values(obj).forEach(year => {
  Object.values(year).forEach(month => {
    Object.values(month).forEach(day => {
      console.log(day);
    })
  })
})

＆＃13;

如何简化对象迭代代码？

3 个答案: