valitron

Valitron：简单的验证，但并不糟糕

Valitron 是一个简单、最小且优雅的独立验证库，没有依赖项。 Valitron 使用简单、直接的验证方法，重点关注可读且简洁的语法。 Valitron 是您一直在寻找的简单实用的验证库。

通过 Tidelift 订阅获得支持的 vlucas/valitron

为什么是Valitron？

Valitron 的创建是出于对其他验证库的不满，这些验证库依赖于 Symfony 的 HttpFoundation 等其他框架的大型组件，从而引入了大量基本验证并不真正需要的额外文件。它还具有特意简单的语法，用于在一次调用中运行所有验证，而不是像其他验证库所要求的那样，通过实例化新类并一次验证一个值来单独验证每个值。

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

安装

Valitron 使用 Composer 来安装和更新：

 curl -s http://getcomposer.org/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 ' => ' [email protected] ' , ' 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 - 必须接受复选框或单选框（yes、on、1、true）
• numeric - 必须是数字
• integer - 必须是整数
• boolean - 必须是布尔值
• array - 必须是数组
• length - 字符串必须有一定的长度
• lengthBetween - 字符串必须在给定长度之间
• lengthMin - 字符串必须大于给定长度
• lengthMax - 字符串必须小于给定长度
• min - 最小值
• max - 最大
• listContains - 对给定数组值执行 in_array 检查（与in相反）
• in - 对给定数组值执行 in_array 检查
• notIn - in in的否定（不在值数组中）
• ip - 有效的 IP 地址
• ipv4 - 有效的 IP v4 地址
• ipv6 - 有效的 IPv6 地址
• email - 有效的电子邮件地址
• emailDNS - 具有活动 DNS 记录的有效电子邮件地址
• url - 有效的 URL
• urlActive - 具有活动 DNS 记录的有效 URL
• alpha - 仅字母字符
• alphaNum - 仅字母和数字字符
• ascii - 仅 ASCII 字符
• slug - URL slug 字符（az、0-9、-、_）
• regex - 字段与给定的正则表达式模式匹配
• date - 字段是有效日期
• dateFormat - 字段是给定格式的有效日期
• dateBefore - 字段是有效日期并且在给定日期之前
• dateAfter - 字段是有效日期并且在给定日期之后
• contains - 字段是一个字符串并且包含给定的字符串
• subset - 字段是数组或标量，所有元素都包含在给定数组中
• containsUnique - 字段是一个数组并且包含唯一值
• creditCard - 字段是有效的信用卡号
• instanceOf - 字段包含给定类的实例
• optional - 值不需要包含在数据数组中。但是，如果是，则必须通过验证。
• arrayHasKeys - 字段是一个数组，包含所有指定的键。

注意：如果您将浮点数与最小/最大验证器进行比较，您应该安装 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规则检查该字段是否为必填字段，是否为空且不是空字符串，如果存在任何其他字段，则检查该字段是否为空且不是空字符串。

 // 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 ();

严格旗帜

strict 标志会将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规则检查该字段是否为必填字段，是否为空，且是否为空字符串（如果不存在任何其他字段）。

 // 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 ();

严格旗帜

strict 标志会将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规则检查数据数组中的两个字段是否相等，以及第二个字段是否不为空。

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

替代语法。

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

不同领域的使用

different规则检查数据数组中的两个字段是否不相同或不同，以及第二个字段是否不为空。

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

替代语法。

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

接受字段的使用

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规则检查字段是否至少为给定值以及提供的值是否为数字。

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

替代语法。

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

最大字段使用量

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规则检查该字段是否存在于给定值数组中。

 $ 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规则检查该字段是否是有效的电子邮件地址。

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

替代语法。

 $ v = new Valitron  Validator ([ ' user_email ' => ' [email protected] ' ]);
$ v -> rules ([
    ' email ' => [
        [ ' user_email ' ]
    ]
]);
$ v -> validate ();

emailDNS 字段使用

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

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

替代语法。

 $ v = new Valitron  Validator ([ ' user_email ' => ' [email protected] ' ]);
$ 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规则检查该字段是否为具有活动 A、AAAA 或 CNAME 记录的有效 url。

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

替代语法。

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

阿尔法字段的使用

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 字符（az、0-9、-、_）。

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

替代语法。

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

正则表达式字段用法

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规则检查提供的字段是否是有效的 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规则检查提供的字段是否是指定日期格式的有效日期。

 $ 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规则检查字段中是否存在给定字符串，并检查字段和搜索值是否都是有效字符串。

 $ 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规则检查该字段是标量字段还是数组字段，以及它的所有值是否包含在给定值集中。

 $ 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 、 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规则确保如果该字段存在于数据集中，则它通过所有验证规则。

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

替代语法。当“用户名”字段不存在或用户名仅为字母字符时，此示例将返回 true。

 $ 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所在范围内定义的变量。 Closure 的签名与Validator::addRule回调的签名相同。

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

链接规则

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

 $ v = new Valitron  Validator ([ ' email_address ' => ' [email protected] ' ]);
$ 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 ' => '[email protected]));
$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：

1. 下载 Composer curl -s http://getcomposer.org/installer | php
2. 运行“安装” php composer.phar install
3. 运行测试phpunit

贡献

1. 分叉它
2. 创建您的功能分支（ git checkout -b my-new-feature ）
3. 做出你的改变
4. 运行测试，如有必要，为您自己的代码添加新的测试（ phpunit ）
5. 提交您的更改（ git commit -am 'Added some feature' ）
6. 推送到分支（ git push origin my-new-feature ）
7. 创建新的拉取请求
8. 拍拍自己的背，因为自己太棒了

安全披露和联系信息

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