Callbacks, Promises மற்றும் async/await ஆகியவற்றை ஒப்பிடுக.

Question

Accepted Answer

இவை Node-இல் **asynchronous** செயல்பாடுகளைக் கையாள்வதற்கான மூன்று தலைமுறைகள் — ஒவ்வொன்றும் முந்தையதைவிட படிக்கும் தன்மையை மேம்படுத்துகின்றன, ஆனால் அனைத்தும் ஒரே event-loop அடித்தளத்தின் மீது கட்டமைக்கப்பட்டுள்ளன.

## 1. Callbacks — அசல் (மற்றும் "callback hell")

```js
fs.readFile("a.txt", (err, a) => {
  if (err) return handle(err);            // error-first callback convention
  fs.readFile("b.txt", (err, b) => {       // nesting deepens with each step...
    if (err) return handle(err);
    db.save(a + b, (err) => {              // "pyramid of doom"
      if (err) return handle(err);
    });
  });
});
```

Node-இன் வழக்கம் **error-first callbacks** (`(err, result)`). அவை வேலை செய்கின்றன ஆனால் ஆழமாக nest செய்யப்படுகின்றன மற்றும் error handling-ஐ சிதறடிக்கின்றன — படிக்கவும் பராமரிக்கவும் கடினம்.

## 2. Promises — chainable, தட்டையானது

```js
readFile("a.txt")
  .then(a => readFile("b.txt").then(b => a + b)) // return a promise → chain waits
  .then(combined => db.save(combined))
  .catch(handle);                                 // ONE place for all errors
```

ஒரு Promise என்பது எதிர்கால மதிப்பைக் குறிக்கிறது; `.then` படிகளை chain செய்கிறது மற்றும் `.catch` chain-இல் உள்ள எந்த error-ஐயும் கையாளுகிறது — nested callbacks-ஐவிட தட்டையானது.

## 3. async/await — synchronous-ஆகத் தோற்றமளிக்கிறது (நவீன இயல்புநிலை)

```js
async function combine() {
  try {
    const a = await readFile("a.txt");   // pause until resolved
    const b = await readFile("b.txt");
    await db.save(a + b);
  } catch (err) {
    handle(err);                          // normal try/catch works
  }
}
```

`async/await` என்பது Promises-இன் மீது உள்ள syntactic sugar — இது sync code போல மேலிருந்து கீழாக படிக்கப்படுகிறது, சாதாரண `try/catch`-ஐப் பயன்படுத்துகிறது, மேலும் இது பரிந்துரைக்கப்படும் நவீன பாணி.

## சார்பற்ற வேலையை serialize செய்ய வேண்டாம்

```js
// ❌ sequential — slow
const a = await getA(); const b = await getB();
// ✅ parallel — both at once
const [a, b] = await Promise.all([getA(), getB()]);
```

## உறவுமுறை

```text
Callbacks → Promises → async/await
All use the event loop. Promises wrap callbacks; async/await wraps Promises.
Modern code: async/await, with Promise.all to parallelize independent ops.
```

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

Node-இல் async கையாளுதல் தவிர்க்க முடியாதது (அனைத்து I/O-வும் async).

முன்னேற்றத்தைப் புரிந்துகொள்வது — error-first callbacks (பழைய API-கள்/library-களில் இன்னும் பொதுவானது), Promises (chainable), மற்றும் async/await (படிக்கக்கூடியது, இயல்புநிலை) — எந்த codebase-ஐயும் படிக்கவும் தூய்மையான async logic எழுதவும் உங்களை அனுமதிக்கிறது.

அவை அனைத்தும் அடிப்படையில் ஒரே event-loop mechanism என்பதை அறிந்துகொள்வதும், சார்பற்ற செயல்பாடுகளை `Promise.all`-உடன் parallelize செய்ய நினைவில் கொள்வதும், சரியான மற்றும் செயல்திறன் மிக்க async Node code-க்கு முக்கியமானது.