CrisDev – Cristian Medeiros

Uma das grandes limitações do PHP5, na minha opnião, é não realizar o cast entre objetos. O PHP permite apenas cast entre tipos primitivos, ou no máximo um object standard, que na maior parte das vezes resolve o que você precisa, mas em um arquitetura mais elaborada isso não é aceito. Para programadores de outras linguagens OO isso é um verdadeiro martirio ou uma limitação imperdoável.

Porém podemos contornar essa falha utilizando um “caster” que nada mais faz do que retornar uma instancia do objeto necessario, caso nosso objeto não seja do tipo especificado:

private function caster($object, $requiredType)
{
    if(get_class($object) != $requiredType)
    {
        return new $requiredType;
    }
}

Com isso é possível que uma classe pai caiba dentro de uma classe filha, com um stdObjetc isso também seria possível, porém em uma arquitetura mais elaborada, isso não seria aceito.

Se você esta usando PDO, esta tendo dificuldades com UTF-8 no seu MySQL, mesmo com tudo setado para UTF-8, você pode tentar isso:

$pdo = new PDO(
    ‘mysql:host=localhost;dbname=nomedobanco’,
    "user",
    "pass",
    array(PDO::MYSQL_ATTR_INIT_COMMAND => "SET NAMES utf8"));

O último parametro do construtor do PDO é um array com as opções específicas do driver, no caso, do driver od MySQL. Este parametro é alimentado no velho estilo "array" chave=>valor.

Observem que o parametro (PDO::MYSQL_ATTR_INIT_COMMAND) não se trata de uma configuração de charset, mas sim de um comando que é executado todas as vezes que você conecta no banco. Neste caso, todas as vezes que ele se conecta no banco, ele executa a query "SET NAMES utf8" (acho que é específica do MySQL) que diz para o MySQL utilizar UTF-8 como charset para nossa conexão.

Para saber mais:

• PDO e BEAN no PHP
• MySQL “Connection Character Sets and Collation” documentation
• PDO constructor documentation
• PDO MySQL driver documentation

Fonte:
http://www.laszlo.nu/post/34159352/how-to-use-utf-8-with-mysql-and-php-data-objects-pdo

Tags BlogBlogs: php, pdo, mysql, utf8, unicode

Não é novidade, mas vale o registro. O PHP 5, possui uma funcionalidade bem interessante, similar a outras linguagens orientadas a objeto, Exceção. Quando algo altera o fluxo de execução do sistema ele dispara uma Exceção. Uma exceção pode ser disparada ou capturada, depende do que você pretende. Você pode customizar um série de tratamentos de erros que irão facilitar o desenvolvimento do seu sistema, com essa custimização você pode saber exatamente o que está sendo tratado e se algo fugir desse controle é algo anormal e fica mais facil a rastreabilidade.

Dentro de uma exceção, você pode disparar um log, ou um alert, ou registrar algo no banco, é um fluxo de erro sob controle.

Eu costumo tratar as exceções para tudo, campo em branco, tipo de dado inválido, e-mail inválido, ou se alguma fórmula não foi validada. Para isso uso um conjunto de classes que constituem as mensagens e os testes para que as exceções sejam disparadas:

Uma classe Main para controlar as requisições de Exception:

MainException.php:

<?PHP
    /**
    * Declaração da classe para tratamento de erros
    * A classe deve ser extendida da classe Exception do PHP
    * Ela irá realizar a sobrescrita da classe Exception do PHP
    */
    class MainException extends Exception {
        //Faço a declaração das variávis que vou utilizar no corpo da classe
        private    $cod          = 0;
        private    $msg          = "";
        private    $erromsg      = "";

        /**
        * Aqui faço a declaração do método construtor de classe
        * Esse método recebe os seguintes parametros:
        * @param $cod – Código de erro
        * @param $msg – Uma mensagem de erro personalizada
        * @param $erromsg – Uma mensagem de erro padrão
        */

        public function __construct( $cod = 0 , $msg = "" , $erromsg = "" ) {
 
            //Sobreescrevo as propiedades da classe passando os parametros
            $this->cod = $cod;
            $this->msg = "Ocorreu um erro não identificado";
            $this->erromsg = $erromsg;
 
            //Aqui eu chamo o construtor da classe pai 
            parent::__construct( $this->msg , $this->cod );        
 
        }
 
 
        /**
        * Este método irá salvar nossos erros em um log
        */
        public function _Log() {

            //Define o arquivo que será criado ou gravado caso exista, o nome do arquivo irá ser o nome da classe
 
            $log = __CLASS__ . "_log_" . date("dmY") . "txt";
 
            //Se não existe arquivo, cria
            if( !file_exists($log)){
 
                $msg = "/************************************************** " .
                " * Arquivo de log " .
                " * " .
                " * ClassName: " . __CLASS__ . " " .
                " * Data Criação: " . date("d/m/Y H:i") . " " .
                " *************************************************/ " .
                "——————————————————————- ";
 
            }else
                $msg = "";
 
                //Abre o arquivo
                if($fp = fopen( $txt , "a+")) {
 
                //Arquivo
                $msg .=    __CLASS__ . " hora: ".date("H:i") . " " .
                "Erro [ {$this->cod} ]: linha ( {$this->line} ) " .
                "{$this->msg} " .
                "{$this->erromsg} " .
                "——————————————————————- ";
 
                //Grava
                fwrite($fp, $msg);
                fclose($fp);
            }
 
        }
 
    }
?>

A classe abaixo estende MainException e a customiza para Exceções de texto:

textException.php:

<?PHP
/**
 * Esta classe é responsável por disparar exceções relacionadas a texto
 */
 class textException extends MainException {
 
      public function __construct(  ) {
          //Sobrescrita do construtor de MainException, com os valores que queremos
          parent::__construct( 1, "Tipo de caracter inválido", PHPSELF);
         
          $this->_Log();
                       
      }
          
 }
?>

A classe abaixo faz a verificação do texto e dispara a exceção:

verificaTexto.php:

<?PHP
 
class verificaTexto
{
    public function __construct($texto)
    {
        if(!is_int($texto))
        {
            echo $texto;
        }
        else
        {
            throw new textException();
        }
    }
 
}
 
?>

A classe abaixo faz o teste para números e caso falhe, dispara MainException, ou seja sem customizar o tipo de exceção que será disparada, então irá enviar a mensagem padrão:

verificaValor.php:

<?PHP
 
class verificaValor
{
    public function __construct($val)
    {
        if($val == 1)
        {
            echo $val;
        }
        else
        {
            throw new MainException();
        }
    }
 
}
 
?>

Apenas para teste:

<?PHP
 
include ("autoload.php");
 
try
{
 
    //$b = new verificaTexto(1);
    $b1 = new verificaValor(1123);
 
}
Catch(textException $te)
{
    echo $te->getMessage();
}
catch(Exception $e)
{
    echo $e->getMessage();
}
 
 
?>

E o autoload se alguém quiser:

<?PHP
 
function __autoload($class_name) {
    require_once $class_name . ‘.php’;
}
 
?>

Como podem ver, a classe MainException é que faz todo o trabalho, nela temos o método principal que realiza o disparo das exceptions, em textException, sobrespcrevemos a classe MainException e fazemos ela se comportar como queremos para disparar apenas uma mensagem de erro para textos.

Ainda existe a possibilidade de disparar uma Exception genérica, caso nosso tratamento não seja para textos. Se observarem com calma verão que se trata apenas de sobrescritas de métodos algo que seria perfeitamente possível sem Exception, porém desta forma temos mais controle (fora a elegancia do código).

Bom é isso, qualquer dúvida comentem.

Para saber mais:

• Exceptions no manual: http://www.php.net/manual/en/language.exceptions.php
• Classe MainException original de José Roberto Gomes da Silva: http://www.plugmasters.com.br/sys/materias/914/1/Exception-com-php

Tags BlogBlogs: php, exception, oo