可以使用map方法：

var array1 = [1, 2, 3, 4, 5];
var array2 = ['a', 'b', 'c', 'd', 'e'];

var arrayCombined = $.map(array1, function(v, i) {
  return [v, array2[i]];
});

console.log(arrayCombined);

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>

演示：http://jsfiddle.net/Guffa/hmUy6/

如果你必须使用jQuery，你可以利用他们的$.map实现。

var result = $.map(array1, function(v, i) {
                                return [v, array2[i]];
                           });

jQuery的$.map会展平返回的数组，从而得到想要的结果。

***DEMO：***http://jsfiddle.net/8rn2w/

纯JS溶液：

var result = array1.reduce(function(arr, v, i) {
                              return arr.concat(v, array2[i]); 
                           }, []);

***DEMO：***http://jsfiddle.net/8rn2w/1/

使用Array.prototype.flat()和Array.prototype.map()的另一个解决方案。

var array1 = [1, 2, 3, 4, 5];
var array2 = ['a', 'b', 'c', 'd', 'e'];

var result = array1.map(
  (element, index) => [element, array2[index]]
).flat();

console.log(result);

对于那些通过搜索引擎到达这里并想要Lodash选项的人：

_.compact(_.flatten(_.zip(array1, array2)))

试试这样的东西：

function merge(array1, array2) {
  if (array1.length == array2.length) {
    var c = [];
    for (var i = 0; i < array1.length; i++) {
      c.push([array1[i], array2[i]]);
    }
    return c;
  }
  return null;
}

我来到这里好奇地想看看是否有一个new Array.prototype.<whatever>()，这是有帮助的-和 flatMap 是…但我还是要用最简单，最明显的解决方案...
(and 10年来没有人使用for循环来构建单个数组）

普通的JavaScript

如果你要合并立体声通道或模板字符串等，这就是你所需要的：

// Supports the two most common cases:
//   - interleaving left and right audio channels
//   - interleaving template string and values
// (right is assumed to be the same length as left, or one shorter)
function interleave(left, right) {

  var both = [];
  var i;

  for (i = 0; i < left.length; i += 1) {
    both.push(left[i]);

    // because a template string will have one fewer value
    // than it will have string parts
    if (i < right.length) {
      both.push(right[i]);
    }
  }

  return both;
}

// a template string will always have one extra item
var abc = ['a', 'b', 'c', 'd' ];
var one = [1, 2, 3 ];

var both = interleave(abc, one);
console.log(both);
// ['a', 1, 'b', 2, 'c', 3, 'd']

flatMap

正如在评论中提到的，这可能是合适的：

function cleverInterleave() {
  return abc.flatMap(function (val, i) {
    if (one[i]) {
      return [val, one[i]];
    }
    return [val];
  });
}

var abc = ['a', 'b', 'c', 'd' ];
var one = [1, 2, 3 ];

cleverInterleave(abc, one);
// ['a', 1, 'b', 2, 'c', 3, 'd']

然而，这似乎有点太“聪明”，而不是 * 直观 *。也没有那么高效……但对于大多数代码来说可读性比效率重要得多所以...两次罢工反对。

mo' channels，mo' problems

您还可以创建一个更通用的形式来处理任意数量的数组，或者压缩长度不等的数组。
但是，我建议使用类似的模式，但要根据实际需要的数组数量进行调整，例如RGB为3，RGBA为4等。

如果您：
1.没有保证长度相同的数组。
1.不能保证第一个数组会比第二个长。
1.不需要依赖图书馆。

function interleave(a, b) {
  const interleaved = [];
  const lenA = a.length;
  const lenB = b.length;
  const len = Math.max(lenA, lenB);
  let i = 0;
  while (i < len) {
    if (lenA > i) interleaved.push(a[i]);
    if (lenB > i) interleaved.push(b[i]);
    i++;
  }
  return interleaved;
}

// Examples
const sameLength = interleave([1, 2], ['A', 'B']);
const aIsLonger = interleave([1, 2], ['A']);
const bIsLonger = interleave([1], ['A', 'B']);
const aIsEmpty = interleave([], ['A', 'B']);
const bIsEmpty = interleave([1, 2], []);

console.log('sameLength', sameLength);
console.log('aIsLonger', aIsLonger);
console.log('bIsLonger', bIsLonger);
console.log('aIsEmpty', aIsEmpty);
console.log('bIsEmpty', bIsEmpty);

我知道这个问题在12年前发布时特别提到了jQuery，所以你可能想为此选择另一个答案，但我没有把它硬塞到这个解决方案中。