Python'un zip işlevinin Javascript eşdeğeri

Python'un zip işlevinin javascript eşdeğeri var mı? Yani, eşit uzunlukta birden çok dizi verildiğinde bir çift çifti oluşturur.

Örneğin, şöyle görünen üç dizim varsa:

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

Çıktı dizisi şöyle olmalıdır:

var output array:[[1,'a',4], [2,'b',5], [3,'c',6]]

2016 güncellemesi:

İşte daha güzel bir Ecmascript 6 sürümü:

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

Çizim eşdeğeri. için Python { zip(*args)}:

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

(ve FizzyTea, ES6'nın varyasyon argümanı sözdizimine sahip olduğuna dikkat çekiyor, bu nedenle aşağıdaki işlev tanımı python gibi davranacak, ancak sorumluluk reddi için aşağıya bakın ... bu kendi tersi olmayacak, bu yüzden zip(zip(x))eşit olmayacak x; Matt Kramer'ın işaret ettiği zip(...zip(...x))==xgibi (gibi normal python içinde zip(*zip(*x))==x))

Alternatif tanım eşdeğeri. için 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

( ...Sözdiziminin şu anda ve muhtemelen gelecekte performans sorunları olabileceğini unutmayın , bu nedenle ikinci yanıtı değişken değişkenli argümanlarla kullanırsanız, bunu mükemmel bir şekilde test etmek isteyebilirsiniz.)

İşte bir 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(...)

Yukarıdaki, dizilerin olması gerektiği gibi eşit büyüklükte olduğunu varsayar. Ayrıca, Python'un argüman listesinin varyasyonlu versiyonundan farklı olarak tek bir liste argümanı listesine geçtiğinizi varsayar.Bu "özelliklerin" tümünü istiyorsanız , aşağıya bakın. Fazladan 2 satır daha kod gerektirir.

Aşağıdakiler zip, dizilerin eşit büyüklükte olmadığı, dizilerin daha uzun bölümlerinin mevcut olmadığını sessizce iddia eden uç durumlarda Python'un davranışını taklit edecektir :

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

Bu, dizilerin tanımlanmadığı yerlere itertools.zip_longestekleyerek Python'un davranışını taklit eder 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()
// []

Bu son iki sürümü (variadic aka. Çoklu bağımsız değişken sürümleri) kullanıyorsanız, zip artık kendi tersi değildir. zip(*[...])Python'dan deyimi taklit zip.apply(this, [...])etmek için zip işlevini ters çevirmek istediğinizde veya giriş olarak değişken sayıda listeye sahip olmak istediğinizde yapmanız gerekir.

ek :

Bu tanıtıcıyı yinelenebilir yapmak için (örneğin, Python'da zipdizelerde, aralıklarda, harita nesnelerinde vb. Kullanabilirsiniz ) aşağıdakileri tanımlayabilirsiniz:

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

Ancak zipaşağıdaki şekilde yazarsanız , bu bile gerekli olmayacaktır:

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

(Ya da range(...)zaten bir tane yazdıysanız Python tarzı bir işlev kullanabilirsiniz . Sonunda ECMAScript dizi anlayışlarını veya oluşturucularını kullanabilirsiniz.)

Alt çizgi kütüphanesine göz atın .

Alt çizgi, en sevdiğiniz geçici işlev yardımcılarını destekleyen 100'den fazla işlev sunar: harita, filtreleme, başlatma - ve daha özel ürünler: işlev bağlama, javascript şablonlama, hızlı dizin oluşturma, derin eşitlik testi vb.

- Bunu yapanlara söyle

Son zamanlarda özellikle zip() işlev ve harika bir ilk izlenim bıraktı. Ben jQuery ve CoffeeScript kullanıyorum ve sadece onlarla birlikte mükemmel gidiyor. Alt çizgi, bıraktıkları yerden devam ediyor ve şimdiye kadar beni hayal kırıklığına uğratmadı. Bu arada, sadece 3kb küçültülmüş.

Bunu kontrol et:

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

Ninjagecko'nun mükemmel ve kapsamlı cevabına ek olarak, iki JS dizisini "tuple-mimic" e sıkıştırmak için gereken tek şey:

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

Açıklama:
Javascript'in bir tuplestürü olmadığından , tuples, listeler ve kümeler için işlevler dil belirtiminde yüksek bir öncelik değildi.
Aksi takdirde, benzer davranışa JS> 1.6'daki Array haritası üzerinden doğrudan erişilebilir . ( mapaslında belirtilmese de çoğu JS 1.4 motorunda genellikle JS motor üreticileri tarafından uygulanır).
Python en başlıca fark zip, izip... kaynaklanır mapbireyin fonksiyonel tarzda, çünkü mapbir işlev-bağımsız değişken gerektirir. Ayrıca Array-intance işlevidir. Array.prototype.mapGirdi için fazladan bir bildirim söz konusuysa bunun yerine biri kullanılabilir .

Misal:

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

Sonuç:

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

İlgili Performans:

Kullanılması mapüzerinde for-loops:

Bakınız: [1,2] ve [7,8] 'i [[1,7], [2,8]] ile birleştirmenin en etkili yolu nedir?

Not: baz tipleri gibi falseve undefinedbir maruz değildir ve böylece bir prototypal nesne hiyerarşisini posess olmayan ve toStringişlevi. Dolayısıyla bunlar çıktıda boş olarak gösterilir.
De parseIntbireyin ikinci bağımsız sayı dönüştürmek için olan baz / sayı radix, olduğu için ve mapargümanı işlev ikinci değişken olarak dizin geçer, bir sargı fonksiyonu kullanılır.

Jeneratörlü modern ES6 örneği:

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

İlk olarak, tekrarlanabilirlerin bir listesini alırız iterators. Bu genellikle şeffaf bir şekilde gerçekleşir, ancak burada açık bir şekilde yapıyoruz, çünkü bunlardan biri tükenene kadar adım adım verdik. .some()Verilen dizideki sonuçlardan herhangi birinin ( yöntemi kullanarak ) tükenip tükenmediğini kontrol ediyoruz ve eğer öyleyse while döngüsünü bozuyoruz.

Diğer Python benzeri işlevlerin yanı sıra , Python muadilinin davranışına benzer şekilde, değerlendirilen tembel bir geri döndürmenin ekstra faydası olan pythonicbir zipişlev sunar :Iterator

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

Açıklama Pythonic'in yazarı ve koruyucusuyum

Python'un iki işlevi vardır: zip ve itertools.zip_longest. JS / ES6 uygulaması şu şekildedir:

JS / ES6 üzerinde Python`un zip uygulaması

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

Sonuçlar:

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, yanlış, 212], [3, -378, 323], ['a', '337', 433]]

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

[]

JS / ES6'da Python`un zip_longest uygulaması

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

Sonuçlar:

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

[[1, 667, 111, tanımsız], [2, yanlış, tanımsız, tanımsız],
[3, -378, tanımsız, tanımsız], ['a', '337', tanımsız, tanımsız]]

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

[[1, 667, 111, null], [2, yanlış, 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, 'Yok'], [2, yanlış, 'Yok', 'Yok'],
[3, -378, 'Yok', 'Yok'], ['a ',' 337 ',' Yok ',' Yok ']]

ES6'yı kullanarak yardımcı program işlevini yapabilirsiniz.

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

Ancak, yukarıdaki çözümde birinci dizinin uzunluğu çıkış dizisinin uzunluğunu tanımlar.

İşte üzerinde daha fazla kontrole sahip olduğunuz çözüm. Biraz karmaşık ama buna değer.

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 Modülü: zip-array

Python javascript sürümü olarak kullanılabilecek bir npm modülü buldum zip:

zip-array - Python'un zip işlevinin bir javascript eşdeğeri. Dizilerin her birinin değerlerini birleştirir.

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

2. tf.data.zip()Tensorflow.js içinde

Başka bir seçenek Tensorflow.js kullanıcıları için: zipJavascript'teki tensorflow veri kümeleriyle çalışmak için python'da bir işleve ihtiyacınız varsa , Tensorflow.js'de kullanabilirsiniz tf.data.zip().

Burada belgelenen Tensorflow.js'deki tf.data.zip ()

Javascript'in kendisinde yerleşik değildir. Ortak Javascript çerçevelerinden bazıları (Prototip gibi) bir uygulama sağlar veya kendiniz yazabilirsiniz.

@Brandon gibi ben tavsiye altını çizmek 'in zip fonksiyonu. Bununla birlikte, en uzun girdinin uzunluğunu döndürmek için gereken değerleri zip_longesteklemek gibi davranır undefined.

Ben kullanılan mixinbir ile alt çizgi uzatmak için yöntem zipShortestPython en gibi davranır, zipkapalı dayalı, için kütüphanenin kendi kaynağındanzip .

Ortak JS kodunuza aşağıdakileri ekleyebilir ve ardından alt çizginin bir parçasıymış gibi çağırabilirsiniz: örneğin, _.zipShortest([1,2,3], ['a'])döndürür [[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;
}});

Dizilerin dizisini azaltabilir ve iç dizinin dizinini alarak yeni diziyi eşleyebilirsiniz.

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

Tembel jeneratör çözümünün bir varyasyonu :

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

Ve bu pitonun klasik "n-grubu" deyimidir zip(*[iter(a)]*n):

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

MochiKit kütüphane bu ve diğer birçok fonksiyonları Python benzeri sağlar. Mochikit geliştiricisi de bir Python hayranıdır, bu nedenle genel Python stiline sahiptir ve aynı zamanda asenkron çağrıları bükülmüş bir çerçevede sarar.

Saf JS'de bir çalışma yaptım, yukarıdaki eklentilerin işi nasıl yaptığını merak ettim. İşte benim sonucum. Bunun IE'de ve benzerlerinde ne kadar kararlı olacağına dair hiçbir fikrim olmadığını söyleyerek önsöz yapacağım. Sadece hızlı bir maket.

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

Kurşun geçirmez değil, ama yine de ilginç.

Bu, Ddi'nin yineleyici tabanlı yanıtından bir satır çıkarır :

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 ile sorun yaşıyorsanız:

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