valitron

Valitron: Einfache Validierung, die nicht scheiße ist

Valitron ist eine einfache, minimalistische und elegante eigenständige Validierungsbibliothek ohne Abhängigkeiten. Valitron verwendet einfache, unkomplizierte Validierungsmethoden mit Schwerpunkt auf lesbarer und prägnanter Syntax. Valitron ist die einfache und pragmatische Validierungsbibliothek, nach der Sie gesucht haben.

Erhalten Sie unterstützte Vlucas/Valitron mit dem Tidelift-Abonnement

Warum Valitron?

Valitron wurde aus Frustration über andere Validierungsbibliotheken erstellt, die Abhängigkeiten von großen Komponenten anderer Frameworks wie Symfonys HttpFoundation aufweisen und eine Menge zusätzlicher Dateien mit sich bringen, die für die grundlegende Validierung nicht wirklich benötigt werden. Es verfügt außerdem über eine bewusst einfache Syntax, mit der alle Validierungen in einem Aufruf ausgeführt werden können, anstatt jeden Wert einzeln zu validieren, indem neue Klassen instanziiert und Werte einzeln validiert werden, wie es bei einigen anderen Validierungsbibliotheken erforderlich ist.

Kurz gesagt, Valitron ist alles, was Sie in einer Validierungsbibliothek gesucht, aber bisher nicht gefunden haben: einfache pragmatische Syntax, leichter, sinnvoller Code, erweiterbar für benutzerdefinierte Rückrufe und Validierungen, gut getestet und ohne Abhängigkeiten . Fangen wir an.

Installation

Valitron verwendet Composer zum Installieren und Aktualisieren von:

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

Die folgenden Beispiele verwenden die PHP 5.4-Syntax, Valitron funktioniert jedoch mit PHP 5.3+.

Verwendung

Die Nutzung ist einfach und unkompliziert. Geben Sie einfach ein Array von Daten an, die Sie validieren möchten, fügen Sie einige Regeln hinzu und rufen Sie dann validate() auf. Wenn Fehler vorliegen, können Sie errors() aufrufen, um diese abzurufen.

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

Mit diesem Format können Sie $_POST Daten direkt und einfach validieren und sogar eine Regel wie required auf ein Array von Feldern anwenden:

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

Sie können die Punktsyntax verwenden, um auf Mitglieder mehrdimensionaler Arrays zuzugreifen, und ein Sternchen, um jedes Mitglied eines Arrays zu validieren:

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

Oder verwenden Sie die Punktsyntax, um alle Mitglieder eines numerischen Arrays zu validieren:

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

Sie können auch mithilfe der Punktnotation auf verschachtelte Werte zugreifen:

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

Sprache und Sprachverzeichnis global festlegen:

 // boot or config file

use Valitron  Validator as V ;

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

Deaktivieren des {field}-Namens in der Ausgabe der Fehlermeldung.

 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 "
    ]
]

Mithilfe erforderlicher bedingter Regeln können Sie Werte bedingt anfordern. In diesem Beispiel benötigen wir zur Authentifizierung entweder ein Token, wenn weder die E-Mail-Adresse noch das Passwort vorhanden sind, oder ein Passwort, wenn die E-Mail-Adresse vorhanden ist.

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

Integrierte Validierungsregeln

• required – Feld ist erforderlich
• requiredWith – Feld ist erforderlich, wenn andere Felder vorhanden sind
• requiredWithout – Feld ist erforderlich, wenn keine anderen Felder vorhanden sind
• equals – Feld muss mit einem anderen Feld übereinstimmen (E-Mail-/Passwortbestätigung)
• different – Das Feld muss sich von einem anderen Feld unterscheiden
• accepted – Kontrollkästchen oder Radio muss akzeptiert werden (ja, ein, 1, wahr)
• numeric – Muss numerisch sein
• integer – Muss eine Ganzzahl sein
• boolean – Muss boolesch sein
• array – Muss ein Array sein
• length – String muss eine bestimmte Länge haben
• lengthBetween – Die Zeichenfolge muss zwischen den angegebenen Längen liegen
• lengthMin – String muss größer als die angegebene Länge sein
• lengthMax – String muss kleiner als die angegebene Länge sein
• min – Minimum
• max – Maximum
• listContains – Führt eine in_array-Prüfung für bestimmte Array-Werte durch (umgekehrt als in )
• in – Führt eine in_array-Prüfung für bestimmte Array-Werte durch
• notIn – Negation der in -Regel (nicht im Wertearray)
• ip – Gültige IP-Adresse
• ipv4 – Gültige IP v4-Adresse
• ipv6 – Gültige IP v6-Adresse
• email – Gültige E-Mail-Adresse
• emailDNS – Gültige E-Mail-Adresse mit aktivem DNS-Eintrag
• url – Gültige URL
• urlActive – Gültige URL mit aktivem DNS-Eintrag
• alpha – Nur alphabetische Zeichen
• alphaNum – Nur alphabetische und numerische Zeichen
• ascii – Nur ASCII-Zeichen
• slug – URL-Slug-Zeichen (az, 0-9, -, _)
• regex – Feld stimmt mit dem gegebenen Regex-Muster überein
• date – Das Feld ist ein gültiges Datum
• dateFormat – Feld ist ein gültiges Datum im angegebenen Format
• dateBefore – Das Feld ist ein gültiges Datum und liegt vor dem angegebenen Datum
• dateAfter – Das Feld ist ein gültiges Datum und liegt nach dem angegebenen Datum
• contains – Feld ist eine Zeichenfolge und enthält die angegebene Zeichenfolge
• subset – Feld ist ein Array oder ein Skalar und alle Elemente sind im angegebenen Array enthalten
• containsUnique – Feld ist ein Array und enthält eindeutige Werte
• creditCard – Feld ist eine gültige Kreditkartennummer
• instanceOf – Feld enthält eine Instanz der angegebenen Klasse
• optional – Wert muss nicht im Datenarray enthalten sein. Wenn dies jedoch der Fall ist, muss es die Validierung bestehen.
• arrayHasKeys – Field ist ein Array und enthält alle angegebenen Schlüssel.

HINWEIS : Wenn Sie Gleitkommazahlen mit Min/Max-Validatoren vergleichen, sollten Sie für eine höhere Genauigkeit und Zuverlässigkeit die BCMath-Erweiterung installieren. Die Erweiterung ist nicht erforderlich, damit Valitron funktioniert, Valitron wird sie jedoch verwenden, sofern verfügbar, und sie wird dringend empfohlen.

Verwendung der Pflichtfelder

Die required Regel prüft, ob ein Feld im Datenarray vorhanden ist und nicht null oder eine leere Zeichenfolge ist.

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

Mithilfe eines zusätzlichen Parameters können Sie diese Regel flexibler gestalten und nur prüfen, ob das Feld im Datenarray vorhanden ist.

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

Alternative Syntax.

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

ErforderlichMit Feldverwendung

Die Regel requiredWith prüft, ob das Feld erforderlich ist, nicht null, und nicht die leere Zeichenfolge ist. Wenn andere Felder vorhanden sind, ist es nicht null, und es handelt sich nicht um die leere Zeichenfolge.

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

Alternative Syntax.

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

Hinweis Sie können mehrere Werte als Array bereitstellen. In diesem Fall ist das Feld erforderlich, wenn IRGENDEINES der Felder vorhanden ist.

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

Alternative Syntax.

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

Strenge Flagge

Das strikte Flag ändert die Regel requiredWith in requiredWithAll wodurch das Feld nur dann benötigt wird, wenn ALLE anderen Felder vorhanden sind, nicht null und nicht die leere Zeichenfolge.

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

Alternative Syntax.

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

Ebenso würde validate() in diesem Fall immer noch true zurückgeben, da das Suffixfeld im strikten Modus nicht erforderlich wäre, da nicht alle Felder bereitgestellt werden.

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

erforderlichOhne Feldverwendung

Die Regel requiredWithout prüft, ob das Feld erforderlich ist, nicht null, und nicht die leere Zeichenfolge, wenn andere Felder NICHT vorhanden sind.

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

Alternative Syntax.

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

Hinweis Sie können mehrere Werte als Array bereitstellen. Wenn in diesem Fall EINES der Felder NICHT vorhanden ist, ist das Feld erforderlich.

 // 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 ' ]);

Alternative Syntax.

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

Strenge Flagge

Das strikte Flag ändert die Regel requiredWithout in requiredWithoutAll wodurch das Feld nur dann erforderlich ist, wenn ALLE anderen Felder nicht vorhanden sind.

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

Alternative Syntax.

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

Ebenso würde validate() in diesem Fall immer noch „true“ zurückgeben, da das Feld „Benutzername“ im strikten Modus nicht erforderlich wäre, da alle Felder bereitgestellt werden.

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

entspricht der Feldnutzung

Die equals prüft, ob zwei Felder im Datenarray gleich sind und ob das zweite Feld nicht null ist.

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

Alternative Syntax.

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

Verwendung verschiedener Felder

Die different Regel prüft, ob zwei Felder im Datenarray nicht gleich oder unterschiedlich sind und ob das zweite Feld nicht null ist.

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

Alternative Syntax.

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

akzeptierte Feldverwendung

Die accepted Regel prüft, ob das Feld entweder „Ja“, „Ein“, „1“ oder „Wahr“ ist.

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

Alternative Syntax.

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

Verwendung numerischer Felder

Die numeric Regel prüft, ob das Feld eine Zahl ist. Dies ist analog zur PHP-Funktion is_numeric().

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

Alternative Syntax.

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

Verwendung von Ganzzahlfeldern

Die integer prüft, ob das Feld eine Ganzzahl ist.

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

Alternative Syntax.

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

Beachten Sie, dass das optionale boolesche Flag für den strikten Modus sicherstellt, dass Ganzzahlen in rein numerischer Form bereitgestellt werden. Die folgende Regel würde also als wahr ausgewertet:

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

Während das Folgende als falsch ausgewertet wird, da das + für die positive Zahl in diesem Fall überflüssig ist:

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

Verwendung boolescher Felder

Die boolean Regel prüft, ob das Feld ein boolescher Wert ist. Dies ist analog zur PHP-Funktion is_bool().

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

Alternative Syntax.

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

Verwendung von Array-Feldern

Die array -Regel prüft, ob das Feld ein Array ist. Dies ist analog zur PHP-Funktion is_array().

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

Alternative Syntax.

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

Verwendung von Längenfeldern

Die length prüft, ob das Feld genau eine bestimmte Länge hat und ob das Feld eine gültige Zeichenfolge ist.

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

Alternative Syntax.

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

Verwendung von lengthBetween-Feldern

Die lengthBetween -Regel prüft, ob das Feld zwischen einem bestimmten Längenbereich liegt und ob das Feld eine gültige Zeichenfolge ist.

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

Alternative Syntax.

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

lengthMin-Feldnutzung

Die lengthMin -Regel prüft, ob das Feld mindestens eine bestimmte Länge hat und ob das Feld eine gültige Zeichenfolge ist.

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

Alternative Syntax.

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

Verwendung von lengthMax-Feldern

Die lengthMax -Regel prüft, ob das Feld höchstens eine bestimmte Länge hat und ob das Feld eine gültige Zeichenfolge ist.

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

Alternative Syntax.

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

Min. Feldnutzung

Die min -Regel prüft, ob das Feld mindestens einen bestimmten Wert enthält und ob der bereitgestellte Wert numerisch ist.

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

Alternative Syntax.

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

Maximale Feldnutzung

Die max -Regel prüft, ob das Feld höchstens einen bestimmten Wert enthält und ob der bereitgestellte Wert numerisch ist.

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

Alternative Syntax.

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

listEnthält die Verwendung von Feldern

Die listContains -Regel prüft, ob das Feld in einem bestimmten Wertearray vorhanden ist.

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

Alternative Syntax.

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

in Feldern Verwendung

Die in Regel prüft, ob das Feld in einem bestimmten Wertearray vorhanden ist.

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

Alternative Syntax.

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

Verwendung von notIn-Feldern

Die notIn -Regel prüft, ob das Feld in einem bestimmten Wertearray NICHT vorhanden ist.

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

Alternative Syntax.

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

Verwendung von IP-Feldern

Die ip Regel überprüft, ob das Feld eine gültige IP-Adresse ist. Dazu gehören IPv4-, IPv6-, private und reservierte Bereiche.

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

Alternative Syntax.

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

Verwendung von IPv4-Feldern

Die ipv4 Regel prüft, ob das Feld eine gültige IPv4-Adresse ist.

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

Alternative Syntax.

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

Verwendung von IPv6-Feldern

Die ipv6 Regel prüft, ob das Feld eine gültige IPv6-Adresse ist.

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

Alternative Syntax.

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

Verwendung von E-Mail-Feldern

Die email Regel prüft, ob es sich bei dem Feld um eine gültige E-Mail-Adresse handelt.

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

Alternative Syntax.

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

Verwendung von emailDNS-Feldern

Die emailDNS Regel überprüft, ob es sich bei dem Feld um eine gültige E-Mail-Adresse mit einem aktiven DNS-Eintrag oder einem beliebigen Typ handelt.

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

Alternative Syntax.

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

Verwendung von URL-Feldern

Die url Regel überprüft, ob das Feld eine gültige URL ist.

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

Alternative Syntax.

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

Verwendung der aktiven URL-Felder

Die urlActive Regel prüft, ob es sich bei dem Feld um eine gültige URL mit einem aktiven A-, AAAA- oder CNAME-Eintrag handelt.

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

Alternative Syntax.

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

Verwendung von Alphafeldern

Die alpha prüft, ob das Feld nur alphabetische Zeichen enthält.

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

Alternative Syntax.

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

Verwendung von alphaNum-Feldern

Die alphaNum Regel prüft, ob das Feld nur alphabetische oder numerische Zeichen enthält.

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

Alternative Syntax.

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

Verwendung von ASCII-Feldern

Die ascii Regel prüft, ob das Feld nur Zeichen im ASCII-Zeichensatz enthält.

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

Alternative Syntax.

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

Verwendung von Slug-Feldern

Die slug Regel prüft, ob das Feld nur URL-Slug-Zeichen (az, 0-9, -, _) enthält.

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

Alternative Syntax.

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

Verwendung von Regex-Feldern

Die regex Regel stellt sicher, dass das Feld einem bestimmten Regex-Muster entspricht. (Diese Regex prüft, ob die Zeichenfolge alphanumerisch ist und zwischen 5 und 10 Zeichen lang ist.)

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

Alternative Syntax.

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

Verwendung von Datumsfeldern

Die date prüft, ob das bereitgestellte Feld ein gültiges DateTime-Objekt ist oder ob die Zeichenfolge über strtotime() in einen Unix-Zeitstempel konvertiert werden kann.

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

Alternative Syntax.

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

Verwendung von dateFormat-Feldern

Die dateFormat Regel prüft, ob das angegebene Feld ein gültiges Datum in einem angegebenen Datumsformat ist.

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

Alternative Syntax.

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

Verwendung von dateBefore-Feldern

Die dateBefore Regel prüft, ob das angegebene Feld ein gültiges Datum vor einem angegebenen Datum ist.

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

Alternative Syntax.

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

Verwendung von dateAfter-Feldern

Die dateAfter Regel prüft, ob das angegebene Feld ein gültiges Datum nach einem angegebenen Datum ist.

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

Alternative Syntax.

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

Enthält die Verwendung von Feldern

Die contains -Regel prüft, ob eine bestimmte Zeichenfolge im Feld vorhanden ist und ob das Feld und der Suchwert beide gültige Zeichenfolgen sind.

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

Alternative Syntax.

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

Hinweis Sie können das optionale Strict-Flag verwenden, um eine Übereinstimmung unter Berücksichtigung der Groß- und Kleinschreibung sicherzustellen. Das folgende Beispiel gibt true zurück:

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

Dies würde hingegen „false“ zurückgeben, da das „M“ in der Suchzeichenfolge im angegebenen Wert kein Großbuchstabe ist:

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

Verwendung von Teilmengenfeldern

Die subset prüft, ob das Feld entweder ein Skalar- oder ein Array-Feld ist und ob alle seine Werte in einem bestimmten Wertesatz enthalten sind.

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

Alternative Syntax.

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

Dieses Beispiel würde „false“ zurückgeben, da die bereitgestellte Farbe Lila nicht im Array der von uns bereitgestellten akzeptierten Werte vorhanden ist.

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

enthältEindeutige Feldverwendung

Die Regel containsUnique prüft, ob das bereitgestellte Feld ein Array ist und alle darin enthaltenen Werte eindeutig sind, dh keine doppelten Werte im Array vorhanden sind.

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

Alternative Syntax.

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

Dieses Beispiel würde „false“ zurückgeben, da die Werte im bereitgestellten Array Duplikate sind.

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

Nutzung der Kreditkartenvalidierung

Mit der Kreditkartenvalidierung können Sie derzeit eine Visa visa , Mastercard mastercard , Dinersclub dinersclub , American Express amex oder Discover discover validieren

Dadurch wird die Kreditkarte mit jedem Kartentyp verglichen

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

Um optional Kartentypen zu filtern, fügen Sie den Slug als nächsten Parameter zu einem Array hinzu:

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

Wenn Sie nur einen Kartentyp validieren möchten, geben Sie ihn als Zeichenfolge ein:

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

Wenn die Informationen zum Kartentyp vom Client stammen, möchten Sie möglicherweise auch noch ein Array gültiger Kartentypen angeben:

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

Verwendung von Instanzen von Feldern

Die Regel instanceOf prüft, ob das Feld eine Instanz einer bestimmten Klasse ist.

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

Alternative Syntax.

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

Hinweis Sie können den Wert auch mit einem bestimmten Objekt und nicht mit dem Namen der Zeichenfolgenklasse vergleichen. Dieses Beispiel würde auch true zurückgeben:

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

Verwendung optionaler Felder

Die optional Regel stellt sicher, dass das Feld, wenn es im Datensatz vorhanden ist, alle Validierungsregeln besteht.

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

Alternative Syntax. Dieses Beispiel würde „true“ zurückgeben, wenn das Feld „Benutzername“ nicht vorhanden ist oder wenn der Benutzername nur aus alphabetischen Zeichen besteht.

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

Dieses Beispiel würde „false“ zurückgeben, da das Feld zwar optional ist, da es jedoch alle Validierungsregeln erfüllen muss, was in diesem Fall nicht der Fall ist.

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

Verwendung von arrayHasKeys-Feldern

Die Regel arrayHasKeys stellt sicher, dass das Feld ein Array ist und alle angegebenen Schlüssel enthält. Gibt „false“ zurück, wenn das Feld kein Array ist oder wenn keine erforderlichen Schlüssel angegeben sind oder wenn ein Schlüssel fehlt.

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

Hinzufügen benutzerdefinierter Validierungsregeln

Um Ihre eigene Validierungsregel hinzuzufügen, verwenden Sie die Methode addRule mit einem Regelnamen, einem benutzerdefinierten Rückruf oder Abschluss und einer Fehlermeldung, die im Fehlerfall angezeigt wird. Der bereitgestellte Rückruf sollte den booleschen Wert „true“ oder „false“ zurückgeben.

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

Sie können auch einmalige Regeln verwenden, die nur für die angegebenen Felder gelten.

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

Dies ist nützlich, da solche Regeln Zugriff auf Variablen haben können, die in dem Bereich definiert sind, in dem sich der Validator befindet. Die Signatur des Abschlusses ist identisch mit der Signatur des Validator::addRule Rückrufs.

Wenn Sie Ihre eigenen Regeln hinzufügen möchten, die nicht statisch sind (d. h. Ihre Regel ist nicht statisch und zum Aufrufen Validator Instanzen verfügbar), müssen Sie Validator::addInstanceRule verwenden. Diese Regel verwendet dieselben Parameter wie Validator::addRule muss jedoch auf einer Validator -Instanz aufgerufen werden.

Verkettungsregeln

Mithilfe der folgenden Syntax können Sie mehrere Regeln miteinander verketten.

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

Alternative Syntax zum Hinzufügen von Regeln

Wenn die Anzahl der Regeln zunimmt, bevorzugen Sie möglicherweise die alternative Syntax zum gleichzeitigen Definieren mehrerer Regeln.

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

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

Wenn Ihre Regel mehrere Parameter erfordert oder ein einzelner Parameter komplexer als eine Zeichenfolge ist, müssen Sie die Regel in ein Array einbinden.

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

Sie können für jeden Regeltyp auch mehrere Regeln angeben.

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

Durch die Kombination dieser Techniken können Sie eine vollständige Regeldefinition in einer relativ kompakten Datenstruktur erstellen.

Sie können mit der rule weiterhin einzelne Regeln hinzufügen, auch nachdem Sie eine Regeldefinition über ein Array angegeben haben. Dies ist besonders nützlich, wenn Sie benutzerdefinierte Validierungsregeln definieren.

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

Sie können Regeln auch feldweise hinzufügen:

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

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

Oder für mehrere Felder gleichzeitig:

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

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

Feldbeschriftung zu Nachrichten hinzufügen

Sie können dies auf zwei verschiedene Arten tun: Sie können einer Regel eine einzelne Beschriftung oder ein Array aller Beschriftungen für die Regeln hinzufügen.

Um einer Regel eine individuelle Beschriftung hinzuzufügen, fügen Sie einfach die label nach der Regel hinzu.

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

Bei dieser Methode gibt es einen Grenzfall: Sie könnten kein Array von Feldnamen in der Regeldefinition verwenden, also eine Regel pro Feld. Das würde also nicht funktionieren:

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

Wir können jedoch ein Array von Labels verwenden, um dieses Problem zu lösen, indem wir stattdessen einfach die labels -Methode hinzufügen:

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

Dadurch wird ein neuer Satz von Tags in Ihre Fehlersprachdatei eingeführt, der wie folgt aussieht {field} . Wenn Sie eine Regel wie equals verwenden, können Sie auf den zweiten Wert in der Sprachdatei zugreifen, indem Sie das Feld mit einem Wert wie {field1} erhöhen.

Wiederverwendung von Validierungsregeln

Mit der Methode „withData“ können Sie Ihre Validierungsregeln wiederverwenden, um schnell verschiedene Daten mit denselben Regeln zu validieren:

 $ 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 

Ausführen von Tests

Die Testsuite ist zum Laden und Ausführen der Valitron-Dateien auf den Composer-Autoloader angewiesen. Bitte stellen Sie sicher, dass Sie Composer heruntergeladen und installiert haben, bevor Sie die Tests ausführen:

1. Laden Sie Composer curl -s http://getcomposer.org/installer | php herunter curl -s http://getcomposer.org/installer | php
2. Führen Sie „install“ php composer.phar install
3. Führen Sie die Tests phpunit aus

Mitwirken

1. Gabel es
2. Erstellen Sie Ihren Feature-Zweig ( git checkout -b my-new-feature )
3. Nehmen Sie Ihre Änderungen vor
4. Führen Sie die Tests durch und fügen Sie bei Bedarf neue für Ihren eigenen Code hinzu ( phpunit )
5. Übernehmen Sie Ihre Änderungen ( git commit -am 'Added some feature' )
6. Zum Zweig pushen ( git push origin my-new-feature )
7. Erstellen Sie eine neue Pull-Anfrage
8. Klopfen Sie sich selbst auf die Schulter, weil Sie so großartig sind

Sicherheitsoffenlegungen und Kontaktinformationen

Um eine Sicherheitslücke zu melden, wenden Sie sich bitte an den Sicherheitskontakt von Tidelift. Tidelift wird die Behebung und Offenlegung koordinieren.