搜索插件、代码仓与 APP 分类

插件详情v2.0.1

verify

验证变得简单。基于扩展的状态验证DSL。

AndroidiOSWebmacOSWindowsLinux
近 30 天下载
61
喜欢数
55
Pub 分数
140

安装插件

flutter pub add verify

插件介绍

基于插件公开信息、社区数据与项目使用情况整理的选型参考。

Verify 是一个 Flutter/Dart 包,通过直观的基于扩展的 DSL 简化表单和状态验证。它使开发者能够使用流畅的语法直接在数据类型上简洁地定义验证规则。该包支持可自定义的验证逻辑,并能无缝集成到现有工作流程中,无需编写样板代码。设计注重易用性,提升了跨多个平台的验证逻辑的可读性和可维护性。

适合场景

  • 表单输入验证
  • UI 组件中的状态验证
  • 实时用户反馈
  • 自定义验证规则
  • 跨平台验证
  • 简化复杂的验证逻辑

主要特点

  • 基于扩展的DSL
  • 最小化样板代码
  • 可链式调用的验证方法
  • 支持自定义验证器
  • 适用于所有 Flutter 平台
  • 与现有代码的轻松集成

适合对象

  • 寻求简单验证的开发者
  • 注重代码整洁的团队
  • 包含大量表单输入的应用程序
  • 面向多个平台的项目
  • 面向前端的 Flutter 应用程序

使用建议

  • 仅限基本验证模式
  • 无内置国际化支持
  • 需要了解 Dart 扩展
  • 不太适合高度动态的验证逻辑
  • 复杂场景可能需要额外的设置

原始 README

以下为关联源码仓库的 README 原文快照,最新内容请访问源码仓库。

Validations made simple

Build Status Pub Package Codecov MIT License

A fp inspired validation DSL. For Dart and Flutter projects.

Features

  • Completely extensible (create your own combinators, validator primitives, etc)
  • Flexible Verify is an extension based API (There is not single class created its all pure functions)
  • Customizable (Define you own error types if required) organize validators how ever you want
  • Bloc friendly (See examples for a concrete implementation)
  • Null safe (as a prerelease)

Usage

Creating validators

A Validator is just a simple function alias:

// One of 2 variats depending on wether the validated subject will be transformed into another type or not
typedef ValidatorT<S, T> = Either<List<dynamic>, T> Function(S subject);
typedef Validator<S> = Either<List<dynamic>, S> Function(S subject);

So you can create your own validator by just specifying a function for example:

final Validator<String> emailValidator = (String email) {
  return email.contains('@') ? Right(email) : Left('Bad email format')
};

Create simple validators from predicates

A simpler way is to use some of the built in helpers.

final contains@ = Verify.that(
  (String email) => email.contains('@'),
    error: 'Bad email format'
    );

Use custom errors and filter them by type

Reuse validators

Use composition to build up more complex validators.

final Validator<String> emailValidator = Verify.all([ contains@, notEmpty ])
Validate and transform

Validators are also capable of transforming their input, so for instance we can do parsing and validation in one go.

final Validator<String, int> intParsingValidator = (String str) => Right(int.parse(str));

final validator = intParsingValidator.onException((_) => Error('not an integer'));
Field validations

Given a model, for instance a user:

class User extends Equatable {
  final String? phone;
  final String? mail;
  final int? age;

  const User(this.phone, this.mail, this.age);

  @override
  List<Object> get props => [phone ?? '', mail ?? '', age ?? ''];
}

Additional checks can be performed on the object and its fields by chaining a series of check and checkField methods.

final userValidator = Verify.empty<User>()
    .check((user) => !user.phone!.isEmpty, error: Error('phone empty'))
    .checkField((user) => user.mail!, emailValidator);

final someUser = User('','', 25);
final Either<List<Error>, User> validationResult = userValidator.verify(someUser);

Note: The difference between check and checkField is that the later ignore the verification when the value is null, this will likely change in next version supporting null safety.

Run a validator

Running a validator is a simple as passing in a parameter since its just a function. To be a bit more eloquent a verify method is provided, this method is special because besides forwarding the argument to the calling validator it can also be used to filter the error list and have it cast to a specific error type. Just supply a specific type parameter.

final signUpValidation = Verify.subject<SignUpState>();
final errors = signUpValidation
    .verify<SignUpError>(newState); // Either<List<SignUpError>, SignUpState>
Built in validators

Verify doesn't come with many built in validators, because they are so simple to create.

It does come with some regex shorthands.

final validator = Verify.fromRegex(RegExp(r"(^\d+$)", error: Error('not just digits')) // Validator<String, int>
Form validation

Often times you will have modeled your error type similar to:

enum FormField {
  email,
  password,
  passwordConfirmation,
}

class SignUpError extends ValidationError {
  final String message;
  final FormField field;

  SignUpError(this.message, {required this.field});

  @override
  String get errorDescription => message;
}

In these scenarios its convenient to be able to group errors by field.

The solution verify provides for this is:

final validator = Verify.inOrder<SignUpFormState>([
  validateMail,
  validatePassword,
  validateConfirmation,
]);

final Map<FormField, SignUpError> errorMap = validator
    .verify<SignUpError>(someState)
    .errorsGroupedBy((error) => error.field);

Sequencing

A slightly different API can be used to achieve the same results as the inOrder composition function.

final numberValidator = Verify.subject<int>()
  .then(Verify.that(
    (subject) => subject % 2 == 0,
    error: Error('not even'),
  ))
  .then(Verify.that(
    (subject) => subject >= 10,
    error: Error('single digit'),
  ));

final errors2 = numberValidator.errors(3); // yields 1 error
final errors = numberValidator.errors(4); // yields 1 error

This way you have quick access to errors segmented by field.

所属分类

依赖

依赖清单 2 项

源码仓库

使用此插件的项目

暂无相关数据。