valitron

Valitron: การตรวจสอบอย่างง่ายที่ไม่ห่วย

Valitron เป็นไลบรารีการตรวจสอบความถูกต้องแบบสแตนด์อโลนที่เรียบง่าย เรียบง่าย และสวยงาม โดยไม่มีการขึ้นต่อกัน Valitron ใช้วิธีการตรวจสอบที่ง่ายและตรงไปตรงมา โดยเน้นที่ไวยากรณ์ที่อ่านง่ายและกระชับ Valitron เป็นไลบรารีการตรวจสอบที่เรียบง่ายและใช้งานได้จริงที่คุณกำลังมองหา

รับ vlucas/valitron ที่รองรับด้วยการสมัครสมาชิก Tidelift

ทำไมต้องวาลิตรอน?

Valitron ถูกสร้างขึ้นด้วยความหงุดหงิดกับไลบรารีการตรวจสอบอื่นๆ ที่ต้องพึ่งพาส่วนประกอบขนาดใหญ่จากเฟรมเวิร์กอื่นๆ เช่น HttpFoundation ของ Symfony โดยดึงไฟล์พิเศษจำนวนมากที่ไม่จำเป็นจริงๆ สำหรับการตรวจสอบขั้นพื้นฐาน นอกจากนี้ยังมีไวยากรณ์ง่ายๆ ที่มีวัตถุประสงค์เพื่อเรียกใช้การตรวจสอบความถูกต้องทั้งหมดในการเรียกครั้งเดียว แทนที่จะตรวจสอบความถูกต้องแต่ละค่าโดยการสร้างอินสแตนซ์คลาสใหม่ และตรวจสอบค่าทีละครั้ง เช่นเดียวกับที่ไลบรารีการตรวจสอบความถูกต้องอื่นๆ ต้องการ

กล่าวโดยสรุป 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 ());
}

การตั้งค่าภาษาและภาษา dir ทั่วโลก:

 // 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 - ต้องยอมรับช่องทำเครื่องหมายหรือวิทยุ (ใช่, บน, 1, จริง)
• numeric - ต้องเป็นตัวเลข
• integer - ต้องเป็นจำนวนเต็ม
• boolean - ต้องเป็นบูลีน
• array - ต้องเป็นอาร์เรย์
• length - สตริงต้องมีความยาวที่แน่นอน
• lengthBetween - สตริงต้องอยู่ระหว่างความยาวที่กำหนด
• lengthMin - สตริงต้องมากกว่าความยาวที่กำหนด
• lengthMax - สตริงต้องน้อยกว่าความยาวที่กำหนด
• min - ขั้นต่ำ
• max - สูงสุด
• listContains - ทำการตรวจสอบ in_array กับค่าอาร์เรย์ที่กำหนด (ในทางกลับกัน แทนที่จะ in )
• in - ทำการตรวจสอบ in_array กับค่าอาร์เรย์ที่กำหนด
• notIn - การปฏิเสธ in (ไม่ใช่ในอาร์เรย์ของค่า)
• ip - ที่อยู่ IP ที่ถูกต้อง
• ipv4 - ที่อยู่ IP v4 ที่ถูกต้อง
• ipv6 - ที่อยู่ IP v6 ที่ถูกต้อง
• email - ที่อยู่อีเมลที่ถูกต้อง
• emailDNS - ที่อยู่อีเมลที่ถูกต้องพร้อมบันทึก DNS ที่ใช้งานอยู่
• url - URL ที่ถูกต้อง
• urlActive - URL ที่ถูกต้องพร้อมบันทึก DNS ที่ใช้งานอยู่
• alpha - อักขระตัวอักษรเท่านั้น
• alphaNum - อักขระตัวอักษรและตัวเลขเท่านั้น
• ascii - อักขระ ASCII เท่านั้น
• slug - อักขระกระสุน URL (az, 0-9, -, _)
• regex - การจับคู่ฟิลด์ที่กำหนดรูปแบบ regex
• date - ฟิลด์เป็นวันที่ที่ถูกต้อง
• dateFormat - ฟิลด์เป็นวันที่ที่ถูกต้องในรูปแบบที่กำหนด
• dateBefore - ฟิลด์เป็นวันที่ที่ถูกต้องและอยู่ก่อนวันที่ที่กำหนด
• dateAfter - ฟิลด์เป็นวันที่ที่ถูกต้องและอยู่หลังวันที่ที่กำหนด
• contains - ฟิลด์เป็นสตริงและมีสตริงที่กำหนด
• subset - ฟิลด์เป็นอาร์เรย์หรือสเกลาร์และองค์ประกอบทั้งหมดมีอยู่ในอาร์เรย์ที่กำหนด
• containsUnique - ฟิลด์เป็นอาร์เรย์และมีค่าที่ไม่ซ้ำกัน
• creditCard - ฟิลด์คือหมายเลขบัตรเครดิตที่ถูกต้อง
• instanceOf - ฟิลด์มีอินสแตนซ์ของคลาสที่กำหนด
• optional - ไม่จำเป็นต้องรวมค่าไว้ในอาร์เรย์ข้อมูล หากเป็นเช่นนั้นก็ต้องผ่านการตรวจสอบ
• arrayHasKeys - ฟิลด์เป็นอาร์เรย์และมีคีย์ที่ระบุทั้งหมด

หมายเหตุ : หากคุณกำลังเปรียบเทียบตัวเลขทศนิยมกับเครื่องมือตรวจสอบค่าต่ำสุด/สูงสุด คุณควรติดตั้งส่วนขยาย BCMath เพื่อความแม่นยำและความน่าเชื่อถือที่มากขึ้น ส่วนขยายไม่จำเป็นสำหรับ Valitron ในการทำงาน แต่ Valitron จะใช้ส่วนขยายนี้หากมี และขอแนะนำอย่างยิ่ง

การใช้ฟิลด์ที่จำเป็น

กฎ required จะตรวจสอบว่ามีฟิลด์อยู่ในอาร์เรย์ข้อมูลหรือไม่ และไม่เป็นค่าว่างหรือสตริงว่าง

 $ 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 จะตรวจสอบว่าฟิลด์นั้นจำเป็น ไม่ใช่ 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() จะยังคงคืนค่าเป็นจริง เนื่องจากฟิลด์ส่วนต่อท้ายไม่จำเป็นต้องใช้ในโหมดเข้มงวด เนื่องจากไม่ได้ระบุฟิลด์ทั้งหมดไว้

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

จำเป็นโดยไม่ต้องใช้งานฟิลด์

กฎ 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() จะยังคงคืนค่าเป็นจริง เนื่องจากฟิลด์ชื่อผู้ใช้ไม่จำเป็นต้องมีในโหมดเข้มงวด เนื่องจากมีการระบุฟิลด์ทั้งหมดไว้แล้ว

 $ 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 จะตรวจสอบว่าช่องเป็น 'ใช่', 'เปิด', 1 หรือจริง

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

ไวยากรณ์สำรอง

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

การใช้ช่องตัวเลข

กฎ numeric จะตรวจสอบว่าฟิลด์นั้นเป็นตัวเลขหรือไม่ สิ่งนี้คล้ายคลึงกับฟังก์ชัน is_numeric() ของ php

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

โปรดทราบว่า แฟล็กบูลีนที่เป็นตัวเลือกสำหรับโหมดเข้มงวดช่วยให้แน่ใจว่าจำนวนเต็มจะถูกระบุในรูปแบบตัวเลขอย่างเคร่งครัด ดังนั้นกฎต่อไปนี้จะประเมินว่าเป็นจริง:

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

โดยที่ค่าต่อไปนี้จะประเมินเป็นเท็จ เนื่องจาก + สำหรับจำนวนบวกในกรณีนี้จะซ้ำซ้อน:

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

การใช้ฟิลด์บูลีน

กฎ boolean จะตรวจสอบว่าฟิลด์นั้นเป็นบูลีนหรือไม่ สิ่งนี้คล้ายคลึงกับฟังก์ชัน is_bool() ของ php

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

ไวยากรณ์สำรอง

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

การใช้ฟิลด์อาร์เรย์

กฎ array จะตรวจสอบว่าฟิลด์นั้นเป็นอาร์เรย์หรือไม่ สิ่งนี้คล้ายคลึงกับฟังก์ชัน is_array() ของ php

 $ 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 ตรวจสอบว่าฟิลด์อยู่ระหว่างช่วงความยาวที่กำหนดและฟิลด์นั้นเป็นสตริงที่ถูกต้องหรือไม่

 $ 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 จะตรวจสอบว่าช่องนั้นไม่มีอยู่ในอาร์เรย์ของค่าที่กำหนด

 $ 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 จะตรวจสอบว่าช่องนั้นเป็น URL ที่ถูกต้องซึ่งมีระเบียน A, AAAA หรือ CNAME ที่ใช้งานอยู่

 $ 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 จะตรวจสอบว่าฟิลด์นี้มีเฉพาะอักขระกระสุน URL (az, 0-9, -, _)

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

ไวยากรณ์สำรอง

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

การใช้ฟิลด์ regex

กฎ regex ช่วยให้มั่นใจว่าช่องตรงกับรูปแบบ 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 ที่จะตรวจสอบว่าฟิลด์ที่ให้มานั้นเป็นออบเจ็กต์ DateTime ที่ถูกต้องหรือไม่ หรือสามารถแปลงสตริงเป็นการประทับเวลา Unix ผ่านทาง strtotime() ได้หรือไม่

 $ 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 การตรวจสอบว่ามีสตริงที่กำหนดอยู่ภายในฟิลด์ และตรวจสอบว่าฟิลด์และค่าการค้นหาเป็นทั้งสตริงที่ถูกต้อง

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

ไวยากรณ์สำรอง

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

หมายเหตุ คุณสามารถใช้แฟล็กเข้มงวดเผื่อเลือกเพื่อให้แน่ใจว่าการจับคู่แบบคำนึงถึงตัวพิมพ์เล็กและตัวพิมพ์ใหญ่ ตัวอย่างต่อไปนี้จะคืนค่าเป็นจริง:

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

โดยที่สิ่งนี้จะส่งกลับค่าเท็จ เนื่องจาก 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 ();

ตัวอย่างนี้จะคืนค่าเท็จ เนื่องจากสีที่ให้ไว้ สีม่วง นั้นไม่มีอยู่ในอาร์เรย์ของค่าที่ยอมรับที่เราระบุ

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

มีการใช้งานฟิลด์ที่ไม่ซ้ำ

กฎ containsUnique จะตรวจสอบว่าฟิลด์ที่ระบุเป็นอาร์เรย์และค่าทั้งหมดที่มีอยู่ภายในไม่ซ้ำกัน กล่าวคือ ไม่มีค่าที่ซ้ำกันในอาร์เรย์

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

ไวยากรณ์สำรอง

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

ตัวอย่างนี้จะคืนค่าเท็จ เนื่องจากค่าในอาร์เรย์ที่ระบุซ้ำกัน

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

การใช้การตรวจสอบบัตรเครดิต

การตรวจสอบบัตรเครดิตในปัจจุบันช่วยให้คุณสามารถตรวจสอบ visa วีซ่า มาสเตอร์การ์ดมาสเตอร์ mastercard Dinersclub dinersclub อเมริกันเอ็กซ์เพรส amex หรือ Discover discover

ซึ่งจะตรวจสอบบัตรเครดิตกับบัตรแต่ละประเภท

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

หากต้องการกรองประเภทการ์ดเพิ่มเติม ให้เพิ่มตัวกระสุนลงในอาร์เรย์เป็นพารามิเตอร์ถัดไป:

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

หมายเหตุ คุณยังสามารถเปรียบเทียบค่ากับอ็อบเจ็กต์ที่กำหนดซึ่งตรงข้ามกับชื่อคลาสสตริงได้ ตัวอย่างนี้จะคืนค่าเป็นจริงด้วย:

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

การใช้ฟิลด์ตัวเลือก

กฎ optional ช่วยให้แน่ใจว่าหากมีฟิลด์อยู่ในชุดข้อมูลที่จะผ่านกฎการตรวจสอบทั้งหมด

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

ไวยากรณ์สำรอง ตัวอย่างนี้จะคืนค่าเป็นจริงเมื่อไม่มีช่อง 'ชื่อผู้ใช้' หรือในกรณีที่ชื่อผู้ใช้เป็นเพียงตัวอักษรเท่านั้น

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

ตัวอย่างนี้จะคืนค่าเท็จ ราวกับว่าฟิลด์นี้เป็นทางเลือก เนื่องจากฟิลด์นั้นต้องผ่านกฎการตรวจสอบทั้งหมด ซึ่งในกรณีนี้จะไม่ผ่าน

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

การใช้งานฟิลด์ arrayHasKeys

กฎ arrayHasKeys ทำให้แน่ใจว่าฟิลด์นั้นเป็นอาร์เรย์และมีคีย์ที่ระบุทั้งหมด ส่งกลับค่าเท็จหากฟิลด์นั้นไม่ใช่อาร์เรย์ หรือหากไม่ได้ระบุคีย์ที่จำเป็น หรือหากคีย์บางคีย์หายไป

 $ 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 พร้อมชื่อกฎ การเรียกกลับหรือการปิดที่กำหนดเอง และข้อความแสดงข้อผิดพลาดที่จะแสดงในกรณีที่เกิดข้อผิดพลาด การโทรกลับที่ให้ไว้ควรส่งคืนบูลีนจริงหรือเท็จ

 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 ' => ' [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. ดาวน์โหลดนักแต่งเพลง 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 จะประสานการแก้ไขและเปิดเผยข้อมูล