Python의 zip 기능과 동등한 Javascript

Python의 zip 기능과 동등한 Javascript

Python의 zip 기능과 동등한 javascript가 있습니까?즉, 동일한 길이의 배열이 여러 개 지정되면 쌍의 배열이 생성됩니다.

예를 들어 다음과 같은 어레이가 3개 있는 경우:

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

출력 배열은 다음과 같습니다.

var outputArray = [[1,'a',4], [2,'b',5], [3,'c',6]]

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

(그리고 아찔함)Tea는 ES6가 다양한 인수 구문을 가지고 있기 때문에 다음 함수의 정의는 python과 같이 동작하지만 면책사항에 대해서는 아래를 참조해 주십시오.이것은 그 자체로 역행하지 않을 것이다.zip(zip(x))같지 않다xMatt Kramer가 지적했듯이zip(...zip(...x))==x(일반 비단뱀처럼)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

(주의:...구문에는 현재 및 미래에 성능 문제가 있을 수 있으므로 variadic 인수와 함께 두 번째 응답을 사용할 경우 테스트를 수행할 수 있습니다.그것은 표준이 된지 꽤 오래되었다는 것을 의미합니다.)

이것을 스트링에 사용하고 싶은 경우는, 부록에 주의해 주세요(아마도 지금 es6를 반복해 사용하는 것이 더 좋은 방법이 있을 것입니다.

---

여기 오넬라이너가 있습니다.

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(...)

---

위의 예에서는 어레이의 사이즈가 같은 것을 상정하고 있습니다.또한 인수 목록이 가변적인 Python 버전과는 달리 lists 인수의 단일 목록을 전달한다고 가정합니다.이러한 「기능」을 모두 필요로 하는 경우는, 이하를 참조해 주세요.2줄 정도의 코드만 있으면 됩니다.

다음은 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()
// []

이 마지막 두 버전(변수 버전, multiple-argument 버전)을 사용하는 경우 zip은 더 이상 역이 아닙니다.의 흉내를 내다zip(*[...])Python의 이디옴, 당신은 할 필요가 있을 것입니다.zip.apply(this, [...])zip 함수를 반전하거나 마찬가지로 가변 개수의 목록을 입력으로 사용할 경우.

---

부록:

이 처리를 반복할 수 있도록 하기 위해(예를 들어 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]]

(또는range(...)Python 스타일의 함수는 이미 작성되어 있습니다.최종적으로는 ECMAScript 어레이의 압축 또는 생성기를 사용할 수 있게 됩니다.)

라이브러리의 언더스코어를 확인합니다.

Underscore는 사용자가 좋아하는 기능 도우미(맵, 필터, 호출)뿐만 아니라 함수 바인딩, javascript templating, 빠른 인덱스 작성, 딥 평등 테스트 등 보다 전문적인 기능을 지원하는 100개 이상의 기능을 제공합니다.

– 만든 사람에게 말합니다.

최근 기능 전용으로 사용하기 시작했는데, 첫인상이 좋습니다.저는 jQuery와 CoffeeScript를 사용하고 있는데, 그것들과 완벽하게 어울립니다.언더스코어는 그들이 멈춘 부분부터 시작하며 지금까지 나를 실망시키지 않았다.아, 그런데 3kb밖에 안 됐어요.

확인해 주세요.

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

발전기를 사용하는 최신 ES6 예:

function *zip (...iterables){
    let iterators = iterables.map(i => i[Symbol.iterator]() )
    while (true) {
        let results = iterators.map(iter => iter.next() )
        if (results.some(res => res.done) ) return
        else yield results.map(res => res.value )
    }
}

우선, 반복 가능한 리스트가 표시됩니다.iterators이 작업은 보통 투명하게 진행되지만, 여기서는 명시적으로 수행합니다.그 중 하나가 소진될 때까지 단계적으로 진행되기 때문입니다.결과 중 하나가 있는지 확인합니다(사용방법:.some()method)는 지정된 배열의 모든 것을 사용하므로, 사용 가능한 경우 while 루프가 끊어집니다.

ninjagecko의 탁월하고 포괄적인 답변과 더불어 두 개의 JS 어레이를 "튜플-미믹"으로 압축하는 데 필요한 것은 다음과 같습니다.

//Arrays: aIn, aOut
Array.prototype.map.call( aIn, function(e,i){return [e, aOut[i]];})

설명:
Javascript에는 다음과 같은 기능이 없기 때문에tuples언어 사양에서는 유형, 튜플 함수, 목록 및 집합의 우선순위가 높지 않았습니다.
그렇지 않으면 JS > 1.6의 어레이 맵을 통해 동일한 동작에 쉽게 접근할 수 있습니다.map> JS 1.4 엔진의 많은 JS 엔진 메이커에 의해 실제로 실장되어 있는 경우가 많습니다(지정되어 있지 않은 경우도 있습니다).
의 큰 zip,izip ...의, ... ★★★★map 「」이래, 「」의 기능 스타일map에는 함수 변환이 필요합니다., 이 함수는 addition, addition, 능, 능, , addition, , addition, of의 함수입니다.Array- - - 。사용할 수 있다Array.prototype.map대신 입력에 대한 추가 선언이 문제가 되는 경우.

예제:

_tarrin = [0..constructor, function(){}, false, undefined, '', 100, 123.324,
         2343243243242343242354365476453654625345345, 'sdf23423dsfsdf',
         'sdf2324.234dfs','234,234fsf','100,100','100.100']
_parseInt = function(i){return parseInt(i);}
_tarrout = _tarrin.map(_parseInt)
_tarrin.map(function(e,i,a){return [e, _tarrout[i]]})

결과:

//'('+_tarrin.map(function(e,i,a){return [e, _tarrout[i]]}).join('),\n(')+')'
>>
(function Number() { [native code] },NaN),
(function (){},NaN),
(false,NaN),
(,NaN),
(,NaN),
(100,100),
(123.324,123),
(2.3432432432423434e+42,2),
(sdf23423dsfsdf,NaN),
(sdf2324.234dfs,NaN),
(234,234fsf,234),
(100,100,100),
(100.100,100)

관련 퍼포먼스:

「」를 사용합니다.map에 걸쳐서forfilenovel:

참고 항목: [1,2] 및 [7,8]을 [1,7], [2,8]로 통합하는 가장 효율적인 방법은 무엇입니까?

주의: 다음과 같은 기본 유형:false ★★★★★★★★★★★★★★★★★」undefined, 시제품의 사물을 노출시키지 .toString됩니다.따라서 출력에는 아무것도 표시되지 않습니다.
~로parseInt의 두 기수는 " " " "부터 " " "부터 " base/number "입니다.map는 인덱스를 인수 함수에 두 번째 인수로 전달하고 래퍼 함수를 사용합니다.

Python과 유사한 다른 함수와 함께, 는zip이 함수는 Python의 동작과 마찬가지로 lazy evaluated를 반환하는 추가적인 이점이 있습니다.

import {zip, zipLongest} from 'pythonic';

const arr1 = ['a', 'b'];
const arr2 = ['c', 'd', 'e'];
for (const [first, second] of zip(arr1, arr2))
    console.log(`first: ${first}, second: ${second}`);
// first: a, second: c
// first: b, second: d

for (const [first, second] of zipLongest(arr1, arr2))
    console.log(`first: ${first}, second: ${second}`);
// first: a, second: c
// first: b, second: d
// first: undefined, second: e

// unzip
const [arrayFirst, arraySecond] = [...zip(...zip(arr1, arr2))];

폭로 나는 피토닉의 작가이자 유지자이다.

Python에는 zip과 itertools.zip_longest의 두 가지 zip 시퀀스가 있습니다.동일한 기능을 위한 Javascript 구현은 다음과 같습니다.

JS/ES6에서 Python의 zip 구현

const zip = (...arrays) => {
    const length = Math.min(...arrays.map(arr => arr.length));
    return Array.from({ length }, (value, index) => arrays.map((array => array[index])));
};

결과:

console.log(zip(
    [1, 2, 3, 'a'],
    [667, false, -378, '337'],
    [111],
    [11, 221]
));

[ [ 1, 667, 111, 11 ] ]

console.log(zip(
    [1, 2, 3, 'a'],
    [667, false, -378, '337'],
    [111, 212, 323, 433, '1111']
));

[ [ 1, 667, 111 ], [2, false, 212 ], [3, -378, 323 ], [a', '337', 433 ]

console.log(zip(
    [1, 2, 3, 'a'],
    [667, false, -378, '337'],
    [111],
    []
));

[]

JS/ES6에서 Python의 zip_longest 구현

(https://docs.python.org/3.5/library/itertools.html?highlight=zip_longest#itertools.zip_longest)

const zipLongest = (placeholder = undefined, ...arrays) => {
    const length = Math.max(...arrays.map(arr => arr.length));
    return Array.from(
        { length }, (value, index) => arrays.map(
            array => array.length - 1 >= index ? array[index] : placeholder
        )
    );
};

결과:

console.log(zipLongest(
    undefined,
    [1, 2, 3, 'a'],
    [667, false, -378, '337'],
    [111],
    []
));

[ 1 undefined [2, undefined [1, 667, 111, undefined], [2, false, defined, undefined],
3 , undefined [ , ' undefined ,] , [ 3, -378 , ] , [ 'a , ' , ' 337 , ] , 、 [ [ [ [ 、 、 [ [ ]

console.log(zipLongest(
    null,
    [1, 2, 3, 'a'],
    [667, false, -378, '337'],
    [111],
    []
));

[ [ 1, 667, 111, null ], [2, false, null, null], [3, -378, null, null], [a', '337', null, null]

console.log(zipLongest(
    'Is None',
    [1, 2, 3, 'a'],
    [667, false, -378, '337'],
    [111],
    []
));

'2 ' ' '없음 [1, 667, 111, '없음', [2, false, '없음',
' ' ' ' '3, -378, 'ㄴ 'ㄴ', 'ㄴ', 'ㄴ', 'ㄴ', 'ㄴ', 'ㄴ', 'ㄴ', 'ㄴ', 'ㄴ', 'ㄴ', 'ㄴ', 'ㄴ', 'ㄴ', 'ㄴ', 'ㄴ', 'ㄴ', 'ㄴ', 'ㄴ', 'ㄴ', 'ㄴ', 'ㄴ', 'ㄴ', 'ㄴ', 'ㄴ', 'ㄴ', 'ㄴ', 'ㄴ', 'ㄴ', 'ㄴ', 'ㄴ', 'ㄴ', 'ㄴ', 'ㄴ', 'ㄴ', 'ㄴ', 'ㄴ', '

ES6를 사용하면 유틸리티 기능을 할 수 있습니다.

console.json = obj => console.log(JSON.stringify(obj));

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

// Example

const array1 = [1, 2, 3];
const array2 = ['a','b','c'];
const array3 = [4, 5, 6];

console.json(zip(array1, array2));         // [[1,"a"],[2,"b"],[3,"c"]]
console.json(zip(array1, array2, array3)); // [[1,"a",4],[2,"b",5],[3,"c",6]]

단, 위의 첫 번째 어레이의 솔루션 길이는 출력 어레이의 길이를 정의합니다.

다음은 사용자가 보다 효과적으로 제어할 수 있는 솔루션입니다.좀 복잡하지만 그럴 가치가 있어요.

function _zip(func, args) {
  const iterators = args.map(arr => arr[Symbol.iterator]());
  let iterateInstances = iterators.map((i) => i.next());
  ret = []
  while(iterateInstances[func](it => !it.done)) {
    ret.push(iterateInstances.map(it => it.value));
    iterateInstances = iterators.map((i) => i.next());
  }
  return ret;
}
const array1 = [1, 2, 3];
const array2 = ['a','b','c'];
const array3 = [4, 5, 6];

const zipShort = (...args) => _zip('every', args);

const zipLong = (...args) => _zip('some', args);

console.log(zipShort(array1, array2, array3)) // [[1, 'a', 4], [2, 'b', 5], [3, 'c', 6]]
console.log(zipLong([1,2,3], [4,5,6, 7]))
// [
//  [ 1, 4 ],
//  [ 2, 5 ],
//  [ 3, 6 ],
//  [ undefined, 7 ]]

모듈: 1. Npm 모듈:zip-array

javascript로 사용할 수.zip:

zip-array - Python의 zip 기능과 동등한 Javascript입니다.각 배열의 값을 병합합니다.

https://www.npmjs.com/package/zip-array

2. tf.data.zip()Tensorflow.jsTensorflow.js로 합니다.

다른 선택은 Tensorflow 사용자를 입니다.Tensorflow.js가 한 경우 Tensorflow.js는 Tensorflow.js는 Tensorflow.js를 사용합니다.필요한 경우zip python의 는 Javascript의 python을 사용할 수 .tf.data.zip()Tensorflow.js는 Tensorflow.js에 있습니다.

Tensorflow.js의 tf.data.zip()은 여기에서 문서화되어 있습니다.

Javascript 자체에 내장되어 있지 않습니다.일반적인 Javascript 프레임워크 중 일부(예: 프로토타입)는 구현을 제공하거나 사용자가 직접 작성할 수 있습니다.

@Brandon과 마찬가지로 Underscore의 zip 기능을 추천합니다.하지만, 그것은 마치zip_longest, 가 ,"undefined가장 긴 입력의 길이를 반환하는 데 필요한 값을 지정합니다.

이 방법을 사용하여 언더스코어를 확장했습니다.zipShortestPython과 같은 zip의 라이브러리 자체 소스를 기반으로 합니다.

의 JS 에 다음의 하고, 스코어의 처럼 부를 수 .「 JS 」_.zipShortest([1,2,3], ['a'])[[1, 'a']]

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

지연 발생기 솔루션의 변형:

function* iter(it) {
    yield* it;
}

function* zip(...its) {
    its = its.map(iter);
    while (true) {
        let rs = its.map(it => it.next());
        if (rs.some(r => r.done))
            return;
        yield rs.map(r => r.value);
    }
}

for (let r of zip([1,2,3], [4,5,6,7], [8,9,0,11,22]))
    console.log(r.join())

// the only change for "longest" is some -> every

function* zipLongest(...its) {
    its = its.map(iter);
    while (true) {
        let rs = its.map(it => it.next());
        if (rs.every(r => r.done))
            return;
        yield rs.map(r => r.value);
    }
}

for (let r of zipLongest([1,2,3], [4,5,6,7], [8,9,0,11,22]))
    console.log(r.join())

입니다.zip(*[iter(a)]*n):

triples = [...zip(...Array(3).fill(iter(a)))]

원래 답변(아래 업데이트 참조)

임의의 수의 어레이를 취하도록 flm의 니프티 답변을 수정했습니다.

 function* zip(arrays, i = 0) {
  while (i<Math.min(...arrays.map(({length})=>length))) {
    yield arrays.map((arr, j) => arr[j < arrays.length - 1 ? i : i++])
  }
 }

갱신된 답변

Tom Pohl이 지적한 바와 같이 이 함수는 가짜 값을 가진 어레이를 처리할 수 없습니다.다음은 모든 유형 및 동일하지 않은 길이의 어레이에 대응할 수 있는 업데이트/개선된 버전입니다.

 function* zip(arrays, i = 0) {
      while (i<Math.min(...arrays.map(arr=>arr.length))) {
        yield arrays.map((arr, j) => arr[j < arrays.length - 1 ? i : i++])
      }
     }
     
   const arr1 = [false,0,1,2]
const arr2 = [100,null,99,98,97]
const arr3 = [7,8,undefined,"monkey","banana"]

console.log(...zip([arr1,arr2,arr3]))

ES2020 최단 변종:

function * zip(arr1, arr2, i = 0) {
  while(arr1[i] || arr2[i]) yield [arr1[i], arr2[i++]].filter(x => !!x);
}
    
[ ...zip(arr1, arr2) ]  // result

내부 어레이의 인덱스 결과를 가져와 어레이의 어레이를 줄이고 새 어레이를 매핑할 수 있습니다.

var array1 = [1, 2, 3],
    array2 = ['a','b','c'],
    array3 = [4, 5, 6],
    array = [array1, array2, array3],
    transposed = array.reduce((r, a) => a.map((v, i) => (r[i] || []).concat(v)), []);

console.log(transposed);

스프레드 재밌다.

const
    transpose = (r, a) => a.map((v, i) => [...(r[i] || []), v]),
    array1 = [1, 2, 3],
    array2 = ['a','b','c'],
    array3 = [4, 5, 6],
    transposed = [array1, array2, array3].reduce(transpose, []);

console.log(transposed);

JS에서 이 작업을 수행하면서 위에 게시된 플러그인이 어떻게 작업을 수행했는지 궁금했습니다.제 결과는 이렇습니다.IE 등에서 얼마나 안정적일지 모르겠다고 서문을 쓰겠습니다.그냥 간단한 모형이에요.

init();

function init() {
    var one = [0, 1, 2, 3];
    var two = [4, 5, 6, 7];
    var three = [8, 9, 10, 11, 12];
    var four = zip(one, two, one);
    //returns array
    //four = zip(one, two, three);
    //returns false since three.length !== two.length
    console.log(four);
}

function zip() {
    for (var i = 0; i < arguments.length; i++) {
        if (!arguments[i].length || !arguments.toString()) {
            return false;
        }
        if (i >= 1) {
            if (arguments[i].length !== arguments[i - 1].length) {
                return false;
            }
        }
    }
    var zipped = [];
    for (var j = 0; j < arguments[0].length; j++) {
        var toBeZipped = [];
        for (var k = 0; k < arguments.length; k++) {
            toBeZipped.push(arguments[k][j]);
        }
        zipped.push(toBeZipped);
    }
    return zipped;
}

방탄은 아니지만 그래도 재미있어요.

비단뱀의 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)

지퍼 기능을 제공하는 옵션과 함께 심플한 기능을 만들었습니다.

function zip(zipper, ...arrays) {
    if (zipper instanceof Array) {
        arrays.unshift(zipper)
        zipper = (...elements) => elements
    }

    const length = Math.min(...arrays.map(array => array.length))
    const zipped = []

    for (let i = 0; i < length; i++) {
        zipped.push(zipper(...arrays.map(array => array[i])))
    }

    return zipped
}

https://gist.github.com/AmrIKhudair/4b740149c29c492859e00f451832975b

많은 이 Javascript를 사용하여 가장 것 .Array.map괜찮지만, 나처럼 javascript를 매일 사용하지 않는 사람에게는 좀 더 읽기 쉬운 대안이 몇 가지 있습니다.

귀엽고 영리한 코드를 피하는 방법은 다음과 같습니다.

function zip(a,b){
    // pre-allocate an array to hold the results 
    rval=Array(Math.max(a.length, b.length));
    for(i=0; i<rval.length; i++){ 
        rval[i]=[a[i],b[i]] 
    }
    return rval
}

생성기를 원하는 경우:

function* _zip(a,b){
    len = Math.max(a.length, b.length) // handle different sized arrays
    for(i=0; i<len; i++) { yield [a[i],b[i]] }
}

꼭 사용하기를 Array.map:

function map(a,b){
    x = a.length > b.length ? a : b // call map on the biggest array
    return x.map((_,i)=>[a[i],b[i]])
}

말씀드렸듯이, 저는 일상적으로 Javascript를 사용하는 사람이 아니기 때문에, 가장 우아한 솔루션은 아니지만, 읽을 수 있습니다.

다음은 iter-ops 라이브러리, 오퍼레이터 zip을 사용하여 빠르고 효율적으로 수행할 수 있는 방법입니다.

const {pipe, zip} = require('iter-ops');

const i = pipe(array1, zip(array2, array3));

console.log(...i); //=> [ 1, 'a', 4 ] [ 2, 'b', 5 ] [ 3, 'c', 6 ]

라이브러리는 모든 입력을 반복 처리하므로 한 번만 반복됩니다.으로 모든 가능한 오브젝트 - 그 handle and and and 、 - - 、 - and 、 and and 、 and and and and and 。Iterable,AsyncIterable,Iterator,AsyncIterator.

---

추신: 저는 반복 수술의 저자입니다.

Mochikit 라이브러리는 이것과 많은 다른 Python과 같은 기능을 제공합니다.Mochikit의 개발자도 Python 팬이기 때문에 Python의 일반적인 스타일을 가지고 있으며,는 비동기 호출을 트위스트와 같은 프레임워크로 랩합니다.

동등한 함수는 없습니다.가 몇 는, 「」를 사용해 주세요.for후.loop을 선택합니다.

var array1 = [1, 2, 3];
var array2 = ['a','b','c'];

for (let i = 0; i < Math.min(array1.length, array2.length); i++) {
    doStuff(array1[i], array2[i]);
}

어레이에 내부 루프가 있는 경우 어레이에 내부 루프가 있을 수 있습니다.

이것이 나의 해결책이다.

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

이것에 의해, Ddi 의 반복자 베이스의 회답과는 다른 행이 됩니다.

function* zip(...toZip) {
  const iterators = toZip.map((arg) => arg[Symbol.iterator]());
  const next = () => toZip = iterators.map((iter) => iter.next());
  while (next().every((item) => !item.done)) {
    yield toZip.map((item) => item.value);
  }
}

ES6에 문제가 없는 경우:

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

언급URL : https://stackoverflow.com/questions/4856717/javascript-equivalent-of-pythons-zip-function