CoffeeScript: एक विस्तृत साइकिल गाइड

जैसा कि आप जानते हैं, कॉफीस्क्रिप्ट जावास्क्रिप्ट की तुलना में नियंत्रण संरचनाओं का एक अलग सेट प्रदान करता है।

इस तथ्य के बावजूद कि भाषा डेवलपर्स ने व्याकरण को यथासंभव सरल बनाया और सभी निर्देशों का विस्तृत विवरण दिया, जिससे कई लोगों के लिए अधिक या कम गैर-मानक चक्र बन जाना एक बड़ी चुनौती है।

इस लेख में मैं आपको कॉफीस्क्रिप्ट और निकट संबंधी नियंत्रण संरचनाओं में छोरों के साथ काम करने के सिद्धांतों के बारे में जितना संभव हो उतना बताने की कोशिश करूंगा।

सभी कोड जावास्क्रिप्ट में तुलनात्मक उदाहरणों के साथ हैं।

शिक्षा के लिए

चलो लूप के लिए सबसे सरल से शुरू करते हैं:

for (var i = 0; i < 10; i++) { //... } 

कॉफीस्क्रिप्ट में, इसे इस तरह लिखा जाएगा:

 for i in [0...10] 

रंगों का उपयोग पुनरावृत्तियों की संख्या निर्धारित करने के लिए किया जाता है।
हमारे मामले में, 0 ... 10 का अर्थ है: लूप के 10 पुनरावृत्तियों का प्रदर्शन।

लेकिन क्या होगा यदि आपको टाइप करने की स्थिति निर्धारित करने की आवश्यकता है I <= 10 ?

 for i in [0..10] 

पहली नज़र में, कुछ भी नहीं बदला है, लेकिन अगर आप बारीकी से देखते हैं, तो आप देख सकते हैं कि सीमा में एक बिंदु कम हो गया है।

परिणामस्वरूप, हमें निम्नलिखित प्रविष्टि मिलती है:

 for (var i = 0; i <= 10; i++) { //... } 

यदि रेंज का प्रारंभिक मूल्य अंतिम [10..0] से अधिक है, तो हमें उल्टे परिणाम के साथ एक उल्टा चक्र मिलेगा:

 for (var i = 10; i >= 0; i--) { //.. } 

मैं यह नोट करना चाहता हूं कि नकारात्मक श्रेणी मानों का उपयोग भी स्वीकार्य है:

 for i in [-10..0] 

और इसलिए, आप सरणी को नकारात्मक मानों से भर सकते हैं:

 [0..-3] #[0, -1, -2, -3] 

अब वास्तविक स्थिति पर विचार करें, एन के भाज्य की गणना करने वाले फ़ंक्शन के उदाहरण का उपयोग करते हुए:

जावास्क्रिप्ट:

 var factorial = function(n) { var result = 1; for (i = 1; i <= n; i++) { result *= i; } return result; }; factorial(5) //120 

CoffeeScript:

 factorial = (n) -> result = 1 for i in [1..n] result *= i result factorial 5 #120 

जैसा कि आप ऊपर दिए गए उदाहरण से देख सकते हैं, कॉफीस्क्रिप्ट कोड जावास्क्रिप्ट की तुलना में अधिक कॉम्पैक्ट और पठनीय है।

हालाँकि, इस कोड को थोड़ा सरल बनाया जा सकता है:

 factorial = (n) -> result = 1 result *= i for i in [1..n] result 

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

[...]

मैं खुद को विषय से थोड़ा विचलित करने और निर्माण के आवेदन से संबंधित एक और दिलचस्प बिंदु का उल्लेख करने की अनुमति देता हूं [...] (स्लाइस) ।

कभी-कभी किसी और के कोड से आप इस निर्माण जैसा कुछ पा सकते हैं:

 'a,b,c'[''...][0] 

जो, निश्चित रूप से, निम्नलिखित का मतलब होगा:

 'a,b,c'.slice('')[0]; //a 

पहली नज़र में, स्लाइस से अलग रेंज काफी मुश्किल है। दो मुख्य अंतर हैं:

सबसे पहले, आप स्लाइस में एक चरम मूल्य को छोड़ सकते हैं

 [1...] 

यहाँ मैं इस अभिव्यक्ति के अनुवाद के बाद हमें जो मिल रहा है उस पर विशेष ध्यान देना चाहूंगा:

 var __slice = Array.prototype.slice; __slice.call(1); 

यह कई स्थितियों के लिए सुविधाजनक हो सकता है, उदाहरण के लिए, फ़ंक्शन तर्कों की सूची प्राप्त करने के लिए:

 fn = -> [arguments...] fn [1..3] #0,1,2,3 

मैं यह नोट करना चाहता हूं कि CoffeeScript में फ़ंक्शन तर्कों की एक सूची प्राप्त करने के लिए एक सुरक्षित और अधिक सुरुचिपूर्ण विकल्प ( फ्लैट्स ) है:

 fn = (args...) -> args fn [1..3] #0,1,2,3 

अंकगणित और तार्किक संचालन का उपयोग करना भी संभव है:

 [1 + 1...] 

दूसरे, स्लाइस से पहले एक ऑब्जेक्ट की अनुमति है

 [1..10][...2] #1,2 

तीसरा, स्लाइस में गणना के उपयोग की अनुमति है

 [1,2,3...] 

यह उदाहरण एक सरल संगति संचालन करता है:

 [1, 2].concat(Array.prototype.slice.call(3)); //[1,2,3] 

एक अधिक उपयोगी उदाहरण:

 list1 = [1,2,3] list2 = [4,5,6] [list1, list2 ...] #[1,2,3,4,5,6] 

सूची की समझ

CoffeeScript में ऑब्जेक्ट्स के साथ काम करने के लिए सबसे महत्वपूर्ण वाक्यविन्यास सूची समझ है ।

1 से n तक सभी तथ्यात्मक गणनाओं की एक सूची प्राप्त कर सकते हैं:

 factorial = (n) -> result = 1 result *= i for i in [1..n] factorial 5 #1,2,6,24,120 

अब एक और दिलचस्प उदाहरण देखते हैं और स्थान ऑब्जेक्ट के पहले पांच सदस्यों को सूचीबद्ध करते हैं:

 (i for i of location)[0...5] # hash, host, hostname, href, pathname 

जावास्क्रिप्ट में, यह कोड इस तरह दिखेगा:

 var list = function() { var result = []; for (var i in location) { result.push(i); } return result; }().slice(0, 5); 

सरणी के तत्वों की सूची (अनुक्रमित नहीं) प्रदर्शित करने के लिए, आपको एक और पैरामीटर सेट करने की आवश्यकता है:

 foo = (value for i, value of ['a', 'b', 'c'][0...2]) # [ a, b ] 

एक तरफ, वस्तुओं के साथ काम करने के लिए सूची अभिव्यक्तियाँ एक बहुत ही कुशल और कॉम्पैक्ट तरीका है। दूसरी ओर, आपको स्पष्ट रूप से समझने की आवश्यकता है कि जावास्क्रिप्ट में अनुवाद के बाद कौन सा कोड प्राप्त होगा।

उदाहरण के लिए, ऊपर दिया गया कोड, जो 0 से 2 तक के तत्वों की एक सूची प्रदर्शित करता है, को इस तरह से अधिक प्रभावी ढंग से फिर से लिखा जा सकता है:

 foo = (value for value in ['a', 'b', 'c'][0...2]) 

या तो:

 ['a', 'b', 'c'].filter (value, i) -> i < 2 

इस बिंदु पर, कृपया पद्धति के नाम और शुरुआती ब्रैकेट के बीच के स्थान पर विशेष ध्यान दें। यह अंतराल आवश्यक है!

यदि आप स्थान छोड़ते हैं, तो हमें निम्नलिखित मिलते हैं:

 ['a', 'b', 'c'].filter(value, i)(function() { return i < 2; }); //ReferenceError: value is not defined! 

अब, आप शायद यह जानने के लिए उत्सुक हैं कि .filter () विकल्प सबसे पसंदीदा क्यों निकला?

तथ्य यह है कि जब हम फॉर- स्टेटमेंट का उपयोग करते हैं, तो अनुवादक आवश्यकता से अधिक लूप के धीमे संस्करण को प्रतिस्थापित करता है, अर्थात्:

प्रसारण परिणाम:

 var i, value; [ (function() { var _ref, _results; _ref = ['a', 'b', 'c'].slice(0, 2); _results = []; for (i in _ref) { value = _ref[i]; _results.push(value); } return _results; })() ]; 

आइए इसका सामना करते हैं, जिसके परिणामस्वरूप कोड भयानक है।

अब फिल्टर विधि का उपयोग करके प्राप्त कोड को देखें:

 ['a', 'b', 'c'].filter(function(value, i) { return i < 2; }); 

जैसा कि आप देख सकते हैं, हमें एक आदर्श और कुशल कोड मिला है!

यदि आप सर्वर पर CoffeeScript का उपयोग करते हैं, तो आपको चिंता करने की कोई बात नहीं है, यदि नहीं, तो आपको याद रखना चाहिए कि IE9- फ़िल्टर विधि का समर्थन नहीं करता है। इसलिए, आपको स्वयं ही इसकी उपलब्धता का ध्यान रखना चाहिए!

फिर ऑपरेटर

जैसा कि आप जानते हैं, अभिव्यक्तियों की व्याख्या करने के लिए, कॉफीस्क्रिप्ट पार्सर इंडेंट, लाइन ब्रेक, कैरिज रिटर्न इत्यादि को पार्स करता है।

निम्नलिखित 1 से n को दो की शक्ति तक संख्या बढ़ाने के लिए एक विशिष्ट चक्र है:

 for i in [1...10] i * i 

स्पष्टता के लिए, हमने लाइन फीड और इंडेंटेशन का उपयोग किया।

हालांकि, वास्तविक स्थिति में, अधिकांश डेवलपर्स इस अभिव्यक्ति को एक पंक्ति में लिखना पसंद करेंगे:

 for i in [1...10] then i * i 

कुछ समय में , अगर / और , और जब / जब बयान, तब स्टेटमेंट पार्सर को भावों को अलग करने का निर्देश देता है।

संचालक द्वारा

इस बिंदु तक, हमने केवल " सरल " चक्रों पर विचार किया है, अब एक निश्चित चरण में लापता मूल्यों वाले चक्रों के बारे में बात करने का समय है।

हम केवल 2 से 10 तक संख्याओं का उत्पादन करेंगे:

 alert i for i in [0..10] by 2 #0,2,4,6,8,10 

जावास्क्रिप्ट में, यह कोड इस तरह दिखेगा:

 for (var i = 2; i <= 10; i += 2) { alert(i); } 

ऑपरेटर द्वारा उन तत्वों की एक श्रृंखला पर लागू किया जाता है जिसमें आप पुनरावृत्ति चरण सेट कर सकते हैं।

हम न केवल संख्या या किसी सरणी के तत्वों के साथ काम कर सकते हैं, बल्कि स्ट्रिंग्स के साथ भी काम कर सकते हैं:

 [i for i in 'Hello World' by 3] #H,l,W,l 

तब और फिर ऑपरेटरों को एक साथ उपयोग किया जा सकता है:

 [for i in 'hello world' by 1 then i.toUpperCase()] # H,E,L,L,O, ,W,O,R,L,D 

यद्यपि यह उदाहरण थोड़ा दूर की बात है और वास्तविक स्थिति में " एक में " कदम को सरल किया जाना चाहिए, फिर भी, तत्कालीन ऑपरेटरों के संयुक्त काम से हमें बहुत कॉम्पैक्ट और कुशल कोड लिखने की अनुमति मिलती है।

खुद का संचालक

जावास्क्रिप्ट अक्सर .hasOwnProperty () पद्धति का उपयोग करता है, जो ऑपरेटर के विपरीत, ऑब्जेक्ट प्रोटोटाइप श्रृंखला में गुणों की जांच नहीं करता है:

 var object = { foo: 1 }; object.constructor.prototype.bar = 1; console.log('bar' in object); // true console.log(object.hasOwnProperty('bar')); // false 

फॉर-इन लूप के शरीर में .hasOwnProperty () पद्धति का उपयोग करने के एक उदाहरण पर विचार करें:

 var object = { foo: 1 }; object.constructor.prototype.toString = function() { return this.foo; }; for (i in object) { if (object.hasOwnProperty(i)) { console.log(i); //foo } } 

इस तथ्य के बावजूद कि हमने प्रोटोटाइप ऑब्जेक्ट में .toString () पद्धति को जोड़ा है, यह लूप के शरीर में सूचीबद्ध नहीं होगा। यद्यपि इसे सीधे पहुँचा जा सकता है:

 object.toString() //1 

CoffeeScript इन उद्देश्यों के लिए स्वयं का एक विशेष ऑपरेटर प्रदान करता है:

 object = foo: 1 object.constructor::toString = -> @foo for own i of object console.log i #foo 

यदि आपको कथन की दूसरी कुंजी का उपयोग करने की आवश्यकता है, तो आपको इसे अल्पविराम द्वारा अलग करने की आवश्यकता है, और आपको स्वयं ऑपरेटर को फिर से जोड़ने की आवश्यकता नहीं है:

 for own key, value of object console.log '#{key}, #{value}' #foo, 1 

सशर्त यदि / अन्यथा कथन

अब मैं एक बहुत ही महत्वपूर्ण बिंदु पर ध्यान आकर्षित करना चाहूंगा, जो कि / अन्य कथनों के साथ लूप साझा करने से जुड़ा है।

कभी-कभी जावास्क्रिप्ट अनुप्रयोगों में हम समान कोड में आ सकते हैं:

 for (var i = 0; i < 10; i++) if (i === 1) break; 

हम इस तरह से लिखने वाले डेवलपर्स की चर्चा नहीं करेंगे और विशेष रूप से निंदा करेंगे।

यह हमारे लिए केवल ब्याज है कि कैसे सही ढंग से CoffeeScript में अभिव्यक्ति लिखना है।

पहली बात यह है कि मन में आता है:

 for i in [0..10] if i is 1 break # Parse error on line 1: Unexpected 'TERMINATOR' 

ठीक है ..., हालांकि, कॉफीस्क्रिप्ट लेक्सिकल विश्लेषण के नियमों के अनुसार, एक अनपेक्षित टर्मिनल मान का विवरण यदि स्टेटमेंट से पहले किया जाता है, जो एक पार्सिंग त्रुटि का कारण होगा!

पिछली सामग्री से, हमें याद है कि हम तत्कालीन ऑपरेटर का उपयोग करके अभिव्यक्ति को एक पंक्ति में लागू कर सकते हैं:

 for i in [0..10] then if i is 1 break #Parse error on line 1: Unexpected 'POST_IF' 

हालाँकि, इससे मदद नहीं मिली, हम फिर से पार्सिंग त्रुटि देखते हैं।

आइए जानने की कोशिश करते हैं ...

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

 for i in [0..10] then if i is 1 then break 

इस प्रकार हमें निम्नलिखित कोड मिलते हैं:

 for (i = 0; i <= 10; i++) { if (i === 1) { break; } } 

कभी-कभी ऐसी परिस्थितियां होती हैं, जब चक्र से पहले, आपको सी। एल के प्रदर्शन की जांच करने की आवश्यकता होती है। स्थिति:

 if (foo === true) { for (i = 0; i <= 10; i++) { if (i === 1) { break; } } } 

गैर - नियतात्मक डेटा प्रोसेसिंग और सूची अभिव्यक्तियों के उपयोग के लिए धन्यवाद, हम अपने कोड का प्रतिनिधित्व इस प्रकार कर सकते हैं:

 (if i is 1 then break) for i in [0..10] if foo is on 

इस तथ्य पर ध्यान देना कि इस मामले में हमने तत्कालीन ऑपरेटर का उपयोग नहीं किया, जबकि कोई पार्सिंग त्रुटियां नहीं हुईं!

जब खंड

हम पहले से ही और फिर बयानों को कवर कर चुके हैं, यह हमारी सूची में अगले बयान के बारे में बात करने का समय है, अर्थात्, जब बयान।

और चलो पिछले उदाहरण के सुधार के साथ शुरू करते हैं:

 if foo is on then for i in [0..10] when i is 1 then break 

इस मामले में, कोड पिछले संस्करण की तुलना में थोड़ा अधिक निकला, हालांकि, इसने बहुत अधिक अभिव्यक्ति और अर्थ प्राप्त किया।

आइए एक और उदाहरण देखें कि आप संख्याओं के क्रम को 1 से 10 तक कैसे घटा सकते हैं एक सकारात्मक पूर्णांक n:

 alert i for i in [1..10] when i % 2 is 0 

जावास्क्रिप्ट कोड में अनुवाद करने के बाद:

 for (i = 1; i <= 10; i++) { if (i % 2 === 0) { alert(i); } } 

जैसा कि आप देख सकते हैं, जब ऑपरेटर ऑपरेटर के साथ काम करने के लिए और भी अधिक विकल्प देता है।

शिक्षा के लिए

सूची अभिव्यक्तियों को देखते हुए आपने पहले से ही स्टेटमेंट ऑफ़ फॉर का उपयोग करने के उदाहरण देखे हैं। अब आइए फॉर- स्टेटमेंट पर करीब से नज़र डालें, जो फॉर-इन के साथ - साथ आपको किसी ऑब्जेक्ट के गुणों पर पुनरावृति करने की अनुमति देता है।

आइए जावास्क्रिप्ट में फ़ोर -इन स्टेटमेंट के साथ एक तुलनात्मक सादृश्य बनाएं।

 var object = { foo: 0, bar: 1 }; for (var i in object) { alert(key + " : " + object[i]); //0 : foo, 1 : bar } 

जैसा कि आप देख सकते हैं, हमने ऑब्जेक्ट गुणों के मूल्य को प्राप्त करने के लिए निम्नलिखित सिंटैक्स का उपयोग किया: ऑब्जेक्ट [i] ।

CoffeeScript में , सब कुछ सरल है, सबसे पहले, हम सूची अभिव्यक्तियों का उपयोग करके किसी वस्तु का मूल्य प्राप्त कर सकते हैं:

 value for key, value of {foo: 1, bar: 2} 

दूसरे, अधिक जटिल अभिव्यक्तियों के लिए, हम परिचित ऑपरेटरों का उपयोग करके अधिक व्यापक संकेतन लागू कर सकते हैं:

 for key, value of {foo: 1, bar: 2} if key is 'foo' and value is 1 then break 

जावास्क्रिप्ट में, इस तरह से एक ही परिणाम प्राप्त किया जा सकता है:

 var object = { foo: 1, bar: 2 }; for (key in object) { if (key === 'foo' && object[i] === 1) { break; } } 

प्रभावी रूप से के लिए उपयोग करने का एक और उदाहरण:

 (if value is 1 then alert "#{key} : #{value}") for key, value of document #ELEMENT_NODE : 1, #DOCUMENT_POSITION_DISCONNECTED : 1 

मैं आपको याद दिलाता हूं कि वस्तु गुणों की सूची प्राप्त करने के लिए कुंजी () विधि सबसे प्रभावी तरीका है:

 Object.keys obj {foo: 1, bar: 2} # foo, bar 

संपत्ति मान प्राप्त करने के लिए, नक्शे के साथ संयोजन में कुंजियों () पद्धति का उपयोग किया जाना चाहिए:

 object = foo: 1 bar: 2 Object.keys(object).map (key) -> object[key]; # 1, 2 

जबकि बयान

बयानों के लिए / की / के अलावा, कॉफीस्क्रिप्ट भी कुछ समय के लिए लागू होता है।

जब हमने फॉर-इन स्टेटमेंट को देखा, तो मैंने n के तथ्यात्मक गणना करने का एक और अधिक कुशल तरीका दिखाने का वादा किया, समय सही है:

 factorial = (n) -> result = 1 while n then result *= n-- result 

ऑफहैंड मैं जोड़ना चाहता हूं कि सबसे सुरुचिपूर्ण फैक्टरियल सॉल्यूशन निम्नलिखित है:

 factorial = (n) -> !n and 1 or n * factorial n - 1 

लूप निर्देश

हम लंबे समय तक इस निर्देश पर ध्यान नहीं देंगे, क्योंकि इसका एकमात्र उद्देश्य एक अंतहीन लूप बनाना है:

 loop then break if foo is bar 

प्रसारण प्रसारण:

 while (true) { if (foo === bar) { break; } } 

निर्देश तक

जब तक कथन एक इंस्ट्रूमेंटेशन के समान है, एक अपवाद के साथ कि अभिव्यक्ति में नकारात्मकता को जोड़ा जाता है।

यह उपयोगी हो सकता है, उदाहरण के लिए, स्ट्रिंग में अगले वर्ण सेट की स्थिति जानने के लिए:

 expr = /foo/g; alert "#{array[0]} : #{expr.lastIndex}" until (array = expr.exec('foofoo')) is null 

प्रसारण प्रसारण:

 var array, expr; expr = /foo*/g; while ((array = expr.exec('foofoo')) !== null) { alert("" + array[0] + " : " + expr.lastIndex); } //foo : 3, foo : 6 

जैसा कि आप उदाहरण से देख सकते हैं, लूप को तब तक निष्पादित किया जाता है जब तक कि अभिव्यक्ति का परिणाम शून्य न हो जाए।

करते-करते बयान

मैं तुरंत कहूंगा कि कॉफ़ीस्क्रिप्ट में डू- ऑफ़ स्टेटमेंट का कार्यान्वयन नहीं है। हालांकि, सरल जोड़तोड़ का उपयोग करते हुए, लूप स्टेटमेंट का उपयोग करके इसके आंशिक व्यवहार का उत्सर्जन करना संभव है:

 loop #... break if foo() 

सरणी विधियाँ (फ़िल्टर, forEach, मैप इत्यादि)

जैसा कि आप जानते हैं, सभी समान तरीके कॉफीस्क्रिप्ट में उपलब्ध हैं जैसा कि JavaSctipt में है ।

इस पूरे समूह के तरीकों का विश्लेषण करने का कोई मतलब नहीं है; हम केवल उदाहरण के रूप में नक्शे () पद्धति का उपयोग करके ऑपरेशन के सामान्य सिद्धांत पर विचार करेंगे।

तीन तत्वों की एक सरणी बनाएं और उनमें से प्रत्येक को वर्ग बनाएं:

 [1..3].map (i) -> i * i 

प्रसारण प्रसारण:

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

एक अन्य उदाहरण पर विचार करें:

 ['foo', 'bar'].map (value, i) -> "#{value} : #{i}" #foo : 0, bar : 1 

दूसरा तर्क, मानचित्र विधि कॉल संदर्भ को स्वीकार करती है:

 var object = new function() { return [0].map(function() { return this }); }; // [Window map] 

जैसा कि आप इसे विंडो के मानचित्र बिंदुओं के अंदर देख सकते हैं, कॉल के संदर्भ को बदलने के लिए, आपको यह स्पष्ट रूप से करने की आवश्यकता है:

 var object = new function() { return [0].map(function() { return this; }, this); }; // [Object {}] 

CoffeeScript इस उद्देश्य के लिए विशेष = = ऑपरेटर का उपयोग करता है:

 object = new -> [0].map (i) => @ 

प्रसारण प्रसारण:

 var object = new function() { var _this = this; return [0].map(function() { return _this; }, this); }; 

दूसरे शब्दों में, अधिकतम संभव सीमा तक इन सरणी विधियों का उपयोग करें।

इन विधियों का क्रॉस-ब्राउज़र कार्यान्वयन जिसे मैंने github'e पर पोस्ट किया है

कॉफीस्क्रिप्ट में मैप और फिल्टर के तरीकों का उपयोग करने का एक वास्तविक उदाहरण github'e पर मेरी एक परियोजना में भी देखा जा सकता है

निर्देश / शॉर्ट सर्किट करें

जैसा कि आप जानते हैं, जावास्क्रिप्ट सक्रिय रूप से क्लोजर का उपयोग करता है, जबकि कॉफीस्क्रिप्ट हमें इस आनंद से वंचित नहीं करता है।

एक अनाम, स्व-बाध्यकारी फ़ंक्शन बनाने के लिए, कॉफीस्क्रिप्ट कथन का उपयोग करता है, जो मनमानी संख्या में तर्क लेता है।

एक उदाहरण पर विचार करें:

 array = []; i = 2 while i-- then array[i] = do (i) -> -> i array[0]() #0 array[1]() #1 

इस कोड का सार सरणी को भरना है। इसी समय, सरणी के तत्वों में प्राथमिक मूल्य नहीं होते हैं, लेकिन फ़ंक्शन होते हैं, जिनमें से प्रत्येक अपने तत्व के सूचकांक को वापस करता है।

जावास्क्रिप्ट में, कोड इस तरह दिखेगा:

 var array = [], i = 2; while (i--) { array[i] = function(i) { return function() { return i; }; }(i); } array[0]() //0 array[1]() //1 

नेस्टेड निर्देश

नेस्टेड निर्देश अन्य निर्देशों से अलग नहीं हैं और समान नियमों का पालन करते हैं:

उदाहरण के लिए, 1 से 3 तक युग्मित तत्वों के साथ सरणी भरें:

 list = [] for i in [0..2] for j in [1..2] list.push i list # [0,0,1,1,2,2] 

जैसा कि आप देख सकते हैं कि कुछ भी जटिल नहीं है!

शायद आप इसे एक पंक्ति में लिखना चाहेंगे। खैर, अब प्रवेश को आसान बनाने की कोशिश करते हैं:

 list = [] for i in [0..2] then for j in [1..2] then list.push i 

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

लेकिन क्या होगा अगर आपको दूसरे चक्र से पहले कुछ अभिव्यक्ति जोड़ने की आवश्यकता है?

एक उदाहरण के रूप में, हम तीन जोड़े तत्वों को 0-3 से प्राप्त करते हैं:

 list = [] for i in [0..2] list.push i for j in [1..1] list.push i list #[0,0,1,1,2,2] 

यह सही विकल्प है और इसमें सुधार के लिए बहुत कुछ नहीं है। एक पंक्ति में सब कुछ लिखना भी काम नहीं करता है, क्योंकि दूसरे चक्र से पहले स्पष्ट पहचान की आवश्यकता होती है। लेकिन चक्र के शरीर को लघु संकेतन में लिखा जा सकता है।

 list = [] for i in [0..2] list.push i list.push i for j in [1..1] list #[0,1,2,3] 

तीसरी पंक्ति में, आप रिकॉर्डिंग के उपसर्ग और उपसर्ग दोनों का उपयोग कर सकते हैं।

jQuery आदि।

मुझे अभी तुरंत कहना है, CoffeeScript के लिए यह कोई फर्क नहीं पड़ता कि आप किस जावास्क्रिप्ट लाइब्रेरी का उपयोग करते हैं।

आइए सबसे महत्वपूर्ण jQuery फ़ंक्शन के साथ शुरू करें - पहले से ही ()

। पहले से ही ():

 $ -> @ 

प्रसारण परिणाम:

 $(function() { return this; }); 

मैं आपके बारे में नहीं जानता, लेकिन मेरे पास ऐसा रिकॉर्ड है जो लगभग हमेशा हंसी का कारण बनता है

हमारी सूची में अगला jQuery विधि .each () है , जो मानक .forEach () विधि के लगभग बराबर है

$ .each:

 $.each [1..3], (i) -> i 

प्रसारण परिणाम:

 $.each([1, 2, 3], function(i) { return i; }); 

ECMASctipt 6

यदि आप ECMASctipt 6 मानक के भविष्य के विकास में रुचि नहीं रखते हैं, तो आप इस अनुभाग को सुरक्षित रूप से छोड़ सकते हैं

जैसा कि आप जानते हैं, भविष्य में ECMASctipt 6 मानक में जनरेटर, पुनरावृत्तियों और सूची अभिव्यक्तियों को लागू करने की योजना बनाई गई है।
फ़ायरफ़ॉक्स अब अधिकांश ड्राफ्ट मानक का समर्थन करता है।

मैं क्यों हूँ?

तथ्य यह है कि भविष्य के ईएस 6 सिंटेक्स आज के कॉफीस्क्रिप्ट के साथ लगभग पूरी तरह से असंगत है।

उदाहरण के लिए, निर्देश के ... अब आवश्यकता से अधिक सामान्य है:

 [value for key, value of [1,2,3]] 

आउटपुट पर, हमें निम्न विकृति मिलती है:

 var key, value; [ (function() { var _ref, _results; _ref = [1, 2, 3]; _results = []; for (key in _ref) { value = _ref[key]; _results.push(value); } return _results; })() ]; //[1, 2, 3] 

भविष्य का मानक वस्तुओं के माध्यम से पुनरावृत्ति का उपयोग करना संभव बनाता है, जो बहुत सरल है:

 [for i of [1,2,3]] 

महान, है ना?

अभिव्यक्ति जनरेटर भी उपलब्ध होंगे:

 [i * 2 for each (i in [1, 2, 3])]; //2,4,6 

इस तरह का रिकॉर्ड भी बन सकेगा:

 [i * 2 for each (i in [1, 2, 3]) if (i % 2 == 0)]; //2 

Iterators भी उपलब्ध हो जाएगा:

 var object = { a: 1, b: 2 }; var it = Iterator(lang); var pair = it.next(); //[a, 1] pair = it.next(); //[b, 2] 

Iterators का उपयोग अभिव्यक्ति जनरेटर के साथ संयोजन के रूप में भी किया जा सकता है:

 var it = Iterator([1,2,3]); [i * 2 for (i in it)]; //1, 4, 6 

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