====== 什么是 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 的参数 =====
''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 的两个坑 =====
''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'' 块越宽,越难判断到底哪一步出错了。只包住真正会抛错的那几行。
- **捕获后不区分类型**:所有错误一把抓,导致「网络超时」和「参数非法」走同一套处理。
===== 七、Promise 的 .then / .catch:另一条捕获通道 =====
''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''。
相关:[[typescript:什么是use_strict|use strict]]、[[typescript:函数]]、[[typescript:第十章_编译配置|编译配置]]、[[typescript:第四章_枚举与字面量类型]]