什么是 try catch

try / catch 是 JavaScript(TypeScript 完全一样)里捕获运行时错误的语法结构:把可能出错的代码放进 try 块,一旦抛出异常,控制流立刻跳到 catch 块,而不是让错误直接崩掉整个程序。

try {
  // 可能会抛错的代码
  JSON.parse("{ 坏掉的 json");
} catch (err) {
  // 出错时走到这里,err 是抛出的那个东西
  console.error("解析失败", err);
}
try {
  risky();
} catch (err) {
  handle(err);
} finally {
  cleanup();
}
块 何时执行 是否必需
try 无条件进入 必需
catch 只有 try 里抛错时才执行 与 finally 至少有一个
finally 无论抛不抛错、有没有 return,都会执行 与 catch 至少有一个

也可以只有 try … finally(只保证清理,不处理错误,错误继续往外传):

try {
  doWork();
} finally {
  closeConnection();   // 即使 doWork() 抛错也会执行
}

catch 后面的括号可以省略(ES2019 的 optional catch binding),只想过一遍错误、不需要错误对象时:

try {
  JSON.parse(text);
} catch {
  return fallback;   // 不关心具体是什么错误
}

TypeScript 里 catch 变量的类型是个重点:JS 允许 throw 任何值(throw “字符串”、throw 42 都合法),所以捕获到的不一定是 Error 实例。

  • tsconfig 开着 “strict”: true(含 useUnknownInCatchVariables)时,catch 变量类型是 unknown,必须先窄化才能访问 err.message。
  • 关掉该选项(或老代码)时它是 any,能直接写 err.message,但不安全。
try {
  risky();
} catch (err) {
  // err: unknown(strict 模式下)
  if (err instanceof Error) {
    console.error(err.message);   // 窄化后才能用
  } else {
    console.error(String(err));
  }
}

嫌样板多可以封一个辅助函数:

function toError(e: unknown): Error {
  return e instanceof Error ? e : new Error(String(e));
}

finally 里的 return / throw 会覆盖 try 或 catch 的结果,甚至把正在传播的错误悄悄吞掉:

function f() {
  try {
    return 1;
  } finally {
    return 2;    // 结果永远是 2,try 里的 return 被吃掉了
  }
}
 
function g() {
  try {
    throw new Error("重要错误");
  } finally {
    return "正常值";   // 错误被静默吞掉,调用方完全不知道出过错
  }
}

所以 finally 里只做清理(关文件、解锁、还原状态),不要 return,也不要抛新错。

try / catch 是同步结构,只拦得住沿着当前调用栈往上抛的错误。

情况 能被同一个 try / catch 捕获吗
同步抛错、throw 能
await 的 Promise 被 reject(在 async 函数里) 能,await 会把 rejection 变成一次同步抛错
没有 await 的 Promise rejection 不能,要用 .catch() 或补上 await
回调里抛错(setTimeout、事件监听、forEach 内部) 不能,那是在别的调用栈里执行的
模块加载失败、语法错误 不能,这类错误发生在进入 try 之前
// 能捕获:await 把 rejection 转成抛错
try {
  const data = await fetchData();
} catch (err) {
  // 请求失败会到这里
}
 
// 不能捕获:没人等这个 Promise
try {
  fetchData();          // 忘了 await,rejection 会变成 unhandledrejection
} catch {
  // 永远不会执行
}
 
// 不能捕获:回调在另一个调用栈里抛错
try {
  setTimeout(() => {
    throw new Error("boom");
  }, 0);
} catch {
  // 也永远不会执行,错误变成未捕获异常
}

想在回调里处理错误,就把 try / catch 写进回调自己内部。

try / catch 常配合自定义错误类使用:抛错时带上可区分的类型,捕获后用 instanceof 分流——能处理的就地处理,处理不了的继续往外抛。

class ValidationError extends Error {
  constructor(message: string) {
    super(message);
    this.name = "ValidationError";
  }
}
 
function parseUser(json: string) {
  try {
    return JSON.parse(json);
  } catch (err) {
    // 换成更贴近业务的错误再抛出
    throw new ValidationError("用户数据不是合法 JSON");
  }
}
 
try {
  parseUser(input);
} catch (err) {
  if (err instanceof ValidationError) {
    showFormError(err.message);   // 能处理的错误,就地处理
  } else {
    throw err;                    // 处理不了,继续往上抛
  }
}

ES2022 起 Error 支持 cause 参数,可以把原始错误挂在新错误上,便于排查:

try {
  await save();
} catch (err) {
  throw new Error("保存用户失败", { cause: err });
}
  • 空 catch 吞错:catch {} 什么都不做,bug 从此消失得无影无踪。至少记一条日志。
  • catch 里返回默认值掩盖问题:把「失败」伪装成「成功」,上层无从察觉。
  • 用异常做流程控制:比如用 try { JSON.parse(x) } catch 判断「是不是 JSON」,有明确校验手段时优先用校验。
  • 包住整个函数体:try 块越宽,越难判断到底哪一步出错了。只包住真正会抛错的那几行。
  • 捕获后不区分类型:所有错误一把抓,导致「网络超时」和「参数非法」走同一套处理。

try / catch 处理的是同步抛错,Promise 的错误则走 .catch() 这条链。两者是一一对应的,只是作用对象不同:.catch 挂在 Promise 对象上,try / catch 包的是代码块和 await。

动态 import() 是「返回 Promise」的典型例子(注意它是函数调用,不是静态 import 语句),所以下面两种写法效果等价:

// 写法一:Promise 链
import("./report.mjs")
  .then((m) => {
    mod = m;                                       // 成功:拿到模块命名空间对象
  })
  .catch((err) => {
    console.error("模块加载失败:" + (err?.message ?? err));   // 失败:这里就相当于 catch 块
  });
 
// 写法二:await + try / catch
try {
  mod = await import("./report.mjs");
} catch (err) {
  console.error("模块加载失败:" + toError(err).message);
}

两种通道的差异:

对比项 p.then(…).catch(…) try { await p } catch
作用对象 Promise 对象本身 代码块 + await
错误从哪来 .catch 回调的参数 catch (err) 的变量
TS 里的类型 回调参数默认是 any,想安全就自己标成 unknown strict 模式下自动是 unknown
收尾方式 .finally(cb),回调不接收参数 finally { … },能访问外面作用域的变量
收尾会不会改变结果 回调的返回值被忽略,不覆盖原结果 finally 里的 return 会覆盖结果(见第三节)
链断了会怎样 变成 unhandledrejection,没人接住 往上抛给最近的 try / catch
捕获回调内部的同步抛错 能,then 回调里抛错会变成 rejected Promise 交给后面的 catch 能,同样被同一个 catch 接住

「断链」是最常见的翻车点:回调里忘了 return,后面的 .catch 就收不到那一步的错误。

// 链连着:loadUser 和 save 的错误都能被 catch 收到
loadUser()
  .then((user) => save(user))          // 隐式 return,链不断
  .catch((err) => console.error(err));
 
// 链断了:save 的错误不会传给这个 catch
loadUser()
  .then((user) => {
    save(user);                        // 少了 return,没人接这个 Promise
  })
  .catch((err) => console.error(err)); // 只收得到 loadUser 的错误

几个相关点:

  • 多个并发任务:Promise.all([…]) 只要有一项 reject 就整体 reject,配一个 .catch 即可;想拿到每一项的结果、不让失败影响其他项,用 Promise.allSettled()。
  • 顶层 await:ESM(.mjs / .mts)允许在模块顶层直接 await,所以顶层也能用 try / catch;CommonJS 不支持顶层 await,那种场合只能 .then/.catch。
  • 「加载失败就回落到备用来源」这类逻辑,本质是把错误当业务分支处理,写在 .catch 里是合理的;但要在日志里留下痕迹,别把回落做成静默成功。
  • try 放可能出错的代码,catch 处理错误,finally 收尾且总会执行。
  • 可以没有 catch(只写 try / finally),也可以省略 catch 的参数。
  • 只能捕获同步抛错和 await 的 rejection;回调里的错误必须在回调内部处理。
  • strict 模式下 catch 变量是 unknown,要用 instanceof 窄化。
  • 别在 finally 里 return;别写空 catch。

相关:use strict、函数、编译配置、第四章_枚举与字面量类型

该主题尚不存在

您访问的页面并不存在。如果允许,您可以使用创建该页面按钮来创建它。

  • typescript/什么是try_catch.txt
  • 最后更改: 2026/10/11 15:26
  • 由 张叶安