JavaScript的`try/catch`异常处理机制：探讨`finally`块的执行时机，以及如何处理异步代码中的异常。 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

JavaScript的`try/catch`异常处理机制：深入`finally`块与异步异常处理

大家好，今天我们来深入探讨JavaScript中的try/catch异常处理机制，重点关注finally块的执行时机，以及如何在异步代码中优雅地处理异常。try/catch是任何健壮的应用程序的基础，理解其细节对编写高质量的代码至关重要。

`try/catch`的基本结构

首先，我们回顾一下try/catch的基本结构：

try {
  // 可能会抛出异常的代码
  // 正常执行的代码
} catch (error) {
  // 处理异常的代码
  // error 对象包含异常的信息
} finally {
  // 无论是否发生异常，都会执行的代码
}

try 块: 包含你认为可能会抛出异常的代码。如果try块中的代码成功执行，则跳过catch块。
catch 块: 如果try块中抛出了异常，则执行catch块中的代码。catch块接收一个error对象，该对象包含关于异常的信息，例如错误消息、堆栈跟踪等。
finally 块: 无论try块中的代码是否抛出异常，finally块中的代码都会执行。finally块通常用于清理资源，例如关闭文件或释放网络连接。

`finally`块的执行时机

finally块的关键在于其执行时机。它保证在try块执行完毕后，但在程序控制权离开try/catch结构之前执行。这意味着：

try块成功执行: try块中的代码执行完毕后，执行finally块。

try {
  console.log("Try block executed successfully.");
} catch (error) {
  console.error("Catch block executed.");
} finally {
  console.log("Finally block executed.");
}
// 输出:
// Try block executed successfully.
// Finally block executed.

try块抛出异常: try块中抛出异常后，执行catch块，然后执行finally块。

try {
  throw new Error("An error occurred.");
  console.log("This line will not be executed."); // 这行代码不会被执行
} catch (error) {
  console.error("Catch block executed:", error.message);
} finally {
  console.log("Finally block executed.");
}
// 输出:
// Catch block executed: An error occurred.
// Finally block executed.

catch块中抛出异常: 如果catch块中也抛出了异常，finally块仍然会执行，然后异常会向上传播。

try {
  throw new Error("An error occurred in try.");
} catch (error) {
  console.error("Catch block executed:", error.message);
  throw new Error("An error occurred in catch.");
} finally {
  console.log("Finally block executed.");
}
// 输出:
// Catch block executed: An error occurred in try.
// Finally block executed.
// Uncaught Error: An error occurred in catch.

try或catch块中存在return语句: 即使try或catch块中存在return语句，finally块仍然会在函数返回之前执行。

function testFinally() {
  try {
    console.log("Try block executed.");
    return "Try return value";
  } catch (error) {
    console.error("Catch block executed:", error.message);
    return "Catch return value";
  } finally {
    console.log("Finally block executed.");
  }
}

console.log(testFinally());
// 输出:
// Try block executed.
// Finally block executed.
// Try return value

需要注意: 如果finally块本身也包含return语句，那么finally块中的return语句会覆盖try或catch块中的return语句。

function testFinallyOverride() {
  try {
    console.log("Try block executed.");
    return "Try return value";
  } catch (error) {
    console.error("Catch block executed:", error.message);
    return "Catch return value";
  } finally {
    console.log("Finally block executed.");
    return "Finally return value"; // 覆盖了 try 块的 return
  }
}

console.log(testFinallyOverride());
// 输出:
// Try block executed.
// Finally block executed.
// Finally return value

try或catch块中存在break或continue语句 (在循环中): finally块仍然会在循环的下一次迭代开始之前执行。

for (let i = 0; i < 3; i++) {
  try {
    if (i === 1) {
      continue; // 跳过当前迭代
    }
    console.log("Try block executed, i =", i);
  } catch (error) {
    console.error("Catch block executed:", error.message);
  } finally {
    console.log("Finally block executed, i =", i);
  }
}

// 输出:
// Try block executed, i = 0
// Finally block executed, i = 0
// Finally block executed, i = 1
// Try block executed, i = 2
// Finally block executed, i = 2

异步代码中的异常处理

在异步JavaScript代码中，异常处理变得更加复杂。传统的try/catch块只能捕获同步代码中的异常。对于异步操作（例如使用setTimeout、Promise、async/await），需要采取不同的策略。

1. `Promise`中的异常处理

Promise提供了.then()和.catch()方法来处理异步操作的结果和错误。

.catch(): 用于捕获Promise链中任何地方发生的错误。

function fetchData() {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      const success = false; // 模拟请求失败
      if (success) {
        resolve("Data fetched successfully.");
      } else {
        reject(new Error("Failed to fetch data."));
      }
    }, 1000);
  });
}

fetchData()
  .then(data => {
    console.log("Data:", data);
  })
  .catch(error => {
    console.error("Error:", error.message);
  })
  .finally(() => {
    console.log("Fetch operation completed.");
  });

// 输出 (模拟请求失败):
// Error: Failed to fetch data.
// Fetch operation completed.

在上面的例子中，fetchData()函数返回一个Promise。如果Promise被拒绝（reject()被调用），则.catch()方法会捕获错误，并在控制台输出错误消息。.finally()方法会在Promise完成（无论是成功还是失败）后执行，用于清理操作。

在.then()中处理错误: .then()方法可以接受两个函数作为参数：一个用于处理成功的结果，另一个用于处理错误。
```
fetchData()
  .then(
    data => {
      console.log("Data:", data);
    },
    error => {
      console.error("Error:", error.message);
    }
  )
  .finally(() => {
    console.log("Fetch operation completed.");
  });
```
这种方式等价于使用.catch()，但在某些情况下，直接在.then()中处理错误可能更方便。

2. `async/await`中的异常处理

async/await是处理异步代码的更现代化的方式。可以使用try/catch块来捕获async函数中发生的异常。

async function fetchDataAsync() {
  try {
    const data = await new Promise((resolve, reject) => {
      setTimeout(() => {
        const success = false; // 模拟请求失败
        if (success) {
          resolve("Data fetched successfully.");
        } else {
          reject(new Error("Failed to fetch data."));
        }
      }, 1000);
    });
    console.log("Data:", data);
    return data; // Important: return the data to ensure correct execution
  } catch (error) {
    console.error("Error:", error.message);
    throw error; // Re-throw the error to propagate it further, if needed
  } finally {
    console.log("Fetch operation completed.");
  }
}

async function main() {
    try {
        const result = await fetchDataAsync();
        console.log("Result from fetchDataAsync:", result);
    } catch (error) {
        console.error("Error caught in main:", error.message);
    }
}

main();

// 输出 (模拟请求失败):
// Error: Failed to fetch data.
// Fetch operation completed.
// Error caught in main: Failed to fetch data.

在这个例子中，fetchDataAsync()函数使用async关键字定义，并使用await关键字等待Promise的解决。try/catch块用于捕获await操作可能抛出的异常。finally块用于在操作完成后执行清理操作。

重要提示: 在 async/await 结构中，如果 async 函数内部的 try/catch 块捕获到异常，并且没有重新抛出，那么调用该 async 函数的地方就不会感知到这个异常。因此，根据你的需求，你可能需要重新抛出异常，以便让调用者知道发生了错误。如果没有 return 在 try 块中，那么调用方会得到 undefined。确保从 try 块返回一个值，特别是在成功的情况下。

3. 全局异常处理

除了使用try/catch和Promise.catch()之外，还可以设置全局异常处理程序来捕获未处理的异常。这对于记录错误、向用户显示友好的错误消息或执行其他全局清理操作非常有用。

window.onerror: 用于捕获JavaScript代码中发生的未处理的错误。

window.onerror = function(message, source, lineno, colno, error) {
  console.error("Global error handler:", message, source, lineno, colno, error);
  // 可以选择阻止默认的错误处理行为
  return true;
};

// 触发一个未处理的错误
setTimeout(() => {
  throw new Error("Unhandled error!");
}, 100);

// 输出:
// Global error handler: Unhandled error! <anonymous> 25 7 Error: Unhandled error!

window.onunhandledrejection: 用于捕获未处理的Promise拒绝。

window.addEventListener('unhandledrejection', function(event) {
  console.error("Unhandled promise rejection:", event.reason);
  // 可以选择阻止默认的错误处理行为
  event.preventDefault();
});

// 触发一个未处理的 Promise 拒绝
Promise.reject(new Error("Unhandled rejection!"));

// 输出:
// Unhandled promise rejection: Error: Unhandled rejection!

注意: window.onunhandledrejection 需要调用 event.preventDefault() 来阻止默认的错误处理行为，例如在控制台中显示错误消息。

4. 错误处理策略的选择

选择哪种错误处理策略取决于具体的场景。一般来说：

使用try/catch块来处理你预期可能会发生的异常，例如文件读取错误、网络请求失败等。
使用Promise.catch()或async/await的try/catch块来处理异步操作中的错误。
使用全局异常处理程序来捕获未处理的异常，作为最后的防线。

各种场景下 `finally` 的作用

场景	`finally` 块的作用
文件操作	确保文件句柄被关闭，防止资源泄漏。例如，无论文件读取是否成功，都关闭文件流。
网络请求	清理资源，例如关闭网络连接、取消定时器等。即使请求失败，也执行清理操作，保持应用程序的稳定。
数据库连接	关闭数据库连接，释放连接资源。无论查询是否成功，都确保连接被正确关闭，防止连接池耗尽。
用户界面更新	隐藏加载指示器、启用按钮等。当异步操作完成时，无论成功与否，都更新UI状态，提供用户反馈。
锁的释放	释放锁，允许其他线程或进程访问共享资源。防止死锁或资源争用，确保并发操作的正确性。
事务处理	提交或回滚事务。根据操作结果，确保事务的一致性。
日志记录	记录操作完成状态。无论操作成功与否，都记录日志，方便调试和审计。
确保代码执行	无论 `try` 或 `catch` 块中发生什么，都必须执行的代码。例如，在函数退出前执行一些必要的清理工作。
覆盖 `try` 或 `catch` 块的返回值	当 `finally` 块包含 `return` 语句时，它会覆盖 `try` 或 `catch` 块中的返回值。这可以用于确保返回一个特定的值，无论之前发生了什么。

最佳实践

不要吞噬异常: 除非你完全理解异常的原因并知道如何处理它，否则不要简单地吞噬异常。吞噬异常会导致程序行为异常，难以调试。最好将异常记录下来或重新抛出，以便让上层代码或全局异常处理程序来处理它。
使用具体的错误类型: 尽可能使用具体的错误类型，例如TypeError、ReferenceError等，而不是笼统地使用Error。这可以让你更精确地识别和处理错误。
提供有用的错误消息: 在创建错误对象时，提供有用的错误消息，以便更容易地诊断问题。
使用日志记录: 使用日志记录工具来记录错误和其他重要的事件。这可以帮助你跟踪问题并进行调试。
保持try块尽可能小: try块应该只包含可能抛出异常的代码。这可以减少try/catch结构的开销，并提高代码的可读性。

结论：掌控 `finally` 的力量，提升代码的健壮性

通过今天的讨论，我们深入了解了JavaScript中try/catch异常处理机制，特别是finally块的执行时机和作用。我们还探讨了如何在异步代码中处理异常，并学习了一些最佳实践。掌握这些知识可以帮助我们编写更健壮、更可靠的JavaScript代码。

理解了 finally 块的执行时机和作用，并结合异步异常处理策略，可以写出更健壮和可维护的代码。记住，良好的错误处理是高质量代码的重要组成部分。

JavaScript的try/catch异常处理机制：深入finally块与异步异常处理

try/catch的基本结构

finally块的执行时机

异步代码中的异常处理

1. Promise中的异常处理

2. async/await中的异常处理