अंडरस्कोर.जेएस कार्यों को चेन करने का पसंदीदा तरीका क्या है?

Question

Underscore.js में फ़ंक्शन कॉल करने के दो तरीके हैं, जिन्हें मैं ऑब्जेक्ट-शैली और फ़ंक्शन-शैली के रूप में संदर्भित करता हूं। वस्तु शैली की तरह लग रहा है:

_(myObject).each(function (val, key) { 
    console.log(key, val); 
}); 

समारोह शैली, दूसरे हाथ पर, इस तरह दिखता है:

_.each(myObject, function (val, key) { 
    console.log(key, val); 
}); 

मैं खुशी से मेरी कोड में वस्तु शैली कॉल का उपयोग किया गया था, लेकिन कुछ पर बिंदु, हालांकि, कॉल की ऑब्जेक्ट शैली underscore.js दस्तावेज़ से गायब हो गई है (हालांकि ऑब्जेक्ट-स्टाइल कॉल अभी भी पूरी तरह से ठीक काम करते हैं)। मैंने जगह के आस-पास संकेत भी देखे हैं (जैसे backbone.js दस्तावेज में) कि फ़ंक्शन-शैली 'बेहतर' या 'पसंदीदा' है।

तो, क्या पसंदीदा विधि कॉल की फ़ंक्शन-शैली है? और यदि हां, तो क्या कोई इस के पीछे तर्क की व्याख्या कर सकता है?

अद्यतन: @ggozad ने आंशिक रूप से मेरे प्रश्न का उत्तर दिया है। लेकिन ऐसा लगता है कि अंडरस्कोर.जेएस कैसे काम करता है, यह संस्करण 0.4.2 के आसपास वापस बनाया गया था। Underscore.js के लिए परिवर्तन इतिहास के माध्यम से पढ़ना, आप संस्करण 1.2.4 के लिए इस प्रविष्टि देख सकते हैं:

अब आप कर सकते हैं (और शायद चाहिए) लिख _.chain(list) बजाय _(list).chain()।

मैं जानना चाहता हूं कि _(list).chain() के बजाय आपको _.chain(list) क्यों लिखना चाहिए।

Answer 1

@ggozad का उत्तर वास्तव में बहुत भ्रामक है। ऑब्जेक्ट उन्मुख शैली में चेनिंग के साथ कुछ लेना देना नहीं है। उदाहरण दिया गया:

_([1,2,3]).map(function (item) { return item * 2; }).map(function (item) { return item*3;}); 

वास्तव में अंडरस्कोर चेनिंग का उपयोग नहीं कर रहा है! यह केवल काम करता है क्योंकि अंतर्निहित जेएस सरणी ऑब्जेक्ट का अपना नक्शा() फ़ंक्शन है। एक समारोह है कि निर्मित नहीं कर रहा है (मिश्रण) की तरह की कोशिश करो और आप इसे टूटता दिखाई देंगे:

_([1,2,3]).shuffle().shuffle(); 

अंडरस्कोर श्रृंखलन प्राप्त करने के लिए एक ही रास्ता chain() कॉल करने के लिए है, जो या तो आप शैली (OO या कार्यात्मक का उपयोग कर सकते है)।

क्यों प्रलेखन कहता है कि आपको _.chain का उपयोग करना चाहिए, मुझे लगता है कि यह सिर्फ एक शैली वरीयता है। मैंने स्पष्टीकरण के लिए issue at GitHub खोला है।

Answer 2

जब _ एक फ़ंक्शन के रूप में उपयोग किया जाता है तो यह अनिवार्य रूप से तर्क को लपेटता है। रैपर सभी सामान्य अंडरस्कोर फ़ंक्शन प्रदान करता है।

शैली से अलग अंतर यह है कि ओओपी शैली (या आपकी परिभाषा में ऑब्जेक्ट शैली) का उपयोग करना यह है कि यह चेन करने योग्य लिपटे ऑब्जेक्ट्स का उत्पादन करता है। तो यह करने के लिए आसान है:

_([1,2,3]).map(function (item) { return item * 2; }).map(function (item) { return item*3;}); 

बराबर होगा:

_.map(_.map([1,2,3], function (item) { return item * 2 }), function (item) { return item * 3 }); 

जो शायद कम स्पष्ट है।