虚中有实——try catch 的异步捕获

try-catch 原理：

try-catch 是一种异常处理机制，用于捕获和处理代码中可能抛出的异常。

• 当程序执行到 try 块时，会按照顺序执行其中的代码；
• 如果 try 块中的代码执行异常，程序会立即跳转到与 catch 关键字对应的 catch 块中执行；
• 在 catch 块中，可以对异常进行捕获和处理，比如打印错误信息、记录日志、或者进行一些恢复性操作；
• 如果 catch 块中的代码执行完毕，程序会继续执行 try-catch 块之后的代码；

Future 原理：

Future 是 Dart 中用于处理异步操作的关键字之一。当调用一个异步函数时，该函数会立即返回一个 Future 对象，表示异步操作的结果，异步对象可能是一个值，也可能是一个异常。Future 的主要使用场景包括：

1. 异步操作的结果表示：当需要执行一个耗时的操作，例如从网络获取数据、文件读写操作等，而不想阻塞当前线程时，就可以使用 Future 来表示这个异步操作的结果。通过 Future，我们可以在异步操作完成后获取到操作的结果，或者在操作失败时获取到错误信息。
2. 异步操作的串行化和并行化：通过 Future，我们可以将多个异步操作串行化或并行化执行，从而提高程序的性能和响应速度。例如，使用 Future.then() 方法可以在一个异步操作完成后执行另一个异步操作，或者使用 Future.wait() 方法可以等待多个异步操作全部完成后再进行下一步操作。
3. 异常处理：Future 也提供了异常处理的功能。当一个异步操作失败时，可以通过 catchError() 方法或 try-catch 块来捕获异常，并进行相应的处理。

Future 的原理主要是基于事件循环和回调机制。当一个异步操作被调用时，它会立即返回一个 Future 对象，表示该操作的结果。然后，异步操作会在后台执行，而不会阻塞当前线程。当操作完成时，会通知事件循环，并将操作的结果传递给对应的 Future 对象。这时，可以通过 Future 对象的方法来获取操作的结果或处理可能发生的异常。

总的来说，Future 关键字提供了一种便捷的方式来处理异步操作，使得程序可以更加高效地利用资源，并提高用户体验。

例子分析

void main() async {
    Future<dynamic> catchMethodA(Function executionMethod) async {
      return await executionMethod();
    }

    Future<dynamic> catchMethodB() async {
      print("catchMethodB executioned");
      throw Exception("catchMethodB throw Error");
    }

    try {
      var methodAResult = await catchMethodA(() {
        try {
          return catchMethodB();
        } catch (e) {
          print("catch a exception in catchMethodB");
        }
      });
      print("methodAResult=$methodAResult");
    } on Exception {
      print("catch a Exception in catchMethodA, it's main method");
    } on Error {
      print("catch a Error in catchMethodA, it's main method");
    }

}

提问：1、执行结果应该是什么2、为什么

print:

catchMethodB executioned
catch a exception in catchMethodA, it's main method

为什么：

内部函数catchMethodB执行前没有使用 await 进行同步处理，并不会等待异步操作完成，执行它将会立即返回一个 Future<dynamic> 对象。在这种情况下，第一次捕获的将是一个 Future<dynamic> 对象，而不是实际的异常。

这意味着外部 methodAResult 捕获的是一个未完成的 Future 对象，其结果值为异常。外部的 try-catch 块通过 await 关键字等待这个 Future 对象的完成，当异步操作完成后，该 Future 对象的状态将变为已完成，并且携带着异常的信息。捕获到了其中携带的异常信息。

让我们逐步分析这段代码的执行过程：

1. main 函数开始执行。
2. catchMethodA 函数被调用，传入一个匿名函数作为参数。
3. catchMethodA 函数内部执行传入的匿名函数，即执行以下代码：
4. 在匿名函数内部，catchMethodB 函数被调用。
5. catchMethodB 函数内部执行，并打印一条信息。
6. catchMethodB 函数抛出一个异常 Exception("catchMethodB Error")。
7. Exception("catchMethodB Error") 以 Future<dynamic> 对象返回给methodAResult 。
8. catchMethodA 函数接收到异常的 Future 对象，并立即返回给 main 函数。
9. main 函数中的 try-catch 块捕获到异常的 Future 对象，并执行 catch 块中的代码，打印一条信息 "catch a exception in catchMethodA, it's main method"。

因此，main 函数的执行结果是打印如下信息：

catchMethodB executioned
catch a exception in catchMethodA, it's main method

在给定的代码中，"catch a exception in catchMethodB" 没有被打印出来，这是因为异常并没有在 catchMethodB 函数内部被捕获。让我们仔细分析一下原因：

1. catchMethodB 函数内部没有显式的 try-catch 块来捕获可能抛出的异常;
2. 异常在 catchMethodB 函数内部抛出后， 以 Future<dynamic>返回会沿着调用栈向上层传播，直到找到一个可以捕获异常的 try-catch 块或直到程序终止;

因此，即使异常是在 catchMethodB 函数内部抛出，但实际上异常的处理是 main 进行的，所以 "catch a exception in catchMethodB" 没有被打印出来。

catch 的捕获项

或许到这里就结束了，但是还想进一步梳理下 catch 的捕获信息

常见异常的继承关系：

Exception
├─ ArgumentError
├─ FormatException
├─ RangeError
├─ StateError
└─ TypeError
Error
├─ AssertionError
├─ CastError
├─ ConcurrentModificationError
├─ FileSystemException
├─ HttpException
├─ NoSuchMethodError
├─ SocketException
└─ TimeoutException

Exception 与 Error

Exception 和 Error 都是用于表示程序中出现的问题的类，但它们在设计初衷和使用场景上存在一些差异：

1. Exception（异常）：设计初衷：Exception 类用于表示程序中的一般性错误或非预期情况。它通常表示由程序错误、无效参数、无效状态等引起的异常情况。使用场景：通常情况下，我们会在代码中显式地抛出 Exception 类或其子类的实例，来表示程序中的异常情况。在捕获异常时，我们可以选择捕获特定类型的 Exception 或捕获所有类型的异常（使用 catch (Exception e) 或 catch (e)）。
2. Error（错误）：设计初衷：Error 类用于表示程序中的错误情况，通常表示更严重的问题，如内存不足、堆栈溢出等。与 Exception 不同，Error 表示的是由于程序错误或系统错误导致的问题，而不是程序中的一般性异常情况。使用场景：通常情况下，Error 不应该被捕获和处理，而是应该由开发者解决并修复问题。如果程序中出现 Error，通常意味着存在严重的问题，可能会导致程序崩溃或无法继续运行。因此，我们不建议捕获 Error，而是应该尽量避免出现这些错误，或者在出现 Error 时及时停止程序并报告问题。

总的来说，Exception 和 Error 在设计初衷和使用场景上有所区别：Exception 主要用于表示程序中的一般性异常情况，而 Error 则表示更严重的问题，通常需要开发者进行处理和解决。在实际开发中，我们应该根据具体情况选择合适的异常类型，并采取适当的措施来处理和修复问题，以提高程序的健壮性和可靠性。

常的异常类型的使用场景：