valitron

Valitron: Validasi Mudah dan Tidak Menyebalkan

Valitron adalah perpustakaan validasi mandiri yang sederhana, minimal dan elegan tanpa ketergantungan. Valitron menggunakan metode validasi yang sederhana dan lugas dengan fokus pada sintaksis yang mudah dibaca dan ringkas. Valitron adalah perpustakaan validasi sederhana dan pragmatis yang Anda cari.

Dapatkan dukungan vlucas/valitron dengan Berlangganan Tidelift

Mengapa Valitron?

Valitron dibuat karena frustrasi dengan perpustakaan validasi lain yang memiliki ketergantungan pada komponen besar dari kerangka kerja lain seperti HttpFoundation dari Symfony, menarik banyak file tambahan yang sebenarnya tidak diperlukan untuk validasi dasar. Ini juga memiliki sintaks sederhana yang sengaja digunakan untuk menjalankan semua validasi dalam satu panggilan alih-alih memvalidasi setiap nilai secara individual dengan membuat instance kelas baru dan memvalidasi nilai satu per satu seperti yang diperlukan oleh beberapa perpustakaan validasi lainnya.

Singkatnya, Valitron adalah segalanya yang Anda cari di perpustakaan validasi tetapi belum dapat menemukannya sampai sekarang: sintaks pragmatis sederhana, kode ringan yang masuk akal, dapat diperluas untuk panggilan balik dan validasi khusus, teruji dengan baik, dan tanpa ketergantungan . Mari kita mulai.

Instalasi

Valitron menggunakan Komposer untuk menginstal dan memperbarui:

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

Contoh di bawah ini menggunakan sintaks PHP 5.4, tetapi Valitron bekerja pada PHP 5.3+.

Penggunaan

Penggunaannya sederhana dan mudah. Cukup sediakan serangkaian data yang ingin Anda validasi, tambahkan beberapa aturan, lalu panggil validate() . Jika ada kesalahan, Anda dapat memanggil errors() untuk mendapatkannya.

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

Dengan menggunakan format ini, Anda dapat memvalidasi data $_POST secara langsung dan mudah, dan bahkan dapat menerapkan aturan seperti required pada array bidang:

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

Anda dapat menggunakan sintaks titik untuk mengakses anggota array multidimensi, dan tanda bintang untuk memvalidasi setiap anggota array:

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

Atau gunakan sintaks titik untuk memvalidasi semua anggota array numerik:

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

Anda juga dapat mengakses nilai bertingkat menggunakan notasi titik:

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

Mengatur bahasa dan direktori bahasa secara global:

 // boot or config file

use Valitron  Validator as V ;

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

Menonaktifkan nama {field} di output pesan kesalahan.

 use Valitron  Validator as V ;

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

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

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

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

Anda dapat mewajibkan nilai secara kondisional menggunakan aturan kondisional yang diperlukan. Dalam contoh ini, untuk autentikasi, kami memerlukan token ketika email dan kata sandi tidak ada, atau kata sandi ketika alamat email ada.

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

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

Aturan Validasi Bawaan

• required - Bidang wajib diisi
• requiredWith - Bidang wajib diisi jika ada bidang lain yang ada
• requiredWithout - Bidang wajib diisi jika ada bidang lain yang TIDAK ada
• equals - Bidang harus cocok dengan bidang lain (konfirmasi email/kata sandi)
• different - Bidang harus berbeda dari bidang lainnya
• accepted - Kotak centang atau Radio harus diterima (ya, aktif, 1, benar)
• numeric - Harus numerik
• integer - Harus berupa bilangan bulat
• boolean - Harus boolean
• array - Harus berupa larik
• length - String harus memiliki panjang tertentu
• lengthBetween - String harus berada di antara panjang yang diberikan
• lengthMin - String harus lebih besar dari panjang yang diberikan
• lengthMax - String harus kurang dari panjang yang diberikan
• min - Minimal
• max - Maksimum
• listContains - Melakukan pemeriksaan in_array pada nilai array tertentu (sebaliknya dari in )
• in - Melakukan pemeriksaan in_array pada nilai array tertentu
• notIn - Negasi aturan in (bukan dalam array nilai)
• ip - Alamat IP yang valid
• ipv4 - Alamat IP v4 yang valid
• ipv6 - Alamat IP v6 yang valid
• email - Alamat email yang valid
• emailDNS - Alamat email valid dengan catatan DNS aktif
• url - URL yang valid
• urlActive - URL valid dengan catatan DNS aktif
• alpha - Hanya karakter alfabet
• alphaNum - Hanya karakter alfabet dan numerik
• ascii - karakter ASCII saja
• slug - karakter slug URL (az, 0-9, -, _)
• regex - Bidang cocok dengan pola regex yang diberikan
• date - Bidang adalah tanggal yang valid
• dateFormat - Bidang adalah tanggal valid dalam format yang diberikan
• dateBefore - Bidang adalah tanggal yang valid dan sebelum tanggal yang ditentukan
• dateAfter - Bidang adalah tanggal yang valid dan setelah tanggal yang ditentukan
• contains - Bidang adalah string dan berisi string yang diberikan
• subset - Bidang adalah larik atau skalar dan semua elemen terdapat dalam larik tertentu
• containsUnique - Bidang adalah array dan berisi nilai unik
• creditCard - Bidang adalah nomor kartu kredit yang valid
• instanceOf - Bidang berisi turunan dari kelas tertentu
• optional - Nilai tidak perlu disertakan dalam array data. Namun jika ya, harus lulus validasi.
• arrayHasKeys - Bidang adalah array dan berisi semua kunci yang ditentukan.

CATATAN : Jika Anda membandingkan angka floating-point dengan validator min/maks, Anda harus menginstal ekstensi BCMath untuk akurasi dan keandalan yang lebih baik. Ekstensi tidak diperlukan agar Valitron dapat berfungsi, tetapi Valitron akan menggunakannya jika tersedia, dan sangat disarankan.

penggunaan bidang yang diperlukan

aturan required memeriksa apakah suatu bidang ada dalam larik data, dan bukan nol atau string kosong.

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

Dengan menggunakan parameter tambahan, Anda dapat membuat aturan ini lebih fleksibel, dan hanya memeriksa apakah bidang tersebut ada dalam larik data.

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

Sintaks alternatif.

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

diperlukanDengan penggunaan bidang

Aturan requiredWith memeriksa bahwa bidang tersebut wajib diisi, bukan nol, dan bukan string kosong, jika ada bidang lain yang ada, bukan nol, dan bukan string kosong.

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

Sintaks alternatif.

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

Catatan Anda dapat memberikan beberapa nilai sebagai sebuah array. Dalam hal ini, jika SALAH SATU bidang ada, bidang tersebut akan wajib diisi.

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

Sintaks alternatif.

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

Bendera yang ketat

Bendera ketat akan mengubah aturan requiredWith menjadi requiredWithAll yang akan memerlukan bidang tersebut hanya jika SEMUA bidang lainnya ada, bukan nol, dan bukan string kosong.

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

Sintaks alternatif.

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

Demikian pula, dalam kasus ini validate() akan tetap mengembalikan nilai true, karena bidang sufiks tidak diperlukan dalam mode ketat, karena tidak semua bidang disediakan.

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

diperlukanTanpa penggunaan bidang

Aturan requiredWithout memeriksa bahwa bidang tersebut wajib diisi, bukan nol, dan bukan string kosong, jika ada bidang lain yang TIDAK ada.

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

Sintaks alternatif.

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

Catatan Anda dapat memberikan beberapa nilai sebagai sebuah array. Dalam hal ini jika SALAH SATU bidang TIDAK ada maka bidang tersebut akan wajib diisi.

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

Sintaks alternatif.

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

Bendera yang ketat

Bendera ketat akan mengubah aturan requiredWithout menjadi requiredWithoutAll yang akan memerlukan bidang tersebut hanya jika SEMUA bidang lainnya tidak ada.

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

Sintaks alternatif.

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

Demikian pula, dalam kasus ini validate() akan tetap mengembalikan nilai true, karena kolom nama pengguna tidak diperlukan dalam mode ketat, karena semua kolom disediakan.

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

sama dengan penggunaan bidang

Aturan equals dengan memeriksa apakah dua bidang sama dalam larik data, dan bidang kedua tidak nol.

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

Sintaks alternatif.

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

penggunaan bidang yang berbeda

Aturan different memeriksa apakah dua bidang tidak sama, atau berbeda, dalam larik data dan bidang kedua tidak nol.

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

Sintaks alternatif.

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

penggunaan bidang yang diterima

Aturan accepted memeriksa apakah kolomnya 'ya', 'aktif', 1, atau benar.

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

Sintaks alternatif.

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

penggunaan bidang numerik

Aturan numeric memeriksa apakah bidangnya berupa angka. Ini analog dengan fungsi is_numeric() php.

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

Sintaks alternatif.

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

penggunaan bidang bilangan bulat

Aturan integer memeriksa apakah bidang tersebut berupa bilangan bulat.

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

Sintaks alternatif.

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

Perhatikan bahwa tanda boolean opsional untuk mode ketat memastikan bilangan bulat diberikan dalam bentuk numerik yang ketat. Jadi aturan berikut akan bernilai benar:

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

Sedangkan yang berikut ini akan bernilai salah, karena tanda + untuk bilangan positif dalam hal ini mubazir:

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

penggunaan bidang boolean

Aturan boolean memeriksa apakah field tersebut boolean. Ini analog dengan fungsi is_bool() php.

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

Sintaks alternatif.

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

penggunaan bidang array

Aturan array memeriksa apakah bidang tersebut adalah array. Ini analog dengan fungsi is_array() php.

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

Sintaks Alternatif.

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

penggunaan bidang panjang

Aturan length memeriksa apakah bidang tersebut memiliki panjang tertentu dan apakah bidang tersebut merupakan string yang valid.

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

Sintaks alternatif.

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

panjangAntara penggunaan bidang

Aturan lengthBetween memeriksa apakah bidang berada di antara garis panjang tertentu dan apakah bidang tersebut adalah string yang valid.

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

Sintaks alternatif.

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

penggunaan bidang lengthMin

Aturan lengthMin memeriksa apakah bidang tersebut setidaknya memiliki panjang tertentu dan bidang tersebut adalah string yang valid.

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

Sintaks alternatif.

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

penggunaan bidang lengthMax

Aturan lengthMax memeriksa apakah bidang tersebut paling banyak memiliki panjang tertentu dan apakah bidang tersebut merupakan string yang valid.

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

Sintaks alternatif.

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

penggunaan bidang min

Aturan min memeriksa apakah bidang tersebut setidaknya memiliki nilai tertentu dan nilai yang diberikan adalah numerik.

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

Sintaks alternatif.

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

penggunaan bidang maksimal

Aturan max memeriksa apakah bidang tersebut paling banyak berisi nilai tertentu dan nilai yang diberikan adalah numerik.

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

Sintaks alternatif.

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

listBerisi penggunaan bidang

Aturan listContains memeriksa apakah bidang tersebut ada dalam larik nilai tertentu.

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

Sintaks alternatif.

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

dalam penggunaan bidang

Aturan in memeriksa apakah bidang tersebut ada dalam larik nilai tertentu.

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

Sintaks alternatif.

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

bukan dalam penggunaan bidang

Aturan notIn memeriksa bahwa bidang tersebut TIDAK ada dalam larik nilai tertentu.

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

Sintaks alternatif.

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

penggunaan bidang ip

Aturan ip memeriksa apakah bidang tersebut adalah alamat ip yang valid. Ini termasuk rentang IPv4, IPv6, pribadi, dan cadangan.

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

Sintaks alternatif.

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

penggunaan bidang ipv4

Aturan ipv4 memeriksa apakah kolom tersebut adalah alamat IPv4 yang valid.

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

Sintaks alternatif.

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

penggunaan bidang ipv6

Aturan ipv6 memeriksa apakah kolom tersebut adalah alamat IPv6 yang valid.

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

Sintaks alternatif.

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

penggunaan bidang email

Aturan email memeriksa apakah kolom tersebut adalah alamat email yang valid.

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

Sintaks alternatif.

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

penggunaan bidang emailDNS

Aturan emailDNS memvalidasi bidang tersebut adalah alamat email yang valid dengan catatan DNS aktif atau jenis apa pun.

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

Sintaks alternatif.

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

penggunaan bidang url

Aturan url memeriksa apakah bidang tersebut adalah url yang valid.

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

Sintaks alternatif.

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

penggunaan bidang urlaktif

Aturan urlActive memeriksa bahwa bidang tersebut adalah url yang valid dengan data A, AAAA, atau CNAME yang aktif.

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

Sintaks alternatif.

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

penggunaan bidang alfa

Aturan alpha memeriksa bahwa bidang tersebut hanya berisi karakter alfabet.

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

Sintaks alternatif.

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

penggunaan bidang alphaNum

Aturan alphaNum memeriksa bidang hanya berisi karakter alfabet atau numerik.

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

Sintaks alternatif.

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

penggunaan bidang ascii

Aturan ascii memeriksa bidang hanya berisi karakter dalam kumpulan karakter ascii.

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

Sintaks alternatif.

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

penggunaan bidang siput

Aturan slug memeriksa bahwa bidang hanya berisi karakter slug URL (az, 0-9, -, _).

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

Sintaks alternatif.

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

penggunaan bidang regex

Aturan regex memastikan bidang tersebut cocok dengan pola regex yang diberikan. (Regex ini memeriksa string alfa numerik antara 5-10 karakter).

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

Sintaks alternatif.

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

penggunaan bidang tanggal

Aturan date memeriksa apakah bidang yang disediakan adalah objek DateTime yang valid atau apakah string dapat dikonversi ke stempel waktu unix melalui strtotime().

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

Sintaks alternatif.

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

penggunaan bidang dateFormat

Aturan dateFormat memeriksa bahwa bidang yang disediakan adalah tanggal yang valid dalam format tanggal yang ditentukan.

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

Sintaks alternatif.

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

tanggalSebelum penggunaan bidang

Aturan dateBefore memeriksa bahwa bidang yang disediakan adalah tanggal yang valid sebelum tanggal yang ditentukan.

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

Sintaks alternatif.

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

tanggalSetelah penggunaan bidang

Aturan dateAfter memeriksa bahwa bidang yang disediakan adalah tanggal yang valid setelah tanggal yang ditentukan.

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

Sintaks alternatif.

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

berisi penggunaan bidang

Aturan contains memeriksa apakah string tertentu ada di dalam bidang dan memeriksa apakah bidang dan nilai pencarian keduanya merupakan string yang valid.

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

Sintaks alternatif.

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

Catatan Anda dapat menggunakan tanda ketat opsional untuk memastikan kecocokan peka huruf besar-kecil. Contoh berikut akan mengembalikan nilai true:

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

Padahal, ini akan menghasilkan false, karena M dalam string pencarian bukan huruf besar pada nilai yang diberikan:

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

penggunaan bidang subset

Aturan subset memeriksa apakah bidang tersebut merupakan bidang skalar atau array dan semua nilainya terkandung dalam kumpulan nilai tertentu.

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

Sintaks alternatif.

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

Contoh ini akan menghasilkan nilai salah, karena warna yang diberikan, ungu, tidak ada dalam array nilai yang diterima yang kami berikan.

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

berisi penggunaan bidang unik

Aturan containsUnique memeriksa bahwa bidang yang disediakan adalah array dan semua nilai yang terkandung di dalamnya unik, yaitu tidak ada nilai duplikat dalam array.

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

Sintaks alternatif.

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

Contoh ini akan menghasilkan nilai salah, karena nilai dalam array yang disediakan adalah duplikat.

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

Penggunaan Validasi Kartu Kredit

Validasi kartu kredit saat ini memungkinkan Anda untuk memvalidasi visa Visa, Mastercard mastercard , Dinersclub dinersclub , American Express amex atau Discover discover

Ini akan memeriksa kartu kredit terhadap setiap jenis kartu

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

Untuk memfilter tipe kartu secara opsional, tambahkan slug ke array sebagai parameter berikutnya:

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

Jika Anda hanya ingin memvalidasi satu jenis kartu, masukkan sebagai string:

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

Jika informasi jenis kartu berasal dari klien, Anda mungkin juga ingin tetap menentukan rangkaian jenis kartu yang valid:

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

penggunaan bidang instanceOf

Aturan instanceOf memeriksa apakah bidang tersebut merupakan turunan dari kelas tertentu.

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

Sintaks alternatif.

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

Catatan Anda juga dapat membandingkan nilai terhadap objek tertentu dibandingkan dengan nama kelas string. Contoh ini juga akan mengembalikan nilai true:

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

penggunaan bidang opsional

Aturan optional memastikan bahwa jika bidang ada dalam kumpulan data maka bidang tersebut lolos semua aturan validasi.

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

Sintaks alternatif. Contoh ini akan mengembalikan nilai true jika kolom 'nama pengguna' tidak ada atau jika nama pengguna hanya berupa karakter alfabet.

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

Contoh ini akan menghasilkan nilai salah, seolah-olah bidang tersebut bersifat opsional, karena disediakan maka bidang tersebut harus melewati semua aturan validasi, yang dalam hal ini tidak.

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

penggunaan bidang arrayHasKeys

Aturan arrayHasKeys memastikan bahwa bidang tersebut adalah array dan berisi semua kunci yang ditentukan. Mengembalikan nilai salah jika bidang tersebut bukan array atau jika tidak ada kunci yang diperlukan yang ditentukan atau jika beberapa kunci hilang.

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

Menambahkan Aturan Validasi Kustom

Untuk menambahkan aturan validasi Anda sendiri, gunakan metode addRule dengan nama aturan, callback atau penutupan khusus, dan pesan kesalahan untuk ditampilkan jika terjadi kesalahan. Callback yang diberikan harus mengembalikan boolean benar atau salah.

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

Anda juga dapat menggunakan aturan satu kali yang hanya berlaku untuk bidang tertentu.

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

Hal ini berguna karena aturan tersebut dapat memiliki akses ke variabel yang ditentukan dalam lingkup tempat Validator berada. Tanda tangan Penutupan identik dengan tanda tangan panggilan balik Validator::addRule .

Jika Anda ingin menambahkan aturan Anda sendiri yang tidak statis (yaitu, aturan Anda tidak statis dan tersedia untuk memanggil instance Validator ), Anda perlu menggunakan Validator::addInstanceRule . Aturan ini akan mengambil parameter yang sama seperti Validator::addRule tetapi harus dipanggil pada instance Validator .

Aturan rantai

Anda dapat menyatukan beberapa aturan menggunakan sintaks berikut.

 $ v = new Valitron  Validator ([ ' email_address ' => ' [email protected] ' ]);
$ v -> rule ( ' required ' , ' email_address ' )-> rule ( ' email ' , ' email_address ' );
$ v -> validate ();

Sintaks alternatif untuk menambahkan aturan

Seiring bertambahnya jumlah aturan, Anda mungkin lebih memilih sintaks alternatif untuk mendefinisikan beberapa aturan sekaligus.

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

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

Jika aturan Anda memerlukan beberapa parameter atau satu parameter yang lebih kompleks daripada string, Anda perlu menggabungkan aturan tersebut ke dalam array.

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

Anda juga dapat menentukan beberapa aturan untuk setiap jenis aturan.

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

Dengan menggabungkan teknik-teknik ini, Anda dapat membuat definisi aturan lengkap dalam struktur data yang relatif kompak.

Anda dapat terus menambahkan aturan individual dengan metode rule bahkan setelah menentukan definisi aturan melalui array. Hal ini sangat berguna jika Anda menentukan aturan validasi khusus.

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

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

Anda juga dapat menambahkan aturan per bidang:

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

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

Atau untuk beberapa bidang sekaligus:

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

$ v = new Valitron Validator(array( ' foo ' => ' bar ' , ' bar ' => '[email protected]));
$v->mapFieldsRules($rules);
$v->validate();

Menambahkan label bidang ke pesan

Anda dapat melakukan ini dengan dua cara berbeda, Anda dapat menambahkan label individual ke aturan atau array dari semua label untuk aturan tersebut.

Untuk menambahkan label individual ke aturan, Anda cukup menambahkan metode label setelah aturan.

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

Ada kasus ekstrem pada metode ini, Anda tidak akan bisa menggunakan array nama bidang dalam definisi aturan, jadi satu aturan per bidang. Jadi ini tidak akan berhasil:

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

Namun kita dapat menggunakan array label untuk mengatasi masalah ini hanya dengan menambahkan metode labels :

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

Ini memperkenalkan sekumpulan tag baru ke file bahasa kesalahan Anda yang terlihat seperti {field} , jika Anda menggunakan aturan seperti equals Anda dapat mengakses nilai kedua dalam file bahasa dengan menambah bidang dengan nilai seperti {field1} .

Penggunaan kembali aturan validasi

Anda dapat menggunakan kembali aturan validasi untuk memvalidasi data yang berbeda dengan cepat menggunakan aturan yang sama menggunakan metode withData:

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

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

Tes Berjalan

Rangkaian pengujian bergantung pada pemuat otomatis Komposer untuk memuat dan menjalankan file Valitron. Harap pastikan Anda telah mengunduh dan menginstal Komposer sebelum menjalankan pengujian:

1. Unduh Komposer curl -s http://getcomposer.org/installer | php
2. Jalankan 'instal' php composer.phar install
3. Jalankan tes phpunit

Berkontribusi

1. Garpu itu
2. Buat cabang fitur Anda ( git checkout -b my-new-feature )
3. Buat perubahan Anda
4. Jalankan pengujian, tambahkan pengujian baru untuk kode Anda sendiri jika perlu ( phpunit )
5. Komit perubahan Anda ( git commit -am 'Added some feature' )
6. Dorong ke cabang ( git push origin my-new-feature )
7. Buat Permintaan Tarik baru
8. Tepuk punggung diri Anda sendiri karena telah begitu luar biasa

Pengungkapan Keamanan dan Informasi Kontak

Untuk melaporkan kerentanan keamanan, silakan gunakan kontak keamanan Tidelift. Tidelift akan mengoordinasikan perbaikan dan pengungkapan.