पाइथन के जिप फ़ंक्शन के बराबर जावास्क्रिप्ट

Question

क्या पायथन के ज़िप फ़ंक्शन के बराबर एक जावास्क्रिप्ट है? यही है, समान लंबाई के कई ऐरे दिए गए जोड़े की एक सरणी बनाते हैं।

उदाहरण के लिए, यदि मेरे पास तीन सरणियाँ हैं जो इस तरह दिखती हैं:

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

आउटपुट सरणी होनी चाहिए:

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

Comments

क्या यह कहना उचित है कि हम पायथन प्रोग्रामर लूप से जुड़े गूंगे तरीकों से 'डरते हैं' क्योंकि वे धीमे हैं, और इसलिए हमेशा चीजों को करने के अंतर्निहित तरीकों की तलाश करते हैं। लेकिन उस जावास्क्रिप्ट में हमें बस इसके साथ मिलना चाहिए और हमारे छोरों को लिखना चाहिए क्योंकि वे विशेष रूप से धीमा नहीं हैं?

— लंदनरोब

@LondonRob एक लूप एक लूप है, जो 'फास्ट' विधि के पीछे छिपा है या नहीं। जावास्क्रिप्ट निश्चित रूप से सरणी के की शुरूआत के साथ उच्च आदेश कार्यों के लिए और अधिक समर्थन मिल रहे थे, forEach, reduce, map, every, आदि यह सिर्फ मामला था कि zipथा कि "कटौती कर" नहीं (एक flatMapभी अनुपस्थित है), प्रदर्शन विचार के लिए नहीं है - लेकिन निष्पक्ष होने के लिए, .NET (3.5) के पास कुछ वर्षों के लिए अनगिनत पर जिप नहीं थी! अंडरस्कोर / लॉश (लॉश 3.x में आलसी अनुक्रम मूल्यांकन) जैसी कोई भी 'फंक्शनलिश लाइब्रेरी' एक समान ज़िप फ़ंक्शन प्रदान करेगी।

— user2864740

@ user2864740 एक व्याख्यायित लूप (जैसे पायथन में) हमेशा मशीन कोड लूप की तुलना में बहुत धीमा होगा । एक जेआईटी-संकलित लूप (जैसे कि आधुनिक जेएस इंजन) में देशी सीपीयू की गति हो सकती है, इतना है कि मशीन कोड लूप का उपयोग करके शुरू किया गया लाभ अनाम फ़ंक्शन कॉल के ओवरहेड द्वारा ऑफसेट किया जा सकता है। फिर भी, यह इन अंतर्निहित कार्यों को करने और कई जेएस इंजनों के साथ आपके "इनर लूप" के कई रूपों को प्रोफाइल करने के लिए समझ में आता है। परिणाम स्पष्ट नहीं हो सकता है।

— तोबिया

Answer 1

2016 अपडेट:

यहाँ एक चकाचौंधा Ecmascript 6 संस्करण है:

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

चित्रण समान। करने के लिए अजगर { zip(*args)}:

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

(और FizzyTea बताते हैं कि ES6 में वैरिएड तर्क वाक्य है, इसलिए निम्न फ़ंक्शन परिभाषा अजगर की तरह काम करेगी, लेकिन अस्वीकरण के लिए नीचे देखें ... यह इसका स्वयं का व्युत्क्रम नहीं zip(zip(x))होगा, इसलिए बराबर नहीं होगा x; हालांकि जैसा कि मैट क्रैमर बताते हैं zip(...zip(...x))==x(जैसे) नियमित रूप से अजगर zip(*zip(*x))==x))

वैकल्पिक परिभाषा equiv। करने के लिए अजगर { 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

(कृपया ध्यान दें कि ...इस समय वाक्यविन्यास में प्रदर्शन के मुद्दे हो सकते हैं, और संभवतः भविष्य में, इसलिए यदि आप दूसरे उत्तर का उपयोग वैरेडिक तर्कों के साथ करते हैं, तो आप इसे पूरा करना चाहते हैं।)

---

यहाँ एक 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(...)

---

उपरोक्त मानता है कि सरणियाँ समान आकार की हैं, जैसा कि उन्हें होना चाहिए। यह भी मानता है कि आप पायथन के संस्करण के विपरीत सूचियों के तर्क की एक सूची में गुजरते हैं, जहां तर्क सूची परिवर्तनशील है। यदि आप इन सभी "सुविधाओं" को चाहते हैं, तो नीचे देखें। यह कोड की लगभग 2 अतिरिक्त लाइनें लेता है।

निम्नलिखित पायथन के 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()
// []

यह पायथन के 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(*[...])पायथन से मुहावरे की नकल करने के लिए , आपको zip.apply(this, [...])ज़िप फ़ंक्शन को उल्टा करना होगा या यदि आप इसी तरह इनपुट के रूप में सूचियों की एक चर संख्या चाहते हैं, तो आपको करना होगा।

---

परिशिष्ट :

इस हैंडल को किसी भी चलने योग्य बनाने के लिए (जैसे कि पायथन में आप 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(...)यदि आप पहले से ही लिख चुके हैं तो आप पायथन-शैली के फ़ंक्शन का उपयोग कर सकते हैं । आखिरकार आप ECMAScript सरणी समझ या जनरेटर का उपयोग करने में सक्षम होंगे।)

Comments

यह मेरे लिए काम नहीं करता है: TypeError: Object 1 का कोई तरीका 'मैप' नहीं है

— Emanuele Paolini

और वैरिएबल आर्ग और किसी भी चलने के लिए ES6:zip = (...rows) => [...rows[0]].map((_,c) => rows.map(row => row[c]));

— 1983

"ऑब्जेक्ट 1 का कोई तरीका 'नक्शा नहीं है" शायद एक वस्तु पर इस का उपयोग करने की कोशिश करने का एक मामला है जिसमें नक्शा विधि नहीं है (जैसे कि एक नोडेलिस्ट, या एक स्ट्रिंग) जो इस पोस्ट के परिशिष्ट में शामिल किया गया था

— निंजाजेको

हालांकि यह सच है कि वैरिएबल ईएस 6 संस्करण संरक्षित नहीं करता है zip(zip(x)) = x, फिर भी आप इस विश्वास में डूब सकते हैं zip(...zip(...x)) = x।

— मैट क्रेमर

const the_longest_array_length = Math.max(...(arrays.map(array => array.length)));

— Константин Ван

Answer 2

लाइब्रेरी अंडरस्कोर की जाँच करें ।

अंडरस्कोर 100 से अधिक फ़ंक्शन प्रदान करता है जो आपके पसंदीदा वर्कडाय कार्यात्मक सहायकों दोनों का समर्थन करते हैं: मानचित्र, फ़िल्टर, आह्वान - साथ ही अधिक विशिष्ट उपहार: फ़ंक्शन बाइंडिंग, जावास्क्रिप्ट टेम्प्लेटिंग, त्वरित अनुक्रमित, गहरी समानता परीक्षण, और इसी तरह।

- इसे बनाने वाले लोग कहें

मैंने हाल ही में इसे विशेष रूप से zip()फ़ंक्शन के लिए उपयोग करना शुरू कर दिया है और इसने एक महान पहली छाप छोड़ी है। मैं jQuery और CoffeeScript का उपयोग कर रहा हूं, और यह पूरी तरह से उनके साथ जाता है। अंडरस्कोर ठीक उसी जगह उठाता है जहां वे छोड़ते हैं और अब तक यह मुझे निराश नहीं करता है। ओह, यह केवल 3kb कीमा बनाया हुआ है।

इसकी जांच - पड़ताल करें:

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

Comments

अंडरस्कोर का उपयोग करते समय, आप हास्केल की स्पष्टता और तार्किक सह-स्थिति के करीब महसूस करते हैं।

— कैमिल बी

अंडरस्कोर के बजाय, यह आज़माएं: lodash.com - ड्रॉप-इन रिप्लेसमेंट, एक ही शानदार स्वाद, अधिक सुविधाएँ, अधिक क्रॉस-ब्राउज़र की संगति, बेहतर perf। विवरण के लिए kitcambridge.be/blog/say-hello-to-lo-dash देखें ।

— मेरलिन मॉर्गन-ग्राहम

Answer 3

Ninjagecko के उत्कृष्ट और व्यापक उत्तर के अलावा, सभी को दो JS-सरणियों को "टपल-मिमिक" के रूप में ज़िप करना है:

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

स्पष्टीकरण:
चूंकि जावास्क्रिप्ट में एक tuplesप्रकार नहीं है, भाषा विनिर्देश में ट्यूपल्स, सूचियों और सेटों के लिए कार्य एक उच्च प्राथमिकता नहीं थी।
अन्यथा, समान व्यवहार JS> 1.6 में Array मानचित्र के माध्यम से सरल तरीके से सुलभ है । ( mapवास्तव में अक्सर JS इंजन निर्माताओं द्वारा कई> JS 1.4 इंजनों में लागू किया जाता है, निर्दिष्ट नहीं होने के बावजूद)।
पायथन के लिए बड़ा अंतर zip, izip... से परिणाम mapके कार्यात्मक शैली, के बाद से mapएक समारोह तर्क की आवश्यकता है। इसके अतिरिक्त यह 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ओवर- forलूप का उपयोग करना :

देखें: [1,2] और [7,8] को [[1,7], [2,8] में विलय करने का सबसे कुशल तरीका क्या है

नोट: आधार प्रकार जैसे कि falseऔर undefinedएक प्रोटोटाइप ऑब्जेक्ट-पदानुक्रम नहीं बनता है और इस प्रकार एक toStringफ़ंक्शन को उजागर नहीं करता है। इसलिए इन्हें आउटपुट में खाली दिखाया गया है।
जैसा कि parseIntदूसरा तर्क आधार / संख्या मूलांक है, जिसमें संख्या को रूपांतरित करना है, और चूंकि mapसूचकांक अपने तर्क-कार्य के दूसरे तर्क के रूप में सूचकांक को पारित करता है, एक आवरण फ़ंक्शन का उपयोग किया जाता है।

Comments

जब मैं इसे आज़माता हूँ तो आपका पहला उदाहरण "aIn एक फंक्शन नहीं है"। यह काम करता है अगर मैं एक प्रोटोटाइप के बजाय सरणी से .map कहता हूं: aIn.map(function(e, i) {return [e, aOut[i]];})क्या गलत है?

— नौमेनन

@ नौमेनन को जवाब तय Array.prototype.mapकरना चाहिए था Array.prototype.map.call।

— उपयोगकर्ता

Answer 4

जनरेटर के साथ आधुनिक 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()देखते हैं कि दिए गए एरे में कोई भी परिणाम ( विधि का उपयोग करके ) समाप्त हो गया है, और यदि ऐसा है, तो हम लूप को तोड़ते हैं।

Comments

यह उत्तर अधिक स्पष्टीकरण का उपयोग कर सकता है।

— सेमीहेयर

हम पुनरावृत्तियों से पुनरावृत्तियों की एक सूची प्राप्त करते हैं। यह आमतौर पर पारदर्शी रूप से होता है, यहाँ हम इसे स्पष्ट रूप से करते हैं, क्योंकि हम चरणबद्ध तरीके से उपज लेते हैं। जांचें कि क्या सरणी में उनमें से कोई (.some () विधि समाप्त हो गई है और यदि ऐसा है तो हम बाधित करते हैं।

— दिमित्रिस

Answer 5

अन्य पायथन जैसे कार्यों के साथ, pythonicएक zipफ़ंक्शन प्रदान करता है , जिसके आलसी मूल्यांकन के अतिरिक्त लाभ के साथ 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))];

प्रकटीकरण मैं लेखक हूँ और पायथन के अनुचर

Answer 6

पायथन के दो कार्य हैं: ज़िप और इटर्टूलस ज़िप_लॉन्गेस्ट। JS / ES6 पर कार्यान्वयन इस प्रकार है:

जेएस / ईएस 6 पर पायथन के ज़िप को लागू करना

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

[[१, ६६67, १११, ११]]

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

[[१, ६६ [, १११], [२, असत्य, २१२], [३, -३,,, ३२३], [, ए ’, 7 337’, 433]]

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

[]

जेएस / ईएस 6 पर पायथन के 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],
    []
));

[[१,
६६ [ , १११, अपरिभाषित], [२, असत्य, अपरिभाषित, अपरिभाषित], [३, -३,,, अपरिभाषित, अपरिभाषित], ['a ’,’ 337, अपरिभाषित, अपरिभाषित]]

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

[[१, ६६ [, १११, नल], [२, झूठा, अशक्त, अशक्त], [३, -३,,, अशक्त, अशक्त], [a ए ’, 7 337’, अशक्त, अशक्त]

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

[[१,
६६ [, १११, None इज़ नो इज़ ’], [२, असत्य,, इज़ नो इज़’, ’इज़ नो ’], [३, -३,,, None इज़ नो इज़ ’, None इज़ नो ’ ’], [67 ए] ',' 337 ',' इज़ नॉट एनी ',' इज़ नो इज़ ']]

Answer 7

आप ES6 का उपयोग करके उपयोगिता कार्य कर सकते हैं।

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

हालांकि, पहले सरणी के ऊपर समाधान लंबाई में आउटपुट सरणी की लंबाई को परिभाषित करता है।

यहाँ समाधान है जिसमें आप इस पर अधिक नियंत्रण रखते हैं। यह थोड़ा जटिल है लेकिन इसके लायक है।

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

Answer 8

1. एनपीएम मॉड्यूल: zip-array

मुझे एक npm मॉड्यूल मिला जिसे अजगर के जावास्क्रिप्ट संस्करण के रूप में इस्तेमाल किया जा सकता है zip:

ज़िप-सरणी - पायथन के ज़िप फ़ंक्शन के बराबर एक जावास्क्रिप्ट। प्रत्येक सरणियों के मूल्यों को एक साथ जोड़ता है।

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

2. tf.data.zip()Tensorflow.js में

एक अन्य वैकल्पिक विकल्प Tensorflow.js उपयोगकर्ताओं के लिए है: यदि आपको zipजावास्क्रिप्ट में टेंसरफ़्लो डेटासेट के साथ काम करने के लिए अजगर में एक फ़ंक्शन की आवश्यकता है , तो आप tf.data.zip()Tensorflow.js में उपयोग कर सकते हैं ।

tf.data.zip () Tensorflow.js में यहाँ प्रलेखित है

Answer 9

स्वयं जावास्क्रिप्ट में बिल्ट-इन नहीं। कुछ सामान्य जावास्क्रिप्ट फ्रेमवर्क (जैसे प्रोटोटाइप) एक कार्यान्वयन प्रदान करते हैं, या आप अपना स्वयं का लिख ​​सकते हैं।

Comments

संपर्क? इसके अलावा, अगर jQuery ने ऐसा किया है, तो मुझे अधिक दिलचस्पी होगी, क्योंकि मैं इसका उपयोग कर रहा हूं ...

— pq।

jQuery: plugins.jquery.com/project/zip प्रोटोटाइप: prototypejs.org/api/enumerable/zip

— Amber

हालांकि ध्यान दें कि jQuery के एक पायथन एक की तुलना में थोड़ा अलग व्यवहार करता है, इसमें वह एक वस्तु देता है, न कि एक सरणी ... और इस तरह एक साथ 2 से अधिक सूचियों को ज़िप नहीं कर सकता है।

— अंबर

ठीक है, लेखक को jQuery को एक समकक्ष नहीं कहना चाहिए।

— पंजा।

Answer 10

@Brandon की तरह, मैं अंडरस्कोर के जिप फंक्शन की सलाह देता हूं । हालांकि, यह सबसे लंबे इनपुट की लंबाई को वापस करने के लिए आवश्यक मूल्यों को zip_longestजोड़ते हुए, जैसे कार्य करता है undefined।

मैंने mixinएक के साथ अंडरस्कोर का विस्तार करने के लिए विधि का उपयोग किया zipShortest, जो कि पायथन की तरह काम करता है zip, लाइब्रेरी के अपने स्रोत के लिए बंद हैzip ।

आप अपने सामान्य जेएस कोड में निम्नलिखित जोड़ सकते हैं और फिर इसे कॉल कर सकते हैं जैसे कि यह अंडरस्कोर का हिस्सा था: _.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;
}});

Comments

एक टिप्पणी के बिना नीचे? मैं इस उत्तर को सुधारने के लिए खुश हूं, लेकिन प्रतिक्रिया के बिना नहीं कर सकता।

— पाट

Answer 11

आप सारणियों के सरणी को कम कर सकते हैं और आंतरिक सरणी के सूचकांक का परिणाम लेकर नए सरणी को मैप कर सकते हैं।

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

Answer 12

आलसी जनरेटर समाधान की एक भिन्नता :

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

Comments

मुझे आश्चर्य है कि इस एक के साथ क्या गलत है, मैंने वही लिखा। मेरे लिए यह अन्य सभी की तुलना में बेहतर लगता है, लेकिन शायद हम दोनों गलत हैं ... मैं इसे प्रवाह प्रकारों को जोड़ने का तरीका ढूंढ रहा था, लेकिन मैं संघर्ष कर रहा हूं: डी।

— cglacet

Answer 13

Mochikit पुस्तकालय यह और कई अन्य कार्यों अजगर की तरह प्रदान करता है। मोचिटिट के डेवलपर भी पायथन प्रशंसक हैं, इसलिए इसमें पाइथन की सामान्य शैली है, और एक ट्विस्टेड जैसी रूपरेखा में एसिंक्स कॉल को भी लपेटता है।

Answer 14

मैंने शुद्ध जेएस में यह सोचकर एक रन लिया कि ऊपर पोस्ट किए गए प्लगइन्स कैसे काम करते हैं। यहाँ मेरा परिणाम है। मैं यह कहकर इसकी प्रस्तावना करूंगा कि मुझे इस बात का कोई पता नहीं है कि 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;
}

यह बुलेटप्रूफ नहीं है, लेकिन यह अभी भी दिलचस्प है।

Comments

jsfiddle अच्छी लगती है। एक TidyUp बटन है! रन बटन के परिणाम पैनल में आपका कंसोल.लॉग आउटपुट नहीं दिखा। क्यों?

— पंजा।

इसे (कंसोल.लॉग) को चलाने के लिए फायरबग जैसी चीज की आवश्यकता होती है। बस में स्विच console.logकरें alert।

तब के लिए परिणाम फलक क्या है?

— पंजा।

यह फिडेल का HTML दिखाता है। इस मामले में, मैं बस सीधे जेएस कर रहा हूं। यहाँ परिणाम document.write() jsfiddle.net/PyTWw/5

Answer 15

यह डैडी के इटेरेटर -आधारित उत्तर से एक पंक्ति को दूर करता है :

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

Answer 16

यदि आप ES6 के साथ ठीक हैं:

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