TypeScript async, Promise และ await



Promise<T>

const p: Promise<string> = fetch("/api/name").then((r) => r.text());

p.then((name) => {
  name.toUpperCase();   // name: string
});

Promise<T> = “ค่า type T ที่จะมาในอนาคต”

async function คืน Promise เสมอ

async function getUser(id: number): Promise<User> {
  const response = await fetch(`/api/users/${id}`);
  return response.json() as Promise<User>;   // (validation ที่ถูกต้องดูบทที่ 30)
}

// return type ที่เขียน Promise<User> — ถ้าเขียน User เฉย ๆ TS wrap เป็น Promise<User> ให้
async function getName(): Promise<string> {
  return "อร";          // return string → Promise<string>
}

async function noReturn(): Promise<void> {
  console.log("done");
}

TS infer return type ของ async function เป็น Promise<...> เสมอ — ไม่ต้องเขียน (เว้น public API)

await แกะ Promise

async function main() {
  const user: User = await getUser(1);   // await Promise<User> → User
  console.log(user.name);

  const name = await getName();           // string
}

await ใช้ได้เฉพาะใน async function (หรือ top-level ใน ESM module)

error typing — catch เป็น unknown

ตั้งแต่ TS 4.4 (useUnknownInCatchVariables, มากับ strict) — catch (e) มี type unknown:

async function safeGetUser(id: number): Promise<User | null> {
  try {
    return await getUser(id);
  } catch (error) {
    // error: unknown  — ต้อง narrow
    if (error instanceof Error) {
      console.error("โหลด user ล้มเหลว:", error.message);
    } else {
      console.error("error ไม่ทราบชนิด:", error);
    }
    return null;
  }
}

ทำไม unknown: JavaScript throw อะไรก็ได้ (throw "string", throw 42, throw null) — TS บังคับให้เช็คว่าเป็น Error จริงก่อนเข้าถึง .message

helper:

function getErrorMessage(error: unknown): string {
  if (error instanceof Error) return error.message;
  if (typeof error === "string") return error;
  return "เกิดข้อผิดพลาดไม่ทราบสาเหตุ";
}

Promise.all — ทำพร้อมกัน

const [user, posts, comments] = await Promise.all([
  getUser(1),          // Promise<User>
  getPosts(1),         // Promise<Post[]>
  getComments(1),      // Promise<Comment[]>
]);
// user: User, posts: Post[], comments: Comment[]  — TS infer tuple ถูกต้อง!

Promise.all ล้มทั้งชุดถ้าตัวใดตัวหนึ่ง reject — ผลคือ Promise<[T1, T2, T3]>

Promise.allSettled — ไม่ล้มทั้งชุด

const results = await Promise.allSettled([
  getUser(1),
  getUser(2),
  getUser(999),   // ตัวนี้ fail
]);

// results: PromiseSettledResult<User>[]
for (const result of results) {
  if (result.status === "fulfilled") {
    console.log(result.value.name);   // narrow → มี value
  } else {
    console.error(result.reason);      // narrow → มี reason
  }
}

PromiseSettledResult<T> เป็น discriminated union — narrow ด้วย result.status

Promise.race / Promise.any

// race — ตัวแรกที่ settle (fulfill หรือ reject) ชนะ
const winner = await Promise.race([
  fetchData(),
  timeout(5000),   // Promise ที่ reject หลัง 5 วิ
]);

// any — ตัวแรกที่ fulfill ชนะ (ignore reject จนกว่าทุกตัว reject)
const fastest = await Promise.any([fetchFromA(), fetchFromB(), fetchFromC()]);

typing async iteration

async function* generateNumbers(): AsyncGenerator<number> {
  for (let i = 0; i < 5; i++) {
    await delay(100);
    yield i;
  }
}

for await (const n of generateNumbers()) {
  console.log(n);   // n: number
}

กับดัก: floating promise

async function saveData() { /* ... */ }

function handler() {
  saveData();   // ⚠️ ไม่ await, ไม่ .catch — error ที่เกิดจะหายไป (unhandled rejection)
}

ตั้ง eslint rule @typescript-eslint/no-floating-promises (type-aware) — บังคับให้ทุก Promise ถูก await, .catch(), หรือ void:

void saveData();                    // จงใจ fire-and-forget (มาร์กไว้)
saveData().catch(logError);         // จัดการ error
await saveData();                   // รอ

กับดัก: array method + async

// ❌ forEach ไม่รอ async callback
users.forEach(async (user) => {
  await sendEmail(user);   // forEach return ก่อน email ส่งเสร็จ
});

// ✅ for...of
for (const user of users) {
  await sendEmail(user);   // ทีละคน ตามลำดับ
}

// ✅ พร้อมกัน
await Promise.all(users.map((user) => sendEmail(user)));

เรื่องที่คนมักพลาด

  • ลืม await — ได้ Promise<T> ไม่ใช่ T; if (promise) เป็น truthy เสมอ
  • catch (e) แล้ว e.message — e เป็น unknown (TS 4.4+); e instanceof Error ก่อน
  • forEach(async ...) — ไม่รอ; ใช้ for...of (sequential) หรือ Promise.all(map(...)) (parallel)
  • floating promise — Promise ที่ไม่ await/catch → unhandled rejection; eslint no-floating-promises
  • Promise.all แล้วตัวเดียว fail = ล้มหมด — ใช้ allSettled ถ้าอยากได้ผลบางส่วน
  • return await vs return — return await x มีประโยชน์ใน try/catch (จับ error ของ x); นอกนั้นเท่ากัน
  • async function ที่ throw sync — ยัง reject Promise (ไม่ throw sync); caller ต้อง await + catch

สรุป

  • Promise<T> = ค่า T ในอนาคต; async function คืน Promise<...> เสมอ (TS wrap ให้)
  • await Promise<T> → T (ใน async function / top-level ESM)
  • catch (e) → e: unknown (TS 4.4+) — e instanceof Error ก่อนใช้ .message; helper getErrorMessage
  • Promise.all([...]) — infer tuple ของผลลัพธ์; ล้มทั้งชุดถ้าตัวใด reject
  • Promise.allSettled — PromiseSettledResult<T>[] (discriminated union, narrow ด้วย .status)
  • floating promise — ต้อง await / .catch() / void; forEach(async) ไม่รอ ใช้ for...of หรือ Promise.all(map)

บทถัดไปว่าด้วยการจัดการข้อผิดพลาด — subclass Error, custom error, catch (e: unknown) narrowing และ Result type pattern