validatorjs

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?

• Nicht abhängig von irgendwelchen Bibliotheken.
• Funktioniert sowohl im Browser als auch im 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 {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 – 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

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 einem abgeflachten Schlüssel zu deklarieren Namen. Zum Beispiel, um 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 zu validierende Feld muss „Ja“, „Ein“, „1“ oder „Wahr“ 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 vollständig 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.

before_or_equal:date

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

zwischen:min,max

Das zu validierende Feld muss eine Größe zwischen der angegebenen Mindest- und Höchstgröße haben. Zeichenfolgen, Zahlen und Dateien werden auf die gleiche 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 passendes Feld „foo_confirmation“ haben. Wenn das zu validierende Feld beispielsweise „password“ ist, muss in der Eingabe ein passendes „password_confirmation“-Feld vorhanden sein.

Datum

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

different: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 Hexadezimalformat 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 eine Zeichenfolge sein.

ganze Zahl

Das zu validierende Feld muss einen ganzzahligen Wert haben.

max:Wert

Überprüfen Sie, ob ein Attribut nicht größer als eine bestimmte Größe ist

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

erforderlich_if:anotherfield,value

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

erforderlich_unless:anotherfield,value

Das zu validierende Feld muss vorhanden und darf nicht leer sein, es sei denn, das Feld anotherfield entspricht einem 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.

require_with_all:foo,bar,...

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

erforderlich_ohne:foo,bar,...

Das zu validierende Feld muss vorhanden 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 nur dann vorhanden und nicht 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.

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 : Bei der Verwendung des regexMusters kann es erforderlich sein, Regeln in einem Array anzugeben, 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 einem Escapezeichen versehen mit einem weiteren umgekehrten Schrägstrich.

Beispiel 3 – Regex-Validierung

1
2
3
4
5
6
7
8
9
10
11
12
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 – Typprüfungsvalidierung

1
2
3
4
5
6
7
8
9
10
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, der eine erfolgreiche oder fehlgeschlagene Validierung darstellt.

errorMessage {String} – Eine optionale Zeichenfolge, in der Sie eine benutzerdefinierte Fehlermeldung angeben können. :attribute innerhalb von 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

passesRegistrieren Sie eine asynchrone Regel, die einen 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 dann Ihren Validator an und geben Sie einen Rückruf an failsoder passesso:

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, einen Anruf passesoder failsohne Rückruf durchzuführen, und der Validator erkennt, dass asynchrone Validierungsregeln vorhanden sind, wird eine Ausnahme ausgelöst.

Error Messages

Dieser Konstruktor generiert automatisch Fehlermeldungen für fehlgeschlagene Validierungsregeln.

Wenn Fehler vorliegen, 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 von Fehlermeldungen für ein Attribut zurück oder ein leeres Array, 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 für ein Attribut Fehlermeldungen 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 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 verfügen über Zeichenfolgen- 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 Fehlermeldungen sogar auf Attributbasis bereitstellen! 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 mit der Eigenschaft globale benutzerdefinierte Attributnamen in Ihrer Sprache angeben attributes.

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 werden standardmäßig in Englisch angezeigt. Um eine andere Sprache in den Browser aufzunehmen, verweisen Sie in einem Skript-Tag auf die Sprachdatei 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 automatisch die Sprachquelldateien ü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 hinzu src/lang!

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

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

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

Standardmeldungen für die Sprache überschreiben:

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