Tolles Community-Modul

validatorjs

Build-Status

Die validatorjs-Bibliothek macht die Datenvalidierung in JavaScript sowohl im Browser als auch in Node.js sehr einfach. Diese Bibliothek wurde vom Validator des Laravel-Frameworks inspiriert .

Warum validatorjs verwenden?

  • Unabhängig von irgendwelchen Bibliotheken.
  • Funktioniert sowohl im Browser als auch in Node.
  • Lesbare und deklarative Validierungsregeln.
  • Fehlermeldungen mit mehrsprachiger Unterstützung.
  • Unterstützung von AMD/Require.js und CommonJS/Browserify.

Installation

Holen Sie sich validatorjs von Bower, NPM oder dem /dist-Verzeichnis auf Github:

1
bower install validatorjs
1
npm install validatorjs

Browser

1
<script src="validator.js"></script>

Node.js / Browserify

1
let Validator = require('validatorjs');

Basic Usage

1
let validation = new Validator(data, rules [, customErrorMessages]);

data {Object} – Die Daten, die Sie validieren möchten

rules {Objekt} – Validierungsregeln

customErrorMessages {Object} – Optionale benutzerdefinierte Fehlermeldungen, die zurückgegeben werden sollen

Beispiel 1 – Bestehen der Validierung

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
let data = { name: 'John', email: 'johndoe@gmail.com', age: 28 }; let rules = { name: 'required', email: 'required|email', age: 'min:18' }; let validation = new Validator(data, rules); validation.passes(); // true validation.fails(); // false

Um Validierungsregeln auf das Datenobjekt anzuwenden , verwenden Sie dieselben Objektschlüsselnamen für das Regelobjekt .

Beispiel 2 – Fehlerhafte Validierung

1 2 3 4 5 6 7 8 9 10 11 12 13 14
let validation = new Validator({ name: 'D', email: 'not an email address.com' }, { name: 'size:3', email: 'required|email' }); validation.fails(); // true validation.passes(); // false // Error messages validation.errors.first('email'); // 'The email format is invalid.' validation.errors.get('email'); // returns an array of all email error messages

Nested Rules

Auch verschachtelte Objekte können validiert werden. Es gibt zwei Möglichkeiten, Validierungsregeln für verschachtelte Objekte zu deklarieren. Die erste Möglichkeit besteht darin, die Validierungsregeln mit einer entsprechenden verschachtelten Objektstruktur zu deklarieren, die die Daten widerspiegelt. Die zweite Möglichkeit besteht darin, Validierungsregeln mit abgeflachtem Schlüssel zu deklarieren Namen, um beispielsweise die folgenden Daten zu validieren:

1 2 3 4 5 6 7 8 9 10
let data = { name: 'John', bio: { age: 28, education: { primary: 'Elementary School', secondary: 'Secondary School' } } };

Wir könnten unsere Validierungsregeln wie folgt deklarieren:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
let nested = { name: 'required', bio: { age: 'min:18', education: { primary: 'string', secondary: 'string' } } }; // OR let flattened = { 'name': 'required', 'bio.age': 'min:18' 'bio.education.primary': 'string', 'bio.education.secondary': 'string' };

WildCards Rules

Auch WildCards können validiert werden.

1 2 3 4 5 6 7 8 9 10 11 12
let data = { users: [{ name: 'John', bio: { age: 28, education: { primary: 'Elementary School', secondary: 'Secondary School' } } }] };

Wir könnten unsere Validierungsregeln wie folgt deklarieren:

1 2 3 4 5 6
let rules = { 'users.*.name': 'required', 'users.*.bio.age': 'min:18' 'users.*.bio.education.primary': 'string', 'users.*.bio.education.secondary': 'string' };

Available Rules

Validierungsregeln haben kein implizites „erforderlich". Wenn ein Feld undefiniert oder eine leere Zeichenfolge ist, besteht es die Validierung. Wenn Sie möchten, dass eine Validierung für undefiniert oder '' fehlschlägt, verwenden Sie die erforderliche Regel.

akzeptiert

Das validierte Feld muss yes, on, 1 oder true sein. Dies ist nützlich, um die Annahme der „Nutzungsbedingungen“ zu validieren.

nach: Datum

Das zu validierende Feld muss nach dem angegebenen Datum liegen.

nach_oder_gleich:Datum

Das Feld unter Validierung muss nach oder gleich dem angegebenen Feld sein

Alpha

Das zu validierende Feld muss ausschließlich aus alphabetischen Zeichen bestehen.

alpha_dash

Das zu validierende Feld kann alphanumerische Zeichen sowie Bindestriche und Unterstriche enthalten.

alpha_num

Das zu validierende Feld muss vollständig aus alphanumerischen Zeichen bestehen.

Reihe

Das zu validierende Feld muss ein Array sein.

vor: Datum

Das zu validierende Feld muss vor dem angegebenen Datum liegen.

vor_oder_gleich:Datum

Das zu validierende Feld muss vor oder gleich dem angegebenen Datum liegen.

zwischen:min,max

Das zu validierende Feld muss eine Größe zwischen den angegebenen Mindest- und Höchstwerten haben. Zeichenfolgen, Zahlen und Dateien werden auf die gleiche Weise wie die Größenregel ausgewertet.

boolesch

Das zu validierende Feld muss ein boolescher Wert der Form true, false, 0, 1, 'true', 'false', '0', '1', sein.

Bestätigt

Das zu validierende Feld muss ein übereinstimmendes Feld von foo_confirmation haben. Wenn das zu validierende Feld beispielsweise password ist, muss ein übereinstimmendes password_confirmation-Feld in der Eingabe vorhanden sein.

Datum

Das validierte Feld muss ein gültiges Datumsformat haben, das vom Javascript- DateObjekt akzeptiert wird.

Ziffern: Wert

Das zu validierende Feld muss numerisch sein und eine genaue Wertlänge haben.

anders: Attribut

Das angegebene Feld muss sich von dem zu validierenden Feld unterscheiden.

Email

Das zu validierende Feld muss als E-Mail-Adresse formatiert sein.

verhexen

Das zu validierende Feld sollte ein hexadezimales Format haben. Nützlich in Kombination mit anderen Regeln, hex|size:6z. B. für die Validierung von Hex-Farbcodes.

in:foo,bar,...

Das zu validierende Feld muss in der angegebenen Werteliste enthalten sein. Das Feld kann ein Array oder eine Zeichenfolge sein.

ganze Zahl

Das zu validierende Feld muss einen ganzzahligen Wert haben.

max:wert

Validieren Sie, dass ein Attribut nicht größer als eine bestimmte Größe ist

Hinweis: Maximale Schecks sind inklusive.

min:wert

Validieren Sie, dass ein Attribut mindestens eine bestimmte Größe hat.

Hinweis: Mindestkontrollen sind inklusive.

not_in:foo,bar,...

Das zu validierende Feld darf nicht in der angegebenen Werteliste enthalten sein.

numerisch

Bestätigen, dass ein Attribut numerisch ist. Die Zeichenfolgendarstellung einer Zahl wird bestanden.

erforderlich

Überprüft, ob die Länge der String-Darstellung des Werts > ist

erforderlich_wenn: ein anderes Feld, Wert

Das validierte Feld muss vorhanden und darf nicht leer sein, wenn das Feld otherfield einen beliebigen Wert hat.

erforderlich_es sei denn: ein anderes Feld, Wert

Das zu validierende Feld muss vorhanden und darf nicht leer sein, es sei denn, das Feld otherfield hat einen beliebigen Wert.

erforderlich_mit:foo,bar,...

Das zu validierende Feld muss vorhanden sein und darf nur dann leer sein, wenn eines der anderen angegebenen Felder vorhanden ist.

required_with_all:foo,bar,...

Das validierte Feld muss vorhanden sein und darf nur dann leer sein, wenn alle anderen angegebenen Felder vorhanden sind.

erforderlich_ohne:foo,bar,...

Das validierte Feld muss vorhanden sein und darf nur dann leer sein, wenn keines der anderen angegebenen Felder vorhanden ist.

erforderlich_ohne_all:foo,bar,...

Das zu validierende Feld muss vorhanden und darf nur dann leer sein, wenn alle anderen angegebenen Felder nicht vorhanden sind.

gleich: Attribut

Das angegebene Feld muss mit dem validierten Feld übereinstimmen.

Größe:Wert

Das zu validierende Feld muss eine Größe haben, die dem angegebenen Wert entspricht. Bei Zeichenfolgendaten entspricht der Wert der Anzahl der Zeichen. Bei numerischen Daten entspricht der Wert einem bestimmten ganzzahligen Wert.

Schnur

Das zu validierende Feld muss eine Zeichenfolge sein.

URL

Überprüfen Sie, ob ein Attribut ein gültiges URL-Format hat

Regex:Muster

Das zu validierende Feld muss mit dem angegebenen regulären Ausdruck übereinstimmen.

Hinweis : Wenn Sie das regexMuster verwenden, müssen Sie möglicherweise Regeln in einem Array angeben, anstatt Pipe-Trennzeichen zu verwenden, insbesondere wenn der reguläre Ausdruck ein Pipe-Zeichen enthält.Für jeden umgekehrten Schrägstrich, den Sie in Ihrem Regex-Muster verwendet haben, müssen Sie jeden einzelnen maskieren mit einem weiteren Backslash.

Beispiel 3 – Regex-Validierung

1 2 3 4 5 6 7 8 9 10 11 12 13
let validation = new Validator({ name: 'Doe', salary: '10,000.00', yearOfBirth: '1980' }, { name: 'required|size:3', salary: ['required', 'regex:/^(?!0\\.00)\\d{1,3}(,\\d{3})*(\\.\\d\\d)?$/'], yearOfBirth: ['required', 'regex:/^(19|20)[\\d]{2,2}$/'] }); validation.fails(); // false validation.passes(); // true

Beispiel 4 – Typüberprüfungsvalidierung

1 2 3 4 5 6 7 8 9 10 11
let validation = new Validator({ age: 30, name: '' }, { age: ['required', { 'in': [29, 30] }], name: [{ required_if: ['age', 30] }] }); validation.fails(); // true validation.passes(); // false

Register Custom Validation Rules

1
Validator.register(name, callbackFn, errorMessage);

name {String} – Der Name der Regel.

callbackFn {Funktion} – Gibt einen booleschen Wert zurück, um eine erfolgreiche oder fehlgeschlagene Validierung darzustellen.

errorMessage {String} – Eine optionale Zeichenfolge, in der Sie eine benutzerdefinierte Fehlermeldung angeben können. :attribute in errorMessage wird durch den Attributnamen ersetzt.

1 2 3
Validator.register('telephone', function(value, requirement, attribute) { // requirement parameter defaults to null return value.match(/^\d{3}-\d{3}-\d{4}$/); }, 'The :attribute phone number is not in the format XXX-XXX-XXXX.');

Asynchronous Validation

Registrieren Sie eine asynchrone Regel, die einen passesRückruf akzeptiert:

1 2 3 4 5 6
Validator.registerAsync('username_available', function(username, attribute, req, passes) { // do your database/api checks here etc // then call the `passes` method where appropriate: passes(); // if username is available passes(false, 'Username has already been taken.'); // if username is not available });

Rufen Sie dann Ihren Validator an und geben Sie einen Rückruf an failsoder passesso weiter:

1 2 3 4 5 6 7 8 9 10 11 12 13
let validator = new Validator({ username: 'test123' }, { username: 'required|min:3|username_available' }); validator.passes(function() { // Validation passed }); validator.fails(function() { validator.errors.first('username'); });

Hinweis: Wenn Sie versuchen, passesoder failsohne Rückruf aufzurufen, und der Validator erkennt, dass es asynchrone Validierungsregeln gibt, wird eine Ausnahme ausgelöst.

Error Messages

Dieser Konstruktor generiert automatisch Fehlermeldungen für fehlgeschlagene Validierungsregeln.

Wenn Fehler auftreten, wird das Eigenschaftsobjekt „ errors “ der Validator-Instanz mit den Fehlermeldungen für alle fehlerhaften Attribute gefüllt.Die Methoden und Eigenschaften des Eigenschaftsobjekts „ errors “ sind:

.first(Attribut)

gibt die erste Fehlermeldung für ein Attribut zurück, andernfalls false

.get(Attribut)

gibt ein Array mit Fehlermeldungen für ein Attribut oder ein leeres Array zurück, wenn keine Fehler vorliegen

.alle()

gibt ein Objekt zurück, das alle Fehlermeldungen für alle fehlerhaften Attribute enthält

.has(Attribut)

gibt true zurück, wenn Fehlermeldungen für ein Attribut vorhanden sind, andernfalls false

.errorCount

die Anzahl der Validierungsfehler

1 2 3
let validation = new Validator(input, rules); validation.errors.first('email'); // returns first error message for email attribute validator.errors.get('email'); // returns an array of error messages for the email attribute

Custom Error Messages

Wenn Sie eine bestimmte Fehlermeldung benötigen und die Standardnachricht nicht überschreiben möchten, können Sie eine Überschreibung als drittes Argument an das Validator-Objekt übergeben, genau wie bei Laravel .

1 2 3 4 5 6 7 8 9 10
let input = { name: '' }; let rules = { name : 'required' }; let validation = new Validator(input, rules, { required: 'You forgot to give a :attribute' }); validation.errors.first('name'); // returns 'You forgot to give a name'

Einige der Validatoren haben String- und numerische Versionen, die Sie auch ändern können.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
let input = { username: 'myusernameistoolong' }; let rules = { username : 'max:16' }; let validation = new Validator(input, rules, { max: { string: 'The :attribute is too long. Max length is :max.' } }); validation.errors.first('username'); // returns 'The username is too long. Max length is 16.'

Sie können sogar Fehlermeldungen pro Attribut angeben! Setzen Sie einfach den Schlüssel der Nachricht auf „validator.attribute“.

1 2 3 4 5 6 7 8 9
let input = { name: '', email: '' }; let rules = { name : 'required', email : 'required' }; let validation = new Validator(input, rules, { "required.email": "Without an :attribute we can't reach you!" }); validation.errors.first('name'); // returns 'The name field is required.' validation.errors.first('email'); // returns 'Without an email we can\'t reach you!'

Custom Attribute Names

Um einen benutzerdefinierten "freundlichen" Attributnamen in Fehlermeldungen anzuzeigen, verwenden Sie.setAttributeNames()

1 2 3 4 5
let validator = new Validator({ name: '' }, { name: 'required' }); validator.setAttributeNames({ name: 'custom_name' }); if (validator.fails()) { validator.errors.first('name'); // "The custom_name field is required." }

Alternativ können Sie globale benutzerdefinierte Attributnamen in Ihrer Sprache mit der attributesEigenschaft bereitstellen.

Sie können auch einen benutzerdefinierten Attributformatierer konfigurieren:

1 2 3 4 5 6 7 8 9 10 11 12 13
// Configure global formatter. Validator.setAttributeFormatter(function(attribute) { return attribute.replace(/_/g, ' '); }); // Or configure formatter for particular instance. let validator = new Validator({ first_name: '' }, { first_name: 'required' }); validator.setAttributeFormatter(function(attribute) { return attribute.replace(/_/g, ' '); }); if (validator.fails()) { console.log(validator.errors.first('first_name')); // The first name field is required. }

Hinweis: Standardmäßig werden alle _-Zeichen durch Leerzeichen ersetzt.

Language Support

Fehlermeldungen sind standardmäßig auf Englisch. Um eine andere Sprache in den Browser aufzunehmen, verweisen Sie auf die Sprachdatei in einem script-Tag und rufen Sie auf Validator.useLang('lang_code').

1 2 3 4 5
<script src="dist/validator.js"></script> <script src="dist/lang/ru.js"></script> <script> Validator.useLang('es'); </script>

In Node werden die Sprachquelldateien automatisch übernommen.

1 2
let Validator = require('validatorjs'); Validator.useLang('ru');

Wenn Sie keine Unterstützung für Ihre Sprache sehen, fügen Sie bitte eine zu hinzu src/lang!

Sie können auch Ihre eigene benutzerdefinierte Sprache hinzufügen, indem Sie anrufen setMessages:

1 2 3
Validator.setMessages('lang_code', { required: 'The :attribute field is required.' });

Holen Sie sich das Rohobjekt von Nachrichten für die angegebene Sprache:

1
Validator.getMessages('lang_code');

Wechseln Sie die vom Validator verwendete Standardsprache:

1
Validator.useLang('lang_code');

Holen Sie sich die verwendete Standardsprache:

1
Validator.getDefaultLang(); // returns e.g. 'en'

Standardmeldungen für Sprache überschreiben:

1 2 3
let messages = Validator.getMessages('en'); messages.required = 'Whoops, :attribute field is required.'; Validator.setMessages('en', messages);