Javascript 对象操作（分组）

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

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的异步行为）

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

编辑： 解决方案应该是动态的。它可能比这更复杂的数据结构。例如：

---

非常感谢您的回答，但实际上我不想得到硬编码的解决方案。也许我也应该把这一点添加到问题中，但假设它可能是更多嵌套对象，比如5-6步到内部

a:{b:{c:{d:{e:{data:data}}}等等

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

---

田地。[“a”、“b”、“c”、“d”、“e”]

假设

requestedType.years

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

//与您的完全相同，但格式更紧凑
常数数据={
2000: {
1:{a:{年份：2000，编号：1，字母表：'a'}}，
2:{a:{年份：2000，编号：2，字母表：'a'}}，
3:{a:{年份：2000年，第3号，字母表：'a'}，
b:{年份：2000年，第3号，字母表：'b'}
},
2010: {
1:{a:{年份：2010，编号：1，字母表：'a'}}，
2:{a:{年份：2010，编号：2，字母表：'a'}}，
3:{a:{年份：2010年，第3号，字母表：'a'}，
b:{年份：2010年，第3号，字母表：'b'}
}
}
常量requestedType={
年份：Object.entries（data.map）（年份=>{
返回{
年份：年份[0]，
编号：Object.entries（年份[1]）.map（年份内容=>{
返回{
否：年份内容[0]，
alphs:Object.entries（yearContent[1]）.map（itemContent=>{
返回{
alph:itemContent[0]，
数据：itemContent[1]
}
})
}
})
}
})
}
console.log（requestedType）
我通过改变一点@GalAbra solution找到了一个解决方案

非常感谢你的帮助。你干得最好对象。条目是个好主意
 年在requestedType数组类型中吗？目前yeaar 2000可用，添加2010将成为years阵列的一部分right@NagaSaiA是的，它肯定是数组。很抱歉造成混淆请分享问题中可能存在的5-6嵌套对象非常感谢您的回答，但实际上我不想得到硬编码的解决方案。也许我也应该把这一点添加到问题中，但假设它可能是更多嵌套对象，比如5-6步到内部。a:{b:{c:{d:{e:{data:data}}}}}等。我无法理解预期结果的逻辑，但我希望您可以使用它创建自己的解决方案：）
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

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

});

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)