Javascript-Äquivalent zur Zip-Funktion von Python

215

Gibt es ein Javascript-Äquivalent zur Zip-Funktion von Python? Das heißt, wenn mehrere Arrays gleicher Länge gegeben sind, wird ein Array von Paaren erzeugt.

Zum Beispiel, wenn ich drei Arrays habe, die so aussehen:

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

Das Ausgabearray sollte sein:

var output array:[[1,'a',4], [2,'b',5], [3,'c',6]]
pq.
quelle
5
Ist es fair zu sagen, dass wir Python-Programmierer Angst vor dummen Methoden mit Schleifen haben, weil sie langsam sind und daher immer nach integrierten Methoden suchen, um Dinge zu tun. Aber dass wir in Javascript einfach weitermachen und unsere Loops schreiben sollten, weil sie nicht besonders langsam sind?
LondonRob
3
@LondonRob Eine Schleife ist eine Schleife, die hinter einer 'schnellen' Methode versteckt ist oder nicht. JavaScript ist auf jeden Fall wurde mehr Unterstützung für Funktionen höherer Ordnung bekommen, mit der Einführung von Arrays forEach, reduce, map, everyetc. Es war nur der Fall , dass zipnicht „den Schnitt“ hat (a flatMapist auch nicht vorhanden), nicht für Leistungsinformationen - aber Um fair zu sein, hatte .NET (3.5) ein paar Jahre lang keine Zip on Enumerable! Jede 'funktionalistische' Bibliothek wie Unterstrich / lodash (lodash 3.x hat eine verzögerte Sequenzauswertung) bietet eine äquivalente Zip-Funktion.
user2864740
@ user2864740 Eine interpretierte Schleife (wie in Python) ist immer viel langsamer als eine Maschinencodeschleife. Eine JIT-kompilierte Schleife (wie in modernen JS-Engines) kann sich der nativen CPU-Geschwindigkeit so sehr nähern, dass die durch die Verwendung einer Maschinencode-Schleife eingeführte Verstärkung durch den Overhead des anonymen Funktionsaufrufs ausgeglichen werden kann. Trotzdem ist es sinnvoll, über diese integrierten Funktionen zu verfügen und verschiedene Variationen Ihrer "inneren Schleifen" mit mehreren JS-Engines zu profilieren. Die Ergebnisse sind möglicherweise nicht offensichtlich.
Tobia

Antworten:

177

Update 2016:

Hier ist eine schickere Ecmascript 6-Version:

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

Abbildung äquiv. zu Python { zip(*args)}:

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

(und FizzyTea weist darauf hin , dass ES6 variadische Argument Syntax hat, so dass die folgende Funktionsdefinition wie Python handeln, aber unter Disclaimer siehe ... das wird nicht über eine eigene inverse sein , so zip(zip(x))wird nicht gleich x, obwohl wie Matt Kramer weist darauf hin zip(...zip(...x))==x(wie in regulärer Python zip(*zip(*x))==x))

Alternative Definition äquiv. zu 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

(Beachten Sie, dass die ...Syntax zu diesem Zeitpunkt und möglicherweise in Zukunft möglicherweise Leistungsprobleme aufweist. Wenn Sie also die zweite Antwort mit verschiedenen Argumenten verwenden, möchten Sie sie möglicherweise perfekt testen.)


Hier ist ein Oneliner:

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

Das Obige setzt voraus, dass die Arrays gleich groß sind, wie sie sein sollten. Es wird auch davon ausgegangen, dass Sie ein einzelnes Listenargument übergeben, im Gegensatz zu Pythons Version, bei der die Argumentliste variadisch ist. Wenn Sie alle diese "Funktionen" möchten , siehe unten. Es dauert nur etwa 2 zusätzliche Codezeilen.

Im Folgenden wird das zipVerhalten von Python in Randfällen nachgeahmt, in denen die Arrays nicht gleich groß sind, und es wird stillschweigend so getan, als ob die längeren Teile der Arrays nicht vorhanden wären:

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

Dies ahmt das itertools.zip_longestVerhalten von Python nach und fügt ein, undefinedwo Arrays nicht definiert sind:

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

Wenn Sie diese beiden letzten Versionen verwenden (verschiedene Versionen mit mehreren Argumenten), ist zip nicht mehr die eigene Umkehrung. Um das zip(*[...])Idiom von Python nachzuahmen , müssen Sie dies tun, zip.apply(this, [...])wenn Sie die Zip-Funktion invertieren möchten oder wenn Sie auf ähnliche Weise eine variable Anzahl von Listen als Eingabe haben möchten.


Nachtrag :

Um dieses Handle iterierbar zu machen (z. B. in Python, das Sie zipfür Zeichenfolgen, Bereiche, Kartenobjekte usw. verwenden können), können Sie Folgendes definieren:

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

Allerdings , wenn Sie schreiben zipin der folgenden Art und Weise , auch das wird nicht nötig sein:

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

Demo:

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

(Oder Sie können eine range(...)Funktion im Python-Stil verwenden, wenn Sie bereits eine geschrieben haben. Schließlich können Sie ECMAScript-Array-Verständnis oder -Generatoren verwenden.)

Ninjagecko
quelle
1
Dies funktioniert bei mir nicht: TypeError: Objekt 1 hat keine Methode 'map'
Emanuele Paolini
7
Und ES6 für verschiedene Argumente und alle iterierbaren:zip = (...rows) => [...rows[0]].map((_,c) => rows.map(row => row[c]));
1983
Bei "Objekt 1 hat keine Methode 'map'" wird wahrscheinlich versucht, dies für ein Objekt zu verwenden, das keine Map-Methode (z. B. eine Knotenliste oder eine Zeichenfolge) hat, die im Anhang dieses Beitrags behandelt wurde
Ninjagecko
Es stimmt zwar, dass die variadische ES6-Version nicht erhalten bleibt zip(zip(x)) = x, aber Sie können sich trotzdem auf das Vertrauen verlassen, dass zip(...zip(...x)) = x.
Matt Kramer
const the_longest_array_length = Math.max(...(arrays.map(array => array.length)));
29онстантин Ван
34

Überprüfen Sie die Bibliothek Unterstrich .

Der Unterstrich bietet über 100 Funktionen, die sowohl Ihre bevorzugten funktionalen Helfer des Alltags unterstützen: Zuordnen, Filtern, Aufrufen - als auch speziellere Extras: Funktionsbindung, JavaScript-Vorlagen, Erstellen schneller Indizes, Tiefengleichheitstests usw.

- Sagen Sie die Leute, die es geschafft haben

Ich habe vor kurzem angefangen, es speziell für die zip()Funktion zu verwenden, und es hat einen großartigen ersten Eindruck hinterlassen. Ich benutze jQuery und CoffeeScript und es passt einfach perfekt zu ihnen. Der Unterstrich setzt genau dort an, wo er aufgehört hat, und hat mich bisher nicht enttäuscht. Ach übrigens, es ist nur 3kb minimiert.

Hör zu:

_.zip(['moe', 'larry', 'curly'], [30, 40, 50], [true, false, false]);
// returns [["moe", 30, true], ["larry", 40, false], ["curly", 50, false]]
Brandon
quelle
3
Wenn Sie Underscore verwenden, fühlen Sie sich der Klarheit und logischen Gemütlichkeit von Haskell etwas näher.
CamilB
12
Versuchen Sie Folgendes, anstatt zu unterstreichen: lodash.com - Drop-In-Ersatz, gleiches großartiges Aroma, mehr Funktionen, mehr browserübergreifende Konsistenz, bessere Leistung. Eine Beschreibung finden Sie unter kitcambridge.be/blog/say-hello-to-lo-dash .
Merlyn Morgan-Graham
16

Zusätzlich zu Ninjageckos hervorragender und umfassender Antwort reicht es aus, zwei JS-Arrays zu einem "Tupel-Mimic" zu komprimieren:

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

Erläuterung:
Da Javascript keinen tuplesTyp hat, hatten Funktionen für Tupel, Listen und Mengen in der Sprachspezifikation keine hohe Priorität.
Andernfalls ist ein ähnliches Verhalten auf einfache Weise über die Array-Zuordnung in JS> 1.6 zugänglich . ( mapwird tatsächlich oft von JS-Motorenherstellern in vielen> JS 1.4-Motoren implementiert, obwohl nicht angegeben).
Der wesentliche Unterschied zu Python zip, izip... Ergebnisse von map‚funktionalem Stil, da maperfordert ein funktions Argument. Zusätzlich ist es eine Funktion der Array-instance. Man kann Array.prototype.mapstattdessen verwenden, wenn eine zusätzliche Deklaration für die Eingabe ein Problem darstellt.

Beispiel:

_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]]})

Ergebnis:

//'('+_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)

Verwandte Leistung:

Verwenden von mapOver- forLoops:

Siehe: Was ist der effizienteste Weg, um [1,2] und [7,8] zu [[1,7], [2,8]] zusammenzuführen?

Reißverschlusstests

Hinweis: Die Basistypen wie falseund undefinedbesitzen keine prototypische Objekthierarchie und machen daher keine toStringFunktion verfügbar . Daher werden diese in der Ausgabe als leer angezeigt.
Da parseIntdas zweite Argument der Basis- / Zahlenradix ist, in den die Zahl konvertiert werden soll, und da mapder Index als zweites Argument an seine Argumentfunktion übergeben wird, wird eine Wrapperfunktion verwendet.

Lorenz Lo Sauer
quelle
Ihr erstes Beispiel sagt "aIn ist keine Funktion", wenn ich es versuche. Es funktioniert, wenn ich .map vom Array aus aufrufe und nicht als Prototyp: aIn.map(function(e, i) {return [e, aOut[i]];})Was ist falsch?
Noumenon
1
@ Noumenon, Array.prototype.maphätte Array.prototype.map.calldie Antwort korrigieren sollen .
Benutzer
11

Modernes ES6-Beispiel mit Generator:

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

Zuerst erhalten wir eine Liste von Iterables als iterators. Dies geschieht normalerweise transparent, aber hier tun wir es explizit, da wir Schritt für Schritt nachgeben, bis einer von ihnen erschöpft ist. Wir prüfen, ob eines der Ergebnisse (mit der .some()Methode) im angegebenen Array erschöpft ist, und wenn ja, unterbrechen wir die while-Schleife.

Dimitris
quelle
Diese Antwort könnte mehr Erklärung gebrauchen.
Cmaher
1
Wir erhalten eine Liste von Iteratoren von iterables. Dies geschieht normalerweise transparent, hier tun wir es explizit, da wir Schritt für Schritt nachgeben, bis einer von ihnen erschöpft ist. Überprüfen Sie, ob einer von ihnen (die .some () -Methode) im Array erschöpft ist, und wir unterbrechen, wenn dies der Fall ist.
Dimitris
11

Bietet neben anderen Python-ähnlichen Funktionen pythoniceine zipFunktion mit dem zusätzlichen Vorteil, dass eine verzögerte Auswertung zurückgegeben wird Iterator, ähnlich dem Verhalten des Python-Gegenstücks :

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))];

Offenlegung Ich bin Autor und Betreuer von Pythonic

Keyvan
quelle
7

Der Python hat zwei Funktionen: zip und itertools.zip_longest. Die Implementierung unter JS / ES6 sieht folgendermaßen aus:

Implementierung Pythons Zip unter JS / ES6

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

Ergebnisse:

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],
    []
));

[]

Implementierung Pythons zip_longest unter JS / ES6

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

Ergebnisse:

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

[[1, 667, 111, undefiniert], [2, falsch, undefiniert, undefiniert],
[3, -378, undefiniert, undefiniert], ['a', '337', undefiniert, undefiniert]]

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],
    []
));

[[1, 667, 111, 'Ist keine'], [2, falsch, 'Ist Keine', 'Ist Keine'],
[3, -378, 'Ist Keine', 'Ist Keine'], ['a ',' 337 ',' Ist keine ',' Ist keine ']]

PADYMKO
quelle
4

Sie können die Dienstprogrammfunktion mithilfe von ES6 aktivieren.

const zip = (arr, ...arrs) => {
  return 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.log(zip(array1, array2));                  // [[1, 'a'], [2, 'b'], [3, 'c']]
console.log(zip(array1, array2, array3));          // [[1, 'a', 4], [2, 'b', 5], [3, 'c', 6]]

In der obigen Lösung definiert die Länge des ersten Arrays jedoch die Länge des Ausgabearrays.

Hier ist die Lösung, bei der Sie mehr Kontrolle darüber haben. Es ist etwas komplex, aber es lohnt sich.

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

Bhargav Patel
quelle
4

1. Npm-Modul: zip-array

Ich habe ein npm-Modul gefunden, das als Javascript-Version von Python verwendet werden kann zip:

zip-array - Ein Javascript-Äquivalent zur Zip-Funktion von Python. Fügt die Werte der einzelnen Arrays zusammen.

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

2. tf.data.zip()in Tensorflow.js

Eine andere alternative Option ist für Benutzer von Tensorflow.js: Wenn Sie eine zipFunktion in Python benötigen , um mit Tensorflow-Datasets in Javascript zu arbeiten, können Sie diese tf.data.zip()in Tensorflow.js verwenden.

tf.data.zip () in Tensorflow.js dokumentiert an hier

Huan
quelle
3

Nicht in Javascript selbst integriert. Einige der gängigen Javascript-Frameworks (z. B. Prototype) bieten eine Implementierung, oder Sie können Ihre eigene schreiben.

Bernstein
quelle
1
Verknüpfung? Außerdem wäre ich mehr interessiert, wenn jQuery es tun würde, da ich das benutze ...
pq.
2
Beachten Sie jedoch, dass sich jQuery etwas anders verhält als Python, da es ein Objekt zurückgibt, kein Array ... und daher nicht mehr als 2 Listen zusammen komprimieren kann.
Amber
Richtig, der Autor sollte die jQuery nicht als gleichwertig bezeichnen.
pq.
3

Wie @Brandon, empfehle ich Unders ‚s Zip - Funktion. Es funktioniert jedoch so zip_longest, undefinedals würden Werte nach Bedarf angehängt , um etwas mit der Länge der längsten Eingabe zurückzugeben.

Ich habe die mixinMethode verwendet, um den Unterstrich mit einem zu erweitern zipShortest, der sich wie Pythons verhält zipund auf der eigenen Quelle der Bibliothek fürzip basiert .

Sie können Ihrem allgemeinen JS-Code Folgendes hinzufügen und ihn dann so aufrufen, als wäre er Teil des Unterstrichs: _.zipShortest([1,2,3], ['a'])Gibt [[1, 'a']]beispielsweise zurück.

// 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;
}});
Klopfen
quelle
Ohne Kommentar abstimmen? Ich bin froh, diese Antwort zu verbessern, kann aber nicht ohne Feedback.
Pat
2

Sie können das Array von Arrays reduzieren und ein neues Array zuordnen, indem Sie das Ergebnis des Index des inneren Arrays verwenden.

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

Nina Scholz
quelle
1

Eine Variation der Lazy Generator-Lösung :

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

Und dies ist die klassische "n-Gruppe" -Sprache der Python zip(*[iter(a)]*n):

triples = [...zip(...Array(3).fill(iter(a)))]
georg
quelle
Ich frage mich, was mit diesem falsch ist, ich habe genau das gleiche geschrieben. Für mich fühlt es sich viel besser an als für alle anderen, aber vielleicht liegen wir beide falsch ... Ich habe nach einer Möglichkeit gesucht, Flusstypen hinzuzufügen, aber ich habe Probleme: D.
Cglacet
0

Die Mochikit- Bibliothek bietet diese und viele andere Python-ähnliche Funktionen. Der Entwickler von Mochikit ist auch ein Python-Fan, hat also den allgemeinen Stil von Python und verpackt die asynchronen Aufrufe in ein verdrehtes Framework.

Keith
quelle
0

Ich habe dies in reinem JS versucht und mich gefragt, wie die oben veröffentlichten Plugins den Job erledigt haben. Hier ist mein Ergebnis. Ich werde dies vorwegnehmen, indem ich sage, dass ich keine Ahnung habe, wie stabil dies im IE und dergleichen sein wird. Es ist nur ein kurzes Modell.

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

Es ist nicht kugelsicher, aber es ist immer noch interessant.

Mr. Polywhirl
quelle
jsfiddle sieht gut aus. Hat einen TidyUp-Button! Die Schaltfläche Ausführen zeigte Ihre console.log-Ausgabe im Ergebnisfenster nicht an. Warum?
pq.
Es (console.log) erfordert so etwas wie Firebug, um ausgeführt zu werden. Wechseln Sie einfach console.logzu alert.
Wofür ist das Ergebnisfenster dann?
pq.
Es zeigt den HTML-Code der Geige. In diesem Fall mache ich nur gerade JS. Hier ist das Ergebnis mit document.write() jsfiddle.net/PyTWw/5
-1

Dies spart eine Linie von Ddis iteratorbasierter Antwort:

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);
  }
}
Steven Kalt
quelle
-1

Wenn Sie mit ES6 gut zurechtkommen:

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