เปรียบเทียบ callbacks, Promises และ async/await

Question

Accepted Answer

ทั้งสามสิ่งนี้คือสามยุคของการจัดการงานแบบ **asynchronous** ใน Node โดยแต่ละยุคพัฒนาความอ่านง่ายขึ้นจากยุคก่อน แต่ทั้งหมดสร้างอยู่บนพื้นฐานของ 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)`) ซึ่งใช้งานได้ แต่ซ้อนกันลึกและกระจายการจัดการ error ออกไป ทำให้อ่านและดูแลรักษายาก

## 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` จัดการ error ใด ๆ ในสายนั้น แบนราบกว่า callback ที่ซ้อนกัน

## 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` คือ syntactic sugar ที่ครอบ Promises อีกชั้น อ่านจากบนลงล่างเหมือนโค้ด sync ใช้ `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 (ยังพบบ่อยใน API/library เก่า), Promises (ต่อกันเป็นสายได้) และ async/await (อ่านง่าย เป็นค่าเริ่มต้น) — ช่วยให้คุณอ่าน codebase ใด ๆ ได้และเขียน logic แบบ async ที่สะอาด

การรู้ว่าทั้งหมดใช้กลไก event loop เดียวกันอยู่เบื้องหลัง และการจำไว้ว่าต้องทำงานที่อิสระต่อกันแบบขนานด้วย `Promise.all` คือกุญแจสำคัญสู่โค้ด async ใน Node ที่ถูกต้องและมีประสิทธิภาพ