So sánh callbacks, Promises và async/await.

Question

Accepted Answer

Đây là ba thế hệ xử lý các thao tác **bất đồng bộ** trong Node — mỗi thế hệ cải thiện khả năng đọc hiểu so với thế hệ trước, nhưng tất cả đều được xây dựng trên cùng một nền tảng event loop.

## 1. Callbacks — thế hệ đầu tiên (và "callback hell")

```js
fs.readFile("a.txt", (err, a) => {
  if (err) return handle(err);            // quy ước error-first callback
  fs.readFile("b.txt", (err, b) => {       // lồng nhau sâu dần qua mỗi bước...
    if (err) return handle(err);
    db.save(a + b, (err) => {              // "kim tự tháp của sự diệt vong"
      if (err) return handle(err);
    });
  });
});
```

Quy ước của Node là **error-first callbacks** (`(err, result)`). Chúng hoạt động được nhưng lồng nhau sâu và làm rải rác việc xử lý lỗi — khó đọc và khó bảo trì.

## 2. Promises — có thể nối chuỗi, phẳng hơn

```js
readFile("a.txt")
  .then(a => readFile("b.txt").then(b => a + b)) // trả về một promise → chuỗi sẽ chờ
  .then(combined => db.save(combined))
  .catch(handle);                                 // MỘT nơi cho mọi lỗi
```

Một Promise đại diện cho một giá trị trong tương lai; `.then` nối chuỗi các bước và `.catch` xử lý bất kỳ lỗi nào trong chuỗi — phẳng hơn so với callback lồng nhau.

## 3. async/await — trông như đồng bộ (mặc định hiện đại)

```js
async function combine() {
  try {
    const a = await readFile("a.txt");   // tạm dừng cho đến khi resolve
    const b = await readFile("b.txt");
    await db.save(a + b);
  } catch (err) {
    handle(err);                          // try/catch thông thường vẫn hoạt động
  }
}
```

`async/await` là cú pháp đường (syntactic sugar) trên Promises — nó đọc từ trên xuống dưới như code đồng bộ, dùng `try/catch` thông thường, và là phong cách hiện đại được khuyến nghị.

## Đừng tuần tự hóa công việc độc lập

```js
// ❌ tuần tự — chậm
const a = await getA(); const b = await getB();
// ✅ song song — cả hai cùng lúc
const [a, b] = await Promise.all([getA(), getB()]);
```

## Mối quan hệ

```text
Callbacks → Promises → async/await
Tất cả đều dùng event loop. Promises bọc callbacks; async/await bọc Promises.
Code hiện đại: async/await, kèm Promise.all để chạy song song các thao tác độc lập.
```

## Tại sao điều này quan trọng

Xử lý bất đồng bộ là điều không thể tránh trong Node (mọi I/O đều bất đồng bộ).

Hiểu sự tiến hóa — error-first callbacks (vẫn phổ biến trong các API/thư viện cũ), Promises (có thể nối chuỗi), và async/await (dễ đọc, mặc định) — cho phép bạn đọc được bất kỳ codebase nào và viết logic bất đồng bộ sạch sẽ.

Biết rằng chúng đều dùng cùng một cơ chế event loop bên dưới, và nhớ chạy song song các thao tác độc lập bằng `Promise.all`, là chìa khóa để viết code Node bất đồng bộ đúng đắn và hiệu năng cao.