Google I/O से जुड़े रहने के लिए धन्यवाद! मांग पर वीडियो देखें.

इस पेज का अनुवाद Cloud Translation API से किया गया है.

कंट्रोल फ़्लो

कंट्रोल फ़्लो वह क्रम होता है जिसमें 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

while

do...while