Módulo comunitario incrible

validatorjs

Estado de compilación

A biblioteca validatorjs facilita moito 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 Nodo.
  • Normas de validación lexibles e declarativas.
  • Mensaxes de erro con soporte multilingüe.
  • Soporte para AMD / Require.js e CommonJS / Browserify.

Instalación

Toma validatorjs de Bower, NPM ou do 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} -Os datos que desexa validar

regras {Obxecto} -Regras de validación

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

Exemplo 1: validación de paso

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 chaves de obxecto para o obxecto de regras .

Exemplo 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

Os obxectos aniñados tamén se poden validar. Hai dúas formas de declarar as regras de validación dos obxectos aniñados. A primeira forma é 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 coa clave achatada 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' } } };

Poderemos 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

Os comodíns tamén se 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' } } }] };

Poderemos 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 requisito implícito ". Se un campo non está definido ou unha cadea baleira pasará a validación. Se desexa que falla unha validación por indefinido ou" ", use a regra requirida .

aceptada

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

despois: data

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

after_or_equal: data

A validación despois do campo debe ser posterior ou igual ao campo indicado

alfa

O campo baixo validación debe ter caracteres completamente alfabéticos.

alpha_dash

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

alpha_num

O campo baixo validación debe ter caracteres enteiramente alfanuméricos.

matriz

O campo baixo validación debe ser unha matriz.

antes: data

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

before_or_equal: 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

Un baixo que ser campo validación do valor booleano A forma de true, false, 0, 1, 'true', 'false', '0', '1',

confirmado

O campo baixo validación debe ter un campo coincidente de foo_confirmation. Por exemplo, se o campo baixo validación é contrasinal, debe haber un campo coincidente con password_confirmation na entrada.

data

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

díxitos: valor

O campo baixo 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 baixo validación debe estar formateado como un enderezo de correo electrónico.

hex

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

en: foo, bar, ...

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

enteiro

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

máximo: valor

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

Nota: o número máximo de comprobacións está incluído.

min: valor

Valida que un atributo ten polo menos un tamaño determinado.

Nota: As comprobacións mínimas están incluídas.

not_in: foo, bar, ...

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

numérico

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

requirido

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

required_if: outro campo, valor

O campo en validación debe estar presente e non baleiro se o campo de 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 campo doutro campo sexa igual a calquera valor.

required_with: foo, barra, ...

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

required_with_all: foo, barra, ...

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

required_without: foo, barra, ...

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

required_without_all: foo, barra, ...

O campo baixo validación debe estar presente e non baleiro só cando non estean presentes 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 dado.

corda

O campo baixo validación debe ser unha cadea.

url

Valida que un atributo ten un formato de URL válido

regex: patrón

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

Nota : Cando se usa o regexpatrón, pode ser necesario especificar regras nunha matriz en lugar de usar delimitadores de tubos, especialmente se a expresión regular contén un carácter de canalización. con outra barra inclinada cara atrás.

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

Exemplo de validación de comprobació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} -O nome da regra.

callbackFn {Función}: devolve un booleano para representar unha validación correcta ou fallida.

errorMessage {Cadea}: unha cadea opcional onde pode especificar unha mensaxe de erro personalizada .: o atributo dentro de 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 mediante 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: detecta se intenta chamar passesou failssen devolución de chamada e o validador hai regras de validación asíncronas, lanzarase unha excepción.

Error Messages

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

Se hai erros, a instancia Validator terá o seu obxecto de propiedade de erros cuberto coas mensaxes de erro de 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 dun atributo, falso en caso contrario

.get (atributo)

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

.todo ()

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

.has (atributo)

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

.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 substitució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 en cadea e numéricas. Tamén podes cambialos.

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 establecer 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 amosar un nome de atributo "agradable" personalizado en 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." }

Como alternativa, pode subministrar nomes de atributos personalizados globais no seu idioma coa attributespropiedade.

Tamén pode configurar un formato de atributo 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 serán substituídos por espazos.

Language Support

As mensaxes de erro están en inglés de xeito predeterminado. Para incluír outro idioma no navegador, faga referencia ao ficheiro de idioma nunha etiqueta de script e chame 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 usado polo validador:

1
Validator.useLang('lang_code');

Obter o idioma predeterminado que se está a usar:

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

Substitúe 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);