validadorsjs

La biblioteca validatorjs fa que la validació de dades en JavaScript sigui molt fàcil 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.
Normes de validació llegibles i declaratives.
Missatges d'error amb suport multilingüe.
Compatibilitat amb AMD/Require.js i CommonJS/Browserify.

Instal·lació

Agafeu validatorjs de Bower, NPM o el directori /dist de 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 retornar

Exemple 1 - Aprovació de la validació

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 clau d'objecte per a l' objecte de regles .

Exemple 2: no validació

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 imbricats també es poden validar. Hi ha dues maneres de declarar regles de validació per als objectes imbricats. La primera és declarar les regles de validació amb una estructura d'objectes imbricats 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 un "obligatori" implícit. Si un camp no està definit o una cadena buida, passarà la validació. Si voleu que la validació falli per a no definit o "", feu servir la regla necessària .

acceptat

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

després de:data

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

posterior_o_igual:data

El camp en fase de validació ha de ser posterior o igual al camp donat

alfa

El camp en validació ha de ser completament alfabètics.

alpha_dash

El camp en validació pot tenir caràcters alfanumèrics, així com guions i guions baixos.

alfa_num

El camp en validació ha de ser completament alfanumèrics.

matriu

El camp en validació ha de ser una matriu.

abans:data

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

abans_o_igual:data

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

entre: mín, màx

El camp en validació ha de tenir una mida entre el mínim i el màxim donats. Les cadenes, els numèrics i els fitxers s'avaluen de la mateixa manera que la regla de mida.

booleà

El camp en validació ha de ser un valor booleà de la forma true, false, 0, 1, 'true', 'false', '0', '1',

confirmat

El camp que s'està validant ha de tenir un camp coincident de foo_confirmation. Per exemple, si el camp que s'està validant és contrasenya, cal que hi hagi un camp coincident password_confirmation a l'entrada.

data

El camp en validació ha de tenir un format de data vàlid que sigui acceptable per Datel'objecte de Javascript.

dígits: valor

El camp en 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 en validació s'ha de formatar com a adreça de correu electrònic.

hex

El camp que s'està validant ha de tenir un format hexadecimal. És útil en combinació amb altres regles, com hex|size:6ara la validació del codi de color hexadecimal.

a:foo,bar,...

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

enter

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

màxim:valor

Valideu que un atribut no sigui superior a una mida determinada

Nota: el màxim de xecs són inclosos.

min:valor

Valideu que un atribut tingui almenys una mida determinada.

Nota: els xecs mínims són inclosos.

not_in:foo,bar,...

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

numèric

Valideu que un atribut sigui numèric. Passarà la representació de cadena d'un nombre.

requerit

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

required_if:un altre camp, valor

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

required_unless:un altre camp, valor

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

required_with:foo,bar,...

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

required_with_all:foo,bar,...

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

required_without:foo,bar,...

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

required_without_all:foo,bar,...

El camp en validació ha d'estar present i no buit només quan tots els altres camps especificats no estan presents.

mateix:atribut

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

mida: valor

El camp en validació ha de tenir una mida que coincideixi amb el valor donat. Per a les dades de cadena, 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 en 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 s'utilitza el regexpatró, pot ser que sigui necessari especificar regles en una matriu en lloc d'utilitzar delimitadors de barra, especialment si l'expressió regular conté un caràcter de barra. Per a cada barra inclinada cap enrere que utilitzeu al vostre patró d'expressió regular, heu d'escapar cadascuna. amb una altra barra enrere.

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

Exemple 4: validació de comprovació de tipus

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

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. :attribute inside 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

Registreu 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: si intenteu trucar passeso failssense una devolució de trucada i el validador detecta que hi ha regles de validació asíncrones, es llançarà 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à el seu objecte de propietat errors emplenat amb els missatges d'error per a tots els atributs fallits. Els mètodes i propietats de l' objecte de propietat errors són:

.first(atribut)

retorna el primer missatge d'error per a un atribut, fals en cas contrari

.get(atribut)

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

.tot()

retorna un objecte que conté tots els missatges d'error per a tots els atributs que fallen

.té (atribut)

retorna true si hi ha missatges d'error per a un atribut, false en cas contrari

.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 de cadena i numèriques. També les podeu canviar.

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 de definir 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 "amic" personalitzat als missatges d'error, feu servir.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."
}

Alternativament, podeu proporcionar noms d'atributs personalitzats globals al vostre idioma amb la attributespropietat.

També podeu configurar un formatador d'atributs personalitzat:

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 es substituiran per espais.

Language Support

Els missatges d'error estan en anglès de manera predeterminada. Per incloure un altre idioma al navegador, feu referència al fitxer d'idioma en una etiqueta d'script i truqueu a 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 suport per al vostre idioma, afegiu-ne un a 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 en brut dels missatges per a l'idioma donat:

1
Validator.getMessages('lang_code');

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

Anul·la 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 comunitari