कंट्रोल फ़्लो वह क्रम होता है जिसमें JavaScript इंटरप्रेटर काम करता है स्टेटमेंट. अगर किसी स्क्रिप्ट में इसके फ़्लो को बदलने वाले स्टेटमेंट शामिल नहीं हैं, तो एक बार में एक लाइन का इस्तेमाल करके, शुरू से आखिर तक चलाया जाता है. कंट्रोल स्ट्रक्चर यह तय करने के लिए इस्तेमाल किया जाता है कि तय की गई शर्तों के सेट, स्टेटमेंट के सेट को बार-बार लागू करना या किसी स्टेटमेंट का क्रम तय करें.
कंडिशनल स्टेटमेंट
कंडीशनल स्टेटमेंट यह तय करते हैं कि कोड को
और स्थितियां. शर्त वाला स्टेटमेंट उस कोड को लागू करता है जो उसमें शामिल होता है. ऐसा तब होता है, जब
जुड़ी हुई शर्त (या शर्तों के सेट) का आकलन करके true
मिलता है. या फिर,
कोड को छोड़ा गया.
if
…else
if
स्टेटमेंट, मेल खाने वाले ब्रैकेट में उस शर्त का आकलन करता है जो
फ़ॉलो करें. अगर ब्रैकेट के अंदर दी गई शर्त की वैल्यू true
की होती है, तो
स्टेटमेंट या ब्लॉक स्टेटमेंट
जो ब्रैकेट मेल खाने वाले ब्रैकेट के बाद आते हैं उन्हें एक्ज़ीक्यूट किया जाता है:
if ( true ) console.log( "True." );
> "True."
if ( true ) {
const myString = "True.";
console.log( myString );
}
> "True."
अगर कोष्ठक के अंदर दी गई शर्त false
का मूल्यांकन करती है, तो यह कथन
इसे अनदेखा कर दिया जाता है:
if ( false ) console.log( "True." );
if
स्टेटमेंट के ठीक बाद एक else
कीवर्ड और उसके
शर्तों के साथ लागू किया गया स्टेटमेंट, एक्ज़ीक्यूट किए जाने वाले स्टेटमेंट का पता लगाता है, अगर
if
शर्त का आकलन false
होगा:
if ( false ) console.log( "True." )''
else console.log( "False" );
> "False."
एक से ज़्यादा if
स्टेटमेंट को एक साथ चेन करने के लिए,
else
अन्य if
कथन के बाद शर्तों के साथ लागू किया गया विवरण:
const myCondition = 2;
if ( myCondition === 5 ) console.log( "Five." );
else if ( myCondition === 2 ) console.log( "Two." );
हमारा सुझाव है कि शर्तों का पालन करते हुए ब्लॉक स्टेटमेंट सिंटैक्स का इस्तेमाल करें, ताकि
रीडबिलिटी को बेहतर किया जा सकता है, लेकिन else if
क्लॉज़ अक्सर इसके अपवाद होते हैं:
if ( myCondition === 5 ) {
console.log( "Five." );
} else if ( myCondition === 3 ) {
console.log( "Three" );
} else {
console.log( "Neither five nor three." );
}
> "Neither five nor three."
टर्नरी ऑपरेटर
if
शर्त के साथ स्टेटमेंट लागू करता है. टर्नरी ऑपरेटर (ज़्यादा सटीक रूप से)
हालाँकि, इसे आम तौर पर टर्नरी कंडीशनल ऑपरेटर कहा जाता है)
का इस्तेमाल किसी एक्सप्रेशन को शर्त के साथ करता है. जैसा कि इसके नाम से ही पता चलता है, टर्नरी
ऑपरेटर ही अकेला JavaScript ऑपरेटर है जो तीन ऑपरेंड का इस्तेमाल करता है:
- ऐसी शर्त के बाद सवाल का निशान (
?
) लगता है जिसका आकलन किया जाना है. - अगर शर्त का आकलन
true
होता है, तो लागू किया जाने वाला एक्सप्रेशन. इसके बाद, कोलन (:
). - शर्त
false
की वैल्यू मिलती है या नहीं, यह एक्ज़ीक्यूट करने के लिए एक्सप्रेशन किया जा सकता है.
इसका इस्तेमाल अक्सर शर्त के साथ वैल्यू को सेट करने या पास करने के लिए किया जाता है:
const myFirstResult = true ? "First value." : "Second value.";
const mySecondResult = false ? "First value." : "Second value.";
myFirstResult;
> "First value."
mySecondResult;
> "Second value."
switch
…case
किसी व्यंजक के मान की तुलना इनकी सूची से करने के लिए switch
कथन का इस्तेमाल करें
एक या ज़्यादा case
कीवर्ड का उपयोग करके परिभाषित संभावित मान. यह सिंटैक्स है
असामान्य, क्योंकि यह JavaScript के शुरुआती डिज़ाइन वाले कुछ फ़ैसलों से आता है.
switch
...case
सिंटैक्स switch
कीवर्ड का इस्तेमाल करता है, जिसके बाद एक्सप्रेशन होता है
इसका आकलन ब्रैकेट में किया जाएगा और इसके बाद, कर्ली ब्रैकेट का इस्तेमाल किया जाएगा.
switch
में case
कीवर्ड शामिल हो सकते हैं. आम तौर पर, इसमें एक या ज़्यादा कीवर्ड होते हैं
उसके बाद कोई एक्सप्रेशन या वैल्यू हो और उसके बाद कोलन (:
) हो.
जब अनुवादक, एक्सप्रेशन से मेल खाने वाली वैल्यू के साथ case
पर पहुंचता है
ब्रैकेट में, switch
कीवर्ड के बाद आकलन किया जाता है. इसलिए, यह किसी भी वैल्यू को एक्ज़ीक्यूट करता है
उस case
क्लॉज़ का पालन करने वाले स्टेटमेंट:
switch ( 2 + 2 === 4 ) {
case false:
console.log( "False." );
case true:
console.log( "True." );
}
> "True."
मेल खाने वाले case
के बाद के सभी स्टेटमेंट एक्ज़ीक्यूट किए जाते हैं, भले ही वे
को ब्लॉक स्टेटमेंट में रखें.
switch ( 2 + 2 === 4 ) {
case false:
console.log( "False." );
case true:
let myVariable = "True.";
console.log( myVariable );
}
> "True."
switch…case
का इस्तेमाल करने का एक नुकसान यह भी है कि मेल खाने के बाद,
JavaScript अनुवादक कोई भी स्टेटमेंट लागू करता है, जो मेल खाने वाले case
के बाद आता है,
वे भी जो अन्य case
क्लॉज़ में मौजूद हैं. इसे "कमिंग थ्रू" कहा जाता है तक
अगली case
:
switch ( 2 + 2 === 7 ) {
case false:
console.log( "False." );
case true:
console.log( "True." );
}
> "False."
> "True."
गलती से बचने के लिए, हर केस को break
कीवर्ड से खत्म करें, जो
switch
बॉडी की जांच तुरंत रोक देता है:
switch ( 2 + 2 === 7 ) {
case false:
console.log( "False." );
break;
case true:
console.log( "True." );
break;
}
> "False."
अगर कोई case
, कंडिशनल वैल्यू से मैच नहीं करता, तो switch
, default
को चुनता है
क्लॉज़, अगर कोई हो:
switch ( 20 ) {
case 5:
console.log( "The value was five." );
break;
case 10:
console.log( "The value was ten." );
break;
default:
console.log( "The value was something unexpected." );
}
> "The value was something unexpected."
हालांकि, फ़ॉल-थ्रू default
पर भी लागू होता है. इससे
अनचाहे नतीजे. इसे ठीक करने के लिए, break
के साथ अपना default
स्टेटमेंट खत्म करें,
या मामलों की सूची में इसे आख़िर में रखें.
switch ( 20 ) {
default:
console.log( "The value was something unexpected." );
case 10:
console.log( "The value was ten." );
break;
case 5:
console.log( "The value was five." );
break;
}
> The value was something unexpected.
> The value was ten.
क्योंकि case
क्लॉज़ की ज़रूरत नहीं है
ग्रुप बनाने के लिए ब्यौरे को ब्लॉक करें
एकाधिक स्टेटमेंट, case
और default
क्लॉज़ नहीं बनते.
लेक्सिकल स्कोप में ये शामिल होते हैं:
let myVariable;
switch ( true ) {
case true:
let myVariable = "True.";
break;
default:
let myVariable = "False.";
break;
}
> Uncaught SyntaxError: redeclaration of let myVariable
दायरा मैनेज करने के लिए, ब्लॉक स्टेटमेंट का इस्तेमाल करें:
let myVariable;
switch ( true ) {
case true: {
let myVariable = "True.";
break;
}
default: {
let myVariable = "False.";
break;
}
}
लूप और इटरेशन
लूप की मदद से, स्टेटमेंट का एक सेट तब तक दोहराया जा सकता है, जब तक शर्त पूरी होती है या जब तक कोई शर्त पूरी नहीं हो जाती. किसी निर्देश के सेट को एक्ज़ीक्यूट करने के लिए लूप का इस्तेमाल करना कोई ख़ास नतीजा मिलने तक कितनी बार या अनुवादक की मदद से बार-बार दोहराए जा सकने वाले डेटा स्ट्रक्चर के आखिर में पहुंच जाता है (उदाहरण के लिए, कोई अरे, मैप या सेट, किसी ऑब्जेक्ट की आखिरी प्रॉपर्टी या आखिरी वर्ण स्ट्रिंग).
"ऊपर से नीचे" को लूप में चलाना इटरेशन के ज़रिए स्क्रिप्ट के एक्ज़िक्यूशन का फ़्लो स्टेटमेंट के एक सेट में की पुष्टि, लूप बनाने के लिए इस्तेमाल किए गए सिंटैक्स के आधार पर की गई है. लूप खत्म होने के बाद, निष्पादन उन स्टेटमेंट के लिए जारी रहता है जो इसके बाद आते हैं. नीचे दिए गए उदाहरण में, लूप के मुख्य भाग में मौजूद कथनों को अनुवादक आगे बढ़ता है:
let iterationCount = 0;
console.log( "Pre-loop." );
while( iterationCount < 3 ) {
iterationCount++;
console.log( "Loop iteration." );
}
console.log( "Continuing on." );
> "Pre-loop."
> "Loop iteration."
> "Loop iteration."
> "Loop iteration."
> "Continuing on."
अगर लूप के चलने के दौरान, शर्तें पूरी नहीं हो पाती हैं, तो लूप जारी रहता है लंबे समय तक. ये इनफ़ाइनाइट लूप, प्रोग्रामिंग में होने वाली एक आम गलती हैं. इनकी वजह से मुख्य एक्ज़ीक्यूशन थ्रेड की वजह से बंद करने या ब्राउज़र टैब को बंद करने का विकल्प भी होता है.
नीचे दिया गया उदाहरण तब तक काम करता है, जब तक बूलियन वैल्यू true
बनी रहती है
true
. बूलियन वैल्यू में बदलाव नहीं किया जा सकता,
इससे एक अनंत लूप बन जाता है.
console.log( "Pre-loop." );
while( true ) {
console.log( "Loop iteration." );
}
> "Pre-loop."
> "Loop iteration."
> "Loop iteration."
> "Loop iteration."
> "Loop iteration."
> "Loop iteration."
…
अपने प्रोडक्शन कोड में अनंत लूप छोड़ने से बचें. अगर गलती से करते हैं, तो आप चल रहे ब्राउज़र टैब को बंद करके इसे ठीक कर सकते हैं में, अपना कोड अपडेट करना होगा, ताकि लूप अब अनंत न रहे. साथ ही, पेज.
while
while
कीवर्ड के बाद एक जोड़े का उपयोग करके एक while
लूप बनाया गया है
मैच करने वाले ब्रैकेट में आकलन करने की शर्त मौजूद होती है. अगर बताए गए
शर्त का मूल्यांकन शुरू में true
, कथन (या
ब्लॉक करें) जो इन सुझावों को फ़ॉलो करते हैं
उन ब्रैकेट को एक्ज़ीक्यूट किया जाता है. अगर नहीं, तो लूप कभी नहीं चलता. हर एक के बाद
फिर से करना होगा, तो स्थिति की फिर से जांच की जाती है. साथ ही, अगर यह अब भी true
है, तो लूप में स्थिति की जांच की जाती है
दोहराता है.
let iterationCount = 0;
while( iterationCount < 3 ) {
iterationCount++;
console.log( `Loop ${ iterationCount }.` );
}
> "Loop 1."
> "Loop 2."
अगर अनुवादक को while
लूप में continue
स्टेटमेंट मिलता है, तो वह रुक जाता है
फिर से करना, स्थिति की दोबारा समीक्षा करना, और मुमकिन होने पर लूप को जारी रखना:
let iterationCount = 0;
while( iterationCount <= 5 ) {
iterationCount++;
if( iterationCount === 3 ) {
continue;
}
console.log( `Loop ${ iterationCount }.` );
}
console.log( "Loop ended." );
> "Loop 1."
> "Loop 2."
> "Loop 4."
> "Loop 5."
> "Loop ended."
अगर अनुवादक को while
लूप में break
स्टेटमेंट मिलता है, तो
रुक जाता है और स्थिति की दोबारा जांच नहीं की जाती, जिससे अनुवादक आगे बढ़ सकता है:
let iterationCount = 1;
while( iterationCount <= 5 ) {
if( iterationCount === 3 ) {
console.log(`Iteration skipped.``);`
break;
}
console.log( `Loop ${ iterationCount }.` );
iterationCount++;
}
console.log( "Loop ended." );
> "Loop 1."
> "Loop 2."
> "Iteration skipped.
> "Loop ended."
while
का इस्तेमाल, तय संख्या में बार-बार करने के लिए किया जा सकता है. ऐसा करने का तरीका
पिछले उदाहरण में बताया गया है, लेकिन while
के लिए सबसे आम इस्तेमाल का उदाहरण
अनिश्चित लंबाई:
let randomize = () => Math.floor( Math.random() * 10 );
let randomNum = randomize();
while( randomNum !== 3 ){
console.log( `The number is not ${ randomNum }.` );
randomNum = randomize();
}
console.log( `The correct number, ${ randomNum }, was found.` );
> "The number is not 0."
> "The number is not 6."
> "The number is not 1."
> "The number is not 8."
> "The correct number, 3, was found."
do
…while
do
...while
, while
लूप का ऐसा वैरिएंट है जिसमें कंडिशनल है
लूप की हर बार प्रोसेस होने के बाद, इवैलुएशन आखिर में होता है. इसका मतलब है कि
लूप का मुख्य भाग हमेशा कम से कम एक बार चलाया जाता है.
do
...while
लूप बनाने के लिए, do
कीवर्ड के बाद स्टेटमेंट का उपयोग करें
(या ब्लॉक करें स्टेटमेंट)
लूप की हर गतिविधि पर लागू होता है. उस स्टेटमेंट के तुरंत बाद, जोड़ें
while
और ऐसे ब्रैकेट जिनमें आकलन की जाने वाली शर्त मौजूद है. टास्क कब शुरू होगा
इस शर्त का मूल्यांकन अब true
के रूप में नहीं होता है, लूप खत्म होता है.
let iterationCount = 1;
do {
console.log( `Loop ${ iterationCount }.` );
iterationCount++;
} while ( iterationCount < 3 );
> "Loop 1."
> "Loop 2."
> "Loop 3."
while
लूप की तरह ही, do
के लिए सबसे आम इस्तेमाल का उदाहरण...while
एक लूप है
अनिश्चित लंबाई:
let randomNum;
do {
randomNum = ( () => Math.floor( Math.random() * 10 ) )();
console.log( `Is the number ${ randomNum }?` );
} while ( randomNum !== 3 );
console.log( `Yes, ${ randomNum } was the correct number.` );
> "Is the number 9?"
> "Is the number 2?"
> "Is the number 8?"
> "Is the number 2?"
> "Is the number 3?"
> "Yes, 3 was the correct number."
for
किसी जानी-पहचानी संख्या को दोहराने के लिए, for
लूप का इस्तेमाल करें. लेगसी कोड बेस में, यह था
इसका इस्तेमाल अक्सर किसी कलेक्शन के एलिमेंट पर दोहराने के लिए किया जाता है.
for
लूप बनाने के लिए, for
कीवर्ड का इस्तेमाल करें और उसके बाद कोष्ठकों का एक समूह इस्तेमाल करें
जो नीचे दिए गए तीन एक्सप्रेशन को क्रम से स्वीकार करता है और इन्हें
सेमीकोलन:
- लूप शुरू होने पर आकलन किया जाने वाला एक्सप्रेशन
- एक शर्त जो तय करती है कि लूप को जारी रखना है या नहीं
- हर लूप के आखिर में एक्ज़ीक्यूट किया जाने वाला एक्सप्रेशन
इन कोष्ठकों के बाद, यह कथन जोड़ें (आम तौर पर ब्लॉक करें) के रूप में) लूप के दौरान चलाया जाता है.
for( let i = 0; i < 3; i++ ) {
console.log( "This loop will run three times.")
}
पहला एक्सप्रेशन ऐसे वैरिएबल को शुरू करता है जो काउंटर की तरह काम करता है. यह
लूप की पहली इटरेशन से पहले, एक्सप्रेशन का एक बार आकलन किया जाता है. आप
किसी दूसरे वैरिएबल की तरह, let
(या var
, पुराने वर्शन) का इस्तेमाल करके इस वैरिएबल को शुरू करें
वैरिएबल होता है और इसका स्कोप लूप का मुख्य हिस्सा होता है. इन वैरिएबल में
मान्य आइडेंटिफ़ायर है, लेकिन "दोहराव" के लिए इन्हें बार-बार i
कहा जाता है या "index" के तौर पर सेट करें.
ऐसा लगता है कि यह नियम,
अनुमानित आइडेंटिफ़ायर के नाम के लिए सबसे सही तरीके,
हालांकि, यह कंवेंशन इतनी अच्छी तरह से बनाया गया है कि दूसरे डेवलपर को भी यह साफ़ तौर पर पता चल जाएगा
एक नज़र डालें. इंडेक्स किए गए कलेक्शन को इंडेक्स नहीं किया जाता,
इन वैरिएबल की शुरुआती वैल्यू करीब-करीब हमेशा 0
होती है.
लूप के अन्य रूपों की तरह, शर्त एक ऐसा एक्सप्रेशन है जो तय करता है कि
लूप चलाना होगा या नहीं. ऊपरी वैल्यू को सेट करने के लिए, अक्सर इसका इस्तेमाल किया जाता है
इटरेशन काउंटर के लिए बाध्य. अनुवादक
पहली बार for
लूप को एक्ज़ीक्यूट किया जा रहा है.अगर शर्त लागू नहीं होती है, तो
true
तक सेट करते हैं, तो लूप का मुख्य हिस्सा नहीं चलाया जाता.
लूप की मदद से, हर इटरेशन के आखिर में फ़ाइनल एक्सप्रेशन को एक्ज़ीक्यूट किया जाता है. आम तौर पर, इसका इस्तेमाल आइडेंटिफ़ायर को एक साथ बढ़ाने के लिए किया जाता है.
आपको ज़्यादातर पुराने दौर में अरे के ज़रिए बार-बार चलने वाले for
लूप दिखेंगे
कोड बेस में भी सेव किया जा सकता है. इन मामलों में, लूप को जारी रखने के लिए तय की गई शर्त एक
इटरेशन की संख्या, दोहराई जा रही कैटगरी की लंबाई से कम या उसके बराबर होती है
से. वर्तमान इटरेशन की संख्या को ट्रैक करने के लिए उपयोग किए जाने वाले चर का उपयोग देखने के लिए किया जाता है
अरे में उस इंडेक्स से जुड़ी वैल्यू को बढ़ा देगा, जिससे हर एलिमेंट को
वह अरे जिस पर कार्रवाई की जानी है. इसके क्रम में:
var myArray = [ true, false, true ];
for( let i = 0; i <= myArray.length; i++ ) {
console.log( myArray[ i ] );
}
> true
> false
> true
यह तरीका अब आधुनिक तरीकों के बजाय, सभी के लिए इटर किए जा सकने वाले डेटा स्ट्रक्चर को लूप में चलाना.
for
[...] of
[...]
for
...of
... लूप का इस्तेमाल करके
इटरेबल डेटा स्ट्रक्चर, जैसे कि कलेक्शन, सेट या मैप.
एक for
...of
... लूप, for
कीवर्ड का इस्तेमाल करता है. इसके बाद, ब्रैकेट का एक सेट होता है
इसमें एक वैरिएबल होता है. इसके बाद of
आता है. इसके बाद, डेटा स्ट्रक्चर को दोहराया जा रहा है
खत्म. वैरिएबल को यहां let
, const
या
var
, एक ऐसा वैरिएबल जिसका एलान पहले मौजूदा स्कोप में ही किया गया था, एक ऑब्जेक्ट
प्रॉपर्टी या
डिस्ट्रक्चर किया जा रहा असाइनमेंट.
इसमें, मौजूदा एलिमेंट के हिसाब से वैल्यू शामिल होती है
लूप में रखा गया है.
const myIterable = [ true, false, true ];
for( const myElement of myIterable ) {
console.log( myElement );
}
> true
> false
> true
इस उदाहरण में, myElement
के लिए const
का इस्तेमाल करना सही है, भले ही myElement
लूप की हर गतिविधि में एक नई वैल्यू दी गई है. इसकी वजह यह है कि वैरिएबल
let
या const
के साथ दिए गए एलान के दायरे में,
लूप. वैरिएबल को हर बार की शुरुआत में शुरू किया जाता है. इसके बाद, इसे हटाया जाता है
प्रक्रिया ख़त्म हो जाएगी.
for
...in
...
किसी ऑब्जेक्ट की संख्या में बदलाव करने के लिए, for
...in
... लूप का इस्तेमाल करें,
इसमें इनहेरिट की गई कई प्रॉपर्टी शामिल हैं. for
...of
... लूप की तरह,
for
...in
... लूप में for
कीवर्ड के बाद ब्रैकेट का सेट होता है
इसमें एक वैरिएबल होता है, जिसमें संबंधित प्रॉपर्टी कुंजी का मान होता है
लूप की मौजूदा चाल के हिसाब से. इस वैरिएबल के बाद
in
कीवर्ड है, फिर ऑब्जेक्ट को दोहराया जा रहा है:
const myObject = { "myProperty" : true, "mySecondProperty" : false };
for( const myKey in myObject ) {
console.log( myKey );
}
> "myProperty"
> "mySecondProperty"
फिर से, लूप की हर बार दोहराए जाने के साथ myKey
की वैल्यू बदलने के बावजूद,
वैरिएबल को खारिज कर दिया गया है, इसलिए बिना किसी गड़बड़ी के const
का इस्तेमाल किया जा सकता है
हर एक गतिविधि के खत्म होने पर, फिर शुरुआत में फिर से बनाया जाता है.
हर प्रॉपर्टी कुंजी से जुड़ी वैल्यू,
for
...in
... सिंटैक्स. हालांकि, लूप के पास प्रॉपर्टी कुंजी का ऐक्सेस
करते हैं, तो आप उस बटन का उपयोग "ऊपर" देखने के लिए कर सकते हैं इसकी वैल्यू:
const myObject = { "myProperty" : true, "mySecondProperty" : false };
for( const myKey in myObject ) {
const myValue = myObject[ myKey ];
console.log( `${ myKey } : ${ myValue }` );
}
> "myProperty : true"
> "mySecondProperty : false"
बिल्ट-इन कंस्ट्रक्टर से इनहेरिट की गई प्रॉपर्टी की गिनती नहीं की जा सकती. इसका मतलब है कि
for
...in
... Object
से इनहेरिट की गई प्रॉपर्टी के ज़रिए बार-बार नहीं होता है
कंस्ट्रक्टर है. हालांकि, ऑब्जेक्ट के अंदर मौजूद कोई भी संख्या वाली प्रॉपर्टी
प्रोटोटाइप चेन में शामिल हैं:
const myPrototype = { "protoProperty" : true };
const myObject = Object.create( myPrototype, {
myProperty: {
value: true,
enumerable: true
}
});
for ( const myKey in myObject ) {
const myValue = myObject[ myKey ];
console.log( `${ myKey } : ${ myValue }` );
}
> "myProperty : true"
> "protoProperty : true"
JavaScript यह तय करने के लिए पहले से मौजूद तरीके उपलब्ध कराता है कि कोई प्रॉपर्टी
प्रॉपर्टी के बजाय ऑब्जेक्ट के प्रोटोटाइप पर मौजूद प्रॉपर्टी की सीधी प्रॉपर्टी
चेन: मॉडर्न
Object.hasOwn()
और लेगसी Object.prototype.hasOwnProperty()
तरीके. ये
तरीकों से यह आकलन किया जाता है कि बताई गई प्रॉपर्टी इनहेरिट की गई है (या उसका एलान नहीं किया गया है),
सिर्फ़ बताए गए ऑब्जेक्ट की तुरंत प्रॉपर्टी के लिए ही true
रिटर्न कर सकता है:
const myPrototype = { "protoProperty" : true };
const myObject = Object.create( myPrototype, {
myProperty: {
value: true,
enumerable: true
}
});
for ( const myKey in myObject ) {
const myValue = myObject[ myKey ];
if ( Object.hasOwn( myObject, myKey ) ) {
console.log( `${ myKey } : ${ myValue }` );
}
}
> "myProperty : true"
यहां तीन स्थिर तरीके भी हैं, जिनमें से हर एक अरे से बनी प्रॉपर्टी को दिखाता है
ऑब्जेक्ट की गिनती की जा सकने वाली कुंजियां (Object.keys()
), वैल्यू (Object.values()
) या
की-वैल्यू पेयर (Object.entries()
):
const myObject = { "myProperty" : true, "mySecondProperty" : false };
Object.keys( myObject );
> Array [ "myProperty", "mySecondProperty" ]
इससे आपको ऑब्जेक्ट बटन, वैल्यू या की-वैल्यू पेयर को दोहराना डिस्ट्रक्चरिंग असाइनमेंट) उस ऑब्जेक्ट के प्रोटोटाइप के मालिकाना हक वाली प्रॉपर्टी को शामिल किए बिना:
const myPrototype = { "protoProperty" : "Non-enumerable property value." };
const myObject = Object.create( myPrototype, {
myProperty: {
value: "Enumerable property value.",
enumerable: true
}
});
for ( const propKey of Object.keys( myObject ) ) {
console.log( propKey );
}
> "myProperty"
for ( const propValue of Object.values( myObject ) ) {
console.log( propValue );
}
> "Enumerable property value."
for ( const [ propKey, propValue ] of Object.entries( myObject ) ) {
console.log( `${ propKey } : ${ propValue }` );
}
> "myProperty : Enumerable property value."
forEach()
Array से मिले forEach()
तरीके,
मैप, सेट करें,
और NodeList कंस्ट्रक्टर की मदद से, डेटा पर फिर से काम करने के लिए एक उपयोगी शॉर्टहैंड की जानकारी दी जाती है
एक कॉलबैक फ़ंक्शन के संदर्भ में व्यवस्थित कर सकते हैं. लूप के अन्य प्रकारों से अलग,
किसी भी forEach()
विधि से बनाए गए लूप को break
का उपयोग करके रोका नहीं जा सकता या
continue
.
forEach
एक ऐसा तरीका है जिसका मालिकाना हक हर डेटा स्ट्रक्चर के प्रोटोटाइप के पास होता है. हर forEach
विधि को तर्क के रूप में कॉलबैक फ़ंक्शन की उम्मीद करता है, हालांकि वे
उस फ़ंक्शन को कॉल करते समय शामिल किए गए आर्ग्युमेंट के शब्द. दूसरा, ज़रूरी नहीं
आर्ग्युमेंट, this
वैल्यू तय करता है, ताकि इसका इस्तेमाल शुरू करने के लिए कॉन्टेक्स्ट के तौर पर किया जा सके
कॉलबैक फ़ंक्शन.
Array.forEach
के साथ इस्तेमाल किया जाने वाला कॉलबैक फ़ंक्शन, ऐसे पैरामीटर उपलब्ध कराता है जिनमें ये शामिल हों
मौजूदा एलिमेंट की वैल्यू, मौजूदा एलिमेंट का इंडेक्स, और वह अरे जिस पर forEach
तरीके को शुरू किया गया था:
const myArray = [ true, false ];
myArray.forEach( ( myElement, i, originalArray ) => {
console.log( i, myElement, originalArray );
});
> 0 true Array(3) [ true, false ]
> 1 false Array(3) [ true, false ]
Map.forEach
के साथ इस्तेमाल किया जाने वाला कॉलबैक फ़ंक्शन, ऐसे पैरामीटर देता है जिनमें
मौजूदा एलिमेंट से जुड़ी वैल्यू, जो मौजूदा एलिमेंट से जुड़ी कुंजी है
एलिमेंट जोड़ा है और मैप forEach
तरीका शुरू किया गया है:
const myMap = new Map([
['myKey', true],
['mySecondKey', false ],
]);
myMap.forEach( ( myValue, myKey, originalMap ) => {
console.log( myValue, myKey, originalMap );
});
> true "myKey" Map { myKey → true, mySecondKey → false }
> false "mySecondKey" Map { myKey → true, mySecondKey → false }
Set.forEach
कॉलबैक में मिलते-जुलते पैरामीटर शामिल होते हैं. क्योंकि सेट में यह शामिल नहीं है
इंडेक्स या कुंजियों से अलग है, तो दूसरा आर्ग्युमेंट
अनावश्यक, अनदेखा करने योग्य मान, सख्ती से सिंटैक्स को
अन्य forEach
तरीके.
const mySet = new Set([ true, false ]);
mySet.forEach( ( myValue, myKey, originalSet ) => {
console.log( myValue, myKey, originalSet );
});
> true true Set [ true, false ]
> false false Set [ true, false ]
इटरेटर
इटर किए जा सकने वाले अलग-अलग एलिमेंट से बना ऐसा डेटा स्ट्रक्चर होता है जिसे
ऊपर बताए गए तरीकों का इस्तेमाल करके बार-बार दोहराया जाएगा. इटरेटर,
इटरेबल ऑब्जेक्ट जो इटरेटर प्रोटोकॉल के मुताबिक काम करता है. इसका मतलब है कि उसे लागू करना होगा
एक next()
तरीका, जो उन एलिमेंट के ज़रिए आगे बढ़ता है जिनमें एक बार में एक तरीका होता है.
हर बार उस तरीके को कॉल करने पर, हर क्रम के लिए एक ऑब्जेक्ट लौटाता है
एक खास फ़ॉर्मैट में होना चाहिए.
JavaScript के बिल्ट-इन इटरेबल डेटा स्ट्रक्चर (जैसे कि
कलेक्शन,
Maps और
सेट) हैं और
लेकिन वे सभी एक iterator
विधि इनहेरिट करते हैं, जिसे
@@iterator
सुनाना निशान,
जो बार-बार इस्तेमाल होने वाले डेटा स्ट्रक्चर से बना इटरेटर ऑब्जेक्ट दिखाता है:
const myIterable = [ 1, 2, 3 ];
const myIterator = myIterable[ Symbol.iterator ]();
myIterable;
> (3) [1, 2, 3]
myIterator;
> Array Iterator {}
इटरेटर पर next()
तरीके को कॉल करने के चरण इसके एलिमेंट के ज़रिए होते हैं
में एक बार में एक होता है, जिसमें प्रत्येक कॉल के लिए एक ऑब्जेक्ट होता है, जिसमें दो होते हैं
प्रॉपर्टी: value
, जिसमें मौजूदा एलिमेंट की वैल्यू होती है और
done
एक बूलियन है, जो हमें यह बताता है कि इटरेटर ने आखिरी एलिमेंट को पास किया है या नहीं
इस्तेमाल किया जा सकता है. next()
पर कॉल करने पर ही done
की वैल्यू true
होती है
में अंतिम तत्व के अलावा किसी तत्व तक पहुंचने का प्रयास करता है,
इटरेटर.
const myIterable = [ 1, 2, 3 ];
const myIterator = myIterable[ Symbol.iterator ]();
myIterator.next();
> Object { value: 1, done: false }
myIterator.next();
> Object { value: 2, done: false }
myIterator.next();
> Object { value: 3, done: false }
myIterator.next();
> Object { value: undefined, done: true }
जनरेटर के फ़ंक्शन
जनरेटर का एलान करने के लिए, function*
कीवर्ड (तारे के निशान पर ध्यान दें) का इस्तेमाल करें
फ़ंक्शन फ़ंक्शन का इस्तेमाल करें या जनरेटर फ़ंक्शन एक्सप्रेशन के बारे में बताएं:
function* myGeneratorFunction() { };
इटरेटर की तरह, जनरेटर फ़ंक्शन भी स्टेट को बनाए रखते हैं. किसी जनरेटर फ़ंक्शन नया जनरेटर ऑब्जेक्ट दिखाता है, लेकिन तुरंत नहीं करता फ़ंक्शन के मुख्य भाग में कोड चलाएं:
function* myGeneratorFunction() {
console.log( "Generator function body ")
};
const myGeneratorObject = myGeneratorFunction();
myGeneratorObject;
> Generator { }
typeof myGeneratorObject;
> "object"
जनरेटर ऑब्जेक्ट, इटरेटर प्रोटोकॉल का पालन करते हैं. प्रत्येक कॉल का मान
जनरेटर फ़ंक्शन पर next()
फ़ंक्शन, yield
एक्सप्रेशन से तय होता है,
जो जनरेटर फ़ंक्शन के निष्पादन को रोकता है और
एक्सप्रेशन जिसमें yield
कीवर्ड शामिल है. बाद में next()
पर कॉल किया जाता है
अगले yield
एक्सप्रेशन पर रोककर, फ़ंक्शन को चलाना जारी रखें और
इससे जुड़ी वैल्यू दिखाता है.
function* myGeneratorFunction() {
yield "My first yielded value.";
yield "My second yielded value.";
};
const myGeneratorObject = myGeneratorFunction();
myGeneratorObject.next();
> Object { value: "My first yielded value.", done: false }
myGeneratorObject.next();
> Object { value: "My second yielded value.", done: false }
जब yield
का इस्तेमाल करके कोई और वैल्यू न दिए जाने के बाद next()
को कॉल किया जाता है,
return
या throw
(किसी गड़बड़ी की स्थिति में), फ़ंक्शन का बाकी हिस्सा
मुख्य हिस्सा काम करता है और लौटाए गए ऑब्जेक्ट में undefined
का value
और done
है
true
की प्रॉपर्टी:
function* myGeneratorFunction() {
console.log( "Start of the generator function." );
yield "First";
console.log( "Second part of the generator function." );
yield "Second";
console.log( "Third part of the generator function." );
yield "Third";
};
const myGeneratorObject = myGeneratorFunction();
myGeneratorObject.next();
> "Start of the generator function."
> Object { value: "First", done: false }
myGeneratorObject.next();
> "Second part of the generator function."
> Object { value: "Second", done: false }
myGeneratorObject.next();
> "Third part of the generator function."
> Object { value: "Third", done: false }
myGeneratorObject.next();
> Object { value: undefined, done: true }
next()
का इस्तेमाल सिर्फ़ उस ऑब्जेक्ट पर करें जिसे जनरेटर फ़ंक्शन दिखाता है, न कि
जनरेटर फ़ंक्शन का इस्तेमाल करता है. ऐसा नहीं करने पर, जनरेटर फ़ंक्शन को किया जाने वाला हर कॉल
एक नया जनरेटर ऑब्जेक्ट बनाता है:
function* myGeneratorFunction() {
yield "First";
yield "Second";
};
myGeneratorFunction().next();
> Object { value: "First", done: false }
myGeneratorFunction().next();
> Object { value: "First", done: false }
किसी दूसरे फ़ंक्शन की तरह, जनरेटर फ़ंक्शन return
से मिलने पर रुक जाता है
कीवर्ड. इसके बाद यह आने वाले संदर्भ में एक ऑब्जेक्ट दिखाता है, जिसमें
true
वैल्यू के साथ, वैल्यू और done
प्रॉपर्टी मिली.
function* myGeneratorFunction() {
yield 1;
yield 2;
return 3;
};
const myGeneratorObject = myGeneratorFunction();
myGeneratorObject.next().done;
> Object { value: 1, done: false }
myGeneratorObject.next().done;
> Object { value: 2, done: false }
myGeneratorObject.next();
> Object { value: 3, done: true }
yield
एक्सप्रेशन, किसी आइडेंटिफ़ायर के कुछ सिमेंटिक को अपना सकता है,
इसमें दो-तरफ़ा "कम्यूनिकेशन" की अनुमति नहीं है निलंबन वाले हिस्से से
जनरेटर फ़ंक्शन. जब जनरेटर के next()
तरीके को वैल्यू को इस तरह पास किया जाता है
है, तो यह पिछले, निलंबित की गई वैल्यू को बदल देता है
yield
एक्सप्रेशन:
function* myGeneratorFunction() {
const firstYield = yield;
yield firstYield + 10;
};
const myGeneratorObject = myGeneratorFunction();
myGeneratorObject.next();
> Object { value: undefined, done: false }
myGeneratorObject.next( 5 );
> Object { value: 15, done: false }
ध्यान रखें कि यह
पिछला yield
, और न सिर्फ़ पिछले yield
का मान फिर से असाइन करता है, बल्कि
next()
में दी गई वैल्यू:
function* myGeneratorFunction() {
const firstYield = yield;
const secondYield = yield firstYield + 100;
yield secondYield + 10;
};
const myGeneratorObject = myGeneratorFunction();
myGeneratorObject.next();
> Object { value: undefined, done: false }
myGeneratorObject.next( 10 ); // Can be thought of as changing the value of the `firstYield` variable to `10
> Object { value: 110, done: false }
myGeneratorObject.next( 20 ); // Can be thought of as changing the value of the `secondYield` variable to `20`, _not_ `20 + 100;`
> Object { value: 30, done: false }
next()
को किए गए पहले कॉल में पास किए गए किसी भी तर्क को अनदेखा कर दिया जाता है, क्योंकि
उस वैल्यू को स्वीकार करने के लिए, पिछले yield
एक्सप्रेशन का इस्तेमाल करें. किसी भी अन्य फ़ंक्शन की तरह,
शुरुआती जनरेटर फ़ंक्शन कॉल में दिए गए तर्क पूरे
जनरेटर फ़ंक्शन के मुख्य भाग का स्कोप:
function* myGeneratorFunction( startingValue ) {
let newValue = yield startingValue + 1;
newValue = yield newValue + 10;
yield startingValue + 20;
};
const myGeneratorObject = myGeneratorFunction( 2 );
myGeneratorObject.next( 1 );
> Object { value: 3, done: false }
myGeneratorObject.next( 5 );
> Object { value: 15, done: false }
myGeneratorObject.next( 10 );
Object { value: 22, done: false }
yield*
(तारे का निशान ध्यान दें) ऑपरेटर का इस्तेमाल बार-बार दोहराए जाने वाले के साथ किया जाता है, जैसे
यह एक अन्य जनरेटर फ़ंक्शन होता है, जो हर वैल्यू को उसके ऑपरेंड के तौर पर फिर से जनरेट करता है
वापसी:
function* mySecondaryGenerator() {
yield 2;
yield 3;
}
function* myGenerator() {
yield 1;
yield* mySecondaryGenerator();
yield 4;
return 5;
}
const myIterator = myGenerator();
myIterator.next();
> Object { value: 1, done: false }
myIterator.next();
> Object { value: 2, done: false }
myIterator.next();
> Object { value: 3, done: false }
myIterator.next();
> Object { value: 4, done: false }
myIterator.next();
> Object { value: 5, done: true }
एसिंक्रोनस JavaScript
हालांकि, JavaScript बुनियादी रूप से सिंक्रोनस होता है ऐसी प्रोसेस भी हैं जिनकी मदद से डेवलपर परफ़ॉर्म करने के लिए इवेंट लूप एसिंक्रोनस टास्क पर जाएं.
वादे
प्रॉमिस ऐसी वैल्यू के लिए प्लेसहोल्डर होता है जिसकी जानकारी नहीं होती कि प्रॉमिस कब है बनाया गया. यह एक कंटेनर है, जो एसिंक्रोनस ऑपरेशन को अंजाम देता है. जिसमें कार्रवाई को सफल या असफल माना जाता है, तो की जाने वाली कार्रवाइयां दोनों ही मामलों में, और उसके नतीजे के तौर पर मिलने वाली वैल्यू.
पहले से मौजूद Promise
के साथ new
ऑपरेटर का इस्तेमाल करके, Promise इंस्टेंस बनाएं
कंस्ट्रक्टर फ़ंक्शन का इस्तेमाल करना होगा. यह कंस्ट्रक्टर, एक्ज़ीक्यूटिव नाम के फ़ंक्शन को स्वीकार करता है
का इस्तेमाल करें. उस एक्ज़िकेटर फ़ंक्शन का इस्तेमाल आम तौर पर एक या उससे ज़्यादा परफ़ॉर्म करने के लिए किया जाता है
साथ ही, एसिंक्रोनस ऐक्शन का इस्तेमाल करके वे शर्तें तय करें जिनके हिसाब से प्रॉमिस को तय किया जाना चाहिए
पूरा या अस्वीकार किया गया. प्रॉमिस का मतलब मंज़ूरी बाकी है से है
जब एक्ज़ीक्यूटर फ़ंक्शन चल रहा हो. वफ़ादारी का काम पूरा होने के बाद, प्रॉमिस
दस्तावेज़ के कुछ सोर्स में, उसे पूरा किया गया या समाधान किया गया माना जाता है, अगर
एक्ज़िकेटर फ़ंक्शन और इसके एसिंक्रोनस ऐक्शन को पूरा किया गया
और मैनेजर फ़ंक्शन में कोई गड़बड़ी होने पर अस्वीकार कर दिया जाता है या
की जा रही एसिंक्रोनस कार्रवाई विफल हो जाती है. प्रॉमिस पूरा होने के बाद या
अस्वीकार कर दिया जाता है, तो इसे सेट किया गया माना जाता है.
const myPromise = new Promise( () => { });
कंस्ट्रक्टर, दो आर्ग्युमेंट के साथ एक्ज़ीक्यूटर फ़ंक्शन को कॉल करता है. वे आर्ग्युमेंट ऐसे फ़ंक्शन हैं जिनकी मदद से, प्रॉमिस को मैन्युअल तरीके से पूरा या अस्वीकार किया जा सकता है:
const myPromise = new Promise( ( fulfill, reject ) => { });
प्रॉमिस को पूरा या अस्वीकार करने के लिए इस्तेमाल किए जाने वाले फ़ंक्शन, आर्ग्युमेंट के तौर पर Promise की वैल्यू (आम तौर पर, अस्वीकार किए जाने की गड़बड़ी होती है):
const myPromise = new Promise( ( fulfill, reject ) => {
const myResult = true;
setTimeout(() => {
if( myResult === true ) {
fulfill( "This Promise was successful." );
} else {
reject( new Error( "This Promise has been rejected." ) );
}
}, 10000);
});
myPromise;
> Promise { <state>: "pending" }
myPromise;
> Promise { <state>: "fulfilled", <value>: "This Promise was successful." }
प्रॉमिस चेनिंग
नतीजे के तौर पर मिलने वाले प्रॉमिस ऑब्जेक्ट पर then()
, catch()
, और
finally()
तरीके Promise कंस्ट्रक्टर से इनहेरिट किए गए हैं. इनमें से सभी
वाले तरीके से प्रॉमिस प्रॉमिस मिलता है, जिस पर then()
की मदद से तुरंत कार्रवाई की जा सकती है,
catch()
या finally()
फिर से, आपको नतीजे वाले प्रॉमिस को चेन करने की सुविधा देता है.
then()
, आर्ग्युमेंट के तौर पर दो कॉलबैक फ़ंक्शन देता है. कार्रवाई पूरी करने के लिए, पहली क्वेरी का इस्तेमाल करें
और दूसरे प्रॉमिस को अस्वीकार कर दिया जाता है. दोनों विधियां सिर्फ़ एक
ऐसा आर्ग्युमेंट जो नतीजे के तौर पर, अपनी वैल्यू का वादा करता है.
const myPromise = new Promise( ( fulfill, reject ) => {
const myResult = true;
setTimeout(() => {
if( myResult === true ) {
fulfill( "This Promise was fulfilled." );
} else {
reject( new Error( "This Promise has been rejected." ) );
}
}, 100);
});
myPromise.then( successfulResult => console.log( successfulResult ), failedResult => console.error( failedResult ) );
> "This Promise was successful."
सिर्फ़ डिलीवर की गई स्थिति को मैनेज करने के लिए, then()
का और catch
का इस्तेमाल करके
अस्वीकार की गई स्थिति को संभालता है. catch
को एक तर्क के साथ कॉल करें, जिसमें
प्रॉमिस अस्वीकार करने के तरीके में दी गई वैल्यू:
const myPromise = new Promise( ( fulfill, reject ) => {
const myResult = false;
setTimeout(() => {
if( myResult === true ) {
fulfill( "This Promise was fulfilled." );
} else {
reject( new Error( "This Promise has been rejected." ) );
}
}, 100);
});
myPromise
.then( fulfilledResult => console.log(fulfilledResult ) )
.catch( rejectedResult => console.log( rejectedResult ) )
.finally( () => console.log( "The Promise has settled." ) );
> "Error: This Promise has been rejected."
> "The Promise has settled."
then
और catch
के उलट, जो प्रॉमिस के समय हैंडलर फ़ंक्शन को चलाने की अनुमति देते हैं
पूरा या अस्वीकार किया जाता है, फ़ंक्शन को finally
में तर्क के रूप में दिया जाता है
का तरीका इस्तेमाल किया जाता है, चाहे प्रॉमिस पूरा हुआ हो या अस्वीकार किया गया हो.
हैंडलर फ़ंक्शन को बिना किसी आर्ग्युमेंट के कॉल किया जाता है, क्योंकि इसका मकसद
प्रॉमिस से पास की गई वैल्यू के साथ काम करता है, तो सिर्फ़
वादा पूरा हो गया.
एक साथ कई काम करना
Promise कंस्ट्रक्टर, एक से ज़्यादा संबंधित प्रॉपर्टी के साथ काम करने के लिए चार तरीके देता है
प्रॉमिस ऑब्जेक्ट ऐसी इटरेबल का इस्तेमाल करके प्रॉमिस करता है जिसमें प्रॉमिस ऑब्जेक्ट शामिल हैं. ये
जिन तरीकों से हर बार प्रॉमिस प्रॉमिस किया जाता है उसे राज्य के हिसाब से पूरा या अस्वीकार किया जाता है
को पास किए गए वादों के बारे में बताना चाहिए. उदाहरण के लिए, Promise.all()
एक प्रॉमिस बनाता है
जिसे सिर्फ़ तब पूरा किया जाता है, जब उस तरीके में दिया गया हर प्रॉमिस पूरा हो:
const firstPromise = new Promise( ( fulfill, reject ) => fulfill( "Successful. ") );
const secondPromise = new Promise( ( fulfill, reject ) => fulfill( "Successful. ") );
const thirdPromise = new Promise( ( fulfill, reject ) => fulfill( "Successful. ") );
const failedPromise = new Promise( ( fulfill, reject ) => reject( "Failed.") );
const successfulPromises = [ firstPromise, secondPromise, thirdPromise ];
const oneFailedPromise = [ failedPromise, ...successfulPromises ];
Promise.all( successfulPromises )
.then( ( allValues ) => {
console.log( allValues );
})
.catch( ( failValue ) => {
console.error( failValue );
});
> Array(3) [ "Successful. ", "Successful. ", "Successful. " ]
Promise.all( oneFailedPromise )
.then( ( allValues ) => {
console.log( allValues );
})
.catch( ( failValue ) => {
console.error( failValue );
});
> "Failed."
प्रॉमिस कॉनमुद्रा का इस्तेमाल करने के तरीके यहां दिए गए हैं:
Promise.all()
- सिर्फ़ तब पूरा किया जाएगा, जब बताए गए सभी प्रॉमिस पूरे हो जाएं.
Promise.any()
- दिए गए वादों में से कोई एक पूरा होने और सिर्फ़ अस्वीकार किए जाने पर ही पूरा किया जाएगा अगर सभी प्रॉमिस अस्वीकार कर दिए जाते हैं.
Promise.allSettled()
- वादों का निपटारा हो जाने पर उन्हें पूरा किया जाता है, भले ही उनका नतीजा कुछ भी हो.
Promise.race()
- सेटलमेंट के पहले वाद के नतीजे के आधार पर अस्वीकार या पूरा किया गया, बाद में निपटाए गए सभी वादों को अनदेखा करना.
async
/await
जब फ़ंक्शन के बारे में एलान से पहले async
कीवर्ड का इस्तेमाल किया जाता है
या फ़ंक्शन एक्सप्रेशन, कोई भी
वह वैल्यू जिसे फ़ंक्शन रिटर्न करता है
वैल्यू. इसका इस्तेमाल करके, एसिंक्रोनस प्रोसेस को चलाने और मैनेज करने के लिए,
वर्कफ़्लो को सिंक्रोनस डेवलपमेंट के तौर पर इस्तेमाल किया जाता है.
async function myFunction() {
return "This is my returned value.";
}
myFunction().then( myReturnedValue => console.log( myReturnedValue ) );
> "This is my returned value."
await
एक्सप्रेशन, एसिंक्रोनस फ़ंक्शन को चलाने से रोकता है
इससे जुड़े प्रॉमिस का समाधान हो जाता है. प्रॉमिस रिज़ॉल्व होने पर,
await
एक्सप्रेशन, प्रॉमिस की पूरी या अस्वीकार की गई वैल्यू है.
async function myFunction() {
const myPromise = new Promise( ( fulfill, reject ) => { setTimeout( () => fulfill( "Successful. "), 5000 ); });
const myPromisedResult = await myPromise;
return myPromisedResult;
}
myFunction()
.then( myResult => console.log( myResult ) )
.catch( myFailedResult => console.error( myFailedResult ) );
> "Successful."
await
एक्सप्रेशन में शामिल कोई भी नॉन-प्रॉमिस वैल्यू
पूरा किया गया वादा:
async function myFunction() {
const myPromisedResult = await "String value.";
return myPromisedResult;
}
myFunction()
.then( myResult => console.log( myResult ) )
.catch( myFailedResult => console.error( myFailedResult ) );
> "String value."
देखें कि आपको कितना समझ आया है
किसी जानी-पहचानी संख्या को दोहराने के लिए, किस तरह के लूप का इस्तेमाल किया जाता है?
for
do...while
while