1
2
3
4

type A = Awaited<Promise<string>>;                  // string
type B = Awaited<Promise<Promise<number>>>;         // number  ✅ 递归
type C = Awaited<string>;                           // string（不是 Promise 就原样返回）
type D = Awaited<Promise<string | Promise<number>>>; // string | number

1
2
3
4
5
6

async function fetchUser() {
  return { id: 1, name: "a" };
}

type FetchedUser = Awaited<ReturnType<typeof fetchUser>>;
// { id: number; name: string }  🔥

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// ✅ 正确
async function a(): Promise<number> { return 1; }

// ⚠️ 合法但多余（TS 会自动展平）
async function b(): Promise<Promise<number>> { return Promise.resolve(1); }

// 🛑 常见错误：手动 new Promise 却没写 async 语义
function c(): Promise<number> {
  return 1;   // ❌ TS2322: Type 'number' is not assignable to type 'Promise<number>'.
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// 🛑 传统 try/catch：catch 里拿不到「成功值」的类型
async function bad() {
  try {
    const user = await fetchUser();
    const posts = await fetchPosts(user.id);
    return { user, posts };            // 类型能推出来
  } catch (e) {
    return { error: e };               // ⚠️ 返回值变成联合，调用方难处理
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

// ✅ Result 类型：把错误变成返回值的一部分
type Result<T, E = Error> =
  | { ok: true; value: T }
  | { ok: false; error: E };

async function safeAsync<T>(p: Promise<T>): Promise<Result<T>> {
  try {
    return { ok: true, value: await p };
  } catch (e) {
    return { ok: false, error: e instanceof Error ? e : new Error(String(e)) };
  }
}

const r = await safeAsync(fetchUser());
if (r.ok) {
  r.value;    // ✅ 收窄到成功分支，类型完整
} else {
  r.error;    // Error
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// 并行 + 逐个报告失败
async function settleAll<T extends readonly unknown[]>(
  promises: { [K in keyof T]: Promise<T[K]> },
): Promise<{ [K in keyof T]: Result<T[K]> }> {
  const results = await Promise.allSettled(promises);
  return results.map((r) =>
    r.status === "fulfilled"
      ? { ok: true as const, value: r.value }
      : { ok: false as const, error: r.reason }
  ) as never;
}

1
2
3
4
5
6
7
8
9

async function fetchWithTimeout(url: string, ms: number): Promise<Response> {
  const controller = new AbortController();
  const timer = setTimeout(() => controller.abort(), ms);
  try {
    return await fetch(url, { signal: controller.signal });
  } finally {
    clearTimeout(timer);       // ✅ 一定要清理，否则计时器泄漏
  }
}

1
2
3
4
5
6
7

// 更简洁的超时写法（较新的运行时支持）
await fetch(url, { signal: AbortSignal.timeout(5000) });

// 合并用户取消 + 超时
await fetch(url, {
  signal: AbortSignal.any([userSignal, AbortSignal.timeout(5000)]),
});

1
2
3
4
5
6
7
8
9

// 🛑 只在浏览器对，Node 下报错
const timer: number = setTimeout(() => {}, 0);

// ✅ 跨平台安全：不要标注类型
const timer = setTimeout(() => {}, 0);
clearTimeout(timer);

// ✅ 或显式用对应环境的类型
const t2: ReturnType<typeof setTimeout> = setTimeout(() => {}, 0);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

class AppError extends Error {
  constructor(
    message: string,
    readonly code: string,
    readonly statusCode = 500,
    options?: { cause?: unknown },
  ) {
    super(message, options);
    this.name = "AppError";
    // 修正原型链（target 低于 ES2015 时必需；现代 target 可省）
    Object.setPrototypeOf(this, AppError.prototype);
  }
}

class NotFoundError extends AppError {
  constructor(resource: string) {
    super(`${resource} 不存在`, "NOT_FOUND", 404);
    this.name = "NotFoundError";
  }
}

class ValidationError extends AppError {
  constructor(readonly issues: string[]) {
    super("校验失败", "VALIDATION", 400);
    this.name = "ValidationError";
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

function handle(e: unknown): Response {
  if (e instanceof ValidationError) {
    return json({ issues: e.issues }, e.statusCode);   // ✅ e.issues 可访问
  }
  if (e instanceof NotFoundError) {
    return json({ message: e.message }, e.statusCode);
  }
  if (e instanceof AppError) {
    return json({ code: e.code }, e.statusCode);
  }
  return json({ message: "内部错误" }, 500);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

try {
  await db.query(sql);
} catch (e) {
  throw new AppError("查询失败", "DB_ERROR", 500, { cause: e });
  // 原始错误保留在 err.cause 里
}

// 读取
if (e instanceof AppError && e.cause instanceof Error) {
  logger.debug("根因", e.cause.message);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

// 判别联合建模错误
type ApiError =
  | { kind: "network"; cause: unknown }
  | { kind: "notFound"; resource: string }
  | { kind: "validation"; issues: string[] }
  | { kind: "server"; status: number; message: string };

type ApiResult<T> = { ok: true; data: T } | { ok: false; error: ApiError };

function describe(e: ApiError): string {
  switch (e.kind) {
    case "network":    return "网络错误";
    case "notFound":   return `${e.resource} 不存在`;     // ✅ e.resource 可访问
    case "validation": return `校验失败: ${e.issues.join(", ")}`;
    case "server":     return `服务端错误 ${e.status}`;
    default: {
      const _exhaustive: never = e;   // ✅ 新增错误类型时编译报错 🔥
      return _exhaustive;
    }
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

JSON.stringify(new Error("出错了"));
// "{}"  ⚠️ message、stack 全都丢了！因为它们是不可枚举属性

// ✅ 手动序列化
function serializeError(e: unknown) {
  if (e instanceof Error) {
    return { name: e.name, message: e.message, stack: e.stack };
  }
  return { name: "Unknown", message: String(e) };
}