validatorjs

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

Perché usare validatorjs?

• Non dipende da nessuna biblioteca.
• Funziona sia nel browser che nel nodo.
• Regole di convalida 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 {Oggetto} -I dati che si desidera convalidare

regole {Oggetto} -Regole di convalida

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

Esempio di convalida a 1 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 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

Gli oggetti nidificati possono anche essere convalidati. Esistono due modi per dichiarare le regole di convalida per gli oggetti nidificati. Il primo è dichiarare le regole di convalida con una struttura di oggetti nidificati corrispondente che rifletta i dati. Il secondo modo è dichiarare le regole di convalida con 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

WildCard può anche essere convalidato.

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 implicito ". Se un campo non è definito o una stringa vuota, passerà la convalida. Se si desidera che una convalida fallisca per non definita o" ", utilizzare la regola richiesta .

accettato

Il campo in corso di convalida deve essere Sì, Sì, 1 o Vero. È utile per convalidare l'accettazione dei "Termini di servizio".

dopo: Data

Il campo in fase di convalida deve essere dopo la data indicata.

after_or_equal: Data

La convalida del campo non deve essere successiva o uguale al campo dato

alfa

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

alpha_dash

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

alpha_num

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 precedente alla data indicata.

before_or_equal: 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. Stringhe, valori numerici e file vengono valutati allo stesso modo della regola di dimensione.

booleano

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

confermato

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

Data

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

le cifre: il valore

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

differente: attributo

Il campo dato 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:6 per la convalida del codice colore esadecimale.

in: foo, bar, ...

Il campo in fase di convalida deve essere incluso nell'elenco di valori indicato, che 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 è maggiore di una determinata dimensione

Nota: i controlli massimi sono inclusi.

min: Valore

Convalida che un attributo abbia almeno 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 indicato.

numerico

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

necessario

Verifica se la lunghezza della rappresentazione String del valore è>

required_if: anotherfield, il valore

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

required_unless: anotherfield, il valore

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

required_with: foo, bar, ...

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

required_with_all: foo, bar, ...

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

required_without: foo, bar, ...

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

required_without_all: foo, bar, ...

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

stesso: attributo

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

dimensioni: il valore

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

corda

Il campo in fase di convalida deve essere una stringa.

url

Convalida che un attributo ha un formato URL valido

regex: modello

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

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

Convalida 3-Regex di esempio

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

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 valore booleano per rappresentare una convalida corretta o non riuscita.

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

Registrare 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 per 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 una richiamata 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.

In caso di errori, l'istanza di Validator avrà il suo oggetto della proprietà degli errori popolato con i messaggi di errore per tutti gli attributi in errore I metodi e le proprietà sull'oggetto della proprietà degli errori sono:

.first (attributo)

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

.get (attributo)

restituisce una matrice di messaggi di errore per un attributo o una matrice vuota se non ci sono errori

.tutti()

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

.has (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 è necessario un messaggio di errore specifico e non si desidera sovrascrivere quello predefinito, è possibile 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 e 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 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 " .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 nel tuo lang con la proprietà degli 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, 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 Nodo, raccoglierà 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, per favore 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);