Question

所以，我一直在想一些我可以用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;
}

我觉得这很简单，但有些帮助会受到赞赏！

Answer 1

这个怎么样：

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;
}

Answer 2

以下是使用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];
var array2 = ['A', 'B', 'C', 'D', 'E'];

console.log(JSON.stringify(w(array1, array2)));

说明：

变量w设置为此简短的递归函数：

(a, b) => a.length ? [a[0], ...w(b, a.slice(1))] : b

由于没有评论的余地，我将逐个解释它。

(a, b) =>-对于两个输入数组，a和b。

a.length-检查第一个数组是否为空。

? [___]-如果不为空，则返回一个数组。

a[0],-使该数组中的第一项与第一个数组中的第一项相同。

...w(b, a.slice(1))-使用相同的函数结果填充数组的其余部分，对第一个参数使用数组b，对第二个参数使用除数组a以外的所有内容

: b-否则，如果第一个数组为空，则返回数组b。

最终要做的是在第一和第二数组之间切换，从该数组中删除第一项，然后将其递归地传递回结果数组。这样做直到一个数组中没有剩余的项目为止，这时将返回另一个数组的其余部分，并将其添加到结果的末尾。

通过一些调整，它可以旋转任意数量的数组。此版本的运行方式基本相同，除了第一个数组获取默认值以处理没有输入的参数，第二个参数处理多个数组而不是一个。另外，在检查数组a的长度之前，它会对b中的数组进行计数，以查看是否还有剩余的数组可以旋转。如果没有，则返回数组a。如果还剩下数组，但a为空，则使用其余数组作为参数返回递归函数的结果。

var w = (a = [], ...b) => 
    b.length ? a.length ? [a[0], ...w(...b, a.slice(1))] : w(...b) : a;

var array1 = [1, 2];
var array2 = '♦♡♣♤♥♢';
var array3 = ['A', 'B', 'C'];
var array4 = ['', '', ''];
var array5 = [null, NaN, undefined];

var stringify = (o) => JSON.stringify(o, (k, v) => v === undefined ? '__undefined__' : v !== v ? '__NaN__' : v).replace(/"__undefined__"/g, 'undefined').replace(/"__NaN__"/g, 'NaN');

console.log(stringify(w()));
console.log(stringify(w(array1)));
console.log(stringify(w(array1, array2)));
console.log(stringify(w(array1, array2, array3)));
console.log(stringify(w(array1, array2, array3, array4)));
console.log(stringify(w(array1, array2, array3, array4, array5)));

我添加了stringify函数，以纠正JSON.stringify将NaN和undefined转换为null的问题。它不会影响编织功能的工作方式。

Answer 3

这是一个快速的...

// 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]

Answer 4

这是使用Array.from()，Array.flat()和Array.filter()的简短方法：

const zip = (a, b) => Array.from( // create an array
    { length: Math.max(a.length, b.length) }, // as long as the longest of a and b
    (_, i) => [a[i], b[i]] // fill it with pairs from a and b
  ).flat().filter(x => x !== undefined); // then flatten the pairs and remove undefined entries

console.log(...zip([1, 2, 3, 4, 5, 6, 7, 8], ['a', 'b', 'c', 'd']));
console.log(...zip([1, 2, 3, 4], ['a', 'b', 'c', 'd', 'e', 'f', 'g']));
console.log(...zip([1, 2, 4, 5], []));
console.log(...zip([], ['a', 'b', 'c', 'd']));

Answer 5

我想了一会儿，这就是我想出来的。它还支持任意数量的数组作为输入，就像其他一些答案一样。

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;
    }
  }
}

Answer 6

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]

.filter(Boolean)对于删除null值是必要的，这些值是由于其中一个数组在另一个数组之前为空而导致的。

以“压缩”方式组合两个数组 - JavaScript

6 个答案: