«

»

nov 30

Construindo uma classe em PHP para validação de dados de entrada

Em uma aplicação Web dinâmica, as entradas de dados (formulários, Web Services, importação de arquivos) são responsáveis por alimentar e manter atualizada a nossa base de dados, ao mesmo tempo, essas entradas podem ser uma porta aberta para dados mal formatados, ataques do tipo script injection ou qualquer outro tipo de sujeira.

Nesse post iremos construir uma classe de validação que será capaz de filtrar, validar e criticar os dados de entrada de uma aplicação, garantindo a integridade dos dados e impedindo ataques.

Requerimentos

Para facilitar o entendimento do código abaixo, aconselho a leitura da documentação da classe Exception e das funções isset, strlen, str_replace, is_numeric, mb_detect_encoding, htmlentities, html_entity_decode, nl2br, strip_tags no site www.php.net.

1º Passo – Criando uma classe de tratamento de erros

Iremos criar uma classe para gerenciar os erros e exceções geradas por nossas classes principal e secundária e para que ela funcione adequadamente, deverá ser herdeira da classe Exception (nativa do PHP).

class DDException extends Exception
{
	
}

Você deve estar se perguntando “Por que não usar a classe Exception, já que a classe herdeira não tem nada implementado?”. Minha resposta é “Se em algum momento quisermos adicionar algum controle de erros ainda não implementado na classe Exception, basta modificar a classe DDException e tudo será resolvido”.

2º Passo – Implementando classe de gerenciamento dos dados a serem validados

Essa será a classe principal, ela será usada para armazenar e gerenciar os nossos dados

class DDDataValidation
{
	private $v_data_values;
	private $v_data_itens_object;

	//constantes de charset
	const UTF_8 = 1;
	const ISO_8859_1 = 2;
	
	//constantes para formato de data
	const DATE_EN = 1;
	const DATE_BR = 2;
	
	//constantes de erro
	const ErrorEmpty = 1;
	const ErrorNumeric = 2;
	const ErrorMaximum = 3;
	const ErrorMinimum = 4;
	const ErrorCPF = 5;
	const ErrorEmail = 6;
	const ErrorDate = 7;
	
	function __construct()
	{
		$this->v_data_values = array();
		$this->v_data_itens_object = array();
	}
	
	/**
	* Adiciona dados para ser validados
	* 
	* @param string $st_alias - Alias definido pelo desenvolvedor para fazer referencia ao dado
	* @param mixed $mx_data - Dado a ser validado
	*/
	public function setData($st_alias,$st_value)
	{
		$this->v_data_values[$st_alias] = $st_value;
		$this->v_data_itens_object[$st_alias] = new DDDataValidationItem(addslashes($st_value));
	}
	
	/**
	* Retorna um objeto contendo dados a serem validados
	* 
	* @param string $st_alias - Alias definido pelo desenvolvedor para fazer referencia ao dado
	* @return DDDataValidationItem
	* @throws DDException
	*/
	public function getData($st_alias)
	{
		if(isset($this->v_data_itens_object[$st_alias]))
			return $this->v_data_itens_object[$st_alias];
		else
			throw new DDException('Alias '.$st_alias.' not found');
	}

	/**
	* Retorna os dados sem nenhuma modificação
	* 
	* @param string $st_alias - Alias definido pelo desenvolvedor para fazer referencia aos dados
	* @throws DDException
	*/
	public function getOriginal($st_alias)
	{
		if(isset($v_campos[$st_alias]))
			return $v_data_values[$st_alias];
		else
			throw new DDException('Alias '.$st_alias.' not found');
	}
	
	/**
 	* Retorna a quantidade de erros, idenpendente
 	* do alias referente ao campo
 	* 
 	* @return integer
	*/
	public function countErrors()
	{
		foreach($this->v_data_itens_object AS $data_objects)
			$in_errors += $data_objects->countErrors();
		return $in_errors;
	}
}

3º Passo – Implementando classe responsável pelos filtros

Nesse momento, iremos implementar uma classe secundária. Ela será responsável por encapsular o dado propriamente dito e por executar os métodos de restrição, filtro e conversão dos dados.

class DDDataValidationItem
{
	private $mx_value;
	private $v_error;
	private $v_boolean_error;
	
	/**
	* O valor do dado pode ser definidos ou não
	* 
	* @param mixed $mx_value
	*/
	function __construct($mx_value = null)
	{
		if($mx_value != null)
			$this->set($mx_value);
	}
	
	
	/**
	* Recebe o dado à ser validado
	* 
	* @param mixed $mx_value
	*/
	public function set($mx_value)
	{
		$this->mx_value = $mx_value;
	}
	
	/**
	* Retorna o dado validado
	* 
	* @return mixed
	*/
	public function get()
	{
		return $this->mx_value;
	}
	
	/**
	* Retorna, se houver, o erro referente ao alias de verficação
	* 
	* @param flag $mx_erro_code
	* 	Use DDDataValidation::ErrorEmpty - retorna o erro de preenchimento do campo
	*		DDDataValidation::ErrorNumeric - retorna o erro da validação de numero
	*		DDDataValidation::ErrorMaximum - retorna o erro da validação de quantidade de caracteres
	*		DDDataValidation::ErrorMinimum - retorna o erro da validação de quantidade de caracteres
	*		DDDataValidation::ErrorCPF - retorna o erro da validação de CPF 
	*		DDDataValidation::ErrorEmail - retorna o erro da validação de e-mail
	*		DDDataValidation::ErrorDate - retornar o erro da validação de data	
	*
	* @return string
	*/
	public function getErrorMsg($mx_erro_code)
	{
		if(isset($this->v_error[$mx_erro_code]))
			return $this->v_error[$mx_erro_code];
		else
			return new DDValidationItem();
		return $this->v_error[$mx_erro_code];
	}
	
	/**
	* Retorna o último erro ocorrido
	* 
	* @return string
	*/
	public function getLastErrorMsg()
	{
		$st_message = end($this->v_error);
		if(isset($st_message))
			return $st_message;
	}
	
	
	/**
	* Retorna o primeiro erro ocorrido
	* 
	* @return string
	*/
	public function getFirstErrorMsg()
	{
		$st_message = reset($this->v_error);
		if(isset($st_message))
			return $st_message;
	}
	
	
	/**
	* Retorna positivo se houver erro e nega
	*
	* @param mixed $mx_erro_code - Alias de referencia do campo
	* @return boolean
	*/
	public function getError($mx_erro_code)
	{
		if(isset($this->v_boolean_error[$mx_erro_code]))
			return $this->v_boolean_error[$mx_erro_code];
	}
	
	/**
	* Retorna todos os erros, separados apenas pelo delimitador
	* 
	* @param character $ch_delimiter - Delimitador
	* @return string
	*/
	public function getAllErrosMessages($ch_delimiter = ' - ')
	{
		foreach($this->v_error AS $st_error)
			if(isset($st_all_error))
				$st_all_error .= $ch_delimiter.$st_error;
			else
				$st_all_error .= $st_error;
		return $st_all_error;	
	}
	
	/**
	* Retorna a quantidade de erros gerados para aquele campo
	* 
	* @return integer
	*/
	public function countErrors()
	{
		return count($this->v_error);
	}
	
	
	/************************/
	/* Métodos de restrição */
	/************************/
	
	/**
	* Verifica se o dado passado está vazio
	* 
	* @param string $st_message - Mensagem de erro
	* @param mixed $mx_error_code - Código de erro, pode ser personalizado
	* @return DDDataValidationItem
	*/
	public function isEmpty( $st_message = null, $mx_error_code = DDDataValidation::ErrorEmpty )
	{
		$mx_value = $this->trim()->get();
		if(!(strlen($mx_value) > 0))
		{
			if($st_message != null)
				$this->v_error[$mx_error_code] = $st_message;
			$this->v_boolean_error[$mx_error_code] = TRUE;
		}		
		return $this;	
	}
	
	/**
	* Verifica se o dado passado é um numero
	* 
	* @param string $st_message - Mensagem de erro
	* @param mixed $mx_error_code - Código de erro, pode ser personalizado
	* @return DDDataValidationItem
	*/
	public function isNumeric( $st_message = null, $mx_error_code = DDDataValidation::ErrorNumeric )
	{
		$mx_value = $this->trim()->get();
		$mx_value = str_replace(',', '.', $mx_value);
		if(!(is_numeric($mx_value)))
		{
			if($st_message != null)
				$this->v_error[$mx_error_code] = $st_message;
			$this->v_boolean_error[$mx_error_code] = TRUE;
		}
		return $this;
	}
	
	/**
	* Verifica se o dado passado tem quantidade de
	* caracteres acima do limite passado como parametro
	* 
	* @param integer $in_max_caracter_count - Quantidade máxima de caracteres
	* @param string $st_message - Mensagem de erro
	* @param mixed $mx_error_code - Código de erro, pode ser personalizado
	* @return DDDataValidationItem
	* @throws DDException
	*/
	public function isMaximum( $in_max_caracter_count , $st_message = null , $mx_error_code = DDDataValidation::ErrorMaximum )
	{
		if(is_int($in_max_caracter_count))
		{
			if((strlen($this->mx_value) >= $in_max_caracter_count))
			{
				if($st_message != null)
					$this->v_error[$mx_error_code] = $st_message;
				$this->v_boolean_error[$mx_error_code] = TRUE;
			}
		}
		else
			throw new DDException('the variable in_max_caracter_count isn\'t numeric');
		return $this;			
	}
	
	/**
	* Verifica se o dado passado tem quantidade de
	* caracteres abaixo do limite passado como parametro
	* 
	* @param integer $in_min_caracter_count - Quantidade mínima de caracteres
	* @param string $st_message - Mensagem de erro
	* @param mixed $mx_error_code - Código de erro, pode ser personalizado
	* @return DDDataValidationItem
	* @throws DDException
	*/
	public function isMinimum( $in_min_caracter_count , $st_message = null , $mx_error_code = DDDataValidation::ErrorMinimum )
	{
		if(is_numeric($in_min_caracter_count))
		{
			if(strlen($this->mx_value) <= $in_min_caracter_count)
			{
				if($st_message != null)
					$this->v_error[$mx_error_code] = $st_message;
				$this->v_boolean_error[$mx_error_code] = TRUE;
			}
		}
		else
			throw new DDException('the variable in_min_caracter_count isn\'t numeric');
		return $this;
	}
	
	/**
	* Verifica se o dado é um CPF válido
	* 
	* @param string $st_message - Mensagem de erro
	* @param mixed $mx_error_code - Código de erro, pode ser personalizado
	* @return DDDataValidationItem
	*/
	public function isCPF( $st_message , $mx_error_code = DDDataValidation::ErrorCPF )
	{
		$st_cpf = $this->mx_value;
		$st_cpf = str_pad(ereg_replace('[^0-9]', '', $st_cpf), 11, '0', STR_PAD_LEFT);
		if 
		(
			strlen($st_cpf) != 11 ||
			$st_cpf == '00000000000' ||
			$st_cpf == '11111111111' ||
			$st_cpf == '22222222222' ||
			$st_cpf == '33333333333' ||
			$st_cpf == '44444444444' ||
			$st_cpf == '55555555555' ||
			$st_cpf == '66666666666' ||
			$st_cpf == '77777777777' ||
			$st_cpf == '88888888888' ||
			$st_cpf == '99999999999'
		)
			$this->v_error[$mx_error_code] = $st_message;
		else
			for ($t = 9; $t < 11; $t++)
			{ 
				for ($d = 0, $c = 0; $c < $t; $c++) 
					$d += $st_cpf{$c} * (($t + 1) - $c);
				
	
				$d = ((10 * $d) % 11) % 10;	
				if ($st_cpf{$c} != $d)
				{
					if($st_message != null)
						$this->v_error[$mx_error_code] = $st_message;
					$this->v_boolean_error[$mx_error_code] = TRUE;
				}	
			}	
		return $this;
	}
	
	/**
	* Verifica se o dado é um e-mail válido
	* 
	* @param string $st_message - Mensagem de erro
	* @param mixed $mx_error_code - Código de erro, pode ser personalizado
	* @return DDDataValidationItem
	*/
	public function isEmail( $st_message , $mx_error_code = DDDataValidation::ErrorEmail )
	{
		$st_email = $this->mx_value;
		$bo_valid = eregi
		(
			"^[0-9a-z]([-_.]?[0-9a-z])*@[0-9a-z]([-.]?[0-9a-z])*\\.[a-z]{2,3}$",
			$st_email,
			$check
		); 
		
		if(!$bo_valid)
		{
			if($st_message != null)
				$this->v_error[$mx_error_code] = $st_message;
			$this->v_boolean_error[$mx_error_code] = TRUE;
		}
		return $this;
	}
	
	/**
	* Verifica se o dado é uma data válida
	* @param integer $in_format - Usado para definir qual o formato da data
	* 		Use DDDataValidation::DATE_BR para formato DD/MM/AAAA
	* 		Use DDDataValidation::DATE_EN para formato AAAA/MM/DD
	* 
	* @param string $st_message - Mensagem de erro
	* @param mixed $mx_error_code - Código de erro, pode ser personalizado
	* @return DDDataValidationItem
	* @throws DDException
	*/
	public function isDate( $st_message = null , $in_format = DDDataValidation::DATE_BR , $mx_error_code = DDDataValidation::ErrorDate )
	{
		$dt_date = $this->mx_value;
		$v_date = preg_split('/[[:punct:]]/',$dt_date);		
		if( !is_numeric($v_date[0]) || !is_numeric($v_date[1]) || !is_numeric($v_date[2])  )
		{
			{
					if($st_message != null)
						$this->v_error[$mx_error_code] = $st_message;
					$this->v_boolean_error[$mx_error_code] = TRUE;
				}
			return $this;
		}
		
		if($in_format == DDDataValidation::DATE_BR)
		{
			$in_day = $v_date[0];
			$in_month =  $v_date[1];
			$in_year =  $v_date[2];
		}
		elseif($in_format == DDDataValidation::DATE_EN)
		{
			$in_day = $v_date[2];
			$in_month =  $v_date[1];
			$in_year =  $v_date[0];
		}
		else
			throw new DDException('Invalid value for variable $in_format');
		
		if (!checkdate( $in_month , $in_day , $in_year ))		
			$this->v_error[$mx_error_code] = $st_message;	
		return $this;
	}
	
	/*********************/
	/* Métodos de filtro */
	/*********************/
	
	/**
	* Retira, por padrão, caracteres de espaço ( ), tab (\t), retorno de carro (\r)
	* e quebra de linhas (\n) no inicio e no fim do dado. Pode ser personalizada 
	* usando a variável $st_characters
	* 
	* @param string $st_characters - Caracteres que devem ser retirados no inicio
	* 		e no fim do dado, o valor padrão é " \t\n\r"
	* 
	* @return DDDataValidationItem
	*/
	public function trim( $st_characters = " \t\n\r" )
	{
		$this->mx_value = trim( $this->mx_value , $st_characters );
		return $this;
	}
	
	/**
	* Retira, por padrão, todas as tags HTML encontradas no dado
	* 
	* @param string $allowable_tags - Use-a para permitir tags especificadas 
	* @return DDDataValidationItem
	*/
	public function noHTML( $allowable_tags = '' )
	{
		$this->mx_value = strip_tags($this->mx_value,$allowable_tags);
		return $this;
	}
	
	/**
	* Retira tudo que não for uma letra do alfabeto 
	* ou um numero de 0 a 9 do dado
	* 
	* @return DDDataValidationItem
	*/
	public function alphaNum()
	{
		$this->trim();
		$this->noHTML();
		$this->mx_value = ereg_replace("([[:punct:]]| )","",$this->mx_value);
		return $this;
	}
	
	/**
	* Retira tudo que não for um numero do dado
	* 
	* @return DDDataValidationItem
	*/
	public function numeric()
	{
		$this->trim();
		$this->noHTML();
		$this->mx_value = ereg_replace("([[:punct:]]|[[:alpha:]]| )","",$this->mx_value);
		return $this;
	}
	
	/************************/
	/* Métodos de conversão */
	/************************/
	
	
	/**
	* Converte uma data do formato Brasileiro Ex: 10/11/2011
	* 	para o formato Americano Ex: 2011/11/10 ou vice-versa
	* 
	* @param integer $f_actual_format - Especificar o formato atual da data
	* 	Use DDDataValidation::DATE_BR para formato Brasileiro
	* 	Use DDDataValidation::DATE_EN para formato Americano
	* @param integer $f_to_format - Especificar o formato de data desejado
	* 	Use DDDataValidation::DATE_BR para formato Brasileiro
	* 	Use DDDataValidation::DATE_EN para formato Americano
	* @param character $ch_delimiter - Especificar o caractere de separação
	* 	para dia mês e ano
	* @throws DDException
	*/
	public function convertDate($f_actual_format = DDDataValidation::DATE_BR , $f_to_format = DDDataValidation::DATE_EN , $ch_delimiter = '-' )
	{
		$dt_date = $this->mx_value;
		$v_date = preg_split('/[[:punct:]]/',$dt_date);
		
		if( !is_numeric($v_date[0]) || !is_numeric($v_date[1]) || !is_numeric($v_date[2])  )
			throw new DDException('this data isn\'t a valid date');
		
		if($f_actual_format != DDDataValidation::DATE_BR && $f_actual_format != DDDataValidation::DATE_EN)
			throw new DDException('$f_actual_format isn\'t a valid flag');
		
		if($f_to_format != DDDataValidation::DATE_BR && $f_to_format != DDDataValidation::DATE_EN)
			throw new DDException('$f_to_format isn\'t a valid flag');
		
		if($f_actual_format == DDDataValidation::DATE_BR)
		{
			$in_day = $v_date[0];
			$in_month =  $v_date[1];
			$in_year =  $v_date[2];
		}
		elseif($f_actual_format == DDDataValidation::DATE_EN)
		{
			$in_day = $v_date[2];
			$in_month =  $v_date[1];
			$in_year =  $v_date[0];
		}
	
		
		if (!checkdate( $in_month , $in_day , $in_year ))
			throw new DDException('this data isn\'t a valid date');
		
		
		if($f_to_format == DDDataValidation::DATE_BR)
			$this->mx_value = $in_day . $ch_delimiter . $in_month . $ch_delimiter . $in_year;			
		elseif($f_to_format == DDDataValidation::DATE_EN)
			$this->mx_value = $in_year . $ch_delimiter . $in_month . $ch_delimiter . $in_day;				
		return $this;
	}
	
	
	/**
	* Converte todos os caractéres especiais em suas
	* respectivas entidades HTML
	* 
	* @return DDDataValidationItem
	*/
	public function htmlEntities()
	{
		$this->mx_value = htmlentities($this->mx_value);
		return $this;
	}

	/**
	* Converte entidades HTML em seus respectivos
	* caracteres especiais
	* 
	* @return DDDataValidationItem
	*/
	public function htmlEntitiesDecode()
	{
		$this->mx_value = html_entity_decode($this->mx_value);
		return $this;
	}
	
	/**
	* Converte characteres de final de linha (\n) para
	* para a tag <br/> do HTML
	* 
	* @return DDDataValidationItem
	*/
	public function nlToBr()
	{
		$this->mx_value = nl2br($this->mx_value);
		return $this;
	}
	

	/**
	* seta o charset do dado
	* 
	* @param integer $in_actual_charset - Seta o charset atual do dado
	* 	Use DDDataValidation::ISO_8859_1 para ISO-8859-1
	* 	Use DDDataValidation::UTF-8 para UTF-8
	* @param integer $in_to_charset - Define o charset desejado
	* 	Use DDDataValidation::ISO_8859_1 para ISO-8859-1
	* 	Use DDDataValidation::UTF-8 para UTF-8
	* @return DDDataValidationItem
	* @throws DDException
	*/
	public function setCharset($in_actual_charset = DDDataValidation::ISO_8859_1 , $in_to_charset = DDDataValidation::UTF_8)
	{
		if($in_actual_charset != DDDataValidation::ISO_8859_1 && $in_actual_charset != DDDataValidation::UTF_8)
			throw new DDException('invalid actual charset variable'); 
		
		if($in_to_charset != DDDataValidation::ISO_8859_1 && $in_to_charset != DDDataValidation::UTF_8)
			throw new DDException('invalid to charset variable');
		
		if($in_actual_charset == DDDataValidation::UTF_8 && $in_to_charset == DDDataValidation::ISO_8859_1)
			$this->mx_value = utf8_decode($this->mx_value);
		
		if($in_actual_charset == DDDataValidation::ISO_8859_1 && $in_to_charset == DDDataValidation::UTF_8)
			$this->mx_value = utf8_encode($this->mx_value);
		return $this;
	}
}

Você deve está pensando “Nossa! Quanto código.“. Eu sei, é realmente muito código, mas ele será escrito apenas uma vez e usado milhares de vezes. Você só terá que mexer nele novamente se houver a necessidade de implementar um novo método ou fazer a manutenção em alguma parte do código. Resumindo, você só terá que entender o código (se você for um bom programador e não gosta de pegar código pronto na Internet) e aprender a usar.

4º Passo – Testando o código

Como teste, iremos usar nossa classe para validar um formulário. Veja o código em anexo abaixo.

<?php
//se o formulário foi enviado

require_once 'DDFormValidation.php';
$o_validation = new DDDataValidation();

//verificando se algo foi enviado
if(count($_POST))
{
	//encapsulando os dados
	$o_validation->setData('nome', $_POST['nome']);
	$o_validation->setData('email', $_POST['email']);
	$o_validation->setData('cpf', $_POST['cpf']);
	$o_validation->setData('data_nascimento', $_POST['data_nascimento']);
	
	//efetuando as validações
	
	//validando nome
	$o_validation->getData('nome')->isEmpty('Nome é obrigatório');
	
	//validando email
	$o_validation->getData('email')->isEmpty('E-mail é obrigatório');
	$o_validation->getData('email')->isEmail('E-mail inválido');
	
	//validando CPF
	$o_validation->getData('cpf')->isEmpty('CPF é obrigatório');
	$o_validation->getData('cpf')->isCPF('CPF inválido');
	
	
	//validando data de nascimento
	$o_validation->getData('data_nascimento')->isEmpty('Data de Nascimento é obrigatória');
	$o_validation->getData('data_nascimento')->isDate('Data de Nascimento inválida',DDDataValidation::DATE_BR);
	
	if($o_validation->countErrors() == 0)
		$st_mensagem =  'cadastrado com sucesso';
}	

	?>
<html>
<head>
<style>
body
{
font-family:"tahoma";
}
</style>
</head>
<body>
<div align=center>
	<br/>
	<br/>	
	<form method="post">
		<table>
			<tr>
				<td colspan="2" align="center" style="font-size: 30px;">
					DigitalDev Form				
				</td>
			</tr>
			<tr>
				<td>
					&nbsp;
				</td>
			</tr>
			<?php
			if(isset($st_mensagem))
			{ 
			?>
			<tr>
				<td colspan="2" align="center">
					<font color='red' size='4'><?php echo $st_mensagem?></font>
				</td>
			</tr>
			<?php
			} 
			?>
			<tr>
				<td align="right">
					Nome:
				</td>
				<td>
					<input type="text" name="nome" value="<?php echo $_POST['nome']?>" maxlength="40">
					<font size='2' color='red'>
						<?php echo $o_validation->getData('nome')->getErrorMsg(DDDataValidation::ErrorEmpty)?>
					</font>
				</td>
			</tr>			
			<tr>
				<td align="right">
					E-mail:
				</td>
				<td>
					<input type="text" name="email" maxlength="40" value="<?php echo $_POST['email']?>">
					<font size='2' color='red'>
						<?php echo $o_validation->getData('email')->getFirstErrorMsg()?>
					</font>
				</td>
			</tr>
			<tr>
				<td align="right">
					CPF:
				</td>
				<td>
					<input type="text" size="11" name="cpf" maxlength="14" value="<?php echo $_POST['cpf']?>">
					<font size='2' color='red'>
						<?php echo $o_validation->getData('cpf')->getFirstErrorMsg()?>
					</font>
				</td>
			</tr>
			<tr>
				<td align="right">
					Data de nascimento:
				</td>
				<td>
					<input type="text" size="10" name="data_nascimento" maxlength="10" value="<?php echo $_POST['data_nascimento']?>">
					<font size='2' color='red'>
						<?php echo $o_validation->getData('data_nascimento')->getFirstErrorMsg()?>
					</font>					
				</td>
			</tr>
			<tr>
				<td colspan="2" align="center">
					<button type="submit">Cadastrar</button>
				</td>
			</tr>
		</table>
	</form>	
</div>	
</body>
</html>

Faça o download do código fonte do exemplo acima clicando aqui.

Apesar dessa classe de validação de dados de entrada ser capaz de nos auxiliar na validação, filtro e conversão de dados de entrada, sempre irá existir situações em que ela não poderá nos auxiliar. Nessas situações o programador deverá efetuar manutenções no código ou implementar novos métodos.

Faça o download do código fonte da classe clicando aqui.

Artigos Relacionados

Construindo uma classe em PHP para conexão com Banco de Dados
SQL Injection, como evitar esse tipo de ataque em páginas PHP

Sobre o autor

Tarcísio

Bacharel em Engenharia da Computação, programador C / C++ , especialista em PHP, MySQL, PostgreSQL.

4 comentários

Pular para o formulário de comentário

  1. Elbert

    Parabéns, excelente artigo Tarcísio!

    Estou tentando testar o seu código mas não estou conseguindo, veja se pode me ajudar:

    Baixei o arquivo DDDataValidation.php e as funções de validação no meu form de acordo com o seu exemplo, mas inicialmente deu um erro, faltando o arquivo “DDFormValidation.php” descrito na linha 4 do seu formulario de entrada de dados. Eu achei que pudesse ser o “DDDataValidation.php” contendo as funções de validação do form, troquei mas não está validando os campos como esperado então não sei o que está errado!

    Aguardo retorno.
    Obrigado.

    Elbert.

    1. Tarcísio

      Qual é exatamente a mensagem do erro?

      1. José Ivan Marciano Junior

        Tarcísio tem uns errinhos ai na sua aplicação, por exemplo na hora de mostrar a mensagem de erro em cada campo, vc não trata se o não existe o objeto DDDataValidationItem… ai como ele está null, dá erro ao tentar buscar getErrorMsg.
        Eu arrumei aqui no meu.

        1. Tarcísio

          Obrigado por avisar José. Vou corrigir e subir uma nova versão.

Deixe uma dúvida, resposta ou sugestão