validateurjs

La bibliothèque validatorjs rend la validation des données en JavaScript très simple à la fois dans le navigateur et dans Node.js. Cette bibliothèque a été inspirée par Validator du framework Laravel .

Pourquoi utiliser validateurjs ?

• Ne dépend d’aucune bibliothèque.
• Fonctionne à la fois dans le navigateur et dans Node.
• Règles de validation lisibles et déclaratives.
• Messages d'erreur avec support multilingue.
• Prise en charge d'AMD/Require.js et CommonJS/Browserify.

Installation

Récupérez validatorjs depuis Bower, NPM ou le répertoire /dist sur 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} - Les données que vous souhaitez valider

règles {Objet} - Règles de validation

customErrorMessages {Object} - Messages d'erreur personnalisés facultatifs à renvoyer

Exemple 1 – Réussite de la validation

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

Pour appliquer des règles de validation à l' objet de données , utilisez les mêmes noms de clé d'objet pour l' objet de règles .

Exemple 2 - Échec de la validation

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

Les objets imbriqués peuvent également être validés. Il existe deux manières de déclarer des règles de validation pour les objets imbriqués. La première consiste à déclarer les règles de validation avec une structure d'objet imbriqué correspondante qui reflète les données. La deuxième méthode consiste à déclarer les règles de validation avec une clé aplatie. noms. Par exemple, pour valider les données suivantes :

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

Nous pourrions déclarer nos règles de validation comme suit :

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

Les WildCards peuvent également être validées.

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'
      }
    }
  }]
};

Nous pourrions déclarer nos règles de validation comme suit :

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

Les règles de validation n'ont pas de "obligatoire" implicite. Si un champ n'est pas défini ou s'il s'agit d'une chaîne vide, il passera la validation. Si vous souhaitez qu'une validation échoue pour un champ non défini ou ", utilisez la règle requise .

accepté

Le champ sous validation doit être oui, activé, 1 ou vrai. Ceci est utile pour valider l'acceptation des "Conditions de service".

après : date

Le champ en cours de validation doit être postérieur à la date indiquée.

après_ou_égal : date

Le champ en cours de validation doit être postérieur ou égal au champ donné

alpha

Le champ en cours de validation doit être entièrement composé de caractères alphabétiques.

tiret_alpha

Le champ en cours de validation peut contenir des caractères alphanumériques, ainsi que des tirets et des traits de soulignement.

numéro_alpha

Le champ en cours de validation doit être entièrement composé de caractères alphanumériques.

tableau

Le champ en cours de validation doit être un tableau.

avant : date

Le champ en cours de validation doit être antérieur à la date indiquée.

avant_ou_égal : date

Le champ en cours de validation doit être antérieur ou égal à la date indiquée.

entre: min, max

Le champ en cours de validation doit avoir une taille comprise entre les valeurs minimale et maximale indiquées. Les chaînes, les valeurs numériques et les fichiers sont évalués de la même manière que la règle de taille.

booléen

Le champ en cours de validation doit être une valeur booléenne de la forme true, false, 0, 1, 'true', 'false', '0', '1',

confirmé

Le champ sous validation doit avoir un champ correspondant de foo_confirmation. Par exemple, si le champ sous validation est un mot de passe, un champ password_confirmation correspondant doit être présent dans l'entrée.

date

Le champ en cours de validation doit être un format de date valide et acceptable par Datel'objet Javascript.

chiffres : valeur

Le champ en cours de validation doit être numérique et doit avoir une longueur de valeur exacte.

différent:attribut

Le champ donné doit être différent du champ en cours de validation.

e-mail

Le champ en cours de validation doit être formaté comme une adresse e-mail.

hexadécimal

Le champ en cours de validation doit être au format hexadécimal. Utile en combinaison avec d'autres règles, comme hex|size:6pour la validation du code couleur hexadécimal.

dans:foo,bar,...

Le champ en cours de validation doit être inclus dans la liste de valeurs donnée. Le champ peut être un tableau ou une chaîne.

entier

Le champ en cours de validation doit avoir une valeur entière.

Valeur max

Vérifier qu'un attribut n'est pas supérieur à une taille donnée

Remarque : Le nombre maximum de chèques est inclus.

min:valeur

Vérifiez qu'un attribut a au moins une taille donnée.

Remarque : les chèques minimum sont inclus.

not_in:foo,bar,...

Le champ en cours de validation ne doit pas être inclus dans la liste de valeurs donnée.

numérique

Valide qu'un attribut est numérique. La représentation sous forme de chaîne d'un nombre sera acceptée.

requis

Vérifie si la longueur de la représentation sous forme de chaîne de la valeur est >

requis_if : un autre champ, valeur

Le champ en cours de validation doit être présent et non vide si le champ anotherfield est égal à n'importe quelle valeur.

requis_sauf : un autre champ, valeur

Le champ en cours de validation doit être présent et non vide sauf si le champ anotherfield est égal à n'importe quelle valeur.

requis_avec:foo,bar,...

Le champ en cours de validation doit être présent et non vide uniquement si l'un des autres champs spécifiés est présent.

requis_avec_all:foo,bar,...

Le champ en cours de validation doit être présent et non vide uniquement si tous les autres champs spécifiés sont présents.

requis_sans:foo,bar,...

Le champ en cours de validation doit être présent et non vide uniquement lorsque l'un des autres champs spécifiés n'est pas présent.

requis_sans_all:foo,bar,...

Le champ en cours de validation doit être présent et non vide uniquement lorsque tous les autres champs spécifiés ne sont pas présents.

idem:attribut

Le champ donné doit correspondre au champ en cours de validation.

taille:valeur

Le champ en cours de validation doit avoir une taille correspondant à la valeur donnée. Pour les données chaîne, la valeur correspond au nombre de caractères. Pour les données numériques, la valeur correspond à une valeur entière donnée.

chaîne

Le champ en cours de validation doit être une chaîne.

URL

Vérifier qu'un attribut a un format d'URL valide

expression régulière:modèle

Le champ en cours de validation doit correspondre à l'expression régulière donnée.

Remarque : Lors de l'utilisation du regexmodèle, il peut être nécessaire de spécifier des règles dans un tableau au lieu d'utiliser des délimiteurs de barres verticales, surtout si l'expression régulière contient un caractère barre verticale. Pour chaque barre oblique inverse que vous avez utilisée dans votre modèle d'expression régulière, vous devez échapper à chacune d'elles. avec une autre barre oblique inverse.

Exemple 3 - Validation Regex

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

Exemple 4 - Validation de la vérification de type

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} - Le nom de la règle.

callbackFn {Fonction} - Renvoie un booléen pour représenter une validation réussie ou échouée.

errorMessage {String} - Une chaîne facultative dans laquelle vous pouvez spécifier un message d'erreur personnalisé. : l'attribut à l'intérieur de errorMessage sera remplacé par le nom de l'attribut.

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

Enregistrez une règle asynchrone qui accepte un passesrappel :

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

Appelez ensuite votre validateur en lui transmettant un rappel failsou passescomme ceci :

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');
});

Remarque : si vous tentez d'appeler passesou failssans rappel et que le validateur détecte qu'il existe des règles de validation asynchrones, une exception sera levée.

Error Messages

Ce constructeur générera automatiquement des messages d'erreur pour les règles de validation qui ont échoué.

S'il y a des erreurs, l'objet de propriété d'erreurs de l'instance de Validator sera rempli avec les messages d'erreur pour tous les attributs défaillants. Les méthodes et propriétés de l' objet de propriété d'erreurs sont :

.premier(attribut)

renvoie le premier message d'erreur pour un attribut, false sinon

.get(attribut)

renvoie un tableau de messages d'erreur pour un attribut, ou un tableau vide s'il n'y a pas d'erreurs

.tous()

renvoie un objet contenant tous les messages d'erreur pour tous les attributs défaillants

.has (attribut)

renvoie vrai si des messages d'erreur existent pour un attribut, faux sinon

.errorCount

le nombre d'erreurs de validation

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

Si vous avez besoin d'un message d'erreur spécifique et que vous ne souhaitez pas remplacer celui par défaut, vous pouvez transmettre un remplacement comme troisième argument à l'objet Validator, tout comme avec 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'

Certains validateurs ont des versions chaîne et numérique. Vous pouvez également les modifier.

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

Vous pouvez même fournir des messages d'erreur par attribut ! Définissez simplement la clé du message sur "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

Pour afficher un nom d'attribut « convivial » personnalisé dans les messages d'erreur, utilisez.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."
}

Vous pouvez également fournir des noms d'attributs personnalisés globaux dans votre langue avec la attributespropriété.

Vous pouvez également configurer un formateur d'attributs personnalisé :

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

Remarque : par défaut, tous les caractères _ seront remplacés par des espaces.

Language Support

Les messages d'erreur sont en anglais par défaut. Pour inclure une autre langue dans le navigateur, référencez le fichier de langue dans une balise de script et appelez 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>

Dans Node, il récupérera automatiquement les fichiers sources de la langue.

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

Si vous ne voyez pas de support pour votre langue, veuillez en ajouter une à src/lang!

Vous pouvez également ajouter votre propre langue personnalisée en appelantsetMessages :

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

Récupère l'objet brut des messages pour la langue donnée :

1
Validator.getMessages('lang_code');

Changez la langue par défaut utilisée par le validateur :

1
Validator.useLang('lang_code');

Obtenez la langue par défaut utilisée :

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

Remplacer les messages par défaut pour la langue :

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