valitron
v1.4.11
Valitron é uma biblioteca de validação autônoma simples, mínima e elegante, SEM dependências. Valitron usa métodos de validação simples e diretos com foco em sintaxe legível e concisa. Valitron é a biblioteca de validação simples e pragmática que você procura.
Obtenha suporte para vlucas/valitron com a assinatura Tidelift
Valitron foi criado a partir da frustração com outras bibliotecas de validação que dependem de grandes componentes de outros frameworks como o HttpFoundation do Symfony, extraindo uma tonelada de arquivos extras que não são realmente necessários para validação básica. Ele também possui uma sintaxe propositalmente simples usada para executar todas as validações em uma chamada, em vez de validar individualmente cada valor instanciando novas classes e validando valores um de cada vez, como algumas outras bibliotecas de validação exigem.
Resumindo, Valitron é tudo o que você procurava em uma biblioteca de validação, mas não conseguiu encontrar até agora: sintaxe pragmática simples, código leve que faz sentido, extensível para callbacks e validações personalizadas, bem testado e sem dependências . Vamos começar.
Valitron usa o Composer para instalar e atualizar:
curl -s http://getcomposer.org/installer | php
php composer.phar require vlucas/valitron
Os exemplos abaixo usam sintaxe PHP 5.4, mas Valitron funciona em PHP 5.3+.
O uso é simples e direto. Basta fornecer uma matriz de dados que você deseja validar, adicionar algumas regras e depois chamar validate() . Se houver algum erro, você pode chamar errors() para obtê-los.
$ v = new Valitron Validator ( array ( ' name ' => ' Chester Tester ' ));
$ v -> rule ( ' required ' , ' name ' );
if ( $ v -> validate ()) {
echo " Yay! We're all good! " ;
} else {
// Errors
print_r ( $ v -> errors ());
} Usando este formato, você pode validar dados $_POST direta e facilmente, e pode até aplicar uma regra como required a uma matriz de campos:
$ v = new Valitron Validator ( $ _POST );
$ v -> rule ( ' required ' , [ ' name ' , ' email ' ]);
$ v -> rule ( ' email ' , ' email ' );
if ( $ v -> validate ()) {
echo " Yay! We're all good! " ;
} else {
// Errors
print_r ( $ v -> errors ());
}Você pode usar a sintaxe de ponto para acessar membros de arrays multidimensionais e um asterisco para validar cada membro de um array:
$ v = new Valitron Validator ( array ( ' settings ' => array (
array ( ' threshold ' => 50 ),
array ( ' threshold ' => 90 )
)));
$ v -> rule ( ' max ' , ' settings.*.threshold ' , 100 );
if ( $ v -> validate ()) {
echo " Yay! We're all good! " ;
} else {
// Errors
print_r ( $ v -> errors ());
}Ou use a sintaxe de ponto para validar todos os membros de uma matriz numérica:
$ v = new Valitron Validator ( array ( ' values ' => array ( 50 , 90 )));
$ v -> rule ( ' max ' , ' values.* ' , 100 );
if ( $ v -> validate ()) {
echo " Yay! We're all good! " ;
} else {
// Errors
print_r ( $ v -> errors ());
}Você também pode acessar valores aninhados usando notação de ponto:
$ v = new Valitron Validator ( array ( ' user ' => array ( ' first_name ' => ' Steve ' , ' last_name ' => ' Smith ' , ' username ' => ' Batman123 ' )));
$ v -> rule ( ' alpha ' , ' user.first_name ' )-> rule ( ' alpha ' , ' user.last_name ' )-> rule ( ' alphaNum ' , ' user.username ' );
if ( $ v -> validate ()) {
echo " Yay! We're all good! " ;
} else {
// Errors
print_r ( $ v -> errors ());
}Configurando o idioma e o diretório de idioma globalmente:
// boot or config file
use Valitron Validator as V ;
V:: langDir ( __DIR__ . ' /validator_lang ' ); // always set langDir before lang.
V:: lang ( ' ar ' );Desativando o nome {field} na saída da mensagem de erro.
use Valitron Validator as V ;
$ v = new Valitron Validator ([ ' name ' => ' John ' ]);
$ v -> rule ( ' required ' , [ ' name ' ]);
// Disable prepending the labels
$ v -> setPrependLabels ( false );
// Error output for the "false" condition
[
[ " name " ] => [
" is required "
]
]
// Error output for the default (true) condition
[
[ " name " ] => [
" name is required "
]
]Você pode exigir valores condicionalmente usando regras condicionais obrigatórias. Neste exemplo, para autenticação, solicitamos um token quando o e-mail e a senha não estiverem presentes ou uma senha quando o endereço de e-mail estiver presente.
// this rule set would work for either data set...
$ data = [ ' email ' => ' [email protected] ' , ' password ' => ' mypassword ' ];
// or...
$ data = [ ' token ' => ' jashdjahs83rufh89y38h38h ' ];
$ v = new Valitron Validator ( $ data );
$ v -> rules ([
' requiredWithout ' => [
[ ' token ' , [ ' email ' , ' password ' ], true ]
],
' requiredWith ' => [
[ ' password ' , [ ' email ' ]]
],
' email ' => [
[ ' email ' ]
]
' optional ' => [
[ ' email ' ]
]
]);
$ this -> assertTrue ( $ v -> validate ());required - O campo é obrigatóriorequiredWith - O campo é obrigatório se algum outro campo estiver presenterequiredWithout - O campo é obrigatório se algum outro campo NÃO estiver presenteequals - O campo deve corresponder a outro campo (confirmação de e-mail/senha)different - O campo deve ser diferente de outro campoaccepted - Caixa de seleção ou Rádio deve ser aceito (sim, ativado, 1, verdadeiro)numeric - deve ser numéricointeger - Deve ser um número inteiroboolean - Deve ser booleanoarray - Deve ser arraylength - a string deve ter um determinado comprimentolengthBetween - A string deve estar entre os comprimentos fornecidoslengthMin - String deve ser maior que o comprimento determinadolengthMax - String deve ser menor que o comprimento determinadomin - Mínimomax - MáximolistContains - Executa a verificação in_array em determinados valores da matriz (o contrário de in )in - Executa verificação in_array em determinados valores do arraynotIn - Negação da regra in (não na matriz de valores)ip - Endereço IP válidoipv4 - Endereço IP v4 válidoipv6 - Endereço IP v6 válidoemail - Endereço de e-mail válidoemailDNS - Endereço de e-mail válido com registro DNS ativourl - URL válidourlActive – URL válido com registro DNS ativoalpha - Somente caracteres alfabéticosalphaNum - Somente caracteres alfabéticos e numéricosascii - somente caracteres ASCIIslug - caracteres de slug de URL (az, 0-9, -, _)regex - O campo corresponde ao padrão regexdate - O campo é uma data válidadateFormat - O campo é uma data válida no formato fornecidodateBefore - O campo é uma data válida e é anterior à data especificadadateAfter - O campo é uma data válida e é posterior à data especificadacontains - O campo é uma string e contém a string fornecidasubset - O campo é uma matriz ou escalar e todos os elementos estão contidos na matriz fornecidacontainsUnique - O campo é uma matriz e contém valores exclusivoscreditCard - O campo é um número de cartão de crédito válidoinstanceOf - O campo contém uma instância da classe fornecidaoptional - o valor não precisa ser incluído na matriz de dados. Se for, no entanto, deve passar na validação.arrayHasKeys - O campo é um array e contém todas as chaves especificadas.NOTA : Se você estiver comparando números de ponto flutuante com validadores mínimo/máximo, deverá instalar a extensão BCMath para maior precisão e confiabilidade. A extensão não é necessária para que o Valitron funcione, mas a Valitron a utilizará se estiver disponível e é altamente recomendada.
a regra required verifica se existe um campo na matriz de dados e não é nulo ou uma string vazia.
$ v -> rule ( ' required ' , ' field_name ' );Usando um parâmetro extra, você pode tornar esta regra mais flexível, e apenas verificar se o campo existe na matriz de dados.
$ v -> rule ( ' required ' , ' field_name ' , true );Sintaxe alternativa.
$ v = new Valitron Validator ([ ' username ' => ' spiderman ' , ' password ' => ' Gr33nG0Blin ' , ' required_but_null ' => null ]);
$ v -> rules ([
' required ' => [
[ ' username ' ],
[ ' password ' ],
[ ' required_but_null ' , true ] // boolean flag allows empty value so long as the field name is set on the data array
]
]);
$ v -> validate (); A regra requiredWith verifica se o campo é obrigatório, não nulo e não a sequência vazia, se algum outro campo estiver presente, não nulo e não a sequência vazia.
// password field will be required when the username field is provided and not empty
$ v -> rule ( ' requiredWith ' , ' password ' , ' username ' );Sintaxe alternativa.
$ v = new Valitron Validator ([ ' username ' => ' spiderman ' , ' password ' => ' Gr33nG0Blin ' ]);
$ v -> rules ([
' requiredWith ' => [
[ ' password ' , ' username ' ]
]
]);
$ v -> validate ();Nota Você pode fornecer vários valores como uma matriz. Neste caso, se QUALQUER um dos campos estiver presente, o campo será obrigatório.
// in this case the password field will be required if the username or email fields are present
$ v -> rule ( ' requiredWith ' , ' password ' , [ ' username ' , ' email ' ]);Sintaxe alternativa.
$ v = new Valitron Validator ([ ' username ' => ' spiderman ' , ' password ' => ' Gr33nG0Blin ' ]);
$ v -> rules ([
' requiredWith ' => [
[ ' password ' , [ ' username ' , ' email ' ]]
]
]);
$ v -> validate (); O sinalizador estrito alterará a regra requiredWith para requiredWithAll , que exigirá o campo apenas se TODOS os outros campos estiverem presentes, não nulos e não a string vazia.
// in this example the suffix field is required only when both the first_name and last_name are provided
$ v -> rule ( ' requiredWith ' , ' suffix ' , [ ' first_name ' , ' last_name ' ], true );Sintaxe alternativa.
$ v = new Valitron Validator ([ ' first_name ' => ' steve ' , ' last_name ' => ' holt ' , ' suffix ' => ' Mr ' ]);
$ v -> rules ([
' requiredWith ' => [
[ ' suffix ' , [ ' first_name ' , ' last_name ' ], true ]
]
]);
$ v -> validate (); Da mesma forma, neste caso, validate() ainda retornaria verdadeiro, pois o campo sufixo não seria obrigatório no modo estrito, pois nem todos os campos são fornecidos.
$ v = new Valitron Validator ([ ' first_name ' => ' steve ' ]);
$ v -> rules ([
' requiredWith ' => [
[ ' suffix ' , [ ' first_name ' , ' last_name ' ], true ]
]
]);
$ v -> validate (); A regra requiredWithout verifica se o campo é obrigatório, não nulo e não a string vazia, se algum outro campo NÃO estiver presente.
// this rule will require the username field when the first_name is not present
$ v -> rule ( ' requiredWithout ' , ' username ' , ' first_name ' )Sintaxe alternativa.
// this will return true, as the username is provided when the first_name is not provided
$ v = new Valitron Validator ([ ' username ' => ' spiderman ' ]);
$ v -> rules ([
' requiredWithout ' => [
[ ' username ' , ' first_name ' ]
]
]);
$ v -> validate ();Nota Você pode fornecer vários valores como uma matriz. Neste caso, se QUALQUER um dos campos NÃO estiver presente, o campo será obrigatório.
// in this case the username field will be required if either the first_name or last_name fields are not present
$ v -> rule ( ' requiredWithout ' , ' username ' , [ ' first_name ' , ' last_name ' ]);Sintaxe alternativa.
// this passes validation because although the last_name field is not present, the username is provided
$ v = new Valitron Validator ([ ' username ' => ' spiderman ' , ' first_name ' => ' Peter ' ]);
$ v -> rules ([
' requiredWithout ' => [
[ ' username ' , [ ' first_name ' , ' last_name ' ]]
]
]);
$ v -> validate (); O sinalizador estrito alterará a regra requiredWithout para requiredWithoutAll , que exigirá o campo apenas se TODOS os outros campos não estiverem presentes.
// in this example the username field is required only when both the first_name and last_name are not provided
$ v -> rule ( ' requiredWithout ' , ' username ' , [ ' first_name ' , ' last_name ' ], true );Sintaxe alternativa.
$ v = new Valitron Validator ([ ' username ' => ' BatMan ' ]);
$ v -> rules ([
' requiredWithout ' => [
[ ' username ' , [ ' first_name ' , ' last_name ' ], true ]
]
]);
$ v -> validate (); Da mesma forma, neste caso, validate() ainda retornaria verdadeiro, pois o campo nome de usuário não seria obrigatório no modo estrito, pois todos os campos são fornecidos.
$ v = new Valitron Validator ([ ' first_name ' => ' steve ' , ' last_name ' => ' holt ' ]);
$ v -> rules ([
' requiredWithout ' => [
[ ' suffix ' , [ ' first_name ' , ' last_name ' ], true ]
]
]);
$ v -> validate (); A regra equals verifica se dois campos são iguais na matriz de dados e se o segundo campo não é nulo.
$ v -> rule ( ' equals ' , ' password ' , ' confirmPassword ' );Sintaxe alternativa.
$ v = new Valitron Validator ([ ' password ' => ' youshouldnotseethis ' , ' confirmPassword ' => ' youshouldnotseethis ' ]);
$ v -> rules ([
' equals ' => [
[ ' password ' , ' confirmPassword ' ]
]
]);
$ v -> validate (); A regra different verifica se dois campos não são iguais ou diferentes na matriz de dados e se o segundo campo não é nulo.
$ v -> rule ( ' different ' , ' username ' , ' password ' );Sintaxe alternativa.
$ v = new Valitron Validator ([ ' username ' => ' spiderman ' , ' password ' => ' Gr33nG0Blin ' ]);
$ v -> rules ([
' different ' => [
[ ' username ' , ' password ' ]
]
]);
$ v -> validate (); A regra accepted verifica se o campo é 'sim', 'ativado', 1 ou verdadeiro.
$ v -> rule ( ' accepted ' , ' remember_me ' );Sintaxe alternativa.
$ v = new Valitron Validator ([ ' remember_me ' => true ]);
$ v -> rules ([
' accepted ' => [
[ ' remember_me ' ]
]
]);
$ v -> validate (); A regra numeric verifica se o campo é um número. Isso é análogo à função is_numeric() do php.
$ v -> rule ( ' numeric ' , ' amount ' );Sintaxe alternativa.
$ v = new Valitron Validator ([ ' amount ' => 3.14 ]);
$ v -> rules ([
' numeric ' => [
[ ' amount ' ]
]
]);
$ v -> validate (); A regra integer verifica se o campo é um número inteiro.
$ v -> rule ( ' integer ' , ' age ' );Sintaxe alternativa.
$ v = new Valitron Validator ([ ' age ' => ' 27 ' ]);
$ v -> rules ([
' integer ' => [
[ ' age ' ]
]
]);
$ v -> validate ();Observe que o sinalizador booleano opcional para o modo estrito garante que os números inteiros sejam fornecidos em um formato estritamente numérico. Portanto, a seguinte regra seria avaliada como verdadeira:
$ v = new Valitron Validator ([ ' negative ' => ' -27 ' , ' positive ' => ' 27 ' ]);
$ v -> rule ( ' integer ' , ' age ' , true );
$ v -> rule ( ' integer ' , ' height ' , true );
$ v -> validate ();Considerando que o seguinte será avaliado como falso, já que o + para o número positivo neste caso é redundante:
$ v = new Valitron Validator ([ ' negative ' => ' -27 ' , ' positive ' => ' +27 ' ]);
$ v -> rule ( ' integer ' , ' age ' , true );
$ v -> rule ( ' integer ' , ' height ' , true );
$ v -> validate (); A regra boolean verifica se o campo é booleano. Isso é análogo à função is_bool() do php.
$ v -> rule ( ' boolean ' , ' remember_me ' );Sintaxe alternativa.
$ v = new Valitron Validator ([ ' remember_me ' => true ]);
$ v -> rules ([
' boolean ' => [
[ ' remember_me ' ]
]
]);
$ v -> validate (); A regra array verifica se o campo é um array. Isso é análogo à função is_array() do php.
$ v -> rule ( ' array ' , ' user_notifications ' );Sintaxe alternativa.
$ v = new Valitron Validator ([ ' user_notifications ' => [ ' bulletin_notifications ' => true , ' marketing_notifications ' => false , ' message_notification ' => true ]]);
$ v -> rules ([
' array ' => [
[ ' user_notifications ' ]
]
]);
$ v -> validate (); A regra length verifica se o campo tem exatamente um determinado comprimento e se o campo é uma string válida.
$ v -> rule ( ' length ' , ' username ' , 10 );Sintaxe alternativa.
$ v = new Valitron Validator ([ ' username ' => ' bobburgers ' ]);
$ v -> rules ([
' length ' => [
[ ' username ' , 10 ]
]
]);
$ v -> validate (); A regra lengthBetween verifica se o campo está entre um determinado comprimento tangente e se o campo é uma string válida.
$ v -> rule ( ' lengthBetween ' , ' username ' , 1 , 10 );Sintaxe alternativa.
$ v = new Valitron Validator ([ ' username ' => ' bobburgers ' ]);
$ v -> rules ([
' lengthBetween ' => [
[ ' username ' , 1 , 10 ]
]
]);
$ v -> validate (); A regra lengthMin verifica se o campo tem pelo menos um determinado comprimento e se o campo é uma string válida.
$ v -> rule ( ' lengthMin ' , ' username ' , 5 );Sintaxe alternativa.
$ v = new Valitron Validator ([ ' username ' => ' martha ' ]);
$ v -> rules ([
' lengthMin ' => [
[ ' username ' , 5 ]
]
]);
$ v -> validate (); A regra lengthMax verifica se o campo tem no máximo um determinado comprimento e se o campo é uma string válida.
$ v -> rule ( ' lengthMax ' , ' username ' , 10 );Sintaxe alternativa.
$ v = new Valitron Validator ([ ' username ' => ' bruins91 ' ]);
$ v -> rules ([
' lengthMax ' => [
[ ' username ' , 10 ]
]
]);
$ v -> validate (); A regra min verifica se o campo tem pelo menos um determinado valor e se o valor fornecido é numérico.
$ v -> rule ( ' min ' , ' age ' , 18 );Sintaxe alternativa.
$ v = new Valitron Validator ([ ' age ' => 28 ]);
$ v -> rules ([
' min ' => [
[ ' age ' , 18 ]
]
]);
$ v -> validate (); A regra max verifica se o campo tem no máximo um determinado valor e se o valor fornecido é numérico.
$ v -> rule ( ' max ' , ' age ' , 12 );Sintaxe alternativa.
$ v = new Valitron Validator ([ ' age ' => 10 ]);
$ v -> rules ([
' max ' => [
[ ' age ' , 12 ]
]
]);
$ v -> validate (); A regra listContains verifica se o campo está presente em uma determinada matriz de valores.
$ v -> rule ( ' listContains ' , ' color ' , ' yellow ' );Sintaxe alternativa.
$ v = new Valitron Validator ([ ' color ' => [ ' blue ' , ' green ' , ' red ' , ' yellow ' ]]);
$ v -> rules ([
' listContains ' => [
[ ' color ' , ' yellow ' ]
]
]);
$ v -> validate (); A regra in verifica se o campo está presente em uma determinada matriz de valores.
$ v -> rule ( ' in ' , ' color ' , [ ' blue ' , ' green ' , ' red ' , ' purple ' ]);Sintaxe alternativa.
$ v = new Valitron Validator ([ ' color ' => ' purple ' ]);
$ v -> rules ([
' in ' => [
[ ' color ' , [ ' blue ' , ' green ' , ' red ' , ' purple ' ]]
]
]);
$ v -> validate (); A regra notIn verifica se o campo NÃO está presente em uma determinada matriz de valores.
$ v -> rule ( ' notIn ' , ' color ' , [ ' blue ' , ' green ' , ' red ' , ' yellow ' ]);Sintaxe alternativa.
$ v = new Valitron Validator ([ ' color ' => ' purple ' ]);
$ v -> rules ([
' notIn ' => [
[ ' color ' , [ ' blue ' , ' green ' , ' red ' , ' yellow ' ]]
]
]);
$ v -> validate (); A regra ip verifica se o campo é um endereço IP válido. Isso inclui intervalos IPv4, IPv6, privados e reservados.
$ v -> rule ( ' ip ' , ' user_ip ' );Sintaxe alternativa.
$ v = new Valitron Validator ([ ' user_ip ' => ' 127.0.0.1 ' ]);
$ v -> rules ([
' ip ' => [
[ ' user_ip ' ]
]
]);
$ v -> validate (); A regra ipv4 verifica se o campo é um endereço IPv4 válido.
$ v -> rule ( ' ipv4 ' , ' user_ip ' );Sintaxe alternativa.
$ v = new Valitron Validator ([ ' user_ip ' => ' 127.0.0.1 ' ]);
$ v -> rules ([
' ipv4 ' => [
[ ' user_ip ' ]
]
]);
$ v -> validate (); A regra ipv6 verifica se o campo é um endereço IPv6 válido.
$ v -> rule ( ' ipv6 ' , ' user_ip ' );Sintaxe alternativa.
$ v = new Valitron Validator ([ ' user_ip ' => ' 0:0:0:0:0:0:0:1 ' ]);
$ v -> rules ([
' ipv6 ' => [
[ ' user_ip ' ]
]
]);
$ v -> validate (); A regra email verifica se o campo é um endereço de email válido.
$ v -> rule ( ' email ' , ' user_email ' );Sintaxe alternativa.
$ v = new Valitron Validator ([ ' user_email ' => ' [email protected] ' ]);
$ v -> rules ([
' email ' => [
[ ' user_email ' ]
]
]);
$ v -> validate (); A regra emailDNS valida se o campo é um endereço de e-mail válido com um registro DNS ativo ou de qualquer tipo.
$ v -> rule ( ' emailDNS ' , ' user_email ' );Sintaxe alternativa.
$ v = new Valitron Validator ([ ' user_email ' => ' [email protected] ' ]);
$ v -> rules ([
' emailDNS ' => [
[ ' user_email ' ]
]
]);
$ v -> validate (); A regra url verifica se o campo é um URL válido.
$ v -> rule ( ' url ' , ' website ' );Sintaxe alternativa.
$ v = new Valitron Validator ([ ' website ' => ' https://example.com/contact ' ]);
$ v -> rules ([
' url ' => [
[ ' website ' ]
]
]);
$ v -> validate (); A regra urlActive verifica se o campo é um URL válido com um registro A, AAAA ou CNAME ativo.
$ v -> rule ( ' urlActive ' , ' website ' );Sintaxe alternativa.
$ v = new Valitron Validator ([ ' website ' => ' https://example.com/contact ' ]);
$ v -> rules ([
' urlActive ' => [
[ ' website ' ]
]
]);
$ v -> validate (); A regra alpha verifica se o campo contém apenas caracteres alfabéticos.
$ v -> rule ( ' alpha ' , ' username ' );Sintaxe alternativa.
$ v = new Valitron Validator ([ ' username ' => ' batman ' ]);
$ v -> rules ([
' alpha ' => [
[ ' username ' ]
]
]);
$ v -> validate (); A regra alphaNum verifica se o campo contém apenas caracteres alfabéticos ou numéricos.
$ v -> rule ( ' alphaNum ' , ' username ' );Sintaxe alternativa.
$ v = new Valitron Validator ([ ' username ' => ' batman123 ' ]);
$ v -> rules ([
' alphaNum ' => [
[ ' username ' ]
]
]);
$ v -> validate (); A regra ascii verifica se o campo contém apenas caracteres do conjunto de caracteres ascii.
$ v -> rule ( ' ascii ' , ' username ' );Sintaxe alternativa.
$ v = new Valitron Validator ([ ' username ' => ' batman123 ' ]);
$ v -> rules ([
' ascii ' => [
[ ' username ' ]
]
]);
$ v -> validate (); A regra slug verifica se o campo contém apenas caracteres de slug de URL (az, 0-9, -, _).
$ v -> rule ( ' slug ' , ' username ' );Sintaxe alternativa.
$ v = new Valitron Validator ([ ' username ' => ' L337-H4ckZ0rz_123 ' ]);
$ v -> rules ([
' slug ' => [
[ ' username ' ]
]
]);
$ v -> validate (); A regra regex garante que o campo corresponda a um determinado padrão regex. (Este regex verifica se a string é alfanumérica entre 5 e 10 caracteres).
$ v -> rule ( ' regex ' , ' username ' , ' /^[a-zA-Z0-9]{5,10}$/ ' );Sintaxe alternativa.
$ v = new Valitron Validator ([ ' username ' => ' Batman123 ' ]);
$ v -> rules ([
' regex ' => [
[ ' username ' , ' /^[a-zA-Z0-9]{5,10}$/ ' ]
]
]);
$ v -> validate (); A regra date verifica se o campo fornecido é um objeto DateTime válido ou se a string pode ser convertida em um carimbo de data/hora unix via strtotime().
$ v -> rule ( ' date ' , ' created_at ' );Sintaxe alternativa.
$ v = new Valitron Validator ([ ' created_at ' => ' 2018-10-13 ' ]);
$ v -> rules ([
' date ' => [
[ ' created_at ' ]
]
]);
$ v -> validate (); A regra dateFormat verifica se o campo fornecido é uma data válida em um formato de data especificado.
$ v -> rule ( ' dateFormat ' , ' created_at ' , ' Y-m-d ' );Sintaxe alternativa.
$ v = new Valitron Validator ([ ' created_at ' => ' 2018-10-13 ' ]);
$ v -> rules ([
' dateFormat ' => [
[ ' created_at ' , ' Y-m-d ' ]
]
]);
$ v -> validate (); A regra dateBefore verifica se o campo fornecido é uma data válida antes de uma data especificada.
$ v -> rule ( ' dateBefore ' , ' created_at ' , ' 2018-10-13 ' );Sintaxe alternativa.
$ v = new Valitron Validator ([ ' created_at ' => ' 2018-09-01 ' ]);
$ v -> rules ([
' dateBefore ' => [
[ ' created_at ' , ' 2018-10-13 ' ]
]
]);
$ v -> validate (); A regra dateAfter verifica se o campo fornecido é uma data válida após uma data especificada.
$ v -> rule ( ' dateAfter ' , ' created_at ' , ' 2018-10-13 ' );Sintaxe alternativa.
$ v = new Valitron Validator ([ ' created_at ' => ' 2018-09-01 ' ]);
$ v -> rules ([
' dateAfter ' => [
[ ' created_at ' , ' 2018-01-01 ' ]
]
]);
$ v -> validate (); A regra contains verifica se uma determinada sequência existe no campo e verifica se o campo e o valor de pesquisa são sequências válidas.
$ v -> rule ( ' contains ' , ' username ' , ' man ' );Sintaxe alternativa.
$ v = new Valitron Validator ([ ' username ' => ' Batman123 ' ]);
$ v -> rules ([
' contains ' => [
[ ' username ' , ' man ' ]
]
]);
$ v -> validate ();Nota Você pode usar o sinalizador estrito opcional para garantir uma correspondência que diferencia maiúsculas de minúsculas. O exemplo a seguir retornará verdadeiro:
$ v = new Valitron Validator ([ ' username ' => ' Batman123 ' ]);
$ v -> rules ([
' contains ' => [
[ ' username ' , ' man ' ]
]
]);
$ v -> validate ();Considerando que isso retornaria falso, já que o M na string de pesquisa não está maiúsculo no valor fornecido:
$ v = new Valitron Validator ([ ' username ' => ' Batman123 ' ]);
$ v -> rules ([
' contains ' => [
[ ' username ' , ' Man ' , true ]
]
]);
$ v -> validate (); A regra subset verifica se o campo é um campo escalar ou de matriz e se todos os seus valores estão contidos em um determinado conjunto de valores.
$ v -> rule ( ' subset ' , ' colors ' , [ ' green ' , ' blue ' , ' orange ' ]);Sintaxe alternativa.
$ v = new Valitron Validator ([ ' colors ' => [ ' green ' , ' blue ' ]]);
$ v -> rules ([
' subset ' => [
[ ' colors ' , [ ' orange ' , ' green ' , ' blue ' , ' red ' ]]
]
]);
$ v -> validate ();Este exemplo retornaria falso, pois a cor fornecida, roxo, não existe na matriz de valores aceitos que estamos fornecendo.
$ v = new Valitron Validator ([ ' colors ' => [ ' purple ' , ' blue ' ]]);
$ v -> rules ([
' subset ' => [
[ ' colors ' , [ ' orange ' , ' green ' , ' blue ' , ' red ' ]]
]
]);
$ v -> validate (); A regra containsUnique verifica se o campo fornecido é um array e se todos os valores contidos nele são únicos, ou seja, não há valores duplicados no array.
$ v -> rule ( ' containsUnique ' , ' colors ' );Sintaxe alternativa.
$ v = new Valitron Validator ([ ' colors ' => [ ' purple ' , ' blue ' ]]);
$ v -> rules ([
' containsUnique ' => [
[ ' colors ' ]
]
]);
$ v -> validate ();Este exemplo retornaria falso, pois os valores na matriz fornecida são duplicados.
$ v = new Valitron Validator ([ ' colors ' => [ ' purple ' , ' purple ' ]]);
$ v -> rules ([
' containsUnique ' => [
[ ' colors ' ]
]
]);
$ v -> validate (); A validação do cartão de crédito atualmente permite validar um visa Visa, Mastercard mastercard , Dinersclub dinersclub , American Express amex ou Discover discover
Isso verificará o cartão de crédito em relação a cada tipo de cartão
$ v -> rule ( ' creditCard ' , ' credit_card ' );Para filtrar opcionalmente os tipos de cartão, adicione o slug a uma matriz como o próximo parâmetro:
$ v -> rule ( ' creditCard ' , ' credit_card ' , [ ' visa ' , ' mastercard ' ]);Caso queira validar apenas um tipo de cartão, coloque-o como uma string:
$ v -> rule ( ' creditCard ' , ' credit_card ' , ' visa ' );Se as informações do tipo de cartão vierem do cliente, você também poderá especificar uma matriz de tipos de cartão válidos:
$ cardType = ' amex ' ;
$ v -> rule ( ' creditCard ' , ' credit_card ' , $ cardType , [ ' visa ' , ' mastercard ' ]);
$ v -> validate (); // false A regra instanceOf verifica se o campo é uma instância de uma determinada classe.
$ v -> rule ( ' instanceOf ' , ' date ' , DateTime);Sintaxe alternativa.
$ v = new Valitron Validator ([ ' date ' => new DateTime ()]);
$ v -> rules ([
' instanceOf ' => [
[ ' date ' , ' DateTime ' ]
]
]);
$ v -> validate ();Nota Você também pode comparar o valor com um determinado objeto em oposição ao nome da classe de string. Este exemplo também retornaria verdadeiro:
$ v = new Valitron Validator ([ ' date ' => new DateTime ()]);
$ existingDateObject = new DateTime ();
$ v -> rules ([
' instanceOf ' => [
[ ' date ' , $ existingDateObject ]
]
]);
$ v -> validate (); A regra optional garante que, se o campo estiver presente no conjunto de dados, ele passará em todas as regras de validação.
$ v -> rule ( ' optional ' , ' username ' );Sintaxe alternativa. Este exemplo retornaria verdadeiro quando o campo 'nome de usuário' não estiver presente ou no caso em que o nome de usuário contenha apenas caracteres alfabéticos.
$ v = new Valitron Validator ([ ' username ' => ' batman ' ]);
$ v -> rules ([
' alpha ' => [
[ ' username ' ]
],
' optional ' => [
[ ' username ' ]
]
]);
$ v -> validate ();Este exemplo retornaria falso, pois embora o campo seja opcional, por ser fornecido ele deve passar por todas as regras de validação, o que neste caso não acontece.
$ v = new Valitron Validator ([ ' username ' => ' batman123 ' ]);
$ v -> rules ([
' alpha ' => [
[ ' username ' ]
],
' optional ' => [
[ ' username ' ]
]
]);
$ v -> validate (); A regra arrayHasKeys garante que o campo seja uma matriz e que contenha todas as chaves especificadas. Retornará falso se o campo não for um array ou se nenhuma chave obrigatória for especificada ou se alguma chave estiver faltando.
$ v = new Valitron Validator ([
' address ' => [
' name ' => ' Jane Doe ' ,
' street ' => ' Doe Square ' ,
' city ' => ' Doe D.C. '
]
]);
$ v -> rule ( ' arrayHasKeys ' , ' address ' , [ ' name ' , ' street ' , ' city ' ]);
$ v -> validate (); Para adicionar sua própria regra de validação, use o método addRule com um nome de regra, um retorno de chamada ou fechamento personalizado e uma mensagem de erro a ser exibida em caso de erro. O retorno de chamada fornecido deve retornar booleano verdadeiro ou falso.
Valitron Validator:: addRule ( ' alwaysFail ' , function ( $ field , $ value , array $ params , array $ fields ) {
return false ;
}, ' Everything you do is wrong. You fail. ' );Você também pode usar regras únicas válidas apenas para os campos especificados.
$ v = new Valitron Validator ( array ( " foo " => " bar " ));
$ v -> rule ( function ( $ field , $ value , $ params , $ fields ) {
return true ;
}, " foo " )-> message ( " {field} failed... " ); Isto é útil porque tais regras podem ter acesso a variáveis definidas no escopo onde o Validator reside. A assinatura do Closure é idêntica à assinatura do retorno de chamada Validator::addRule .
Se você deseja adicionar suas próprias regras que não sejam estáticas (ou seja, sua regra não é estática e está disponível para chamar instâncias Validator ), você precisa usar Validator::addInstanceRule . Esta regra terá os mesmos parâmetros que Validator::addRule mas deve ser chamada em uma instância Validator .
Você pode encadear várias regras usando a sintaxe a seguir.
$ v = new Valitron Validator ([ ' email_address ' => ' [email protected] ' ]);
$ v -> rule ( ' required ' , ' email_address ' )-> rule ( ' email ' , ' email_address ' );
$ v -> validate ();À medida que o número de regras aumenta, você pode preferir a sintaxe alternativa para definir diversas regras de uma só vez.
$ rules = [
' required ' => ' foo ' ,
' accepted ' => ' bar ' ,
' integer ' => ' bar '
];
$ v = new Valitron Validator ( array ( ' foo ' => ' bar ' , ' bar ' => 1 ));
$ v -> rules ( $ rules );
$ v -> validate ();Se a sua regra exigir vários parâmetros ou um único parâmetro mais complexo que uma string, será necessário agrupar a regra em uma matriz.
$ rules = [
' required ' => [
[ ' foo ' ],
[ ' bar ' ]
],
' length ' => [
[ ' foo ' , 3 ]
]
];Você também pode especificar diversas regras para cada tipo de regra.
$ rules = [
' length ' => [
[ ' foo ' , 5 ],
[ ' bar ' , 5 ]
]
];Juntando essas técnicas, você pode criar uma definição de regra completa em uma estrutura de dados relativamente compacta.
Você pode continuar adicionando regras individuais com o método rule mesmo depois de especificar uma definição de regra por meio de uma matriz. Isto é especialmente útil se você estiver definindo regras de validação personalizadas.
$ rules = [
' required ' => ' foo ' ,
' accepted ' => ' bar ' ,
' integer ' => ' bar '
];
$ v = new Valitron Validator ( array ( ' foo ' => ' bar ' , ' bar ' => 1 ));
$ v -> rules ( $ rules );
$ v -> rule ( ' min ' , ' bar ' , 0 );
$ v -> validate ();Você também pode adicionar regras por campo:
$ rules = [
' required ' ,
[ ' lengthMin ' , 4 ]
];
$ v = new Valitron Validator ( array ( ' foo ' => ' bar ' ));
$ v -> mapFieldRules ( ' foo ' , $ rules );
$ v -> validate ();Ou para vários campos ao mesmo tempo:
$ rules = [
' foo ' => [ ' required ' , ' integer ' ],
' bar ' =>[ ' email ' , [ ' lengthMin ' , 4 ]]
];
$ v = new Valitron Validator(array( ' foo ' => ' bar ' , ' bar ' => '[email protected]));
$v->mapFieldsRules($rules);
$v->validate();Você pode fazer isso de duas maneiras diferentes: pode adicionar um rótulo individual a uma regra ou uma matriz de todos os rótulos das regras.
Para adicionar um rótulo individual à regra, basta adicionar o método label após a regra.
$ v = new Valitron Validator ( array ());
$ v -> rule ( ' required ' , ' name ' )-> message ( ' {field} is required ' )-> label ( ' Name ' );
$ v -> validate ();Há um caso extremo nesse método: você não seria capaz de usar uma matriz de nomes de campos na definição da regra, portanto, uma regra por campo. Então isso não funcionaria:
$ v = new Valitron Validator ( array ());
$ v -> rule ( ' required ' , array ( ' name ' , ' email ' ))-> message ( ' {field} is required ' )-> label ( ' Name ' );
$ v -> validate (); No entanto, podemos usar uma série de rótulos para resolver esse problema simplesmente adicionando o método labels :
$ v = new Valitron Validator ( array ());
$ v -> rule ( ' required ' , array ( ' name ' , ' email ' ))-> message ( ' {field} is required ' );
$ v -> labels ( array (
' name ' => ' Name ' ,
' email ' => ' Email address '
));
$ v -> validate (); Isso introduz um novo conjunto de tags em seu arquivo de idioma de erro que se parece com {field} . Se você estiver usando uma regra como equals você pode acessar o segundo valor no arquivo de idioma incrementando o campo com um valor como {field1} .
Você pode reutilizar suas regras de validação para validar rapidamente dados diferentes com as mesmas regras usando o método withData:
$ v = new Valitron Validator ( array ());
$ v -> rule ( ' required ' , ' name ' )-> message ( ' {field} is required ' );
$ v -> validate (); //false
$ v2 = $ v -> withData ( array ( ' name ' => ' example ' ));
$ v2 -> validate (); //true O conjunto de testes depende do autoloader do Composer para carregar e executar os arquivos Valitron. Certifique-se de ter baixado e instalado o Composer antes de executar os testes:
curl -s http://getcomposer.org/installer | phpphp composer.phar installphpunit git checkout -b my-new-feature )phpunit )git commit -am 'Added some feature' )git push origin my-new-feature )Para relatar uma vulnerabilidade de segurança, use o contato de segurança da Tidelift. A Tidelift coordenará a correção e divulgação.
