परिचय

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

थ्रेड को फ़्रीज़ किए बिना इन एसिंक कार्यों को संभालने के लिए, हमें प्रॉमिस—एक शक्तिशाली उपकरण मिलता है जो एसिंक्रोनस प्रोग्रामिंग को सरल बनाता है। वादों के साथ, आप लंबे समय से चल रहे कार्यों को अधिक प्रभावी ढंग से प्रबंधित कर सकते हैं, साफ-सुथरा, अधिक पठनीय कोड लिख सकते हैं, और खतरनाक "कॉलबैक नरक से बच सकते हैं। "

इस लेख में, मेरा लक्ष्य आपको यह परिचित कराना है कि वादे क्या हैं, वे कैसे काम करते हैं, और कैसे वे अतुल्यकालिक प्रोग्रामिंग को सरल बनाते हैं।

एक वादा क्या है?

कल्पना करें कि आप किसी रेस्तरां में भोजन का ऑर्डर दे रहे हैं। एक बार जब आप अपना ऑर्डर दे देते हैं, तो आपको अपना भोजन तैयार होने के लिए रसोई में इंतजार नहीं करना पड़ता है। इसके बजाय, आप अपनी बातचीत जारी रखते हैं या उस माहौल का आनंद लेते हैं जब पृष्ठभूमि में रसोई आपका भोजन तैयार कर रही होती है। रेस्तरां खाना तैयार होने पर आपको परोसने का वादा करता है। आप इस वादे पर भरोसा कर सकते हैं क्योंकि, अंततः, दो चीजों में से एक होगी: या तो आपका भोजन आ जाएगा (पूरा हो गया), या रसोई आपको सूचित कर देगी कि वे ऑर्डर पूरा नहीं कर सकते (अस्वीकृत) ).

जावास्क्रिप्ट में, वादे एक समान तरीके से काम करते हैं। जब आप जावास्क्रिप्ट से कुछ ऐसा करने के लिए कहते हैं जिसमें समय लगता है—जैसे सर्वर से डेटा प्राप्त करना—तो यह एक वादा लौटाता है। यह वादा आपको तुरंत परिणाम नहीं देता है। इसके बजाय, यह आपको बताता है, "जब काम पूरा हो जाएगा तो मैं आपसे संपर्क करूंगा।" उस दौरान, आपका बाकी कोड चलता रहेगा। एक बार कार्य पूरा हो जाने पर, वादा या तो है:

• पूर्ण (कार्य सफल हुआ), या
• अस्वीकृत (कार्य विफल हुआ), और आप तदनुसार परिणाम संभाल सकते हैं।

जावास्क्रिप्ट में वादे कैसे काम करते हैं

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

• लंबित: कार्य अभी भी प्रगति पर है, और अंतिम परिणाम (पूर्ण या अस्वीकृत) अभी तक निर्धारित नहीं है।
• पूर्ण: कार्य सफलतापूर्वक पूरा हुआ, और परिणाम उपलब्ध है।
• अस्वीकृत: कार्य विफल रहा, और एक त्रुटि को संभालने के लिए उपलब्ध है

1. एक वादा बनाना

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

const myPromise = new Promise((resolve, reject) => {
  // Simulating an asynchronous task (e.g., fetching data)
  const success = true; // Simulate success or failure

  if (success) {
    resolve("Operation completed successfully!"); // Fulfill the promise
  } else {
    reject("Operation failed."); // Reject the promise
  }
});

2. वादों को सुलझाना और अस्वीकार करना

एक बार वादा बन जाने के बाद, आप संकल्प या अस्वीकार पर कॉल करके इसका परिणाम तय कर सकते हैं:

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

3. वादों का उपभोग करना

एक बार जब आप एक वादा बना लेते हैं, तो अगला कदम इसका उपभोग करना होता है। वादों के परिणामों को संभालने के लिए जावास्क्रिप्ट कई तरीके प्रदान करता है: .then(), .catch(), और .finally()। इनमें से प्रत्येक विधि एक विशिष्ट उद्देश्य को पूरा करती है और आपको अतुल्यकालिक संचालन के परिणामों को प्रभावी ढंग से प्रबंधित करने की अनुमति देती है।

• समाधान किए गए वादों को .then() के साथ संभालना: .then() विधि का उपयोग यह निर्दिष्ट करने के लिए किया जाता है कि जब वादा पूरा हो जाए तो क्या होना चाहिए। इसमें दो वैकल्पिक तर्क लगते हैं: एक हल किए गए मान के लिए कॉलबैक और दूसरा अस्वीकृतियों को संभालने के लिए।

const fetchData = () => {
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve("Data fetched successfully!");
    }, 1000);
  });
};

fetchData()
  .then(result => {
    console.log(result); // Logs: Data fetched successfully!
  });

• .catch() के साथ अस्वीकृतियों को संभालना: .catch() विधि विशेष रूप से Promise के निष्पादन के दौरान होने वाली त्रुटियों को संभालने के लिए डिज़ाइन की गई है। यह इसे अस्वीकृतियों से निपटने का एक साफ़ तरीका बनाता है।

const fetchWithError = () => {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      reject("Error fetching data."); // Simulating an error
    }, 1000);
  });
};

fetchWithError()
  .then(result => {
    console.log(result);
  })
  .catch(error => {
    console.error(error); // Logs: Error fetching data.
  });

• अंतिम या क्लीनअप क्रियाएं .finally() का उपयोग करते हुए: .finally() विधि आपको वादा पूरा होने के बाद कोड निष्पादित करने की अनुमति देती है, भले ही यह पूरा हुआ हो या अस्वीकार किया गया हो। यह सफ़ाई कार्यों या कार्यों के लिए उपयोगी है जिन्हें सफलता और विफलता दोनों परिदृश्यों में चलाया जाना चाहिए।

fetchData()
  .then(result => {
    console.log(result); // Logs: Data fetched successfully!
  })
  .catch(error => {
    console.error(error); // Handle error
  })
  .finally(() => {
    console.log("Promise has settled."); // Logs after either success or failure
  });

संक्षिप्त होने के लिए:

• फिर(): किसी वादे के हल किए गए मूल्य को संभालने के लिए इस विधि का उपयोग करें।
• कैच(): जब कोई वादा अस्वीकार कर दिया जाता है तो त्रुटियों को संभालने के लिए इस विधि का उपयोग करें।
• अंततः(): यह विधि वादे के निपटारे के बाद कोड चलाती है, परिणाम की परवाह किए बिना, सफाई या अंतिम कार्रवाई की अनुमति देती है।

4. वचनबद्धता

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

आइए निम्नलिखित उदाहरण पर एक नज़र डालें:

const fetchUserData = () => {
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve({ userId: 1, username: "JohnDoe" });
    }, 1000);
  });
};

const fetchPosts = (userId) => {
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve(["Post 1", "Post 2", "Post 3"]); // Simulated posts
    }, 1000);
  });
};

// Chaining Promises
fetchUserData()
  .then(user => {
    console.log("User fetched:", user);
    return fetchPosts(user.userId); // Pass userId to the next promise
  })
  .then(posts => {
    console.log("Posts fetched:", posts);
  })
  .catch(error => {
    console.error("Error:", error);
  });

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

निष्कर्ष

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

• अतुल्यकालिक कार्यों के प्रबंधन को सरल बनाएं और कॉलबैक नरक से बचें।
• निष्पादन के स्पष्ट प्रवाह को बनाए रखने के लिए एकाधिक अतुल्यकालिक संचालन को श्रृंखलाबद्ध करें।
• एकीकृत दृष्टिकोण के साथ त्रुटियों को प्रभावी ढंग से संभालें।

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