JS中try-catch异常处理机制详解(结合 async/await)

try {
  // 可能抛出异常的代码（同步/await 异步）
} catch (error) {
  // 只有 try 块抛出异常时，才执行这里（处理错误）
} finally {
  // 可选：无论是否抛出异常，最终一定会执行（收尾操作）
}

function syncErrorDemo() {
  try {
    console.log("开始执行同步代码");
    // 抛出同步异常：访问未定义的变量
    console.log(nonExistVar); 
    console.log("这行代码不会执行"); // 异常后停止执行
  } catch (error) {
    // 捕获异常并解析
    console.log("捕获到同步异常：");
    console.log("错误类型：", error.name); // ReferenceError
    console.log("错误信息：", error.message); // nonExistVar is not defined
    console.log("调用栈：", error.stack); // 定位错误位置（调试关键）
  } finally {
    console.log("finally：同步代码执行收尾\n");
  }
}
 
syncErrorDemo();

function validateAge(age) {
  try {
    if (age < 18) {
      // 手动抛出自定义 Error 对象（推荐）
      throw new Error("年龄必须≥18岁");
    }
    console.log("年龄验证通过");
  } catch (error) {
    console.log("验证失败：", error.message);
  }
}
 
validateAge(16); // 验证失败：年龄必须≥18岁
validateAge(20); // 年龄验证通过

// 错误示例：同步 try-catch 捕获不到异步回调的异常
function wrongAsyncCatch() {
  try {
    setTimeout(() => {
      // 异步回调内的异常，外层 try-catch 捕获不到
      throw new Error("异步回调出错");
    }, 1000);
  } catch (error) {
    console.log("捕获到错误：", error); // 永远不会执行
  }
}
wrongAsyncCatch(); // 控制台会抛出“未捕获的异常”

// 模拟异步操作（返回 Promise）
function fetchData(url) {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      if (url === "success") {
        resolve({ data: "请求成功", code: 200 });
      } else {
        // Promise reject 会被 await 转化为同步异常
        reject(new Error("接口请求失败：404 Not Found"));
      }
    }, 1000);
  });
}
 
// async/await + try-catch 捕获异步异常
async function asyncAwaitCatch() {
  try {
    console.log("开始请求接口");
    // await 等待 Promise，若 reject 则抛出异常
    const res = await fetchData("fail"); 
    console.log("接口返回：", res); // 异常后不会执行
  } catch (error) {
    // 捕获异步异常（等同于 Promise 的 .catch()）
    console.log("捕获到异步异常：", error.message);
    // 错误兜底：使用默认数据
    const defaultData = { data: "默认数据", code: 500 };
    console.log("兜底方案：", defaultData);
  } finally {
    console.log("finally：请求流程收尾（关闭加载弹窗）");
  }
}
 
asyncAwaitCatch();

async function parallelCatch() {
  try {
    // Promise.all 中任意一个 Promise reject，整体就会抛出异常
    const [res1, res2] = await Promise.all([
      fetchData("success"), // 成功
      fetchData("fail")     // 失败
    ]);
    console.log("并行请求成功：", res1, res2);
  } catch (error) {
    console.log("并行请求失败：", error.message);
    // 兜底：重新请求失败的接口
    const backupRes = await fetchData("success");
    console.log("兜底成功：", backupRes);
  }
}
parallelCatch();

try {
  const res = undefined; // 静默失败，无异常抛出
  if (!res) {
    console.log("数据为空，但未抛出异常");
  }
} catch (error) {
  console.log("不会执行这里");
}

function finallyPriority() {
  try {
    return "try 返回值";
  } catch (e) {
    return "catch 返回值";
  } finally {
    console.log("finally 先执行");
  }
}
console.log(finallyPriority()); // 输出：finally 先执行 → try 返回值

// 错误：try-catch 捕获不到非 await 的 Promise 异常
async function wrongCatch() {
  try {
    // 未用 await，Promise 异常会“逃逸”
    fetchData("fail"); 
  } catch (error) {
    console.log("捕获不到：", error);
  }
}
wrongCatch(); // 控制台抛出未捕获的异常

// 错误：请求失败时，未关闭加载弹窗
async function noFinally() {
  console.log("打开加载弹窗");
  try {
    await fetchData("fail");
  } catch (error) {
    console.log("请求失败");
    // 忘记关闭弹窗
  }
  // 如果没有 catch，弹窗永远不会关闭
}

// 低效：只打印日志，没有兜底逻辑
async function uselessCatch() {
  try {
    await fetchData("fail");
  } catch (error) {
    console.log("出错了：", error); // 仅打印，无兜底
  }
  // 后续代码依赖接口数据，会继续报错
  console.log(res.data); // res 未定义
}

// 1. try-catch 写法（推荐）
async function tryCatchDemo() {
  try {
    const res = await fetchData("fail");
  } catch (e) {
    console.log("捕获错误：", e.message);
  }
}
 
// 2. Promise.catch 写法（等价）
async function promiseCatchDemo() {
  const res = await fetchData("fail").catch(e => {
    console.log("捕获错误：", e.message);
  });
}