Javascript 将相同长度的数组合并到对象数组中

我有10个数据数组，如下所示：

var arr = [1,2,3,4,5,6,7,8,9,10]
var arr2=['hello','hello1','hello2','hello3','hello4','hello5','hello6','hello7','hello8','hello9']
...8 More Arrays

每个数组每次都将具有完全相同的元素数。我想知道生成这样一个对象数组的最佳方法，该数组结合了各种数组：

overallarray = [{
arr1 = 1,
arr2 = 'hello'
...
},
{
arr1 = 2,
arr2 = 'hello1'
...
}]

---

我知道我可以使用大量的for循环，但我正在寻找一个可能有人拥有的更优化的解决方案。

这就是

Array.map（）

将成为您的朋友的地方。您可以遍历任意数组（因为它们具有相同数量的元素），然后按索引访问每个元素，以获取数据集中每个数组的相应值，如下所示：

var arr=[0,1,2,3,4,5,6,7,8,9]
var arr2=[“你好”，“你好1”，“你好2”，“你好3”，“你好4”，“你好5”，“你好6”，“你好7”，“你好8”，“你好9]；
变量arr3=['foo'，'foo1'，'foo2'，'foo3'，'foo4'，'foo5'，'foo6'，'foo7'，'foo8'，'foo9']；
让mapped=arr.map（（元素，索引）=>{
返回{
arr1:arr[索引]，
arr2:arr2[索引]，
arr3:arr3[索引]
}
});
console.log（映射）假设
arr1
，
arr2
不是所需的结果对象属性名称（如果需要）


对于任意数量的数据数组，它可以很好地扩展
指定任意键名（不一定与数组变量名对应，更糟糕的是，需要的属性名不能是有效的变量名）
比公认的解决方案更有效；）

您可以执行以下操作：


const arr1=[1,2,3,4,5,6,7,8,9,10]，
arr2=[“你好”，“你好1”，“你好2”，“你好3”，“你好4”，“你好5”，“你好6”，“你好7”，“你好8”，“你好9”]，
keyNames=['id'，'greeting']，
组=（…数组）=>（键）=>
arrays.reduce（（res、arr、idx）=>
（arr.forEach（（e，i）=>res[i][keys[idx]]=e），res），
from（{length:arrays[0].length}，（）=>（{}））
)
console.log（组（arr1、arr2）（键名））
。作为控制台包装{min height:100%；}
只需使用1个循环计数器迭代所有数组：

    var dataArrayOne = [1, 2, 3, 4 ];
    var dataArrayTwo = ["hello", "hello1", "hello2", "hello3" ];
...

    var resultArray = [];

    for (var i = 0; i < 4; i++)
    {
        var combined = {
            arr1: dataArrayOne[I],
            arr2: dataArrayTwo[i]
...
        };

        resultArray.push(combined);
    }

var-dataArrayOne=[1,2,3,4]；
var dataArrayTwo=[“你好”，“你好1”，“你好2”，“你好3”]；
...
var resultArray=[]；
对于（变量i=0；i<4；i++）
{
组合风险值={
arr1:dataArrayOne[I]，
arr2:dataArrayTwo[i]
...
};
结果：推挤（组合）；
}
您可以从中获得：

[  [1, 2, 3]
,  [4, 5, 6]
,  [7, 8, 9]
]

[  [1, 4, 7]
,  [2, 5, 8]
,  [3, 6, 9]
]

为此：

[  [1, 4, 7]
,  [2, 5, 8]
,  [3, 6, 9]
]

[ {arr1: 1, arr2: 4, arr3: 7}
, {arr1: 2, arr2: 5, arr3: 8}
, {arr1: 3, arr2: 6, arr3: 9}
]

使用此功能：

const combine =
  (...arrs) =>
    [ arrs.map(xs => xs[0])
    , ... (  arrs.every(xs => xs.length === 1)
              ? []
              : combine(...arrs.map(xs => xs.slice(1)))
          )
    ];


combine
  (  [1, 2, 3]
  ,  [4, 5, 6]
  ,  [7, 8, 9]
  );

const to_obj =
  (...arrs) =>
    arrs.map(arr =>
      Object.fromEntries(
        arr.map((x, i) => [`arr${i+1}`, x])));

to_obj
  ( [1, 4, 7]
  , [2, 5, 8]
  , [3, 6, 9]
  )

然后从这个角度：

[  [1, 2, 3]
,  [4, 5, 6]
,  [7, 8, 9]
]

[  [1, 4, 7]
,  [2, 5, 8]
,  [3, 6, 9]
]

为此：

[  [1, 4, 7]
,  [2, 5, 8]
,  [3, 6, 9]
]

[ {arr1: 1, arr2: 4, arr3: 7}
, {arr1: 2, arr2: 5, arr3: 8}
, {arr1: 3, arr2: 6, arr3: 9}
]

使用此功能：

const combine =
  (...arrs) =>
    [ arrs.map(xs => xs[0])
    , ... (  arrs.every(xs => xs.length === 1)
              ? []
              : combine(...arrs.map(xs => xs.slice(1)))
          )
    ];


combine
  (  [1, 2, 3]
  ,  [4, 5, 6]
  ,  [7, 8, 9]
  );

const to_obj =
  (...arrs) =>
    arrs.map(arr =>
      Object.fromEntries(
        arr.map((x, i) => [`arr${i+1}`, x])));

to_obj
  ( [1, 4, 7]
  , [2, 5, 8]
  , [3, 6, 9]
  )

希望将这两个函数连接在一起是简单的


关于性能的说明

由于每10个元素正好有10个数组，您不太可能知道某个解决方案的性能是否优于另一个解决方案。您可能应该选择在可读性或维护方面感觉正确的解决方案

根据这些标准，你可能应该排除我的；只是想分享一种不同的方法。
为什么您的数据设置是这样的？您只需要一个循环，就可以循环索引以复制每个数组中所需的每个属性。一个循环，多个赋值给一个空白对象。dandavis是对的——如果你确信每个数组的长度完全相同，那么在任何一个数组上循环一次，只需重用当前迭代器值就可以了。@DakotaBrown:我确实在
arr1
不能作为所需属性名的行之间错过了它，所以我稍微改进了我的答案，你可以考虑使用它，因为它不仅仅是很好地缩放，而且可以指派不可变名称的属性名称，这是很重要的，尤其是对于更大的数据集。@ JHECHT，我的意思是你将如何组合这10个数组？在某些情况下，它们必须手动组合way@Jhecht更新以包含在
.map（）
@lainatnavi中一般处理数组的案例？对实际上？可能不会。应该这样做吗？绝对不是。@mhodges这就是我想要的，为了澄清为什么我的数据会以如此奇怪的方式移动，我正在集成几个SAAS平台，这些平台最初不是为协同工作而设计的，每个平台在格式和功能方面都有自己的数据需求，我必须解决这些需求。值得注意的是，阵列名称不一定是渐进式的。