Mostrando postagens com marcador agilizando a produção com PHP. Mostrar todas as postagens
Mostrando postagens com marcador agilizando a produção com PHP. Mostrar todas as postagens

quinta-feira, 16 de agosto de 2012

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

quinta-feira, 5 de julho de 2012

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
  2. class Pessoa{
  3.    
  4.     private $nome;
  5.     private $sexo;
  6.    
  7.     public function getNome() {
  8.         return $this->nome;
  9.     }
  10.     public function setNome($nome) {
  11.         $this->nome = $nome;
  12.     }
  13.     public function getSexo() {
  14.         return $this->sexo;
  15.     }
  16.     public function setSexo($sexo) {
  17.         $this->sexo = $sexo;
  18.     }
  19.    
  20. }
  21. $reflection = new ReflectionClass('Pessoa');
  22. 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!


=]


segunda-feira, 2 de julho de 2012

DateTime do PHP

A partir do PHP 5.2.0, há uma maneira nativa e simples de se trabalhar com horários e datas, com auxílio da classe DateTime Link Externo.

O objetivo do artigo é mostrar algumas das utilidades da classe DateTime

Sumário
1. Construtor da classe
2. Formatando datas
3. Adicionando períodos a datas
4. Subtraindo períodos de uma data
5. Calculando diferença entre datas
6. Modificando a data e a hora do objeto


1. Construtor da classe

Sintaxe do construtor:
DateTime::__construct ([ string $time = "now" [, DateTimeZone $timezone = NULL ]] )
O método aceita dois parâmetros, ambos opcionais. O primeiro é a data/hora, no mesmo formato aceito pela função strftime() Link Externo. O segundo consiste no timezone que deve ser utilizado. Ele deve ser uma instância da classe DateTimeZone Link Externo. Uma outra maneira de definir o timezone é por meio da função date_default_timezone_set() Link Externo.
Ambas as classes DateTime e DateTimeZone disparam uma exceção se seus construtores receberem parâmetro inválidos. Logo, podemos usar blocos try/catch para instanciar essas classes.
try
{
 $DateTime = new DateTime( 'now', new DateTimeZone( 'America/Sao_Paulo') );
}
catch( Exception $e )
{
 echo 'Erro ao instanciar objeto.
';
 echo $e->getMessage();
 exit();
}
Experimente trocar o "now" por um valor não aceito pelo método, como uma string qualquer. Uma exceção será disparada.

2. Formatando datas

Para formatar datas, utilizamos o método format, que aceita um parâmetro, correspondente a uma formatação de data aceita pela função date() Link Externo.
$DateTime = new DateTime();
echo $DateTime->format( "d/m/Y H:i:s" ) . ' '; echo $DateTime->format( "Y-m-d H:i:s" ) . ' '; echo $DateTime->format( "Y/m/d H:i:s" ) . ' ';

 

3. Adicionando períodos a datas

Com o método add(), podemos adicionar períodos à data salva no objeto DateTime. É possível adicionar períodos de dias, períodos de tempo ou ambos, seguindo a formatação aceita pelo método, que recebe um único parâmetro, o qual é uma instância da classeDateInterval Link Externo, responsável por manipular os dados do período especificado.
Os períodos são especificados da seguinte maneira: períodos de dias são precedidos pela letra "P", seguidas de inteiros e seus respectivos identificadores de tempo ("D" para dias, "M" para meses e "Y" para anos). Períodos de tempo são precedidos pela letra "T" e seguidos de inteiros e seus respectivos identificadores de unidade ("H" para horas, "M" para minutos e "S" para segundos).
$DateTime = new DateTime();
$DateTime->add( new DateInterval( "P30D" ) ); // adiciona 30 dias echo $DateTime->format( "d/m/Y" ) . ' ';
$DateTime->add( new DateInterval( "P2M" ) ); // adiciona 2 meses echo $DateTime->format( "d/m/Y" ) . ' ';
$DateTime->add( new DateInterval( "P5Y" ) ); // adiciona 5 anos echo $DateTime->format( "d/m/Y" ) . ' ';
$DateTime->add( new DateInterval( "P5Y2M30D" ) ); // adiciona 30 dias, 2 meses e 5 anos echo $DateTime->format( "d/m/Y" ) . ' ';
Note que cada adição é feita com base na adição anterior, uma vez que cada soma modifica a data armazenada no objeto.

 

4. Subtraindo períodos de uma data

O método sub funciona da mesma forma que o add, com a mesma lista de parâmetros, mas, logicamente, em vez de adicionar períodos, ele os subtrai.
$DateTime = new DateTime();
$DateTime->sub( new DateInterval( "P30D" ) ); // subtrai 30 dias echo $DateTime->format( "d/m/Y" ) . ' ';
$DateTime->sub( new DateInterval( "P2M" ) ); // subtrai 2 meses echo $DateTime->format( "d/m/Y" ) . ' ';
$DateTime->sub( new DateInterval( "P5Y" ) ); // subtrai 5 anos echo $DateTime->format( "d/m/Y" ) . ' ';
$DateTime->sub( new DateInterval( "P5Y2M30D" ) ); // subtrai 30 dias, 2 meses e 5 anos echo $DateTime->format( "d/m/Y" ) . ' ';

 

5. Calculando diferença entre datas

Usando o método diff, podemos calcular o intervalo entre duas datas, com precisão de dias, meses, anos, horas, minutos e segundos. Esse método retorna uma instância da classe DateInterval, já citada anteriormente neste artigo.
$DateTime = new DateTime();
$diff = $DateTime->diff( new DateTime( '2009-02-14' ) );
echo "Diferença de: " . $diff->d . " dias " . $diff->m . " meses " . $diff->y . " anos " . $diff->h . " horas " . $diff->i . " minutos " . $diff->s . " segundos ";

 

6. Modificando a data e a hora do objeto

Para modificar a data e a hora armazenadas no objeto, utilizamos os métodos setDate esetTime.
$DateTime = new DateTime();
echo $DateTime->format( "d/m/Y H:i" ) . ' ';
$DateTime->setDate( 2007, 07, 07 ); $DateTime->setTime( 07, 27 );
echo $DateTime->format( "d/m/Y H:i" ) . '
';




Atenção amigos. Esse artigo não é meu mas sim do Roberto Beraldo Chaiben e o link original é: http://helpmasters.com.br/artigo/92/php-usando-a-classe-nativa-datetime
 Estou reproduzindo pois achei o artigo muito util e assim eu também não perco ele por ai! Todos os créditos ao escritor pelo otimo artigo.