Promise, async/await

நீங்கள் ஒரு பிரபலமான புத்தக எழுத்தாளர் என்று கற்பனை செய்து பாருங்கள், ஒரு குறிப்பிட்ட நாளில் ஒரு புதிய புத்தகத்தை வெளியிட திட்டமிட்டுள்ளீர்கள். இந்தப் புத்தகத்தில் ஆர்வம் கொண்ட வாசகர்கள் இந்தப் புத்தகத்தை தங்கள் விருப்பப்பட்டியலில் (wishlist) சேர்த்துக்கொள்கிறார்கள் மற்றும் வெளியிடப்படும் போது அல்லது வெளியீட்டு நாள் ஒத்திவைக்கப்பட்டாலும் கூட அவர்களுக்கு அறிவிக்கப்படும். வெளியீட்டு நாளில், அனைவருக்கும் அறிவிக்கப்படும் மற்றும் புத்தகத்தை வாங்கலாம், இது அனைத்து தரப்பினரையும் மகிழ்விக்கிறது. இது நிரலாக்கத்தில் நடக்கும் நிஜ வாழ்க்கை ஒப்புமையாகும் (analogy).

1. ஒரு "தயாரிக்கும் குறியீடு (producing code)" என்பது நேரம் எடுக்கும் மற்றும் ஏதோ ஒன்றை சாதிக்கும் ஒன்று. இங்கே இது ஒரு புத்தக எழுத்தாளர்.
2. ஒரு "பயன்படுத்தும் குறியீடு (consuming code)" என்பது தயாரிக்கும் குறியீடு தயாரானதும் அதைப் பயன்படுத்தும் ஒன்று. இந்த வழக்கில், இது ஒரு "வாசகர் (reader)".
3. "தயாரிக்கும் குறியீடு" மற்றும் "பயன்படுத்தும் குறியீடு" ஆகியவற்றிற்கு இடையேயான தொடர்பை ஒரு promise என்று அழைக்கலாம், ஏனெனில் இது "தயாரிக்கும் குறியீட்டிலிருந்து" முடிவுகளை "பயன்படுத்தும் குறியீட்டிற்கு" பெறுவதை உறுதி செய்கிறது.

Promise

நாம் செய்த ஒப்புமை ஜாவாஸ்கிரிப்ட் promise பொருளுக்கும் பொருந்தும். promise பொருளுக்கான கன்ஸ்ட்ரக்டர் (constructor) தொடரியல்:

let promise = new Promise(function(resolve, reject) {
  // executor (தயாரிக்கும் குறியீடு, "எழுத்தாளர்")
});

இங்கே, ஒரு செயல்பாடு new Promise க்கு அனுப்பப்படுகிறது, இது executor என்றும் அழைக்கப்படுகிறது, மேலும் இது உருவாக்கப்பட்டவுடன் தானாகவே இயங்குகிறது. இது முடிவைக் கொடுக்கும் தயாரிக்கும் குறியீட்டைக் கொண்டுள்ளது. resolve மற்றும் reject ஆகியவை ஜாவாஸ்கிரிப்ட் தானாகவே வழங்கும் வாதங்கள் (arguments) மற்றும் முடிவுகள் வந்ததும் இவற்றில் ஒன்று அழைக்கப்படும்.

• resolve(value): முடிவு வந்தவுடன் value ஐத் திரும்பப் பெறும் ஒரு பின்கூப்பிடல் செயல்பாடு (callback function)
• reject(error): பிழை (error) ஏற்பட்டால் error ஐத் திரும்பப் பெறும் ஒரு பின்கூப்பிடல் செயல்பாடு, இது ஒரு பிழைப் பொருளைத் (error object) திரும்பப் பெறுகிறது

new Promise கன்ஸ்ட்ரக்டரால் திரும்பப் பெறப்பட்ட promise பொருளின் உள் பண்புகள் (internal properties) பின்வருமாறு:

• state - ஆரம்பத்தில் pending (நிலுவையில் உள்ளது), பின்னர் resolve செய்யும் போது fulfill (நிறைவேற்றப்பட்டது) அல்லது reject அழைக்கப்படும் போது rejected (நிராகரிக்கப்பட்டது) என்று மாறும்
• result - ஆரம்பத்தில் undefined, பின்னர் resolve செய்யும் போது value ஆக அல்லது reject அழைக்கப்படும் போது error ஆக மாறும்

ஒரு promise இன் எடுத்துக்காட்டு.

let promiseOne = new Promise(function(resolve, reject) {
  // promise கட்டமைக்கப்படும் போது செயல்பாடு தானாகவே செயல்படுத்தப்படும்

  // 1-வினாடிக்குப் பிறகு "done" என்ற முடிவோடு வேலை முடிந்துவிட்டது என்பதற்கான சமிக்ஞை
  setTimeout(() => resolve("done"), 1000);
})

let promiseTwo = new Promise(function(resolve, reject) {
  // promise கட்டமைக்கப்படும் போது செயல்பாடு தானாகவே செயல்படுத்தப்படும்

  // 1-வினாடிக்குப் பிறகு "error" என்ற முடிவோடு வேலை முடிந்துவிட்டது என்பதற்கான சமிக்ஞை
  setTimeout(() => reject(new Error("Whoops!")), 1000);
})

இங்கே, promiseOne என்பது "நிறைவேற்றப்பட்ட promise க்கான (fulfilled promise)" ஒரு எடுத்துக்காட்டாகும், ஏனெனில் அது மதிப்புகளை வெற்றிகரமாகத் தீர்க்கிறது, அதேசமயம் promiseTwo நிராகரிக்கப்படுவதால் அது ஒரு "நிராகரிக்கப்பட்ட promise (rejected promise)" ஆகும். ஆரம்பத்தில் நிலுவையில் (pending) உள்ள promise க்கு மாறாக, நிராகரிக்கப்படாத அல்லது தீர்க்கப்படாத ஒரு promise செட்டில் (settled) promise என்று அழைக்கப்படுகிறது. promise இலிருந்து பயன்படுத்தும் செயல்பாட்டை (Consuming function) .then மற்றும் .catch முறைகளைப் பயன்படுத்தி பதிவு செய்யலாம். முந்தைய முறைகள் நிறைவடைந்த பிறகு தூய்மைப்படுத்தல் (cleanup) அல்லது இறுதி செய்வதற்கு (finalizing) நாம் .finally முறையையும் சேர்க்கலாம்.

let promiseOne = new Promise(function(resolve, reject) {
  setTimeout(() => resolve("done!"), 1000);
});

// resolve ஆனது .then இல் உள்ள முதல் செயல்பாட்டை இயக்குகிறது
promiseOne.then(
  result => alert(result), // 1 விநாடிக்கு பிறகு "done!" ஐக் காட்டுகிறது
  error => alert(error) // இயங்காது
);

let promiseTwo = new Promise(function(resolve, reject) {
  setTimeout(() => reject(new Error("Whoops!")), 1000);
});

// reject ஆனது .then இல் உள்ள இரண்டாவது செயல்பாட்டை இயக்குகிறது
promiseTwo.then(
  result => alert(result), // இயங்காது
  error => alert(error) // 1 விநாடிக்கு பிறகு "Error: Whoops!" ஐக் காட்டுகிறது
);

let promiseThree = new Promise((resolve, reject) => {
  setTimeout(() => reject(new Error("Whoops!")), 1000);
});

// .catch(f) என்பது promise.then(null, f) ஐப் போன்றதே
promiseThree.catch(alert); // 1 விநாடிக்கு பிறகு "Error: Whoops!" ஐக் காட்டுகிறது