Flutter错误追踪插件failure_stack的使用

Flutter错误追踪插件failure_stack的使用

为什么使用failure_stack？

传统的错误处理方法（抛出和捕获异常）可能会导致不可预测的错误和行为。通过使用结果类型作为返回值，你可以确保处理每个可能发生的错误，从而降低程序出错的可能性。

你可能会问，我已经知道Result和Either类型很好用，但已经有dartz和fpdart这样的库了，为什么还要创建另一个库呢？上述提到的库在函数式编程方面非常出色，但在处理错误时，当你的程序变得更大且包含大量嵌套函数调用时，它们可能不是最佳选择。因此，在普通的Either类型之上，此包具有一些额外的功能：

1. 鼓励用户在作用域改变时提供新的错误类型，通常是在应用程序或第三方库的不同层之间传递（例如，ApiError用于基础设施层错误，InvalidInputError用于应用层）。
2. 能够附加任何额外数据到失败中。
3. 能够将失败推入堆栈并在稍后处理它们，同时仍然跟踪它们。

使用方法

假设我们有一个将String解析为int的函数，如果输入不是一个数字，则该函数可能会失败。

class ParsingFailure {} // 表示解析失败的错误

Result<int, ParsingFailure> parse(String numString);

当我们使用这个函数时，有三种处理结果的方式。

1. 当你不关心可能出现的失败时

// .ok 返回包含Ok值的结果，因为结果可能失败，所以它是一个可空类型。
int? result = parse(targetString).ok;

2. 穷尽匹配

switch (parse(targetString)) {
  case Ok<int, ParsingFailure> ok: {
    print("成功: ${ok.value}");
  },
  case Fail<int, ParsingFailure> fail: {
    print("失败: ${fail.failure}");
  }
}

3. 当你在返回Result类型的函数中时，使用resultHandleEnvironment代替。

警告：不要解包与失败类型不匹配的结果，使用Result.mapFail或Result.pushFail来更改失败类型。

Result<int, FormatException> parseString(String s) {
  try {
    return Ok(int.parse(s));
  } on FormatException catch (e) {
    Result<int, FormatException> r = e.intoFailure();
    return r.attach("解析 $s 到 int 失败");
  }
}

class ParseExperimentFailure {
  const ParseExperimentFailure();
  [@override](/user/override)
  String toString() {
    return "ParseExperimentFailure: 无效的实验输入";
  }
}

Result<List<int>, ParseExperimentFailure> parseExperiment(String input) {
  return resultHandleEnvironment(() {
    List<int> values = input
        .split(" ")
        .map((String s) => parseString(s))  // Result<int, FormatException>
        .map((Result<int, FormatException> result) =>
            result.pushFail(const ParseExperimentFailure())) // Result<int, ParseExperimentFailure>
        // 当结果为Ok时，解包为int，
        // 否则抛出ParseExperimentFailure并由resultHandleEnvironment捕获并返回为Fail(ParseExperimentFailure)
        .map((Result<int, ParseExperimentFailure> result) => result.unwrap()) // int
        .toList(growable: false);
    return Ok(values);
  });
}

将异常和错误转换为失败

使用intoFailure()扩展方法

Future<Result<(), DioException>> callApi() async {
  try {
    await dio.post(/*一些代码*/);
  } on DioException catch (e) {
    return e.intoFailure();
  }
}

完整示例

import 'package:failure_stack/failure_stack.dart';

Result<int, FormatException> parseString(String s) {
  try {
    return Ok(int.parse(s));
  } on FormatException catch (e) {
    Result<int, FormatException> r = e.intoFailure();
    return r.attach("解析 $s 到 int 失败");
  }
}

class ParseExperimentFailure {
  const ParseExperimentFailure();
  [@override](/user/override)
  String toString() {
    return "ParseExperimentFailure: 无效的实验输入";
  }
}

Result<List<int>, ParseExperimentFailure> parseExperiment(String input) {
  return resultHandleEnvironment(() {
    List<int> values = input
        .split(" ")
        .map((String e) => parseString(e))
        .map((Result<int, FormatException> e) =>
            e.pushFail(const ParseExperimentFailure()))
        .map((Result<int, ParseExperimentFailure> e) => e.unwrap())
        .toList(growable: false);
    return Ok(values);
  });
}

class ExperimentError {
  [@override](/user/override)
  String toString() {
    return "ExperimentError: 无法运行实验";
  }
}

Result<List<int>, ExperimentError> startExperiments(Map<int, String> inputs) {
  return resultHandleEnvironment(() {
    List<int> finalResults = [];

    inputs.entries.map((e) {
      return parseExperiment(e.value).pushFail(ExperimentError()).unwrap();
    }).forEach((element) => finalResults.addAll(element));

    return Ok(finalResults);
  });
}

void main() {
  final experimentsInput = {0: "1 5 6", 4: "4 5 6", 6: "3 5w"};

  switch (startExperiments(experimentsInput)) {
    case Ok ok:
      {
        print(ok.value);
      }
    case Fail fail:
      {
        print(fail.stack);
      }
  }
}