Type Hinting no PHP

Olá amigos tudo bem? Hoje serei breve (acho que essa frase virou prefixo dos meus ultimos posts... Oo)

Bem vamos lá....

                                 TYPE HINTING

A partir do PHP 5.0 foi introduzido o Type Hinting, mesmo sendo relativamente velho as pessoas não sabem o que é pois bem, traduzindo Type Hinting é "Indução de Tipo". Particularmente eu não gosto das traduções ao pé da letra pois no mundo da TI isso mais atrapalha do que ajuda, mas nesse caso a tradução ao pé da letra vai ajudar e muito então vamos fazer uma "análise sintática"

da tradução!




Indução de tipo, indução -> alguém está induzindo algo e tipo, esse algo é o tipo. Agora, pesquisando em que contexto isso se refere nós podemos entender que indução de tipo é uma função dizer qual tipo ela recebe, mais o menos assim:

 Exemplo type hinting

1. /* Type Hinting */
2. function insereLista(\Lib\Nucleo\Pessoa $pessoa){
3.         /*
4.         * inserindo na lista....
5.         */
6. }

Temos a função insereLista que recebe um parametro $pessoa... mas o que é esse pessoa? Antes do parametro colocamos a classe em que esse parametro é uma instância dizendo para a função o tipo do parametro. Ficando mais coeso o código e ainda bem fácil de dar manutenção.

Legal é só isso? Funciona com tipo primitivo? :D

Não!

O Type Hinting foi introduzido no PHP 5.0 para objetos e 5.1 para arrays os tipos escalares ainda não é nativo mas, caso vc queira usa-los é necessário o uso da extensão SPL_Types que vc pode ver aqui. 

PS: Não confundam isso com CAST... não tem nada haver satangoss nessa ideia ai heinn?!

so.... fui.

Mais? php.net

Late Static Binding no PHP

O Late Static Binding existe a partir do PHP 5.3 e a maioria das explicações não são muito claras e por isso essa funcionalidade fica meio na... nuvem! 

A documentação do PHP define o Late Static Binding como "maneira de referenciar a classe chamada no contexto de herança estática"
ENTENDEU? 

Esta definição apesar de palavras bem usadas no nosso dia a dia não deixou muito claro a sua finalidade e ai ficamos muuito confusos... Felizmente esse é o tipo de conceito que não se entra na cabeça de "prima" e para ajudar a documentação do PHP tem bastante exemplo.

Chega de papo, a melhor forma de entender isso é vendo o CÓDIGO!

Para usar a Late Static Binding, precisamos de uma classe que herda de outra classe e alguns métodos estáticos para sobreescrevemos. Veja:

Late static binding - php 5.3

1. class classePai {
2.    
3.     public static function normalCall() {
4.         self::calledMethod();
5.     }  
7.     public static function lateStaticCall() {
8.         static::calledMethod();
9.     }  
11.     public static function calledMethod() {
12.         echo " Chamada na classe PAI \n";
13.     }  
14.    
15. }
17. class classeFilha extends classePai {
18.    
19.     public static function calledMethod() {
20.         echo "Chamada na classe Filha \n";
21.     }  
22.    
23. }

Veja bem, temos a classeFilha que extende da classePai...
Na classePai temos 3 métodos estáticos, normalCall, lateStaticCall e calledMethod na classe filha temos apenas um método estático o calledMethod

Percebam que tanto na filha quanto na pai temos a classe calledMethod certo?
Pois bem, se chamarmos o método estático normalCall tanto com a classe filha como a pai o resultado seria  Chamada na classe PAI  veja um pequeno exemplo do uso.

USANDO FORMA COMUM PARA CHAMAR OUTRO METODO ESTATICAMENTE

1.  classePai::normalCall(); // Chamada na classe PAI
2.  classeFilha::normalCall(); // Chamada na classe PAI

Ou seja, independente de chamar o método estático na filha ou na pai a função que a classe normalCall irá chamar sempre será a calledMethod da classe pai, pois é isso que o self esta fazendo.

Agora, se fizermos a mesma coisa mais trocando o self por static que é como esta implementado no método lateStaticCall a chamada seria diferente pois o Late Static Binding estaria em ação, veja:

USANDO LATE STATIC BINDING NO PHP

1.  classePai::lateStaticCall(); // Chamada na classe PAI
2.  classeFilha::lateStaticCall(); // Chamada na classe Filha

Fonte: PHP.net (como sempre, rs)

SPL PHP

Se você nem imagina o que significa SPL no PHP é provavel que você veio aqui por culpa da certificação da ZEND (pois SPL esta no edital da prova), e eu já vou adiantando que você se deu muito bem pois a ideia é justamente esclarecer o SPL para vc aprender e ir bem na certificação!

SPL significa Standard PHP Library  que é uma coleção de interfaces e classes que servem para resolver problemas padrões da orientação a objetos no PHP.
Em resumo SPL fornece um conjunto padrão de interfaces para PHP5. O objetivo do SPL é implementar algumas interfaces de dados eficientes de acesso e classes para PHP. Funcionalmente ele é projetado para percorrer estruturas agregadas (qualquer coisa que você quer varrer). Estes podem incluir matrizes, conjuntos de resultados de banco de dados, árvores xml, listas de diretório ou de qualquer lista em tudo. Atualmente SPL lida com iteradores.

Agora você pensa: Legal, mais onde isso exatamente me ajuda? Eu sei que ver o Homer aqui comemorando é muito legal mas eu quero uma finalidade para a SPL... 

E ai eu te digo, vou repetir mais com outras palavras a explicação.... o SPL são interfaces e classes nativas do PHP que tem o intuito de resolver problemas que ocorrem com frequencia no desenvolvimento, como por exemplo uma interação de arrays e etc...

Agora melhorou né? Mais como funciona?... A SPL é dividida em categorias de acordo com a funcionalidade.

Eu não vou ficar escrevendo TUDO aqui pois seria replicar o que existe na documentação do PHP, mais vou dar um copy paste de uma classe que é a ArrayIterator, veja como é util.

A classe ArrayIterator

Introdução

Este iterator permite remover e modificar valores e chaves quando iterando arrays e objetos.

Quando você quiser iterar o mesmo array múltiplas vezes você precisa instanciar ArrayObject e criar instâncias de ArrayIterator que é consultado usando foreach ou chamando o método getIterator() manualmente.

Sinopse da classe

ArrayIterator implements Iterator , Traversable , ArrayAccess , SeekableIterator , Countable {

/* Métodos */

public void append ( mixed $value )

public void asort ( void )

public __construct ([ mixed $array = array() [, int $flags = 0 ]] )

public int count ( void )

mixed current ( void )

public array getArrayCopy ( void )

public void getFlags ( void )

mixed key ( void )

public void ksort ( void )

public void natcasesort ( void )

public void natsort ( void )

void next ( void )

public void offsetExists ( string $index )

public mixed offsetGet ( string $index )

public void offsetSet ( string $index , string $newval )

public void offsetUnset ( string $index )

void rewind ( void )

void seek ( int $position )

public string serialize ( void )

public void setFlags ( string $flags )

public void uasort ( string $cmp_function )

public void uksort ( string $cmp_function )

public string unserialize ( string $serialized )

bool valid ( void )

}

Seus métodos e funcionalidade

• ArrayIterator::append — Acrescentar um elemento
• ArrayIterator::asort — Ordenar matriz por valores
• ArrayIterator::__construct — O seu construtor
• ArrayIterator::count — Conta elementos
• ArrayIterator::current — Retorna o valor do elemento atual do array
• ArrayIterator::getArrayCopy — Get array copy
• ArrayIterator::getFlags — Get flags
• ArrayIterator::key — Retorna a chave do elemento atual do array
• ArrayIterator::ksort — Ordena um array pela chave
• ArrayIterator::natcasesort — Ordena um array naturalmente, case insensitive
• ArrayIterator::natsort — Ordena um array naturalmente
• ArrayIterator::next — Avança para o próximo elemento
• ArrayIterator::offsetExists — Check if offset exists
• ArrayIterator::offsetGet — Get value for an offset
• ArrayIterator::offsetSet — Set value for an offset
• ArrayIterator::offsetUnset — Unset value for an offset
• ArrayIterator::rewind — Recoloca o array no início
• ArrayIterator::seek — Aponta para determinada posição
• ArrayIterator::serialize — Serialize
• ArrayIterator::setFlags — Set behaviour flags
• ArrayIterator::uasort — User defined sort
• ArrayIterator::uksort — User defined sort
• ArrayIterator::unserialize — Unserialize
• ArrayIterator::valid — Verifica se o array possui mais elementos

Informações completas sobre a a classe?
o PHP tem uma das melhores documentações do mundo, então é só acessar. http://www.php.net/manual/pt_BR/book.spl.php

Valeu!

Autoload no PHP 5

Olá amigos tudo bem? Hoje vou falar de forma básica sobre o autoload no PHP.

Não vou entrar no mérito de discutir o pq do autoload pois se vc veio aqui é pq sabe ou tem ideia da sua utilização. Para evitarmos o uso de include manualmente a partir do PHP 5 foi disponibilizado o autoload que é basicamente uma forma de carregarmos a classe que precisamos. Mais como funciona?

A partir fo PHP 5, basta definir uma função __autoload no inicio do script que ela é automaticamente chamada quando tentamos usar uma classe.

Dessa forma:

<?php

function __autoload($class_name){
        require_once $class_name . '.php';
    }
   
    $pessoa = new Pessoa();
    $pessoa->setNome($nome);

?>

Basicamente a classe carregaria automaticamente e não precisamos ficar chamando o __autoload pois ele é carregado automaticamente. Que artigo mais basico e rápido esse não é? Bem, essa é a ideia hehe.

Reflection no PHP

Olá amigos e amigas tudo bem? Espero que sim =) ... Hoje vou falar rapidamente do Reflection no PHP... Reflection? 

O que é isso? A partir do PHP 5 foi implementado uma API chamada Reflection. Ela permite fazermos reflexão de objetos, ou seja, observar a estrutura de classes como seus métodos, atributos, interfaces... tudo em tempo de execução (runtime). Basicamente a reflexão de um objeto permite que ele se observe, como nós olhando em um espelho.

Ta, mais e como posso fazer um teste disso? Simples, vamos utilizar a ReflectionClass afim de exibir sua funcionalidade.

1. <?php
3. class Pessoa{
4.    
5.     private $nome;
6.     private $sexo;
7.    
8.     public function getNome() {
9.         return $this->nome;
10.     }
12.     public function setNome($nome) {
13.         $this->nome = $nome;
14.     }
16.     public function getSexo() {
17.         return $this->sexo;
18.     }
20.     public function setSexo($sexo) {
21.         $this->sexo = $sexo;
22.     }
23.    
24. }
26. $reflection = new ReflectionClass('Pessoa');
27. var_dump($reflection->getMethods());

Veja que criamos uma classe pessoa com 2 atributos, nome e sexo e os sets e gets dessa classe... depois criamos uma instancia da ReflectionClass passando a classe Pessoa como argumento e utilizamos o metodo getMethods para buscar os mesmos... o resultado disso?

1. array(4) { [0]=> &object(ReflectionMethod)#2 (2) { ["name"]=> string(7) "getNome" ["class"]=> string(6) "Pessoa" } [1]=> &object(ReflectionMethod)#3 (2) { ["name"]=> string(7) "setNome" ["class"]=> string(6) "Pessoa" } [2]=> &object(ReflectionMethod)#4 (2) { ["name"]=> string(7) "getSexo" ["class"]=> string(6) "Pessoa" } [3]=> &object(ReflectionMethod)#5 (2) { ["name"]=> string(7) "setSexo" ["class"]=> string(6) "Pessoa" } }

Esse foi o resultado, conseguimos "dissecar" a classe facilmente... bom não é? Eu tenho certeza que se é a primeira vez que vc lê sobre reflection vc esta com mt raiva... Mais vou amenizar isso sem te oferecer um suco de maracuja.

Onde utilizamos o reflection?
As opções são várias para utilizar o REFLECTION mais eu vou me conter apenas a falar sobre onde já é bem utilizado...

Vc já ouviu falar sobre ORM? Se sim então provavelmente conhece o DOCTRINE framework ORM para PHP não é? Veja bem, o DOCTRINE utiliza reflection nas entidades que escrevemos para poder gerar o SQL e criar/sincronizar nossas classes com o banco, assim não precisamos ficar criando scripts SQL sempre que mudarmos a estrutura do nosso banco basta sincronizar e quem faz essa brincadeira é o DOCTRINE utilizando o REFLECTION do PHP...

O BOUML um software para UML faz uma engenharia reversa do nosso código PHP para diagramas e como vc acha que ele faz isso? Mágica? Não, ele usa o reflection... São 'n' as possibilidades para o uso do reflection então se pintar uma ideia insana para uma aplicação sua e vc achar que ela é impossível pela limitação da tecnologia.... pare, pense, pesquise e implemente! :)

Espero ter ajudado!

=]