Question

我有一个这样的嵌套对象。

data = {
    2000: {
        1: {
            a: {year: 2000, no: 1, alphabet: 'a'}
        }, 
        2: {
            a: {year: 2000, no: 2, alphabet: 'a'}
        },
        3: {
            a: {year: 2000, no: 3, alphabet: 'a'},
            b: {year: 2000, no: 3, alphabet: 'b'}
        }
    },
    2010: {
        1: {
            a: {year: 2010, no: 1, alphabet: 'a'}
        }, 
        2: {
            a: {year: 2010, no: 2, alphabet: 'a'}
        },
        3: {
            a: {year: 2010, no: 3, alphabet: 'a'},
            b: {year: 2010, no: 3, alphabet: 'b'}
        }
    }
}

requestedType = {
    years: [
    {
        year: "2000",
        nos: [
            {
                no: 1,
                alphs: [
                    {
                        alph: "a",
                        data: {year: 2000, no: 1, alphabet: 'a'}
                    }
                ]
            },
            {
                no: 2,
                alphs: [
                    {
                        alph: "a",
                        data: {year: 2000, no: 2, alphabet: 'a'}
                    }
                ]
            },
            {
                no: 3,
                alphs: [
                    {
                        alph: "a",
                        data: {year: 2000, no: 3, alphabet: 'a'}
                    },
                    {
                        alph: "b",
                        data: {year: 2000, no: 3, alphabet: 'b'}
                    }
                ]
            },
        ]
    },
    {
       year: "2010",
       nos: [........]
    }
    ]

}

我想将此数据更改为该结构。

基本上我可以使用此功能来做到这一点，但我想动态地做到这一点

我尝试使用递归（在foreach循环中调用相同的函数，但是它不能按我期望的方式工作。因为，我猜是因为Javascript的异步行为）。

var years =  Object.keys(data)
years.forEach((year, i) => {
    var noData = result[year]
    years[i] = {year, no: noData}

    var nos =  Object.keys(noData)
    nos.forEach((no, j) => {
        var alpData = noData[no]
        nos[j] = {no, alphabet: alpData}
    });
    years[i]["nos"] = nos

    ....................

});

等待您的帮助，任何建议都是完美的

修改：解决方案应该是动态的。数据结构可能比这更复杂。例如：非常感谢您的回答，但实际上我不想得到硬编码的解决方案。也许我也应该将其添加到问题中，但假设它可能是更多嵌套的对象，例如需要进行5至6步。

a：{b：{c：{d：{e：{数据：数据}}}}}等等。

基本上，您可以认为我们有一个包含所有这些内容的数组

个字段。 [“ a”，“ b”，“ c”，“ d”，“ e”]

Answer 1

假设requestedType.years是一个数组，这就是您描述的（非常复杂的）结构：

// Exactly the same as yours, but in a more compact format
const data = {
  2000: {
    1: { a: { year: 2000, no: 1, alphabet: 'a' } },
    2: { a: { year: 2000, no: 2, alphabet: 'a' } },
    3: { a: { year: 2000, no: 3, alphabet: 'a' },
         b: { year: 2000, no: 3, alphabet: 'b' } }
  },
  2010: {
    1: { a: { year: 2010, no: 1, alphabet: 'a' } },
    2: { a: { year: 2010, no: 2, alphabet: 'a' } },
    3: { a: { year: 2010, no: 3, alphabet: 'a' },
         b: { year: 2010, no: 3, alphabet: 'b' } }
  }
}

const requestedType = {
  years: Object.entries(data).map(year => {
    return {
      year: year[0],
      nos: Object.entries(year[1]).map(yearContent => {
        return {
          no: yearContent[0],
          alphs: Object.entries(yearContent[1]).map(itemContent => {
            return {
              alph: itemContent[0],
              data: itemContent[1]
            }
          })
        }
      })
    }
  })
}
console.log(requestedType);

Answer 2

const data = {
  2000: {
    1: { a: { year: 2000, no: 1, alphabet: 'a' } },
    2: { a: { year: 2000, no: 2, alphabet: 'a' } },
    3: { a: { year: 2000, no: 3, alphabet: 'a' },
         b: { year: 2000, no: 3, alphabet: 'b' } }
  },
  2010: {
    1: { a: { year: 2010, no: 1, alphabet: 'a' } },
    2: { a: { year: 2010, no: 2, alphabet: 'a' } },
    3: { a: { year: 2010, no: 3, alphabet: 'a' },
         b: { year: 2010, no: 3, alphabet: 'b' } }
  }
}

var keys = ["year", "no", "alphabet"]

  function magic(data, i, keys){
      var label = keys[i] + 's'
      var next = keys[i+1] + 's'
      return Object.entries(data).map(el => {
        var res = {}
        res[label] = el[0]
        if(i !== keys.length-1){
            res[next] =  magic(el[1], i+1, keys)
        } else {
            var key = Object.keys(data)
            res["data"] = data[key[0]]
        }
        return res
      })
  }

r = magic(data, 0, keys)
console.log(r)

我通过稍微更改@GalAbra解决方案找到了解决方案。

非常感谢您的帮助。您完成了大部分工作！ Object.entries 是个好电话！

对象操作（分组）

2 个答案: