ECMAScript 6 (ES-2015) का परिचय

ईएस 6 का परिचय

सामग्री की तालिका
1. टेम्पलेट शाब्दिक
2. लेट और कास्ट
3. एरो फंक्शन एक्सप्रेशन
4. के लिए
5. गणना की गई संपत्ति के नाम
6. ऑब्जेक्ट.साइन ()
बाकी पैरामीटर
8. डिफ़ॉल्ट पैरामीटर
9. विनाशकारी कार्य
10. नक्शा
11. सेट करें
12. कक्षाएं
13. वादा
14. Iterators
15. जनक
16. सुंबोल

टेम्पलेट शाब्दिक (टेम्पलेट स्ट्रिंग्स)

टेम्प्लेट शाब्दिक स्ट्रिंग शाब्दिक हैं जो अभिव्यक्ति के अंदर उपयोग करने की अनुमति देते हैं। उनके साथ आप बहुस्तरीय शाब्दिक और स्ट्रिंग प्रक्षेप का उपयोग कर सकते हैं।

टेम्पलेट शाब्दिक डबल या सिंगल के बजाय बैकटिक्स (``) में संलग्न हैं। वे एक डॉलर चिह्न और घुंघराले ब्रेसिज़ ($ {अभिव्यक्ति}) द्वारा चिह्नित वाइल्डकार्ड शामिल कर सकते हैं। प्रतिस्थापन अभिव्यक्तियाँ और उनके बीच का पाठ फ़ंक्शन को पास किया जाता है। डिफ़ॉल्ट रूप से, फ़ंक्शन बस एक स्ट्रिंग में सभी भागों को मिलाता है। यदि रेखा से पहले एक अभिव्यक्ति है (यहाँ यह टैग है), तो टेम्पलेट लाइन को "टैग टेम्पलेट" कहा जाता है। इस मामले में, टैग अभिव्यक्ति (आमतौर पर एक फ़ंक्शन) को संसाधित टेम्पलेट शाब्दिक के साथ कहा जाता है, जिसे आप आउटपुट से पहले संशोधित कर सकते हैं। टेम्प्लेट शाब्दिकों में बैकवोट से बचने के लिए, बैकस्लैश \ n निर्दिष्ट करें।

बहुभाषी शाब्दिक
न्यूलाइन वर्ण वाइल्डकार्ड शाब्दिक का हिस्सा हैं। नियमित तार का उपयोग करते हुए, सम्मिलन लपेटने के लिए निम्नलिखित सिंटैक्स की आवश्यकता होगी:

console.log('string text line 1\n' + 'string text line 2'); // "string text line 1 // string text line 2" 

टेम्पलेट शाब्दिक का उपयोग करने के साथ ही:

 console.log(`string text line 1 string text line 2`); // "string text line 1 // string text line 2" 

अभिव्यक्ति इंटरपोलेशन
नियमित स्ट्रिंग्स में एक्सप्रेशन डालने के लिए, आपको निम्नलिखित सिंटैक्स का उपयोग करना होगा:

 var a = 5; var b = 10; console.log('Fifteen is ' + (a + b) + ' and not ' + (2 * a + b) + '.'); // "Fifteen is 15 and not 20." 

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

 var a = 5; var b = 10; console.log(`Fifteen is ${a + b} and not ${2 * a + b}.`); // "Fifteen is 15 and not 20." 

नेस्टेड टेम्पलेट
कई बार, एक पैटर्न बनाने के लिए एक स्ट्रिंग बनाने का सबसे छोटा और शायद अधिक पठनीय तरीका है। बस बैककोट किए गए टेम्पलेट के अंदर एक और डाल दिया, उन्हें $ {} प्रतिस्थापन में लपेटकर। उदाहरण के लिए, यदि अभिव्यक्ति सही है, तो आप एक टेम्पलेट शाब्दिक वापस कर सकते हैं।
ES5 में:

 var classes = 'header' classes += (isLargeScreen() ? '' : item.isCollapsed ? ' icon-expander' : ' icon-collapser'); 

ES2015 में नेस्टिंग के बिना टेम्पलेट शाब्दिक के साथ:

 const classes = `header ${ isLargeScreen() ? '' : (item.isCollapsed ? 'icon-expander' : 'icon-collapser') }`; 

नेस्टेड टेम्पलेट शाब्दिक के साथ ES2015 में:

 const classes = `header ${ isLargeScreen() ? '' : `icon-${item.isCollapsed ? 'expander' : 'collapser'}` }`; 

टैग टेम्प्लेट
टेम्प्लेट शाब्दिकों का एक विस्तारित रूप टेम्प्लेट टैग किया गया है। वे आपको फ़ंक्शन का उपयोग करके टेम्पलेट शाब्दिकता को पार्स करने की अनुमति देते हैं। ऐसे फ़ंक्शन के पहले तर्क में स्ट्रिंग मानों की एक सरणी होती है, और बाकी में प्रतिस्थापन से अभिव्यक्ति होती है। नतीजतन, फ़ंक्शन को इकट्ठे स्ट्रिंग (या कुछ पूरी तरह से अलग, जैसा कि बाद में दिखाया जाएगा) वापस करना चाहिए। फ़ंक्शन का नाम कुछ भी हो सकता है।

 var person = 'Mike'; var age = 28; function myTag(strings, personExp, ageExp) { var str0 = strings[0]; // "That " var str1 = strings[1]; // " is a " // ,     // (  )    , //    (""),    . // var str2 = strings[2]; var ageStr; if (ageExp > 99){ ageStr = 'centenarian'; } else { ageStr = 'youngster'; } //     ,     return `${str0}${personExp}${str1}${ageStr}`; } var output = myTag`That ${ person } is a ${ age }`; console.log(output);// That Mike is a youngster 

टैग फ़ंक्शन को स्ट्रिंग वापस करने के लिए आवश्यक नहीं है।

कच्ची रेखाएँ
टैग टेम्पलेट के पहले तर्क के लिए उपलब्ध विशेष कच्ची संपत्ति, आपको स्ट्रिंग को उस रूप में प्राप्त करने की अनुमति देती है जिसमें यह व्याख्या के बिना दर्ज किया गया था।

 function tag(strings) { return strings.raw[0]; } tag`string text line 1 \\n string text line 2`; //  "string text line 1 \\n string text line 2", //  'n'    '\' 

इसके अलावा, एक String.raw () पद्धति है जो डिफ़ॉल्ट टेम्पलेट फ़ंक्शन के समान स्रोत स्ट्रिंग लौटाती है और स्ट्रिंग संयोजन एक साथ वापस आ जाएगी।

ECMAScript 2016 में, टैग किए गए टेम्पलेट निम्नलिखित वर्णों से बचने के लिए नियमों का पालन करते हैं:

• यूनिकोड वर्ण "\ u" से शुरू होते हैं, उदाहरण के लिए, \ u00A9
• यूनिकोड कोड पॉइंट "\ u {}" से शुरू होता है, उदाहरण के लिए, \ u {2F804}
• हेक्साडेसिमल चरित्र प्रतिनिधित्व "\ x" से शुरू होता है, उदाहरण के लिए, \ xA9
• "" के साथ शुरू होने वाले वर्णों का अष्टक निरूपण, उदाहरण के लिए, \ 251

चलो और कास्ट

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

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

वैश्विक और ब्लॉक दायरे के बीच अंतर का एक उदाहरण:

 function myFunction() { if (true) let a = 5; console.log(a); //SyntaxError   a     if if (true) var b = 5; console.log(b); //5   b     } 

एरो फंक्शन एक्सप्रेशन

एरो फंक्शन एक्सप्रेशंस में फंक्शनल एक्सप्रेशंस की तुलना में छोटा सिंटैक्स होता है और इसे लेक्सिक रूप से इस के मान से जोड़ा जाता है (लेकिन इसे अपने आप से नहीं जोड़ा जाता है, आर्ग्युमेंट्स, सुपर या न्यूटार्गेट)। एरो फ़ंक्शंस की अभिव्यक्ति आपको एक नाम निर्दिष्ट करने की अनुमति नहीं देती है, इसलिए तीर फ़ंक्शंस अनाम हैं जब तक कि कुछ भी नहीं सौंपा जाए।

मूल वाक्य रचना

 (param1, param2, …, paramN) => { statements } (param1, param2, …, paramN) => expression // : (param1, param2, …, paramN) => { return expression; } //       : (singleParam) => { statements } singleParam => { statements } //       : () => { statements } () => expression // : () => { return expression; } 

विस्तारित वाक्यविन्यास

 //     ,     params => ({foo: bar}) // Rest       (param1, param2, ...rest) => { statements } (param1 = defaultValue1, param2, …, paramN = defaultValueN) => { statements } //    var f = ([a, b] = [1, 2], {x: c} = {x: a + b}) => a + b + c; f(); // 6 

तीर के कार्यों के बारे में अधिक जानकारी, आप यहां पा सकते हैं।

के लिए ... का

के लिए ... कथन का उपयोग करने योग्य वस्तुओं के माध्यम से एक लूप निष्पादित करता है (सरणी, मानचित्र, सेट, तर्कों की एक वस्तु और जैसे), प्रत्येक पुनरावृत्ति पर आह्वान करते हुए ऑपरेटर को ऑब्जेक्ट के विभिन्न गुणों से प्रत्येक मान के लिए चरणबद्ध करते हैं।

क्यों उपयोग नहीं करना चाहिए ... के लिए पाश में iterate करने के लिए? क्योंकि इंजन के आधार पर, जावास्क्रिप्ट यादृच्छिक क्रम में पुनरावृत्ति कर सकता है, जिससे अप्रत्याशित परिणाम हो सकते हैं। यदि एक संपत्ति एक पुनरावृत्ति में बदल जाती है और फिर बदल जाती है, तो लूप में इसका मूल्य इसका अंतिम मूल्य है। चक्र तक पहुंचने से पहले हटा दी गई एक संपत्ति इसमें भाग नहीं लेगी। लूप में ऑब्जेक्ट में जोड़े गए गुणों को छोड़ दिया जा सकता है। सामान्य तौर पर, यदि आपने पहले ही इसे पारित नहीं किया है, तो पुनरावृत्ति के दौरान किसी संपत्ति को जोड़ना, संशोधित करना या हटाना नहीं है। इस बात की कोई गारंटी नहीं है कि जोड़े गए संपत्तियों को चक्र द्वारा दौरा किया जाएगा, परिवर्तन किए जाने के बाद बदल दिया जाएगा, और हटाए जाने के बाद हटा दिया जाएगा। इसके अलावा, पुनरावृत्त चर एक स्ट्रिंग है, एक संख्या नहीं है, जिसका अर्थ है कि यदि आप चर के साथ कोई गणना करने जा रहे हैं, तो आपको उन्हें जोड़ने के बजाय तारों को समतल करने की आवश्यकता होगी। तो तार्किक त्रुटियों से बचने के लिए, आपको इसका उपयोग नहीं करना चाहिए!

लूप के लिए ... लूप के लिए ... के विपरीत, लूप में सभी एन्यूमरेटेड प्रॉपर्टीज देता है, जिनमें नॉन-पूर्णांक नाम और विरासत में मिली चीजें शामिल हैं।

लूप सिंटैक्स के लिए ...

 for (var i of arr) //for ( of ) arr[i] = "something value" 

उदाहरण:

 Object.prototype.objCustom = function() {}; Array.prototype.arrCustom = function() {}; let iterable = [3, 5, 7]; iterable.foo = 'hello'; for (let i in iterable) console.log(i); // 0, 1, 2, "foo", "arrCustom", "objCustom" for (let i in iterable) { if (iterable.hasOwnProperty(i)) console.log(i); //  0, 1, 2, "foo" } for (let i of iterable) console.log(i); // 3, 5, 7 

प्रत्येक ऑब्जेक्ट objCustom पद्धति को इनहेरिट करेगा और प्रत्येक Array Object.prototype और Array.prototype में उन्हें बनाकर arrCustom पद्धति को इनहेरिट करेगा। प्रोटोटाइप ऑब्जेक्ट इनहेरिट करने के कारण ओब्जेक्ट और ऑर्कुटोटाइप विधियों को विरासत में मिलाएगा।

लूप केवल पुनरावृत्त वस्तु के प्रगणित गुणों को प्रदर्शित करता है, जिस क्रम में वे बनाए गए थे। यह मान 3, 5, 7 और हैलो को प्रिंट नहीं करता है क्योंकि वे गणना करने योग्य नहीं हैं। गुणों और विधियों के नाम प्रदर्शित किए जाते हैं, उदाहरण के लिए, arrCustom और objCustom।

लूप पिछले एक के समान है, लेकिन यह जांचने के लिए hasOwnProperty () का उपयोग करता है कि वस्तु की यह संपत्ति अपनी है या विरासत में मिली है। केवल स्वयं के गुण प्रदर्शित किए जाते हैं। 0, 1, 2 और foo नाम केवल वस्तु के उदाहरण के हैं (विरासत में नहीं)। ArCustom और objCustom तरीके आउटपुट नहीं हैं क्योंकि वे विरासत में मिले हैं।

यह लूप पुनरावृत्ति को दरकिनार करता है और पुनरावृत्त वस्तु के मानों को प्रदर्शित करता है जो इसे पुनरावृत्त करने की विधि में परिभाषित किए गए हैं, अर्थात्। ऑब्जेक्ट के गुण नहीं, लेकिन सरणी 3, 5, 7 के मान।

गणना की गई संपत्ति के नाम

वस्तुओं और उनके तत्वों की घोषणा के लिए सिंटैक्स गणना की गई संपत्ति के नामों का समर्थन करता है। यह आपको कोष्ठक [] के लिए एक अभिव्यक्ति जोड़ने की अनुमति देता है जिसका मूल्यांकन संपत्ति के नाम के रूप में किया जाएगा। यह टेम्पलेट शाब्दिक के समान है।

परिकलित नामों का उदाहरण:

 var a = () => "world"; var a = { ["a" + (10 - 6)]: { ["some" + "string"]: true, [10 + 20]: 10, [`hello ${a()}`]: a() } } 

Object.assign ()

Object.assign () विधि का उपयोग किसी एक या अधिक स्रोत ऑब्जेक्ट से लक्ष्य ऑब्जेक्ट के लिए अपने स्वयं के एन्यूमरेटेड गुणों के मान की प्रतिलिपि बनाने के लिए किया जाता है। कॉपी करने के बाद, यह लक्ष्य वस्तु को वापस करता है।

Object.assign () विधि स्रोत ऑब्जेक्ट से लक्षित ऑब्जेक्ट के लिए केवल एन्यूमरेटेड और देशी गुणों की प्रतिलिपि बनाती है। यह स्रोत वस्तुओं पर आंतरिक [[प्राप्त करें]] विधि और लक्ष्य वस्तु पर आंतरिक [[सेट]] विधि का उपयोग करता है, इसलिए यह गेटर्स और सेटर भी कहता है। यही कारण है कि यह केवल नए गुणों की नकल या परिभाषित करने के बजाय गुण प्रदान करता है। यह व्यवहार प्रोटोटाइप में नई संपत्तियों को इंजेक्ट करने के लिए अनुपयुक्त विधि को प्रस्तुत कर सकता है यदि इंजेक्शन स्रोत ऑब्जेक्ट में गेटर्स होते हैं। इसके बजाय, उनकी परिभाषा के संकेत सहित संपत्ति परिभाषाओं के प्रोटोटाइप की प्रतिलिपि बनाने के लिए, Object.getOwnPropertyDescriptor () और Object.defineProperty () विधियों का उपयोग किया जाना चाहिए।

स्ट्रिंग और प्रतीक दोनों के प्रकारों के गुणों की नकल की जाती है।

एक त्रुटि की स्थिति में, उदाहरण के लिए, जब संपत्ति योग्य नहीं होती है, तो TypeError अपवाद फेंक दिया जाता है, और लक्ष्य ऑब्जेक्ट अपरिवर्तित रहता है।

ध्यान दें कि यदि प्रारंभिक मान शून्य या अपरिभाषित हैं, तो Object.assign () विधि अपवाद को नहीं फेंकती है।

उदाहरण: एक वस्तु का क्लोनिंग

 var obj = { a: 1 }; var copy = Object.assign({}, obj); console.log(copy); // { a: 1 } 

उदाहरण: वस्तुओं का विलय करना

 var o1 = { a: 1 }; var o2 = { b: 2 }; var o3 = { c: 3 }; var obj = Object.assign(o1, o2, o3); console.log(obj); // { a: 1, b: 2, c: 3 } console.log(o1); // { a: 1, b: 2, c: 3 },     . 

बाकी पैरामीटर

फ़ंक्शन के शेष मापदंडों का सिंटैक्स आपको एक सरणी के रूप में असीमित तर्क का प्रतिनिधित्व करने की अनुमति देता है।

यदि अंतिम नामित फ़ंक्शन तर्क में एक उपसर्ग है ..., तो यह स्वचालित रूप से फ़ंक्शन के पास दिए गए तर्कों की वास्तविक संख्या के अनुसार 0 से theArgs.length के तत्वों के साथ एक सरणी बन जाता है।

वाक्य-विन्यास

 function(a, b, ...theArgs) { // ... } 

शेष मापदंडों के सिंटैक्स का उपयोग करने का एक उदाहरण:

 function name (a, b, ...c) {} name (0, 1, 2, 3,) 

इस उदाहरण में, a = 0 b = 1 c [0] = 2 c [1] = 3
यदि शेष पैरामीटर पारित नहीं किया जाता है, तो यह एक खाली सरणी होगी (साधारण मापदंडों के विपरीत, यह कभी अपरिभाषित नहीं होगी)।

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

 var a = [ 0, 1, 2 ]; var b = [ 3, 4, 5 ]; var c = [ ...a, ...b ]; // [ 0, 1, 2, 3, 4, 5 ] 

डिफ़ॉल्ट पैरामीटर

डिफ़ॉल्ट पैरामीटर आपको औपचारिक फ़ंक्शन पैरामीटर को डिफ़ॉल्ट मानों को सेट करने की अनुमति देता है यदि फ़ंक्शन को बिना तर्क के कहा जाता है, या यदि पैरामीटर स्पष्ट रूप से अप्रकाशित है।

जावास्क्रिप्ट में, एक फ़ंक्शन के पैरामीटर जो मानों को पारित नहीं करते हैं, जब इसे डिफ़ॉल्ट मान को अपरिभाषित कहा जाता है। हालाँकि, कुछ मामलों में यह एक अलग डिफ़ॉल्ट मान सेट करने के लिए उपयोगी हो सकता है। यह ऐसे मामलों के लिए है जो डिफ़ॉल्ट सेटिंग्स का इरादा है।

डिफ़ॉल्ट मान केवल एक औपचारिक पैरामीटर को सौंपा गया है यदि, फ़ंक्शन कॉल के दौरान, इस पैरामीटर के लिए मान पारित नहीं किया गया था या अपरिभाषित नहीं था।

डिफ़ॉल्ट मापदंडों का उपयोग करने का एक उदाहरण:

 function myFun(a=5) { return a*a; } console.log(myFun()); // 25 

विनाशकारी कार्य

जावास्क्रिप्ट एक्सप्रेशंस में विनाशकारी असाइनमेंट सिंटैक्स आपको किसी ऑब्जेक्ट में एक सरणी या शाब्दिक की घोषणा के समान सिंटैक्स का उपयोग करके एरे या ऑब्जेक्ट्स से डेटा प्राप्त करने की अनुमति देता है।

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

विनाशकारी असाइनमेंट का उपयोग करने के प्रमुख तरीकों में से एक ऑपरेटर के साथ डेटा संरचना को पढ़ना है, हालांकि आप इसके अलावा कई अन्य उपयोग पा सकते हैं।

विनाशकारी असाइनमेंट का उदाहरण:

 var a, b, rest; [a, b] = [1, 2]; console.log(a); // 1 console.log(b); // 2 [a, b, ...rest] = [1, 2, 3, 4, 5]; console.log(a); // 1 console.log(b); // 2 console.log(rest); // [3, 4, 5] ({a, b} = {a:1, b:2}); console.log(a); // 1 console.log(b); // 2 

आप यहां और उदाहरण देख सकते हैं।

नक्शा

मानचित्र - मुख्य-मूल्य जोड़े वाली एक वस्तु और सम्मिलन क्रम को संरक्षित करना। किसी भी मूल्य (दोनों वस्तुओं और आदिम) का उपयोग कुंजी के रूप में किया जा सकता है।

एक उदाहरण:

 var myMap = new Map(); var keyObj = {}, keyFunc = function () {}, keyString = "a string"; //   myMap.set(keyString, "value associated with 'a string'"); myMap.set(keyObj, "value associated with keyObj"); myMap.set(keyFunc, "value associated with keyFunc"); myMap.size; // 3 //   myMap.get(keyString); // "value associated with 'a string'" myMap.get(keyObj); // "value associated with keyObj" myMap.get(keyFunc); // "value associated with keyFunc" myMap.get("a string"); // "value associated with 'a string'" //   keyString === 'a string' myMap.get({}); // undefined,   keyObj !== {} myMap.get(function() {}) // undefined,   keyFunc !== function () {} 

वस्तु से मानचित्र का अंतर:

• ऑब्जेक्ट कुंजियाँ लाइन्स और सिंबल हैं, जबकि फ़ंक्शंस, ऑब्जेक्ट्स और प्राइमिटिव्स सहित कोई भी मान मैप की हो सकता है।
• ऑब्जेक्ट्स के विपरीत, मैप में कुंजियों का आदेश दिया गया है। इस प्रकार, मानचित्र पुनरावृत्ति के दौरान, चाबियाँ प्रविष्टि क्रम में वापस आ जाती हैं।
• आप आकार की संपत्ति का उपयोग करके मानचित्र में तत्वों की संख्या आसानी से प्राप्त कर सकते हैं, जबकि किसी ऑब्जेक्ट में तत्वों की संख्या केवल मैन्युअल रूप से निर्धारित की जा सकती है।
• मानचित्र एक चलने योग्य वस्तु है और इसे सीधे पुन: प्रसारित किया जा सकता है, जबकि वस्तु को कुंजी की सूची और उनके पुनरावृत्ति की मैन्युअल रसीद की आवश्यकता होती है।
• ऑब्जेक्ट में एक प्रोटोटाइप होता है और इसलिए इसमें कुंजियों का एक मानक सेट होता है, जो लापरवाह होने पर, आपकी चाबियों के साथ अंतर कर सकता है। ES5 की रिलीज़ के बाद से, इसे map = Object.create (null) के उपयोग से बदला जा सकता है।
• चाबियों को बार-बार जोड़ने या हटाने के मामलों में मानचित्र का बेहतर प्रदर्शन हो सकता है।

गुण और विधियाँ:

• Map.prototyp.size - एक मानचित्र पर कुंजी \ value जोड़े की संख्या लौटाता है
• Map.prototyp.set (कुंजी, मान) - पास किए गए key \ value जोड़े को मैप में जोड़ता है। यदि निर्दिष्ट कुंजी पहले से मौजूद है, तो यह नए मूल्य के साथ ओवरराइट किया जाएगा।
• Map.prototyp.get (कुंजी) - पारित कुंजी का मान लौटाता है। यदि कोई कुंजी नहीं है, तो अपरिभाषित वापस आ जाएगा
• Map.prototype.has (कुंजी) - यदि पास कुंजी मौजूद है और यह नहीं है तो गलत है
• Map.prototyp.delete (कुंजी) - निर्दिष्ट की \ value जोड़ी को हटाता है और सही लौटाता है। यदि कुंजी मौजूद नहीं है, तो गलत देता है।
• Map.prototyp.clear () - मैप से सभी प्रमुख \ value जोड़े को निकालता है
• Map.prototyp.keys () - प्रत्येक तत्व के लिए एक मानचित्र पर कुंजियों का एक पुनरावर्तक लौटाता है
• Map.prototyp.values ​​() - प्रत्येक तत्व के लिए मानचित्र पर मूल्यों का एक पुनरावृत्ति देता है
• Map.prototyp.entries () - प्रत्येक तत्व के लिए मैप पर सरणी [कुंजी, मूल्य] का एक पुनरावृत्ति देता है

सेट

आपको किसी भी प्रकार के, आदिम और अन्य प्रकार के ऑब्जेक्ट के अद्वितीय मूल्यों को सहेजने की अनुमति देता है।

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

गुण और उदाहरण तरीके सेट करें

• आकार - सेट ऑब्जेक्ट में तत्वों की संख्या लौटाता है।
• add (value) - सेट ऑब्जेक्ट में दिए गए मान के साथ एक नया तत्व जोड़ता है। सेट ऑब्जेक्ट लौटाता है।
• clear () - सेट ऑब्जेक्ट से सभी तत्वों को निकालता है।
• डिलीट (मूल्य) - मान से जुड़े तत्व को हटाता है और उस मान को लौटाता है जिसमें (मान) पहले होता है। है (मान) बाद में गलत वापस आ जाएगा।
• प्रविष्टियाँ () - एक नया Iterator ऑब्जेक्ट देता है जिसमें सम्मिलन क्रम में सेट ऑब्जेक्ट में प्रत्येक तत्व के लिए [मान, मान] की एक सरणी होती है। यह मैप ऑब्जेक्ट के समान संग्रहीत किया जाता है, इसलिए प्रत्येक प्रविष्टि की कुंजी और मूल्य के लिए यहां समान मूल्य है।
• forEach (callbackFn [, thisArg]) - कॉलबैक में एक बार सेट ऑब्जेक्ट में मौजूद प्रत्येक मान के लिए कॉल करें। यदि यह 'एर्ग' के लिए निर्दिष्ट है, तो इसका उपयोग प्रत्येक कॉलबैक के लिए इस मान के रूप में किया जाएगा।
• has (value) - एक बूलियन मान देता है जो यह पुष्टि करता है कि दिए गए मान वाला तत्व सेट ऑब्जेक्ट में मौजूद है या नहीं।
• मान () - एक नया Iterator ऑब्जेक्ट देता है जिसमें सम्मिलन क्रम में सेट ऑब्जेक्ट में प्रत्येक तत्व के लिए मान शामिल हैं।

सेट ऑब्जेक्ट का उपयोग करना

 var mySet = new Set(); mySet.add(1); // Set { 1 } mySet.add(5); // Set { 1, 5 } mySet.add(5); // Set { 1, 5 } mySet.add("some text"); // Set { 1, 5, 'some text' } var o = {a: 1, b: 2}; mySet.add(o); mySet.add({a: 1, b: 2}); //  o    ,      mySet.has(1); // true mySet.has(3); // false, 3     set mySet.has(5); // true mySet.has(Math.sqrt(25)); // true mySet.has("Some Text".toLowerCase()); // true mySet.has(o); // true mySet.size; // 5 mySet.delete(5); //  5  set mySet.has(5); // false, 5   mySet.size; // 4,     console.log(mySet); // Set {1, 'some text', Object {a: 1, b: 2}, Object {a: 1, b: 2}} 

बाईपास सेट

 //    : 1, "some text", {"a": 1, "b": 2} for (let item of mySet) console.log(item); //    : 1, "some text", {"a": 1, "b": 2} for (let item of mySet.keys()) console.log(item); //    : 1, "some text", {"a": 1, "b": 2} for (let item of mySet.values()) console.log(item); //    : 1, "some text", {"a": 1, "b": 2} //(key  value    ) for (let [key, value] of mySet.entries()) console.log(key); //  Set  Array var myArr = Array.from(mySet); // [1, "some text", {"a": 1, "b": 2}] //       HTML  mySet.add(document.body); mySet.has(document.querySelector("body")); // true //   Array  Set   mySet2 = new Set([1,2,3,4]); mySet2.size; // 4 [...mySet2]; // [1,2,3,4] //      var intersection = new Set([...set1].filter(x => set2.has(x))); //      var difference = new Set([...set1].filter(x => !set2.has(x))); //   set   forEach mySet.forEach(function(value) { console.log(value); }); // 1 // 2 // 3 // 4 

कक्षाएं

जावास्क्रिप्ट में कक्षाएं ECMAScript 2015 में शुरू की गई थीं और जावास्क्रिप्ट में प्रोटोटाइप वंशानुक्रम पर सिंथेटिक चीनी हैं। क्लास सिंटैक्स एक नए ऑब्जेक्ट-ओरिएंटेड मॉडल को पेश नहीं करता है, लेकिन ऑब्जेक्ट बनाने और विरासत को व्यवस्थित करने के लिए एक सरल और अधिक सहज तरीका प्रदान करता है।

कक्षाएं वास्तव में "विशेष कार्य" होती हैं, इसलिए जैसे आप फ़ंक्शन (फ़ंक्शन एक्सप्रेशन और फ़ंक्शन घोषणाएँ) को परिभाषित करते हैं, आप कक्षाओं को क्लास एनाउंसमेंट और क्लास एक्सप्रेशन के साथ परिभाषित कर सकते हैं।

फंक्शन डिक्लेरेशन और क्लास डिक्लेरेशन के बीच का अंतर यह है कि फंक्शन डिक्लेरेशन फहराया जाता है, जबकि क्लास डिक्लेरेशन नहीं होता है। इसलिए, आपको पहले अपनी कक्षा की घोषणा करनी चाहिए और उसके बाद ही उसके साथ काम करना चाहिए, अन्यथा प्रकार का एक संदर्भ Reference को फेंक दिया जाएगा।

वर्ग घोषणा

कक्षा को परिभाषित करने का पहला तरीका एक वर्ग घोषणा के साथ है। ऐसा करने के लिए, वर्ग कीवर्ड का उपयोग करें और वर्ग नाम निर्दिष्ट करें (उदाहरण में, "myClass")।

 class myClass{ constructor(height, width) { this.height = height; this.width = width; } } 

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

 //  var myClass = class { constructor(height, width) { this.height = height; this.width = width; } }; //  var myClass = class myClass { constructor(height, width) { this.height = height; this.width = width; } }; 

कक्षा की अभिव्यक्तियाँ कक्षा की घोषणाओं की तरह ही लहराती समस्याओं के अधीन हैं!

क्लास डिक्लेरेशन बॉडीज़ और क्लास एक्सप्रेशंस को सख्त मोड में निष्पादित किया जाता है।
सख्त मोड रनटाइम के सिंटैक्स और व्यवहार को बदलता है।
अधिक सटीक होने के लिए, सख्त मोड की विशेषता निम्नलिखित है:

• त्रुटियों को अपवाद में बदलें
• परिवर्तन जो अपने नाम का उपयोग करने के कुछ मामलों में एक चर की गणना को सरल करते हैं;
• , eval arguments;
• , «» JavaScript;

1. .
2. .
3. , , .
4. ( ).
5. , , . , .
6. . .
7. अष्टक वर्ग प्रणाली का वाक्य विन्यास निषिद्ध है।
8. आदिम मूल्यों के साथ गुण सेट करना निषिद्ध है।

चर के साथ काम का
सरलीकरण सख्त मोड कोड में इसकी परिभाषा के स्थान के साथ चर नाम की तुलना को सरल करता है।

1. के साथ उपयोग करना निषिद्ध है। इसके साथ समस्या यह है कि रनटाइम पर, ब्लॉक के अंदर कोई भी नाम संसाधित होने वाली वस्तु की संपत्ति या आसपास के (या यहां तक ​​कि वैश्विक) संदर्भ में एक चर का उल्लेख कर सकता है - इस बारे में पहले से जानना असंभव है। पहले से मौजूद एक साधारण विकल्प - एक छोटे नाम के साथ एक चर के लिए वस्तु को असाइन करना और फिर इस चर की संपत्ति के रूप में वांछित संपत्ति तक पहुंचना।
2. eval () सख्त मोड में आसपास के संदर्भ में नए चर नहीं जोड़ता है।
3. सरल नामों को हटाना निषिद्ध है।

Eval और तर्कों का सरलीकरण
Strict मोड तर्कों और eval के व्यवहार में विषमताओं की संख्या को कम करता है, दोनों एक निश्चित मात्रा में जादू को नियमित कोड में मिलाते हैं। तो eval वैरिएबल को जोड़ता या हटाता है और उनके मूल्यों को बदलता है, और तर्कों का चर आपको इसके अनुक्रमित गुणों से आश्चर्यचकित कर सकता है, जो नामित फ़ंक्शन तर्कों के लिए संदर्भ (समानार्थक शब्द) हैं।

1. कीवर्ड के निष्कासन और तर्कों को ओवरराइड या संशोधित नहीं किया जा सकता है।
2. तर्कों के क्षेत्र नामांकित तर्कों से जुड़े नहीं हैं, लेकिन मूल्यों की उनकी डुप्लिकेट प्रतियां हैं।
3. तर्क। कानूनी संपत्ति समर्थित नहीं है। नियमित कोड में, तर्कों। संपत्ति का अर्थ फ़ंक्शन को संदर्भित करता है, जिसके आह्वान के लिए तर्कों का निर्माण किया गया था।

"सुरक्षित" जावास्क्रिप्ट
कुछ वेबसाइटें उपयोगकर्ताओं को जावास्क्रिप्ट लिखने की क्षमता प्रदान करती हैं जिन्हें अन्य उपयोगकर्ताओं की ओर से साइट पर निष्पादित किया जाएगा। ब्राउज़रों में, जावास्क्रिप्ट में निजी जानकारी तक पहुँच हो सकती है, जो कि जावास्क्रिप्ट में एक सुरक्षा छेद है।

1. फ़ंक्शन को दिया गया मान इस प्रकार है कि ऑब्जेक्ट को सख्त मोड में नहीं रखा गया है।
2. मूल ECMAScript एक्सटेंशन के माध्यम से जावास्क्रिप्ट स्टैक को "रन" करना संभव नहीं है।
3. फ़ंक्शन में, तर्क संपत्ति अब फ़ंक्शन के अंदर बनाए गए चर तक पहुंच प्रदान नहीं करती है।

आप Strict मोड के बारे में अधिक जानने के लिए ECMAScript 5.1 विनिर्देश को देख सकते हैं।
और मोज़िला से प्रलेखन भी ।

कंस्ट्रक्टर्स

कंस्ट्रक्टर एक विशेष विधि है जिसका उपयोग कक्षा का उपयोग करके बनाई गई वस्तुओं को बनाने और शुरू करने के लिए किया जाता है।

 class Student { constructor(name) { this.name = name; } } var robert = new Student('Robert'); console.log(robert.name); // Outputs 'Robert' 

कक्षा से नई वस्तुएं बनाते समय, कंस्ट्रक्टर () लॉन्च किया जाएगा, जो ऑब्जेक्ट्स को इनिशियलाइज़ करने के लिए आवश्यक है।

एक वर्ग में केवल एक विधि हो सकती है जिसे कंस्ट्रक्टर कहा जाता है। यदि क्लास में एक से अधिक कंस्ट्रक्टर हैं, तो सिंटैक्सएयर अपवाद को फेंक दिया जाएगा।

सुपर कीवर्ड का उपयोग कंस्ट्रक्टर में पैरेंट क्लास के कंस्ट्रक्टर को इनवाइट करने के लिए किया जा सकता है।

यदि आपने एक कंस्ट्रक्टर विधि को परिभाषित नहीं किया है, तो डिफ़ॉल्ट कंस्ट्रक्टर का उपयोग किया जाएगा।
आधार कक्षाओं के लिए, डिफ़ॉल्ट निर्माता है:

 constructor() {} 

व्युत्पन्न वर्गों के लिए, डिफ़ॉल्ट निर्माता है:

 constructor(...args) { super(...args); } 

तरीकों

विधि घोषणा सिंटैक्स:

 var obj = { property([parameters]) {}, get property() {}, set property(value) {}, * generator() {} }; 

जनरेटर के तरीकों की संक्षिप्तता

 var obj = { * g() { var index = 0; while(true) yield index++; } }; var it = obj.g(); console.log(it.next().value); // 0 console.log(it.next().value); // 1 

जनरेटर के तरीकों को छोड़कर सभी विधि परिभाषाएं निर्माता नहीं हो सकती हैं और यदि आप उन्हें त्वरित करने का प्रयास करते हैं, तो एक टाइपर फेंक देंगे।

गणना की गई संपत्ति के नाम

 var obj = { ["foo" + 2](){ return 2; } console.log(obj.foo2()); // 2 }; 

स्थैतिक खोजशब्द एक वर्ग के लिए स्थिर विधियों को परिभाषित करता है। स्टैटिक विधियों को उनकी कक्षा को तुरंत बताए बिना बुलाया जाता है, और उन्हें कक्षा के उदाहरणों पर नहीं बुलाया जा सकता है।

गेट और बसने का सिंटैक्स

 class Student { constructor(name) { this.name = name; } get Name() { return this.name; } set Name(newName) { if(typeof(newName) != "string") throw new Error("Name is not a string!"); else this.name = newName; // Robert } } var robert = new Student('robert'); robert.Name = "Robert"; console.log(robert.Name); 

• सेटर - लिखित मापदंडों के सत्यापन के लिए आवश्यक (जैसा कि ऊपर उदाहरण में)
• getter - गुण प्राप्त करने की आवश्यकता (हालांकि उन्हें सीधे प्राप्त किया जा सकता है)। तर्क नहीं हो सकते

ES6 में कोई अंतर्निहित इनकैप्सुलेशन नहीं है, लेकिन आप इसे स्वयं व्यवस्थित कर सकते हैं। उदाहरण के लिए, इस तरह:

 var Student = (function () { let privateProps = new WeakMap(); class Person { constructor(name, Age) { this.name = name; // public privateProps.set(this, {age: Age}); // private } get Age() { return privateProps.get(this).age; } set Age (newAge) { privateProps.set(this, {age: newAge}); } } return Person; })(); var robert = new Student('Robert', 19); robert.Age = 20; console.log(robert.Age); // 20 

विरासत

क्लास को घोषित करने और क्लास एक्सप्रेशंस में एक और क्लास का बच्चा पैदा करने के लिए एक्सटेंडर्स कीवर्ड का इस्तेमाल किया जाता है।

 class Person { constructor (age) { this.age = age; } sayAge () { return this.age; } } class Student extends Person { constructor (name, age) { super(age); this.name = name; } sayFull () { return `Hello my name is ${this.name} and I'm ${super.sayAge()} years old`; } } var robert = new Student("Robert", 19); console.log(robert.sayFull()); // Hello my name is Robert and I'm 19 years old 

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

जब आप चाइल्ड क्लास में पैरेंट क्लास के तरीकों को ओवरराइड करते हैं, तो डिफ़ॉल्ट रूप से चाइल्ड क्लास के तरीकों को बुलाया जाएगा, लेकिन आप सुपर () फ़ंक्शन का उपयोग करके स्पष्ट रूप से पेरेंट क्लास के तरीकों को कॉल कर सकते हैं।

 class obj { constructor(name){ this.name = name; } displayName(){ return this.name.length; } } undefined class obj_2 extends obj { constructor(name) { super(name); } displayName() { //     return [this.name, super.displayName()]; } } var Obj = new obj_2("obj_2"); console.log(Obj.displayName()); // Array [ "obj_2", 5 ] 

फैली इनलाइन ऑब्जेक्ट्स को एक्सटेंड करने के साथ
यह उदाहरण इनलाइन डेट ऑब्जेक्ट को बढ़ाता है।

 class myDate extends Date { constructor() { super(); } getFormattedDate() { var months = [ 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec' ]; return this.getDate() + '-' + months[this.getMonth()] + '-' + this.getFullYear(); } } 

वादा

प्रॉमिस ऑब्जेक्ट का उपयोग आस्थगित और अतुल्यकालिक गणनाओं के लिए किया जाता है।

वादा तीन राज्यों में हो सकता है:

• लंबित: प्रारंभिक अवस्था, पूर्ण नहीं और अस्वीकृत नहीं।
• (fulfilled): .
• (rejected): .

(pending), (fulfilled), (), (rejected), . , then. ( , , .. « », , , DOM.)

Promise.prototype.then() Promise.prototype.catch() , , .


(promise)
नए कीवर्ड और इसके कंस्ट्रक्टर के उपयोग से एक प्रॉमिस ऑब्जेक्ट बनाया जाता है। प्रॉमिस कंस्ट्रक्टर एक तर्क को एक निष्पादक फ़ंक्शन के रूप में ले जाता है। इस फ़ंक्शन को पैरामीटर के रूप में दो कॉलबैक फ़ंक्शन को स्वीकार करना चाहिए। पहले एक (संकल्प) को कहा जाता है जब एसिंक्रोनस ऑपरेशन सफलतापूर्वक पूरा हुआ और मूल्य के रूप में इसके निष्पादन का परिणाम लौटाया गया। ऑपरेशन के विफल होने पर दूसरा कॉलबैक (अस्वीकार) कहा जाता है, और विफलता के कारण का संकेत देते हुए एक मूल्य देता है, सबसे अधिक बार एक त्रुटि वस्तु।

 const myPromise = new Promise((resolve, reject) => { //   ,    : resolve(someValue); //   //  reject("failure reason"); //  }); 

दो तर्कों के साथ एक फ़ंक्शन ऑब्जेक्ट, हल और अस्वीकार, वादे के सफल होने का कारण बनता है; दूसरा इसे अस्वीकार करता है।

फ़ंक्शन को वादा कार्यक्षमता के साथ प्रदान करने के लिए, आपको बस इसमें वादा वस्तु वापस करने की आवश्यकता है।

 function myAsyncFunction(url) { return new Promise((resolve, reject) => { const xhr = new XMLHttpRequest(); xhr.open("GET", url); xhr.onload = () => resolve(xhr.responseText); xhr.onerror = () => reject(xhr.statusText); xhr.send(); }); } 

के साथ। तब निष्पादन और अस्वीकृति संचालकों को संलग्न किया जाता है।

तरीकों

• Promise.all (iterable) - सभी वादों के क्रियान्वयन या उनमें से किसी के लिए अस्वीकार किए जाने का इंतजार करता है। एक वादा लौटाता है जिसे सभी वादों के चलने के बाद निष्पादित किया जाएगा। इस घटना में कि किसी भी वादे को अस्वीकार कर दिया गया है, Promise.all भी अस्वीकार कर दिया जाएगा।
• Promise.allSettled (iterable) - सभी प्राप्त वादों के पूरा होने का इंतजार करता है (निष्पादन और अस्वीकृति दोनों)। एक ऐसा वादा लौटाता है, जब सभी प्राप्त वादों को पूरा किया जाता है (निष्पादित या अस्वीकृत), जिसमें प्राप्त वादों के निष्पादन के परिणामों की एक सरणी होती है।
• Promise.race (iterable) - किसी भी प्राप्त वादों के निष्पादन या अस्वीकृति की प्रतीक्षा करता है। एक वादा लौटाता है जिसे पहले निष्पादित या अस्वीकार किए गए वादे के निष्पादन के परिणाम के साथ निष्पादित या अस्वीकार किया जाएगा।
• Promise.reject (कारण) - कारण के कारण अस्वीकार कर दिया गया वादा वापस करता है।
• Promise.resolve (मान) - परिणाम मान के साथ निष्पादित वादा लौटाता है।

प्रॉमिस प्रोटोटाइप

• पकड़ (चालू) - वादे की अस्वीकृति को संभालने के लिए एक कॉलबैक फ़ंक्शन जोड़ता है, जो कि दिए गए वादे के साथ किए गए एक नए वादे को वापस करता है, या अगर वादा किया जाता है, तो मूल समाधान मूल्य।
• तब (onFulfilled, onRejected) - एक वादे को पूरा करने और अस्वीकृति हैंडलर जोड़ता है, और एक नया वादा करता है जिसे तथाकथित हैंडलर के मूल्य के साथ निष्पादित किया जाता है, या मूल मूल्य यदि वादा नहीं किया गया था (यानी, यदि संबंधित ऑनफिल्ड या ऑनरकेड हैंडलर एक फ़ंक्शन नहीं है)।

अतुल्यकालिक http अनुरोध बनाना:

 const URL = "https://getfestivo.com/v1/holidays?api_key=f8f42551-eb66-49d2-bcba-b8e42727ddfb&country=US&year=2019"; //  API      function asyncHttpRequest (url) { return new Promise((resolve, reject) => { //  promise if (url == undefined) //     url reject(new Error("Expected url and received nothing")); else { resolve(() => { fetch(url).then((response) => { //   return response.json(); //    JSON   }).then((myJson) => { return(console.log(myJson)); //      }); }); } } );} asyncHttpRequest(URL).then((result) => result(), (error) => console.log(error)); 

आप आधिकारिक दस्तावेज़ीकरण में और साथ ही मोज़िला प्रलेखन में वादों के बारे में अधिक उदाहरण और जानकारी प्राप्त कर सकते हैं ।

iterators

एक संग्रह में प्रत्येक आइटम को संसाधित करना एक बहुत ही सामान्य ऑपरेशन है। जावास्क्रिप्ट एक संग्रह पर पुनरावृत्ति करने के लिए कई तरीके प्रदान करता है, लूप के लिए एक सरल से मानचित्र (), फ़िल्टर (), और सरणी समझ के लिए। Iterators और जनरेटर भाषा की कोर में सीधे गणना की अवधारणा को लागू करते हैं और लूप्स के लिए व्यवहार की स्थापना के लिए एक तंत्र प्रदान करते हैं।

एक ऑब्जेक्ट एक इटरेटर है यदि वह इस अनुक्रम के भीतर अपनी वर्तमान स्थिति को ट्रैक करते समय, संग्रह के तत्वों को एक बार में एक्सेस कर सकता है। जावास्क्रिप्ट में, एक इट्रेटर एक ऑब्जेक्ट है जो एक अगली () विधि प्रदान करता है जो अनुक्रम के अगले तत्व को वापस करता है। यह विधि दो गुणों वाली एक वस्तु लौटाती है: किया और मूल्य।

एक बार बनाने के बाद, इटेरेटर ऑब्जेक्ट को अगली () विधि से कॉल करके स्पष्ट रूप से उपयोग किया जा सकता है।

Iterable - यह एक ऐसी वस्तु है जिसकी सामग्री को इससे अधिक पुनरावृत्त किया जा सकता है।
चलने योग्य वस्तु गैर-चलने योग्य से भिन्न होती है, इसमें एक विशेष विधि होती है जो किसी वस्तु तक पहुंच के लिए एक विशेष प्रतीक का उपयोग करती है: Symbol.iterator

 Iterable { [Symbol.iterator]() } 

विधि जो वस्तु लौटाती है, उसे औपचारिक रूप से एक पुनरावृत्तिक कहा जाता है।
इट्रेटर की सिर्फ एक अगली () विधि है

 Iterator { next(); } 

जो दो गुणों के साथ एक वस्तु देता है (चलो इसे itreratorResult कहते हैं) और किया गया गुण

 IteratorResult { done, value } 

किया इंगित करता है कि अनुक्रम में कोई मान अभी भी खोजा जा रहा है, और मान में अनुक्रम का अगला तत्व है।


आरंभीकरण के बाद, अगले () विधि को कुंजी-मूल्य जोड़े को एक-एक करके ऑब्जेक्ट में एक्सेस करने के लिए कहा जा सकता है।

यदि ऑब्जेक्ट मानों की गणना करने के लिए एक विधि को परिभाषित करता है, तो यह एक तर्क देने योग्य है, उदाहरण के लिए, मानों का निर्माण कैसे किया जाता है। कुछ अंतर्निहित प्रकार, जैसे कि ऐरे या मैप, डिफ़ॉल्ट रूप से चलने योग्य हैं, जबकि अन्य प्रकार, जैसे ऑब्जेक्ट, नहीं हैं।

चलने योग्य होने के लिए, एक ऑब्जेक्ट को पुनरावृत्ति विधि को लागू करना चाहिए, जिसका अर्थ है कि यह (या प्रोटोटाइप श्रृंखला में से एक ऑब्जेक्ट) के पास Symbol.iterator नामक एक संपत्ति होनी चाहिए।

ऐसा मानक मानक जैसा दिखता है:

 function makeIterator(array){ var nextIndex = 0; return { next: function(){ return nextIndex < array.length ? { value: array[nextIndex++], done: false } : { done: true }; } } } 

जेनरेटर

जनरेटर एक विशेष प्रकार का फ़ंक्शन है जो एक इट्रेटर फैक्टरी की तरह काम करता है। फ़ंक्शन एक जनरेटर बन जाता है यदि इसमें एक या अधिक उपज स्टेटमेंट होते हैं और फ़ंक्शन * सिंटैक्स का उपयोग करता है।

जनरेटर एक नए प्रकार का फ़ंक्शन है जो इसके निष्पादन को रोक सकता है और एक मध्यवर्ती परिणाम लौटा सकता है और बाद में निष्पादन फिर से शुरू कर सकता है।

आइए एक नियमित फ़ंक्शन को देखें जो कुछ गणित करता है और एक परिणाम देता है:

 function myFunction (a) { a = a*2; a = a - 1; return a; } console.log(myFunction(5)); // 9 

अब एक समान जनरेटर फ़ंक्शन पर एक नज़र डालें:

 function* generator(a) { a = a*2; yield a; a = a - 1; yield a; } var it = generator(5); console.log(it.next().value); // 10 console.log(it.next().value); // 9</i> 

जैसा कि पहले कहा गया था, जनरेटर अपने निष्पादन को रोक सकते हैं और एक मध्यवर्ती परिणाम लौटा सकते हैं। यह उदाहरण दिखाता है कि पहली कॉल के समय, फ़ंक्शन ऐसा होता है जैसे कि पहले ब्रेकपॉइंट उपज पर इसके निष्पादन को निलंबित करता है और पहली अभिव्यक्ति का परिणाम देता है। दूसरे कॉल में, फ़ंक्शन पिछले ब्रेकपॉइंट से जारी रहता है और अगले एक्सप्रेशन के परिणाम को लौटाता है।

फ़ंक्शन जनरेटर जटिल अनुक्रमिक कार्यों को लिखने के लिए एक शक्तिशाली उपकरण प्रदान करते हैं।

जनरेटर मांग पर अपनी उपज के भावों के परिणामों की गणना करते हैं, जो उन्हें उच्च कम्प्यूटेशनल जटिलता, या यहां तक ​​कि अनंत अनुक्रमों के साथ कुशलता से काम करने की अनुमति देता है।

अगली () विधि एक मान भी लेती है जिसका उपयोग जनरेटर की आंतरिक स्थिति को बदलने के लिए किया जा सकता है। अगले () को दिए गए मान को अंतिम उपज अभिव्यक्ति का परिणाम माना जाएगा जिसने जनरेटर को रोक दिया।

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

यदि उपज कथन फेंकने वाले अपवाद से निपटने के दौरान नहीं होता है, तो अपवाद को फेंक () कॉल के माध्यम से ऊपर पारित किया जाता है, और बाद में () को कॉल करने का परिणाम सही के बराबर किया जाएगा।

जेनरेटर में एक रिटर्न (मान) विधि होती है जो दिए गए मान को लौटाती है और जनरेटर को रोकती है।

प्रतीक

प्रतीक एक आदिम डेटा प्रकार है जिसके उदाहरण अद्वितीय और अपरिवर्तनीय हैं।

जावास्क्रिप्ट रनटाइम में, प्रतीक () फ़ंक्शन को कॉल करके एक "प्रतीक" मान बनाया जाता है, जो गतिशील रूप से एक अनाम और अद्वितीय मूल्य बनाता है। एकमात्र उचित उपयोग चरित्र को बचाने के लिए है, और फिर ऑब्जेक्ट की संपत्ति बनाने के लिए संग्रहीत मूल्य का उपयोग करें।

जब एक संपत्ति के असाइनमेंट में एक पहचानकर्ता के रूप में एक चरित्र का उपयोग किया जाता है, तो संपत्ति (उदाहरण के लिए, एक चरित्र) गुमनाम होती है; और भी गिनने योग्य नहीं है। चूंकि संपत्ति कम्प्यूटेशनल नहीं है, इसलिए यह "for (... में ...)" लूप में प्रदर्शित नहीं होगा, और चूंकि प्रॉपर्टी बेनामी है, इसलिए इसे "Object.getOwnPropertyNames ()" परिणाम सरणी में प्रदर्शित नहीं किया जाएगा। इस संपत्ति को प्रतीक के प्रारंभिक मूल्य का उपयोग करके बनाया जा सकता है, या परिणाम सरणी "Object.getOwnPropertySymbols ()" के माध्यम से पुनरावृत्ति करके।


तो आप एक चरित्र संपत्ति बना सकते हैं:

 var user = { name: "Alex", [Symbol("password")]: "12hsK3I" } 

वर्ण ऑब्जेक्ट्स की एक सरणी प्राप्त करने के लिए, Object.getOwnPropertySymbols (obj) संपत्ति का उपयोग करें;
अपने कोड में कहीं भी पहुंचने के लिए, Symbol.for () और Symbol.keyFor () विधियों का उपयोग करें।

Sumbol डेटा प्रकार के बारे में अधिक जानकारी के लिए, आधिकारिक दस्तावेज़ में देखें , और मोज़िला दस्तावेज़ में भी ।