ప్రధాన కంటెంట్‌కు వెళ్లండి
మాడ్యూల్ 7 · 4లో పాఠం 1కోర్సులో 25/32~12 min
మాడ్యూల్ పాఠాలు (1/4)

వాగ్దానాలు: అవి ఏమిటి

ప్రామిస్ అనేది భవిష్యత్తులో పూర్తి చేయబోయే ఆపరేషన్ ఫలితాన్ని సూచించే విలువ. ఇది మూడు రాష్ట్రాల్లో ఒకదానిలో ఉండవచ్చు:

  • పెండింగ్ — ఆపరేషన్ ఇంకా ప్రోగ్రెస్‌లో ఉంది
  • ** నెరవేరింది** — ఇది విజయవంతంగా ముగిసింది, ఒక విలువ ఉంది
  • తిరస్కరించబడింది — ఇది విఫలమైంది, లోపం ఉంది

పెండింగ్‌లో ఉన్న స్థితిని విడిచిపెట్టిన తర్వాత, అది శాశ్వతంగా "స్థిరపడుతుంది".

పరిష్కరించబడిన వాగ్దానాన్ని సృష్టించడం

రెండు అత్యంత సాధారణ మార్గాలు — మీరు దాదాపుగా కన్స్ట్రక్టర్‌తో "చేతితో" వాగ్దానాన్ని సృష్టించలేరు:

JS
const p1 = Promise.resolve(42);
const p2 = Promise.reject(new Error('oops'));

ఫలితాన్ని చదవడం: .then / .catch

JS
Promise.resolve(10).then((v) => {
  console.log(v); // 10
});

Promise.reject(new Error('no')).catch((e) => {
  console.log(e.message); // 'no'
});

.then పరిష్కరించబడిన విలువతో పిలువబడే ఒక ఫంక్షన్‌ను అందుకుంటుంది. .catch తిరస్కరణ విషయంలో లోపంతో పిలువబడే ఒక ఫంక్షన్‌ను అందుకుంటుంది.

చైనింగ్

ప్రతి .then వాగ్దానాన్ని తిరిగి ఇస్తుంది: మీరు వాటిని మార్చడానికి బంధించవచ్చు దశలవారీగా విలువ.

JS
Promise.resolve(5)
  .then((n) => n * 2)
  .then((n) => n + 1)
  .then((n) => console.log(n)); // 11

.thenలో ఎవరైనా విసిరితే (లేదా విఫలమైన వాగ్దానాన్ని తిరిగి ఇస్తే), అమలు మొదటి తదుపరి .catchకి దూకుతుంది.

కన్స్ట్రక్టర్ (అరుదైన)

JS
const p = new Promise((resolve, reject) => {
  if (Math.random() > 0.5) resolve('ok');
  else reject(new Error('no'));
});

మీరు కాల్‌బ్యాక్‌లను (ఉదా. పాత DOM APIలు లేదా సెట్‌టైమ్‌అవుట్) ఉపయోగించే ఏదైనా "వాగ్దానం" చేయవలసి వచ్చినప్పుడు మాత్రమే మీరు దాన్ని ఉపయోగిస్తారు.

దీనిని ప్రయత్నించండి

వ్యాయామం#js.m7.l1.e1
ప్రయత్నాలు: 0లోడ్ అవుతోంది...

ఒక సంఖ్య ఇచ్చినట్లయితే, n యొక్క రెట్టింపుతో పరిష్కరించబడిన వాగ్దానాన్ని తిరిగి ఇచ్చే `ప్రామిస్డ్ వెర్షన్(n)`ని నిర్వచించండి.

ఎడిటర్ లోడ్ అవుతోంది…
సూచనను చూపించు

రిటర్న్ Promise.resolve(n * 2)

3 ప్రయత్నాల తర్వాత పరిష్కారం లభిస్తుంది

వ్యాయామం సమీక్షించండి

వ్యాయామం#js.m7.l1.e2
ప్రయత్నాలు: 0లోడ్ అవుతోంది...

సంఖ్య యొక్క వాగ్దానాన్ని స్వీకరించి, సంఖ్య + 3 యొక్క వాగ్దానాన్ని అందించే `incrementThree(p)`ని నిర్వచించండి. .తర్వాత గొలుసును ఉపయోగించండి.

ఎడిటర్ లోడ్ అవుతోంది…
సూచనను చూపించు

p.then((n) => n + 3)

3 ప్రయత్నాల తర్వాత పరిష్కారం లభిస్తుంది