Node.js try/catch/finally

try/catch/finally 捕获同步执行中的异常。

基本语法

结构

try {
  // 可能出错的代码
} catch (err) {
  // 错误处理
} finally {
  // 无论成功失败都执行
}

try 块

包裹风险代码

try {
  const data = JSON.parse(jsonString);
  const result = process(data);
} catch (err) {
  console.error('处理失败:', err.message);
}

多个语句

try {
  const file = fs.readFileSync('config.json');
  const config = JSON.parse(file);
  initialize(config);
} catch (err) {
  // 任意语句出错都会捕获
  handleError(err);
}

catch 块

捕获错误对象

try {
  riskyOperation();
} catch (err) {
  console.log('名称:', err.name);      // Error, TypeError 等
  console.log('消息:', err.message);   // 错误描述
  console.log('堆栈:', err.stack);     // 调用栈
}

条件捕获

try {
  operation();
} catch (err) {
  if (err instanceof TypeError) {
    console.log('类型错误:', err.message);
  } else if (err instanceof RangeError) {
    console.log('范围错误:', err.message);
  } else {
    console.log('其他错误:', err);
  }
}

重新抛出

try {
  operation();
} catch (err) {
  if (err.code === 'RECOVERABLE') {
    recover();
  } else {
    throw err;  // 无法处理，重新抛出
  }
}

finally 块

清理资源

let resource = null;
try {
  resource = acquireResource();
  process(resource);
} catch (err) {
  console.error('处理失败:', err);
} finally {
  // 确保释放资源
  if (resource) {
    releaseResource(resource);
  }
}

无论结果执行

let status = 'pending';
try {
  doWork();
  status = 'success';
} catch (err) {
  status = 'failed';
} finally {
  // 无论成功失败都记录
  logStatus(status);
}

无 catch 的 finally

try {
  operation();
} finally {
  cleanup();  // 清理后错误继续向上传播
}

完整示例

数据库操作

let connection = null;
try {
  connection = await db.connect();
  await connection.query('INSERT ...');
  await connection.commit();
} catch (err) {
  if (connection) {
    await connection.rollback();
  }
  throw err;
} finally {
  if (connection) {
    await connection.close();
  }
}

文件处理

let file = null;
try {
  file = fs.openSync('data.txt', 'r');
  const content = fs.readFileSync(file);
  parse(content);
} catch (err) {
  console.error('文件处理错误:', err.message);
} finally {
  if (file) {
    fs.closeSync(file);
  }
}

嵌套 try/catch

try {
  try {
    innerOperation();
  } catch (err) {
    if (err.recoverable) {
      recoverInner();
    } else {
      throw err;  // 传递到外层
    }
  }
  outerOperation();
} catch (err) {
  handleOuterError(err);
}

注意事项

不捕获异步错误

// try/catch 无法捕获异步回调中的错误
try {
  fs.readFile('file.txt', (err, data) => {
    if (err) throw new Error('读取失败');  // 不会被捕获
  });
} catch (err) {
  // 永远不会执行
}

// 正确做法
fs.readFile('file.txt', (err, data) => {
  if (err) {
    console.error(err);
    return;
  }
});

async/await 可捕获

// async/await 的 Promise 错误可被捕获
try {
  const data = await fs.promises.readFile('file.txt');
} catch (err) {
  console.error('读取失败:', err);
}

不要滥用

// 错误：用 try/catch 控制流程
try {
  const value = obj.property;
} catch (err) {
  // obj 可能不存在
}

// 正确：先检查
if (obj && obj.property) {
  const value = obj.property;
}

要点总结

• try 包裹可能出错的代码
• catch 捕获并处理错误
• finally 无论结果都执行，用于清理
• try/catch 只捕获同步错误
• async/await 可用 try/catch 捕获 Promise 错误