validadoresjs

A biblioteca validatorjs facilita a validación de datos en JavaScript tanto no navegador como en Node.js. Esta biblioteca inspirouse no Validator do framework Laravel .

Por que usar validatorjs?

• Non depende de ningunha biblioteca.
• Funciona tanto no navegador como no Node.
• Normas de validación lexibles e declarativas.
• Mensaxes de erro con soporte multilingüe.
• Compatibilidade con AMD/Require.js e CommonJS/Browserify.

Instalación

Colle os validadores de Bower, NPM ou o directorio /dist en 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]);

datos {Obxecto} - Os datos que quere validar

regras {Obxecto} - Regras de validación

customErrorMessages {Object} - Mensaxes de erro personalizadas opcionais para devolver

Exemplo 1 - Aprobación da validación

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

Para aplicar regras de validación ao obxecto de datos , use os mesmos nomes de chave de obxecto para o obxecto de regras .

Exemplo 2: fallo na validación

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

Os obxectos aniñados tamén se poden validar. Hai dúas formas de declarar regras de validación para obxectos aniñados. A primeira é declarar as regras de validación cunha estrutura de obxectos aniñados correspondente que reflicta os datos. A segunda forma é declarar as regras de validación cunha chave aplanada. nomes. Por exemplo, para validar os seguintes datos:

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

Poderíamos declarar as nosas regras de validación do seguinte xeito:

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

Tamén se poden validar os comodíns.

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

Poderíamos declarar as nosas regras de validación do seguinte xeito:

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

As regras de validación non teñen un "obrigatorio" implícito. Se un campo non está definido ou unha cadea baleira, pasará a validación. Se queres que falle unha validación para non definido ou "", utiliza a regra obrigatoria .

aceptada

O campo en validación debe ser si, activado, 1 ou verdadeiro. Isto é útil para validar a aceptación das "Condicións de servizo".

despois de: data

O campo en validación debe ser posterior á data indicada.

despois_ou_igual:data

O campo en fase de validación debe ser posterior ou igual ao campo indicado

alfa

O campo en validación debe ser completamente alfabético.

trazo_alfa

O campo en validación pode ter caracteres alfanuméricos, así como guións e guións baixos.

alfa_num

O campo en validación debe conter caracteres completamente alfanuméricos.

matriz

O campo en validación debe ser unha matriz.

antes: data

O campo en validación debe ser anterior á data indicada.

antes_ou_igual:data

O campo en validación debe ser anterior ou igual á data indicada.

entre: mín, máx

O campo en validación debe ter un tamaño entre o mínimo e o máximo indicados. As cadeas, os números e os ficheiros avalíanse do mesmo xeito que a regra de tamaño.

booleano

O campo en validación debe ser un valor booleano do formulario true, false, 0, 1, 'true', 'false', '0', '1',

confirmado

O campo en validación debe ter un campo coincidente foo_confirmation. Por exemplo, se o campo en validación é contrasinal, debe estar presente un campo coincidente password_confirmation na entrada.

data

O campo en validación debe ser un formato de data válido que sexa aceptable polo Dateobxecto de Javascript.

díxitos: valor

O campo en validación debe ser numérico e debe ter unha lonxitude exacta de valor.

diferente:atributo

O campo indicado debe ser diferente do campo en validación.

correo electrónico

O campo en validación debe ter formato como enderezo de correo electrónico.

hex

O campo en validación debe ter un formato hexadecimal. Útil en combinación con outras regras, como hex|size:6para a validación do código de cores hexadecimal.

en:foo,bar,...

O campo en validación debe incluírse na lista de valores indicada. O campo pode ser unha matriz ou unha cadea.

enteiro

O campo en validación debe ter un valor enteiro.

máx: valor

Valida que un atributo non sexa maior que un tamaño determinado

Nota: os cheques máximos son incluídos.

min:valor

Valida que un atributo teña polo menos un tamaño determinado.

Nota: os cheques mínimos son incluídos.

not_in:foo,bar,...

O campo en validación non debe incluírse na lista de valores dada.

numérico

Valida que un atributo sexa numérico. Pasará a representación en cadea dun número.

necesario

Comproba se a lonxitude da representación String do valor é >

requirido_se:outro campo,valor

O campo en validación debe estar presente e non estar baleiro se o outro campo é igual a calquera valor.

required_unless:outro campo,valor

O campo en validación debe estar presente e non estar baleiro a menos que o outro campo sexa igual a algún valor.

required_with:foo,bar,...

O campo en validación debe estar presente e non estar baleiro só se hai algún dos outros campos especificados.

required_with_all:foo,bar,...

O campo en validación debe estar presente e non estar baleiro só se están presentes todos os demais campos especificados.

requirido_sen:foo,bar,...

O campo en validación debe estar presente e non estar baleiro só cando non estea presente ningún dos outros campos especificados.

required_without_all:foo,bar,...

O campo en validación debe estar presente e non estar baleiro só cando non estean todos os demais campos especificados.

mesmo:atributo

O campo indicado debe coincidir co campo en validación.

tamaño: valor

O campo en validación debe ter un tamaño que coincida co valor indicado. Para os datos de cadea, o valor corresponde ao número de caracteres. Para os datos numéricos, o valor corresponde a un valor enteiro determinado.

corda

O campo en validación debe ser unha cadea.

url

Validar que un atributo teña un formato de URL válido

regex: patrón

O campo en validación debe coincidir coa expresión regular indicada.

Nota : ao usar o regexpatrón, pode ser necesario especificar regras nunha matriz en lugar de usar delimitadores de barra, especialmente se a expresión regular contén un carácter de barra. Para cada barra invertida que utilizaches no teu patrón de expresión regular, debes escapar de cada unha. con outra barra cara atrás.

Exemplo 3 - Validación 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

Exemplo 4 - Validación de verificación de tipos

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

nome {Cadea} - O nome da regra.

callbackFn {Función} - Devolve un booleano para representar unha validación exitosa ou fallida.

errorMessage {String} - Unha cadea opcional onde podes especificar unha mensaxe de erro personalizada. :attribute inside errorMessage substituirase polo nome do atributo.

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

Rexistra unha regra asíncrona que acepte unha passesdevolución de chamada:

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ón, chame ao seu validador pasando unha devolución de chamada failsou passesasí:

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 tentas chamar passesou failssen unha devolución de chamada e o validador detecta que hai regras de validación asíncronas, lanzarase unha excepción.

Error Messages

Este construtor xerará automaticamente mensaxes de erro para as regras de validación que fallaron.

Se hai erros, a instancia de Validator terá o seu obxecto de propiedade de erros enchedo coas mensaxes de erro para todos os atributos que fallan. Os métodos e propiedades do obxecto de propiedade de erros son:

.primeiro (atributo)

devolve a primeira mensaxe de erro para un atributo, false en caso contrario

.get(atributo)

devolve unha matriz de mensaxes de erro para un atributo ou unha matriz baleira se non hai erros

.todos()

devolve un obxecto que contén todas as mensaxes de erro para todos os atributos que fallan

.ten (atributo)

devolve verdadeiro se existen mensaxes de erro para un atributo, false en caso contrario

.errorCount

o número de erros de validación

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 precisa unha mensaxe de erro específica e non quere anular a predeterminada, pode pasar unha anulación como terceiro argumento ao obxecto Validator, igual que 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'

Algúns dos validadores teñen versións de cadea e numéricas. Tamén podes cambialas.

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

Incluso podes proporcionar mensaxes de erro por atributo. Só tes que configurar a clave da mensaxe en "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

Para mostrar un nome de atributo "amigable" personalizado nas mensaxes de erro, use.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."
}

Alternativamente, pode proporcionar nomes de atributos personalizados globais na súa lingua coa attributespropiedade.

Tamén pode configurar un formateador de atributos personalizado:

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: por defecto todos os _ caracteres substituiranse por espazos.

Language Support

As mensaxes de erro están en inglés de forma predeterminada. Para incluír outro idioma no navegador, fai referencia ao ficheiro de idioma nunha etiqueta de guión e chama 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>

En Node, recollerá automaticamente os ficheiros fonte do idioma.

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

Se non ves soporte para o teu idioma, engade un a src/lang!

Tamén podes engadir o teu propio idioma personalizado chamando a setMessages:

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

Obter o obxecto bruto das mensaxes para o idioma dado:

1
Validator.getMessages('lang_code');

Cambia o idioma predeterminado empregado polo validador:

1
Validator.useLang('lang_code');

Obter o idioma predeterminado que se utiliza:

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

Anular as mensaxes predeterminadas para o idioma:

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