将两个数组合并为一个；“拉链”；时尚-JavaScript

所以，我一直在考虑一些可以在JavaScript中使用数组的小练习。我想到了以“压缩”方式组合两个数组的想法（arrayA[0]、arrayB[0]、arrayA[1]、arrayB[1]…）等等。在一个可能更长的阵列中，任何剩余的东西都会被钉在末端

我搜索了stackoverflow——我问的原因是我目前正在学习编程入门课程，所以我们对JavaScript可以做的“事情”并不十分了解。如果可能的话，希望看到一个简单的解决方案

目前，我已经开始采用另一种方式，但我似乎无法将阵列剩余部分的最后一部分固定到底

function alternatingMerge(array1, array2)
//this function will merge two different arrays in an alternating fashion
//i.e = array1[0], array2[0], array1[1], array2[1], array1[2], array2[2], ... , etc
{
    var mergedArray;
    var i; // while loop counter
    var j; // 
    var k; // 
    var arrayLengths;

    arrayLengths = array1.length + array2.length;
    i = 0; // 
    j = 0; // ARRAY1 COUNTER
    k = 0; // ARRAY2 COUNTER
    mergedArray = new Array(arrayLengths);
    //window.alert(mergedArray);

    while (i < arrayLengths)
    {
        if (i%2 === 0)
        {
            mergedArray[i] = array2[j];
            j = j + 1;
        }
        else
        {
            mergedArray[i] = array1[k];
            k = k + 1;
        }
        i = i + 1;
    }
    return mergedArray;
}

函数交替合并（array1，array2）
//此函数将以交替方式合并两个不同的数组
//i、 e=array1[0]，array2[0]，array1[1]，array2[1]，array1[2]，array2[2]，等
{
达雷变种；
var i；//while循环计数器
var j；//
变量k；//
var排列长度；
ArrayLength=array1.length+array2.length；
i=0；//
j=0；//阵列1计数器
k=0；//阵列2计数器
mergedArray=新阵列（阵列长度）；
//窗口警报（合并Darray）；
而（i<排列长度）
{
如果（i%2==0）
{
mergedArray[i]=array2[j]；
j=j+1；
}
其他的
{
mergedArray[i]=array1[k]；
k=k+1；
}
i=i+1；
}
返回Darray；
}

我觉得这是很简单的事情，但一些帮助将不胜感激

这个怎么样：

function mergeAlternating(array1, array2) {
    var mergedArray = [];

    for (var i = 0, len = Math.max(array1.length, array2.length); i < len; i++) {
        if (i < array1.length) {
            mergedArray.push(array1[i]);
        }
        if (i < array2.length) {
            mergedArray.push(array2[i]);
        }
    }
    return mergedArray;
}

函数合并交替（array1，array2）{
var mergedArray=[]；
对于（变量i=0，len=Math.max（array1.length，array2.length）；i

这里是一个快速拍摄

// Takes an arbitrary number of arrays as arguments
function zip() {
   var merged = [], index = 0, cont, i;
   do {
      cont = false;
      for (var i=0; i<arguments.length; i++) {
         A = arguments[i];
         if (index < A.length) {   
            cont = true;
            merged.push(A[index]);
         }
      }
      index++;
   } while (cont);
   return merged;
}

merged = zip([1,3,5,7,9,11], [2,4,6,8]);
// [1, 2, 3, 4, 5, 6, 7, 8, 9, 11]

merged = zip([1, 4, 7], [2, 5, 8], [3, 6, 9])
// [1, 2, 3, 4, 5, 6, 7, 8, 9]

//将任意数量的数组作为参数
函数zip（）{
var合并=[]，指数=0，续，i；
做{
cont=假；
对于（var i=0；i我考虑了一会儿，这就是我想到的。它还支持任意数量的数组作为输入，就像其他一些答案一样

function merge() {
  var result = [];
  for (var i = 0;;++i) {
    var temp = [];
    for (var j = 0; j < arguments.length; ++j) {
      var atPos = arguments[j].slice(i, i+1);
      if (atPos.length) {
        temp.push(result.push(atPos[0]));
      }
    }
    if (temp.length == 0) {
      return result;
    }
  }
}

函数合并（）{
var结果=[]；
对于（变量i=0；；++i）{
var-temp=[]；
对于（var j=0；j

.filter（Boolean）
是删除一个数组在另一个数组之前为空而产生的
null
值所必需的。
这里有一个小而有效的编织函数，可用于使用ES6（现代浏览器）的任意大小的两个数组：


var w=（a，b）=>a.length？[a[0]，…w（b，a.slice（1））]：b；
var array1=[0,1,2,3,4,5,6,7,8,9]；
变量array2=['A'，'B'，'C'，'D'，'E']；
console.log（JSON.stringify（w（array1，array2））；
以下是使用和执行此操作的一种简单方法：


constzip=（a，b）=>Array.from（//创建一个数组
{length:Math.max（a.length，b.length）}，//与a和b中最长的一样长
（u，i）=>[a[i]，b[i]//用a和b的对填充它
).flat（）.filter（x=>x！==未定义）；//然后展平对并删除未定义的项
log（…zip（[1,2,3,4,5,6,7,8]，'a'，'b'，'c'，'d']）；
log（…zip（[1,2,3,4]，'a'，'b'，'c'，'d'，'e'，'f'，'g']）；
log（…zip（[1,2,4,5]，]）；
console.log（…zip（[]，['a'，'b'，'c'，'d']）；
replicate of:这很好，应该有更多的投票权，谢谢omikes！
var aOne = [1,3,5,7,9,11], aTwo = [2,4,6,8], aResult = [];
while (Math.max(aOne.length, aTwo.length) > 0)
  aResult.push(aOne.shift(), aTwo.shift());
document.writeln('aResult: ' + JSON.stringify(aResult.filter(Boolean)));
// aResult: [1,2,3,4,5,6,7,8,9,11]