Ir para o conteúdo

- - - - -

Validação De Campos Com Php


Criado por Jonatã Cioni', Nov 25 2011 11:04

2 respostas neste tópico
  • Por favor, faça o login para responder

#1 Jonatã Cioni'

Jonatã Cioni'
  • Jonatã Cioni'
  • Colaborador
  • 2 Revisões

Revisou 25 novembro 2011 - 11:04

tah tudo bem comentado e explicado, mais... qualquer duvida... é só perguntar...

ah... e preste atenção aos comentarios iniciais que tem instruções de utilização... tah bem explicado tb...

espero poder ajudar alguém...

/*
* Função para validação de campos v1.1
* Autor: Jonatã Luiz Cioni
* Argumento unico array $campos
* modo de usar: testaCampos(array('name_do_input_a_ser_validado' => array("Legenda que aparecera para o usuario, em caso de algum erro","tipo_do_campo")
*
* tipos que podem ser setados:
* string = em caso do campo somente puder ser digitado LETRAS
* inteiro = em caso do campo somente puder ser digitado NUMEROS
* email = validação para campo de email
* telefone = validação para campo de teleofne no formato: (000)0000-0000
* cep = validação de CEP no formato: 00000-000
* cpf_num = validação de CPF no formato: 00000000000
* cpf_num_ponto = validação de CPF no formato 000.000.000-00
*/
function ValidaFormulario(array $campos){
	//seta as variaveis que armazenarão os erros e define elas como array
	$camposVazios = array();
	$camposErrados = array();
	//faz uma foreach para pegar os campos e valida-los
	foreach($campos as $campo => $itens){
		//verifica se o campo da que esta sendo verificado no loop esta vazio
		if(empty($_POST[$campo])){
			$camposVazios[] = strtoupper($itens[0])."<br/>";
		}
		//se não estiver vazio, verifica a compatibilidade dos dados digitados pelo usuario
		if(!empty($_POST[$campo])){
			//se tiver setado o tipo como string, a função valida-o como string
			if($itens[1] == 'string' && !preg_match("/^[a-zA-Z]+$/",$_POST[$campo])){
				$camposErrados[] = "No campo ".strtoupper($itens[0])." você só pode digitar letras<br/>";
			}
			//se tiver setado o tipo como inteiro, a função valida-o como inteiro
			if($itens[1] == 'inteiro' && !preg_match("/^[0-9]+$/",$_POST[$campo])){
				$camposErrados[] = "No campo ".strtoupper($itens[0])." você só pode digitar números<br/>";
			}
			//se tiver setado o tipo como email, a função valida-o como email
			if($itens[1] == 'email' && !preg_match("/^[a-z0-9_\.\-]+@[a-z0-9_\.\-]*[a-z0-9_\-]+\.[a-z]{2,4}$/i",$_POST[$campo])){
				$camposErrados[] = "Digite um E-mail válido no campo ".strtoupper($itens[0])."<br/>";
			}
			//se tiver setado o tipo como telefone, a função valida-o como telefone
			if($itens[1] == 'telefone' && !preg_match("/^\(\d{3}\)[\s-]?\d{4}-\d{4}$/",$_POST[$campo])){
				$camposErrados[] = "Digite o formato correto no campo ".strtoupper($itens[0])." => Correto: (000)0000-0000<br/>";
			}
			//se tiver setado o tipo como cep, a função valida-o como cep
			if($itens[1] == 'cep' && !preg_match("/^[0-9]{5}([-][0-9]{3})$/",$_POST[$campo])){
				$camposErrados[] = "Digite o formato correto no campo ".strtoupper($itens[0])." => Correto: 00000-000<br/>";
			}
			//se tiver setado o tipo como cpf_num, a função valida-o como cpf_num
			if($itens[1] == 'cpf_num' && !preg_match("/^[0-9]{11}$/",$_POST[$campo])){
				$camposErrados[] = "Digite o formato correto no campo ".strtoupper($itens[0])." => Correto: 00000000000<br/>";
			}
			//se tiver setado o tipo como cpf_num_ponto, a função valida-o como cpf_num_ponto
			if($itens[1] == 'cpf_num_ponto' && !preg_match("/^[0-9]{3}\.[0-9]{3}\.[0-9]{3}\-[0-9]{2,2}$/",$_POST[$campo])){
				$camposErrados[] = "Digite o formato correto no campo ".strtoupper($itens[0])." => Correto: 000.000.000-00<br/>";
			}
		}
	}
	//se tiver algum tipo de rro ou campo vazio, entra no if...
	if(count($camposVazios) > 0 || count($camposErrados) > 0){
		//se tiver algum campo vazio... mostra-os
		if(count($camposVazios) > 0){
			$retorno.= "Os seguintes campos Obrigatórios estão vazios:<br/>".implode("",$camposVazios);
		}
		//se tiver campos vazios e campos com erro... pula uma linha para não ficar tudo muito junto
		if(count($camposVazios) > 0 && count($camposErrados) > 0){
			$retorno.= '<br/>';
		}
		//se tiver campos com erros... mostra-os
		if(count($camposErrados) > 0){
			$retorno.= "Ocorreram os seguintes erros:<br/>".implode("",$camposErrados);
		}
	//...se não tiver nenhum erro e nenhum campo vazio... entra no else...
	}else{
		$retorno = 0;
	}
	return $retorno;
}


#2 Bruno_BRO

Bruno_BRO
  • Bruno_BRO
  • Colaborador
  • 1 Revisões

Revisou 08 janeiro 2012 - 22:28

Uma outra forma seria utilizando as funções: ctype, filter_var.
Criei a classe abaixo utilizando essas funções.

Exemplo de utilização:

index.htm

<form method="post" action="verifica.php">
 <input type="entry" nome="nome" />
 <input type="entry" nome="idade" />
 <input type="submit" value="Enviar" />
</form>


verifica.php

<?php
include('ValidationFormServer.class.php');

$verifica = new ValidationFormServer();
$verifica->setMethod('nome','Alpha');
$verifica->setMethod('idade', 'Numeric');

$mensagens = "";

foreach ($_POST as $campo => $valor)
{
   $mensagens .= $verifica->check($campo, $valor);
}

print $mensagens;
?>

Classe de verificação


ValidationFormServer.class.php

<?php
/**
*  Esta classe tem o objetivo de vericar o preenchimento de determinados campos de um formulario
*  no lado do Servidor.
*  Aqueles campos que tiverem problemas de preenchimento serao exibidos novamente
* 
*  @author Bruno R. de Oliveira
*  @version 1.0
*  @copyright 2010 Bruno R. de Oliveira
*  @see http://br.php.net/manual/pt_BR/book.ctype.php , http://br.php.net/manual/pt_BR/function.filter-var.php
*/

class ValidationFormServer
{

      private $fields; #campos adicionados e suas respectivas mensagens
      private $fieldsRequired; #array com os campos que devem ser preenchidos
      private $fieldsEmail; #array com os campos que devem ter formato de e-mail
      private $fieldsEmailNull;
      private $fieldsAlphaNumeric; #array com os campos que devem ter formato Alfa-numéricos (letras e números)
      private $fieldsAlphaNumericNull;
      private $fieldsAlpha; #array com os campos que devem ter formato Alfa (somente letras)
      private $fieldsAlphaNull;
      private $fieldsNumeric; #array com os campos que devem ter formato numérico
      private $fieldsNumericNull;
      private $fieldsNull; #campos que não precisam ser preenchidos
      
      function __construct()
      {
            $this->fields = array();
            $this->fieldsRequired = array();
            $this->fieldsEmail = array();
            $this->fieldsEmailNull = array();
            $this->fieldsAlphaNumeric = array();
            $this->fieldsAlphaNumericNull = array();
            $this->fieldsAlpha = array();
            $this->fieldsAlphaNull = array();
            $this->fieldsNumeric = array();
            $this->fieldsNumericNull = array();
            $this->fieldsNull = array();
      }
            
      /**
       * Adiciona um metodo de verificacao
       * @param string $field = nome do campo no formulário
       * @param string $method = metodo de verificacao desta classe
       */
      public function setMethod($field, $method)
      {
            $this->fields[] = $field;
            $this->{'method' . $method}($field);
      }
      
      /**
       * Retorna os métodos de validação disponíveis
       * Será utilizado na classe TField
       * 
       * @return array
       */
      static function getType()
      {
      	return array('Required', 'Email', 'EmailNull', 'AlphaNumeric', 'AlphaNumericNull', 'Alpha', 'AlphaNull', 'Numeric', 'NumericNull', 'Null');	
      }
      
      /**
      * Adiciona ao Metodo de verificacao de preenchimento
      * @param string $field
      */
      private function methodNull($field)
      {
      	$this->fieldsNull[] = $field->getName();
      }
      
      /**
       * Adiciona ao Metodo de verificacao de preenchimento
       * @param string $field
       */
      private function methodRequired($field)
      {
            $this->fieldsRequired[] = $field->getName();
      }
      
      /**
       * Adiciona ao Metodo de verificacao de e-mail
       * @param string $field
       */
      private function methodEmail($field)
      {
      	$this->fieldsEmail[] = $field->getName();
      }
    
      /**
       * Adiciona ao Metodo de verificacao de e-mail mas que pode ser fazio
       * @param string $field
      */
      private function methodEmailNull($field)
      {
      	$this->fieldsEmailNull[] = $field->getName();
      }
      
      /**
       * Adiciona ao Metodo de verificacao anfanumurica
       * @param string $field
       */
      private function methodAlphaNumeric($field)
      {
      	$this->fieldsAlphaNumeric[] = $field->getName();
      }
        
      /**
       * Adiciona ao Metodo de verificacao anfanumurica
       * @param string $field
      */
      private function methodAlphaNumericNull($field)
      {
      	$this->fieldsAlphaNumericNull[] = $field->getName();
      }
      
      /**
      * Adiciona ao Metodo de verificacao Alpha
      * @param string $field
      */
      private function methodAlpha($field)
      {
      	$this->fieldsAlpha[] = $field->getName();
      }
 
      /**
       * Adiciona ao Metodo de verificacao Alpha
       * @param string $field
      */
      private function methodAlphaNull($field)
      {
      	$this->fieldsAlphaNull[] = $field->getName();
      }
      
      /**
       * Adiciona ao Metodo de verificacao numerica
       * @param string $field
       */
      private function methodNumeric($field)
      {
      	$this->fieldsNumeric[] = $field->getName();
      }

      /**
      * Adiciona ao Metodo de verificacao numerica
      * @param string $field
      */
      private function methodNumericNull($field)
      {
      	$this->fieldsNumericNull[] = $field->getName();
      }
      
      /**
       * Faz as checagens necessarias dos campos e retorna uma mensagem
       *
       * @return string
       */
      public function check($fieldName, $fieldValue)
      {
      	
        //armazena as mensagens
      	$mensagens = "";

      	//checa os campos que devem ser preenchidos
      	if (in_array($fieldName, $this->fieldsRequired))
      	{
      		if (empty($fieldValue))
      		{
      			$mensagens .= 'O campo ' . $fieldName . ' deve ser preenchido!<br/>';
      		}
      	}

      	//checa os campos com formato de e-mail
      	if (in_array($fieldName, $this->fieldsEmail))
      	{
      		if (filter_var($fieldValue, FILTER_VALIDATE_EMAIL) === false)
      		{
      			$mensagens .= 'O campo ' . $fieldName . ' deve estar no formato nome@dominio.aaa!<br/>';
      		}
      	}
      	
      	//checa os campos com formato de e-mail que pode estar vazio
      	if (in_array($fieldName, $this->fieldsEmailNull))
      	{
      		if ($fieldValue)
      		{
	      		if (filter_var($fieldValue, FILTER_VALIDATE_EMAIL) === false)
	      		{
	      			$mensagens .= 'O campo ' . $fieldName . ' deve estar no formato nome@dominio.aaa!<br/>';
	      		}
      		}
      	}

      	//checa os campos que devem ser alfanumericos
      	if (in_array($fieldName, $this->fieldsAlphaNumeric))
      	{
      		if (!ctype_alnum($fieldValue))
      		{
      			$mensagens .= 'O campo ' . $fieldName . ' deve conter letras ou n&uacute;meros!<br/>';
      		}
      	}
      	
      	//checa os campos que devem ser alfanumericos que pode estar vazio
      	if (in_array($fieldName, $this->fieldsAlphaNumericNull))
      	{
      		if ($fieldValue)
      		{
	      		if (!ctype_alnum($fieldValue))
	      		{
	      			$mensagens .= 'O campo ' . $fieldName . ' deve conter letras ou n&uacute;meros!<br/>';
	      		}
      		}
      	}
      	
      	//checa os campos que devem ser alfa (somente letras)
      	if (in_array($fieldName, $this->fieldsAlpha))
      	{
      		if (!ctype_alpha($fieldValue))
      		{
      			$mensagens .= 'O campo ' . $fieldName . ' deve conter apenas letras!<br/>';
      		}
      	}
      	
      	//checa os campos que devem ser alfa (somente letras) que pode estar vazio
      	if (in_array($fieldName, $this->fieldsAlphaNull))
      	{
      		if ($fieldValue)
      		{
	      		if (!ctype_alpha($fieldValue))
	      		{
	      			$mensagens .= 'O campo ' . $fieldName . ' deve conter apenas letras!<br/>';
	      		}
      		}
      	}

      	//checa os campos que devem ser numericos
      	if (in_array($fieldName, $this->fieldsNumeric))
      	{
      		if (!ctype_digit($fieldValue))
      		{
      			$mensagens .= 'O campo ' . $fieldName . ' deve conter apenas n&uacute;meros!<br/>';
      		}
      	}
      	
      	//checa os campos que devem ser numericos que pode estar vazio
      	if (in_array($fieldName, $this->fieldsNumericNull))
      	{
      		if ($fieldValue)
      		{
	      		if (!ctype_digit($fieldValue))
	      		{
	      			$mensagens .= 'O campo ' . $fieldName . ' deve conter apenas n&uacute;meros!<br/>';
	      		}
      		}
      	}

      	return $mensagens;
	}
}
?>


#3 Jonatã Cioni'

Jonatã Cioni'
  • Jonatã Cioni'
  • Colaborador
  • 2 Revisões

Revisou 09 janeiro 2012 - 15:28

nova versão ai pra quem estiver usando minha função...
mais explicada e add novas validações...

/**************************************
* Função para validação de campos v1.2
* Autor: Jonatã Luiz Cioni
* Argumento unico array $campos
**************************************/
function ValidaFormulario(array $campos){
	//variaveis para armazenamento das mensagens
	$camposVazios = array();
	$camposErrados = array();
	$sucesso = true;
	$erro = '';
	
	// Faz um foreach em cada campo setado na função
	foreach($campos as $campo => $itens){
		// Se o campo estiver vazio, armazena a legenda do campo q esta vazio
		if(empty($_POST[$campo])){
			$camposVazios[] = strtoupper($itens[0])."<br/>";
		}
		// se estiver setado o tipo de dado, a função validará de acordo com o q foi pedido na função
		// OBS IMPORTANTE: SE O CAMPO FOR ALFANUMERICO, NÃO COLOQUE TIPO NENHUM, POIS SÓ PRECISARA VALIDAR SE ESTA VAZIO
		if(!empty($_POST[$campo]) && array_key_exists('tipo',$itens)){
			// Se for do tipo string, não aceitará letras
			if($itens['tipo'] == 'string' && !preg_match("/^[a-zA-Z]+$/",$_POST[$campo])){
				$camposErrados[] = "No campo ".strtoupper($itens[0])." voce só pode digitar letras<br/>";
			}
			// Se for do tipo inteiro, só aceitará numeros
			if($itens['tipo'] == 'inteiro' && !preg_match("/^[0-9]+$/",$_POST[$campo])){
				$camposErrados[] = "No campo ".strtoupper($itens[0])." voce só pode digitar números<br/>";
			}
			// tipo para comparação de dados com outro campo, consta no exemplo duas vezes...
			if($itens['tipo'] == 'igualdade' && strlen($_POST[$campo]) != strlen($_POST[$itens['compara']])){
				$camposErrados[] = "Os campos ".strtoupper($itens[0])." e ".strtoupper($itens['legenda_2'])." tem que ser iguais<br/>";
			}
			// valida o e-mail
			if($itens['tipo'] == 'email' && !preg_match("/^[a-z0-9_\.\-]+@[a-z0-9_\.\-]*[a-z0-9_\-]+\.[a-z]{2,4}$/i",$_POST[$campo])){
				$camposErrados[] = "Digite um E-mail válido no campo ".strtoupper($itens[0])."<br/>";
			}
			// valida o formato do telefone com DDD de 3 digitos
			if($itens['tipo'] == 'ddd_telefone' && !preg_match("/^\(\d{3}\)[\s-]?\d{4}-\d{4}$/",$_POST[$campo])){
				$camposErrados[] = "Digite o formato correto no campo ".strtoupper($itens[0]).", correto: (000)0000-0000<br/>";
			}
			// valida DD com 3 numeros, pois tem usuario que teima em colocar somente dois digitos, quando nós queremos os 3			
			if($itens['tipo'] == 'ddd_3' && !preg_match("/^\d{3}$/",$_POST[$campo])){
				$camposErrados[] = "Digite o formato correto no campo ".strtoupper($itens[0]).", correto: 000<br/>";
			}
			// valida o numeros do telefone sem o DDD
			if($itens['tipo'] == 'telefone' && !preg_match("/^\d{4}-\d{4}$/",$_POST[$campo])){
				$camposErrados[] = "Digite o formato correto no campo ".strtoupper($itens[0]).", correto: 0000-0000<br/>";
			}
			// valida o CEP sem o traço
			if($itens['tipo'] == 'cep_num' && !preg_match("/^\d{5}$/",$_POST[$campo])){
				$camposErrados[] = "Digite o formato correto no campo ".strtoupper($itens[0])." correto: 00000000<br/>";
			}
			// valida o CEP com o traço
			if($itens['tipo'] == 'cep' && !preg_match("/^\d{5}-\d{3}$/",$_POST[$campo])){
				$camposErrados[] = "Digite o formato correto no campo ".strtoupper($itens[0])." correto: 00000-000<br/>";
			}
			// valida o tamanho do CPF
			if($itens['tipo'] == 'cpf_num' && !preg_match("/^\d{11}$/",$_POST[$campo])){
				$camposErrados[] = "Digite o formato correto no campo ".strtoupper($itens[0])." correto: 00000000000<br/>";
			}
			// valida o tamanho e o formato do CPF
			if($itens['tipo'] == 'cpf_separators' && !preg_match("/^\d{3}.\d{3}.\d{3}-\d{2}$/",$_POST[$campo])){
				$camposErrados[] = "Digite o formato correto no campo ".strtoupper($itens[0])." correto: 000.000.000-00<br/>";
			}
			// valida o tamanho do CNPJ, com o novo formato, de 15 digitos
			if($itens['tipo'] == 'cnpj_num' && !preg_match("/^\d{15}$/",$_POST[$campo])){
				$camposErrados[] = "Digite o formato correto no campo ".strtoupper($itens[0])." correto: 000000000000000<br/>";
			}
			// valida o formato e o tamanho do CNPJ já com o novo formato do CNPJ
			if($itens['tipo'] == 'cnpj_separators' && !preg_match("/^\d{3}.\d{3}.\d{3}/\d{4}-\d{2}$/",$_POST[$campo])){
				$camposErrados[] = "Digite o formato correto no campo ".strtoupper($itens[0])." correto: 000.000.000/0000-00<br/>";
			}
		}
	}
	// verifica se houve algum erro
	if(count($camposVazios) > 0 || count($camposErrados) > 0){
		// se houve, mostra a mensagem com as legendas dos campos e os tipo de erro
		if(count($camposVazios) > 0){
			$erro.= "Os seguintes campos Obrigatórios estăo vazios:<br/>".implode("",$camposVazios);
		}
		if(count($camposVazios) > 0 && count($camposErrados) > 0){
			$erro.= '<br/>';
		}
		if(count($camposErrados) > 0){
			$erro.= "Ocorreram os seguintes erros:<br/>".implode("",$camposErrados);
		}
		return $erro;
	}else{
		// se não retorna true
		return $sucesso;
	}
}

modo novo de utilizar, prestem atenção q tem varias modificações:
<?php
if($_GET['teste'] == 'teste'){
	//exemplo:
	$validacao = ValidaFormulario(array(
		'nome' => array('Nome'),
		'endereco' => array('Endereço'),
		'email' => array('E-mail', 'tipo' => 'email'),
		'email_confirme' => array('Confirme seu E-mail', 'tipo' => 'igualdade', 'compara' => 'email', 'legenda_2' => 'E-mail'),
		'login' => array('Login'),
		'senha' => array('Senha'),
		'senha_confirme' => array('Repita a Senha', 'tipo' => 'igualdade', 'compara' => 'senha', 'legenda_2' => 'Senha'),
	));
	
	if($validacao === true)
	{
		echo 'sucesso';
	}
	else
	{
		echo $validacao;
	}
	//fim do exemplo
}
?>
<form method="post" id="formulario" name="formulario" enctype="multipart/form-data" action="?teste=teste">
	Nome: <input type="text" name="nome" id="nome" value="<?php echo $_POST['nome'];?>" /></br>
	Endereço: <input type="text" name="endereco" id="endereco" value="<?php echo $_POST['endereco'];?>" /></br>
	E-mail: <input type="text" name="email" id="email" value="<?php echo $_POST['email'];?>" /></br>
	Confirme E-mail: <input type="text" name="email_confirme" id="email_confirme" value="<?php echo $_POST['email_confirme'];?>" /></br>
	Login: <input type="text" name="login" id="login" value="<?php echo $_POST['login'];?>" /></br>
	Senha: <input type="text" name="senha" id="senha" value="<?php echo $_POST['senha'];?>" /></br>
	Confirme Senha: <input type="text" name="senha_confirme" id="senha_confirme" value="<?php echo $_POST['senha_confirme'];?>" /></br>
    
	<input type="submit" name="mandar" id="mandar" value="Testar Campos" />
</form>





1 usuário(s) está(ão) lendo este código

1 membro(s), 0 visitante(s) e 0 membros anônimo(s)