validadorjs

La biblioteca validatorjs facilita la validación de datos en JavaScript tanto en el navegador como en Node.js. Esta biblioteca se inspiró en el Validator del framework Laravel .

¿Por qué utilizar validatorjs?

• No depende de ninguna biblioteca.
• Funciona tanto en el navegador como en Node.
• Reglas de validación legibles y declarativas.
• Mensajes de error con soporte multilingüe.
• Compatibilidad con AMD/Require.js y CommonJS/Browserify.

Instalación

Tome validatorjs de Bower, NPM o el 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]);

data {Object} - Los datos que desea validar

reglas {Objeto} - Reglas de validación

customErrorMessages {Objeto}: mensajes de error personalizados opcionales para devolver

Ejemplo 1: aprobar la 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 reglas de validación al objeto de datos , utilice los mismos nombres de clave de objeto para el objeto de reglas .

Ejemplo 2: validación 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

Los objetos anidados también se pueden validar. Hay dos formas de declarar reglas de validación para objetos anidados. La primera forma es declarar las reglas de validación con una estructura de objeto anidado correspondiente que refleje los datos. La segunda forma es declarar reglas de validación con clave aplanada. nombres, por ejemplo para validar los siguientes 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'
    }
  }
};

Podríamos declarar nuestras reglas de validación de la siguiente 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

Los comodines también se pueden 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íamos declarar nuestras reglas de validación de la siguiente 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

Las reglas de validación no tienen un 'requerido' implícito. Si un campo no está definido o es una cadena vacía, pasará la validación. Si desea que una validación falle por indefinido o '', use la regla requerida .

aceptado

El campo bajo validación debe ser sí, encendido, 1 o verdadero, esto es útil para validar la aceptación de los "Términos de Servicio".

después: fecha

El campo bajo validación debe ser posterior a la fecha indicada.

después_o_igual: fecha

El campo bajo validación debe ser posterior o igual al campo dado

alfa

El campo bajo validación debe contener caracteres enteramente alfabéticos.

alfa_dash

El campo bajo validación puede tener caracteres alfanuméricos, así como guiones y guiones bajos.

número_alfa

El campo bajo validación debe contener caracteres completamente alfanuméricos.

formación

El campo bajo validación debe ser una matriz.

antes: fecha

El campo bajo validación debe ser anterior a la fecha indicada.

antes_o_igual: fecha

El campo bajo validación debe ser anterior o igual a la fecha indicada.

entre: mínimo, máximo

El campo bajo validación debe tener un tamaño entre el mínimo y el máximo dados. Las cadenas, los números y los archivos se evalúan de la misma manera que la regla de tamaño.

booleano

El campo bajo validación debe ser un valor booleano de la forma true, false, 0, 1, 'true', 'false', '0', '1',

confirmado

El campo bajo validación debe tener un campo coincidente de foo_confirmation. Por ejemplo, si el campo bajo validación es contraseña, un campo coincidente de contraseña_confirmación debe estar presente en la entrada.

fecha

El campo bajo validación debe tener un formato de fecha válido que sea aceptable para Dateel objeto de Javascript.

dígitos: valor

El campo bajo validación debe ser numérico y debe tener una longitud exacta de valor.

diferente: atributo

El campo proporcionado debe ser diferente al campo bajo validación.

correo electrónico

El campo bajo validación debe tener el formato de una dirección de correo electrónico.

maleficio

El campo bajo validación debe tener un formato hexadecimal. Es útil en combinación con otras reglas, como hex|size:6la validación de códigos de colores hexadecimales.

en:foo,bar,...

El campo bajo validación debe estar incluido en la lista de valores dada. El campo puede ser una matriz o una cadena.

entero

El campo bajo validación debe tener un valor entero.

valor máximo

Validar que un atributo no sea mayor que un tamaño determinado

Nota: Los cheques máximos son inclusivos.

mín: valor

Validar que un atributo tenga al menos un tamaño determinado.

Nota: Los cheques mínimos son inclusivos.

not_in:foo,bar,...

El campo bajo validación no debe estar incluido en la lista de valores proporcionada.

numérico

Validar que un atributo sea numérico. Se pasará la representación en cadena de un número.

requerido

Comprueba si la longitud de la representación String del valor es >

require_if:otro campo,valor

El campo bajo validación debe estar presente y no vacío si el campo de otro campo es igual a cualquier valor.

requerido_a menos que: otro campo, valor

El campo bajo validación debe estar presente y no vacío a menos que el campo otro campo sea igual a cualquier valor.

requerido_con:foo,barra,...

El campo bajo validación debe estar presente y no vacío solo si alguno de los otros campos especificados está presente.

requerido_con_todo:foo,bar,...

El campo bajo validación debe estar presente y no vacío solo si todos los demás campos especificados están presentes.

requerido_sin:foo,bar,...

El campo bajo validación debe estar presente y no vacío solo cuando alguno de los otros campos especificados no esté presente.

requerido_sin_todo:foo,bar,...

El campo bajo validación debe estar presente y no vacío solo cuando todos los demás campos especificados no estén presentes.

mismo: atributo

El campo proporcionado debe coincidir con el campo bajo validación.

tamaño: valor

El campo bajo validación debe tener un tamaño que coincida con el valor dado. Para datos de cadena, el valor corresponde al número de caracteres. Para datos numéricos, el valor corresponde a un valor entero dado.

cadena

El campo bajo validación debe ser una cadena.

URL

Validar que un atributo tenga un formato de URL válido

expresión regular: patrón

El campo bajo validación debe coincidir con la expresión regular dada.

Nota : Al usar el regexpatrón, puede ser necesario especificar reglas en una matriz en lugar de usar delimitadores de barra vertical, especialmente si la expresión regular contiene un carácter de barra vertical. Para cada barra invertida que usó en su patrón de expresión regular, debe escapar de cada una. con otra barra hacia atrás.

Ejemplo 3: validación de expresiones regulares

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

Ejemplo 4: Validación de verificación de tipo

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

name {String}: el nombre de la regla.

callbackFn {Función}: devuelve un valor booleano para representar una validación exitosa o fallida.

errorMessage {String}: una cadena opcional donde puede especificar un mensaje de error personalizado. :el atributo dentro de errorMessage se reemplazará con el nombre del 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

Registre una regla asincrónica que acepte una passesdevolución de llamada:

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

Luego llame a su validador pasándole una devolución de llamada failso 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: si intenta llamar passeso failssin una devolución de llamada y el validador detecta que hay reglas de validación asincrónicas, se generará una excepción.

Error Messages

Este constructor generará automáticamente mensajes de error para las reglas de validación que fallaron.

Si hay errores, la instancia del Validador tendrá su objeto de propiedad de errores lleno con los mensajes de error para todos los atributos fallidos. Los métodos y propiedades del objeto de propiedad de errores son:

.primero(atributo)

devuelve el primer mensaje de error para un atributo, falso en caso contrario

.obtener(atributo)

devuelve una matriz de mensajes de error para un atributo, o una matriz vacía si no hay errores

.todo()

devuelve un objeto que contiene todos los mensajes de error para todos los atributos defectuosos

.tiene(atributo)

Devuelve verdadero si existen mensajes de error para un atributo; falso en caso contrario.

.errorCount

el número de errores 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

Si necesita un mensaje de error específico y no desea anular el predeterminado, puede pasar una anulación como tercer argumento al objeto Validator, al 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'

Algunos de los validadores tienen versiones numéricas y de cadena. También puedes cambiarlas.

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 puede proporcionar mensajes de error por atributo! Simplemente establezca la clave del mensaje 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 nombre de atributo personalizado "descriptivo" en mensajes de error, utilice.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, puede proporcionar nombres de atributos personalizados globales en su idioma con la attributespropiedad.

También puede 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: de forma predeterminada, todos los caracteres _ se reemplazarán con espacios.

Language Support

Los mensajes de error están en inglés de forma predeterminada. Para incluir otro idioma en el navegador, haga referencia al archivo de idioma en una etiqueta de secuencia de comandos y llame 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, se seleccionará automáticamente los archivos fuente del idioma.

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

Si no ve soporte para su idioma, ¡agregue uno a src/lang!

También puede agregar su propio idioma personalizado llamando a setMessages:

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

Obtenga el objeto sin formato de los mensajes para el idioma dado:

1
Validator.getMessages('lang_code');

Cambie el idioma predeterminado utilizado por el validador:

1
Validator.useLang('lang_code');

Obtenga el idioma predeterminado que se utiliza:

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

Anular los mensajes predeterminados para el idioma:

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