将对象的关键点和值转换为对象数组

Question

所以我有一个看起来像这样的数据结构：

data = {
a: [1, 2, 3, 4, 5],
b: ["a", "b", "c", "d", "e"],
c: ["123", "235423", "12312", "1231", "12312"],
d: ["aa", "bb", "cc", "dd", "ee"],
...
}

我需要将其转换为以下结构：

[
{ a: 1, b: "a", c: "123", d: "aa", ... },
{ a: 2, b: "b", c: "235423", d: "bb", ... },
{ a: 3, b: "c", c: "12312", d: "cc", ... },
{ a: 4, b: "d", c: "1231", d: "dd", ... },
{ a: 5, b: "a", c: "12312", d: "ee", ... },
]

data中的键的数量可以变化，但值的长度在所有阵列中总是相同的，即data[a].length === data[z].length总是真的。

我的解决方案：

const doStuff = () => {
const result = [];
const keys = Object.keys(data);
if (!keys) return result;
const valuesLength = keys[0].length
const result = [];
for (let i = 0; i < valuesLength ; i++) {
const obj = {};
for (const key in data) {
obj[key] = data[key][i];
}
result.push(obj);
}
return result;
};

使用两个for循环不是最有效的一个，因为密钥的数量可能很大，所以我正在寻找一个最优化的解决方案

Answer 1

您可以使用Array.prototype.reduce()遍历源对象键(Object.keys()(，使用Array.prototype.forEach()循环内部数组，并为结果对象分配相应的属性：

const src = {a:[1,2,3,4,5],b:["a","b","c","d","e"],c:["123","235423","12312","1231","12312"],d:["aa","bb","cc","dd","ee"]},
result = Object
.keys(src)
.reduce((acc, key, i, keys) => {
src[key].forEach((v, j) => {
acc[j] = acc[j] || {}
acc[j][key] = v
})
return acc
}, [])

console.log(result)

.as-console-wrapper{min-height:100%;}

Answer 2

解决方案需要两个循环。一个用于遍历对象中的属性，另一个用于循环遍历值数组。

就我个人而言，我会使用reduce和forEach作为两个循环

const data = {
a: [1, 2, 3, 4, 5],
b: ["a", "b", "c", "d", "e"],
c: ["123", "235423", "12312", "1231", "12312"],
d: ["aa", "bb", "cc", "dd", "ee"]
}
const result = Object.entries(data).reduce((arr, [key, values]) => (
values.forEach((value, index) => {
arr[index] = {
...arr[index],
[key]: value
};
}),
arr), []);
console.log(result);

没有肥箭和破坏

var data = {
a: [1, 2, 3, 4, 5],
b: ["a", "b", "c", "d", "e"],
c: ["123", "235423", "12312", "1231", "12312"],
d: ["aa", "bb", "cc", "dd", "ee"]
};
var result = Object.entries(data).reduce(function(result, entry) {
var key = entry[0];
var arr = entry[1];
arr.forEach(function(value, index) {
result[index] = result[index] || {};
result[index][key] = value;
});
return result;
}, []);
console.log(result);

Answer 3

请检查以下代码：

var data = {
a: [1, 2, 3, 4, 5],
b: ["a", "b", "c", "d", "e"],
c: ["123", "235423", "12312", "1231", "12312"],
d: ["aa", "bb", "cc", "dd", "ee"]
}

var anotherObjArray = [];
for(var i=0;i<data[Object.keys(data)[0]].length;i++){
let tempObj = {};
for(var j=0;j<Object.keys(data).length;j++){
tempObj[Object.keys(data)[j]] = data[Object.keys(data)[j]][i];    
}
anotherObjArray.push(tempObj);
}

anotherObjArray是满足您需求的最终数组。

Answer 4

通过假设相同长度的数组，您可以获得条目，并通过映射所有值以及位于相同索引和新属性的对象来减少数组。

const
data = { a: [1, 2, 3, 4, 5], b: ["a", "b", "c", "d", "e"], c: ["123", "235423", "12312", "1231", "12312"], d: ["aa", "bb", "cc", "dd", "ee"] },
result = Object
.entries(data)
.reduce((r, [k, a]) => a.map((v, i) => ({ ...r[i], [k]: v })), []);
console.log(result);

.as-console-wrapper { max-height: 100% !important; top: 0; }