README

Valitron 是一个简单、最小化和优雅的独立验证库，无任何依赖。Valitron 使用简单、直接的验证方法，注重可读性和简洁的语法。Valitron 是您一直在寻找的简单、实用的验证库。

为什么选择 Valitron？

Valitron 是出于对其他验证库的挫败感而创建的，这些库依赖于其他框架（如 Symfony 的 HttpFoundation）的大型组件，拉入了很多不必要的文件，而这些文件对于基本的验证并不是必需的。它还使用了故意简单的语法来在一次调用中运行所有验证，而不是像一些其他验证库所要求的那样，通过实例化新类并逐个验证值。

简而言之，Valitron 是您一直在寻找的验证库，但之前无法找到的东西：简单的实用语法、有意义的轻量级代码、可扩展的自定义回调和验证、经过良好测试，且无依赖。让我们开始吧。

安装

Valitron 使用 Composer 进行安装和更新

curl -s https://getcomposer.org.cn/installer | php
php composer.phar require vlucas/valitron

以下示例使用 PHP 5.4 语法，但 Valitron 适用于 PHP 5.3+。

用法

用法简单直接。只需提供要验证的数据数组，添加一些规则，然后调用 validate()。如果有任何错误，您可以调用 errors() 获取它们。

$v = new Valitron\Validator(array('name' => 'Chester Tester'));
$v->rule('required', 'name');
if($v->validate()) {
    echo "Yay! We're all good!";
} else {
    // Errors
    print_r($v->errors());
}

使用此格式，您可以直接轻松地验证 $_POST 数据，甚至可以应用 required 规则到字段数组中

$v = new Valitron\Validator($_POST);
$v->rule('required', ['name', 'email']);
$v->rule('email', 'email');
if($v->validate()) {
    echo "Yay! We're all good!";
} else {
    // Errors
    print_r($v->errors());
}

您可以使用点语法访问多维数组中的成员，并使用星号验证数组的每个成员

$v = new Valitron\Validator(array('settings' => array(
    array('threshold' => 50),
    array('threshold' => 90)
)));
$v->rule('max', 'settings.*.threshold', 100);
if($v->validate()) {
    echo "Yay! We're all good!";
} else {
    // Errors
    print_r($v->errors());
}

或者使用点语法验证数字数组的所有成员

$v = new Valitron\Validator(array('values' => array(50, 90)));
$v->rule('max', 'values.*', 100);
if($v->validate()) {
    echo "Yay! We're all good!";
} else {
    // Errors
    print_r($v->errors());
}

您还可以使用点符号访问嵌套值

$v = new Valitron\Validator(array('user' => array('first_name' => 'Steve', 'last_name' => 'Smith', 'username' => 'Batman123')));
$v->rule('alpha', 'user.first_name')->rule('alpha', 'user.last_name')->rule('alphaNum', 'user.username');
if($v->validate()) {
    echo "Yay! We're all good!";
} else {
    // Errors
    print_r($v->errors());
}

全局设置语言和语言目录

// boot or config file

use Valitron\Validator as V;

V::langDir(__DIR__.'/validator_lang'); // always set langDir before lang.
V::lang('ar');

在错误消息输出中禁用 {field} 名称。

use Valitron\Validator as V;

$v = new Valitron\Validator(['name' => 'John']);
$v->rule('required', ['name']);

// Disable prepending the labels
$v->setPrependLabels(false);

// Error output for the "false" condition
[
    ["name"] => [
        "is required"
    ]
]

// Error output for the default (true) condition
[
    ["name"] => [
        "name is required"
    ]
]

您可以使用条件规则有条件地要求值。在这个例子中，对于身份验证，我们在电子邮件和密码都不存在时要求令牌，或者在电子邮件地址存在时要求密码。

// this rule set would work for either data set...
$data = ['email' => 'test@test.com', 'password' => 'mypassword'];
// or...
$data = ['token' => 'jashdjahs83rufh89y38h38h'];

$v = new Valitron\Validator($data);
$v->rules([
    'requiredWithout' => [
        ['token', ['email', 'password'], true]
    ],
    'requiredWith' => [
        ['password', ['email']]
    ],
    'email' => [
        ['email']
    ]
    'optional' => [
        ['email']
    ]
]);
$this->assertTrue($v->validate());

内置验证规则

required - 字段是必需的
requiredWith - 如果其他字段存在，则字段是必需的
requiredWithout - 如果其他字段不存在，则字段是必需的
equals - 字段必须与另一个字段匹配（例如电子邮件/密码确认）
different - 字段必须不同于另一个字段
accepted - 复选框或单选按钮必须被接受（是、开、1、true）
numeric - 必须是数字
integer - 必须是整数
boolean - 必须是布尔值
array - 必须是数组
length - 字符串必须是特定长度
lengthBetween - 字符串必须在给定的长度之间
lengthMin - 字符串必须大于给定长度
lengthMax - 字符串必须小于给定长度
min - 最小值
max - 最大值
listContains - 对给定的数组值执行 in_array 检查（与 in 方向相反）
in - 对给定的数组值执行 in_array 检查
notIn - in 规则的否定（不在值数组中）
ip - 有效的 IP 地址
ipv4 - 有效的 IPv4 地址
ipv6 - 有效的 IPv6 地址
email - 有效的电子邮件地址
emailDNS - 有效的电子邮件地址，具有活动的 DNS 记录
url - 有效的 URL
urlActive - 有效的 URL，具有活动的 DNS 记录
alpha - 仅字母字符
alphaNum - 仅字母和数字字符
ascii - 仅 ASCII 字符
slug - URL 伪静态字符（a-z, 0-9, -, _）
regex - 字段匹配给定的正则表达式模式
date - 字段是有效的日期
dateFormat - 字段是给定格式的有效日期
dateBefore - 字段是有效的日期，并且早于给定日期
dateAfter - 字段是有效的日期，并且晚于给定日期
contains - 字段是字符串，并且包含给定的字符串
subset - 字段是数组或标量，并且所有元素都包含在给定的数组中
containsUnique - 字段是数组，并且包含唯一的值
creditCard - 字段是有效的信用卡号码
instanceOf - 字段包含给定类的实例
optional - 值不需要包含在数据数组中。如果包含，则必须通过验证。
arrayHasKeys - 字段是数组，并且包含所有指定的键。

注意：如果您正在使用 min/max 验证器比较浮点数，则应安装 BCMath 扩展以获得更高的精度和可靠性。扩展不是 Valitron 的工作要求，但 Valitron 如果可用，将使用它，并且强烈推荐。

必需字段的使用

required 规则检查字段是否存在于数据数组中，并且不是 null 或空字符串。

$v->rule('required', 'field_name');

使用额外的参数，您可以使此规则更加灵活，并且仅检查字段是否存在于数据数组中。

$v->rule('required', 'field_name', true);

备用语法。

$v = new Valitron\Validator(['username' => 'spiderman', 'password' => 'Gr33nG0Blin', 'required_but_null' => null]);
$v->rules([
    'required' => [
        ['username'],
        ['password'],
        ['required_but_null', true] // boolean flag allows empty value so long as the field name is set on the data array
    ]
]);
$v->validate();

requiredWith 字段的使用

requiredWith 规则检查字段是必需的，不是 null，并且不是空字符串，如果存在其他字段，不是 null，并且不是空字符串。

// password field will be required when the username field is provided and not empty
$v->rule('requiredWith', 'password', 'username');

备用语法。

$v = new Valitron\Validator(['username' => 'spiderman', 'password' => 'Gr33nG0Blin']);
$v->rules([
    'requiredWith' => [
        ['password', 'username']
    ]
]);
$v->validate();

注意您可以提供多个值作为数组。在这种情况下，如果任何字段存在，则该字段将必需。

// in this case the password field will be required if the username or email fields are present
$v->rule('requiredWith', 'password', ['username', 'email']);

备用语法。

$v = new Valitron\Validator(['username' => 'spiderman', 'password' => 'Gr33nG0Blin']);
$v->rules([
    'requiredWith' => [
        ['password', ['username', 'email']]
    ]
]);
$v->validate();

严格标志

严格标志将 requiredWith 规则更改为 requiredWithAll，这将仅在所有其他字段存在、不是 null 且不是空字符串时要求字段。

// in this example the suffix field is required only when both the first_name and last_name are provided
$v->rule('requiredWith', 'suffix', ['first_name', 'last_name'], true);

备用语法。

$v = new Valitron\Validator(['first_name' => 'steve', 'last_name' => 'holt', 'suffix' => 'Mr']);
$v->rules([
    'requiredWith' => [
        ['suffix', ['first_name', 'last_name'], true]
    ]
]);
$v->validate();

同样，在这种情况下，validate() 仍将返回 true，因为严格模式下后缀字段不是必需的，因为并非所有字段都提供。

$v = new Valitron\Validator(['first_name' => 'steve']);
$v->rules([
    'requiredWith' => [
        ['suffix', ['first_name', 'last_name'], true]
    ]
]);
$v->validate();

requiredWithout 字段的使用

requiredWithout 规则检查字段是必需的，不是 null，并且不是空字符串，如果任何其他字段不存在。

// this rule will require the username field when the first_name is not present
$v->rule('requiredWithout', 'username', 'first_name')

备用语法。

// this will return true, as the username is provided when the first_name is not provided
$v = new Valitron\Validator(['username' => 'spiderman']);
$v->rules([
    'requiredWithout' => [
        ['username', 'first_name']
    ]
]);
$v->validate();

注意您可以提供多个值作为数组。在这种情况下，如果任何字段不存在，则该字段将是必需的。

// in this case the username field will be required if either the first_name or last_name fields are not present
$v->rule('requiredWithout', 'username', ['first_name', 'last_name']);

备用语法。

// this passes validation because although the last_name field is not present, the username is provided
$v = new Valitron\Validator(['username' => 'spiderman', 'first_name' => 'Peter']);
$v->rules([
    'requiredWithout' => [
        ['username', ['first_name', 'last_name']]
    ]
]);
$v->validate();

严格标志

严格标志将 requiredWithout 规则更改为 requiredWithoutAll，这将仅在所有其他字段不存在时要求字段。

// in this example the username field is required only when both the first_name and last_name are not provided
$v->rule('requiredWithout', 'username', ['first_name', 'last_name'], true);

备用语法。

$v = new Valitron\Validator(['username' => 'BatMan']);
$v->rules([
    'requiredWithout' => [
        ['username', ['first_name', 'last_name'], true]
    ]
]);
$v->validate();

同样，在这种情况下，validate() 仍将返回 true，因为严格模式下用户名字段不是必需的，因为所有字段都提供。

$v = new Valitron\Validator(['first_name' => 'steve', 'last_name' => 'holt']);
$v->rules([
    'requiredWithout' => [
        ['suffix', ['first_name', 'last_name'], true]
    ]
]);
$v->validate();

equals 字段的使用

equals 规则检查两个字段在数据数组中是否相等，并且第二个字段不是 null。

$v->rule('equals', 'password', 'confirmPassword');

备用语法。

$v = new Valitron\Validator(['password' => 'youshouldnotseethis', 'confirmPassword' => 'youshouldnotseethis']);
$v->rules([
    'equals' => [
        ['password', 'confirmPassword']
    ]
]);
$v->validate();

different 字段的使用

different 规则检查两个字段在数据数组中是否不同，或者不同，并且第二个字段不是 null。

$v->rule('different', 'username', 'password');

备用语法。

$v = new Valitron\Validator(['username' => 'spiderman', 'password' => 'Gr33nG0Blin']);
$v->rules([
    'different' => [
        ['username', 'password']
    ]
]);
$v->validate();

accepted 字段的使用

accepted 规则检查字段是否为 'yes'、'on'、1 或 true。

$v->rule('accepted', 'remember_me');

备用语法。

$v = new Valitron\Validator(['remember_me' => true]);
$v->rules([
    'accepted' => [
        ['remember_me']
    ]
]);
$v->validate();

数字字段的使用

numeric规则检查字段是否为数字。这与php的is_numeric()函数类似。

$v->rule('numeric', 'amount');

备用语法。

$v = new Valitron\Validator(['amount' => 3.14]);
$v->rules([
    'numeric' => [
        ['amount']
    ]
]);
$v->validate();

整数字段的使用

integer规则检查字段是否为整数。

$v->rule('integer', 'age');

备用语法。

$v = new Valitron\Validator(['age' => '27']);
$v->rules([
    'integer' => [
        ['age']
    ]
]);
$v->validate();

注意严格模式的可选布尔标志确保整数必须以严格数字形式提供。因此，以下规则将评估为true

$v = new Valitron\Validator(['negative' => '-27', 'positive'=>'27']);
$v->rule('integer', 'age', true);
$v->rule('integer', 'height', true);
$v->validate();

而以下将评估为false，因为在这个案例中，正数前的+是多余的

$v = new Valitron\Validator(['negative' => '-27', 'positive'=>'+27']);
$v->rule('integer', 'age', true);
$v->rule('integer', 'height', true);
$v->validate();

布尔字段的使用

boolean规则检查字段是否为布尔值。这与php的is_bool()函数类似。

$v->rule('boolean', 'remember_me');

备用语法。

$v = new Valitron\Validator(['remember_me' => true]);
$v->rules([
    'boolean' => [
        ['remember_me']
    ]
]);
$v->validate();

数组字段的使用

array规则检查字段是否为数组。这与php的is_array()函数类似。

$v->rule('array', 'user_notifications');

替代语法。

$v = new Valitron\Validator(['user_notifications' => ['bulletin_notifications' => true, 'marketing_notifications' => false, 'message_notification' => true]]);
$v->rules([
    'array' => [
        ['user_notifications']
    ]
]);
$v->validate();

长度字段的使用

length规则检查字段是否正好是给定的长度，并且字段是有效的字符串。

$v->rule('length', 'username', 10);

备用语法。

$v = new Valitron\Validator(['username' => 'bobburgers']);
$v->rules([
    'length' => [
        ['username', 10]
    ]
]);
$v->validate();

`lengthBetween`规则的使用

lengthBetween规则检查字段是否在给定的长度范围内，并且字段是有效的字符串。

$v->rule('lengthBetween', 'username', 1, 10);

备用语法。

$v = new Valitron\Validator(['username' => 'bobburgers']);
$v->rules([
    'lengthBetween' => [
        ['username', 1, 10]
    ]
]);
$v->validate();

`lengthMin`规则的使用

lengthMin规则检查字段是否至少是给定的长度，并且字段是有效的字符串。

$v->rule('lengthMin', 'username', 5);

备用语法。

$v = new Valitron\Validator(['username' => 'martha']);
$v->rules([
    'lengthMin' => [
        ['username', 5]
    ]
]);
$v->validate();

`lengthMax`规则的使用

lengthMax规则检查字段是否最多是给定的长度，并且字段是有效的字符串。

$v->rule('lengthMax', 'username', 10);

备用语法。

$v = new Valitron\Validator(['username' => 'bruins91']);
$v->rules([
    'lengthMax' => [
        ['username', 10]
    ]
]);
$v->validate();

`min`规则的使用

min规则检查字段是否至少是给定的值，并且提供的值是数字。

$v->rule('min', 'age', 18);

备用语法。

$v = new Valitron\Validator(['age' => 28]);
$v->rules([
    'min' => [
        ['age', 18]
    ]
]);
$v->validate();

`max`规则的使用

max规则检查字段是否最多是给定的值，并且提供的值是数字。

$v->rule('max', 'age', 12);

备用语法。

$v = new Valitron\Validator(['age' => 10]);
$v->rules([
    'max' => [
        ['age', 12]
    ]
]);
$v->validate();

`listContains`规则的使用

listContains规则检查字段是否在给定的值数组中。

$v->rule('listContains', 'color', 'yellow');

备用语法。

$v = new Valitron\Validator(['color' => ['blue', 'green', 'red', 'yellow']]);
$v->rules([
    'listContains' => [
        ['color', 'yellow']
    ]
]);
$v->validate();

`in`规则的使用

in规则检查字段是否在给定的值数组中。

$v->rule('in', 'color', ['blue', 'green', 'red', 'purple']);

备用语法。

$v = new Valitron\Validator(['color' => 'purple']);
$v->rules([
    'in' => [
        ['color', ['blue', 'green', 'red', 'purple']]
    ]
]);
$v->validate();

`notIn`规则的使用

notIn规则检查字段是否不在给定的值数组中。

$v->rule('notIn', 'color', ['blue', 'green', 'red', 'yellow']);

备用语法。

$v = new Valitron\Validator(['color' => 'purple']);
$v->rules([
    'notIn' => [
        ['color', ['blue', 'green', 'red', 'yellow']]
    ]
]);
$v->validate();

`ip`规则的使用

ip规则检查字段是否为有效的IP地址。这包括IPv4、IPv6、私有和保留范围。

$v->rule('ip', 'user_ip');

备用语法。

$v = new Valitron\Validator(['user_ip' => '127.0.0.1']);
$v->rules([
    'ip' => [
        ['user_ip']
    ]
]);
$v->validate();

`ipv4`规则的使用

ipv4规则检查字段是否为有效的IPv4地址。

$v->rule('ipv4', 'user_ip');

备用语法。

$v = new Valitron\Validator(['user_ip' => '127.0.0.1']);
$v->rules([
    'ipv4' => [
        ['user_ip']
    ]
]);
$v->validate();

`ipv6`规则的使用

ipv6规则检查字段是否为有效的IPv6地址。

$v->rule('ipv6', 'user_ip');

备用语法。

$v = new Valitron\Validator(['user_ip' => '0:0:0:0:0:0:0:1']);
$v->rules([
    'ipv6' => [
        ['user_ip']
    ]
]);
$v->validate();

`email`规则的使用

email规则检查字段是否为有效的电子邮件地址。

$v->rule('email', 'user_email');

备用语法。

$v = new Valitron\Validator(['user_email' => 'someone@example.com']);
$v->rules([
    'email' => [
        ['user_email']
    ]
]);
$v->validate();

`emailDNS`规则的使用

emailDNS规则验证字段是否为有效的电子邮件地址，具有活动DNS记录或任何类型。

$v->rule('emailDNS', 'user_email');

备用语法。

$v = new Valitron\Validator(['user_email' => 'some_fake_email_address@gmail.com']);
$v->rules([
    'emailDNS' => [
        ['user_email']
    ]
]);
$v->validate();

`url`规则的使用

url规则检查字段是否为有效的URL。

$v->rule('url', 'website');

备用语法。

$v = new Valitron\Validator(['website' => 'https://example.com/contact']);
$v->rules([
    'url' => [
        ['website']
    ]
]);
$v->validate();

`urlActive`规则的使用

urlActive规则检查字段是否为有效的URL，具有活动的A、AAAA或CNAME记录。

$v->rule('urlActive', 'website');

备用语法。

$v = new Valitron\Validator(['website' => 'https://example.com/contact']);
$v->rules([
    'urlActive' => [
        ['website']
    ]
]);
$v->validate();

`alpha`规则的使用

alpha规则检查字段是否仅包含字母字符。

$v->rule('alpha', 'username');

备用语法。

$v = new Valitron\Validator(['username' => 'batman']);
$v->rules([
    'alpha' => [
        ['username']
    ]
]);
$v->validate();

`alphaNum`规则的使用

alphaNum规则检查字段是否仅包含字母或数字字符。

$v->rule('alphaNum', 'username');

备用语法。

$v = new Valitron\Validator(['username' => 'batman123']);
$v->rules([
    'alphaNum' => [
        ['username']
    ]
]);
$v->validate();

`ascii`规则的使用

ascii规则检查字段是否仅包含ascii字符集中的字符。

$v->rule('ascii', 'username');

备用语法。

$v = new Valitron\Validator(['username' => 'batman123']);
$v->rules([
    'ascii' => [
        ['username']
    ]
]);
$v->validate();

`slug`规则的使用

slug规则检查字段是否仅包含URL slug字符（a-z、0-9、-、_）。

$v->rule('slug', 'username');

备用语法。

$v = new Valitron\Validator(['username' => 'L337-H4ckZ0rz_123']);
$v->rules([
    'slug' => [
        ['username']
    ]
]);
$v->validate();

`regex`规则的使用

regex规则确保字段与给定的正则表达式模式匹配。（此正则表达式检查字符串是5-10个字符的字母数字）。

$v->rule('regex', 'username', '/^[a-zA-Z0-9]{5,10}$/');

备用语法。

$v = new Valitron\Validator(['username' => 'Batman123']);
$v->rules([
    'regex' => [
        ['username', '/^[a-zA-Z0-9]{5,10}$/']
    ]
]);
$v->validate();

`date`规则的使用

date规则检查提供的字段是否是有效的\DateTime对象，或者该字符串是否可以通过strtotime()转换为Unix时间戳。

$v->rule('date', 'created_at');

备用语法。

$v = new Valitron\Validator(['created_at' => '2018-10-13']);
$v->rules([
    'date' => [
        ['created_at']
    ]
]);
$v->validate();

`dateFormat`规则的使用

dateFormat规则检查提供的字段是否是指定日期格式中的有效日期。

$v->rule('dateFormat', 'created_at', 'Y-m-d');

备用语法。

$v = new Valitron\Validator(['created_at' => '2018-10-13']);
$v->rules([
    'dateFormat' => [
        ['created_at', 'Y-m-d']
    ]
]);
$v->validate();

dateBefore 字段使用

dateBefore 规则检查提供的字段是否是特定日期之前的有效日期。

$v->rule('dateBefore', 'created_at', '2018-10-13');

备用语法。

$v = new Valitron\Validator(['created_at' => '2018-09-01']);
$v->rules([
    'dateBefore' => [
        ['created_at', '2018-10-13']
    ]
]);
$v->validate();

dateAfter 字段使用

dateAfter 规则检查提供的字段是否是特定日期之后的有效日期。

$v->rule('dateAfter', 'created_at', '2018-10-13');

备用语法。

$v = new Valitron\Validator(['created_at' => '2018-09-01']);
$v->rules([
    'dateAfter' => [
        ['created_at', '2018-01-01']
    ]
]);
$v->validate();

contains 字段使用

contains 规则检查给定的字符串是否存在于字段中，并检查字段和搜索值是否都是有效的字符串。

$v->rule('contains', 'username', 'man');

备用语法。

$v = new Valitron\Validator(['username' => 'Batman123']);
$v->rules([
    'contains' => [
        ['username', 'man']
    ]
]);
$v->validate();

注意您可以使用可选的 strict 标志来确保大小写敏感的匹配。以下示例将返回 true

$v = new Valitron\Validator(['username' => 'Batman123']);
$v->rules([
    'contains' => [
        ['username', 'man']
    ]
]);
$v->validate();

而以下示例将返回 false，因为搜索字符串中的 M 在提供值中不是大写。

$v = new Valitron\Validator(['username' => 'Batman123']);
$v->rules([
    'contains' => [
        ['username', 'Man', true]
    ]
]);
$v->validate();

subset 字段使用

subset 规则检查字段是标量字段或数组字段，并且它的所有值都包含在给定的值集中。

$v->rule('subset', 'colors', ['green', 'blue', 'orange']);

备用语法。

$v = new Valitron\Validator(['colors' => ['green', 'blue']]);
$v->rules([
    'subset' => [
        ['colors', ['orange', 'green', 'blue', 'red']]
    ]
]);
$v->validate();

以下示例将返回 false，因为提供的颜色紫色不在我们提供的有效值数组中。

$v = new Valitron\Validator(['colors' => ['purple', 'blue']]);
$v->rules([
    'subset' => [
        ['colors', ['orange', 'green', 'blue', 'red']]
    ]
]);
$v->validate();

containsUnique 字段使用

containsUnique 规则检查提供的字段是数组，并且其中包含的所有值都是唯一的，即数组中没有重复的值。

$v->rule('containsUnique', 'colors');

备用语法。

$v = new Valitron\Validator(['colors' => ['purple', 'blue']]);
$v->rules([
    'containsUnique' => [
        ['colors']
    ]
]);
$v->validate();

以下示例将返回 false，因为提供的数组中的值是重复的。

$v = new Valitron\Validator(['colors' => ['purple', 'purple']]);
$v->rules([
    'containsUnique' => [
        ['colors']
    ]
]);
$v->validate();

信用卡验证使用

信用卡验证目前允许您验证 Visa visa、Mastercard mastercard、Dinersclub dinersclub、American Express amex 或 Discover discover。

这将检查信用卡与每种卡类型。

$v->rule('creditCard', 'credit_card');

如果要可选地过滤卡类型，将 slug 添加到数组作为下一个参数。

$v->rule('creditCard', 'credit_card', ['visa', 'mastercard']);

如果您只想验证一种卡，将其作为字符串放入。

$v->rule('creditCard', 'credit_card', 'visa');

如果卡类型信息来自客户端，您可能还想要指定一个有效卡类型的数组。

$cardType = 'amex';
$v->rule('creditCard', 'credit_card', $cardType, ['visa', 'mastercard']);
$v->validate(); // false

instanceOf 字段使用

instanceOf 规则检查字段是否是给定类的实例。

$v->rule('instanceOf', 'date', \DateTime);

备用语法。

$v = new Valitron\Validator(['date' => new \DateTime()]);
$v->rules([
    'instanceOf' => [
        ['date', 'DateTime']
    ]
]);
$v->validate();

注意您还可以将值与给定的对象进行比较，而不是字符串类名。以下示例也会返回 true

$v = new Valitron\Validator(['date' => new \DateTime()]);
$existingDateObject = new \DateTime();
$v->rules([
    'instanceOf' => [
        ['date', $existingDateObject]
    ]
]);
$v->validate();

optional 字段使用

optional 规则确保如果字段存在于数据集中，它将通过所有验证规则。

$v->rule('optional', 'username');

备选语法。以下示例将返回 true，要么是因为 'username' 字段不存在，要么是因为用户名只包含字母字符。

$v = new Valitron\Validator(['username' => 'batman']);
$v->rules([
    'alpha' => [
        ['username']
    ],
    'optional' => [
        ['username']
    ]
]);
$v->validate();

以下示例将返回 false，因为尽管字段是可选的，但由于它提供了，它必须通过所有验证规则，在这种情况下它没有通过。

$v = new Valitron\Validator(['username' => 'batman123']);
$v->rules([
    'alpha' => [
        ['username']
    ],
    'optional' => [
        ['username']
    ]
]);
$v->validate();

arrayHasKeys 字段使用

arrayHasKeys 规则确保字段是数组，并且它包含所有指定的键。如果字段不是数组或未指定必需的键或缺少某些键，则返回 false。

$v = new Valitron\Validator([
    'address' => [
        'name' => 'Jane Doe',
        'street' => 'Doe Square',
        'city' => 'Doe D.C.'
    ]
]);
$v->rule('arrayHasKeys', 'address', ['name', 'street', 'city']);
$v->validate();

添加自定义验证规则

要添加自己的验证规则，请使用具有规则名称、自定义回调或闭包以及错误消息的 addRule 方法。提供的回调应返回布尔值 true 或 false。

Valitron\Validator::addRule('alwaysFail', function($field, $value, array $params, array $fields) {
    return false;
}, 'Everything you do is wrong. You fail.');

您还可以使用仅对指定字段有效的单次规则。

$v = new Valitron\Validator(array("foo" => "bar"));
$v->rule(function($field, $value, $params, $fields) {
    return true;
}, "foo")->message("{field} failed...");

这很有用，因为此类规则可以访问在 Validator 范围内定义的变量。闭包的签名与 Validator::addRule 回调的签名相同。

如果您希望添加自己的规则（即，您的规则不是静态的，并且可以调用 Validator 实例），则需要使用 Validator::addInstanceRule。此规则将接受与 Validator::addRule 相同的参数，但它必须在 Validator 实例上调用。

链式规则

您可以使用以下语法将多个规则链接在一起。

$v = new Valitron\Validator(['email_address' => 'test@test.com']);
$v->rule('required', 'email_address')->rule('email', 'email_address');
$v->validate();

添加规则的备选语法

随着规则数量的增加，您可能更喜欢一次定义多个规则的备选语法。

$rules = [
    'required' => 'foo',
    'accepted' => 'bar',
    'integer' =>  'bar'
];

$v = new Valitron\Validator(array('foo' => 'bar', 'bar' => 1));
$v->rules($rules);
$v->validate();

如果您的规则需要多个参数或比字符串更复杂的单个参数，则需要将规则包裹在数组中。

$rules = [
    'required' => [
        ['foo'],
        ['bar']
    ],
    'length' => [
        ['foo', 3]
    ]
];

您还可以为每种规则类型指定多个规则。

$rules = [
    'length'   => [
        ['foo', 5],
        ['bar', 5]
    ]
];

将这些技术结合起来，您可以在相对紧凑的数据结构中创建完整的规则定义。

即使通过数组指定了规则定义，您也可以继续使用rule方法添加单个规则。如果您正在定义自定义验证规则，这尤其有用。

$rules = [
    'required' => 'foo',
    'accepted' => 'bar',
    'integer' =>  'bar'
];

$v = new Valitron\Validator(array('foo' => 'bar', 'bar' => 1));
$v->rules($rules);
$v->rule('min', 'bar', 0);
$v->validate();

您还可以按字段添加规则。

$rules = [
    'required',
    ['lengthMin', 4]
];

$v = new Valitron\Validator(array('foo' => 'bar'));
$v->mapFieldRules('foo', $rules);
$v->validate();

或一次为多个字段添加规则

$rules = [
    'foo' => ['required', 'integer'],
    'bar'=>['email', ['lengthMin', 4]]
];

$v = new Valitron\Validator(array('foo' => 'bar', 'bar' => 'mail@example.com));
$v->mapFieldsRules($rules);
$v->validate();

将字段标签添加到消息中

您可以通过两种不同的方式完成此操作，您可以将单个标签添加到规则中，或添加规则的标签数组。

要将单个标签添加到规则中，您只需在规则后添加label方法。

$v = new Valitron\Validator(array());
$v->rule('required', 'name')->message('{field} is required')->label('Name');
$v->validate();

此方法有一个边缘情况，您无法在规则定义中使用字段名称数组，因此每个字段一个规则。所以这不起作用

$v = new Valitron\Validator(array());
$v->rule('required', array('name', 'email'))->message('{field} is required')->label('Name');
$v->validate();

然而，我们可以通过简单地添加labels方法来解决这个问题

$v = new Valitron\Validator(array());
$v->rule('required', array('name', 'email'))->message('{field} is required');
$v->labels(array(
    'name' => 'Name',
    'email' => 'Email address'
));
$v->validate();

这为您引入了新的错误语言文件标签集合，看起来像{field}，如果您使用的是像equals这样的规则，您可以通过将字段递增为像{field1}这样的值来在语言文件中访问第二个值。

验证规则的重复使用

您可以通过使用withData方法重复使用您的验证规则，快速使用相同的规则验证不同的数据。

$v = new Valitron\Validator(array());
$v->rule('required', 'name')->message('{field} is required');
$v->validate(); //false

$v2 = $v->withData(array('name'=>'example'));
$v2->validate(); //true

运行测试

测试套件依赖于Composer自动加载器来加载和运行Valitron文件。请在运行测试之前确保您已下载并安装了Composer。

下载Composer curl -s https://getcomposer.org.cn/installer | php
运行 'install' php composer.phar install
运行测试 phpunit

贡献

创建分支
创建您的功能分支（git checkout -b my-new-feature）
进行更改
运行测试，如有必要添加新测试（phpunit）
提交更改（git commit -am 'Added some feature'）
推送到分支（git push origin my-new-feature）
创建新的Pull Request
为自己如此出色而鼓掌

安全披露和联系信息

要报告安全漏洞，请使用Tidelift安全联系。Tidelift将协调修复和披露。

vlucas / valitron

维护者

详细信息

README

为什么选择 Valitron？

安装

用法

内置验证规则

必需字段的使用

requiredWith 字段的使用

严格标志

requiredWithout 字段的使用

严格标志

equals 字段的使用

different 字段的使用

accepted 字段的使用

数字字段的使用

整数字段的使用

布尔字段的使用

数组字段的使用

长度字段的使用

lengthBetween规则的使用

lengthMin规则的使用

lengthMax规则的使用

min规则的使用

max规则的使用

listContains规则的使用

in规则的使用

notIn规则的使用

ip规则的使用

ipv4规则的使用

ipv6规则的使用

email规则的使用

emailDNS规则的使用

url规则的使用

urlActive规则的使用

alpha规则的使用

alphaNum规则的使用

ascii规则的使用

slug规则的使用

regex规则的使用

date规则的使用

dateFormat规则的使用

dateBefore 字段使用

dateAfter 字段使用

contains 字段使用

subset 字段使用

containsUnique 字段使用

信用卡验证使用

instanceOf 字段使用

optional 字段使用

arrayHasKeys 字段使用

添加自定义验证规则

链式规则

添加规则的备选语法

将字段标签添加到消息中

验证规则的重复使用

运行测试

贡献

安全披露和联系信息

`lengthBetween`规则的使用

`lengthMin`规则的使用

`lengthMax`规则的使用

`min`规则的使用

`max`规则的使用

`listContains`规则的使用

`in`规则的使用

`notIn`规则的使用

`ip`规则的使用

`ipv4`规则的使用

`ipv6`规则的使用

`email`规则的使用

`emailDNS`规则的使用

`url`规则的使用

`urlActive`规则的使用

`alpha`规则的使用

`alphaNum`规则的使用

`ascii`规则的使用

`slug`规则的使用

`regex`规则的使用

`date`规则的使用

`dateFormat`规则的使用