Javascript。如何创建一个循环来创建对象，然后将这些对象推送到数组中？

因此，我开始导入4个不同的数组，其中包含等量的数据

然后我创建了一个类，认为该类可以帮助我使用导入的数据创建对象

所以我的想法是，如果我循环该类，它可以通过索引生成一个包含所有4个数组数据的对象，然后将该对象推送到数组中

我希望我的objectArray的最终结果会像

[ {nn: "Lion", dat1: 4, dat2: 9, dat3: 10}, {nn: "Zebra", dat1: 5, dat2: 10, dat3: 7}, {nn: "Monkey", dat1: 2, dat2: 6, dat3: 14} ...etc. ]

//模拟
常数threeToType={
名称：[“狮子”、“斑马”、“猴子”]，
数据1:[4,5,2],，
数据2:[9,10,6],，
数据3:[10,7,14]，
};
const{name，data1，data2，data3}=threeToType；//要求（'./threeToType'）；
让objectArray=[]；
类makeObj{
构造函数（nn、dat1、dat2、dat3）{
这个。_nn=nn；
这个。_dat1=dat1；
这个._dat2=dat2；
这个._dat3=dat3；
}
}
对于（让newObj，i=0，tN=”，tD1=0，tD2=0，tD3=0；i为什么不简单地：

const {name, data1, data2, data3} = require('./threeToType');
let objectArray = []
for (let i = 0; i < name.length; i++) {
  let newItem = { nn: name[i], tD1: data1[i], tD2: data2[i], td3: data3[i] }
  objectArray.push(newItem)
}

const{name，data1，data2，data3}=require（'./threeToType'）；
让objectArray=[]
for（设i=0；i
按照您的意愿从/获取您的
nameArr
、
data1Arr
、
data2Arr
和
data3Arr
——我已经为代码片段使用了一些数据

map
使用索引（
idx
此处）迭代数组中的项（
cv
此处，未使用）。

我们使用该
idx
从所有数组中检索“并行”项，并从中生成一个对象。

我们用括号（
（
和
）
）包围对象，因为它是返回的，我们不希望浏览器认为它是代码（
返回
是一个函数，但我们可以省略括号，在这里-我们使用它们）


nameArr=[“斑马”、“狮子”、“大象”]；
data1Arr=[23,12,40]；
数据2ARR=[“非洲”、“美国”、“印度”]；
data3Arr=[true，false，true]；
objArr=nameArr.map（（cv，idx）=>({
名称：nameArr[idx]，
data1:data1Arr[idx]，
data2:data2Arr[idx]，
data3:data3Arr[idx]
}));
console.log（objArr）；
.as console wrapper{max height:100%！important；top:0；}
这里有一个更通用的解决方案，它假设您的输入数组基本上是表中的行（因为它们都具有相同的长度），并且您希望将它们“翻转”或反转为列。基本上是二维数组

我不想让输入数组的名称出现在这个算法中。在JS中，没有简单的方法可以将变量的名称（比如代码片段中的“data1”）作为字符串获取

顺便说一句，你可以用任意数量的数组来调用它，只要它们都具有相同的长度

const invertRows = (...rows) => {
    const numRows = rows.length;
    const numColumns = rows[0].length;

    const inverted = new Array(numColumns);
    for (let col=0; col < numColumns; col++) {
        inverted[col] = new Array(numRows);
        for (let row=0; row < numRows; row++) {
            inverted[col][row] = rows[row][col];
        }
    }
    return inverted;
};

const arr1 = [1,2,3];
const arr2 = [3,4,5];

console.log(invertRows(arr1, arr2));

// Returns: [ [ 1, 3 ], [ 2, 4 ], [ 3, 5 ] ]

const invertRows=（…rows）=>{
const numRows=rows.length；
常量numColumns=行[0]。长度；
const inversed=新数组（numColumns）；
for（设col=0；col
我目前不确定您的要求，您当前的解决方案确实有效

以下是转换数据结构的通用解决方案：

// from
const columns = {name: ["John Doe", "Jane Doe"], age: [42, 39]};
// into
const rows = [{name: "John Doe", age: 42}, {name: "Jane Doe", age: 39}];
// and the other way around.


const threeToType={
名称：[“狮子”、“斑马”、“猴子”]，
数据1:[4,5,2],，
数据2:[9,10,6],，
数据3:[10,7,14]，
};
函数columnsToRows（列）{
columns=Object.entries（列）；
if（columns.length==0）返回[]；
const collength=columns.map（（[，value]）=>values.length）；
常数MaxColleLength=数学最大值（…ColleLength）；
返回数组。from（{length:maxColLength}，（\ux，i）=>{
const row=Object.create（空）；
columns.forEach（（[colName，values]）=>row[colName]=values[i]）；
返回行；
});
}
函数rowsToColumns（行）{
if（rows.length==0）返回{}；
const columns=Object.create（null）；
const colNames=new Set（rows.flatMap（（row）=>Object.keys（row））；
forEach（（colName）=>columns[colName]=[]）；
rows.forEach（（row）=>{
forEach（（colName）=>columns[colName].push（row[colName]）；
});
返回列；
}
log（columnsToRows（threeToType））；
console.log（rowsToColumns（columnsToRows（threeToType））；
您能否详细说明“它可以通过索引生成一个包含所有4个数组的数据的对象，然后将该对象推送到数组中。”确切的意思是？我不知道你想完成什么。啊，我没意识到你想做什么。如果你把4个数组看作表中的4行，你想把行变成列。不，你不需要一个
类来帮助你创建对象。一个简单的对象文字就足够了。但是不管怎样，你的代码你的意思是
name[i]
？（你写了
name[o]
。）如果我的答案有用，请投票并选择。谢谢。