Flutter错误处理或增强插件error_or_plus的使用

Flutter错误处理或增强插件error_or_plus的使用

整理后的内容

1. 安装插件

   dart pub add error_or_plus
   

2. 替换抛出异常为ErrorOr<T>

double divide(int a, int b) {
  if (b == 0 ) {
    return Errors.unexpected(description: "Cannot divide by zero");
  }

  return a / b;
}

var result = divide(4, 2);

if (result.isError) {
  print(result.firstError.description);
  return;
}

print(result.value * 2); // 4

1. 支持多个错误

class User {
  final String _name;

  User._internal(this._name);

  static ErrorOr<User> create(String name) {
    List<Errors> errors = [];

    if (name.length < 2) {
      errors.add(Errors.validation(description: "Name is too short"));
    }

    if (name.length > 100) {
      errors.add(Errors.validation(description: "Name is too long"));
    }

    if (name.isEmpty) {
      errors.add(Errors.validation(
          description: "Name cannot be empty or whitespace only"));
    }

    if (errors.isNotEmpty) {
      return errors.toErrorOr<User>();
    }

    return User._internal(name).toErrorOr();
  }
}

1. 各种功能方法和扩展方法

2. 创建一个ErrorOr实例

ErrorOr<int> result = 5.ToErrorOr();
ErrorOr<int> result = Errors.unexpected().ToErrorOr<int>();
ErrorOr<int> result = [Errors.validation(), Errors.validation()].ToErrorOr<int>();

1. 属性

• isError

  if (result.isError {
    // 结果包含一个或多个错误
  }
  

• value

  if (!result.isError) { // 结果包含一个值
    print(result.value);
  }
  

• errors

  if (result.isError) {
    result.errors // 包含发生的所有错误
        .forEach((error) => print(error.description));
  }
  

• firstError

  if (result.isError) {
    var firstError = result.firstError; // 只有第一个发生的错误
    print(firstError == result.errors[0]); // true
  }
  

• errorsOrEmptyList

  if (result.isError) {
    result.errorsOrEmptyList // List<Errors> { /* 一个或多个错误 */ }
    return;
  }
  
  result.errorsOrEmptyList // List<Errors> { }
  

1. 方法

• match

  String foo = result.match(
      (value) => value,
      (errors) => "${errors.Count} errors occurred.");
  

• matchAsync

  String foo = await result.matchAsync(
      (value) => Future.value(value),
      (errors) => Future.value("${errors.Count} errors occurred."));
  

• matchFirst

  String foo = result.matchFirst(
      (value) => value,
      (firstError) => firstError.description);
  

• matchFirstAsync

  String foo = await result.matchFirstAsync(
      (value) => Future.value(value),
      (firstError) => Future.value(firstError.description));
  

• doSwitch

  result.doSwitch(
      (value) => print(value),
      (errors) => print("${errors.Count} errors occurred."));
  

• doSwitchAsync

  await result.doSwitchAsync(
      (value) { print(value); return Future.value(true); },
      (errors) { print("${errors.Count} errors occurred."); return Future.value(true); });
  

• doSwitchFirst

  result.doSwitchFirst(
      (value) => print(value),
      (firstError) => print(firstError.description));
  

• doSwitchFirstAsync

  await result.doSwitchFirstAsync(
      (value) { print(value); return Future.value(true); },
      (firstError) { print(firstError.description); return Future.value(true); });
  

• also

  ErrorOr<int> foo = result
      .also((val) => val * 2);
  

• alsoAsync

  ErrorOr<String> foo = await result
      .alsoAsync((val) => doSomethingAsync(val))
      .alsoAsync((val) => doSomethingElseAsync("The result is ${val}"));
  

• alsoDo

  ErrorOr<String> foo = result
      .alsoDo((val) => print(val))
      .alsoDo((val) => print("The result is ${val}");
  

• alsoDoAsync

  ErrorOr<String> foo = await result
      .alsoDoAsync((val) => Future.delayed(Duration(milliseconds: val)))
      .alsoDo((val) => print("Finsihed waiting ${val} seconds."))
      .alsoDoAsync((val) => Future.value(val * 2))
      .alsoDo((val) =&gt "The result is ${val}");
  

• failIf

  ErrorOr<int> foo = result
      .failIf((val) => val > 2, Errors.validation(description: "${val} is too big"));
  

• orElse

  ErrorOr<String> foo = result
      .orElse(valueOnErrorHandler: "fallback value");
  

• orelseAsync

  ErrorOr<String> foo = await result
      .orElseAsync(valueOnErrorHandler: Future.value("fallback value"));
  

• mixing also-also-do-alsoasync-alsoDoasync

  ErrorOr<String> foo = await result
      .alsoDoAsync((val) =&gt Future.delayed(Duration(milliseconds: val)))
      .failIf((val) => val > 2, Errors.validation(description: "${val} is too big"))
      .alsoDo((val) =&gt print("Finished waiting ${val} seconds."))
      .alsoAsync((val) =&gt Future.value(val * 2))
      .also((val) =&gt "The result is ${val}")
      .orElse(errorOnErrorHandler: (errors) =&gt Errors.unexpected())
      .matchFirst(
          (value) =&gt value,
          (firstError) =&gt "An error occurred: {firstError.description}");
  

1. 错误类型

每个Errors实例都有一个Type属性，它是一个枚举值，代表错误的类型。

1. 组织错误

一个很好的方法是创建一个静态类来组织预期的错误。例如：

class DivisionErrors {
  static Errors cannotdivideByZero = Errors.unexpected(
      code: "Division.CannotdivideByZero",
      description: "Cannot divide by zero.");
}

然后可以像这样使用：

public ErrorOr<double> divide(int a, int b) {
  if (b == 0 {
    return DivisionErrors.cannotdivideByZero;
  }

  return a / b;
}