这是我的解决方案

let zip = (a, b) => (a.length < b.length
  ? a.map((e, i) => [e, b[i]])
  : b.map((e, i) => [a[i], e]))

和@Brandon一样，我推荐Underscore的zip功能。但是，它的作用类似zip_longest，根据需要附加未定义的值以返回最长输入的长度。

我使用mixin方法用zipshort扩展下划线，它的作用类似于Python的zip，基于库自己的zip源代码。

你可以在你的普通JS代码中添加以下代码，然后像调用下划线一样调用它:_。zipShortest ([1, 2, 3], [a])返回[[1,' ']],例如。

// Underscore library addition - zip like python does, dominated by the shortest list
//  The default injects undefineds to match the length of the longest list.
_.mixin({
    zipShortest : function() {
        var args = Array.Prototype.slice.call(arguments);
        var length = _.min(_.pluck(args, 'length')); // changed max to min
        var results = new Array(length);
        for (var i = 0; i < length; i++) {
            results[i] = _.pluck(args, "" + i);
        }
        return results;
}});

python zip函数的生成器方法。

function* zip(...arrs){
  for(let i = 0; i < arrs[0].length; i++){
    a = arrs.map(e=>e[i])
    if(a.indexOf(undefined) == -1 ){yield a }else{return undefined;}
  }
}
// use as multiple iterators
for( let [a,b,c] of zip([1, 2, 3, 4], ['a', 'b', 'c', 'd'], ['hi', 'hello', 'howdy', 'how are you']) )
  console.log(a,b,c)

// creating new array with the combined arrays
let outputArr = []
for( let arr of zip([1, 2, 3, 4], ['a', 'b', 'c', 'd'], ['hi', 'hello', 'howdy', 'how are you']) )
  outputArr.push(arr)

查看下划线库。

Underscore提供了超过100个函数，这些函数既支持你最喜欢的日常函数帮助:映射、过滤器、调用——也支持更专业的功能:函数绑定、javascript模板、创建快速索引、深度等式测试等等。

-说说制作它的人

我最近开始专门为zip()函数使用它，它给我留下了很好的第一印象。我使用jQuery和CoffeeScript，它只是完美地与他们。下划线就在他们离开的地方，到目前为止，它还没有让我失望。哦，顺便说一下，它只缩小了3kb。

看看吧:

_.zip(['moe', 'larry', 'curly'], [30, 40, 50], [true, false, false]);
// returns [["moe", 30, true], ["larry", 40, false], ["curly", 50, false]]

如果你喜欢ES6:

const zip = (arr,...arrs) =>(
                            arr.map(
                              (v,i) => arrs.reduce((a,arr)=>[...a, arr[i]], [v])))

2016年更新:

下面是一个更时髦的Ecmascript 6版本:

zip= rows=>rows[0].map((_,c)=>rows.map(row=>row[c]))

对应于Python{zip(*args)}的插图:

> zip([['row0col0', 'row0col1', 'row0col2'],
       ['row1col0', 'row1col1', 'row1col2']]);
[["row0col0","row1col0"],
 ["row0col1","row1col1"],
 ["row0col2","row1col2"]]

(FizzyTea指出ES6有可变参数语法，所以下面的函数定义将像python一样，但请参见下面的免责声明…它不是它自己的逆函数所以zip(zip(x))不等于x;尽管正如Matt Kramer指出的那样，zip(…zip(…x))==x(就像常规python中的zip(*zip(*x))==x)))

Python{zip}的替代定义:

> zip = (...rows) => [...rows[0]].map((_,c) => rows.map(row => row[c]))
> zip( ['row0col0', 'row0col1', 'row0col2'] ,
       ['row1col0', 'row1col1', 'row1col2'] );
             // note zip(row0,row1), not zip(matrix)
same answer as above

(请注意…语法现在可能存在性能问题，将来也可能存在，因此如果使用带有可变参数的第二个答案，可能需要对其进行性能测试。也就是说，自从它被纳入标准已经有一段时间了。)

如果你想在字符串上使用它，一定要注意它的附录(也许现在用es6 iterables有更好的方法)。

---

这里有一句话:

function zip(arrays) {
    return arrays[0].map(function(_,i){
        return arrays.map(function(array){return array[i]})
    });
}

// > zip([[1,2],[11,22],[111,222]])
// [[1,11,111],[2,22,222]]]

// If you believe the following is a valid return value:
//   > zip([])
//   []
// then you can special-case it, or just do
//  return arrays.length==0 ? [] : arrays[0].map(...)

---

上面假设数组的大小相等，因为它们应该是相等的。它还假设你传递了一个单独的list of lists参数，不像Python版本的参数列表是可变的。如果你想要所有这些“特性”，请参见下面。它只需要额外的两行代码。

下面将模拟Python在数组大小不相等的边缘情况下的zip行为，默默地假装数组中较长的部分不存在:

function zip() {
    var args = [].slice.call(arguments);
    var shortest = args.length==0 ? [] : args.reduce(function(a,b){
        return a.length<b.length ? a : b
    });

    return shortest.map(function(_,i){
        return args.map(function(array){return array[i]})
    });
}

// > zip([1,2],[11,22],[111,222,333])
// [[1,11,111],[2,22,222]]]

// > zip()
// []

这将模拟Python的itertools.zip_longest行为，在未定义数组的地方插入undefined:

function zip() {
    var args = [].slice.call(arguments);
    var longest = args.reduce(function(a,b){
        return a.length>b.length ? a : b
    }, []);

    return longest.map(function(_,i){
        return args.map(function(array){return array[i]})
    });
}

// > zip([1,2],[11,22],[111,222,333])
// [[1,11,111],[2,22,222],[null,null,333]]

// > zip()
// []

如果你使用这最后两个版本(可变变量aka。多参数版本)，那么zip就不再是它自己的逆。要模仿Python中的zip(*[…])习语，需要执行zip。当您想要反转zip函数，或者如果您想类似地使用可变数量的列表作为输入时，应用(this，[…])。

---

附录:

要使此句柄为任何可迭代对象(例如，在Python中，您可以对字符串、范围、映射对象等使用zip)，您可以定义以下内容:

function iterView(iterable) {
    // returns an array equivalent to the iterable
}

然而，如果你以下面的方式写zip，即使这样也不需要:

function zip(arrays) {
    return Array.apply(null,Array(arrays[0].length)).map(function(_,i){
        return arrays.map(function(array){return array[i]})
    });
}

演示:

> JSON.stringify( zip(['abcde',[1,2,3,4,5]]) )
[["a",1],["b",2],["c",3],["d",4],["e",5]]

(或者你可以使用一个范围(…)python风格的函数(如果你已经写过的话)。最终，您将能够使用ECMAScript数组推导式或生成器。)