validatorjs

La libreria validatorjs rende la convalida 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 dipende da alcuna libreria.
• Funziona sia nel browser che in Node.
• Regole di validazione leggibili e dichiarative.
• Messaggi di errore con supporto multilingue.
• Supporto 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 desideri convalidare

regole {Oggetto} - Regole di convalida

customErrorMessages {Object}: messaggi di errore personalizzati facoltativi da restituire

Esempio 1: superamento della convalida

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

Anche gli oggetti nidificati possono 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 struttura di oggetti nidificati corrispondente che riflette i dati. Il secondo modo è dichiarare le regole di convalida con una 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 validazione 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

È inoltre possibile convalidare i caratteri jolly.

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 validazione 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 "richiesto" implicito. Se un campo non è definito o è una stringa vuota, passerà la convalida. Se desideri che una convalida fallisca per undefinito o '', utilizza la regola obbligatorio .

accettato

Il campo in fase di convalida deve essere sì, attivo, 1 o vero, utile per convalidare l'accettazione dei "Termini di servizio".

dopo:data

Il campo in fase di validazione deve essere successivo alla data indicata.

dopo_o_uguale:data

Il campo in fase di convalida deve essere successivo o uguale al campo specificato

alfa

Il campo in fase di validazione deve essere composto interamente da caratteri alfabetici.

alpha_dash

Il campo in fase di convalida può contenere caratteri alfanumerici, nonché trattini e trattini bassi.

numero_alfa

Il campo in fase di validazione deve essere interamente composto da caratteri alfanumerici.

vettore

Il campo in fase di convalida deve essere un array.

prima:data

Il campo in fase di validazione deve essere antecedente alla data indicata.

prima_o_uguale:data

Il campo in fase di validazione deve essere precedente o uguale alla data indicata.

tra:min,max

Il campo in fase di convalida deve avere una dimensione compresa tra il minimo e il massimo specificati. Stringhe, numeri e file vengono valutati allo stesso modo della regola di dimensione.

booleano

Il campo in fase di convalida deve essere un valore booleano nel formato true, false, 0, 1, 'true', 'false', '0', '1',

confermato

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

data

Il campo in fase di convalida deve essere un formato di data valido accettabile dall'oggetto Javascript Date.

cifre: valore

Il campo in fase di convalida deve essere numerico e deve avere una lunghezza esatta di valore.

diverso: attributo

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

e-mail

Il campo in fase di validazione deve essere formattato come indirizzo email.

esadecimale

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

in:pippo,bar,...

Il campo in fase di convalida deve essere incluso nell'elenco di valori fornito e può essere un array o una stringa.

numero intero

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

massimo:valore

Convalidare che un attributo non sia maggiore di una determinata dimensione

Nota: i controlli massimi sono inclusi.

min:valore

Convalidare che un attributo abbia almeno una determinata dimensione.

Nota: gli assegni minimi sono inclusi.

not_in:foo,bar,...

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

numerico

Verifica che un attributo sia numerico. La rappresentazione di stringa di un numero passerà.

necessario

Controlla se la lunghezza della rappresentazione String del valore è >

obbligatorio_se:unaltrocampo,valore

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

richiesto_a meno che:unaltrocampo,valore

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

richiesto_con:pippo,bar,...

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

obbligatorio_con_tutti:pippo,bar,...

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

richiesto_senza:pippo,bar,...

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

richiesto_senza_tutto:pippo,bar,...

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

stesso: attributo

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

dimensione: valore

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

corda

Il campo in fase di convalida deve essere una stringa.

URL

Verifica che un attributo abbia un formato URL valido

regex:modello

Il campo in fase di convalida deve corrispondere all'espressione regolare specificata.

Nota : quando si utilizza il regexmodello, potrebbe essere necessario specificare le regole in un array anziché utilizzare i delimitatori pipe, soprattutto se l'espressione regolare contiene un carattere pipe. Per ogni barra rovesciata utilizzata nel modello regex, è necessario eseguire l'escape di ciascuno di essi. con un'altra barra rovesciata.

Esempio 3: convalida 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

Esempio 4: convalida del controllo del tipo

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

callbackFn {Funzione} - Restituisce un valore booleano per rappresentare una convalida riuscita o fallita.

errorMessage {String} - Una stringa facoltativa in cui è possibile specificare un messaggio di errore personalizzato. :attribute 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 una passesrichiamata:

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 una richiamata a failso passesin questo 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 passeso failssenza richiamata e il validatore rileva che esistono regole di convalida asincrona, 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 proprio oggetto proprietà errori popolato con i messaggi di errore per tutti gli attributi non riusciti. I metodi e le proprietà sull'oggetto proprietà errori sono:

.first(attributo)

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

.get(attributo)

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

.Tutto()

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

.ha(attributo)

restituisce vero se esistono messaggi di errore per un attributo, falso altrimenti

.errorCount

il numero di errori di validazione

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 numeriche, puoi anche modificarle.

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 "friendly" 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 i nomi degli attributi personalizzati globali nella tua lingua con la attributesproprietà.

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

Per impostazione predefinita, i messaggi di errore sono in inglese. Per includere un'altra lingua nel browser, fare riferimento al file della lingua in un tag di script e chiamare 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 specificata:

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