validatorjs

La biblioteca validatorjs facilita molt la validació de dades en JavaScript tant al navegador com a Node.js. Aquesta biblioteca es va inspirar en el validador del framework Laravel .

Per què utilitzar validatorjs?

No depèn de cap biblioteca.
Funciona tant al navegador com al node.
Regles de validació declarables i llegibles.
Missatges d'error amb suport multilingüe.
Suport AMD / Require.js i CommonJS / Browserify.

Instal·lació

Agafeu validadors de Bower, NPM o del directori / dist a 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]);

dades {objecte}: les dades que voleu validar

regles {Objecte}: regles de validació

customErrorMessages {Object}: missatges d'error personalitzats opcionals per tornar

Exemple 1: validació de passar

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 aplicar regles de validació a l' objecte de dades , utilitzeu els mateixos noms de claus d'objecte per a l' objecte de regles .

Exemple 2: validació fallida

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

Els objectes niats també es poden validar. Hi ha dues maneres de declarar les regles de validació dels objectes niats. La primera manera és declarar les regles de validació amb una estructura d’objectes niats corresponent que reflecteixi les dades. La segona manera és declarar les regles de validació amb la clau aplanada noms, per exemple, per validar les dades següents:

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

Podríem declarar les nostres regles de validació de la següent manera:

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

Els comodins també es poden validar.

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

Podríem declarar les nostres regles de validació de la següent manera:

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 regles de validació no tenen cap requisit implícit ". Si un camp no està definit o una cadena buida, passarà la validació. Si voleu que falli una validació per a indefinit o", utilitzeu la regla requerida .

acceptat

El camp sota validació ha de ser sí, activat, 1 o cert. Això és útil per validar l'acceptació de les "Condicions del servei".

després: data

El camp en validació ha de ser posterior a la data indicada.

after_or_equal: data

La validació sense anul·lar el camp ha de ser posterior o igual al camp donat

alfa

El camp sota validació ha de tenir caràcters completament alfabètics.

alpha_dash

El camp en validació pot tenir caràcters alfanumèrics, a més de guions i guions baixos.

alpha_num

El camp en convalidació ha de ser completament de caràcters alfanumèrics.

matriu

El camp sota validació ha de ser una matriu.

abans: data

El camp en validació ha de ser anterior a la data indicada.

before_or_equal: data

El camp en validació ha de ser anterior o igual a la data indicada.

entre: mín., màx

El camp sota validació ha de tenir una mida entre el mínim i el màxim donats. Les cadenes, els números i els fitxers s’avaluen de la mateixa manera que la regla de mida.

booleà

Un baix HA DE SER Validació de camp de la valor booleà La forma de true, false, 0, 1, 'true', 'false', '0', '1',

confirmat

El camp sota validació ha de tenir un camp coincident de foo_confirmation. Per exemple, si el camp sota validació és una contrasenya, ha de tenir un camp coincident de password_confirmation a l'entrada.

data

El camp sota validació ha de ser un format de data vàlid que sigui acceptable per l' Dateobjecte de Javascript .

dígits: valor

El camp sota validació ha de ser numèric i ha de tenir una longitud exacta de valor.

diferent: atribut

El camp donat ha de ser diferent del camp en validació.

correu electrònic

El camp sota validació ha de tenir el format d'una adreça de correu electrònic.

hex

El camp sota validació hauria de ser un format hexadecimal. Útil en combinació amb altres regles, com hex|size:6per a la validació del codi de color hexadecimal.

a: foo, bar, ...

El camp sota validació s'ha d'incloure a la llista de valors donada. El camp pot ser una matriu o una cadena.

enter

El camp sota validació ha de tenir un valor enter.

màxim: valor

Valideu que un atribut no sigui superior a una mida determinada

Nota: els controls màxims són inclosos.

min: valor

Valideu que un atribut tingui almenys una mida determinada.

Nota: Els controls mínims són inclosos.

not_in: foo, barra, ...

El camp sota validació no s'ha d'incloure a la llista de valors indicada.

numèric

Valideu que un atribut és numèric. La representació de cadena d'un número passarà.

obligatori

Comprova si la longitud de la representació de cadena del valor és>

required_if: un altre camp, valor

El camp en convalidació ha d'estar present i no buit si el camp d'un altre camp és igual a qualsevol valor.

required_unless: un altre camp, valor

El camp sota validació ha d'estar present i no buit tret que el camp d'un altre camp sigui igual a qualsevol valor.

requerit_amb: foo, barra, ...

El camp sota validació ha d'estar present i no buit només si hi ha algun dels altres camps especificats.

required_with_all: foo, barra, ...

El camp sota validació ha d'estar present i no buit només si hi ha tots els altres camps especificats.

required_without: foo, barra, ...

El camp en convalidació ha d’estar present i no buit només quan no hi ha cap dels altres camps especificats.

required_without_all: foo, barra, ...

El camp sota validació ha d’estar present i no buit només quan no hi són presents tots els altres camps especificats.

mateix: atribut

El camp donat ha de coincidir amb el camp en fase de validació.

mida: valor

El camp en convalidació ha de tenir una mida que coincideixi amb el valor donat. Per a les dades de cadenes, el valor correspon al nombre de caràcters. Per a les dades numèriques, el valor correspon a un valor enter determinat.

corda

El camp sota validació ha de ser una cadena.

url

Valideu que un atribut tingui un format d'URL vàlid

regex: patró

El camp en validació ha de coincidir amb l’expressió regular donada.

Nota : Quan utilitzeu el regexpatró, pot ser que calgui especificar regles en una matriu en lloc d'utilitzar delimitadors de canonades, especialment si l'expressió regular conté un caràcter de canonada. Per a cada barra inclinada que heu utilitzat al patró de regla regular, n'heu d'escapar. amb una altra barra inclinada cap enrere.

Exemple 3: validació de 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

Exemple de validació de comprovació de 4 tipus

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

1Validator.register(name, callbackFn, errorMessage);

name {String}: el nom de la regla.

callbackFn {Funció}: retorna un booleà per representar una validació correcta o fallida.

errorMessage {String}: una cadena opcional on podeu especificar un missatge d'error personalitzat .: l'atribut dins errorMessage se substituirà pel nom de l'atribut.

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

Registre una regla asíncrona que accepti una passesdevolució de trucada:

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

A continuació, truqueu al vostre validador passant una devolució de trucada failso passesaixí:

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: detecta si intenteu trucar passeso failssense devolució de trucada i el validador té regles de validació asíncrones, es produirà una excepció.

Error Messages

Aquest constructor generarà automàticament missatges d'error per a les regles de validació que han fallat.

Si hi ha errors, la instància del validador tindrà l' objecte de propietat d' errors amb els missatges d'error de tots els atributs que falten. Els mètodes i propietats de l' objecte de propietat d' errors són:

.first (atribut)

retorna el primer missatge d'error d'un atribut, en cas contrari, és fals

.get (atribut)

retorna una matriu de missatges d'error per a un atribut o una matriu buida si no hi ha errors

.all ()

retorna un objecte que conté tots els missatges d'error de tots els atributs fallits

.ha (atribut)

retorna cert si hi ha missatges d'error per a un atribut, en cas contrari és fals

.errorCount

el nombre d'errors de validació

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 necessiteu un missatge d'error específic i no voleu anul·lar el predeterminat, podeu passar una substitució com a tercer argument a l'objecte Validator, igual que amb 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'

Alguns dels validadors tenen versions numèriques i de cadenes. També podeu canviar-les.

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

Fins i tot podeu proporcionar missatges d'error per atribut. Només heu d'establir la clau del missatge a "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 mostrar un nom d'atribut "amigable" personalitzat als missatges d'error, utilitzeu .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."
}

També podeu proporcionar noms d’atributs personalitzats globals al vostre lang amb la attributespropietat.

També podeu configurar un formatador d'atributs personalitzats:

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 defecte, tots els _ caràcters se substituiran per espais.

Language Support

Els missatges d'error estan en anglès de manera predeterminada. Per incloure un altre idioma al navegador, consulteu el fitxer d'idioma en una etiqueta de script i truqueu 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>

A Node, recollirà automàticament els fitxers font de l’idioma.

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

Si no veieu compatibilitat amb el vostre idioma, afegiu-ne un src/lang.

També podeu afegir el vostre propi idioma personalitzat trucant a setMessages:

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

Obteniu l'objecte brut dels missatges per a l'idioma donat:

1
Validator.getMessages('lang_code');

Canvieu l'idioma predeterminat utilitzat pel validador:

1
Validator.useLang('lang_code');

Obteniu l'idioma predeterminat que s'utilitza:

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

Substitueix els missatges predeterminats per a l'idioma:

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

Guia de desenvolupament

Mòdul bàsic

Objectes incorporats

Mòdul de comunitat