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 將協調修復和揭露。