जावास्क्रिप्ट 'प्रतीक्षा' वास्तव में इंतजार कब करता है?

Question

मैं this article पढ़ रहा था, और सोच रहा था कि क्यों पहले स्निपेट में दूसरा wait() पहले wait() को समाप्त करने के लिए इंतजार कर रहा है जबकि दूसरे स्निपेट में दो wait() एसिंक चलाते हैं?

async function series() { 
    await wait(500); 
    await wait(500); 
    return "done!"; 
} 

async function parallel() { 
    const wait1 = wait(500); 
    const wait2 = wait(500); 
    await wait1; 
    await wait2; 
    return "done!"; 
} 

function wait(ms) { 
    return new Promise(r => setTimeout(r, ms)); 
} 

Answer 1

अपना पहला समारोह में:

async function series() { 
    await wait(500); // 1 
    await wait(500); // 2 
    return "done!"; 
} 

आप जैसे ही यह शुरू कर दिया है पहले wait का इंतजार करने के लिए जे एस बता रहे हैं।
इसका मतलब यह है दूसरा wait(500) शुरू नहीं कर सकते, इससे पहले कि पहले एक खत्म:

1. उत्प्रेरक wait(500) // 1
2. कि के लिए प्रतीक्षा पारित करने के लिए
3. उत्प्रेरक wait(500) // 2
4. इंतजार है कि

पारित करने के लिए

दूसरे समारोह में:

async function parallel() { 
    const wait1 = wait(500); // 1 
    const wait2 = wait(500); // 2 
    await wait1; 
    await wait2; 
    return "done!"; 
} 

दोनों wait कॉल शुरू कर दिया, इससे पहले कि कोड परिणामों का इंतजार करने के लिए कहा जाता है।

1. उत्प्रेरक wait(500) // 1
2. उत्प्रेरक wait(500) // 2
3. wait1 पारित करने के लिए प्रतीक्षा करें,
4. के लिए wait2 पारित करने के लिए

क्योंकि wait1 और wait2 एक दूसरे के बाद तुरंत ट्रिगर कर रहे हैं इंतजार, वे कर रहे हैं व्यावहारिक रूप से समानांतर में चल रहा है।

इस कल्पना कीजिए:

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

Answer 2

यह एसिंक कार्यों पर निर्भर करता है यदि दो कार्य निर्भर हैं तो हमें उन्हें निष्पादित करना होगा। अर्थात। पूरा करने के लिए पहले कार्य की प्रतीक्षा करें; पहली चीज में पहली चीज हो रही है, यही कारण है कि इसे पूरा करने में लगभग 1000ms लगते हैं।

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

यह सी # async-await तंत्र के समान है। संदर्भ के लिए कृपया Asynchronous Programming with async and await