async/await எவ்வாறு செயல்படுகிறது?

Question

Accepted Answer

`async/await` என்பது **Promises மீதான syntax sugar** ஆகும், இது ஒத்திசைவான குறியீடாக படிக்கப்படும் பக்கச்சரிக்கப்பட்ட குறியீட்டை எழுத உங்களை அனுமதிக்கிறது. ஒரு `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
  }
}
```

## வரிசைமுறை vs இணை — ஒரு பொதுவான செயல்திறன் தவறு

`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` ஆனது thread ஐ தடுக்காது; இது கட்டுப்பாட்டை விளைவிக்கிறது, மற்ற குறியீடு இயக்கப்பட்டு, பின்னர் மீண்டும் தொடங்குகிறது. மறந்து விடாதே: `await`(அல்லது `.catch`) இல்லாமல் `async` செயல்பாட்டை அழைப்பது பிழைகளை மறைக்க முடியும்.

## ஏன் இது முக்கியம்

இது பக்கச்சரிக்கப்பட்ட ஓட்டங்களை படிக்கக்கூடியதாக்குகிறது மற்றும் பக்கச்சரிக்கப்பட்ட வேலையை வரிசைப்படுத்துவதற்கான நவீன இயல்பு — ஆனால் நீங்கள் `Promise.all` உடன் சுயாதீன செயல்பாடுகளை தெளிவாக இணையாக்க வேண்டும்.