🚴🏻 🍷 🧚 12 जावास्क्रिप्ट के बारे में पता करने के लिए अवधारणाओं 🐨 ✊🏼 🧗🏿

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

1. मूल्यों और संदर्भों को संग्रहित करने वाले चर

यह समझना कि जावास्क्रिप्ट में वास्तव में चर मान कैसे असाइन किए जाते हैं, उन लोगों के लिए बेहद महत्वपूर्ण है जो सही ढंग से काम करने वाले कोड लिखना चाहते हैं। इस तंत्र की गलतफहमी उन कार्यक्रमों को लिखने की ओर ले जाती है जिनमें चर के मान अनजाने में बदल सकते हैं।

जावास्क्रिप्ट, यदि किसी इकाई में एक आदिम प्रकार है (विशेष रूप से, Boolean , null , undefined , String और Number प्रकार), हमेशा इस इकाई के मूल्य के साथ काम करता है। यही है, मान संबंधित चर के लिए लिखा गया है। अगर हम किसी ऑब्जेक्ट (उदाहरण के लिए, Object , Array , Function ) के बारे में बात कर रहे हैं, तो जब इसे किसी वैरिएबल पर असाइन किया जाता है, तो इसके लिए एक संदर्भ इसे लिखा जाता है, जिस पते पर यह मेमोरी में स्थित है।

एक उदाहरण पर विचार करें। निम्नलिखित कोड स्निपेट में, एक स्ट्रिंग को var1 लिखा जाता है। उसके बाद, var2 मान var2 वेरिएबल को लिखा var2 है। चूंकि var1 चर में एक आदिम प्रकार ( String ) होता है, इसलिए var1 में उपलब्ध स्ट्रिंग की एक प्रति var1 को लिखी var1 । यह हमें var2 को एक चर के रूप में विचार करने की अनुमति देता है जो कि var1 से पूरी तरह से स्वतंत्र है, हालांकि यह var1 के समान मूल्य को संग्रहीत करता है। var1 नया मान लिखने से var1 प्रभावित नहीं होता है।

 let var1 = 'My string'; let var2 = var1; var2 = 'My new string'; console.log(var1); // 'My string' console.log(var2); // 'My new string'

अब वस्तुओं के साथ काम करने के एक उदाहरण पर विचार करें।

 let var1 = { name: 'Jim' } let var2 = var1; var2.name = 'John'; console.log(var1); // { name: 'John' } console.log(var2); // { name: 'John' }

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

2. शॉर्ट सर्किट

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

 function createGreeter(greeting) { return function(name) {   console.log(greeting + ', ' + name); } } const sayHello = createGreeter('Hello'); sayHello('Joe'); // Hello, Joe

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

 function apiConnect(apiKey) { function get(route) {   return fetch(`${route}?key=${apiKey}`); } function post(route, params) {   return fetch(route, {     method: 'POST',     body: JSON.stringify(params),       headers: {         'Authorization': `Bearer ${apiKey}`       }     }) } return { get, post } } const api = apiConnect('my-secret-key'); //     API     api.get('http://www.example.com/get-endpoint'); api.post('http://www.example.com/post-endpoint', { name: 'Joe' });

3. विनाशकारी असाइनमेंट

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

 const obj = { name: 'Joe', food: 'cake' } const { name, food } = obj; console.log(name, food); // 'Joe' 'cake'

यदि आपको निकाले गए गुणों के नाम निर्दिष्ट करने की आवश्यकता है जो उन वस्तुओं से अलग हैं जो उनके पास ऑब्जेक्ट में हैं, तो आप ऐसा कर सकते हैं:

 const obj = { name: 'Joe', food: 'cake' } const { name: myName, food: myFood } = obj; console.log(myName, myFood); // 'Joe' 'cake'

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

 const person = { name: 'Eddie', age: 24 } function introduce({ name, age }) { console.log(`I'm ${name} and I'm ${age} years old!`); } console.log(introduce(person)); // "I'm Eddie and I'm 24 years old!"

4. फैला हुआ संचालक

प्रसार ऑपरेटर एक काफी सरल निर्माण है जो एक अप्रस्तुत व्यक्ति के लिए समझ से बाहर हो सकता है। निम्नलिखित उदाहरण में एक संख्यात्मक सरणी है, जिसमें अधिकतम मूल्य संग्रहीत है जिसमें हमें खोजने की आवश्यकता है। हम इसके लिए Math.max() विधि का उपयोग करना चाहते हैं, लेकिन यह पता नहीं है कि सरणियों के साथ कैसे काम किया जाए। वह, तर्क के रूप में, स्वतंत्र संख्यात्मक मूल्यों को मानता है। सरणी से इसके तत्वों को निकालने के लिए, हम प्रसार ऑपरेटर का उपयोग करते हैं, जो तीन बिंदुओं की तरह दिखता है।

 const arr = [4, 6, -1, 3, 10, 4]; const max = Math.max(...arr); console.log(max); // 10

5. शेष कथन

बाकी ऑपरेटर आपको फ़ंक्शन में दिए गए किसी भी तर्क को किसी सरणी में बदलने की अनुमति देता है।

 function myFunc(...args) { console.log(args[0] + args[1]); } myFunc(1, 2, 3, 4); // 3

6. ऐरे तरीके

सरणी विधियां अक्सर डेवलपर को विभिन्न प्रकार के डेटा रूपांतरण कार्यों को खूबसूरती से हल करने के लिए सुविधाजनक उपकरण देती हैं। मैं कभी-कभी StackOverflow पर सवालों के जवाब देता हूं। उनमें से, अक्सर ऐसे होते हैं जो वस्तुओं के सरणियों के साथ उन या अन्य तरीकों से काम करने के लिए समर्पित होते हैं। यह ऐसी स्थितियों में है कि सरणी विधियां विशेष रूप से उपयोगी हैं।

यहां हम कई ऐसे तरीकों पर विचार करेंगे, जो एक दूसरे के साथ अपनी समानता के सिद्धांत द्वारा एकजुट होंगे। यह ध्यान दिया जाना चाहिए कि यहां मैं आपको सरणियों के सभी तरीकों के बारे में नहीं बताऊंगा। आप एमडीएन पर उनकी पूरी सूची पा सकते हैं (वैसे, यह मेरा पसंदीदा जावास्क्रिप्ट संदर्भ है)।

▍Map (), फ़िल्टर (), और कम () तरीके

map() , filter() और reduce() सरणी विधियाँ आपको सरणियों को बदलने या किसी एकल मान (जो कि एक वस्तु हो सकती है) को कम करने की अनुमति देती हैं।

map() विधि एक नई सरणी देता है जिसमें संसाधित सरणी के परिवर्तित मान होते हैं। इस पद्धति से पारित फ़ंक्शन में वे वास्तव में कैसे रूपांतरित होंगे, यह निर्दिष्ट किया गया है।

 const arr = [1, 2, 3, 4, 5, 6]; const mapped = arr.map(el => el + 20); console.log(mapped); // [21, 22, 23, 24, 25, 26]

filter() विधि तत्वों की एक सरणी लौटाता है, जिन मानों की जाँच इस विधि में दी गई है, वह true ।

 const arr = [1, 2, 3, 4, 5, 6]; const filtered = arr.filter(el => el === 2 || el === 4); console.log(filtered); // [2, 4]

reduce() विधि एक निश्चित मान देता है, जो कि सरणी के सभी तत्वों को संसाधित करने का परिणाम है।

 const arr = [1, 2, 3, 4, 5, 6]; const reduced = arr.reduce((total, current) => total + current); console.log(reduced); // 21

▍ मेथड पाते हैं (), findIndex () और indexOf ()

सरणी विधियाँ find() , findIndex() और indexOf() एक दूसरे के साथ भ्रमित करना आसान है। इनकी विशेषताओं को समझने में आपकी मदद करने के लिए निम्नलिखित स्पष्टीकरण हैं।

find() विधि निर्दिष्ट मापदंड से मेल खाने वाले सरणी का पहला तत्व लौटाती है। यह विधि, पहले उपयुक्त तत्व को खोजने, सरणी में खोज जारी नहीं रखती है।

 const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; const found = arr.find(el => el > 5); console.log(found); // 6

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

findIndex() विधि find() समान है, लेकिन सरणी में पहला उपयुक्त तत्व वापस करने के बजाय, यह उस तत्व के सूचकांक को लौटाता है। इस पद्धति को बेहतर ढंग से समझने के लिए, निम्नलिखित उदाहरण पर एक नज़र डालें, जो स्ट्रिंग मानों की एक सरणी का उपयोग करता है।

 const arr = ['Nick', 'Frank', 'Joe', 'Frank']; const foundIndex = arr.findIndex(el => el === 'Frank'); console.log(foundIndex); // 1

findIndex() विधि findIndex() विधि findIndex() विधि के समान है, लेकिन यह एक तर्क के रूप में कार्य करता है, लेकिन एक सामान्य मूल्य नहीं। वांछित सरणी तत्व की खोज करते समय जटिल तर्क की आवश्यकता नहीं होने पर इसका उपयोग किया जा सकता है।

 const arr = ['Nick', 'Frank', 'Joe', 'Frank']; const foundIndex = arr.indexOf('Frank'); console.log(foundIndex); // 1

▍ पुश (), पॉप (), शिफ्ट (), और अनशिफ्ट () तरीके

push() , pop() , shift() और unshift() का उपयोग सरणियों में नए तत्वों को जोड़ने और उनसे पहले से मौजूद सरणियों में मौजूद तत्वों को निकालने के लिए किया जाता है। इस मामले में, काम शुरू या सरणी के अंत में स्थित तत्वों के साथ किया जाता है।

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

 let arr = [1, 2, 3, 4]; const pushed = arr.push(5); console.log(arr); // [1, 2, 3, 4, 5] console.log(pushed); // 5

pop() विधि सरणी से अंतिम तत्व निकालता है। यह सरणी को संशोधित करता है और इससे हटाए गए तत्व को वापस करता है।

 let arr = [1, 2, 3, 4]; const popped = arr.pop(); console.log(arr); // [1, 2, 3] console.log(popped); // 4

shift() विधि पहले तत्व को सरणी से हटाती है और इसे वापस करती है। यह उस सरणी को भी संशोधित करता है जिसके लिए इसे कहा जाता है।

 let arr = [1, 2, 3, 4]; const shifted = arr.shift(); console.log(arr); // [2, 3, 4] console.log(shifted); // 1

unshift() विधि किसी सरणी के आरंभ में एक या अधिक तत्व जोड़ती है। वह, फिर से, सरणी को संशोधित करता है। उसी समय, यहां चर्चा की गई अन्य तीन विधियों के विपरीत, यह सरणी की नई लंबाई लौटाती है।

 let arr = [1, 2, 3, 4]; const unshifted = arr.unshift(5, 6, 7); console.log(arr); // [5, 6, 7, 1, 2, 3, 4] console.log(unshifted); // 7

Methods स्लाइस () और ब्याह () विधियाँ

इन विधियों का उपयोग सरणी को संशोधित करने या सरणी के कुछ हिस्से को वापस करने के लिए किया जाता है।

splice() विधि मौजूदा तत्वों को हटाकर या उन्हें अन्य तत्वों के साथ बदलकर एक सरणी की सामग्री को बदल देती है। वह सरणी में नए तत्वों को जोड़ने में सक्षम है। यह विधि सरणी को संशोधित करती है।

निम्न उदाहरण, यदि आप इसे सामान्य भाषा में वर्णित करते हैं, तो यह इस तरह दिखता है: आपको सरणी स्थिति 1 , 0 तत्वों को निकालने और b युक्त तत्व जोड़ने की आवश्यकता है।

 let arr = ['a', 'c', 'd', 'e']; arr.splice(1, 0, 'b')

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

 let arr = ['a', 'b', 'c', 'd', 'e']; const sliced = arr.slice(2, 4); console.log(sliced); // ['c', 'd'] console.log(arr); // ['a', 'b', 'c', 'd', 'e']

▍ विधि क्रमबद्ध ()

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

 let arr = [1, 7, 3, -1, 5, 7, 2]; const sorter = (firstEl, secondEl) => firstEl - secondEl; arr.sort(sorter); console.log(arr); // [-1, 1, 2, 3, 5, 7, 7]

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

7. जनक

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

यहाँ एक जनरेटर है जिसे सीमित संख्या में मान लौटाने के लिए डिज़ाइन किया गया है:

 function* greeter() { yield 'Hi'; yield 'How are you?'; yield 'Bye'; } const greet = greeter(); console.log(greet.next().value); // 'Hi' console.log(greet.next().value); // 'How are you?' console.log(greet.next().value); // 'Bye' console.log(greet.next().value); // undefined

और यहाँ एक जनरेटर है जिसे लूप के माध्यम से अनंत मानों को वापस करने के लिए डिज़ाइन किया गया है।

 function* idCreator() { let i = 0; while (true)   yield i++; } const ids = idCreator(); console.log(ids.next().value); // 0 console.log(ids.next().value); // 1 console.log(ids.next().value); // 2 //   ...

8. मूल्यों की समानता (==) और सख्त समानता (===) की जाँच के लिए ऑपरेटर

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

 console.log(0 == '0'); // true console.log(0 === '0'); // false

9. वस्तुओं की तुलना

मुझे कभी-कभी यह देखना पड़ता है कि जेएस प्रोग्रामिंग में नए लोग एक ही गलती कैसे करते हैं। वे वस्तुओं की सीधे तुलना करने की कोशिश करते हैं। वे चर जिनमें ऑब्जेक्ट "संग्रहीत" होते हैं, उनके संदर्भ होते हैं, न कि ये ऑब्जेक्ट स्वयं।

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

 const joe1 = { name: 'Joe' }; const joe2 = { name: 'Joe' }; console.log(joe1 === joe2); // false

इसके अलावा, निम्नलिखित उदाहरण में, यह पता चलता है कि joe1 joe2 बराबर है क्योंकि दोनों चर एक ही वस्तु के संदर्भ को संग्रहीत करते हैं।

 const joe1 = { name: 'Joe' }; const joe2 = joe1; console.log(joe1 === joe2); // true

वास्तविक वस्तु तुलना के तरीकों में से एक JSON-string प्रारूप में उनका प्रारंभिक रूपांतरण है। सच है, इस दृष्टिकोण में एक समस्या है, जो यह है कि वस्तु के प्राप्त स्ट्रिंग प्रतिनिधित्व में इसके गुणों के एक निश्चित क्रम की गारंटी नहीं है। वस्तुओं की तुलना करने के लिए एक अधिक विश्वसनीय तरीका वस्तुओं की गहरी तुलना के लिए उपकरणों से युक्त एक विशेष पुस्तकालय का उपयोग करना है (उदाहरण के लिए, यह लेश लाइब्रेरी का isEqual () तरीका है)।

वस्तुओं की तुलना करने की पेचीदगियों को बेहतर ढंग से समझने और अलग-अलग चर में एक ही वस्तुओं के लिए लिंक लिखने के संभावित परिणामों को समझने के लिए, इस लेख में चर्चा की गई पहली जेएस अवधारणा पर एक नज़र डालें।

10. कॉलबैक फ़ंक्शंस

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

 function myFunc(text, callback) { setTimeout(function() {   callback(text); }, 2000); } myFunc('Hello world!', console.log); // 'Hello world!'

11. वादा करता है

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

 const myPromise = new Promise(function(res, rej) { setTimeout(function(){   if (Math.random() < 0.9) {     return res('Hooray!');   }   return rej('Oh no!'); }, 1000); }); myPromise .then(function(data) {   console.log('Success: ' + data);  })  .catch(function(err) {   console.log('Error: ' + err);  }); //  Math.random()  , ,  0.9,    : // "Success: Hooray!" //  Math.random()  , ,  0.9,  0.9,    : // "Error: On no!"

12. async / निर्माण का इंतजार है

वादों के साथ काम करने के बाद, तब, संभवतः, आप कुछ और चाहते हैं। उदाहरण के लिए, async / प्रतीक्षा निर्माण में महारत हासिल करें। यह वादों के लिए वाक्यगत चीनी है। निम्नलिखित उदाहरण में, हम एसिंक्रोनस async , एक एसिंक्रोनस फ़ंक्शन का उपयोग करके बनाते हैं, और इसमें, await कीवर्ड का उपयोग करते हुए, हम ग्रीटर greeter लिए प्रतीक्षा को व्यवस्थित करते हैं।

 const greeter = new Promise((res, rej) => { setTimeout(() => res('Hello world!'), 2000); }) async function myFunc() { const greeting = await greeter; console.log(greeting); } myFunc(); // 'Hello world!'

परिणाम

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

प्रिय पाठकों! आप इस लेख में और कौन सी जावास्क्रिप्ट अवधारणाएँ जोड़ेंगे?

12 जावास्क्रिप्ट के बारे में पता करने के लिए अवधारणाओं