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)`) ਹੈ। ਇਹ ਕੰਮ ਕਰਦੇ ਹਨ ਪਰ ਡੂੰਘਾਈ ਵਿੱਚ ਸ਼ਾਮਲ ਹੋ ਜਾਂਦੇ ਹਨ ਅਤੇ ਗਲਤੀ ਸੰਭਾਲਣ ਖਿੰਡਿਆ ਹੁੰਦਾ ਹੈ — ਪੜ੍ਹਨਾ ਅਤੇ ਬਣਾਈ ਰੱਖਣਾ ਮੁਸ਼ਕਲ।

## 2. Promises — ਚੇਨਕਾਰੀ, ਸਮਤਲ

```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` ਪੜਾਵਾਂ ਨੂੰ ਚੇਨ ਕਰਦਾ ਹੈ ਅਤੇ `.catch` ਚੇਨ ਵਿੱਚ ਕਿਸੇ ਵੀ ਗਲਤੀ ਨੂੰ ਸੰਭਾਲਦਾ ਹੈ — ਸ਼ਾਮਲ callbacks ਨਾਲੋਂ ਸਮਤਲ।

## 3. async/await — ਸਮਕਾਲੀ-ਦਿਖਾਈ ਦੇਣ ਵਾਲਾ (ਆਧੁਨਿਕ ਮੂਲ ਵਿਕਲਪ)

```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 ਹੈ — ਇਹ ਸਮਕਾਲੀ ਕੋਡ ਵਾਂਗ ਸਿਖਰ ਤੋਂ ਹੇਠ ਪੜ੍ਹਿਆ ਜਾਂਦਾ ਹੈ, ਸਾਧਾਰਨ `try/catch` ਵਰਤਦਾ ਹੈ, ਅਤੇ ਸਿਫਾਰਸ਼ ਕੀਤਾ ਆਧੁਨਿਕ ਸਟਾਇਲ ਹੈ।

## ਸਵਤੰਤਰ ਕੰਮ ਨੂੰ ਲੜੀਬੱਧ ਨਾ ਕਰੋ

```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.
```

## ਇਹ ਮਾਇਨੇ ਰੱਖਦਾ ਹੈ

Async ਸੰਭਾਲਣਾ Node ਵਿੱਚ ਅਪਰਿਹਾਰ੍ਯ ਹੈ (ਸਾਰਾ I/O async ਹੈ)।

ਪ੍ਰਗਤੀ ਨੂੰ ਸਮਝਣਾ — error-first callbacks (ਪੁਰਾਤਨ APIs/libraries ਵਿੱਚ ਅਜੇ ਆਮ), Promises (ਚੇਨਕਾਰੀ), ਅਤੇ async/await (ਪੜ੍ਹਨਯੋਗ, ਮੂਲ ਵਿਕਲਪ) — ਤੁਹਾਨੂੰ ਕਿਸੇ ਵੀ codebase ਨੂੰ ਪੜ੍ਹਨ ਅਤੇ ਸਾਫ async ਤਰਕ ਲਿਖਣ ਦੇ ਯੋਗ ਬਣਾਉਂਦਾ ਹੈ।

ਇਹ ਜਾਣਨਾ ਕਿ ਉਹ ਸਾਰੇ ਅੰਦਰ ਇੱਕ ਹੀ event-loop ਮਾਡੀ ਹਨ, ਅਤੇ `Promise.all` ਦੇ ਨਾਲ ਸਵਤੰਤਰ ਕਾਰਜਾਂ ਨੂੰ ਸਮਾਂਤਰ ਬਣਾਉਣਾ ਯਾਦ ਰੱਖਣਾ, ਸਹੀ ਅਤੇ ਪ੍ਰਭਾਵਸ਼ালੀ async Node ਕੋਡ ਲਈ ਕੁੰਜੀ ਹੈ।