PHP - Sobre a função filter_var()

Muitas pessoas desconhecem essa função de validação de dados, pois também, antés do PHP 5.2/PECL filter ela nem existia.

Vou descrever ela um pouco e mostrar exemplos de uso para a mesma.

filter_var() - Filtra uma variável com um filtro especificado.

Uso:

mixed filter_var ( mixed $variavel [, int $filtro [, mixed $opcoes ]] )

Os possíveis filtros você pode encontrar aqui: Constantes pré-definidades para a extensão filter

Exemplo:
Ao invés de você utilizar uma expressão regular ou algo do gênero (POG) para verificar um e-mail:

À maneira velha (preg_match()):
var_dump(preg_match('/\\b[A-Z0-9._%-]+@[A-Z0-9.-]+\\.[A-Z]{2,4}\\b/i’, “foo@bar.com”)); //1 ou seja TRUE

pode utilizar assim, com a filter_var():
var_dump(filter_var('foo@bar.com', FILTER_VALIDATE_EMAIL); //TRUE

Conclusão:

Para que eu vou usar uma expressão regular, se eu posso utilizar uma função construída só para isso?

Com a filter_var(), eu posso filtrar vários tipos de dados, desde verificar se a variável é do tipo $_POST até verificar se a variável é um IP válido.

Podem tentar validar com a filter_var_array(), caso queiram com dados de Array.

Para mais informações: Filter Functions Manual

Em caso de dúvidas, fórum WM Online.

Combinando melhor suas Arrays - PHP

Essa dica vai para quem precisa combinar uma ou mais arrays e quer manter os indices das mesmas, pois o array_merge() reordena os indices.

Exemplo:
<?php
$arr_1 = array();
$arr_2 = array(1 => “foo”);
print_r (array_merge($arr_1, $arr_2);
?>


Resultado será:

Array
(
[0] => data
)


“Ótemo” … perdeu o indice :B

Para resulver isto, vamos concatenar as arrays (sim, você pode concatená-las, utilizando opoerador +):

<?php
$arr_1 = array();
$arr_2 = array(1 => “foo”);
print_r (($arr_1 + $arr_2));
?>

Resultado será:

Array
(
[1] => data
)


Este exemplo mesmo está disposto no próprio manual do array_merge(), mas poucos tem vontade ir até o final e ler tudo certinho.

Uma cosia legal, que agora com o PHP5, você pode utilizar typecasting para juntar arrays com o array_merge()

<?php
$beginning = ‘foo’;
$end = array(1 => ‘bar’);
$result = array_merge((array)$beginning, (array)$end);
?>

Caso queira juntar arrays recursivamente, recomendo a função array_merge_recursive().

Simples assim

Pseudo Singleton Pattern com PHP5

Muita gente que programa com PHP5 Orientado a Objetos, sofre com o problema de reinstânciamento de classes ao longo de seus processos, como por exemplo, uma simples Conexão ao MySQL.

Visando este tipo de coisa, demonstro para vocês um exemplo de uma pseudo Singleton Pattern (php5 não suporta em toda sua essência, Java por exemplo aceita) . Afinal todo mundo sabe, que conexão persistente com o banco de dados é cafonérrimoooo, para saber, leia este artigo: Are PHP persistent connections evil?. O pessoal do suporte técnico do Onda me indicou o artigo (adoro quando provam que eu estou errado, assim tenho a oportunidade de aprender da maneira certa ).

Vamos ao que interessa:

No exemplo abaixo eu criei um front-end para gerenciar conexões utilizando a biblioteca ADODB para PHP.

<?php
/**
* @package controlller
* Classe de controle de conexão com o banco de dados.
* @author Julio Luiz <bfmaster_duran.at.yahoo.com.br>
*/
class Conexao {
private static $_instancia = null;
private $_conexao;
private $_bd = null;
private $_data = null;
private $_qtd;
private $_generated_key;
private $_arrValores = null;
private $_arrErros;
/**
* Construtor privado da classe, ou seja, somente a propria classe poderá acessar ele.
*/
private function __construct() {
$this->_newConnection();
}
/**
* Funcao que realiza uma nova conexao com o banco de dados.
*/
private function _newConnection() {
try {
$this->_conexao = &NewADOConnection(’mysqlt’); //Driver do ADODB p/ se trabalhar com mysql com suporte a transactions.
@$this->_conexao->Connect(”localhost”, “root”, “”, “”);
if ($this->_conexao->IsConnected()) {
$this->_conexao->SetFetchMode(ADODB_FETCH_ASSOC); //Setando o retorno das arrays de resultados para modo associativo, bem melhor trabalhar com arrays associativas.
} else
throw new Exception($this->_conexao->ErrorMsg());
} catch (Exception $err) {
$this->setErro($err->getMessage());
}
}
/**
* Pseudo Singleton Pattern para conexao,
* assim nao é necessário fazer uma nova conexão ou reinstanciar a classe ao longo dos processos.
* @author Julio Luiz <bfmaster_duran.at.yahoo.com>
* @return Conexao
*/
public static function getConexao() {
if (!isset(self::$_instancia)) {
$c = __CLASS__;
self::$_instancia = new $c;
}
return self::$_instancia;
}

Vocês não sabem (vão saber se utilizarem) o ganho de processamento que isto lhe dá, claro que eu dou um require_once na classe de conexão no arquivo que todas as classes/processos compartilham para eu nao ter que ficar buscando ele toda hora. :B~

Para chamar a conexão, eu faço simplesmente assim:

$conexao = Conexao::getConexao();
$conexao->executeQuery($SQL); //Esta funcao esta na classe mais abaixo, nao achei necessario por ela aqui.

Atualmente estou utilizando isto num projeto na empresa (utilizo ela faz uns 6 meses), antes a empresa não tinha algo como isto, então cada vez que precisava fazer consulta era uma nova conexão ao banco dados. Já imaginaram isso num ambiente multiusuário? (tá certo que nem em sonho os projetos iriam checar a este patamar, só um uns dois que estão atualmente sendo feitos nela).

Mais uma contribuição do meu conhecimento para o melhoramente do seu nível profissional ;D