Javascript 将中的对象数组转换为一个逗号分隔的对象

我有下面的数组

常数arr=

0: Object { 1: 1, 6: 1, 11: 1, … }
1: Object { 2: "3", 7: "", 12: "", … }
2: Object { 3: "3", 8: "", 13: "", … }
3: Object { 4: "", 9: "", 19: "3", … }
4: Object { 5: "4", 10: "", 15: "", … }

我希望它像转换非空值一样进行转换

{1:2，6:1，11:1，2:3，3:3，19:3，5:4}

我尝试了以下解决方案：

let result = JSON.stringify(arr).replace(/(\[)(.+)(\])/g, "{$2}");

但我得到的结果是

{{"1":1,"6":1,"11":1,"16":1},{"2":"3","7":"","12":"","17":""},{"3":"3","8":"","13":"","18":""},{"4":"","9":"","14":"","19":"3"},{"5":"4","10":"","15":"","20":""}}

---

请帮助您获得所需的回复。

这里有一个片段可以帮助您开始。对于重复的关键点，将保留后面的关键点，但如果这不是所需的行为，则可以添加一个简单的if条件来保留第一次出现的关键点或根据需要处理它

让arr=[
{1: 1, 6: 1, 11: 1,},
{2: "3", 7: "", 12: "",},
{3: "3", 8: "", 13: "",},
{4: "", 9: "", 19: "3",},
{5: "4", 10: "", 15: "",},
];
让输出={}；
arr.forEach（a=>Object.entries（a）
.filter（（[，value]）=>value）
.forEach（（[key，value]）=>output[key]=value））；
控制台日志（输出）这里有一个片段让您开始学习。对于重复的关键点，将保留后面的关键点，但如果这不是所需的行为，则可以添加一个简单的if条件来保留第一次出现的关键点或根据需要处理它


让arr=[
{1: 1, 6: 1, 11: 1,},
{2: "3", 7: "", 12: "",},
{3: "3", 8: "", 13: "",},
{4: "", 9: "", 19: "3",},
{5: "4", 10: "", 15: "",},
];
让输出={}；
arr.forEach（a=>Object.entries（a）
.filter（（[，value]）=>value）
.forEach（（[key，value]）=>output[key]=value））；
控制台日志（输出）因此您需要循环所有索引，然后循环所有键并查看它们是否有值


var-arr=[
{ 1: 1, 6: 1, 11: 1},
{ 2: "3", 7: "", 12: ""},
{ 3: "3", 8: "", 13: ""},
{ 4: "", 9: "", 19: "3"},
{ 5: "4", 10: "", 15: ""}
]
var out=arr.REDUCT（（结果，obj）=>{
Object.entries（obj.forEach）（[key，value]）=>{
如果（值！==“”）{
结果[键]=数字（值）
}
})
返回结果
}, {})
log（JSON.stringify（out））
因此需要循环所有索引，然后循环所有键，看看它们是否有值


var-arr=[
{ 1: 1, 6: 1, 11: 1},
{ 2: "3", 7: "", 12: ""},
{ 3: "3", 8: "", 13: ""},
{ 4: "", 9: "", 19: "3"},
{ 5: "4", 10: "", 15: ""}
]
var out=arr.REDUCT（（结果，obj）=>{
Object.entries（obj.forEach）（[key，value]）=>{
如果（值！==“”）{
结果[键]=数字（值）
}
})
返回结果
}, {})
console.log（JSON.stringify（out））
一个可能的解决方案是生成一个新的
对象。在下一个解决方案中，如果内部对象之间存在共享密钥，则最新的
值
将存储在最终的
对象
上。对于将字符串强制转换为数字，我们使用运算符：


const arr=[
{1: 1, 6: 1, 11: 1},
{2: "3", 7: "", 12: ""},
{3: "3", 8: "", 13: ""},
{4: "", 9: "", 19: "3"},
{5: "4", 10: "", 15: ""}
];
让res=arr.reduce（（acc，obj）=>
{
Object.entries（obj.forEach）（[k，v]）=>
{
如果（v！=“acc[k]=+v；
});
返回acc；
}, {});
控制台日志（res）
.as控制台{背景色：黑色！重要；颜色：石灰；}
.作为控制台包装{max height:100%！important；top:0；}
一个可能的解决方案是使用生成新的
对象。在下一个解决方案中，如果内部对象之间存在共享密钥，则最新的
值
将存储在最终的
对象
上。对于将字符串强制转换为数字，我们使用运算符：


const arr=[
{1: 1, 6: 1, 11: 1},
{2: "3", 7: "", 12: ""},
{3: "3", 8: "", 13: ""},
{4: "", 9: "", 19: "3"},
{5: "4", 10: "", 15: ""}
];
让res=arr.reduce（（acc，obj）=>
{
Object.entries（obj.forEach）（[k，v]）=>
{
如果（v！=“acc[k]=+v；
});
返回acc；
}, {});
控制台日志（res）
.as控制台{背景色：黑色！重要；颜色：石灰；}
。作为控制台包装{max height:100%！important；top:0；}
如果顺序不重要，这将提供您正在寻找的解决方案：


const arr=[
{ 1: 1, 6: 1, 11: 1 },
{ 2: "3", 7: "", 12: "" },
{ 3: "3", 8: "", 13: "" },
{ 4: "", 9: "", 19: "3" },
{ 5: "4", 10: "", 15: ""}
];
让减少=到达减少（（acc，val）=>{
对象分配（acc，
Object.keys（val）
.filter（key=>val[key]）
.reduce（（res，key）=>（res[key]=+val[key]，res），{}）
);
返回acc；
}, {});
log（JSON.stringify（reduced））如果订单不重要，这将提供您正在寻找的解决方案：


const arr=[
{ 1: 1, 6: 1, 11: 1 },
{ 2: "3", 7: "", 12: "" },
{ 3: "3", 8: "", 13: "" },
{ 4: "", 9: "", 19: "3" },
{ 5: "4", 10: "", 15: ""}
];
让减少=到达减少（（acc，val）=>{
对象分配（acc，
Object.keys（val）
.filter（key=>val[key]）
.reduce（（res，key）=>（res[key]=+val[key]，res），{}）
);
返回acc；
}, {});
log（JSON.stringify（reduced））如果发生碰撞（两个对象具有相同的键），您希望发生什么？如果一些内部对象共享相同的
键，您会怎么做？您希望在输出中保留哪一个？按键不会重复。它们是唯一的如果发生碰撞（两个对象具有相同的键），您希望发生什么？如果一些内部对象共享相同的
键，您会怎么做？您希望在输出中保留哪一个？按键不会重复。它们是唯一的。我可以将其作为“{1:1，6:1，11:1，2:3…等等”}”…就像我需要strigify对象，但不需要使用JSON.stringify@epascarelloSo reg exp来删除引号一样
JSON.stringify（out）.replace（/“/g）”）
我可以把它作为“{1:1，6:1，11:1，2:3…等等”…就像我需要strigify对象，但不需要JSON.stringify@epascarelloSo reg exp来删除引号一样？
JSON.stringify（out）.replace（/“/g）”）