Krahasoni callbacks, Promises dhe async/await.

Question

Accepted Answer

Këto janë tre brezni të trajtimit të operacioneve **asinkrone** në Node — secila përmirëson lexueshmërinë në krahasim me atë të mëparshme, por të gjitha ndërtohen në të njëjtën bazë të event-loop.

## 1. Callbacks — origjinalja (dhe "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);
    });
  });
});
```

Konvencioni i Node është **error-first callbacks** (`(err, result)`). Ato punojnë, por fuqisht të ndërlikuar dhe shpërndarje të trajtimit të gabimeve — të vështira për të lexuar dhe për të mirëmbajtur.

## 2. Promises — zinxhirore, më të sheshuara

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

Një Promise përfaqëson një vlerë të ardhshme; `.then` zinxhiron hapat dhe `.catch` trajton çdo gabim në zinxhir — më e sheshte se callbacks të ndërlikitur.

## 3. async/await — pamje sinkrone (standardi modern)

```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` është sheqer sintaksore mbi Promises — lexohet nga lart poshtë si kod sinkron, përdor `try/catch` të zakonshëm dhe është stili modern i rekomanduar.

## Mos serizuali punën e pavarur

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

## Marrëdhënia

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

## Pse është e rëndësishme

Trajtimi asinkron është i pashmangshëm në Node (i gjithë I/O është asinkron).

Kuptimi i progresimit — error-first callbacks (ende të zakonshëm në API-t/bibliotekad më të vjetra), Promises (zinxhirore) dhe async/await (lexueshme, standardi) — ju lejon të lexoni çdo bazë kodi dhe të shkruani logjikë asinkrone të pastër.

Dija që të gjithë janë i njëjti mekanizëm event-loop nën sipërfaqe, dhe të mbani mend të paralelizoni operacionet e pavarura me `Promise.all`, është thelbësore për kodin asinkron të duhur dhe performant në Node.