validatorejs

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 nessuna 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 {Oggetto}-I dati che vuoi convalidare

regole {Oggetto}-Regole di convalida

customErrorMessages {Oggetto} -Messaggi di errore personalizzati facoltativi da restituire

Esempio di convalida 1-Passing

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 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 consiste nel dichiarare le regole di convalida con una struttura di oggetto nidificato corrispondente 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 "richiesto" implicito. Se un campo è indefinito o una stringa vuota, passerà la convalida. Se vuoi che una convalida non riesca per undefined o "", usa la regola richiesta .

accettato

Il campo in fase di convalida deve essere yes, on, 1 o true, utile per convalidare l'accettazione dei "Termini di servizio".

dopo: data

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

after_or_equal:data

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

alfa

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

alfa_dash

Il campo in fase di convalida può contenere caratteri alfanumerici, trattini e caratteri di sottolineatura.

numero_alfa

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

Vettore

Il campo in fase di convalida deve essere un array.

prima: data

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

prima_o_uguale:data

Il campo in fase di convalida 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 indicati. Le stringhe, i numeri ei file vengono valutati allo stesso modo della regola di dimensione.

booleano

Un sotto DEVE ESSERE Campo Convalida del valore booleano A La forma di true, false, 0, 1, 'true', 'false', '0', '1',

confermato

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

Data

Il campo in fase di convalida deve essere un formato di data valido che sia accettabile Datedall'oggetto di Javascript .

cifre:valore

Il campo in fase di convalida 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 in fase di convalida deve essere formattato come indirizzo e-mail.

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 specificato. Il campo può essere un array o una stringa.

numero intero

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

massimo:valore

Convalida che un attributo non è maggiore di una data 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:pippo,bar,...

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

numerico

Convalida che un attributo è numerico. La rappresentazione di stringa di un numero passerà.

necessario

Controlla se la lunghezza della rappresentazione String del valore è>

richiesto_se:altro campo,valore

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

required_unless:un altro campo,valore

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

richiesto_con:pippo,bar,...

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

richiesto_con_tutto:pippo,bar,...

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

richiesto_senza:pippo,bar,...

Il campo in fase di convalida deve essere presente e non vuoto solo quando non è presente alcuno degli altri campi specificati.

richiesto_senza_tutto: foo,bar,...

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

stesso:attributo

Il campo specificato 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 determinato valore intero.

corda

Il campo in fase di convalida deve essere una stringa.

URL

Convalida che un attributo abbia un formato URL valido

regex: modello

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

Nota : quando si utilizza il regexmodello, potrebbe essere necessario specificare le regole in un array invece di utilizzare i delimitatori di barra verticale, specialmente se l'espressione regolare contiene un carattere barra verticale.Per ogni barra rovesciata utilizzata nel modello regex, è necessario eseguire l'escape di ciascuno con un altro slash all'indietro.

Esempio 3-Regex convalida

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 di convalida del controllo di 4 tipi

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 {Funzione}-Restituisce un booleano per rappresentare una convalida riuscita o non riuscita.

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

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: rileva se si tenta di chiamare passeso failssenza un callback e il validatore ci sono regole di validazione 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 non riusciti.I metodi e le proprietà sull'oggetto proprietà errors sono:

.first(attributo)

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

.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

.ha (attributo)

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

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

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 all'attributo!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 nomi di 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

I messaggi di errore sono in inglese per impostazione predefinita. Per includere un'altra lingua nel browser, fai 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, rileverà 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);