Javascript 用对象数组生成新对象

从对象1开始，我试图形成另一个对象2。我已经在下面写了这段代码，但我不知道这是实现目标2的正确方法

var arr = [];
    object1.filter(function(value) {
                                return value.hasOwnProperty("This Year"); // Get only elements, which have such a key
                                    }).map(function(value) {
                                arr.push({value:value["This Year"]}); // Extract the values only
                                    });

对象1

var obj=[
  {
    "sno": 1,
    "Last Year": 10000
  },
  {
    "sno": 2,
    "Last Year": 11500
  },
  {
    "sno": 3,
    "Last Year": 12500
  },
  {
    "sno": 4,
    "This Year": 25400
  },
  {
    "sno": 5,
    "Last Year": 15000
  },
  {
    "sno": 6,
    "This Year": 29800
  }
]

对象2-期望的结果

var dataset = [
        {
            "seriesname": "Last Year",
            "data": [
                {
                    "value": "10000"
                },
                {
                    "value": "11500"
                },
                {
                    "value": "12500"
                },
                {
                    "value": "15000"
                }
            ]
        },
        {
            "seriesname": "This Year",
            "data": [
                {
                    "value": "25400"
                },
                {
                    "value": "29800"
                }
            ]
        }
    ]

如果有人能帮我找到更好的方法。在我的代码中，我正在硬编码对象1的键名。是否有其他方法？

为了避免硬编码年份条目，您可以使用

RegExp

查找包含

年份

单词的关键字

var obj1 = [
  {
    "sno": 1,
    "Last Year": 10000
  },
  {
    "sno": 2,
    "Last Year": 11500
  },
  {
    "sno": 3,
    "Last Year": 12500
  },
  {
    "sno": 4,
    "This Year": 25400
  },
  {
    "sno": 5,
    "Last Year": 15000
  },
  {
    "sno": 6,
    "This Year": 29800
  }
];

var dataset = [];

["This Year", "Last Year"].forEach((series) => {
    dataset.push({
        seriesname: series,
        data: obj1.filter((el) => {
                return el[series];
            }).map((el) => {
                return {
                    value: el[series]
                }
            })
        });
});

console.log(JSON.stringify(dataset, null, 2));

var arr=[{sno:1，“去年”：1e4}，{sno:2，“去年”：11500}，{sno:3，“去年”：12500}，{sno:4，“今年”：25400}，{sno:5，“去年”：15e3}，{sno:6，“今年”：29800}，
res=[…新集合（arr.map（v=>Object.keys（v.find）（z=>/year/i.test（z）））]
.map（c=>（{seriesname:c，data:arr.filter（x=>x[c]）.map（a=>（{value:a[c]}））；
控制台日志（res）为了避免硬编码年份条目，可以使用
RegExp
查找包含
年份
单词的关键字


var arr=[{sno:1，“去年”：1e4}，{sno:2，“去年”：11500}，{sno:3，“去年”：12500}，{sno:4，“今年”：25400}，{sno:5，“去年”：15e3}，{sno:6，“今年”：29800}，
res=[…新集合（arr.map（v=>Object.keys（v.find）（z=>/year/i.test（z）））]
.map（c=>（{seriesname:c，data:arr.filter（x=>x[c]）.map（a=>（{value:a[c]}））；
控制台日志（res）
您可以通过从输入数组中不是
sno
的对象获取唯一的键名来提取键，然后使用减缩器更改数据格式


var obj=[
{
“sno”：1，
“去年”：10000
},
{
“sno”：2，
“去年”：11500
},
{
“sno”：3，
“去年”：12500
},
{
“sno”：4，
“今年”：25400
},
{
“sno”：5，
“去年”：15000
},
{
“sno”：6，
“今年”：29800
}
]
常量getSeries=obj=>{
const emptyResult=getSeriesNames（obj）.map（seriesName=>({
序列号，
数据：[]
}));
返回对象减少（（结果，项目）=>{
const series=result.filter（项中的series=>series.seriesName）[0]
series.data.push（{value:item[series.seriesName]}）；
返回结果；
}，清空结果）；
}
const getSeriesNames=obj=>obj.reduce（（名称，项）=>{
对象。键（项）
.filter（key=>key！=='sno'）
.forEach（键=>{
如果（！name.includes（键））{
姓名。按（键）；
}
});
返回姓名；
}, []); 
console.log（getSeries（obj））
您可以通过从输入数组中不是
sno
的对象获取唯一的键名来提取键，然后使用减缩器更改数据格式


var obj=[
{
“sno”：1，
“去年”：10000
},
{
“sno”：2，
“去年”：11500
},
{
“sno”：3，
“去年”：12500
},
{
“sno”：4，
“今年”：25400
},
{
“sno”：5，
“去年”：15000
},
{
“sno”：6，
“今年”：29800
}
]
常量getSeries=obj=>{
const emptyResult=getSeriesNames（obj）.map（seriesName=>({
序列号，
数据：[]
}));
返回对象减少（（结果，项目）=>{
const series=result.filter（项中的series=>series.seriesName）[0]
series.data.push（{value:item[series.seriesName]}）；
返回结果；
}，清空结果）；
}
const getSeriesNames=obj=>obj.reduce（（名称，项）=>{
对象。键（项）
.filter（key=>key！=='sno'）
.forEach（键=>{
如果（！name.includes（键））{
姓名。按（键）；
}
});
返回姓名；
}, []); 
console.log（getSeries（obj））一个好的答案应该包括解释它是如何回答问题的，例如，为什么你认为这比OP“更好”。看起来我误解了这个问题。一个好的答案应该包括解释它是如何回答问题的，例如，为什么你认为这比OP“更好”。看起来我误解了这个问题。