4

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

我觉得这很简单，但我们将不胜感激！

4

6 回答 6

8

这是一个使用 ES6（现代浏览器）的任意大小的两个数组的小而有效的编织函数：

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

const array1 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
const 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。

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

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

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

const array1 = [1, 2];
const array2 = '♦♡♣♤♥♢';
const array3 = ['A', 'B', 'C'];
const array4 = ['', '', ''];
const array5 = [null, NaN, undefined];

const 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. 它不会影响编织功能的工作方式。

于 2019-03-09T12:59:26.297 回答
4

这个怎么样：

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;
}
于 2012-04-25T01:08:41.500 回答
2

这是一个快速的...

// 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]
于 2012-04-25T01:14:55.133 回答
2

这是使用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']));

于 2019-03-09T13:07:09.583 回答
0

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

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;
    }
  }
}
于 2012-04-25T06:27:21.380 回答
0 
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由于其中一个数组在另一个数组之前为空而产生的值。

于 2019-02-22T11:46:58.360 回答