如何创建一个循环来创建对象，然后将这些对象推入数组？

Question

所以我开始导入 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. ]// mockconst threeToType = {   name: ["Lion", "Zebra", "Monkey"],  data1: [     4,       5,        2],  data2: [     9,      10,        6],  data3: [    10,       7,       14],};const {name, data1, data2, data3} = threeToType; // require('./threeToType');let objectArray = [];class makeObj{    constructor(nn, dat1, dat2, dat3){        this._nn = nn;        this._dat1 = dat1;        this._dat2 = dat2;        this._dat3 = dat3;    }}for(let newObj, i = 0, tN = "", tD1 = 0, tD2 = 0, tD3 = 0; i<name.length; i++){    tN = name[i];    tD1 = data1[i];    tD2 = data2[i];    tD3 = data3[i];    objectArray.push(newObj = new makeObj(tN, tD1, tD2, tD3));}console.log(objectArray);

Answer 1

为什么不只是简单地：

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)

}

Answer 2

获取您的nameArr, data1Arr, data2Arr, 和data3Arr来自/如何您希望 - 我已经为代码段使用了一些数据。

mapcv使用索引（此处）迭代数组（此处未使用）中的项目idx。

我们用它来idx从所有数组中检索“平行”项并从中创建一个对象。我们用括号 (和)

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

nameArr=["Zebra", "Lion", "Elephant"];

data1Arr=[23, 12, 40];

data2Arr=["Africa", "America", "India"];

data3Arr=[true, false, true];

objArr=nameArr.map((cv, idx)=>({

  name:nameArr[idx],

  data1:data1Arr[idx],

  data2:data2Arr[idx],

  data3:data3Arr[idx]

}));

console.log(objArr);

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

Answer 3

这是一个更通用的解决方案，假设您的输入数组基本上是表格的行（因为它们都具有相同的长度），并且您想要“翻转”或将它们反转为列。基本上是一个二维数组。

我会将输入数组的名称保留在该算法之外。在 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 ] ]

Answer 4

我目前不太确定您在问什么，您当前的解决方案确实有效。

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

// 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 = {

   name: ["Lion", "Zebra", "Monkey"],

  data1: [     4,       5,        2],

  data2: [     9,      10,        6],

  data3: [    10,       7,       14],

};

function columnsToRows(columns) {

  columns = Object.entries(columns);

  if (columns.length == 0) return [];

  

  const colLengths = columns.map(([,values]) => values.length);

  const maxColLength = Math.max(...colLengths);

  

  return Array.from({length: maxColLength}, (_, i) => {

    const row = Object.create(null);

    columns.forEach(([colName, values]) => row[colName] = values[i]);

    return row;

  });

}

function rowsToColumns(rows) {

  if (rows.length == 0) return {};

  const columns = Object.create(null);

  const colNames = new Set(rows.flatMap((row) => Object.keys(row)));

  

  colNames.forEach((colName) => columns[colName] = []);

  rows.forEach((row) => {

    colNames.forEach((colName) => columns[colName].push(row[colName]));

  });

  

  return columns;

}

console.log(columnsToRows(threeToType));

console.log(rowsToColumns(columnsToRows(threeToType)));