Tolles Community-Modul

validatorjs

Build-Status

Die Bibliothek validatorjs 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 Bibliotheken.
  • Funktioniert sowohl im Browser als auch in Node.
  • Lesbare und deklarative Validierungsregeln.
  • Fehlermeldungen mit mehrsprachiger Unterstützung.
  • Unterstützung für 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

Regeln {Object}-Validierungsregeln

customErrorMessages {Object} – Optionale zurückzugebende benutzerdefinierte Fehlermeldungen

Beispiel 1 – Bestandene 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 – Fehlgeschlagene 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

Verschachtelte Objekte können ebenfalls 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 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

WildCards können ebenfalls 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 nicht definiert oder eine leere Zeichenfolge ist, besteht die Validierung. Wenn eine Validierung für undefiniertes oder '' fehlschlagen soll, verwenden Sie die erforderliche Regel.

akzeptiert

Das zu validierende 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.

after_or_equal:date

Das zu validierende Feld 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 ausschließlich aus alphanumerischen Zeichen bestehen.

Array

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 sein.

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 dieselbe Weise wie die Größenregel ausgewertet.

boolesch

Ein unter MUSS BE Feld Validierung von A Boolescher Wert Die Form von true, false, 0, 1, 'true', 'false', '0', '1',

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 zu validierende Feld muss ein gültiges Datumsformat aufweisen, 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 vom 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, z. B. hex|size:6fü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 ein String sein.

ganze Zahl

Das zu validierende Feld muss einen ganzzahligen Wert haben.

max:Wert

Überprüfen Sie, ob ein Attribut eine bestimmte Größe nicht überschreitet

Hinweis: Maximale Schecks sind inklusive.

min:Wert

Überprüfen Sie, ob ein Attribut mindestens eine bestimmte Größe hat.

Hinweis: Mindestschecks sind inklusive.

not_in:foo,bar,...

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

numerisch

Überprüfen Sie, ob ein Attribut numerisch ist. Die Zeichenfolgendarstellung einer Zahl wird übergeben.

erforderlich

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

required_if:anotherfield,value

Das zu validierende Feld muss vorhanden sein und darf nicht leer sein, wenn das Feld otherfield einem beliebigen Wert entspricht.

required_unless:anotherfield,value

Das zu validierende Feld muss vorhanden sein und darf nicht leer sein, es sei denn, das otherfield-Feld ist gleich einem 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 zu validierende Feld muss vorhanden sein und darf nur dann leer sein, wenn alle anderen angegebenen Felder vorhanden sind.

erforderlich_ohne:foo,bar,...

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

erforderlich_ohne_all: foo,bar,...

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

gleich: Attribut

Das angegebene Feld muss mit dem zu validierenden 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 mit Escapezeichen versehen mit einem weiteren Schrägstrich.

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-Prü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, indem Sie einen Rückruf an failsoder passesso senden :

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: Erkennt, ob Sie versuchen, passesoder failsohne Rückruf anzurufen und der Validator asynchrone Validierungsregeln gibt, wird eine Ausnahme ausgelöst.

Error Messages

Dieser Konstruktor generiert automatisch Fehlermeldungen für fehlgeschlagene Validierungsregeln.

Wenn es Fehler gibt, wird die Validator - Instanz seines haben Fehler . Eigenschaftsobjekt mit den Fehlermeldungen für alle Fehler Attribute bevölkert Die Methoden und Eigenschaften auf dem Fehler Eigenschaftsobjekt sind:

.first(Attribut)

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

.get(Attribut)

gibt ein Array von 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 fehlgeschlagenen Attribute enthält

.hat(Attribut)

gibt true zurück, wenn Fehlermeldungen für ein Attribut vorliegen, 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 Standard-Fehlermeldung 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. Sie können diese auch ändern.

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 bereitstellen! Legen Sie einfach den Schlüssel der Nachricht auf "validator.attribute" fest.

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 mit der attributesEigenschaft globale benutzerdefinierte Attributnamen in Ihrer Sprache angeben .

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 in Englisch. Um eine andere Sprache in den Browser einzubinden, verweisen Sie auf die Sprachdatei in einem Skript-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 wird es automatisch auf die Sprachquelldateien aufgenommen.

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 Folgendes anrufen setMessages:

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

Rufen Sie das Rohobjekt von Nachrichten für die angegebene Sprache ab:

1
Validator.getMessages('lang_code');

Wechseln Sie die vom Validator verwendete Standardsprache:

1
Validator.useLang('lang_code');

Rufen Sie die verwendete Standardsprache ab:

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

Standardnachrichten für Sprache überschreiben:

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