Beranda>Kode sumber PHP>Kategori lainnya
Unduh

mighty

Pustaka validasi terakhir yang Anda perlukan!


Daftar isi

Instalasi
Tentang mighty
Mulai cepat
mVEL
Contoh
Kendala
Validasi
Dokumentasi
Spesifikasi
log perubahan


Jika Anda menyukai proyek ini dan ingin mendukung pengembangannya, memberikannya akan sangat kami hargai!


Fitur Utama

  1. Nol ketergantungan.
  2. Kerangka kerja agnostik, dapat diintegrasikan dalam basis kode apa pun.
  3. Ekspresif, intuitif, dan mudah digunakan dengan lebih dari 250 aturan validasi bawaan.

<rentang kelas= Demo perkasa" style="max-width: 100%;">

Instalasi 

composer require marwanalsoltany/ mighty

Tentang mighty

Validasi adalah tugas umum dalam aplikasi web apa pun. Data yang dikirimkan ke aplikasi melalui formulir —atau jenis masukan apa pun— harus selalu divalidasi berdasarkan serangkaian aturan. mighty dapat menangani dengan cara yang mudah dan ekspresif.

mighty adalah pustaka validasi yang cepat, kuat, kuat, dan mudah digunakan yang menyenangkan untuk digunakan, membuat validasi data apa pun menjadi mudah. Berkat kekuatan Bahasa Ekspresi Validasi (mVEL) mighty , ini tidak seperti apa pun yang pernah Anda lihat sebelumnya. Dengan pendekatan validasinya dan lebih dari 250 aturan bawaannya, hampir tidak ada hal yang tidak dapat Anda validasi dengannya, dengan cara yang sangat ekspresif dan ringkas. Sederhananya, mighty adalah validasi steroid! Ini memang perpustakaan validasi terakhir yang Anda perlukan.

mighty menyediakan beberapa pendekatan berbeda untuk memvalidasi data. Kasus penggunaan yang paling umum adalah memvalidasi data masuk melalui permintaan HTTP, namun tentu saja tidak terbatas pada itu; mighty juga menyediakan atribut dalam bentuk batasan untuk memvalidasi model dan/atau objek apa pun dengan mudah.

mighty menyertakan beragam aturan validasi yang mudah digunakan yang dapat Anda terapkan sebagai satu aturan atau menggabungkannya satu sama lain menggunakan operator untuk membuat validasi yang lebih kompleks.

Mulai cepat

Untuk mempelajari tentang fitur validasi mighty yang canggih, mari langsung ke intinya dan lihat beberapa contoh:

Validasi Data Umum

Memvalidasi data formulir menggunakan Validator::class :

mightyValidator; $validator = new Validator(); $validator ->setData([ 'name' => 'John Doe', 'username' => 'john.doe', 'password' => 'Super@Secret#123', 'email' => '[email protected]', 'hobbies' => ['coding', 'design', 'sports'], ]) ->setValidations([ // required&string&between:3,255 'name' => $validator->validation()->required()->string()->between(3, 255), // required&string&matches:/[a-z0-9._-]/i 'username' => $validator->validation()->required()->string()->matches('/[a-z0-9._-]/i'), // required&string&min:8 'password' => $validator->validation()->required()->string()->min(8), // required&email 'email' => $validator->validation()->required()->email(), // null^(required&array&max:5) 'hobbies' => $validator ->validation() ->null() ->xor() ->group(fn ($validation) => $validation ->array() ->max(5) ), // null|(if:${hobbies.validations.array}&(string&min:3)) // hobby can be null or a string with at least 3 characters if hobbies is an array 'hobbies.*' => $validator ->validation() ->null() ->or() ->group(fn ($validation) => $validation ->if('${hobbies.validations.array}') ->open() ->string() ->min(3) ->close() ), ]) ->validate(); $result = $validator->isOK(); // boolean result of the overall validation result $errors = $validator->getErrors(); // an array of results of validations that failed $results = $validator->getResults(); // an array of results of all validations $validator->check(); // void or throws an exception with a nicely formatted message of what exactly went wrong ">
 use MAKS  mighty  Validator ;

$ validator = new Validator ();

$ validator
    -> setData ([
        ' name '     => ' John Doe ' ,
        ' username ' => ' john.doe ' ,
        ' password ' => ' Super@Secret#123 ' ,
        ' email '    => ' [email protected] ' ,
        ' hobbies '  => [ ' coding ' , ' design ' , ' sports ' ],
    ])
    -> setValidations ([
        // required&string&between:3,255
        ' name '      => $ validator -> validation ()-> required ()-> string ()-> between ( 3 , 255 ),
        // required&string&matches:/[a-z0-9._-]/i
        ' username '  => $ validator -> validation ()-> required ()-> string ()-> matches ( ' /[a-z0-9._-]/i ' ),
        // required&string&min:8
        ' password '  => $ validator -> validation ()-> required ()-> string ()-> min ( 8 ),
        // required&email
        ' email '     => $ validator -> validation ()-> required ()-> email (),
        // null^(required&array&max:5)
        ' hobbies '   => $ validator
            -> validation ()
            -> null ()
            -> xor ()
            -> group ( fn ( $ validation ) => $ validation
                -> array ()
                -> max ( 5 )
            ),
        // null|(if:${hobbies.validations.array}&(string&min:3))
        // hobby can be null or a string with at least 3 characters if hobbies is an array
        ' hobbies.* ' => $ validator
            -> validation ()
            -> null ()
            -> or ()
            -> group ( fn ( $ validation ) => $ validation
                -> if ( ' ${hobbies.validations.array} ' )
                -> open ()
                -> string ()
                -> min ( 3 )
                -> close ()
            ),
    ])
    -> validate ();

$ result = $ validator -> isOK (); // boolean result of the overall validation result

$ errors = $ validator -> getErrors (); // an array of results of validations that failed

$ results = $ validator -> getResults (); // an array of results of all validations

$ validator -> check (); // void or throws an exception with a nicely formatted message of what exactly went wrong

Validasi Objek

Memvalidasi keadaan suatu objek menggunakan atribut Constraint::class :

mightyValidationStrategy; use MAKS mighty ValidationBehavior; use MAKS mighty ValidationOperator; use MAKS mighty ValidationConstraint; use MAKS mighty ValidationConstraint as Assert; use MAKS mighty ValidationConstraintValidatableObjectInterface; use MAKS mighty ValidationConstraintValidatableObjectTrait; class ValidatableObject implements ValidatableObjectInterface { use ValidatableObjectTrait; #[AssertRuleEquals('CONST')] public const CONST = 'CONST'; #[AssertRuleIn(['STATIC', 'VAR'])] public static $static = 'VAR'; #[AssertRuleStringConstraint] #[AssertRuleStringCharset('UTF-8')] #[AssertRuleBetween(3, 99)] public $default = 'DEFAULT'; #[AssertRuleStringConstraint] #[AssertRuleStringContains('<element>')] #[AssertRuleXml] public $xml = '<?xml version="1.0"?><element></element>'; #[AssertRuleArrayConstraint] #[AssertShape([ 'string' => new AssertRuleStr, 'array' => new AssertRuleArr, ])] public $array = [ 'string' => 'value', 'array' => [], ]; #[AssertRuleObjectConstraint] #[AssertRuleObjectIsInstanceOf(ValidatableObjectInterface::class)] #[AssertValid(message: 'Not valid')] public $object; #[AssertCallback('is_scalar', 'Data is not scalar')] #[Constraint('string&min:3', strategy: Strategy::FailLazy, messages: [ 'string' => 'Must be string.', 'min' => 'Must be longer than ${@arguments.0}.', ])] public function getDefault() { return $this->default; } #[AssertCompound([ new AssertRuleStr, new AssertCompound([ new AssertRuleArr, new AssertCompound([ new AssertRuleBlank, ], Operator::Not), ], Operator::And), ], Operator::Xor, Behavior::Pessimistic, Strategy::FailLazy)] public static function getStaticProperty() { return static::$static; } } $object = new ValidatableObject(); $result = $object->isValid(); // boolean result of the overall validation result $results = $object->validate(); // an array of results of all validations $object->check(); // void or throws an exception with a nicely formatted message of what exactly went wrong ">
 use MAKS  mighty  Validation  Strategy ;
use MAKS  mighty  Validation  Behavior ;
use MAKS  mighty  Validation  Operator ;
use MAKS  mighty  Validation  Constraint ;
use MAKS  mighty  Validation  Constraint as Assert ;
use MAKS  mighty  Validation  Constraint  ValidatableObjectInterface ;
use MAKS  mighty  Validation  Constraint  ValidatableObjectTrait ;


class ValidatableObject implements ValidatableObjectInterface
{
    use ValidatableObjectTrait;


    #[ Assert  Rule Equals( ' CONST ' )]
    public const CONST = ' CONST ' ;

    #[ Assert  Rule In([ ' STATIC ' , ' VAR ' ])]
    public static $ static = ' VAR ' ;

    #[ Assert  Rule StringConstraint]
    #[ Assert  Rule StringCharset( ' UTF-8 ' )]
    #[ Assert  Rule Between( 3 , 99 )]
    public $ default = ' DEFAULT ' ;

    #[ Assert  Rule StringConstraint]
    #[ Assert  Rule StringContains( ' <element> ' )]
    #[ Assert  Rule Xml]
    public $ xml = ' <?xml version="1.0"?><element></element> ' ;

    #[ Assert  Rule ArrayConstraint]
    #[ Assert Shape([
        ' string ' => new Assert  Rule  Str ,
        ' array '  => new Assert  Rule  Arr ,
    ])]
    public $ array = [
        ' string ' => ' value ' ,
        ' array '  => [],
    ];

    #[ Assert  Rule ObjectConstraint]
    #[ Assert  Rule ObjectIsInstanceOf(ValidatableObjectInterface::class)]
    #[ Assert Valid(message: ' Not valid ' )]
    public $ object ;

    #[ Assert Callback( ' is_scalar ' , ' Data is not scalar ' )]
    #[Constraint( ' string&min:3 ' , strategy: Strategy::FailLazy, messages: [
        ' string ' => ' Must be string. ' ,
        ' min '    => ' Must be longer than ${@arguments.0}. ' ,
    ])]
    public function getDefault ()
    {
        return $ this -> default ;
    }

    #[ Assert Compound([
        new Assert  Rule  Str ,
        new Assert  Compound ([
            new Assert  Rule  Arr ,
            new Assert  Compound ([
                new Assert  Rule  Blank ,
            ], Operator::Not),
        ], Operator::And),
    ], Operator::Xor, Behavior::Pessimistic, Strategy::FailLazy)]
    public static function getStaticProperty ()
    {
        return static :: $ static ;
    }
}

$ object = new ValidatableObject ();

$ result = $ object -> isValid (); // boolean result of the overall validation result

$ results = $ object -> validate (); // an array of results of all validations

$ object -> check (); // void or throws an exception with a nicely formatted message of what exactly went wrong

Contoh output dari validasi objek yang dapat divalidasi akan terlihat seperti ini: 

 // check out the previous snippet see the used constraints

$ object = new ValidatableObject ();
$ object -> object = new class implements ValidatableObjectInterface {
    use ValidatableObjectTrait;
    // some properties and their validation constraints ...
};
$ object -> default = null ; // this must be a string

$ object -> check ();

// ValidationFailedException::class
// Data failed to pass the validation.
// (01) The value (null) of the "ValidatableObject->default" property failed to pass the validation [string]. Problem: Value must be a string.
// (02) The value (null) of the "ValidatableObject->default" property failed to pass the validation [string.charset:"UTF-8"]. Problem: Value must be encoded in one of the following charsets: ["UTF-8"].
// (03) The value (null) of the "ValidatableObject->default" property failed to pass the validation [between:3,99]. Problem: Value must be between 3 and 99 or have a value/count/length that is between 3 and 99.
// (04) The return value (null) of the "ValidatableObject->getDefault()" method failed to pass the validation [callback]. Problem: Data is not scalar.
// (05) The return value (null) of the "ValidatableObject->getDefault()" method failed to pass the validation [string&min:3]. Problems: Must be string; Must be longer than 3.

Periksa juga ValidatableObject dan ValidatableObjectChild .

■ Petunjuk: Contoh lainnya dapat ditemukan di bagian Contoh.

Bahasa Ekspresi Validasi mighty

mighty memiliki konsep Ekspresi Validasi. Ekspresi Validasi dalam bentuknya yang paling sederhana hanyalah sebuah string yang menggambarkan seberapa mighty seharusnya memvalidasi data yang diberikan. String ini didasarkan pada Spesifikasi Bahasa Ekspresi Validasi (mVEL) mighty . mVEL cukup sederhana, dapat dibaca manusia, dan mudah ditangani. Ini adalah kombinasi konsep dan/atau spesifikasi yang sudah mapan seperti Aljabar Boolean, Operator Bitwise, JSON, dan CSV.

Oleh karena itu, Ekspresi Validasi dapat didefinisikan sebagai string yang berisi beberapa aturan yang dipisahkan oleh Operator Bitwise yang akan membangun ekspresi yang bila dievaluasi menggunakan logika Aljabar Boolean , akan menghasilkan hasil akhir validasi. Aturan dapat memiliki argumen, tipe argumen ini dapat dilambangkan menggunakan aturan tipe JSON yang sama. Sebuah aturan juga dapat memiliki beberapa argumen dan argumen tersebut dipisahkan dengan koma ( CSV ).

Misalnya required&string&between:2,255|null adalah Ekspresi Validasi yang valid, ekspresi ini dapat dipahami sebagai berikut:

  1. Ekspresi tersebut memiliki empat aturan.
  2. Ekspresi tersebut berisi aturan:
    1. required Menegaskan bahwa masukan ada.
    2. string Menegaskan bahwa inputnya adalah string.
    3. between:2,255 Menegaskan bahwa input adalah string dengan panjang antara 2 dan 255.
    4. null Menegaskan bahwa masukannya adalah nol.
  3. Hasil akhirnya merupakan hasil evaluasi ekspresi yang dihasilkan dari hasil setiap aturan yang direkatkan menggunakan operator bitwise.

Ekspresi required&string&between:2,255|null berarti input harus ada; DAN bertipe string; DAN panjangnya antara 2 dan 255; ATAU batal. Jadi ini adalah string yang dapat dibatalkan yang panjangnya bukan nol harus antara 2 dan 255 karakter.

Katakanlah masukannya adalah " mighty is Awesome!" , hasil dari ekspresi required&string&between:2,255|null terhadap input tersebut adalah 1&1&1|0 yang akan menghasilkan 1 yaitu true , jika inputnya null hasilnya adalah 0&0&0|1 = 1 , jika inputnya adalah X hasilnya akan menjadi 0&0&0|0 = 0 , dll ...

Tidak seperti implementasi validasi lainnya, konsep Aljabar Boolean menggunakan Operator Bitwise , memberikan kemungkinan untuk membangun validasi kompleks yang sangat mudah dibaca dan kompak sambil menjaga aturan ke jumlah minimum, menggunakan kembali logika yang ada secara terbalik atau majemuk, dan akhirnya menjaga logika yang ada. basis kode sekering mungkin. Manfaatnya dapat diringkas dalam poin-poin berikut:

  1. Suatu aturan TIDAK dapat diedit (menggunakan ~ ) untuk melakukan kebalikan dari apa yang biasanya dilakukannya.
  2. Aturan kompleks dapat berupa hasil dari perintah AND (menggunakan & ), perintah OR (menggunakan | ), atau perintah XOR (menggunakan ^ ), dua atau lebih aturan sederhana.
  3. Aturan dapat dikelompokkan bersama dan/atau diberi prioritas lebih tinggi dengan menggunakan tanda kurung, yaitu OPEN (menggunakan ( ) dan CLOSE (menggunakan ) ).
  4. Ekspresi Validasi juga dapat memiliki perilaku, yaitu karakter yang mengawali string Ekspresi Validasi yang akan memengaruhi semua aturan. Perilaku yang tersedia adalah:
    1. NORMAL : jalankan semua aturan, perilaku default (tanpa awalan).
    2. OPTIMIS : berhenti menjalankan aturan setelah kesuksesan pertama ( awalan ? ).
    3. PESSIMISTIC : berhenti menjalankan aturan setelah kegagalan pertama ( awalan ! ).
  5. Keterbacaan dapat ditingkatkan dengan melakukan aliasing pada beberapa aturan atau menambahkan kumpulan aturan sebagai makro dan mengeksekusinya menggunakan sintaks [macro] .

Konsep JSON juga memastikan keamanan tipe data argumen, dan konsep CSV memastikan daftar argumen memiliki aturan penguraian yang jelas.

Hal terbaiknya, Anda tidak perlu menghafal semua aturan atau sintaks Validation Expression Language. Kelas Validation adalah antarmuka lancar yang dapat digunakan untuk membangun Ekspresi Validasi. Ia mengetahui semua aturan mighty yang tersedia dan memiliki dukungan penuh IDE-Intellisense untuk membuatnya semudah mungkin. Misalnya:

mightyValidation; // the validation expression: `required&string&between:2,255|null` // can be constructed using the Validation::class as follows: $validation = (new Validation())->required()->string()->between(2, 255)->or()->null(); // AND is the default operator // or statically: $validation = Validation::required()->string()->between(2, 255)->or()->null(); ">
 use MAKS  mighty  Validation ;

// the validation expression: `required&string&between:2,255|null`
// can be constructed using the Validation::class as follows:
$ validation = ( new Validation ())-> required ()-> string ()-> between ( 2 , 255 )-> or ()-> null (); // AND is the default operator
// or statically:
$ validation = Validation:: required ()-> string ()-> between ( 2 , 255 )-> or ()-> null ();

■ Fakta: Biasanya dibutuhkan lebih banyak kata untuk mendeskripsikan fungsi ekspresi validasi daripada ekspresi validasi itu sendiri!

Contoh

Berikut adalah beberapa contoh skenario dunia nyata:

Memvalidasi Nilai Tunggal

mightyValidator; $result = ($validator = new Validator()) ->validateOne( '123', $validator ->validation() // can be an integer or float or a string that is numeric // this example is only for demonstration only, // the same result can be achieved using numeric() only ->integer()->or()->float()->or()->group( fn ($validation) => $validation->string()->and()->numeric() ) ) ->toArray(); // $result would look something like this: [ 'value' => '123', 'result' => true, 'validations' => [ 'integer' => false, 'float' => false, 'string' => true, 'numeric' => true, ], 'errors' => [], 'metadata' => [ 'basis' => 'integer|float|(string&numeric)', 'rules' => 'integer|float|(string&numeric)', 'expression' => '0|0|(1&1)', ], ]; // you can also simply use the static helper Validator::validateData($data, $validation);">
 use MAKS  mighty  Validator ;

$ result = ( $ validator = new Validator ())
    -> validateOne (
        ' 123 ' ,
        $ validator
            -> validation ()
            // can be an integer or float or a string that is numeric
            // this example is only for demonstration only,
            // the same result can be achieved using numeric() only
            -> integer ()-> or ()-> float ()-> or ()-> group (
                fn ( $ validation ) => $ validation -> string ()-> and ()-> numeric ()
            )
    )
    -> toArray ();

// $result would look something like this:
[
    ' value ' => ' 123 ' ,
    ' result ' => true ,
    ' validations ' => [
        ' integer ' => false ,
        ' float ' => false ,
        ' string ' => true ,
        ' numeric ' => true ,
    ],
    ' errors ' => [],
    ' metadata ' => [
        ' basis ' => ' integer|float|(string&numeric) ' ,
        ' rules ' => ' integer|float|(string&numeric) ' ,
        ' expression ' => ' 0|0|(1&1) ' ,
    ],
];

// you can also simply use the static helper Validator::validateData($data, $validation);

Memvalidasi Data Terstruktur

mightyValidator; use AppServiceHaveIBeenPwnedService as PasswordService; $validator = new Validator(); $data = [ 'name' => 'John Doe', 'age' => 32, 'email' => '[email protected]', 'username' => 'john.doe', 'password' => 'Secret@123', 'image' => '/path/to/image.png', 'submission' => 'now', 'consent' => 'yes', 'data' => [ 'nickname' => 'JOE', 'number' => 7, 'hobbies' => [ 'coding', 'cooking', 'reading', ] ], ]; $validations = [ 'name' => $validator->validation()->required()->string()->stringCharset(['UTF-8', 'ASCII'])->pessimistic(), // or using mVEL => required&string&string.charset:'["UTF-8","ASCII"]' 'age' => $validator->validation()->required()->integer()->min(18), // or using mVEL => required&integer&min:18 'email' => $validator->validation()->required()->email()->macro('gmail'), // or using mVEL => required&email&[gmail] 'username' => $validator->validation()->required()->username(), // or using mVEL => required&username 'password' => $validator->validation()->required()->password()->callback(fn ($input) => !PasswordService::isPwned($input)), // or using mVEL => required&password (NOTE: callback ist not possible, it requires a Validation::class instance that is bound to the Validator::class instance) 'image' => $validator->validation()->null()->xor()->group(fn () => $this->image()->imageDimensions(1920, 1080, '<=')), // or using mVEL => null^(image&image.dimensions:1920,1080,"<=") 'submission' => $validator->validation()->required()->datetime()->datetimeLt('2022-12-07'), // or using mVEL => required&datetime&datetime.lt:"2022-12-07" 'consent' => $validator->validation()->assert('${age.value}', 18, '>=')->or()->accepted()->or()->assertEquals('${this}', 'granted')->optimistic(), // or using mVEL => ?assert:${age.value},18,">="|accepted|assert.equals:${this},"granted" 'data' => $validator->validation()->required()->array()->arrayHasKey('nickname'), // or using mVEL => required&array&array.hasKey:"nickname" 'data.*' => $validator->validation()->scalar()->or()->array()->optimistic(), // or using mVEL => ?scalar|array 'data.nickname' => $validator->validation()->string()->min(2)->max(32), // or using mVEL => string&min:2&max:32 'data.hobbies.*' => $validator->validation()->ifEq('${data.hobbies.validations.array}', false)->or()->group(fn () => $this->string()->min(3)), // or using mVEL => if.eq:${data.hobbies.validations.array},false|(string&min:3) ]; $labels = [ 'name' => 'Name', 'age' => 'Age', 'email' => 'E-Mail', 'password' => 'Password', 'image' => 'Image', 'data' => 'Data', 'data.*' => 'Value of data', 'consent' => 'Consent', ]; $messages = [ '*' => [ // this will be expanded for all fields 'required' => '${@label} is a required field.', ], 'age' => [ 'min' => '${@label} must be at least ${@arguments.0}.', ], 'username' => [ 'matches' => '${@label} must contain letters, numbers, and the following characters ".-_" only.', ], 'consent' => [ 'assert' => 'You must be at least ${@arguments.1} years old to submit this form.', ] ]; $validator ->setData($data) ->setValidations($validations) ->setMessages($messages) ->setLabels($labels) ->validate(); $results = $validator->getResults(); // $result should look something like this: [ // this will actually be a Result object // array syntax is used here for demonstration purposes 'name' => [ 'key' => 'name', 'value' => 'John Doe', 'result' => true, 'validations' => [ 'required' => true, 'string' => true, 'string.charset' => true, ], 'errors' => [], 'metadata' => [ 'basis' => '!required&string&string.charset:["UTF-8","ASCII"]', 'rules' => 'required&string&string.charset:["UTF-8","ASCII"]', 'expression' => '1&1&1', ], ], // other validations ... ]; // you can also simply use the static helper Validator::validateData($data, $validations);">
 use MAKS  mighty  Validator ;
use App  Service  HaveIBeenPwnedService as PasswordService ;

$ validator = new Validator ();

$ data = [
    ' name '       => ' John Doe ' ,
    ' age '        => 32 ,
    ' email '      => ' [email protected] ' ,
    ' username '   => ' john.doe ' ,
    ' password '   => ' Secret@123 ' ,
    ' image '      => ' /path/to/image.png ' ,
    ' submission ' => ' now ' ,
    ' consent '    => ' yes ' ,
    ' data '       => [
        ' nickname ' => ' JOE ' ,
        ' number '   => 7 ,
        ' hobbies '  => [
            ' coding ' ,
            ' cooking ' ,
            ' reading ' ,
        ]
    ],
];

$ validations = [
    ' name '           => $ validator -> validation ()-> required ()-> string ()-> stringCharset ([ ' UTF-8 ' , ' ASCII ' ])-> pessimistic (),
    // or using mVEL => required&string&string.charset:'["UTF-8","ASCII"]'
    ' age '            => $ validator -> validation ()-> required ()-> integer ()-> min ( 18 ),
    // or using mVEL => required&integer&min:18
    ' email '          => $ validator -> validation ()-> required ()-> email ()-> macro ( ' gmail ' ),
    // or using mVEL => required&email&[gmail]
    ' username '       => $ validator -> validation ()-> required ()-> username (),
    // or using mVEL => required&username
    ' password '       => $ validator -> validation ()-> required ()-> password ()-> callback ( fn ( $ input ) => !PasswordService:: isPwned ( $ input )),
    // or using mVEL => required&password (NOTE: callback ist not possible, it requires a Validation::class instance that is bound to the Validator::class instance)
    ' image '          => $ validator -> validation ()-> null ()-> xor ()-> group ( fn () => $ this -> image ()-> imageDimensions ( 1920 , 1080 , ' <= ' )),
    // or using mVEL => null^(image&image.dimensions:1920,1080,"<=")
    ' submission '     => $ validator -> validation ()-> required ()-> datetime ()-> datetimeLt ( ' 2022-12-07 ' ),
    // or using mVEL => required&datetime&datetime.lt:"2022-12-07"
    ' consent '        => $ validator -> validation ()-> assert ( ' ${age.value} ' , 18 , ' >= ' )-> or ()-> accepted ()-> or ()-> assertEquals ( ' ${this} ' , ' granted ' )-> optimistic (),
    // or using mVEL => ?assert:${age.value},18,">="|accepted|assert.equals:${this},"granted"
    ' data '           => $ validator -> validation ()-> required ()-> array ()-> arrayHasKey ( ' nickname ' ),
    // or using mVEL => required&array&array.hasKey:"nickname"
    ' data.* '         => $ validator -> validation ()-> scalar ()-> or ()-> array ()-> optimistic (),
    // or using mVEL => ?scalar|array
    ' data.nickname '  => $ validator -> validation ()-> string ()-> min ( 2 )-> max ( 32 ),
    // or using mVEL => string&min:2&max:32
    ' data.hobbies.* ' => $ validator -> validation ()-> ifEq ( ' ${data.hobbies.validations.array} ' , false )-> or ()-> group ( fn () => $ this -> string ()-> min ( 3 )),
    // or using mVEL => if.eq:${data.hobbies.validations.array},false|(string&min:3)
];

$ labels = [
    ' name '     => ' Name ' ,
    ' age '      => ' Age ' ,
    ' email '    => ' E-Mail ' ,
    ' password ' => ' Password ' ,
    ' image '    => ' Image ' ,
    ' data '     => ' Data ' ,
    ' data.* '   => ' Value of data ' ,
    ' consent '  => ' Consent ' ,
];

$ messages = [
    ' * ' => [ // this will be expanded for all fields
        ' required ' => ' ${@label} is a required field. ' ,
    ],
    ' age ' => [
        ' min ' => ' ${@label} must be at least ${@arguments.0}. ' ,
    ],
    ' username ' => [
        ' matches ' => ' ${@label} must contain letters, numbers, and the following characters ".-_" only. ' ,
    ],
    ' consent ' => [
        ' assert ' => ' You must be at least ${@arguments.1} years old to submit this form. ' ,
    ]
];

$ validator
    -> setData ( $ data )
    -> setValidations ( $ validations )
    -> setMessages ( $ messages )
    -> setLabels ( $ labels )
    -> validate ();

$ results = $ validator -> getResults ();

// $result should look something like this:
[
    // this will actually be a Result object
    // array syntax is used here for demonstration purposes
    ' name ' => [
        ' key ' => ' name ' ,
        ' value ' => ' John Doe ' ,
        ' result ' => true ,
        ' validations ' => [
            ' required ' => true ,
            ' string ' => true ,
            ' string.charset ' => true ,
        ],
        ' errors ' => [],
        ' metadata ' => [
            ' basis ' => ' !required&string&string.charset:["UTF-8","ASCII"] ' ,
            ' rules ' => ' required&string&string.charset:["UTF-8","ASCII"] ' ,
            ' expression ' => ' 1&1&1 ' ,
        ],
    ],
    // other validations ...
];

// you can also simply use the static helper Validator::validateData($data, $validations);

■ Petunjuk: Saat memberikan penggantian pesan ke Validator::class , disarankan untuk menggunakan RuleValidation::class untuk menyetel kunci array. Kelas ini berisi semua nama aturan bawaan mighty sebagai konstanta kelas.

Memperluas Validator

Validator dapat diperluas dengan tiga cara:

  • Dengan menambahkan aturan.
  • Dengan menambahkan alias.
  • Dengan menambahkan makro.
mightyValidator; use MAKS mighty Rule; $validator = new Validator(); // adding a new rule $validator->addRule( (new Rule()) ->name('equals') ->arguments(['string']) ->callback(fn (string $input, mixed $expected): bool => $input == $expected) ->parameters(['@input', '@arguments.0']) ->comparison(['@output', '===', true]) ->example('equals:value') ->description('Asserts that the input is equal to the given value.') ); // adding a new rule alias $validator->addRuleAlias('eq', 'equals'); // adding a new rules macro $validator->addRuleMacro('gmail', 'string&email&matches:"/@gmail.com$/i"'); $results = $validator->validateAll( [ 'name' => 'John', 'email' => '[email protected]', ], [ 'name' => 'eq:John', 'email' => 'required&[gmail]', ] ); // $results should look like this: [ // items will actually be a Result object // array syntax is used here for demonstration purposes 'name' => [ 'key' => 'name', 'value' => 'John', 'result' => true, 'validations' => [ 'eq' => true, ], 'errors' => [], 'metadata' => [ 'basis' => 'eq:John', 'rules' => 'eq:John', 'expression' => '1', ], ], 'email' => [ 'key' => 'email', 'value' => '[email protected]', 'result' => false, 'validations' => [ 'required' => true, 'string' => true, 'email' => true, 'matches' => false, ],, 'errors' => [], 'metadata' => [ 'basis' => 'required&[gmail]', 'rules' => 'required&(string&email&matches:"/@gmail.com$/i")', 'expression' => '1&(1&1&0)', ], ], ];">
 use MAKS  mighty  Validator ;
use MAKS  mighty  Rule ;

$ validator = new Validator ();

// adding a new rule
$ validator -> addRule (
    ( new Rule ())
        -> name ( ' equals ' )
        -> arguments ([ ' string ' ])
        -> callback ( fn ( string $ input , mixed $ expected ): bool => $ input == $ expected )
        -> parameters ([ ' @input ' , ' @arguments.0 ' ])
        -> comparison ([ ' @output ' , ' === ' , true ])
        -> example ( ' equals:value ' )
        -> description ( ' Asserts that the input is equal to the given value. ' )
);

// adding a new rule alias
$ validator -> addRuleAlias ( ' eq ' , ' equals ' );

// adding a new rules macro
$ validator -> addRuleMacro ( ' gmail ' , ' string&email&matches:"/@gmail.com$/i" ' );

$ results = $ validator -> validateAll (
    [
        ' name '  => ' John ' ,
        ' email ' => ' [email protected] ' ,
    ],
    [
        ' name '  => ' eq:John ' ,
        ' email ' => ' required&[gmail] ' ,
    ]
);

// $results should look like this:
[
    // items will actually be a Result object
    // array syntax is used here for demonstration purposes
    ' name ' => [
        ' key ' => ' name ' ,
        ' value ' => ' John ' ,
        ' result ' => true ,
        ' validations ' => [
            ' eq ' => true ,
        ],
        ' errors ' => [],
        ' metadata ' => [
            ' basis ' => ' eq:John ' ,
            ' rules ' => ' eq:John ' ,
            ' expression ' => ' 1 ' ,
        ],
    ],
    ' email ' => [
        ' key ' => ' email ' ,
        ' value ' => ' [email protected] ' ,
        ' result ' => false ,
        ' validations ' => [
            ' required ' => true ,
            ' string ' => true ,
            ' email ' => true ,
            ' matches ' => false ,
        ],,
        ' errors ' => [],
        ' metadata ' => [
            ' basis ' => ' required&[gmail] ' ,
            ' rules ' => ' required&(string&email&matches:"/@gmail.com$/i") ' ,
            ' expression ' => ' 1&(1&1&0) ' ,
        ],
    ],
];

■ Petunjuk: Lihat rules default, aliases , dan macros Validator untuk melihat contoh lainnya.

Kendala

mighty terdiri dari lebih dari 250 aturan/atribut yang dapat digunakan untuk memvalidasi data atau nilai kelas, konstanta kelas, properti, dan metode.

Atribut dibagi menjadi tiga kelompok utama:

  1. Atribut Kendala Generik
  2. Atribut Batasan Khusus
  3. Atribut Batasan Aturan

Grup Atribut Kendala Generik

Atribut Kendala Generik terletak di bawah namespace MAKS mighty Validation .

Grup ini saat ini hanya terdiri dari satu atribut saja; itulah atribut Constraint . Atribut ini memerlukan Ekspresi Validasi untuk memvalidasi data yang diterapkannya. Ini juga merupakan kelas dasar untuk semua atribut lainnya.

Grup Atribut Kendala Khusus

Atribut Batasan Khusus terletak di bawah namespace MAKS mighty ValidationConstraint .

Grup ini berisi atribut yang melakukan pekerjaan tertentu yang hanya tersedia dalam konteks atribut. Ini terdiri dari atribut berikut:

  • Rule : Atribut ini digunakan untuk memvalidasi data apa pun menggunakan aturan validasi tunggal. Ini juga merupakan kelas dasar untuk semua atribut di Grup Atribut Batasan Aturan.
  • Callback : Atribut ini digunakan untuk memvalidasi data apa pun menggunakan fungsi panggilan balik.
  • Valid : Atribut ini digunakan untuk memvalidasi keabsahan suatu objek yang dapat divalidasi.
  • Shape : Atribut ini digunakan untuk memvalidasi bentuk array atau objek. Perhatikan bahwa ini adalah satu-satunya atribut yang memvalidasi sekumpulan nilai (data terstruktur) dan bukan hanya satu nilai.
  • Compound : Atribut ini digunakan untuk menggabungkan serangkaian batasan untuk membangun Ekspresi Validasi. Batasan dapat digabungkan menggunakan operator apa pun, dan juga dapat memiliki perilaku. Ini berfungsi sebagai cara berorientasi objek untuk membangun Ekspresi Validasi.

■ Catatan: Perhatikan bahwa batasan yang diperbolehkan untuk digunakan dengan Shape::class dan Compound::class harus merupakan instance aktual dari Constraint::class , Rule::class , atau Compound::class . Callback::class , Valid::class , atau Shape::class dari Grup Atribut Kendala Khusus TIDAK diperbolehkan. Jika Anda memerlukan fitur ini, buka terbitan dan kita akan mendiskusikan penerapannya

Grup Atribut Batasan Aturan

Atribut Batasan Aturan terletak di bawah namespace MAKS mighty ValidationConstraintRule .

Grup ini berisi atribut yang didasarkan pada aturan validasi tunggal. Ini terdiri dari sebagian besar atribut yang disediakan mighty . Lihat bagian Validasi untuk daftar lengkap.

Menambahkan Batasan Kustom

mighty memiliki banyak sekali batasan bawaan, sangat jarang Anda membutuhkan apa pun selain yang disediakan mighty . Meskipun demikian, terkadang muncul kebutuhan akan batasan khusus, berikut cara mencapainya:

mightyRule; use MAKS mighty Result; use MAKS mighty ValidationStrategy; use MAKS mighty ValidationConstraint; use MAKS mighty ValidationConstraintValidatesOne; // use the ValidatesMany interface if your Constraint returns a collection of Result objects use MAKS mighty ValidationConstraintValidatesMany; #[Attribute( Attribute::TARGET_PROPERTY | Attribute::TARGET_METHOD )] class MyCustomConstraint extends Constraint implements ValidatesOne { public function __construct( ?string $message = null, Strategy $strategy = Strategy::FailFast, ) { parent::__construct( validation: 'app.myCustomConstraint', messages: ['app.myCustomConstraint' => $message], strategy: $strategy ); } public function validate(mixed $value = null): Result { // it is really up to you, how you handle this // you will just work with a normal mighty Validator // here we're just preparing the data to pass to the Validator $name = ''; $data = [$name => $value]; $validations = [$name => $this->validation]; $messages = [$name => [$this->validation => $this->messages[$this->validation] ?? null]]; $labels = [$name => static::class]; // you can reuse the built-in rules or // add you own Rule that handles your custom logic $result = $this ->getValidator() ->addRule( // see MAKS mighty Rule for more info (new Rule()) ->setName('app.myCustomConstraint') ->setCallback(static fn ($input) => $input /* here comes your logic */) ->setParameters(['@input']) // rule callback dependencies ->setMessage('${@label} must follow my custom constraint validation.') // this is the default message ) ->setData($data) ->setValidations($validations) ->setMessages($messages) ->setLabels($labels) ->validate(); return $result[$name]; // if you implement ValidatesMany, you will just return $result } }">
 <?php

declare (strict_types= 1 );

namespace App  Validation  Constraint ;

use Attribute ;
use MAKS  mighty  Rule ;
use MAKS  mighty  Result ;
use MAKS  mighty  Validation  Strategy ;
use MAKS  mighty  Validation  Constraint ;
use MAKS  mighty  Validation  Constraint  ValidatesOne ;
// use the ValidatesMany interface if your Constraint returns a collection of Result objects
use MAKS  mighty  Validation  Constraint  ValidatesMany ;

#[Attribute(
    Attribute:: TARGET_PROPERTY |
    Attribute:: TARGET_METHOD
)]
class MyCustomConstraint extends Constraint implements ValidatesOne
{
    public function __construct (
        ? string $ message = null ,
        Strategy $ strategy = Strategy::FailFast,
    ) {
        parent :: __construct (
            validation: ' app.myCustomConstraint ' ,
            messages: [ ' app.myCustomConstraint ' => $ message ],
            strategy: $ strategy
        );
    }


    public function validate ( mixed $ value = null ): Result
    {
        // it is really up to you, how you handle this
        // you will just work with a normal mighty Validator
        // here we're just preparing the data to pass to the Validator
        $ name        = '' ;
        $ data        = [ $ name => $ value ];
        $ validations = [ $ name => $ this -> validation ];
        $ messages    = [ $ name => [ $ this -> validation => $ this -> messages [ $ this -> validation ] ?? null ]];
        $ labels      = [ $ name => static ::class];

        // you can reuse the built-in rules or
        // add you own Rule that handles your custom logic
        $ result = $ this
            -> getValidator ()
            -> addRule (
                // see MAKS mighty Rule for more info
                ( new Rule ())
                    -> setName ( ' app.myCustomConstraint ' )
                    -> setCallback ( static fn ( $ input ) => $ input /* here comes your logic */ )
                    -> setParameters ([ ' @input ' ]) // rule callback dependencies
                    -> setMessage ( ' ${@label} must follow my custom constraint validation. ' ) // this is the default message
            )
            -> setData ( $ data )
            -> setValidations ( $ validations )
            -> setMessages ( $ messages )
            -> setLabels ( $ labels )
            -> validate ();

        return $ result [ $ name ]; // if you implement ValidatesMany, you will just return $result
    }
}

■ Catatan: Batasan khusus dianggap sebagai bagian dari Grup Atribut Batasan Khusus (yaitu tidak boleh digunakan dengan/di dalam Shape::class dan Compound::class )

Validasi

Tabel berikut mencantumkan semua aturan yang tersedia termasuk atribut dan Metode yang setara:

Aturan dan Alias

  • Validation::class
  • Constraint::class dan Constraint/Rule/*
TIDAK. Aturan Keterangan Atribut / Metode
001 Nama: null
Penggunaan: null		 Menegaskan bahwa inputnya nol. Atribut:
NullConstraint::class
Metode:
Validation::null()
002 Nama: boolean
Penggunaan: boolean		 Menegaskan bahwa inputnya adalah boolean. Atribut:
Boolean::class
Metode:
Validation::boolean()
003 Nama: integer
Penggunaan: integer		 Menegaskan bahwa inputnya adalah bilangan bulat. Atribut:
Integer::class
Metode:
Validation::integer()
004 Nama: float
Penggunaan: float		 Menegaskan bahwa inputnya adalah float. Atribut:
FloatConstraint::class
Metode:
Validation::float()
005 Nama: numeric
Penggunaan: numeric		 Menegaskan bahwa inputnya berupa angka. Atribut:
NumericConstraint::class
Metode:
Validation::numeric()
006 Nama: string
Penggunaan: string		 Menegaskan bahwa inputnya adalah string. Atribut:
StringConstraint::class
Metode:
Validation::string()
007 Nama: scalar
Penggunaan: scalar		 Menegaskan bahwa inputnya adalah skalar. Atribut:
Scalar::class
Metode:
Validation::scalar()
008 Nama: array
Penggunaan: array		 Menegaskan bahwa inputnya adalah array. Atribut:
ArrayConstraint::class
Metode:
Validation::array()
009 Nama: object
Penggunaan: object		 Menegaskan bahwa inputnya adalah sebuah objek. Atribut:
ObjectConstraint::class
Metode:
Validation::object()
010 Nama: callable
Penggunaan: callable		 Menegaskan bahwa input dapat dipanggil. Atribut:
CallableConstraint::class
Metode:
Validation::callable()
011 Nama: iterable
Penggunaan: iterable		 Menegaskan bahwa masukannya dapat diubah. Atribut:
IterableConstraint::class
Metode:
Validation::iterable()
012 Nama: countable
Penggunaan: countable		 Menegaskan bahwa inputnya dapat dihitung. Atribut:
Countable::class
Metode:
Validation::countable()
013 Nama: resource
Penggunaan: resource		 Menegaskan bahwa masukan adalah sumber daya. Atribut:
ResourceConstraint::class
Metode:
Validation::resource()
014 Nama: type
Penggunaan: type:'["int","float"]'		 Menegaskan bahwa input adalah salah satu tipe yang diberikan. Atribut:
Type::class
Metode:
Validation::type(string|array $type)
015 Nama: type.debug
Penggunaan: type.debug:string		 Menegaskan bahwa input adalah tipe tertentu menggunakan get_debug_type(). Atribut:
TypeDebug::class
Metode:
Validation::typeDebug(string $type)
016 Nama: alpha
Penggunaan: alpha		 Menegaskan bahwa input hanya terdiri dari karakter alfabet. Atribut:
Alpha::class
Metode:
Validation::alpha()
017 Nama: alnum
Penggunaan: alnum		 Menegaskan bahwa input hanya terdiri dari karakter alfanumerik. Atribut:
Alnum::class
Metode:
Validation::alnum()
018 Nama: lower
Penggunaan: lower		 Menegaskan bahwa input hanya terdiri dari karakter huruf kecil. Atribut:
Lower::class
Metode:
Validation::lower()
019 Nama: upper
Penggunaan: upper		 Menegaskan bahwa input hanya terdiri dari karakter huruf besar. Atribut:
Upper::class
Metode:
Validation::upper()
020 Nama: cntrl
Penggunaan: cntrl		 Menegaskan bahwa input hanya terdiri dari karakter kontrol. Atribut:
Cntrl::class
Metode:
Validation::cntrl()
021 Nama: space
Penggunaan: space		 Menegaskan bahwa input hanya terdiri dari karakter spasi putih. Atribut:
Space::class
Metode:
Validation::space()
022 Nama: punct
Penggunaan: punct		 Menegaskan bahwa input hanya terdiri dari karakter tanda baca. Atribut:
Punct::class
Metode:
Validation::punct()
023 Nama: graph
Penggunaan: graph		 Menegaskan bahwa masukan hanya terdiri dari karakter grafis (karakter yang menghasilkan keluaran yang terlihat). Atribut:
Graph::class
Metode:
Validation::graph()
024 Nama: print
Penggunaan: print		 Menegaskan bahwa input hanya terdiri dari karakter yang dapat dicetak. Atribut:
PrintConstraint::class
Metode:
Validation::print()
025 Nama: digit
Penggunaan: digit		 Menegaskan bahwa input hanya terdiri dari digit (karakter numerik). Atribut:
Digit::class
Metode:
Validation::digit()
026 Nama: xdigit
Penggunaan: xdigit		 Menegaskan bahwa input mewakili digit heksadesimal. Atribut:
Xdigit::class
Metode:
Validation::xdigit()
027 Nama: booleanLike
Penggunaan: booleanLike		 Menegaskan bahwa input adalah nilai yang dapat diuraikan sebagai boolean (TRUE: true, "true", "1", "on", "yes"; FALSE: false, "false", "0", "off" , "tidak", "", batal). Atribut:
BooleanLike::class
Metode:
Validation::booleanLike()
028 Nama: integerLike
Penggunaan: integerLike:0,100		 Menegaskan bahwa input adalah nilai yang dapat diurai sebagai bilangan bulat dalam rentang yang ditentukan. Atribut:
IntegerLike::class
Metode:
Validation::integerLike(int $min = PHP_INT_MIN, int $max = PHP_INT_MAX)
029 Nama: integerLike.allowOctal
Penggunaan: integerLike.allowOctal:0,100		 Menegaskan bahwa masukan adalah nilai yang dapat diurai sebagai bilangan bulat dalam rentang yang ditentukan dan dapat dalam notasi oktal. Atribut:
IntegerLikeAllowOctal::class
Metode:
Validation::integerLikeAllowOctal(int $min = PHP_INT_MIN, int $max = PHP_INT_MAX)
030 Nama: integerLike.allowHex
Penggunaan: integerLike.allowHex:0,100		 Menegaskan bahwa masukan adalah nilai yang dapat diuraikan sebagai bilangan bulat dalam rentang yang ditentukan dan dapat dalam notasi heksadesimal. Atribut:
IntegerLikeAllowHex::class
Metode:
Validation::integerLikeAllowHex(int $min = PHP_INT_MIN, int $max = PHP_INT_MAX)
031 Nama: floatLike
Penggunaan: floatLike:1.0,100.0		 Menegaskan bahwa input adalah nilai yang dapat diurai sebagai float dalam rentang yang ditentukan. Atribut:
FloatLike::class
Metode:
Validation::floatLike(float $min = PHP_FLOAT_MIN, float $max = PHP_FLOAT_MAX)
032 Nama: floatLike.allowThousands
Penggunaan: floatLike.allowThousands:1.0,100.0		 Menegaskan bahwa input adalah nilai yang dapat diurai sebagai float dalam rentang yang ditentukan. Atribut:
FloatLikeAllowThousands::class
Metode:
Validation::floatLikeAllowThousands(float $min = PHP_FLOAT_MIN, float $max = PHP_FLOAT_MAX)
033 Nama: regexp
Penggunaan: regexp:"/[az]/i"		 Menegaskan bahwa masukan cocok dengan ekspresi reguler yang kompatibel dengan Perl. Atribut:
Regexp::class
Metode:
Validation::regexp(string $pattern)
034 Nama: ip
Penggunaan: ip		 Menegaskan bahwa inputnya adalah alamat IP. Atribut:
Ip::class
Metode:
Validation::ip()
035 Nama: ip.v4
Penggunaan: ip.v4		 Menegaskan bahwa inputnya adalah alamat IPv4. Atribut:
IpV4::class
Metode:
Validation::ipV4()
036 Nama: ip.v6
Penggunaan: ip.v6		 Menegaskan bahwa inputnya adalah alamat IPv6. Atribut:
IpV6::class
Metode:
Validation::ipV6()
037 Nama: ip.notReserved
Penggunaan: ip.notReserved		 Menegaskan bahwa input adalah alamat IP yang tidak berada dalam rentang IP yang dicadangkan. Atribut:
IpNotReserved::class
Metode:
Validation::ipNotReserved()
038 Nama: ip.notPrivate
Penggunaan: ip.notPrivate		 Menegaskan bahwa inputnya adalah alamat IP yang tidak berada dalam rentang IP pribadi. Atribut:
IpNotPrivate::class
Metode:
Validation::ipNotPrivate()
039 Nama: mac
Penggunaan: mac		 Menegaskan bahwa inputnya adalah alamat MAC. Atribut:
Mac::class
Metode:
Validation::mac()
040 Nama: url
Penggunaan: url		 Menegaskan bahwa inputnya adalah URL. Atribut:
Url::class
Metode:
Validation::url()
041 Nama: url.withPath
Penggunaan: url.withPath		 Menegaskan bahwa masukan adalah URL yang berisi jalur. Atribut:
UrlWithPath::class
Metode:
Validation::urlWithPath()
042 Nama: url.withQuery
Penggunaan: url.withQuery		 Menegaskan bahwa masukan adalah URL yang berisi kueri. Atribut:
UrlWithQuery::class
Metode:
Validation::urlWithQuery()
043 Nama: email
Penggunaan: email		 Menegaskan bahwa inputnya adalah alamat email. Atribut:
Email::class
Metode:
Validation::email()
044 Nama: email.withUnicode
Penggunaan: email.withUnicode		 Menegaskan bahwa inputnya adalah alamat email (unicode diperbolehkan). Atribut:
EmailWithUnicode::class
Metode:
Validation::emailWithUnicode()
045 Nama: domain
Penggunaan: domain		 Menegaskan bahwa inputnya adalah domain. Atribut:
Domain::class
Metode:
Validation::domain()
046 Nama: domain.isActive
Penggunaan: domain.isActive		 Menegaskan bahwa input adalah domain aktif. Bekerja dengan domain dan email. Atribut:
DomainIsActive::class
Metode:
Validation::domainIsActive()
047 Nama: file
Penggunaan: file		 Menegaskan bahwa inputnya adalah file (bisa berupa file, link, atau direktori). Atribut:
File::class
Metode:
Validation::file()
048 Nama: file.isFile
Penggunaan: file.isFile		 Menegaskan bahwa inputnya adalah file. Atribut:
FileIsFile::class
Metode:
Validation::fileIsFile()
049 Nama: file.isLink
Penggunaan: file.isLink		 Menegaskan bahwa masukannya adalah tautan. Atribut:
FileIsLink::class
Metode:
Validation::fileIsLink()
050 Nama: file.isDirectory
Penggunaan: file.isDirectory		 Menegaskan bahwa inputnya adalah direktori. Atribut:
FileIsDirectory::class
Metode:
Validation::fileIsDirectory()
051 Nama: file.isExecutable
Penggunaan: file.isExecutable		 Menegaskan bahwa input adalah file dan dapat dieksekusi. Atribut:
FileIsExecutable::class
Metode:
Validation::fileIsExecutable()
052 Nama: file.isWritable
Penggunaan: file.isWritable		 Menegaskan bahwa input adalah file dan dapat ditulis. Atribut:
FileIsWritable::class
Metode:
Validation::fileIsWritable()
053 Nama: file.isReadable
Penggunaan: file.isReadable		 Menegaskan bahwa input adalah file dan dapat dibaca. Atribut:
FileIsReadable::class
Metode:
Validation::fileIsReadable()
054 Nama: file.isUploaded
Penggunaan: file.isUploaded		 Menegaskan bahwa inputnya adalah file yang diupload melalui HTTP POST. Atribut:
FileIsUploaded::class
Metode:
Validation::fileIsUploaded()
055 Nama: file.size
Penggunaan: file.size:1024		 Menegaskan bahwa masukan adalah file dan ukurannya sama dengan ukuran yang diberikan dalam byte. Atribut:
FileSize::class
Metode:
Validation::fileSize(int $sizeInBytes)
056 Nama: file.size.lte
Penggunaan: file.size.lte:1024		 Menegaskan bahwa masukan adalah file dan ukurannya kurang dari atau sama dengan ukuran yang diberikan dalam byte. Atribut:
FileSizeLte::class
Metode:
Validation::fileSizeLte(int $sizeInBytes)
057 Nama: file.size.gte
Penggunaan: file.size.gte:1024		 Menegaskan bahwa masukan adalah file dan ukurannya lebih besar dari atau sama dengan ukuran yang diberikan dalam byte. Atribut:
FileSizeGte::class
Metode:
Validation::fileSizeGte(int $sizeInBytes)
058 Nama: file.dirname
Penggunaan: file.dirname:/path/to/dir		 Menegaskan bahwa inputnya adalah file dan nama dirnya sama dengan nama dirname yang diberikan. Atribut:
FileDirname::class
Metode:
Validation::fileDirname(string $dirname)
059 Nama: file.basename
Penggunaan: file.basename:file.ext		 Menegaskan bahwa inputnya adalah file dan nama dasarnya sama dengan nama dasar yang diberikan. Atribut:
FileBasename::class
Metode:
Validation::fileBasename(string $basename)
060 Nama: file.filename
Penggunaan: file.filename:file		 Menegaskan bahwa inputnya adalah file dan nama filenya sama dengan nama file yang diberikan. Atribut:
FileFilename::class
Metode:
Validation::fileFilename(string $filename)
061 Nama: file.extension
Penggunaan: file.extension:ext		 Menegaskan bahwa inputnya adalah file dan ekstensinya sama dengan ekstensi yang diberikan. Atribut:
FileExtension::class
Metode:
Validation::fileExtension(string $extension)
062 Nama: file.mime
Penggunaan: file.mime:text/plain		 Menegaskan bahwa inputnya adalah file dan tipe MIME-nya adalah salah satu tipe MIME yang diberikan. Atribut:
FileMime::class
Metode:
Validation::fileMime(string|array $mine)
063 Nama: image
Penggunaan: image		 Menegaskan bahwa inputnya adalah file gambar (jpg, jpeg, png, gif, bmp, svg, atau webp). Atribut:
Image::class
Metode:
Validation::image()
064 Nama: image.width
Penggunaan: image.width:1920		 Menegaskan bahwa masukannya adalah gambar dan lebarnya sama dengan lebar yang diberikan dalam piksel. Atribut:
ImageWidth::class
Metode:
Validation::imageWidth(int $width)
065 Nama: image.width.lte
Penggunaan: image.width.lte:1920		 Menegaskan bahwa masukannya adalah gambar dan lebarnya kurang dari atau sama dengan lebar tertentu dalam piksel. Atribut:
ImageWidthLte::class
Metode:
Validation::imageWidthLte(int $width)
066 Nama: image.width.gte
Penggunaan: image.width.gte:1920		 Menegaskan bahwa masukannya adalah gambar dan lebarnya lebih besar atau sama dengan lebar yang ditentukan dalam piksel. Atribut:
ImageWidthGte::class
Metode:
Validation::imageWidthGte(int $width)
067 Nama: image.height
Penggunaan: image.height:1080		 Menegaskan bahwa masukannya adalah gambar dan tingginya sama dengan tinggi tertentu dalam piksel. Atribut:
ImageHeight::class
Metode:
Validation::imageHeight(int $height)
068 Nama: image.height.lte
Penggunaan: image.height.lte:1080		 Menegaskan bahwa masukannya adalah gambar dan tingginya kurang dari atau sama dengan tinggi tertentu dalam piksel. Atribut:
ImageHeightLte::class
Metode:
Validation::imageHeightLte(int $height)
069 Nama: image.height.gte
Penggunaan: image.height.gte:1080		 Menegaskan bahwa masukannya adalah gambar dan tingginya lebih besar atau sama dengan tinggi tertentu dalam piksel. Atribut:
ImageHeightGte::class
Metode:
Validation::imageHeightGte(int $height)
070 Nama: image.dimensions
Penggunaan: image.dimensions:1920,1080,==		 Menegaskan bahwa masukannya adalah gambar dan dimensinya kurang dari, sama dengan, atau lebih besar dari lebar dan tinggi tertentu dalam piksel. Atribut:
ImageDimensions::class
Metode:
Validation::imageDimensions(int $width, int $height, string $operator = '==')
071 Nama: image.ratio
Penggunaan: image.ratio:16:9		 Menegaskan bahwa masukannya adalah gambar dan rasio aspeknya sama dengan rasio yang diberikan (rasio harus ditentukan sebagai pecahan seperti "16/9"). Atribut:
ImageRatio::class
Metode:
Validation::imageRatio(string $ratio)
072 Nama: if
Penggunaan: if:7,7,==		 Memeriksa kondisi antara argumen pertama dan argumen kedua, operator kondisi juga dapat ditentukan sebagai argumen ketiga. Atribut:
IfConstraint::class
Metode:
Validation::if(mixed $actual, mixed $expected = true, string $operator = '==')
073 Nama: if.eq
Penggunaan: if.eq:3,3		 Memeriksa kondisi antara argumen pertama dan argumen kedua, operator kondisinya adalah "==". Atribut:
IfEq::class
Metode:
Validation::ifEq(mixed $actual, mixed $expected)
074 Nama: if.neq
Penggunaan: if.neq:1,2		 Memeriksa kondisi antara argumen pertama dan argumen kedua, operator kondisinya adalah "!=". Atribut:
IfNeq::class
Metode:
Validation::ifNeq(mixed $actual, mixed $expected)
075 Nama: if.id
Penggunaan: if.id:3,3		 Memeriksa kondisi antara argumen pertama dan argumen kedua, operator kondisinya adalah "===". Atribut:
IfId::class
Metode:
Validation::ifId(mixed $actual, mixed $expected)
076 Nama: if.nid
Penggunaan: if.nid:1,2		 Memeriksa kondisi antara argumen pertama dan argumen kedua, operator kondisinya adalah "!==". Atribut:
IfNid::class
Metode:
Validation::ifNid(mixed $actual, mixed $expected)
077 Nama: if.gt
Penggunaan: if.gt:2,1		 Memeriksa kondisi antara argumen pertama dan argumen kedua, operator kondisinya adalah ">". Atribut:
IfGt::class
Metode:
Validation::ifGt(mixed $actual, mixed $expected)
078 Nama: if.gte
Penggunaan: if.gte:2,2		 Memeriksa kondisi antara argumen pertama dan argumen kedua, operator kondisinya adalah ">=". Atribut:
IfGte::class
Metode:
Validation::ifGte(mixed $actual, mixed $expected)
079 Nama: if.lt
Penggunaan: if.lt:1,2		 Memeriksa kondisi antara argumen pertama dan argumen kedua, operator kondisinya adalah "<". Atribut:
IfLt::class
Metode:
Validation::ifLt(mixed $actual, mixed $expected)
080 Nama: if.lte
Penggunaan: if.lte:1,2		 Memeriksa kondisi antara argumen pertama dan argumen kedua, operator kondisinya adalah "<=". Atribut:
IfLte::class
Metode:
Validation::ifLte(mixed $actual, mixed $expected)
081 Nama: empty
Penggunaan: empty		 Menegaskan bahwa input kosong menggunakan konstruksi bahasa kosong() (kosong, yaitu string kosong, array kosong, false, null, atau 0). Atribut:
EmptyConstraint::class
Metode:
Validation::empty()
082 Nama: required
Penggunaan: required		 Menegaskan bahwa input diperlukan (tidak kosong, yaitu bukan string kosong atau null). Atribut:
Required::class
Metode:
Validation::required()
083 Nama: allowed
Penggunaan: allowed		 Menegaskan bahwa input diperbolehkan (bisa kosong atau memiliki nilai apa pun, string nol dan kosong dianggap sebagai nilai yang valid). Atribut:
Allowed::class
Metode:
Validation::allowed()
084 Nama: forbidden
Penggunaan: forbidden		 Menegaskan bahwa input dilarang (null atau tidak ada). Atribut:
Forbidden::class
Metode:
Validation::forbidden()
085 Nama: accepted
Penggunaan: accepted		 Menegaskan bahwa input diterima (sama dengan: "on", "yes", "yeah", "yep", "yo", "ok", "oke", "aye", 1 atau "1", true atau " true") perhatikan bahwa string diperlakukan dengan cara yang tidak peka huruf besar-kecil. Atribut:
Accepted::class
Metode:
Validation::accepted()
086 Nama: declined
Penggunaan: declined		 Menegaskan bahwa input ditolak (sama dengan: "off", "no", "not", "nope", "neh", "nay", 0 atau "0", false atau "false") perhatikan bahwa string diperlakukan dengan cara yang tidak peka huruf besar-kecil. Atribut:
Declined::class
Metode:
Validation::declined()
087 Nama: bit
Penggunaan: bit		 Menegaskan bahwa masukannya adalah bit (sama dengan: 1 atau "1", benar; 0 atau "0", salah). Atribut:
Bit::class
Metode:
Validation::bit()
088 Nama: bit.isOn
Penggunaan: bit.isOn		 Menegaskan bahwa input adalah bit yang dihidupkan (sama dengan: benar, 1 atau "1"). Atribut:
BitIsOn::class
Metode:
Validation::bitIsOn()
089 Nama: bit.isOff
Penggunaan: bit.isOff		 Menegaskan bahwa input adalah bit yang dimatikan (sama dengan: false, 0 atau "0"). Atribut:
BitIsOff::class
Metode:
Validation::bitIsOff()
090 Nama: equals
Penggunaan: equals:value		 Menegaskan bahwa input sama dengan nilai yang diberikan. Bekerja dengan tipe skalar dan null. Operator perbandingannya adalah "==". Atribut:
Equals::class
Metode:
Validation::equals(string|int|float|bool|null $value)
091 Nama: matches
Penggunaan: matches:'"/^[a-zA-Z0-9]+$/"'		 Menegaskan bahwa masukan cocok dengan pola yang diberikan. Bekerja dengan string saja. Atribut:
Matches::class
Metode:
Validation::matches(string $pattern)
092 Nama: in
Penggunaan: in:val1,val2,...		 Menegaskan bahwa input ada dalam nilai yang diberikan. Bekerja dengan tipe skalar dan null. Atribut:
In::class
Metode:
Validation::in(string|int|float|bool|null ...$values)
093 Nama: count
Penggunaan: count:3		 Menegaskan bahwa jumlah input sama dengan nilai yang diberikan. Bekerja dengan semua tipe data (null: 0; boolean: 0 atau 1; float/integer: nilai angka; string: jumlah karakter; array/dapat dihitung: jumlah elemen; objek: jumlah properti yang dapat diakses). Atribut:
Count::class
Metode:
Validation::count(int $count)
094 Nama: min
Penggunaan: min:3		 Menegaskan bahwa jumlah input lebih besar atau sama dengan nilai yang diberikan. Bekerja dengan semua tipe data (null: 0; boolean: 0 atau 1; float/integer: nilai angka; string: jumlah karakter; array/dapat dihitung: jumlah elemen; objek: jumlah properti yang dapat diakses). Atribut:
Min::class
Metode:
Validation::min(int|float $count)
095 Nama: max
Penggunaan: max:3		 Menegaskan bahwa jumlah input kurang dari atau sama dengan nilai yang diberikan. Bekerja dengan semua tipe data (null: 0; boolean: 0 atau 1; float/integer: nilai angka; string: jumlah karakter; array/dapat dihitung: jumlah elemen; objek: jumlah properti yang dapat diakses). Atribut:
Max::class
Metode:
Validation::max(int|float $count)
096 Nama: between
Penggunaan: between:3,7		 Menegaskan bahwa jumlah input berada di antara nilai yang diberikan. Bekerja dengan semua tipe data (null: 0; boolean: 0 atau 1; float/integer: nilai angka; string: jumlah karakter; array/dapat dihitung: jumlah elemen; objek: jumlah properti yang dapat diakses). Atribut:
Between::class
Metode:
Validation::between(int|float $min, int|float $max)
097 Nama: number.isPositive
Penggunaan: number.isPositive		 Menegaskan bahwa inputnya adalah bilangan positif. Atribut:
NumberIsPositive::class
Metode:
Validation::numberIsPositive()
098 Nama: number.isNegative
Penggunaan: number.isNegative		 Menegaskan bahwa inputnya adalah bilangan negatif. Atribut:
NumberIsNegative::class
Metode:
Validation::numberIsNegative()
099 Nama: number.isEven
Penggunaan: number.isEven		 Menegaskan bahwa inputnya adalah bilangan genap. Atribut:
NumberIsEven::class
Metode:
Validation::numberIsEven()
100 Nama: number.isOdd
Penggunaan: number.isOdd		 Menegaskan bahwa masukannya adalah bilangan ganjil. Atribut:
NumberIsOdd::class
Metode:
Validation::numberIsOdd()
101 Nama: number.isMultipleOf
Penggunaan: number.isMultipleOf:3		 Menegaskan bahwa inputnya adalah kelipatan dari bilangan yang diberikan. Atribut:
NumberIsMultipleOf::class
Metode:
Validation::numberIsMultipleOf(float $number)
102 Nama: number.isFinite
Penggunaan: number.isFinite		 Menegaskan bahwa inputnya adalah bilangan berhingga. Atribut:
NumberIsFinite::class
Metode:
Validation::numberIsFinite()
103 Nama: number.isInfinite
Penggunaan: number.isInfinite		 Menegaskan bahwa inputnya adalah bilangan tak terhingga. Atribut:
NumberIsInfinite::class
Metode:
Validation::numberIsInfinite()
104 Nama: number.isNan
Penggunaan: number.isNan		 Menegaskan bahwa inputnya bukan angka. Atribut:
NumberIsNan::class
Metode:
Validation::numberIsNan()
105 Nama: string.charset
Penggunaan: string.charset:UTF-8		 Menegaskan bahwa input dikodekan dalam salah satu rangkaian karakter yang diberikan (termasuk alias). Pemeriksaan dilakukan dengan peka huruf besar-kecil. Atribut:
StringCharset::class
Metode:
Validation::stringCharset(string|array $charset)
106 Nama: string.contains
Penggunaan: string.contains:substring		 Menegaskan bahwa input berisi substring yang diberikan. Argumen boolean kedua dapat ditentukan untuk mengaktifkan mode ketat (peka huruf besar/kecil). Atribut:
StringContains::class
Metode:
Validation::stringContains(string $substring, bool $strict = false)
107 Nama: string.startsWith
Penggunaan: string.startsWith:substring,1		 Menegaskan bahwa input dimulai dengan substring yang diberikan. Argumen boolean kedua dapat ditentukan untuk mengaktifkan mode ketat (peka huruf besar/kecil). Atribut:
StringStartsWith::class
Metode:
Validation::stringStartsWith(string $substring, bool $strict = false)
108 Nama: string.endsWith
Penggunaan: string.endsWith:substring,0		 Menegaskan bahwa input diakhiri dengan substring yang diberikan. Argumen boolean kedua dapat ditentukan untuk mengaktifkan mode ketat (peka huruf besar/kecil). Atribut:
StringEndsWith::class
Metode:
Validation::stringEndsWith(string $substring, bool $strict = false)
109 Nama: string.length
Penggunaan: string.length:3		 Menegaskan bahwa inputnya adalah string dengan panjang yang ditentukan. Atribut:
StringLength::class
Metode:
Validation::stringLength(int $length)
110 Nama: string.wordsCount
Penggunaan: string.wordsCount:3		 Menegaskan bahwa masukan adalah string yang berisi jumlah kata yang ditentukan secara tepat. Atribut:
StringWordsCount::class
Metode:
Validation::stringWordsCount(int $count)
111 Nama: array.hasKey
Penggunaan: array.hasKey:key		 Menegaskan bahwa array input memiliki kunci yang diberikan. Atribut:
ArrayHasKey::class
Metode:
Validation::arrayHasKey(string|int $key)
112 Nama: array.hasValue
Penggunaan: array.hasValue:value		 Menegaskan bahwa array input berisi nilai yang diberikan. Bekerja dengan tipe skalar. Atribut:
ArrayHasValue::class
Metode:
Validation::arrayHasValue(mixed $value)
113 Nama: array.hasDistinct
Penggunaan: array.hasDistinct:key		 Menegaskan bahwa inputnya adalah array multidimensi yang berisi nilai berbeda dari kunci yang diberikan. Atribut:
ArrayHasDistinct::class
Metode:
Validation::arrayHasDistinct(string|int $key)
114 Nama: array.isAssociative
Penggunaan: array.isAssociative		 Menegaskan bahwa inputnya adalah array asosiatif. Atribut:
ArrayIsAssociative::class
Metode:
Validation::arrayIsAssociative()
115 Nama: array.isSequential
Penggunaan: array.isSequential		 Menegaskan bahwa inputnya adalah array berurutan. Atribut:
ArrayIsSequential::class
Metode:
Validation::arrayIsSequential()
116 Nama: array.isUnique
Penggunaan: array.isUnique		 Menegaskan bahwa array masukan berisi nilai unik. Hanya bekerja dengan array satu dimensi. Atribut:
ArrayIsUnique::class
Metode:
Validation::arrayIsUnique()
117 Nama: array.subset
Penggunaan: array.subset:'{"a":1,"b":2}'		 Menegaskan bahwa inputnya adalah array yang berisi subset tertentu. Perhatikan bahwa pemeriksaan ini hanya berlaku untuk dimensi pertama array. Atribut:
ArraySubset::class
Metode:
Validation::arraySubset(array $subset)
118 Nama: object.hasProperty
Penggunaan: object.hasProperty:property		 Menegaskan bahwa input memiliki properti yang diberikan. Atribut:
ObjectHasProperty::class
Metode:
Validation::objectHasProperty(string $property)
119 Nama: object.hasMethod
Penggunaan: object.hasMethod:method		 Menegaskan bahwa input memiliki metode yang diberikan. Atribut:
ObjectHasMethod::class
Metode:
Validation::objectHasMethod(string $method)
120 Nama: object.isStringable
Penggunaan: object.isStringable		 Menegaskan bahwa input mengimplementasikan metode __toString(). Atribut:
ObjectIsStringable::class
Metode:
Validation::objectIsStringable()
121 Nama: object.isInstanceOf
Penggunaan: object.isInstanceOf:NamespaceClass		 Menegaskan bahwa input adalah turunan dari kelas tertentu. Atribut:
ObjectIsInstanceOf::class
Metode:
Validation::objectIsInstanceOf(string $classFQN)
122 Nama: object.isSubclassOf
Penggunaan: object.isSubclassOf:NamespaceClass		 Menegaskan bahwa input adalah subkelas dari kelas yang diberikan. Atribut:
ObjectIsSubclassOf::class
Metode:
Validation::objectIsSubclassOf(string $classFQN)
123 Nama: serialized
Penggunaan: serialized		 Menegaskan bahwa input adalah data serial PHP yang valid. Atribut:
Serialized::class
Metode:
Validation::serialized()
124 Nama: json
Penggunaan: json		 Menegaskan bahwa inputnya adalah JSON yang valid. Atribut:
Json::class
Metode:
Validation::json()
125 Nama: base64
Penggunaan: base64		 Menegaskan bahwa input adalah string berkode Base64 yang valid. Atribut:
Base64::class
Metode:
Validation::base64()
126 Nama: xml
Penggunaan: xml		 Menegaskan bahwa inputnya adalah XML yang valid. Atribut:
Xml::class
Metode:
Validation::xml()
127 Nama: locale
Penggunaan: locale		 Menegaskan bahwa masukan adalah pengidentifikasi lokal yang valid (default: [ISO 639-1] atau [ISO 639-1]_[ISO 3166-1 alpha-2], peka huruf besar-kecil, masukan dikanonikalisasi sebelum diperiksa (tanda hubung ke garis bawah, tidak ada titik atau rangkaian karakter); ketat: [ISO 639-1] atau [ISO 639-1]_[ISO 3166-1 alpha-2], peka huruf besar-kecil tanpa kanonikalisasi. Atribut:
Locale::class
Metode:
Validation::locale(bool $strict = false)
128 Nama: language
Penggunaan: language		 Menegaskan bahwa masukan adalah kode bahasa yang valid (default: "ISO 639-1"; panjang: "ISO 639-2/T"). Atribut:
Language::class
Metode:
Validation::language(bool $long = false)
129 Nama: country
Penggunaan: country		 Menegaskan bahwa input adalah kode negara yang valid (default: "ISO 3166-1 alpha-2"; panjang: "ISO 3166-1 alpha-3"). Atribut:
Country::class
Metode:
Validation::country(bool $long = false)
130 Nama: timezone
Penggunaan: timezone		 Menegaskan bahwa input adalah pengidentifikasi zona waktu yang valid (default: tidak peka huruf besar-kecil; ketat: peka huruf besar-kecil). Atribut:
Timezone::class
Metode:
Validation::timezone(bool $strict = false)
131 Nama: datetime
Penggunaan: datetime		 Menegaskan bahwa input adalah string/objek datetime yang valid. Atribut:
Datetime::class
Metode:
Validation::datetime()
132 Nama: datetime.eq
Penggunaan: datetime.eq:"2015-01-01"		 Menegaskan bahwa input sama dengan string tanggal dan waktu yang diberikan. Atribut:
DatetimeEq::class
Metode:
Validation::datetimeEq(string $datetime)
133 Nama: datetime.lt
Penggunaan: datetime.lt:tomorrow		 Menegaskan bahwa input adalah string/objek waktu-waktu yang kurang dari (sebelum) string waktu-waktu yang diberikan. Atribut:
DatetimeLt::class
Metode:
Validation::datetimeLt(string $datetime)
134 Nama: datetime.lte
Penggunaan: datetime.lte:tomorrow		 Menegaskan bahwa input adalah string/objek tanggalwaktu yang kurang dari (sebelum) atau sama dengan string tanggalwaktu yang diberikan. Atribut:
DatetimeLte::class
Metode:
Validation::datetimeLte(string $datetime)
135 Nama: datetime.gt
Penggunaan: datetime.gt:today		 Menegaskan bahwa input adalah string/objek tanggalwaktu yang lebih besar dari (setelah) string tanggalwaktu yang diberikan. Atribut:
DatetimeGt::class
Metode:
Validation::datetimeGt(string $datetime)
136 Nama: datetime.gte
Penggunaan: datetime.gte:today		 Menegaskan bahwa input adalah string/objek tanggalwaktu yang lebih besar dari (setelah) atau sama dengan string tanggalwaktu yang diberikan. Atribut:
DatetimeGte::class
Metode:
Validation::datetimeGte(string $datetime)
137 Nama: datetime.birthday
Penggunaan: datetime.birthday		 Menegaskan bahwa inputnya adalah string/objek tanggalwaktu yang berulang tahun hari ini. Input sebaiknya dalam format "YYYY-MM-DD". Atribut:
DatetimeBirthday::class
Metode:
Validation::datetimeBirthday()
138 Nama: datetime.format
Penggunaan: datetime.format:"Ymd H:i:s"		 Menegaskan bahwa inputnya adalah tanggal/waktu yang valid dengan format yang diberikan. Atribut:
DatetimeFormat::class
Metode:
Validation::datetimeFormat(string $format)
139 Nama: datetime.format.global
Penggunaan: datetime.format.global		 Menegaskan bahwa masukan tampak seperti string tanggalwaktu global yang valid seperti yang ditentukan dalam spesifikasi HTML5. Atribut:
DatetimeFormatGlobal::class
Metode:
Validation::datetimeFormatGlobal()
140 Nama: datetime.format.local
Penggunaan: datetime.format.local		 Menegaskan bahwa masukan tampak seperti string tanggalwaktu lokal yang valid seperti yang ditentukan dalam spesifikasi HTML5. Atribut:
DatetimeFormatLocal::class
Metode:
Validation::datetimeFormatLocal()
141 Nama: datestamp
Penggunaan: datestamp		 Menegaskan bahwa masukan tampak seperti stempel tanggal manusia, format DMY atau MDY, dipisahkan dengan titik, tanda hubung, atau garis miring. Atribut:
Datestamp::class
Metode:
Validation::datestamp()
142 Nama: datestamp.ymd
Penggunaan: datestamp.ymd		 Menegaskan bahwa masukan terlihat seperti stempel tanggal berformat YMD manusia, dipisahkan dengan titik, tanda hubung, atau garis miring. Atribut:
DatestampYmd::class
Metode:
Validation::datestampYmd()
143 Nama: datestamp.dmy
Penggunaan: datestamp.dmy		 Menegaskan bahwa masukan terlihat seperti stempel tanggal berformat DMY manusia, dipisahkan dengan titik, tanda hubung, atau garis miring. Atribut:
DatestampDmy::class
Metode:
Validation::datestampDmy()
144 Nama: datestamp.mdy
Penggunaan: datestamp.mdy		 Menegaskan bahwa masukan terlihat seperti stempel tanggal berformat MDY manusia, dipisahkan dengan titik, tanda hubung, atau garis miring. Atribut:
DatestampMdy::class
Metode:
Validation::datestampMdy()
145 Nama: timestamp
Penggunaan: timestamp		 Menegaskan bahwa input terlihat seperti stempel waktu manusia, format 24 atau 12 jam dengan atau tanpa detik. Atribut:
Timestamp::class
Metode:
Validation::timestamp()
146 Nama: timestamp.12
Penggunaan: timestamp.12		 Menegaskan bahwa input terlihat seperti stempel waktu manusia, format 12 jam dengan atau tanpa detik dan opsional AM/PM. Atribut:
Timestamp12::class
Metode:
Validation::timestamp12()
147 Nama: timestamp.hms
Penggunaan: timestamp.hms		 Menegaskan bahwa input terlihat seperti stempel waktu manusia, format 24 atau 12 jam dengan detik. Atribut:
TimestampHms::class
Metode:
Validation::timestampHms()
148 Nama: timestamp.hm
Penggunaan: timestamp.hm		 Menegaskan bahwa input terlihat seperti stempel waktu manusia, format 24 atau 12 jam tanpa detik. Atribut:
TimestampHm::class
Metode:
Validation::timestampHm()
149 Nama: timestamp.ms
Penggunaan: timestamp.ms		 Menegaskan bahwa masukan tampak seperti stempel waktu manusia, hanya berisi menit dan detik. Atribut:
TimestampMs::class
Metode:
Validation::timestampMs()
150 Nama: calender.day
Penggunaan: calender.day		 Menegaskan bahwa masukan tampak seperti hari kalender dalam format shot atau panjang ("Senin" atau "Senin"). Atribut:
CalenderDay::class
Metode:
Validation::calenderDay()
151 Nama: calender.month
Penggunaan: calender.month		 Menegaskan bahwa input tampak seperti bulan kalender dalam format shot atau long ("Jan" atau "January"). Atribut:
CalenderMonth::class
Metode:
Validation::calenderMonth()
152 Nama: username
Penggunaan: username		 Menegaskan bahwa input adalah nama pengguna yang valid (antara 4-32 karakter, terdiri dari huruf apa pun, opsional angka, opsional salah satu karakter berikut "-_." (tidak berurutan), dan harus selalu dimulai dengan huruf dan diakhiri dengan huruf atau angka). Atribut:
Username::class
Metode:
Validation::username()
153 Nama: password
Penggunaan: password		 Menegaskan bahwa yang dimasukkan adalah kata sandi yang valid (minimal 8 karakter, terdiri dari minimal satu huruf kecil dan satu huruf kapital, minimal satu angka, minimal satu karakter khusus, dan opsional spasi). Atribut:
Password::class
Metode:
Validation::password()
154 Nama: uuid
Penggunaan: uuid		 Menegaskan bahwa inputnya adalah UUID yang valid. Versi (v1/v2/v3/v4/v5) dapat ditentukan untuk mempersempit pola. Atribut:
Uuid::class
Metode:
Validation::uuid(string|int|null $version = null)
155 Nama: ascii
Penggunaan: ascii		 Menegaskan bahwa input adalah string yang hanya berisi karakter ASCII (string yang sesuai dengan ASCII). Atribut:
Ascii::class
Metode:
Validation::ascii()
156 Nama: slug
Penggunaan: slug		 Menegaskan bahwa inputnya adalah slug yang valid. Atribut:
Slug::class
Metode:
Validation::slug()
157 Nama: meta
Penggunaan: meta		 Menegaskan bahwa input adalah string yang hanya berisi karakter meta (karakter khusus) (yaitu "@, #, $, ...").. Atribut:
Meta::class
Metode:
Validation::meta()
158 Nama: text
Penggunaan: text		 Menegaskan bahwa inputnya adalah string yang berisi huruf dan tanda baca dari bahasa apa pun. Atribut:
Text::class
Metode:
Validation::text()
159 Nama: words
Penggunaan: words		 Menegaskan bahwa inputnya adalah string yang hanya berisi kata dan spasi tanpa karakter lain. Atribut:
Words::class
Metode:
Validation::words()
160 Nama: spaceless
Penggunaan: spaceless		 Menegaskan bahwa input adalah string yang tidak mengandung karakter spasi. Atribut:
Spaceless::class
Metode:
Validation::spaceless()
161 Nama: emoji
Penggunaan: emoji		 Menegaskan bahwa masukan berisi emoji. Atribut:
Emoji::class
Metode:
Validation::emoji()
162 Nama: roman
Penggunaan: roman		 Menegaskan bahwa yang diinput adalah bilangan romawi yang valid. Atribut:
Roman::class
Metode:
Validation::roman()
163 Nama: phone
Penggunaan: phone		 Menegaskan bahwa yang dimasukkan adalah nomor telepon yang valid (mendukung: Amerika Utara, Eropa, dan sebagian besar negara Asia dan Timur Tengah). Atribut:
Phone::class
Metode:
Validation::phone()
164 Nama: geolocation
Penggunaan: geolocation		 Menegaskan bahwa masukan adalah geolokasi yang valid (kombinasi koordinat lintang dan bujur). Atribut:
Geolocation::class
Metode:
Validation::geolocation()
165 Nama: version
Penggunaan: version		 Menegaskan bahwa masukan adalah nomor versi semantik yang valid. Atribut:
Version::class
Metode:
Validation::version()
166 Nama: amount
Penggunaan: amount		 Menegaskan bahwa input hanya berisi angka, titik desimal opsional (koma atau titik), dan minus opsional (misalnya digunakan untuk sejumlah uang). Atribut:
Amount::class
Metode:
Validation::amount()
167 Nama: amount.dollar
Penggunaan: amount.dollar		 Menegaskan bahwa masukan adalah jumlah USD yang diformat secara valid, dengan koma desimal dan pemisah ribuan bersifat opsional. Atribut:
AmountDollar::class
Metode:
Validation::amountDollar()
168 Nama: amount.euro
Penggunaan: amount.euro		 Menegaskan bahwa masukan adalah jumlah EUR yang diformat secara valid, dengan koma desimal dan pemisah ribuan bersifat opsional. Atribut:
AmountEuro::class
Metode:
Validation::amountEuro()
169 Nama: color
Penggunaan: color		 Menegaskan bahwa input adalah warna CSS yang valid (Kata Kunci "longgar", HEX, HEX-Alpha, RGB, RGBA, RGB "sintaks baru", HSL, HSLA, HSL "sintaks baru"). Atribut:
Color::class
Metode:
Validation::color()
170 Nama: color.hex
Penggunaan: color.hex		 Menegaskan bahwa input adalah warna CSS HEX yang valid. Atribut:
ColorHex::class
Metode:
Validation::colorHex()
171 Nama: color.hexShort
Penggunaan: color.hexShort		 Menegaskan bahwa input adalah warna CSS 3-Char-HEX yang valid. Atribut:
ColorHexShort::class
Metode:
Validation::colorHexShort()
172 Nama: color.hexLong
Penggunaan: color.hexLong		 Menegaskan bahwa input adalah warna CSS 6-Char-HEX yang valid. Atribut:
ColorHexLong::class
Metode:
Validation::colorHexLong()
173 Nama: color.hexAlpha
Penggunaan: color.hexAlpha		 Menegaskan bahwa input adalah warna CSS HEX-Alpha (4 atau 8 Karakter) yang valid. Atribut:
ColorHexAlpha::class
Metode:
Validation::colorHexAlpha()
174 Nama: color.rgb
Penggunaan: color.rgb		 Menegaskan bahwa input adalah warna CSS RGB yang valid. Atribut:
ColorRgb::class
Metode:
Validation::colorRgb()
175 Nama: color.rgba
Penggunaan: color.rgba		 Menegaskan bahwa input adalah warna CSS RGBA yang valid. Atribut:
ColorRgba::class
Metode:
Validation::colorRgba()
176 Nama: color.rgb.new
Penggunaan: color.rgb.new		 Menegaskan bahwa input adalah warna RGB CSS4 yang valid. Atribut:
ColorRgbNew::class
Metode:
Validation::colorRgbNew()
177 Nama: color.hsl
Penggunaan: color.hsl		 Menegaskan bahwa input adalah warna CSS HSL yang valid. Atribut:
ColorHsl::class
Metode:
Validation::colorHsl()
178 Nama : color.hsla
Penggunaan: color.hsla		 Menegaskan bahwa input adalah warna CSS HSLA yang valid. Atribut:
ColorHsla::class
Metode:
Validation::colorHsla()
179 Nama: color.hsl.new
Penggunaan: color.hsl.new		 Menegaskan bahwa input adalah warna CSS4 HSL yang valid. Atribut:
ColorHslNew::class
Metode:
Validation::colorHslNew()
180 Nama: color.keyword
Penggunaan: color.keyword		 Menegaskan bahwa input adalah warna kata kunci CSS yang valid (ketat, seperti dalam spesifikasi CSS). Atribut:
ColorKeyword::class
Metode:
Validation::colorKeyword()
181 Nama: ssn
Penggunaan: ssn		 Menegaskan bahwa input adalah SSN yang valid (nomor jaminan sosial AS). Atribut:
Ssn::class
Metode:
Validation::ssn()
182 Nama: sin
Penggunaan: sin		 Menegaskan bahwa input adalah dosa yang valid (nomor asuransi sosial CA). Atribut:
Sin::class
Metode:
Validation::sin()
183 Nama: nino
Penggunaan: nino		 Menegaskan bahwa inputnya adalah nino yang valid (nomor asuransi nasional Inggris). Atribut:
Nino::class
Metode:
Validation::nino()
184 Nama: vin
Penggunaan: vin		 Menegaskan bahwa input adalah VIN yang valid (nomor identifikasi kendaraan). Atribut:
Vin::class
Metode:
Validation::vin()
185 Nama: issn
Penggunaan: issn		 Menegaskan bahwa inputnya adalah ISSN yang valid (nomor seri internasional). Atribut:
Issn::class
Metode:
Validation::issn()
186 Nama: isin
Penggunaan: isin		 Menegaskan bahwa inputnya adalah ISIN yang valid (nomor identifikasi sekuritas internasional). Atribut:
Isin::class
Metode:
Validation::isin()
187 Nama: isbn
Penggunaan: isbn		 Menegaskan bahwa inputnya adalah ISBN yang valid (nomor buku standar internasional). Jenis (10/13) dapat ditentukan untuk mempersempit polanya. Atribut:
Isbn::class
Metode:
Validation::isbn(string|int|null $type = null)
188 Nama: imei
Penggunaan: imei		 Menegaskan bahwa inputnya adalah IMEI yang valid (nomor identitas peralatan stasiun seluler internasional). Atribut:
Imei::class
Metode:
Validation::imei()
189 Nama: imei.sv
Penggunaan: imei.sv		 Menegaskan bahwa inputnya adalah IMEI-SV yang valid (International Mobile Station Equipment Identity dan Nomor Versi Perangkat Lunak). Atribut:
ImeiSv::class
Metode:
Validation::imeiSv()
190 Nama: meid
Penggunaan: meid		 Menegaskan bahwa inputnya adalah MEID (pengidentifikasi peralatan seluler) yang valid. Atribut:
Meid::class
Metode:
Validation::meid()
191 Nama: esn
Penggunaan: esn		 Menegaskan bahwa input adalah ESN yang valid (nomor seri elektronik). Atribut:
Esn::class
Metode:
Validation::esn()
192 Nama: currency
Penggunaan: currency		 Menegaskan bahwa input adalah kode mata uang yang valid (default: "ISO 4217 alpha"; numerik: "ISO 4217 numerik"). Atribut:
Currency::class
Metode:
Validation::currency(bool $numeric = false)
193 Nama: currency.name
Penggunaan: currency.name		 Menegaskan bahwa input adalah nama mata uang yang valid (seperti dalam ISO 4217). Atribut:
CurrencyName::class
Metode:
Validation::currencyName()
194 Nama: creditcard
Penggunaan: creditcard		 Menegaskan bahwa input adalah nomor kartu kredit yang valid, ruang seimbang dan/atau tanda hubung diizinkan. Atribut:
Creditcard::class
Metode:
Validation::creditcard()
195 Nama: creditcard.visa
Penggunaan: creditcard.visa		 Menegaskan bahwa input adalah nomor kartu kredit visa yang valid, ruang seimbang dan/atau tanda hubung diizinkan. Atribut:
CreditcardVisa::class
Metode:
Validation::creditcardVisa()
196 Nama: creditcard.mastercard
Penggunaan: creditcard.mastercard		 Menegaskan bahwa input adalah nomor kartu kredit MasterCard yang valid, ruang seimbang dan/atau tanda hubung diizinkan. Atribut:
CreditcardMastercard::class
Metode:
Validation::creditcardMastercard()
197 Nama: creditcard.discover
Penggunaan: creditcard.discover		 Menegaskan bahwa input adalah nomor kartu kredit Discover yang valid, ruang seimbang dan/atau tanda hubung diizinkan. Atribut:
CreditcardDiscover::class
Metode:
Validation::creditcardDiscover()
198 Nama: creditcard.americanExpress
Penggunaan: creditcard.americanExpress		 Menegaskan bahwa input adalah nomor kartu kredit American Express yang valid, ruang seimbang dan/atau tanda hubung diizinkan. Atribut:
CreditcardAmericanExpress::class
Metode:
Validation::creditcardAmericanExpress()
199 Nama: creditcard.dinersClub
Penggunaan: creditcard.dinersClub		 Menegaskan bahwa input adalah nomor kartu kredit Diners Club yang valid, ruang seimbang dan/atau tanda hubung diizinkan. Atribut:
CreditcardDinersClub::class
Metode:
Validation::creditcardDinersClub()
200 Nama: creditcard.jcb
Penggunaan: creditcard.jcb		 Menegaskan bahwa input adalah nomor kartu kredit JCB yang valid, ruang seimbang dan/atau tanda hubung diizinkan. Atribut:
CreditcardJcb::class
Metode:
Validation::creditcardJcb()
201 Nama: creditcard.maestro
Penggunaan: creditcard.maestro		 Menegaskan bahwa input adalah nomor kartu kredit maestro yang valid, ruang seimbang dan/atau tanda hubung diizinkan. Atribut:
CreditcardMaestro::class
Metode:
Validation::creditcardMaestro()
202 Nama: creditcard.chinaUnionPay
Penggunaan: creditcard.chinaUnionPay		 Menegaskan bahwa inputnya adalah nomor kartu kredit China UnionPay yang valid, ruang seimbang dan/atau tanda hubung diizinkan. Atribut:
CreditcardChinaUnionPay::class
Metode:
Validation::creditcardChinaUnionPay()
203 Nama: creditcard.instaPayment
Penggunaan: creditcard.instaPayment		 Menegaskan bahwa input adalah nomor kartu kredit Instapayment yang valid, ruang seimbang dan/atau tanda hubung diizinkan. Atribut:
CreditcardInstaPayment::class
Metode:
Validation::creditcardInstaPayment()
204 Nama: creditcard.laser
Penggunaan: creditcard.laser		 Menegaskan bahwa input adalah nomor kartu kredit laser yang valid, ruang seimbang dan/atau tanda hubung diizinkan. Atribut:
CreditcardLaser::class
Metode:
Validation::creditcardLaser()
205 Nama: creditcard.uatp
Penggunaan: creditcard.uatp		 Menegaskan bahwa input adalah nomor kartu kredit UATP yang valid, ruang seimbang dan/atau tanda hubung diizinkan. Atribut:
CreditcardUatp::class
Metode:
Validation::creditcardUatp()
206 Nama: creditcard.mir
Penggunaan: creditcard.mir		 Menegaskan bahwa input adalah nomor kartu sistem pembayaran miR yang valid, ruang seimbang dan/atau tanda hubung diizinkan. Atribut:
CreditcardMir::class
Metode:
Validation::creditcardMir()
207 Nama: cvv
Penggunaan: cvv		 Menegaskan bahwa input adalah CVV yang valid (kode keamanan kartu). Atribut:
Cvv::class
Metode:
Validation::cvv()
208 Nama: bic
Penggunaan: bic		 Menegaskan bahwa input adalah BIC yang valid (Bank Identifier Code). Atribut:
Bic::class
Metode:
Validation::bic()
209 Nama: iban
Penggunaan: iban:IQ		 Menegaskan bahwa inputnya adalah IBAN yang valid (nomor rekening bank internasional). Kode negara "ISO 3166-1 Alpha-2" dapat ditentukan untuk mempersempit polanya. Atribut:
Iban::class
Metode:
Validation::iban(?string $country = null)
210 Nama: luhn
Penggunaan: luhn		 Menegaskan bahwa input melewati pemeriksaan algoritma luhn. Aturan ini sebagian besar digunakan bersama dengan aturan lain seperti nomor kartu kredit dan pengidentifikasi untuk memeriksa lebih lanjut validitas subjek. Atribut:
Luhn::class
Metode:
Validation::luhn()
211 Nama: php.keyword
Penggunaan: php.keyword		 Menegaskan bahwa input adalah kata kunci bahasa PHP. Atribut:
PhpKeyword::class
Metode:
Validation::phpKeyword()
212 Nama: php.reserved
Penggunaan: php.reserved		 Menegaskan bahwa input adalah kata yang dilindungi bahasa PHP. Atribut:
PhpReserved::class
Metode:
Validation::phpReserved()
213 Nama: php.reserved.extra
Penggunaan: php.reserved.extra		 Menegaskan bahwa input adalah kata yang dicadangkan bahasa PHP termasuk kata -kata yang dipesan lembut. Atribut:
PhpReservedExtra::class
Metode:
Validation::phpReservedExtra()
214 Nama: regex
Penggunaan: regex		 Menegaskan bahwa input adalah ekspresi reguler yang valid. Atribut:
Regex::class
Metode:
Validation::regex()
215 Nama: bool
Penggunaan: Lihat boolean		 Alias, lihat boolean untuk deskripsi lengkapnya. Atribut:
BoolConstraint::class
Metode:
Validation::bool()
216 Nama: int
Penggunaan: Lihat integer		 Alias, lihat integer untuk deskripsi lengkap. Atribut:
IntConstraint::class
Metode:
Validation::int()
217 Nama: long
Penggunaan: Lihat integer		 Alias, lihat integer untuk deskripsi lengkap. Atribut:
Long::class
Metode:
Validation::long()
218 Nama: double
Penggunaan: Lihat float		 Alias, lihat float untuk deskripsi lengkap. Atribut:
Double::class
Metode:
Validation::double()
219 Nama: real
Penggunaan: Lihat float		 Alias, lihat float untuk deskripsi lengkap. Atribut:
Real::class
Metode:
Validation::real()
220 Nama: str
Penggunaan: Lihat string		 Alias, lihat string untuk deskripsi lengkap. Atribut:
Str::class
Metode:
Validation::str()
221 Nama: arr
Penggunaan: Lihat array		 Alias, lihat array untuk deskripsi lengkap. Atribut:
Arr::class
Metode:
Validation::arr()
222 Nama: obj
Penggunaan: Lihat object		 Alias, lihat object untuk deskripsi lengkap. Atribut:
Obj::class
Metode:
Validation::obj()
223 Nama: stream
Penggunaan: Lihat resource		 Alias, lihat resource untuk deskripsi lengkap. Atribut:
Stream::class
Metode:
Validation::stream()
224 Nama: assert
Penggunaan: Lihat if		 Alias, lihat if untuk deskripsi lengkap. Atribut:
Assert::class
Metode:
Validation::assert(mixed $actual, mixed $expected = true, string $operator = '==')
225 Nama: assert.equals
Penggunaan: Lihat if.eq		 Alias, lihat if.eq untuk deskripsi lengkap. Atribut:
AssertEquals::class
Metode:
Validation::assertEquals(mixed $actual, mixed $expected)
226 Nama: assert.notEquals
Penggunaan: Lihat if.neq		 Alias, lihat if.neq untuk deskripsi lengkap. Atribut:
AssertNotEquals::class
Metode:
Validation::assertNotEquals(mixed $actual, mixed $expected)
227 Nama: assert.greaterThan
Penggunaan: Lihat if.gt		 Alias, lihat if.gt untuk deskripsi lengkap. Atribut:
AssertGreaterThan::class
Metode:
Validation::assertGreaterThan(mixed $actual, mixed $expected)
228 Nama: assert.greaterThanOrEquals
Penggunaan: Lihat if.gte		 Alias, lihat if.gte untuk deskripsi lengkap. Atribut:
AssertGreaterThanOrEquals::class
Metode:
Validation::assertGreaterThanOrEquals(mixed $actual, mixed $expected)
229 Nama: assert.lessThan
Penggunaan: Lihat if.lt		 Alias, lihat if.lt untuk deskripsi lengkap. Atribut:
AssertLessThan::class
Metode:
Validation::assertLessThan(mixed $actual, mixed $expected)
230 Nama: assert.lessThanOrEquals
Penggunaan: Lihat if.lte		 Alias, lihat if.lte untuk deskripsi lengkap. Atribut:
AssertLessThanOrEquals::class
Metode:
Validation::assertLessThanOrEquals(mixed $actual, mixed $expected)
231 Nama: blank
Penggunaan: Lihat empty		 Alias, lihat empty untuk deskripsi lengkap. Atribut:
Blank::class
Metode:
Validation::blank()
232 Nama: is
Penggunaan: Lihat equals		 Alias, lihat equals untuk deskripsi lengkap. Atribut:
Is::class
Metode:
Validation::is(mixed $value)
233 Nama: same
Penggunaan: Lihat equals		 Alias, lihat equals untuk deskripsi lengkap. Atribut:
Same::class
Metode:
Validation::same(mixed $value)
234 Nama: pattern
Penggunaan: Lihat matches		 Alias, lihat matches untuk deskripsi lengkap. Atribut:
Pattern::class
Metode:
Validation::pattern(string $pattern)
235 Nama: choice
Penggunaan: Lihat in		 Alias, lihat in untuk deskripsi lengkap. Atribut:
Choice::class
Metode:
Validation::choice(string|int|float|bool|null ...$values)
236 Nama: size
Penggunaan: Lihat count		 Alias, lihat count untuk deskripsi lengkap. Atribut:
Size::class
Metode:
Validation::size(int $size)
237 Nama: length
Penggunaan: Lihat count		 Alias, lihat count untuk deskripsi lengkap. Atribut:
Length::class
Metode:
Validation::length(int $count)
238 Nama: range
Penggunaan: Lihat between		 Alias, lihat between untuk deskripsi lengkap. Atribut:
Range::class
Metode:
Validation::range(int|float $min, int|float $max)
239 Nama: minmax
Penggunaan: Lihat between		 Alias, lihat between untuk deskripsi lengkap. Atribut:
Minmax::class
Metode:
Validation::minmax(int|float $min, int|float $max)
240 Nama: filled
Penggunaan: Lihat required		 Alias, lihat required untuk deskripsi lengkap. Atribut:
Filled::class
Metode:
Validation::filled()
241 Nama: present
Penggunaan: Lihat required		 Alias, lihat required untuk deskripsi lengkap. Atribut:
Present::class
Metode:
Validation::present()
242 Nama: optional
Penggunaan: Lihat allowed		 Alias, lihat allowed untuk deskripsi lengkap. Atribut:
Optional::class
Metode:
Validation::optional()
243 Nama: date
Penggunaan: Lihat datetime		 Alias, lihat datetime untuk deskripsi lengkap. Atribut:
Date::class
Metode:
Validation::date()
244 Nama: date.equals
Penggunaan: Lihat datetime.eq		 Alias, lihat datetime.eq untuk deskripsi lengkap. Atribut:
DateEquals::class
Metode:
Validation::dateEquals(string $datetime)
245 Nama: date.before
Penggunaan: Lihat datetime.lt		 Alias, lihat datetime.lt untuk deskripsi lengkap. Atribut:
DateBefore::class
Metode:
Validation::dateBefore(string $datetime)
246 Nama: date.beforeOrEquals
Penggunaan: Lihat datetime.lte		 Alias, lihat datetime.lte untuk deskripsi lengkap. Atribut:
DateBeforeOrEquals::class
Metode:
Validation::dateBeforeOrEquals(string $datetime)
247 Nama: date.after
Penggunaan: Lihat datetime.gt		 Alias, lihat datetime.gt untuk deskripsi lengkap. Atribut:
DateAfter::class
Metode:
Validation::dateAfter(string $datetime)
248 Nama: date.afterOrEquals
Penggunaan: Lihat datetime.gte		 Alias, lihat datetime.gte untuk deskripsi lengkap. Atribut:
DateAfterOrEquals::class
Metode:
Validation::dateAfterOrEquals(string $datetime)
249 Nama: date.format
Penggunaan: Lihat datetime.format		 Alias, lihat datetime.format untuk deskripsi lengkap. Atribut:
DateFormat::class
Metode:
Validation::dateFormat(string $format)
250 Nama: cakeday
Penggunaan: Lihat datetime.birthday		 Alias, lihat datetime.birthday untuk deskripsi lengkap. Atribut:
Cakeday::class
Metode:
Validation::cakeday()

Makro

Makro Ekspresi validasi
[nullable] null^~empty
[alnumDash] matches:"/[a-zA-Z0-9-_]+/"
[twitterHandle] matches:'"/^[a-zA-Z_]{1}[a-zA-Z0-9_]{0,14}$/"'
[gmail] email&string.contains:"@gmail."
[eduMail] email&string.endsWith:".edu"

Tolok ukur

Sekarang, mungkin terlihat mighty melakukan terlalu banyak dan masalah kinerja mulai muncul. Nah, tidak perlu khawatir tentang itu. mighty sangat cepat dan dioptimalkan untuk memberikan kinerja terbaik. Berikut adalah beberapa tolok ukur kinerja validator:

Benchmark ilmiah tidak begitu

Kinerja Validator mighty dan Laravel Validator dalam aplikasi Laravel. Tes dilakukan dengan menggunakan array 50000 elemen, setengah dari mereka adalah bilangan bulat dan setengah lainnya adalah string numerik. Setiap validator diuji 10 kali (berturut -turut) dan hasil rata -rata 10 ini dikumpulkan:

mighty Validator with XDebug disabled [ // required&integer 'preparationTime' => '1.32ms', // the time required to build the array 'validationTime' => '1107.29ms', // the time required to validate the array 'totalTime' => '1108.61ms', // the time required for the whole process ] // mighty Validator with XDebug enabled [ // required&integer 'preparationTime' => '9.09ms', 'validationTime' => '6085.04ms', 'totalTime' => '6094.13ms', ] // Laravel Validator with XDebug disabled [ // required|integer 'preparationTime' => '1.33ms', 'validationTime' => '13882.72ms', 'totalTime' => '13884.05ms', ] // Laravel Validator with XDebug enabled [ // required|integer 'preparationTime' => '9.33ms', 'validationTime' => '24010.60ms', 'totalTime' => '24019.93ms', ]">
 $ data = array_merge ( range ( 1 , 25000 ), array_map ( ' strval ' , range ( ' 25001 ' , ' 50000 ' )));
// mighty Validator with XDebug disabled
[ // required&integer
  ' preparationTime ' => ' 1.32ms ' ,    // the time required to build the array
  ' validationTime '  => ' 1107.29ms ' , // the time required to validate the array
  ' totalTime '       => ' 1108.61ms ' , // the time required for the whole process
]
// mighty Validator with XDebug enabled
 [ // required&integer
  ' preparationTime ' => ' 9.09ms ' ,
  ' validationTime '  => ' 6085.04ms ' ,
  ' totalTime '       => ' 6094.13ms ' ,
]
// Laravel Validator with XDebug disabled
[ // required|integer
  ' preparationTime ' => ' 1.33ms ' ,
  ' validationTime '  => ' 13882.72ms ' ,
  ' totalTime '       => ' 13884.05ms ' ,
]
// Laravel Validator with XDebug enabled
[ // required|integer
  ' preparationTime ' => ' 9.33ms ' ,
  ' validationTime '  => ' 24010.60ms ' ,
  ' totalTime '       => ' 24019.93ms ' ,
]

Jadi mighty sekitar 12,5x kali lebih cepat dari Laravel Validator dengan XDEBUG dinonaktifkan dan sekitar 4x kali lebih cepat dengan XDEBUG diaktifkan.

Benchmark ilmiah

Benchmark dilakukan dengan menggunakan PhpBench. Berikut ini adalah gambaran cepat:

mighty/phpbench.json.dist with PHP version 8.1.9, xdebug , opcache MAKS mighty BenchmarksConstraintBench benchAValidValidatableObject............I4 ✔ Mo305.595074ops/s (±0.75%) benchAnInvalidValidatableObject.........I4 ✔ Mo326.708522ops/s (±1.02%) MAKS mighty BenchmarksValidatorBench benchSingleValidationString.............I4 ✔ Mo0.02212ms (±1.59%) benchSingleValidationObject.............I4 ✔ Mo0.126929ms (±1.63%) benchBulkValidationObject...............I4 ✔ Mo9.345847ms (±0.62%) benchBulkValidationString...............I4 ✔ Mo6.734188ms (±0.40%) Subjects: 6, Assertions: 6, Failures: 0, Errors: 0">
 PHPBench (1.2.6) running benchmarks...
with configuration file: mighty /phpbench.json.dist
with PHP version 8.1.9, xdebug , opcache 

MAKS mighty BenchmarksConstraintBench

    benchAValidValidatableObject............I4 ✔ Mo305.595074ops/s (±0.75%)
    benchAnInvalidValidatableObject.........I4 ✔ Mo326.708522ops/s (±1.02%)

MAKS mighty BenchmarksValidatorBench

    benchSingleValidationString.............I4 ✔ Mo0.02212ms (±1.59%)
    benchSingleValidationObject.............I4 ✔ Mo0.126929ms (±1.63%)
    benchBulkValidationObject...............I4 ✔ Mo9.345847ms (±0.62%)
    benchBulkValidationString...............I4 ✔ Mo6.734188ms (±0.40%)

Subjects: 6, Assertions: 6, Failures: 0, Errors: 0

■ Fakta: Hasil benchmark terbaru juga dapat ditemukan di pipa CI, yang akan diperbarui dengan masing -masing Push/PR ke bagian atas.

Catatan

  1. mighty menghasilkan pesan kesalahan yang sangat ramah secara default (saat ini hanya dalam bahasa Inggris). Pesan -pesan ini dapat dengan mudah ditimpa pada pangkalan validator/kendala. Anda mungkin ingin memiliki pesan -pesan ini dalam berbagai bahasa, untuk itu, metode MAKS mighty Rule::setMessageTranslator() dapat digunakan. Metode ini adalah cara yang nyaman untuk mengatur penerjemah pesan global, dibutuhkan penutupan yang mendapatkan pesan mentah (dengan placeholder) sebagai argumen dan harus mengembalikan versi yang diterjemahkan dari pesan itu.
  2. Lihat spesifikasi bahasa ekspresi validasi mighty untuk mempelajari lebih lanjut tentang teori di balik mighty dan untuk memahami cara kerja bahasa.
  3. Lihat dokumentasi API mighty untuk mempelajari lebih lanjut tentang API PHP. API didokumentasikan dengan baik dan seharusnya tidak ada yang tidak tercakup di sana.
  4. mighty saat ini adalah perpustakaan validasi murni, tidak melakukan transformasi apa pun pada data. Mesin dan desain saat ini cukup fleksibel dan dapat digunakan untuk dengan mudah mengimplementasikan pembersih di atasnya, tidak ada rencana untuk membuat ini saat ini tetapi mungkin merupakan tonggak sejarah di masa depan.

Lisensi

mighty adalah proyek open-source yang dilisensikan di bawah lisensi MIT .
Hak Cipta (C) 2022 Marwan al-Soltany. Semua hak dilindungi undang-undang.

Memperluas
Informasi Tambahan
Aplikasi Terkait
Direkomendasikan untuk Anda
Informasi Terkait Semua