Callback'leri, Promise'leri ve async/await'i karşılaştırın.

Question

Accepted Answer

Bunlar Node'da **asenkron** işlemleri yönetmenin üç nesli — her biri öncekinin okunabilirliğini iyileştiriyor, ancak hepsi aynı event-loop temelinde inşa ediliyor.

## 1. Callback'ler — orijinal (ve "callback cehennemi")

```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'un kuralı **error-first callback'ler**'dir (`(err, result)`). Çalışırlar ama derinlemesine iç içe geçerler ve hata işlemesini dağıtırlar — okuması ve bakımı zordur.

## 2. Promise'ler — zincirlenebilir, daha düz

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

Bir Promise gelecek bir değeri temsil eder; `.then` adımları zincirler ve `.catch` zincirdeki herhangi bir hatayı işler — iç içe geçmiş callback'lerden daha düzdür.

## 3. async/await — senkron görünümlü (modern varsayılan)

```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` Promise'ler üzerine sözdizimsel şekerlemedir — senkron kod gibi yukarıdan aşağıya okunur, sıradan `try/catch` kullanır ve önerilen modern stildir.

## Bağımsız işleri seri hale getirmeyin

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

## İlişki

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

## Neden önemli

Asenkron işleme Node'da kaçınılmazdır (tüm I/O asenkrondur).

İlerlemeyi anlama — error-first callback'ler (eski API'lar/kütüphanelerde hala yaygın), Promise'ler (zincirlenebilir) ve async/await (okunabilir, varsayılan) — herhangi bir kod tabanını okumanızı ve temiz asenkron mantık yazmanızı sağlar.

Bunların hepsinin altında aynı event-loop mekanizması olduğunu bilmek ve bağımsız işlemleri `Promise.all` ile paralelleştirmeyi hatırlamak, doğru ve performant asenkron Node kodu için anahtardır.