validatorjs

La libreria validatorjs rende la validazione dei dati in JavaScript molto semplice sia nel browser che in Node.js. Questa libreria è stata ispirata dal Validator del framework Laravel .

Perché usare validatorjs?

• Non dipendente da alcuna libreria.
• Funziona sia nel browser che in Node.
• Regole di convalida leggibili e dichiarative.
• Messaggi di errore con supporto multilingue.
• Supporto per AMD / Require.js e CommonJS / Browserify.

Installazione

Prendi validatorjs da Bower, NPM o dalla directory / dist su 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}: i dati che si desidera convalidare

regole {Oggetto} -Regole di convalida

customErrorMessages {Object} -Messaggi di errore personalizzati opzionali da restituire

Esempio 1: convalida di passaggio

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

Per applicare le regole di convalida all'oggetto dati , utilizzare gli stessi nomi di chiave dell'oggetto per l'oggetto regole .

Esempio 2: convalida non riuscita

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

Gli oggetti nidificati possono anche essere convalidati. Esistono due modi per dichiarare le regole di convalida per gli oggetti nidificati. Il primo modo è dichiarare le regole di convalida con una corrispondente struttura di oggetti nidificati che riflette i dati. Il secondo modo è dichiarare le regole di convalida con la chiave appiattita nomi. Ad esempio, per convalidare i seguenti dati:

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

Potremmo dichiarare le nostre regole di convalida come segue:

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

I caratteri jolly possono anche essere convalidati.

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

Potremmo dichiarare le nostre regole di convalida come segue:

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

Le regole di convalida non hanno un "" obbligatorio implicito. Se un campo non è definito o una stringa vuota, la convalida passerà. Se desideri che una convalida non riesca per undefined o "", utilizza la regola richiesta .

accettato

Il campo sotto convalida deve essere sì, attivato, 1 o true. Ciò è utile per convalidare l'accettazione dei "Termini di servizio".

dopo: data

Il campo da convalidare deve essere successivo alla data specificata.

after_or_equal: data

Il campo sotto la convalida deve essere successivo o uguale al campo specificato

alfa

Il campo da convalidare deve contenere caratteri interamente alfabetici.

alpha_dash

Il campo da convalidare può contenere caratteri alfanumerici, trattini e trattini bassi.

alpha_num

Il campo in fase di convalida deve contenere interamente caratteri alfanumerici.

Vettore

Il campo da convalidare deve essere un array.

prima: data

Il campo da convalidare deve essere precedente alla data specificata.

before_or_equal: data

Il campo in convalida deve essere precedente o uguale alla data specificata.

tra: min, max

Il campo in fase di convalida deve avere una dimensione compresa tra il minimo e il massimo specificato. Stringhe, valori numerici e file vengono valutati allo stesso modo della regola delle dimensioni.

booleano

Il campo da convalidare deve essere un valore booleano nella forma true , false , 0 , 1 , 'true' , 'false' , '0' , '1' ,

confermato

Il campo sotto convalida deve avere un campo corrispondente di foo_confirmation Ad esempio, se il campo sotto convalida è password, nell'input deve essere presente un campo corrispondente password_confirmation.

Data

Il campo da convalidare deve essere un formato di data valido accettabile dall'oggetto Date di Javascript.

cifre: valore

Il campo da convalidare deve essere numerico e deve avere una lunghezza esatta del valore.

diverso: attributo

Il campo specificato deve essere diverso dal campo in fase di convalida.

e-mail

Il campo da convalidare deve essere formattato come indirizzo e-mail.

esadecimale

Il campo da convalidare deve essere in formato esadecimale. Utile in combinazione con altre regole, come hex|size:6 per la convalida del codice colore esadecimale.

in: foo, bar, ...

Il campo da convalidare deve essere incluso nell'elenco di valori fornito. Il campo può essere un array o una stringa.

numero intero

Il campo in fase di convalida deve avere un valore intero.

max: valore

Convalida che un attributo non sia maggiore di una determinata dimensione

Nota: i controlli massimi sono inclusi.

min: valore

Convalida che un attributo sia almeno di una determinata dimensione.

Nota: i controlli minimi sono inclusi.

not_in: foo, bar, ...

Il campo in fase di convalida non deve essere incluso nell'elenco di valori fornito.

numerico

Convalida che un attributo sia numerico. La rappresentazione sotto forma di stringa di un numero passerà.

necessario

Controlla se la lunghezza della rappresentazione String del valore è>

richiesto_if: un altro campo, valore

Il campo in convalida deve essere presente e non vuoto se il campo anotherfield è uguale a qualsiasi valore.

richiesto_unless: un altro campo, valore

Il campo in convalida deve essere presente e non vuoto a meno che il campo di un altro campo non sia uguale a un valore qualsiasi.

richiesto_con: foo, bar, ...

Il campo in convalida deve essere presente e non vuoto solo se è presente uno degli altri campi specificati.

required_with_all: foo, bar, ...

Il campo in convalida deve essere presente e non vuoto solo se sono presenti tutti gli altri campi specificati.

required_without: foo, bar, ...

Il campo in convalida deve essere presente e non vuoto solo quando uno qualsiasi degli altri campi specificati non è presente.

required_without_all: foo, bar, ...

Il campo in convalida deve essere presente e non vuoto solo quando tutti gli altri campi specificati non sono presenti.

stesso: attributo

Il campo specificato deve corrispondere al campo in fase di convalida.

dimensione: valore

Il campo da convalidare deve avere una dimensione corrispondente al valore specificato. Per i dati di stringa, il valore corrisponde al numero di caratteri. Per i dati numerici, il valore corrisponde a un determinato valore intero.

corda

Il campo da convalidare deve essere una stringa.

url

Verifica che un attributo abbia un formato URL valido

regex: pattern

Il campo da convalidare deve corrispondere all'espressione regolare data.

Nota : quando si utilizza il pattern regex , potrebbe essere necessario specificare regole in un array invece di utilizzare i delimitatori pipe, soprattutto se l'espressione regolare contiene un carattere pipe. Per ogni barra rovesciata utilizzata nel pattern regex, è necessario eseguire l'escape di ciascuna uno con un altro taglio all'indietro.

Esempio di convalida 3-Regex

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

Esempio 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} -Il nome della regola.

callbackFn {Function}: restituisce un valore booleano per rappresentare una convalida riuscita o non riuscita.

errorMessage {String} -Una stringa opzionale in cui è possibile specificare un messaggio di errore personalizzato .: l'attributo all'interno di errorMessage verrà sostituito con il nome dell'attributo.

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

Registra una regola asincrona che accetta un callback di passes :

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

Quindi chiama il tuo validatore passando un callback a fails o passes modo:

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

Nota: se si tenta di chiamare i passes o fails senza un callback e il validatore rileva che ci sono regole di convalida asincrone, verrà generata un'eccezione.

Error Messages

Questo costruttore genererà automaticamente messaggi di errore per le regole di convalida non riuscite.

Se sono presenti errori, l'istanza di Validator avrà il suo oggetto proprietà errors popolato con i messaggi di errore per tutti gli attributi con errori. I metodi e le proprietà sull'oggetto proprietà errors sono:

.first (attributo)

restituisce il primo messaggio di errore per un attributo, altrimenti false

.get (attributo)

restituisce un array di messaggi di errore per un attributo o un array vuoto se non ci sono errori

.tutti()

restituisce un oggetto contenente tutti i messaggi di errore per tutti gli attributi in errore

.has (attributo)

restituisce true se esistono messaggi di errore per un attributo, false in caso contrario

.errorCount

il numero di errori di convalida

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

Se hai bisogno di un messaggio di errore specifico e non vuoi sovrascrivere quello predefinito, puoi passare un override come terzo argomento all'oggetto Validator, proprio come con 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'

Alcuni validatori hanno versioni stringa e numerica, puoi anche cambiarle.

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

Puoi anche fornire messaggi di errore in base agli attributi. Basta impostare la chiave del messaggio su "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

Per visualizzare un nome di attributo " .setAttributeNames() " personalizzato nei messaggi di errore, utilizzare .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."
}

In alternativa, puoi fornire nomi di attributi personalizzati globali nella tua lingua con la proprietà attributes .

Puoi anche configurare un formattatore di attributi personalizzato:

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

Nota: per impostazione predefinita, tutti i caratteri _ verranno sostituiti con spazi.

Language Support

I messaggi di errore sono in inglese per impostazione predefinita. Per includere un'altra lingua nel browser, Validator.useLang('lang_code') riferimento al file della lingua in un tag di script e chiama 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, riprenderà automaticamente i file di origine della lingua.

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

Se non vedi il supporto per la tua lingua, aggiungine uno a src/lang !

Puoi anche aggiungere la tua lingua personalizzata chiamando setMessages :

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

Ottieni l'oggetto grezzo dei messaggi per la lingua data:

1
Validator.getMessages('lang_code');

Cambia la lingua predefinita utilizzata dal validatore:

1
Validator.useLang('lang_code');

Ottieni la lingua predefinita utilizzata:

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

Sostituisci i messaggi predefiniti per la lingua:

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