Javascript-Äquivalent zur Zip-Funktion von Python

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

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

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

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?

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.

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.

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

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

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

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

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

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

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

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

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.

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.

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

Wenn Sie mit ES6 gut zurechtkommen:

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