Javascript 使用交替值合并两个数组

我想合并两个长度不同的数组：

let array1 = ["a", "b", "c", "d"];
let array2 = [1, 2];

我期望的结果是

[“a”，1，“b”，2，“c”，“d”]

---

最好的方法是什么？

创建一个元组数组。每个元组包含每个数组中的1个元素，通过展开元组数组并添加数组中的剩余项来展平：

常量a1=[“a”、“b”、“c”、“d”]； 常数a2=[1,2]； 常数l=数学最小值（a1.长度，a2.长度）； const merged=[].concat（…Array.from（{length:l}，（u，i）=>[a1[i]，a2[i]]，a1.slice（l），a2.slice（l））；

---

console.log（合并）您可以迭代数组和构建备用元素的最小长度，并在最后推送其余元素

var array1=[“a”、“b”、“c”、“d”]，
array2=[1,2]，
结果=[]，
i、 l=数学最小值（array1.length，array2.length）；
对于（i=0；i控制台日志（结果）这里有另一种方法，您可以使用解构赋值来完成-


const interleave=（[x，…xs]，ys=[]）=>
x==未定义
? ys//base:nox
：[x，…交错（ys，xs）]//归纳：一些x
console.log（交错（[0,2,4,6]，[1,3,5]）/[0 1,2,4,6]
console.log（交错（[0,2,4]，[1,3,5,7]）/[01,2,4,7]
console.log（交错（[0,2,4]，]）/[0,2,4]
console.log（交错（[]，[1,3,5,7]）/[1,3,5,7]
console.log（interleave（[]，[]）/[]
ONELINER：我假设
x=array1
，
y=array2
，x和y可以是任意arr

[...x,...y].reduce((l,c,i)=>(i<x.length&&l.push(x[i]),i<y.length&&l.push(y[i]),l),[])

[…x，…y].reduce（（l，c，i）=>（i您可以执行以下操作：


常量数组1=[“a”、“b”、“c”、“d”]；
常量数组2=[1,2]；
常量合并数组=（a，b）=>（a.length>b.length？a:b）
.reduce（（acc，cur，i）=>a[i]和&b[i]？[…acc，a[i]，b[i]：[…acc，cur]，]）；
console.log（mergeArrays（array1，array2））；//[“a”，1，“b”，2，“c”，“d”]
这可以通过使用
reduce
中的拼接函数来完成：


函数拼接器（数组、元素、索引）{
阵列拼接（索引*2，0，元素）；
返回数组；
}
功能编织（阵列1、阵列2）{
返回array1.reduce（拼接器，array2.slice（））；
}
设数组1=[“a”、“b”、“c”、“d”]；
设array2=[1,2]；
让结果=编织（排列1，排列2）；
console.log（结果）；
这是一个现代的解决方案，可以使用任意数量的阵列：

const braidArrays = (...arrays) => {
  const braided = [];
  for (let i = 0; i < Math.max(...arrays.map(a => a.length)); i++) {
    arrays.forEach((array) => {
      if (array[i] !== undefined) braided.push(array[i]);
    });
  }
  return braided;
};

这是一个有点冗长的解决方案，让您可以选择先使用哪个阵列

const a=['a'，'b'，'c']；
常数b=[1,4]；
const combinealternatingrays=（a，b）=>{
让合并=[]；
常量[更短，更大]=[a，b]。排序（（a，b）=>a.length-b.length）；
较短的forEach（（项目，i）=>{
组合推送（较大[i]，项目）；
})
组合推送（…较大切片（较短长度））；
综合收益；
}
console.log（组合存储阵列（a、b））；

也可以使用reduce，但语法在我看来不太清楚

const a=['a'，'b'，'c']；
常数b=[1,4]；
const combinealternatingrays=（a，b）=>{
常量[更短，更大]=[a，b]。排序（（a，b）=>a.length-b.length）；
还原(
（组合，下一个，i，更短）=>{
返回（i==（shorter.length-1））？[…组合，较大[i]，下一个，…较大的.slice（shorter.length）]：[…组合，较大[i]，下一个]；
},
[]
);
}
console.log（组合存储阵列（a、b））；
使用ES6，这通常可用于任意长度的任意数量的数组。关键是按顺序遍历所有数组，而不考虑长度，然后将它们拥有的每个值添加到单个合并数组中

通过使用数组的集合，我们可以统一处理每个数组中的项

当产生其他序列的一些交替值序列时，这通常被称为an。有时也称为a-这在扑克牌中更广为人知-完美的法罗洗牌将两堆牌组合在一起，使每堆牌交替。然而，这是一个交错序列和数学家的示例s也使用这个术语来描述交织的过程


//遍历所有数组并生成它们的值
函数*ParallelWalkAllarray（…数组）{
//获取每个数组的迭代器
const iterators=arrays.map（arr=>arr[Symbol.iterator]（））；
让价值观；
//循环直到完成
while（true）{
值=迭代器
.map（it=>it.next（））//addvance迭代器
.filter（（{done}）=>！done）//保留未完成的内容
.map（（{value}）=>value）；//获取值
//筋疲力尽就退出
如果（values.length==0）
返回；
//生成所有值的元组
屈服值；
}
}
函数交错合并数组（…数组）{
//启动发电机功能
常量序列=并行阵列（…阵列）；
让合并=[]；
//将每个结果展平为单个数组
for（序列的常量结果）{
合并。推送（…结果）
}
返回合并；
}
常数数组1=[1,2,3,4,5]；
常量数组2=['a'，'b'，'c'，'d'，'e']；
console.log(
交错合并阵列（阵列1、阵列2）
);
const shortArray=[“苹果”、“香蕉”]；
console.log(
交错合并阵列（阵列1，短阵列）
);
console.log(
交错合并阵列（短阵列，阵列2）
);
console.log(
交错合并阵列（阵列1、短阵列、阵列2）
)；
对于这种情况，我通常使用：


var=（a，b）=>{
常量maxLength=数学最大值（a.长度，b.长度）；
让结果=[]；
for（设i=0；iitem）；
};
设数组1=[“a”、“b”、“c”、“d”]；
设array2=[1,2]；
console.log（阵列1，ar
braidArrays(['a','b','c','d'], [1,2,3], [99,98,97,96,95]);
// ['a', 1, 99, 'b', 2, 98, 'c', 3, 97, 'd', 96, 95]

function *gen(arr1, arr2){
    for(let i = 0; i < Math.max(arr1.length, arr2.length); i++) {
        if (arr1[i]) yield arr1[i];
        if (arr2[i]) yield arr2[i];
    }
}
const x = gen(['a','b','c','d'], [1,2]);
const result = [...x];

Array(6) [ "a", 1, "b", 2, "c", "d" ]

const merge = (arr1, arr2) => ((arr1.length > arr2.length) ? arr1 : arr2).map((_,i)=>[arr1[i],arr2[i]]).flat().filter(Boolean);