Fantastisches Community-Modul

validatorjs

Build-Status

Die validatorjs-Bibliothek erleichtert die Datenüberprüfung in JavaScript sowohl im Browser als auch in Node.js. Diese Bibliothek wurde vom Validator des Laravel-Frameworks inspiriert.

Warum validatorjs verwenden?

  • Nicht abhängig von Bibliotheken.
  • Funktioniert sowohl im Browser als auch im Knoten.
  • Lesbare und deklarative Validierungsregeln.
  • Fehlermeldungen mit mehrsprachiger Unterstützung.
  • Unterstützung für AMD / Require.js und CommonJS / Browserify.

Installation

Holen Sie sich validatorjs aus Bower, NPM oder dem Verzeichnis / dist 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 {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

Verwenden Sie zum Anwenden von Validierungsregeln auf das Datenobjekt 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

Verschachtelte Objekte können auch 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 einem reduzierten 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

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 undefiniert oder eine leere Zeichenfolge ist, besteht es die Validierung. Wenn eine Validierung für undefiniert 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: Datum

Das zu validierende Feld muss nach oder gleich dem angegebenen Feld sein

Alpha

Das zu validierende Feld muss vollständig alphabetisch sein.

alpha_dash

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

alpha_num

Das zu validierende Feld muss vollständig alphanumerisch sein.

Array

Das zu validierende Feld muss ein Array sein.

vor: Datum

Das zu validierende Feld muss vor dem angegebenen Datum liegen.

before_or_equal: 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 Min- und Max-Werten haben. Zeichenfolgen, Zahlen und Dateien werden auf dieselbe Weise wie die Größenregel ausgewertet.

Boolescher Wert

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 in der Eingabe ein übereinstimmendes Feld password_confirmation vorhanden sein.

Datum

Field, ein unter der MUSS Validierung auf der A DATE! Valid Format , das von Javascripts akzeptabel ist Date - Objekt.

Ziffern: Wert

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

anders: Attribut

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

E-Mail

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

hex

Das zu validierende Feld sollte ein hexadezimales Format haben. Nützlich in Kombination mit anderen Regeln wie hex|size:6 für die Validierung des hexadezimalen Farbcodes.

in: foo, bar, ...

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

Ganzzahl

Das zu validierende Feld muss einen ganzzahligen Wert haben.

max: Wert

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

Hinweis: Maximale Überprüfungen sind inklusive.

min: Wert

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

Hinweis: Mindestprüfungen sind inklusive.

not_in: foo, bar, ...

Das zu validierende Feld darf nicht in die angegebene Werteliste aufgenommen werden.

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: ein anderes Feld, Wert

Das zu validierende Feld muss vorhanden und nicht leer sein, wenn das Feld für ein anderes Feld einem beliebigen Wert entspricht.

require_unless: ein anderes Feld, Wert

Das zu validierende Feld muss vorhanden und nicht leer sein, es sei denn, das Feld für ein anderes Feld entspricht einem beliebigen Wert.

required_with: foo, bar, ...

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

required_with_all: foo, bar, ...

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

Erforderlich_ohne: foo, bar, ...

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

required_without_all: foo, bar, ...

Das zu validierende Feld darf nur vorhanden und nicht leer sein, wenn nicht alle anderen angegebenen Felder 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.

Zeichenfolge

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 regex Muster verwenden, müssen möglicherweise Regeln in einem Array angegeben werden, anstatt Pipe-Trennzeichen zu verwenden, insbesondere wenn der reguläre Ausdruck ein Pipe-Zeichen enthält. Für jeden Schrägstrich, den Sie in Ihrem Regex-Muster verwendet haben, müssen Sie jedes maskieren einer mit einem anderen 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-Type Checking Validation

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 {Function} - 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 .: Das Attribut 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 passes Rü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 Ihren Validator A die dann zu Rückruf vorbei fails oder passes in etwa so:

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 zu Anrufversuch passes oder fails die ohne einen Rückruf und es gibt bei den Validator Detects Asynchronous Validierungsregeln, durch eine Ausnahme geworfen werden.

Error Messages

Dieser Konstruktor generiert automatisch Fehlermeldungen für fehlgeschlagene Validierungsregeln.

Wenn Fehler vorliegen, wird in der Validator-Instanz das Fehler- Eigenschaftsobjekt mit den Fehlermeldungen für alle fehlerhaften Attribute gefüllt. Die Methoden und Eigenschaften für das Fehler- Eigenschaftsobjekt sind:

.first (Attribut)

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

.get (Attribut)

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

.all ()

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

.hat (Attribut)

Gibt true zurück, wenn für ein Attribut Fehlermeldungen 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 Standardmeldung nicht überschreiben möchten, können Sie wie bei Laravel eine Überschreibung als drittes Argument an das Validator-Objekt übergeben.

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 Zeichenfolgen- und numerische Versionen. Sie können sie 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! Setzen Sie den Schlüssel der Nachricht einfach 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

Verwenden Sie .setAttributeNames() um einen benutzerdefinierten "freundlichen" Attributnamen in Fehlermeldungen .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 attributes Eigenschaft 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 aufzunehmen, verweisen Sie auf die Validator.useLang('lang_code') in einem Skript-Tag und rufen Sie 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 erfasst.

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 src/lang !

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

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

Holen Sie sich das Rohobjekt der 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'

Standardnachrichten für Sprache überschreiben:

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