Módulo de comunidad impresionante

validatorjs

Estado de construcció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 de Laravel .

¿Por qué usar 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 {Object} -Mensajes de error personalizados opcionales para devolver

Ejemplo 1: aprobación de 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 , use 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 las reglas de validación para los 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 las reglas de validación con una clave plana 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 para indefinido o "", use la regla requerida .

aceptado

El campo bajo validación debe ser sí, activado, 1 o verdadero. Esto es útil para validar la aceptación de las "Condiciones de servicio".

después: fecha

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

after_or_equal: fecha

El campo después de la validación debe ser igual o posterior al campo dado

alfa

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

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 alfanumérico.

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.

before_or_equal: fecha

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

entre: min, max

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 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 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 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. Útil en combinación con otras reglas, como hex|size:6 para la validación del código de color hexadecimal.

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 están incluidos.

min: valor

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

Nota: Los controles mínimos están incluidos.

not_in: foo, bar, ...

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

numérico

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

necesario

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 están presentes todos los demás campos especificados.

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

cuerda

El campo bajo validación debe ser una cadena.

url

Validar 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: Cuando se utiliza la regex . Patrón, puede ser necesario especificar reglas de una matriz en lugar de utilizar delimitadores de tuberías, especialmente si la expresión regular contiene un carácter de barra vertical para cada barra hacia atrás que utilizó en su patrón de expresión regular, que debe escapar de cada uno uno con otra barra inclinada hacia atrás.

Ejemplo 3: validación de expresiones regulares

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 de validación de verificación de 4 tipos

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 será reemplazado por 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 así:

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 a passes o fails sin una devolución de llamada y el validador detecta que hay reglas de validación asincrónicas, se lanzará 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 poblado con los mensajes de error para todos los atributos que fallan. Los métodos y propiedades del objeto de propiedad de errores son:

.first (atributo)

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

.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 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 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 " .setAttributeNames() " personalizado en los 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 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: 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, recogerá automáticamente los archivos de origen del idioma.

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

Si no encuentra 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 está utilizando:

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