Impresionante módulo de comunidad

validatorjs

Estado de compilación

La biblioteca validatorjs hace que la validación de datos en JavaScript sea muy fácil tanto en el navegador como en Node.js. Esta biblioteca se inspiró en el Validator del marco Laravel .

¿Por qué usar validatorjs?

  • No depende de ninguna biblioteca.
  • Funciona tanto en el navegador como en el nodo.
  • Reglas de validación legibles y declarativas.
  • Mensajes de error con soporte multilingüe.
  • Soporte 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 {Object} - Mensajes de error personalizados opcionales para devolver

Ejemplo 1: validación de aprobació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 , use los mismos nombres de clave de objeto para el objeto de reglas .

Ejemplo 2: validación errónea

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 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 yes, on, 1 o true. 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.

after_or_equal: fecha

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

alfa

El campo bajo validación debe ser completamente caracteres alfabéticos.

alpha_dash

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

alpha_num

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

matriz

El campo bajo validación debe ser una matriz.

antes: fecha

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

before_or_equal: fecha

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

entre: min, max

El campo bajo validación debe tener un tamaño entre el mínimo y el máximo. 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 de contraseña_confirmación debe estar presente en la entrada.

fecha

El campo bajo validación debe ser un formato de fecha válido que sea aceptable por el objeto Date 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 dado debe ser diferente al campo bajo validación.

correo electronico

El campo bajo validación debe estar formateado como una dirección de correo electrónico.

maleficio

El campo bajo validación debe ser un formato hexadecimal, útil en combinación con otras reglas, como hex|size:6 para la validación de código de color hexadecimal.

en: foo, bar, ...

El campo bajo validación debe incluirse 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.

max: valor

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

Nota: los cheques máximos son inclusivos.

min: valor

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

Nota: los controles mínimos son inclusivos.

not_in: foo, bar, ...

El campo bajo validación no debe incluirse en la lista de valores dada.

numérico

Valide que un atributo sea numérico. La representación de cadena de un número pasará.

requerido

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

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

required_unless: otro campo, valor

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

required_with: foo, bar, ...

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

required_with_all: 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.

required_without: 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.

required_without_all: 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 dado 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 los datos de cadena, el valor corresponde al número de caracteres. Para los datos numéricos, el valor corresponde a un valor entero dado.

cuerda

El campo bajo validación debe ser una cadena.

url

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

regex: patrón

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

Nota: el Cuando un uso de al El regex patrón, puede ser necesario a la normativa indicar, en una matriz en lugar de un uso delimitador requerido tubería y, ESPECIALMENTE SI en la expresión regular El del contiene un tubo de Carácter del Para el cada barra hacia atrás que utilizó en su patrón de expresión, que la debe escapar de la cada uno. uno con otro corte hacia atrás.

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

Ejemplo 4 Validación de comprobación de tipo

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} -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 devolución de llamada de 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 });

Luego llame a su validador pasando una devolución de llamada a fails o passes manera:

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 passes o fails sin 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 de Validator tendrá su objeto de propiedad de errores rellenado con los mensajes de error para todos los atributos que fallan. Los métodos y propiedades en el objeto de propiedad de errores son:

.first (atributo)

devuelve el primer mensaje de error para un atributo, de lo contrario es falso

.get (atributo)

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

.todos ()

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

.has (atributo)

devuelve verdadero si existen mensajes de error para un atributo, falso de lo contrario

.errorCount

la cantidad 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 de cadena y numéricas. También puede 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 configure 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 "amigable" personalizado en los mensajes de error, 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, puede proporcionar nombres de atributos personalizados globales en su idioma con la propiedad de attributes .

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: por defecto, todos los caracteres serán reemplazados por 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 script 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 recogerá automáticamente en los archivos de origen 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 mensajes predeterminados para el idioma:

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