Validação

Limites observados na implementação

• required trata string vazia/null como ausente, mas a implementação não considera array vazio [] falha; para campos-array, não dependa apenas desta regra.
• Regras desconhecidas não produzem erro nesta implementação. Use somente as regras enumeradas e teste cada combinação.
• phone remove caracteres não numéricos e exige 10 ou 11 dígitos; não valida DDD nem estrutura de número brasileiro.
• mimes usa Fileinfo contra o mapa de MIME conhecido; para extensão fora desse mapa, o fallback verifica a extensão. A mensagem não deve ser interpretada como garantia de inspeção MIME para toda extensão customizada.
• Regras de arquivo leem estrutura de uploads; min/max significam KB. Campo ausente sem required não falha apenas por estar ausente.
• As mensagens padrão estão codificadas no Validator; mensagens customizadas por campo/regra são recurso de FormRequest::messages(), não API de Validator.
• Chamadas repetidas a validate() na mesma instância mantêm erros já acumulados; crie uma nova instância para um ciclo independente.

O Validator cobre validação de entrada; constraints de banco ainda são necessárias para unicidade e integridade concorrente. Consulte FormRequest e migrations.

Regras condicionais, confirmação e valores zero

As regras condicionais aceitam os formatos implementados pela string: required_if:campo,valor, required_unless:campo,valor, required_with:campo e required_without:campo. confirmed compara o campo com a chave irmã {campo}_confirmation; por exemplo, regra em password e input password_confirmation. Declare também regra de presença para o campo de confirmação se seu formulário precisar exigi-lo expressamente.

$rules = [
    'password' => 'required|min:8|confirmed',
    'password_confirmation' => 'required',
    'company_name' => 'required_if:account_type,company',
];

Na implementação atual, a regra required usa uma checagem de vazio baseada em empty(); a regra rejeita o número 0 como vazio, mas tem exceção explícita que aceita a string '0'. Para quantidades/flags em que zero é válido, valide presença/tipo separadamente ou use uma regra que represente explicitamente o domínio e teste esse caso.

FormRequest e arquivos

FormRequest não coleta automaticamente $_FILES. Para validar uploads, passe os arquivos diretamente a Validator::make($data, $rules, $_FILES) ou adapte explicitamente o request para usar setFiles($_FILES) antes de validar. Não assuma que uma regra file/image na classe basta sem fornecer os dados do upload.

Mensagens customizadas

O mapeamento do FormRequest só reconhece os nomes de regras cobertos explicitamente pela implementação de messageMatchesRule(). Mensagens de regras fora desse mapa não são automaticamente convertidas em mensagem customizada por esse mecanismo; nesse caso, use a mensagem padrão do Validator ou estenda o mapeamento no código, em vez de prometer que qualquer regra será traduzida.

Referência individual de todas as regras

Nos exemplos, considere use Framework\Support\Validator;. Uma regra aprovada não retorna true por si: ela não adiciona mensagem; erros são acumulados em errors() e consultados com passes()/fails(). Valores vazios e arquivos têm exceções descritas em cada entrada.

required

O que verifica: Exige que o valor não seja tratado como vazio pela implementação.

Sintaxe e parâmetros: Sem parâmetro.

Validator::make(['name' => 'Ana'], ['name' => 'required']);

Resultado e observações: A validação cria erro se o valor passar pela condição de vazio do PHP. A string ’0’ e o array vazio [] são exceções explícitas que passam; o inteiro 0 e false falham. Use nullable/required conscientemente; required não valida tipo nem estrutura interna.

nullable

O que verifica: Permite valor ausente/vazio e interrompe as demais regras desse campo.

Sintaxe e parâmetros: Sem parâmetro.

Validator::make(['nickname' => null], ['nickname' => 'nullable|alpha']);

Resultado e observações: Com null, string vazia, array vazio ou arquivo ausente, as demais regras são ignoradas. required_* é processada antes dessa saída e ainda pode exigir o campo. Não converte o valor nem remove a chave.

min:N

O que verifica: Impõe limite inferior inclusivo para comprimento de string ou valor numérico.

Sintaxe e parâmetros: N é o mínimo. O modo numérico só é ativado se a lista do mesmo campo também contiver numeric ou integer.

Validator::make(['name' => 'Ana'], ['name' => 'min:2']);

Resultado e observações: Para texto compara mb_strlen; no modo numérico compara float. O valor vazio é ignorado por esta regra; combine com required se obrigatório. Para upload, quando o campo também tem file/image/mimes, min passa a significar KB.

min_length:N

O que verifica: Alias de min para o mínimo de caracteres quando não há numeric/integer.

Sintaxe e parâmetros: N é o comprimento mínimo.

Validator::make(['name' => 'Ana'], ['name' => 'min_length:2']);

Resultado e observações: Usa a mesma implementação de min; com numeric/integer no mesmo campo também compara valor numérico, apesar do nome. Vazio é ignorado; combine com required.

max:N

O que verifica: Impõe limite superior inclusivo para comprimento de string ou valor numérico.

Sintaxe e parâmetros: N é o máximo. Modo numérico depende de numeric ou integer na mesma lista.

Validator::make(['name' => 'Ana'], ['name' => 'max:50']);

Resultado e observações: Texto usa mb_strlen; modo numérico compara float. Vazio é ignorado. Em campo de upload classificado por file/image/mimes, max significa KB do arquivo.

max_length:N

O que verifica: Alias de max para o máximo de caracteres quando não há numeric/integer.

Sintaxe e parâmetros: N é o comprimento máximo.

Validator::make(['name' => 'Ana'], ['name' => 'max_length:50']);

Resultado e observações: Compartilha a lógica de max; se numeric/integer estiver na mesma lista, compara valor numérico. Não impõe obrigatoriedade.

between:min,max

O que verifica: Exige valor/comprimento entre os limites, inclusive.

Sintaxe e parâmetros: min e max são separados por vírgula; o modo numérico depende de numeric/integer no campo.

Validator::make(['rating' => '4'], ['rating' => 'required|numeric|between:1,5']);

Resultado e observações: Para texto conta caracteres; para numeric/integer compara float. O método ignora vazio e parâmetro ausente. Em campo de arquivo, between não é uma regra de tamanho de arquivo: use min/max com regra de arquivo.

size:N

O que verifica: Exige comprimento ou valor exatamente igual a N.

Sintaxe e parâmetros: N é o tamanho/valor exato; numeric/integer no mesmo campo ativa comparação numérica.

Validator::make(['pin' => '1234'], ['pin' => 'required|digits:4|size:4']);

Resultado e observações: Sem numeric/integer, compara número de caracteres. Vazio é ignorado; combine com required. Em campo de upload, size não é roteada como regra de arquivo nesta implementação.

numeric

O que verifica: Aceita valor para o qual is_numeric() é true.

Sintaxe e parâmetros: Sem parâmetro.

Validator::make(['amount' => '12.50'], ['amount' => 'required|numeric']);

Resultado e observações: Não converte o dado, apenas testa. Vazio é ignorado; combine com required. Ao combinar numeric com min/max/between/size, essas regras usam comparação de valor numérico.

integer

O que verifica: Exige que filter_var(..., FILTER_VALIDATE_INT) reconheça inteiro.

Sintaxe e parâmetros: Sem parâmetro.

Validator::make(['quantity' => '3'], ['quantity' => 'required|integer|min:1']);

Resultado e observações: Não aceita decimal textual como 3.0. Não transforma a string em int. Também ativa modo numérico para min/max/between/size.

boolean

O que verifica: Restringe o valor a true, false, 0, 1, ’0’ ou ’1’.

Sintaxe e parâmetros: Sem parâmetro.

Validator::make(['accepted' => '1'], ['accepted' => 'required|boolean']);

Resultado e observações: A comparação usa lista estrita; strings como yes/on e inteiros diferentes não passam. null e string vazia são ignorados pela regra; use required quando a chave deve existir.

email

O que verifica: Valida e-mail por filter_var(FILTER_VALIDATE_EMAIL).

Sintaxe e parâmetros: Sem parâmetro.

Validator::make(['email' => 'ana@example.com'], ['email' => 'required|email']);

Resultado e observações: Vazio é ignorado, não é obrigatório por si só. Não confirma existência da caixa nem domínio; use verificação por e-mail separadamente se o fluxo exigir.

url

O que verifica: Valida URL por filter_var(FILTER_VALIDATE_URL).

Sintaxe e parâmetros: Sem parâmetro.

Validator::make(['site' => 'https://example.com'], ['site' => 'required|url']);

Resultado e observações: Vazio é ignorado. A regra é sintática; não acessa a URL nem garante disponibilidade ou segurança do destino.

ip

O que verifica: Valida endereço aceito por FILTER_VALIDATE_IP.

Sintaxe e parâmetros: Sem parâmetro.

Validator::make(['ip' => '2001:db8::1'], ['ip' => 'required|ip']);

Resultado e observações: Abrange IPv4/IPv6 conforme PHP. Vazio é ignorado; não prova que o endereço está alocado ou pertence ao cliente.

uuid

O que verifica: Exige formato hexadecimal 8-4-4-4-12, sem distinção de maiúsculas/minúsculas.

Sintaxe e parâmetros: Sem parâmetro.

Validator::make(['id' => '550e8400-e29b-41d4-a716-446655440000'], ['id' => 'required|uuid']);

Resultado e observações: A regex não verifica versão nem variante UUID; valida apenas a forma. Vazio é ignorado.

json

O que verifica: Exige uma string que json_decode consiga decodificar sem erro.

Sintaxe e parâmetros: Sem parâmetro.

Validator::make(['payload' => '{"ok":true}'], ['payload' => 'required|json']);

Resultado e observações: O valor precisa ser string não vazia; o literal JSON null é válido quando decodifica sem erro. Não retorna o objeto decodificado nem valida um schema.

alpha

O que verifica: Permite letras após remover espaços do valor.

Sintaxe e parâmetros: Sem parâmetro.

Validator::make(['first_name' => 'Ana Maria'], ['first_name' => 'required|alpha']);

Resultado e observações: Usa ctype_alpha sobre string convertida, após retirar espaços ASCII; acentos UTF-8 não são tratados por uma regra Unicode explícita. Não remova/persista a versão normalizada: a regra só valida.

alphanumeric

O que verifica: Permite letras/números depois de retirar espaços, sublinhados e hífens.

Sintaxe e parâmetros: Sem parâmetro.

Validator::make(['code' => 'AB-12_3'], ['code' => 'required|alphanumeric']);

Resultado e observações: A implementação aceita espaços, _ e - porque os remove antes de ctype_alnum; não é uma regra que exija que o texto original contenha somente caracteres alfanuméricos.

array

O que verifica: Exige que o valor não vazio seja um array PHP.

Sintaxe e parâmetros: Sem parâmetro.

Validator::make(['services' => ['email', 'sms']], ['services' => 'required|array']);

Resultado e observações: null e string vazia são ignorados pela regra; [] é array e passa em array, embora required também não rejeite [] nesta implementação. Valide os elementos com regras para chaves aninhadas somente se o Validator realmente as suportar; não há sintaxe wildcard documentada.

digits:N

O que verifica: Exige exatamente N caracteres numéricos, todos dígitos.

Sintaxe e parâmetros: N é a quantidade exata; apenas dígitos, sem sinal/decimal.

Validator::make(['code' => '1234'], ['code' => 'required|digits:4']);

Resultado e observações: Usa ctype_digit e mb_strlen. Preserva zeros à esquerda se o dado vier como string. Vazio é ignorado.

digits_between:min,max

O que verifica: Exige somente dígitos e comprimento entre limites inclusivos.

Sintaxe e parâmetros: min e max são quantidades separadas por vírgula.

Validator::make(['code' => '12345'], ['code' => 'required|digits_between:4,6']);

Resultado e observações: Não aceita sinais, espaços ou separador decimal; valida quantidade de caracteres, não magnitude. Vazio é ignorado.

date

O que verifica: Exige valor que strtotime() reconheça.

Sintaxe e parâmetros: Sem parâmetro.

Validator::make(['date' => '2026-09-30'], ['date' => 'required|date']);

Resultado e observações: strtotime aceita formatos relativos/amplos do PHP; a regra não exige um formato ISO específico. Combine com validação própria quando o formato exato importar.

time

O que verifica: Exige formato 24h HH:MM ou HH:MM:SS.

Sintaxe e parâmetros: Sem parâmetro.

Validator::make(['starts_at' => '13:45:00'], ['starts_at' => 'required|time']);

Resultado e observações: Regex limita horas 00–23 e minutos/segundos 00–59. Não aceita fuso ou frações. Vazio é ignorado.

after:campo

O que verifica: Exige que o timestamp do valor seja estritamente posterior ao de outro campo.

Sintaxe e parâmetros: campo é a chave de comparação dentro de $data.

Validator::make(['start' => '2026-09-30', 'end' => '2026-10-01'], ['start' => 'required|date', 'end' => 'required|date|after:start']);

Resultado e observações: Usa strtotime; igualdade falha. Se o outro campo estiver ausente/vazio ou uma das datas não puder ser convertida, esta regra não cria erro; associe date/time para validar formato.

before:campo

O que verifica: Exige que o timestamp do valor seja estritamente anterior ao de outro campo.

Sintaxe e parâmetros: campo é a chave de comparação em $data.

Validator::make(['start' => '2026-09-30', 'end' => '2026-10-01'], ['end' => 'required|date', 'start' => 'required|date|before:end']);

Resultado e observações: Usa strtotime; igualdade falha. Sem valor de comparação válido, não cria erro; combine com date/time.

cep

O que verifica: Verifica forma de CEP: cinco dígitos, hífen opcional, três dígitos.

Sintaxe e parâmetros: Sem parâmetro.

Validator::make(['cep' => '01234-567'], ['cep' => 'required|cep']);

Resultado e observações: Não consulta serviço postal nem confirma que o CEP existe. Vazio é ignorado.

uf

O que verifica: Aceita uma das 27 siglas brasileiras após converter o valor para maiúsculas.

Sintaxe e parâmetros: Sem parâmetro.

Validator::make(['state' => 'sp'], ['state' => 'required|uf']);

Resultado e observações: Aceita minúsculas devido a strtoupper; verifica lista fixa, não normaliza o valor devolvido. Vazio é ignorado.

phone

O que verifica: Remove tudo que não seja dígito e exige 10 ou 11 dígitos.

Sintaxe e parâmetros: Sem parâmetro.

Validator::make(['phone' => '(11) 91234-5678'], ['phone' => 'required|phone']);

Resultado e observações: Não valida DDD, país, prefixo móvel nem existência do número; apenas contagem após remoção de máscara. Vazio é ignorado.

confirmed

O que verifica: Compara o valor com a chave irmã {campo}_confirmation.

Sintaxe e parâmetros: Sem parâmetro; para password, usa password_confirmation.

Validator::make(['password' => 'senhaSegura', 'password_confirmation' => 'senhaSegura'], ['password' => 'required|confirmed']);

Resultado e observações: A comparação é estrita e a regra ignora valor vazio. Não exige que a chave de confirmação exista; declare required para ela quando necessário.

same:campo

O que verifica: Exige igualdade estrita com outra chave de $data.

Sintaxe e parâmetros: campo é a chave de comparação.

Validator::make(['password' => 'abc', 'repeat' => 'abc'], ['repeat' => 'required|same:password']);

Resultado e observações: Usa !==, sem coerção; string ’1’ e inteiro 1 diferem. Valor vazio no campo validado é ignorado.

different:campo

O que verifica: Exige que o valor seja estritamente diferente do campo indicado.

Sintaxe e parâmetros: campo é a chave de comparação.

Validator::make(['email' => 'a@example.com', 'backup' => 'b@example.com'], ['backup' => 'required|different:email']);

Resultado e observações: Usa === para detectar igualdade; sem coerção. Campo validado vazio é ignorado.

starts_with:a,b

O que verifica: Exige que o valor comece com pelo menos um prefixo da lista.

Sintaxe e parâmetros: a,b são prefixos separados por vírgula; não há trim dos itens.

Validator::make(['document' => 'DOC-42'], ['document' => 'required|starts_with:DOC-,REQ-']);

Resultado e observações: O valor compara com str_starts_with; qualquer prefixo basta. Lista vazia retorna válido; espaços em parâmetros contam literalmente.

ends_with:a,b

O que verifica: Exige que o valor termine com pelo menos um sufixo da lista.

Sintaxe e parâmetros: a,b são sufixos separados por vírgula; não há trim dos itens.

Validator::make(['file_name' => 'report.csv'], ['file_name' => 'required|ends_with:.csv,.xlsx']);

Resultado e observações: O valor compara com str_ends_with; qualquer sufixo basta. Lista vazia retorna válido; a regra não inspeciona conteúdo do arquivo.

in:a,b

O que verifica: Restringe o valor a um item da lista separada por vírgula.

Sintaxe e parâmetros: Itens seguem após dois-pontos e não são aparados de espaços.

Validator::make(['role' => 'member'], ['role' => 'required|in:member,admin']);

Resultado e observações: Usa in_array sem strict=true, portanto a comparação pode fazer coerção PHP. Vazio é ignorado. Para conjunto fixo crítico, normalize tipo e valores antes de validar.

not_in:a,b

O que verifica: Rejeita valores contidos na lista separada por vírgula.

Sintaxe e parâmetros: Itens seguem após dois-pontos; espaços são literais.

Validator::make(['status' => 'blocked'], ['status' => 'required|not_in:disabled,banned']);

Resultado e observações: Usa in_array não estrito, como in. Vazio é ignorado; não altera o dado.

regex:/.../

O que verifica: Testa valor por preg_match usando a expressão recebida.

Sintaxe e parâmetros: Parâmetro deve conter delimitadores válidos do PCRE, por exemplo /^ABC-[0-9]+$/.

Validator::make(['code' => 'ABC-123'], ['code' => 'required|regex:/^[A-Z]{3}-[0-9]{3}$/']);

Resultado e observações: Vazio é ignorado; o parser de regras divide por cada | sem parser de escape, então padrões com alternância | não são seguros na string de regras. Use delimitadores e escape corretamente; regex inválida não é convertida em erro de validação controlado.

required_if:campo,valor

O que verifica: Exige o campo quando outra chave está presente e seu valor em string coincide com o parâmetro.

Sintaxe e parâmetros: campo é a chave comparada; valor é comparado como string; separe por vírgula.

Validator::make(['account_type' => 'company', 'tax_id' => '123'], ['tax_id' => 'required_if:account_type,company']);

Resultado e observações: A comparação do valor de controle usa string; campo ausente/vazio não coincide. Avaliada antes de nullable. Não divide valores que contenham vírgula.

required_unless:campo,valor

O que verifica: Exige o campo quando outra chave não coincide com o valor informado.

Sintaxe e parâmetros: campo e valor são separados por vírgula.

Validator::make(['account_type' => 'company', 'tax_id' => '123'], ['tax_id' => 'required_unless:account_type,person']);

Resultado e observações: A ausência do campo de controle conta como não coincidência e torna o alvo obrigatório. Comparação por string; avaliada antes de nullable.

required_with:campo

O que verifica: Exige o campo-alvo quando o campo indicado estiver presente e não vazio.

Sintaxe e parâmetros: campo é uma chave em $data.

Validator::make(['company' => 'Acme', 'tax_id' => '123'], ['tax_id' => 'required_with:company']);

Resultado e observações: Presença significa isset e valor diferente de null/; zero e false contam como presentes. Avaliada antes de nullable.

required_without:campo

O que verifica: Exige o campo-alvo quando a chave indicada estiver ausente, null ou string vazia.

Sintaxe e parâmetros: campo é uma chave em $data.

Validator::make([], ['phone' => 'required_without:email']);

Resultado e observações: A ausência do outro campo dispara a obrigatoriedade. Zero/false contam como presentes; é avaliada antes de nullable. Para exigir ao menos um de dois campos, aplique a regra correspondente nos campos necessários.

unique:tabela,coluna[,id]

O que verifica: Verifica ausência de registro com o mesmo valor no banco.

Sintaxe e parâmetros: tabela é tabela literal; coluna é opcional (default: nome do campo); terceiro valor opcional ignora ID positivo usando coluna id.

Validator::make(['email' => 'novo@example.com'], ['email' => 'required|unique:users,email']);

Resultado e observações: Table/column são interpolados no SQL, não bindados/sanitizados: só constantes controladas pelo código. Valor vazio ignora a consulta. Não substitui índice UNIQUE e há race condition. O ignore é apenas terceiro item inteiro positivo e usa id literal; em update, informe unique:users,email,42.

exists:tabela,coluna

O que verifica: Verifica se há registro cujo valor da coluna coincide com o dado.

Sintaxe e parâmetros: tabela literal; coluna é opcional e por padrão id.

Validator::make(['user_id' => 1], ['user_id' => 'required|exists:users,id']);

Resultado e observações: Table/column são interpolados no SQL e devem ser fixos/controlados. Valor vazio ignora a consulta. Não cria foreign key e não protege contra remoção concorrente.

file

O que verifica: Exige upload PHP recebido com UPLOAD_ERR_OK e is_uploaded_file verdadeiro.

Sintaxe e parâmetros: Sem parâmetro; exige array individual em $files[$field].

Validator::make([], ['document' => 'required|file'], $_FILES);

Resultado e observações: Não pode ser validado com array inventado em teste simples: tmp_name precisa ser upload HTTP real. Sem required, ausência do arquivo não falha por si só; consulte erros PHP de upload.

image

O que verifica: Exige upload bem-sucedido cujo MIME real começa com image/.

Sintaxe e parâmetros: Sem parâmetro; arquivo vem de $files.

Validator::make([], ['avatar' => 'required|image'], $_FILES);

Resultado e observações: Fileinfo lê o MIME do arquivo real e não confia em $_FILES[type], mas não decodifica/regrava imagem nem garante conteúdo seguro. Para SVG, a política de armazenamento/serving continua sendo responsabilidade da aplicação.

mimes:jpg,png,...

O que verifica: Exige extensão enviada na lista e, para extensões conhecidas, MIME real compatível com whitelist.

Sintaxe e parâmetros: Extensões permitidas separadas por vírgula; espaços nas entradas são aparados.

Validator::make([], ['document' => 'required|mimes:pdf,docx|max:2048'], $_FILES);

Resultado e observações: Exige upload real. Extensões do MIME_MAP têm MIME validado; extensão fora do mapa cai apenas na checagem de extensão. Como file/image/mimes classifica o campo como upload, min/max passam a KB. A regra não move o arquivo.

Métodos públicos de Validator

Assinaturas e contratos dos métodos da classe base; os mecanismos internos privados não são API pública.

Construtor

Assinatura: public function __construct(array $data, array $files = []): void

Parâmetros: $data é o mapa de valores já extraídos; $files é opcional no formato PHP $_FILES.

Retorno: Retorno void; armazena os dois arrays na instância.

$v = new Validator($request->all(), $_FILES);

Observações: Não valida automaticamente; chame validate() ou use make().

setFiles()

Assinatura: public function setFiles(array $files): static

Parâmetros: $files substitui todo o mapa de arquivos atual, no formato $_FILES.

Retorno: Retorna a mesma instância para encadeamento.

$v->setFiles($_FILES)->validate($rules);

Observações: Não limpa os erros já acumulados nem altera os dados de formulário.

validate()

Assinatura: public function validate(array $rules): static

Parâmetros: $rules é mapa campo => string de regras separadas por |.

Retorno: Retorna $this; falhas são acumuladas em errors().

$v = (new Validator($data))->validate(['email' => 'required|email']);

Observações: Executa todas as regras e acumula todas as mensagens por campo; não existe método público stop-on-first. Chamadas repetidas reutilizam/acumulam erros.

make()

Assinatura: public static function make(array $data, array $rules, array $files = []): static

Parâmetros: $data e $rules são obrigatórios; $files é opcional.

Retorno: Cria new static($data, $files), valida e devolve a instância concreta.

$v = Validator::make($request->all(), $rules, $_FILES);

Observações: Factory equivalente a construir e chamar validate(); não devolve bool nem dados limpos.

passes()

Assinatura: public function passes(): bool

Parâmetros: Sem parâmetros.

Retorno: true quando a lista de erros está vazia.

if ($v->passes()) { /* seguir fluxo */ }

Observações: É o estado da instância após validação; não executa regras sozinho.

fails()

Assinatura: public function fails(): bool

Parâmetros: Sem parâmetros.

Retorno: Inverso de passes(): true quando há erros.

if ($v->fails()) { $errors = $v->errors(); }

Observações: Não altera erros nem executa uma nova validação.

errors()

Assinatura: public function errors(): array

Parâmetros: Sem parâmetros.

Retorno: Mapa array<string, list<string>>: chave do campo para uma lista de mensagens.

$emailErrors = $v->errors()['email'] ?? [];

Observações: Pode haver mais de uma mensagem para campo porque a validação não para no primeiro erro.

firstError()

Assinatura: public function firstError(?string $field = null): ?string

Parâmetros: $field é opcional; quando informado seleciona o campo.

Retorno: Primeira mensagem do campo ou a primeira mensagem global; null quando não há erro.

$message = $v->firstError('email');

Observações: Sem field percorre o primeiro bucket; string vazia é tratada como ausência do argumento por causa do if ($field).