async/await ఎలా పనిచేస్తుంది?

Question

Accepted Answer

`async/await` అనేది **Promises మీద సింటాక్స్ సుగర్** ఇది సమకాలీన కోడ్‌లా చదువుకోబడే అసమకాలీన కోడ్‌ను వ్రాయడానికి మిమ్మల్ని అనుమతిస్తుంది. `async` ఫంక్షన్ ఎల్లప్పుడు Promise ను అందిస్తుంది; `await` ఒక Promise సెటిల్ జరిసేవరకు ఫంక్షన్‌ను పాజ్ చేస్తుంది, తర్వాత దాని విలువతో పুനరారంభిస్తుంది.

```js
async function loadUser(id) {
  try {
    const res = await fetch(`/api/users/${id}`); // pause until the response
    const user = await res.json();               // pause until parsed
    return user;                                  // becomes the resolved value
  } catch (err) {
    console.error(err); // catches rejections from any await above
  }
}
```

## సీక్వెన్షియల్ వర్సస్ సమాంతర — సాధారణ పనితీరు తప్పు

`await` విషయాలను **ఒకటి తరువాత ఒకటిగా** అమలు చేస్తుంది. రెండు అభ్యర్థనలు ఒకదానిపై ఆధారపడకపోతే, వాటి కోసం ఎదురుచూస్తున్న సీక్వెన్స్ నిరర్థకంగా నెమ్మదిగా ఉంటుంది:

```js
// ❌ sequential — total time = a + b
const a = await getA();
const b = await getB();

// ✅ parallel — total time = max(a, b)
const [a, b] = await Promise.all([getA(), getB()]);
```

## లోపం నిర్వహణ

`.catch` కు బదులుగా `try/catch` ని ఉపయోగించండి. తిరస్కరించిన ఎదురు చూస్తున్న Promise విసిరిపోతుంది, కాబట్టి ఒక `catch` మొత్తం బ్లాక్‌ను కవర్ చేస్తుంది.

## హుడ్ కింద

ఇది ఇప్పటికీ Promises మరియు microtask queue — `await` థ్రెడ్‌ను నిరోధించదు; ఇది నియంత్రణను ఇస్తుంది కాబట్టి ఇతర కోడ్ నడుస్తుంది, తర్వాత పుష్కలం చేస్తుంది. మర్చిపోవద్దు: `await`(లేదా `.catch`) లేకుండా `async` ఫంక్షన్‌ను పిలవడం లోపాలను నిరోధించగలదు.

## ఇది ఎందుకు ముఖ్యమైనది

ఇది అసమకాలీన ప్రవాహాలను చదవదగ్గవిగా చేస్తుంది మరియు అసమకాలీన పనిని సీక్వెన్సింగ్ చేయడానికి ఆధునిక డిఫాల్ట్ — కానీ మీరు `Promise.all` తో స్వతంత్ర కార్యకలాపాలను చేతన సమాంతరం చేయాలి.