Introdução à Linguagem PHP

! " #
$ %!#
$& '#
%& $ ( &)* +, & -(& . & , &/ $ %!0 .$ & , 1 2 #
!&# !&#
$& '#
3 '-#
4($(
5* . %- '!& 67& 8 7& 8 7& 5 !&8 7& ! &9 :
; .$ 67& 9 :
. & <" =
. & < > ?<" =
7& , " .& 0
3 & @0
. & < A?" "B=
. & < > ?< A?" "B=
7& , A & CD 0
3 & @0
. & < ?? ?=
. & < > ?< ?? ?=
7& , 1 ! 0
3 & @0
'&5 *! =
7& , & . $&. ' 0
3 & @0
E

5 6<F& 6 ' (! -<& 99

(
5 6 3 #G 3#H 3#= H &% 3#H 3# ! $
3#H' 3# 3 # 3 #G 8 7& 8 7& 8 7& 5 !&8 7& ! &90
5 6 <F& 6I! F<& I99
& <! F6 ( 56 H = H H ! & H' 8 7& 8
7& 8 7& 5 !&8 7& ! &990
& * *&0
E

5 F* % (*! ' '& &

& <& <$ '!& 6 %- '!& 90

1 C *% & '& ' + D ( J ?

&.$ 0
4#

3 '-#
$ %!#

Programação Orientada a Objeto em PHP

(Extraído do Livro “Zend PHP 5 Certification Study Guide”)

A Orientação a Objetos no PHP em sua 5ª versão foi totalmente reescrita do zero. Neste capítulo,
presume‐se que o aluno esteja familiarizado com os conceitos de OO para que possa usufruir de seu poder
aplicado ao PHP.
Enquanto o objetivo deste capítulo não é fornecer um guia aos conceitos da Programação Orientada a
Objetos (POO), é uma boa idéia dar uma breve olhada em alguns de seus fundamentos. A POO remonta o
conceito de agrupar código e dados juntos em unidades lógicas chamadas classes. Este processo é
usualmente conhecido como encapsulamento, ou ocultação de informações, desde que seu objetivo é
dividir uma aplicação em entidades separadas cujos componentes internos podem ser alterados sem
alterar suas interfaces. Então classes são essencialmente uma representação de um conjunto de funções
(conhecidas por métodos e variáveis (conhecidas por propriedades ou atributos) projetadas para
trabalharem juntas e fornecer uma interface específica para o mundo externo. É importante entender que
classes são apenas plantas que não podem ser usadas diretamente – elas têm que ser instanciadas em
objetos que podem interagir com o resto da aplicação.

Declarando uma classe

A declaração básica de uma classe é muito simples:

! %- ! :
&K' )*
E

Como você pode perceber, esse código avisa ao interpretador PHP que você está declarando uma classe
chamada myClass cujo conteúdo será normalmente uma combinação de constantes, variáveis e funções
(métodos).

Instanciando um Objeto

Uma vez que tenha declarado uma classe, você precisa instanciá‐la para obter as vantagens que ela
oferece. Isso é feito usando o construtor &;:

7%- .& , &; %- ! 690

No PHP 5, os objetos são tratados de maneira diferente dos outros tipos de variáveis. Um objeto é sempre
passado por referência ao invés de por valor. Por exemplo:

7%- ! .& , &; %- ! 690

7. (- .& , 7%- ! .&690

Neste caso, ambas as variáveis %- ! .& e . (- .& apontarão para o mesmo objeto.
Isso é um comportamento padrão dos objetos na maioria das linguagens, mas não era o caso no PHP 4.

Herança de classe

Um dos fundamentos chave da POO é a herança. Ela permite que uma classe estenda outra,
essencialmente para adicionar novos métodos e propriedades, bem como redefinindo‐os caso já existentes.
Por exemplo:

.! :
5* . & 69
:
&.$ == & . !!&' 0
E
5* . 5* .69
:
 &.$ ==5* . . !!&' 0
E
E
.! 3 &/ & ' :
5* . & 69
:
&.$ 3== & . !!&' 0
E
E
.! . &/ & ' 3 :
5* . & 69
:
( & == & 690
E
E
.! ' &/ & ' . :
5* . & 69
:
3== & 690
E
E
7 , &; 690
73 , &; 3690
7. , &; .690
7' , &; '690
7 # & 690 * (* == & . !!&'
73 # & 690 * (* 3== & . !!&'
73 #5* .690 * (* ==5* . . !!&'
7. # & 690 * (* 3== & . !!&'
7' # & 690 * (* 3== & . !!&'

Nesse script, começamos declarando uma classe chamada “a”. Então declaramos a classe “b” que estende
“a”. Como pode ver, a classe “b” também tem o método & 69 que redefine aquele declarado em “a”.
Perceba que ainda podemos, no entanto, acessar os outros métodos de “a”. Por exemplo, se chamarmos
73 #5* .69, estamos efetivamente chamando o método 5* .69 de “a”.

Como mencionado anteriormente, classes podem conter métodos e variáveis (propriedades). Métodos são
declarados do mesmo jeito das funções tradicionais:

.! %- ! :
5* . %-1* . 69 :
&.$ * . !!&' %- ! ==%-1* . 0
E
E

Do lado de fora do escopo de uma classe, seus métodos são chamados usando o operador ‐>:

7 3L , &; %- ! 690
7 3L #%-1* . 690
Realemente, a variável 7 3L só é válida dentro do escopo de nosso pequeno trecho de código acima – que
nos deixa com um dilema: como referenciar um método de classe de dentro da própria classe? Aqui vai um
exemplo:

.! %- ! :
5* . %-1* . 69 :
 &.$ * . !!&' %- ! ==%-1* . 0
E
5* . . !! -1* . 69 :
444
E
E

Claramente, . !! -1* . 69 precisa de uma maneira de chamar %-1* . 69 de dentro do

escopo do objeto. Para que isso seja possível, o PHP dispõe de uma variável especial chamada 7 $ . Ele
sempre se refere ao próprio objeto. Exemplo:

.! %- ! :
5* . %-1* . 67' 9 :
&.$ $& + !*& 7' 0
E
5* . . !! -1* . 67' 9 :
!! %-1* . 69
7 $ #%-1* . 67' 90
E
E
7 3L , &; %- ! 690
7 3L #. !! -1* . 6 M 90

Este trecho de código mostrará “The value is 123”.

Construtores

O PHP introduziu o conceito de construtor unificado e, juntamente com ele, um novo destruidor de
objetos. O construtor e o destruidor são métodos especiais de classe que são chamados, como seus nomes
sugerem, na criação e destruição dos objetos, ou para executar procedimentos de inicialização. Nas versões
anteriores do PHP, construtores tinham o mesmo nome da classe. Agora, utiliza‐se o método
<<. *. 69. Isso é útil, pois caso queira renomear a classe, não será preciso renomear os
construtores. Exercício: verifique se é possível existir mais de um método construtor na mesma classe.

.! 5 :
5* . <<. *. 69
:
&.$ << <<0
E
5* . 5 69
:
-!& . *.
E
E
&; 5 690

Destruidores

Além do método <<. *. 69, temos também o método <<'& *. 69. Ele trabalha como uma
imagem de espelho do <<. *. 69. Ele é chamado logo antes de um objeto ser destruído e é útil
para executar operações de limpeza, como desconectar de um recurso remoto ou apagar arquivos
temporários:

.! 5 :
5* . <<. *. 69
 :
&.$ << << < 0
E
5* . <<'& *. 69
:
&.$ << <<0
E
E
&; 5 690

Esse código mostrará:

5 ==<<. *.
5 ==<<'& *.

A destruição ocorre quando qualquer referência a um objeto desaparece, como no caso abaixo:

7 , &; 5 690
73 , 7 0
* & 67 90

Mesmo que um objeto ainda possua uma ou mais referências ativas, o método <<'& *. 69 é
chamado no final da execução do script, então você terá a garantia de que em algum momento seu
destruidor será executado. Entretanto, não há uma maneira de determinar a ordem de destruição de dois
ou mais objetos. Isso pode causar algum problema quando um objeto depende de outro para executar uma
ou mais funções.

Visibilidade

O PHP 5 adicionou a noção de visibilidade de métodos e propriedades de objetos , que permite que você
determine o escopo a partir do qual cada componente de sua classe possa ser acessado.

(*3! . O recurso pode ser acessado a partir de qualquer escopo.

( &. &' O recurso só pode ser acessado de dentro da classe onde está definido ou a partir
de seus descendentes.
( + & O recurso só pode ser acessado de dentro da classe onde está definido.
5 ! O recurso pode ser acessado a partir de qualquer escopo, mas não pode ser redefinido ou
sobrecarregado.

OBS: o nível de visibilidade final somente se aplica a métodos e classes. Classes que são declaradas como
final não podem ser estendidas. Normalmente, você irá querer tornar todos os métodos e propriedades de
sua API públicas, desde que queira torná‐los acessíveis de fora de seus objetos, enquanto você desejará
manter as operações internas protegidas ou privadas. Construtores e destruidores são normalmente
declarados como públicos, entretanto, às vezes você pode desejar tornar os construtores privados quando,
por exemplo, quer usar alguns padrões de projeto como o Singleton ou Factory:

.! 5 :
(*3! . 75 , N3 N0
( &. &' 73 O , N3 N0
( + & 7)*/ , N3 F N0
5* . <<. *. 69
:
+ <'*%(6F& < 3L&. <+ 67 $ 990
E
E
.! 3 &/ & ' 5 :
5* . <<. *. 69
:
+ <'*%(6F& < 3L&. <+ 67 $ 990
E
E

.! 3 O :
5* . <<. *. 69 :
75 , &; 5 690
+ <'*%(6F& < 3L&. <+ 675 990
E
E
&; 5 690
&; 3 690
&; 3 O690

O exemplo acima cria três classes: 5 , 3 que estende 5 e tem acesso a todos os métodos e
propriedades públicos e privados de 5 e, finalmente, 3 O que cria uma nova instância de 5 e pode
somente acessar suas propriedades públicas. Execute o programa e observe a saída.

Declarando e Acessando Propriedades

Propriedades são declaradas em PHP orientado a objetos usando um dos modificadores de acesso
mencionados anteriormente, seguido de seus respectivos nomes:

.! 5 :
(*3! . 73 0
( &. &' 73 O0
( + & 73 0
(*3! . + , & 0 > F
(*3! . + M , M 0 "*%& . + !*&
(*3! . + , - 6 8 M8 90
E

Observe que, como uma variável comum, uma propriedade de classe pode ser declarada e inicializada ao
mesmo tempo. Entretanto, a inicialização é limitada à associação de valores (mas não a uma avaliação de
expressão). Você não pode, por exemplo, iniciar uma propriedade chamando uma função, o que só pode
ser feito de dentro de um construtor.

Juntamente com o PPP, o PHP 5 também implementa métodos e propriedades estáticos. Ao contrário dos
métodos e propriedades regulares, os seus correspondentes estáticos existem e são acessíveis como parte
de uma classe em si, em oposição ao existente apenas no âmbito de uma das suas instâncias. Isto permite
tratá‐las como verdadeiras contêineres de funções e dados interrelacionados o que, por sua vez, é um
expediente muito útil para evitar conflitos de nomes. Enquanto o PHP 4 permitia que você chamasse
qualquer método de uma classe estática usando o escopo operador de resolução:: (oficialmente conhecido
como Paamayim Nekudotayim‐hebraico para Colon "Double"), o PHP 5 introduz uma sintaxe mais rigorosa
que apela para o uso da palavra‐chave para transmitir a utilização de propriedades e métodos como
tal. Você deve ter em mente que o PHP 5 é muito rigoroso sobre o uso de propriedades e métodos
estáticos. Por exemplo, chamar propriedades estáticas usando a notação de objeto resultará em uma
mensagem de erro:

.! 5 :
. 73 , 3 0
 . (*3! . 5* . 3 O69
:
&.$ &!! !' 0
E
E
75 , &; 5 690
75 #3 O690
&.$ 75 #3 0

Isso irá mostrar:

5 ==3 O
" .&= '&5 &' ( (& -= 5 ==73 .*%& ! & P

É necessário para a definição de estático seguir a definição de visibilidade, ou seja, se nenhuma definição
de visibilidade é declarada, o método ou propriedade é considerado público.

Constantes de Classe

Constantes de classe funcionam da mesma forma que as constantes regulares, exceto que possuem o
escopo interno à classe. Constantes de classe são públicas e acessíveis a partir de qualquer escopo. Por
exemplo, o seguinte script mostrará &!! !':

.! 5 :
. A? , &!! !' 0
E
&.$ 5 == A?0

Constantes de classe têm várias vantagens sobre as constantes tradicionais: uma vez que são encapsuladas
em uma classe, elas fazem um código muito mais limpo, e são significativamente mais rápidas do que as
declaradas com o construtor '&5 &69.

Operador de Resolução de Escopo (::)

O Operador de Resolução de Escopo, também chamado de , ou em termos mais

simples, dois pontos duplo, é um que permite acesso a métodos ou membros estáticos, constantes,
e sobrecarregados de uma classe. Quando referenciando esses itens de fora da definição da classe, você
usa o nome da classe. No PHP 5.3.0, é possível referenciar o nome da classe usando uma variável. O valor
da variável não pode ser uma palavra chave (e.g. &!5, ( & e .).
pode parecer de início uma escolha estranha para um dois pontos duplo. No entanto, na hora de escrever o
Engine da Zend 0.5 (que provia o PHP3), foi o que a equipe da decidiu. Realmente significa dois
pontos duplo ‐ em Hebreu!

.! $ ! & :
. QA ?< "> , I % + ! . &I0
E
7.! %& , I $ ! &I0
&.$ 7.! %&==QA ?< "> 0 " R
&.$ $ ! &==QA ?< "> 0
Duas palavras‐chaves especiais e são usadas para acessar membros ou métodos de dentro da
definição da classe.

.! * ! & &/ & ' $ ! & :

(*3! . . 7%&*<& . , I+ S+&! & S . I0
(*3! . . 5* . ' *(! 69 :
&.$ ( & ==QA ?< "> G 0
&.$ &!5==7%&*<& . G 0
E
E
7.! %& , I * ! &I0
&.$ 7.! %&==' *(! 690 " R
* ! &==' *(! 690

Quando uma subclasse sobrecarrega a definição de um método do pai, O PHP não chamará o método pai.
Fica ao encargo da subclasse chamar o método pai ou não. Isso também se aplica a definições de métodos
Construtores e Destruidores, Sobrecarregados e Mágicos também.

.! $ ! & :
( &. &' 5* . % $ 1* . 69 :
&.$ $ ! &==% $ 1* . 69G 0
E
E
.! * ! & &/ & ' $ ! & :
T > 3 &. &F '&5 CD ' ( T
(*3! . 5* . % $ 1* . 69 :
T ' .$ % 5* CD ( T
( & ==% $ 1* . 690
&.$ * ! &==% $ 1* . 69G 0
E
E
7.! & , &; * ! &690
7.! & #% $ 1* . 690

Outro novo recurso adicionado ao PHP 5 é o de interfaces e classes abstratas. Elas são usadas para criar
uma série de restrições sobre a concepção básica de um grupo de classes. Uma classe abstrata define
essencialmente o esqueleto básico de um tipo específico de entidade encapsulada. Por exemplo, você pode
usar uma classe abstrata para definir uma base conceitual de um "carro" como tendo duas portas, um
método de fechar ou abrir portas. Classes abstratas não podem ser usadas diretamente, mas devem ser
estendidas para que a classe descendente forneça um conjunto completo de métodos. Por exemplo:

3 . .! > &<A' ( & :

( + & 7 '0
3 . 5* . & 690
3 . 5* . *(' &690
(*3! . 5* . +&69
:
5 6 < *!!67 $ # '99 :
7 $ #*(' &690
E &! & :
7 $ # & 690
 E
E
E

.! < > &<A' ( & &/ & ' > &<A' ( & :
(*3! . <<. *. 67' 9
:

E
5* . & 69
:

E
5* . *(' &69
:

E
E

Você deve declarar uma classe como abstrata, enquanto ela tiver (ou herdar, sem fornecer um
corpo) pelo menos um método abstrato.

Como você pode ver, neste exemplo, nós definimos uma classe chamada > &<A' ( & e
declaramos dois métodos abstratos chamados & 69 e *(' &69. Observe como esses métodos na
verdade não têm um corpo ‐ que é um dos requisitos das classes abstratas – e como a própria classe deve
ser declarada como abstrata, para que o compilador possa satisfazer os requisitos do analisador sintático.
Em seguida, estender > &<A' ( & em < > &<A' ( & , que já não é abstrata,
porque temos agora um corpo fornecido, tanto para & 69 como para *(' &69

Interfaces

Interfaces, por outro lado, são usadas para especificar uma API que uma classe deve implementar. Isto
permite‐lhe criar um contrato "comum" que as classes devem implementar com o propósito de satisfazer
determinados requisitos lógicos, por exemplo, você poderia usar interfaces para o conceito abstrato de
fornecedor de banco de dados em uma API comum que poderia então ser implementada em uma série de
classes que fazem interface com SGBDs diferentes. Métodos de Interface não podem conter nenhum
corpo:

& 5 .& > &<A' ( & :

(*3! . 5* . & 690
(*3! . 5* . *(' &690
(*3! . 5* . +&690
(*3! . 5* . &;?&. '67 %& , *!!90
E
.! < > &<A' ( & %(!&%& > &<A' ( & :
(*3! . 5* . & 69
:

E
(*3! . 5* . *(' &69
:

E
(*3! . 5* . +&69
:
 E
(*3! . 5* . &;?&. '67 %& , *!!9
:
E
E

Se, no exemplo acima, você não definir todos os métodos para uma interface em particular ou todos os
argumentos para qualquer método de determinada interface (ou seja, não tiver a mesma assinatura), você
vai ver algo como:

1 ! & = ! < > &<A' ( & . 3 . %& $ ' '

%* $& &5 & 3& '&.! &' 3 . %(!&%& $& &% F %& $ '
6 > &<A' ( & == +&9 ' .*%& ! & MP

ou

1 ! & = &.! 5 < > &<A' ( & == &;?&. '69 %* 3&

. %( 3!& ; $ $ 5 > &<A' ( & == &;?&. '69 ' .*%&
! & M

É possível implementar mais de uma interface numa mesma classe. Bastando separá‐las por vírgula:

.! < > &<A' ( & %(!&%& > &<A' ( & 8

>&&@ 3!& & :

Lembre‐se: uma classe só pode estender uma classe pai, mas pode implementar várias interfaces.

.! < > &<A' ( & &/ & ' %(!&%&

> &<A' ( & 8 >&&@ 3!& & :

Determinando Uma classe de objeto

Muitas vezes é conveniente ser capaz de determinar se um determinado objeto é uma instância de uma
determinada classe, ou se ela implementa uma interface específica. Isto pode ser feito usando o operador
.& 5:

5 67 3L .& 5 - ! 9 :
&.$ G7 3L .& 5 - ! 0
E

Naturalmente, .& 5 permite‐lhe inspecionar todas as classes ancestrais de seu objeto, bem
como as interfaces.

Exceções

Mesmo que tenham sido um alimento básico da programação orientada a objeto por anos, as exceções
apenas recentemente se tornaram parte do arsenal PHP. Exceções fornecem um mecanismo de controle de
erro que é mais refinado do que o tratamento de falhas tradicional do PHP, e que permite um grau muito
maior de controle. Existem várias diferenças fundamentais entre erros "regulares" de PHP e exceções:

As exceções são objetos, criados (ou "lançados") quando ocorre um erro;

 Exceções podem ser tratadas em diferentes pontos na execução de um script, e diferentes tipos de
Exceções podem ser tratadas por partes separadas de um código de script;
Todas as exceções não são fatais;
Exceções podem ser lançadas a partir do método <<. *. 69 em caso de falha;
Exceções alteram o fluxo do aplicativo.

A classe Exception Básica

Como mencionado no parágrafo anterior, as exceções são objetos que devem ser instâncias diretas ou
indiretas (por exemplo através de herança) da classe Exceção. Esta última é construída no PHP em si, e é
declarada como segue:

.! /.&( :
$& & %& F& . &' ; $ $ &/.&(
( &. &' 7%& F& , N @ ; /.&( N0
$& & . '& . &' ; $ $ &/.&(
( &. &' 7. '& , 0
$& ( $ %& 5 $& 5 !& ;$& & $& &/.&( ..* &'
( &. &' 75 !&0
$& ! & 5 $& 5 !& ;$& & $& &/.&( ..* &'
( &. &' 7! &0
*.
5* . <<. *. 67%& F& , *!!8 7. '& , 90
?& * $& %& F&
5 ! 5* . F& & F&690
?& * $& & . '&
5 ! 5* . F& '&690
?& * $& 5 !& %&
5 ! 5* . F& 1 !&690
?& * $& 5 !& ! &
5 ! 5* . F& &690
?& * &/&.* 3 .@ .& -
5 ! 5* . F& .&690
?& * 3 .@ .& F
5 ! 5* . F& .&A > F690
?& * F &( & & 5 $& &/.&(
5* . << > F690
E

Quase todas as propriedades de uma exceção são automaticamente preenchidas para você pelo
interpretador, de modo geral, você só precisa enviar uma mensagem e um código, e todas as informações
restantes o PHP cuidará para você. Uma vez que uma exceção é uma classe comum (se embutida), você
pode estendê‐la e efetivamente criar suas próprias exceções, proporcionando assim seus manipuladores de
erro com qualquer informação adicional que sua aplicação requeira.

Lançando Exceções

As exceções são normalmente criadas e acionadas quando um erro ocorre usando a construtor $ ;:

Embora seja uma prática comum, você não precisa criar o objeto /.&( diretamente na
expressão $ ;.

5 67& 9 :
$ ; &; /.&( 6 $ %- & 90
E
As exceções, em seguida, "borbulham" até que sejam tratadas pelo script ou causem uma exceção fatal. O
tratamento de exceções é feita usando um bloco - . .$:

- :
5 67& 9 :
$ ; &;
/.&( 6 $ %- & 90
E
E . .$ 6 /.&( 7&9 :
'!& &/.&(
E

No exemplo acima, qualquer exceção que é lançada dentro do bloco -69será capturada e passada ao
código que está dentro do bloco . .$69, onde pode ser manipulada como você desejar. Observe como
o método . .$69 da declaração obriga‐nos a informar o tipo de exceção que queremos para o
. .$69; uma das melhores características das exceções é o fato de que você pode decidir que tipo de
exceção capturar. Desde que você é livre para estender a Classe pai Exception, isso significa que diferentes
blocos aninhados - . .$ podem ser usados para interceptar e lidar com diferentes tipos de
erros:

.! %- /.&( &/ & ' /.&( : E

- :
- :
- :
&; 6 %- )!='3 %&,O.& 90
$ ; &; %- /.&( 6 A * @ ; & ..* &' 90
E . .$ 6 /.&( 7&9 :
&.$ 7& #F& & F&690
E
E . .$6%- /.&( 7&9 :
&.$ 7& #F& & F&690
E
E . .$ 6 /.&( 7&9 :
&.$ 7& #F& & F&690
E

Nesse exemplo, temos três blocos aninhados - . .$, o mais interno só irá capturar objetos
/.&( , enquanto que o próximo vai pegar os objetos myException comuns e as regiões mais
periféricas irão capturar todas as outras exceções que poderíamos ter perdido. Ao invés de aninhar blocos
- . .$ como fizemos acima, você pode também apenas encadear os blocos . .$:

- :
&; 6 %- )!='3 %&,O.& 90
$ ; &; %- /.&( 6 A * @ ; & ..* &' 90
E . .$ 6 /.&( 7&9 :
&.$ 7& #F& & F&690
E . .$ 6%- /.&( 7&9 :
&.$ 7& #F& & F&690
E . .$ 6 /.&( 7&9 :
&.$ 7& #F& & F&690
E

Uma vez que uma exceção tenha sido capturada, a execução do script seguirá diretamente após o último
bloco . .$. Para evitar erros fatais de exceções não capturadas, você poderia envolver toda a sua
aplicação em um bloco - . .$ ‐ o que, contudo, poderia ser bastante inconveniente.
Felizmente, há uma solução melhor – o PHP nos permite definir uma função ". .$ !!", que é
chamada automaticamente sempre que uma exceção não é tratada. Esta função é configurada chamando
& <&/.&( <$ '!& 69:

5* . $ '!& . *F$ /.&( 67&9

:
&.$ 7& #F& & F&690
E
& <&/.&( <$ '!& 6 $ '!& . *F$ /.&( 90
$ ; &; /.&( 6 * . *F$ %& 90
&.$ $ &+& ' (! -&' 0

Note que, devido o manipulador de exceção ". .$‐ !!” ser chamado apenas após a exceção ter
borbulhada por todo o script, ele, assim como um bloco abrangente - . .$, é o fim da linha para
o seu código. Em outras palavras, a exceção já causou um erro fatal, e a você será apenas dada a
oportunidade de lidar com isso, mas não recuperar a partir dela. Por exemplo, o código acima nunca terá
uma saída “You caught me!”, porque a exceção gerada irá disparar e causar o manipulador de exceção
$ '!& . *F$ /.&( 69, fazendo com que o script termine.

: Se você deseja restaurar o manipulador de exceção anteriormente usado, seja ele o padrão
de um erro fatal ou outro definido pelo usuário, você pode usar
r& &<&/.&( <$ '!& 69.

Exercícios:

Construa um programa com as seguintes características: uma classe Conta abstrata com os métodos
abstratos F& > !' 69, . 6+ ! 9 e '&( 6+ ! 9. A seguir, cria duas classes,
& & e *( C , sendo que a classe *( . deverá estender a classe
& &, mas contendo um método &%* & 6 &%( 9 que aplicará regras de
, ou seja, a remuneração incide apenas sobre o montante principal, a uma taxa
constante de 10% ao mês. Não se esqueça de definir a classe Conta como abstrata e de inicializar as duas
classes ( *( . e & &) com um saldo inicial. Instancie ambas as classes com um
valor inicial de R$100,00, exiba os saldos, faça saques e remunere o capital da conta poupança exibindo os
valores na tela. Tente fazer sem olhar a resposta abaixo:

4($(
3 . .! :
(*3! . 7 !' 0
(*3! . 3 . 5* . F& > !' 690
(*3! . 3 . 5* . . 67+ ! 90
(*3! . 3 . 5* . '&( 67+ ! 90
E

.! & & &/ & ' :

(*3! . 5* . <<. *. 67+ ! 9 :
7 $ # !' , 7+ ! 0
E
(*3! . 5* . F& > !' 69 :
& * 7 $ # !' 0
E
(*3! . 5* . . 67+ ! 9 :
5 67+ ! # 7 $ #F& > !' 699
7 $ # !' ,7+ ! 0
&! & &.$ >>UQ A? >> QA ? 0
E
(*3! . 5* . '&( 67+ ! 9 :
 5 67+ ! 9 &.$ Q .V D ( '& . & & + ! 0
&! & 7 $ # !' W,7+ ! 0
E
E
.! *( .
&/ & ' & & :
( + & . 7 / , 0 H %V
(*3! . 5* . <<. *. 67+ ! 9 :
7 $ # !' , 7+ ! 0
E
(*3! . 5* . &%* & 67 &%( 9 :
7 $ # !' W, 7 $ # !' T6 &!5==7 / T 7 &%( 90
E
E

7. , &; & &6 90

7.M , &; *( . 6 90
&.$ 7. #'&( 6 90
&.$ 7. #F& > !' 690
&.$ $ # 0
&.$ 7.M #'&( 6M 90
&.$ 7.M # &%* & 6M90
&.$ 7.M #F& > !' 690
4#

Introdução ao MVC com CodeIgniter e PHP

Encontrei esse tutorial sobre MVC que utiliza um framework para permitir maior produtividade no
desenvolvimento de software em PHP, conforme exigido na prática profissional da disciplina. Este
tutorial foi extraído do endereço $ (= ( F % ' % 3! F ( . % e
adaptado ao português brasileiro. Este tutorial tem como objetivo abordar o desenvolvimento de
aplicações web seguindo uma arquitetura conhecida como arquitetura MVC – Model, View,
Controller. A ferramenta utilizada neste tutorial será o framework CodeIgniter.

O que é Framework?

Em desenvolvimento de software, um framework ou arcabouço é uma abstração que une códigos

comuns entre vários projetos de software provendo uma funcionalidade genérica. Um framework
pode atingir uma funcionalidade específica, por configuração, durante a programação de uma
aplicação. Ao contrário das bibliotecas, é o framework quem dita o fluxo de controle da aplicação,
chamado de Inversão de Controle. Ainda, framework é um conjunto de classes que colaboram
para realizar uma responsabilidade para um domínio de um subsistema da aplicação. (Extraído da
Wikipédia)

O que é o MVC?

O MVC, Model View Controller, é um padrão de desenvolvimento de aplicações, normalmente,

mas não forçosamente, web. A implementação de aplicações usando este padrão são feitas com
recurso a frameworks, apesar de não ser obrigatória a utilização de um para seguir o padrão.

Camadas e respectivas funções

 Model: Nesta camada são definidas as regras de acesso e manipulação dos dados, que
normalmente são armazenados em bases de dados ou arquivos, mas nada indica que sirva
só para alojamento persistente dos dados. Pode ser usado para dados em memória volátil,
por exemplo: memória RAM, apesar não se verificar tal utilização com muita freqüência.
Todas as regras relacionadas com tratamento, obtenção e validação dos dados devem ser
implementados nesta camada.
View: Esta camada é responsável por gerar a forma como a resposta será apresentada,
página web, formulário, relatório, etc.
Controller: É a camada responsável por responder aos pedidos por parte do usuário.
Sempre que um usuário faz um pedido ao servidor esta camada é a primeira a ser
executada.

Cadeia de Funcionamento

Esta é a cadeia normal de funcionamento deste padrão, em que todas as camadas são usadas, o
que nem sempre acontece:

1. O usuário efetua um pedido ao servidor

2. O controller processa o pedido do usuário.
3. O controller efetua uma chamada ao model, para obter ou manipular dados.
4. O model devolve os dados pedidos que serão passados ao view.
5. A view gera a apresentação dos dados, por exemplo: uma página HTML.

Existe a possibilidade, bastante freqüente, de um pedido não precisar invocar o model. Basta
querer gerar conteúdo que não necessite de qualquer tipo de dados. Neste caso o controller
chamará diretamente o view. Existe também a possibilidade de não ser gerada uma view, por
exemplo: o pedido ser uma atualização de dados. Apesar de não ser necessário é recomendado
fazê‐lo, as regras de interação obrigam a que se notifique o usuário do sucesso de uma operação,
ou seja, a utilização de uma view.

Frameworks Existentes:

Existem diversas frameworks que cobrem inúmeras linguagens, algumas só para web e outras
mais genéricas:

PHP: CodeIgniter, CakePHP, Symfony, Zend Framework, etc.

Ruby: Ruby on Rails, etc.
Python: Django, Zope, TuboGears, etc.
Java: J2EE, Spring Framework, etc.
Mono/.NET: Monorail, etc.

Nota: Estes são os frameworks mais populares tendo em conta que são Software Livre, existem
outros proprietários, que obviamente não recomendo.

Por que o CodeIgniter?

A resposta curta: porque simplesmente estou utilizando‐o no momento. A resposta comprida: os

critérios para o tutorial foram os mesmos para o meu projeto. A questão da linguagem caiu
obviamente para o PHP, quer pela sua popularidade em aplicações web, quer pelo fato de ser
bastante fácil obter serviços de alojamento que o suportem. Quanto ao framework, já utilizei o
Symfony e já brinquei com o CakePHP e estou agora a utilizar o CodeIgniter. A escolha deste
framework recaiu sobre os seguintes critérios: é simples e com um desempenho bastante bom e a
sua abordagem é bastante mais direta que o CakePHP e o Symfony. Esta última é mais complexa,
apesar de não ser de todo uma desvantagem. Escolhi o CodeIgniter por ter a "melhor relação
custo/qualidade".

Para utilizar este framework basta qualquer servidor HTTP com suporte a PHP. É extremamente
provável que a aplicação que deseja desenvolver necessite de uma base de dados, estão
disponíveis os motores livres PostgreSQL, MySQL e SQLite juntamente com outros proprietários. O
primeiro passo é a instalação do framework. Nada mais simples.

Fazer o download do framework em $ (= . '& F & . % ' ; ! ' ($(

Descomprimir o arquivo.
E copiar o conteúdo do diretório '& F & </ / // para o seu diretório web.

Nota: Evite desenvolver a partir do seu servidor de hospedagem. Se desejar trabalhar num
ambiente semelhante a um ambiente real, será boa idéia recorrer a máquinas virtuais. Depois no
browser abrir: $ (= ! . !$ ( <'&< 3 !$ '&/ ($(, se tudo correu
bem então está pronto a começar a trabalhar. Como ambiente de desenvolvimento recomendo a
IDE Eclipse com o plugin PHP Edit (ou mesmo o PDT) ou o NetBeans da SUN também com o plugin
PHP. São ferramentas bastante robustas, de fácil utilização, que completam automaticamente o
código e que funcionam bem com este framework. Podem fazer download a partir do site oficial e
instalar o plugin PHP posteriormente, ou fazer o download personalizado com as funcionalidades
que desejar no site yoxos.

Estrutura de diretórios

O framework é constituído por um conjunto de diretórios por onde estão espalhados os diversos
componentes que o compõem. Ao instalar, verá que existe um diretório de documentação na raiz.
Você poderá mantê‐lo ou apagá‐lo, poderá mantê‐lo durante o desenvolvimento da aplicação,
mas deverá apagá‐lo quando disponibilizar a aplicação online, a não ser que queira disponibilizar
essa documentação online. Existe também um arquivo index.php, este tem obrigatoriamente que
existir, pois todos os pedidos à aplicação se iniciam a partir dele. Por fim, temos o diretório system
onde existem os seguintes diretórios:

application: este será o diretório onde fará o desenvolvimento da sua aplicação. Em

condições normais será o único a sofrer alterações durante o desenvolvimento.
cache: o cache do sistema, onde são criados arquivos temporários que permitem o
aumento da performance da aplicação.
codeigniter: o "motor" do framework.
database: controladores de base de dados.
fonts: tipos de letra.
helpers: coleções de funções de auxilio ao desenvolvimento que, por exemplo, poderão
ajudar a criar elementos de uma página de uma forma mais simples.
language: arquivos com termos usados pela framework numa determinada língua.
Instalação do Português padrão.
 library: biblioteca com as classes de referência que podem ser utilizadas no
desenvolvimento da aplicação.
logs: logs de sistema
plugins: similar aos helpers, só que em vez de uma coleção de funções os plugins apenas
disponibilizam uma função.
scaffolding: motor de scaffolding. Permite a gerar automaticamente páginas de
visualização, criação, edição e eliminação de dados a partir de tabelas da base de dados.
Esta ferramenta apenas deve ser utilizada durante o desenvolvimento, pois não oferece
qualquer garantia de segurança. Este modelo de scaffolding deixou de ser oficialmente
suportado e será substituído, pelo que não deverá ser abordado para já nesta série de
tutoriais.

Dentro da pasta application temos um conjunto de diretórios orientado para o desenvolvimento

da aplicação. Os diretórios helpers, languages e libraries são equivalentes aos que encontramos no
diretório system, mas neste caso destinam‐se a componentes criados especificamente para o seu
projeto. Os diretórios restantes são os seguintes:

config: arquivos de configuração.

controllers: local onde criará os seus controllers.
errors: páginas de erro personalizadas, como por exemplo o famoso 404‐Not Found
hooks: extensões ao CodeIgniter, onde poderá criar funções ou classes que serão
executadas em determinados momentos do fluxo de processamento da aplicação.
models: local onde criará os seus models.
views: local onde criará as suas views.

Olá mundo

Para variar vamos começar com a criação de um programa Olá Mundo. A maneira mais simples de
fazê‐lo é utilizar apenas um controlador. Vá à pasta controllers e crie um arquivo chamado
primeiro.php e edite‐o. Nele escreva o seguinte código:
4($(
%& !!&
:

69
:
( & == 690
E

69
:
I !S * ' I
E
E
4#

Se digitar no seu web browser o endereço $ (= ! . !$ '&/ ($( ( %&

obterá uma página com o texto “Olá Mundo”. O exemplo começa pela declaração de uma classe
que herda as características de classe do CodeIgniter Controller, todos os controllers são
subclasses de !!& , o nome da classe e do arquivo são iguais, a única diferença é que o
nome da classe deve começar sempre com maiúscula. Depois temos duas funções: a função
%& 69 é o construtor da classe, que neste caso apenas chama o construtor da sua
superclasse, este pode ser usado para carregar qualquer tipo de componente do sistema; a
segunda função é uma atividade do controlador, normalmente todos os controladores têm uma
função index que é chamada sempre que esse controlador é invocado sem que seja invocada
qualquer função. Vamos acrescentar mais uma função ao nosso controlador:
4($(
%& !!&
:
6 9

69
:
I * F %* '& 5& %& I0
E
E
4#

OBS: o PHP 5 utiliza o construtor <<. *. 69

Esta função é similar à anterior, apenas serve para demonstrar o funcionamento dos endereços.
Neste caso, para invocar esta atividade do controlador deverá digitar o endereço:

$ (= ! . !$ '&/ ($( ( %& (

A estrutura padrão dos endereços é:

'&/ ($( " %& ' ! ' A + ' '& 5 % CD . %(!&%&

Caso não seja especificada nenhuma atividade, será sempre executada a função '&/, como no
primeiro exemplo, pelo que deverá existir sempre um '&/ em cada controlador.

OBS: Agora, é bom configurar o arquivo config.php na pasta . 5 F dentro da pasta

((! . . Nela, existe uma linha 7. 5 FXI3 &<* !IY ,
$ (= &/ %(!& . % . Altere‐a para o endereço que você vai utilizar em seu aplicativo. Por
exemplo: Z$ (= ! . !$ ( <'&< 3 !$ [.

Views

As views são arquivos PHP que contêm código HTML e chamadas PHP responsáveis pela
apresentação dos dados. No exemplo anterior eram os controladores que apresentavam qualquer
conteúdo na página, o que não é prático nem segue a norma MVC, pelo que vamos fazer algumas
alterações. Primeiro vamos acrescentar uma nova view, no diretório + &; crie o arquivo
%& F&% ($( com o seguinte conteúdo:

$ %!#
$& '#
!&# 4($( 7 !& 4# !&#
$& '#

3 '-#
$ # 4($( 7%& F& 4# $ #
3 '-#
$ %!#
Esta view será invocada por ambos os controladores e como podemos observar serão passadas
duas variáveis: !& que definirá o título a aparecer na janela do browser e %& F& que terá
a mensagem que aparecerá na página web. Para utilizar a view vamos alterar ambas as ações do
controlador.

4($(
%& !!&
:

69
:
( & == 690
E

69
:
7' XI !&IY,I %& /&%(! I0
7' XI%& F&IY,I !S * ' I0
7 $ #! ' # 6I%& F&%I87' 90
E

69
:
7' XI !&IY,IA % $ ( D I0
7' XI%& F&IY,I * F %* '& 5& %& I0
7 $ #! ' # 6I%& F&%I87' 90
E
E
4#

Agora o funcionamento ficou ligeiramente alterado. Para passar dados a uma view é necessário
criar um vetor associativo em que o índice terá correspondência a uma variável com o mesmo
nome na view. A última linha de cada atividade é uma chamada à view onde o primeiro parâmetro
corresponde ao nome do arquivo da view (a extensão PHP pode ser omitida), e o segundo
corresponde à estrutura com os dados a serem passados. Não há qualquer obrigação de passar
dados para uma view, pelo que nestes casos deverá apenas invocar a view apenas com o primeiro
parâmetro. Para uma view podem ser passados dados de qualquer tipo, sejam eles numéricos,
texto, objetos ou outras estruturas de dados. O próximo exemplo demonstra como passar um
vetor para a view e como este normalmente é tratado. Crie uma nova view chamada
( . ($( com o seguinte conteúdo:

$ %!#
$& '#
!&# % ! '& \( . !&#
$& '#

3 '-#
*!#
4($( 67 ( . 7 ( .9= 4#
! # 4($( 7 ( . 4# ! #
4($( 4#
*!#
3 '-#
$ %!#

Aqui a única diferença é que é usado um ciclo 5 & .$ para escrever cada um dos elementos na
página. Para pôr esta view para funcionar necessitamos criar uma atividade no nosso controlador
que o invoque, por isso vamos adicionar a função ( . 69 no arquivo ( %& ($(:
 69
:
7' XI ( . IY , 6I '&!I8 IQ &;I8 I !!& I90
7 $ #! ' # 6I ( . I8 7' 90
E

Nada mais simples. No diretório views é possível criar subdiretórios para organizá‐las. Para invocar
essas views deverá incluir o nome do diretório na sua chamada:
7 $ #! ' # 6I' &. - ( . I90

E assim terminamos este capítulo, no próximo serão abordados o uso de bases de dados e os
modelos.

Acesso a dados
Depois de termos dado uma visão global ao padrão MVC e de dar os primeiros passos com o
framework CodeIgniter, abordaremos uma parte também importante de uma aplicação web: o
acesso a bases de dados.

Criação da base de dados e configurar o acesso

Ao contrário de alguns frameworks, como por exemplo, o Symfony, o Django, etc., o CodeIgniter
não possui nenhum mecanismo próprio para criação de bases de dados, à semelhança do que
acontece no Ruby on Rails ou no CakePHP, motivo pelo qual teremos que criá‐lo. O CodeIgniter
segue um padrão de acesso a dados conhecido como Active Record que será demonstrado mais à
frente. Para este capítulo, apenas iremos utilizar a seguinte tabela utilizando o MySQL:

]* & ] 6
] '] 6 9 8
]* & %&] + .$ 6M 9 .$ . & ! 8
]( ;'] + .$ 6 9 .$ . & ! 8
] ! ] + .$ 6 9 .$ . & ! 8
]&% !] + .$ 6 9 .$ . & ! 8
! "# $ % $ 6] ']9
90

Agora vamos configurar o acesso à base de dados no CodeIgniter, dentro do diretório

((! . . 5 F editem o arquivo ' 3 & ($(:

7 . +&<F *( , '&5 *! 0
7 . +&< &. ' , ? 0

7'3XI'&5 *! IYXI$ %&IY , ! . !$ 0

7'3XI'&5 *! IYXI* & %&IY , 0
7'3XI'&5 *! IYXI( ; 'IY , 0
7'3XI'&5 *! IYXI' 3 &IY , ' 0
7'3XI'&5 *! IYXI'3' +& IY , %- )! 0
7'3XI'&5 *! IYXI'3( &5 /IY , 0
7'3XI'&5 *! IYXI(. &. IY , ? 0
7'3XI'&5 *! IYXI'3<'&3*FIY , ? 0
7'3XI'&5 *! IYXI. .$&< IY , 1A > 0
7'3XI'&5 *! IYXI. .$&' IY , 0
7'3XI'&5 *! IYXI.$ < & IY , * 52 0
7'3XI'&5 *! IYXI'3. !! IY , * 52<F& & !<. 0
O arquivo em si não tem muito que saber. Basta alterar o valor de cada elemento com os dados
respectivos. Para seguir este tutorial será necessário ter a variável 7 . +&< &. ' fixada
como TRUE. O passo seguinte será configurar o acesso à classe de base de dados. Isto pode ser
feito de dois modos: ativar o carregamento automático da classe ou carregá‐la no construtor de
cada Controller ou Model:

& !!&
:
!
69
:
( & == 690
7 $ #! ' # & 690
E
E

"
# " $# #
% % & '% %(
7 * ! 'XI! 3 & IY , 6I' 3 &I90

Para verificar se a conexão à base de dados está funcionando basta executar o seu browser e abrir
o url da sua aplicação. Se não foi informado algum erro, então está tudo ok.

Nota: A escolha de utilização de carregamento automático ou não classes está dependente do tipo
de projeto. Se for uma classe utilizada por todos os controladores recomenda‐se o carregamento
automático de modo a poupar algum esforço. Se essa classe apenas for utilizada por algumas
funcionalidades então recomendo que se faça o carregamento apenas quando necessárias para
evitar sobrecarregar os controladores com material desnecessário.

Ler registros da base de dados

A exibição de dados é certamente a tarefa mais comum em aplicações web. Para demonstrar
como realizar este tipo de tarefas vamos criar duas atividades num controlador & em
. !!& * & ($(=

* & !!
* & $ ; 7 '

Para testar este exemplo recomendo que introduzam alguns dados na tabela * & :

4($(
& !!&
:
69
:
( & == 690
7 $ #! ' # 6I* !I90
E

69
:
 7' XI! IY,7 $ #'3 #' 6I* & I90
# )
7 $ #! ' # 6I* & !!I87' 90
E

69
:
* +,
- .
7* & %& , 7 $ #* # ' 6 8 90

67* & %& ,, 9

:
-
6I* & !!I90
E

:
7 & *! , 7 $ #'3 #' 6
I* & I8
6I* &%&I ,# 7* & %&990
/
7' XI* & IY , 7 & *! # 690
7 $ #! ' # 6I* & $ ;I87' 90
E
E
E
4#

E agora as duas * & !! e * & $ ;:

* & !!=

$ # '& * *S $ #

3!&#
#
$# & %& $#
$# % ! $#
$# $#
#

4($( 67! # 69 7* & 9= 4#

#
'# 4($( 7* & #* & %& 4# '#
'# 4($( 7* & #&% ! 4# '#
'# 4($( 6I* & $ ; I 7* & #* & %&904# '#
#
4($( 4#
3!&#

* & $ ;=

(# 3# & %&= 3# 4($( 7* & #* & %& 4# (#

(# 3# % != 3# 4($( 7* & #&% ! 4# (#

Os métodos mais importantes para este exemplo são:

7 $ #'3 #F& 6I 3&! I9 Devolve todos os dados da tabela (> T 1?

3&! )
 7 $ #'3 #F& <;$& &6I 3&! I8 . ^ 9 seleciona todos os registro
que correspondam a um critério.

Os registros devolvidos são armazenados numa estrutura em memória da qual se pode extrair
cada um deles como instância de um objeto Active Record, como neste exemplo, ou
alternativamente num array associativo. Neste exemplo foram usados dois métodos: & *! 69
e ;69. O método & *! 69, usado na view * & !! gera uma lista de objetos ;, cada
um deles representa um registro. O método ;69 extrai diretamente uma linha, o que é muito
útil para casos como este em que a consulta à base de dados devolve uma única linha, caso
devolva mais que uma linha o método ;69 devolverá apenas a primeira linha.

Neste exemplo utilizou‐se o helper url. Esse fornece, entre outras, a função .$ que nos
permite criar hyperlinks de forma dinâmica para outras funcionalidades da nossa aplicação. No
exemplo acima podemos ver que esta é utilizada para criar ligações para a página show de cada
registro. Outra função a destacar que utilizamos é a função * # &F%& que extrai
elementos da nossa url, neste caso o username. O segundo parâmetro é opcional e indica o valor
por omissão caso se invoque essa funcionalidade sem fornecer o username.

Modelos

Como foi explicado no primeiro tutorial, no padrão MVC o Model é responsável pela abstração do
acesso a dados. O que se passa no CodeIgniter é que o padrão Active Record já faz isso de uma
forma mais geral. É possível criar um projeto sem ter que implementar classes do tipo modelo,
mas para casos mais específicos, como consultas mais complexas, é recomendado implementar
essas funções numa classe '&!. Podemos reestruturar o exemplo anterior tendo em conta os
seguintes aspectos:

Estamos requisitando à tabela todos os campos de um registro quando apenas utilizamos

dois deles
Podemos criar métodos para obter os dados prontos a ser exibidos, encurtando o tamanho
dos nossos controladores

Para isso vamos criar uma classe * & <% '&! ($( no diretório % '&! :

4($(
& <% '&! '&!
:
' ( & 67* & %&9
:
#
7 $ #'3 # 6I* & %&8 &% !I90
7 & *! , 7 $ #'3 #' 6
I* & I8
6I* & %&I ,# 7* & %&990
7 & *! # 690
E

' ( & 69
:
7 $ #'3 # 6I* & %&8 &% !I90
7 & *! , 7 $ #'3 #' 6I* & I90
7 & *! # 690
E
E
Neste exemplo, criamos duas funções que retornam os resultados apenas com os dados que
desejamos exibir. O método &!&. da classe '3 encarrega‐se de definir os campos a retornar
pela próxima consulta à base de dados. Agora falta‐nos alterar o controlador para utilizar o
% '&!.

4($(
& !!&
:
69
:
( & == 690
7 $ #! ' # 6I* !I90
7 $ #! ' # 6I* & <% '&!I90
E

69
:

0
7' XI! IY ,
7 $ #* & <% '&! #' ( & 690
7 $ #! ' # 6I* & !!I87' 90
E

69
:
* +,
- .
7* & %& , 7 $ #* # ' 6 8 90

67* & %& ,, 9

:
6I* & !!I90
E

:
7' XI* & IY ,
7 $ #* & <% '&! #) ( & 67* & %&90
7 $ #! ' # 6I* & $ ;I87' 90
E
E
E
4#

Para completar, como o método B& A!! (! - 3!&69 já retorna uma lista & *! ,
devemos ir ao código da view user/all e remover a chamada ao método & *! 69 no ciclo
5 & .$ para que tudo funcione devidamente.

Inserir dados, Formulários e Validação

No que diz respeito à validação, será usado o novo sistema 5 %<+ ! ' introduzido na
versão 1.7.0. Em qualquer página web com validação de dados existe o seguinte ciclo de validação:

1. Pedir os dados ao usuário;

2. Verificar os dados;
3. Caso os dados não sejam válidos exibir erros e voltar ao ponto um;
4. Tratar os dados.
Começando pela solicitação de dados, vamos criar uma view * & &F & ($( com o
seguinte conteúdo:

4($( + ! ' <& 69 4#

4($( 6I* & &F & I9 4#

5 &!' & #
! 3&! , * & %& # *S = ! 3&!#
(* -(&, &/ ', * & %& + !*&, #
! 3&! , ( ; ' # ! + &= ! 3&!#
(* -(&, ( ; ' ', ( ; ' + !*&, #
! 3&! , . 5 % # 5 % = ! 3&!#
(* -(&, ( ; ' ', . 5 % + !*&, #
! 3&! , &% ! # % ! ! 3&!#
(* -(&, &/ ', &% ! + !*&, #
5 &!' & #
(* -(&, *3% + !*&, + #
5 %#

A view acima é um formulário típico em PHP/HTML. Na primeira linha serão impressas as

mensagens de erro caso a validação dos dados falhe. Recorre‐se também à função 5 %< F
para gerar uma tag form que chamará o controlador responsável por validar e armazenar os
dados. Agora para armazenar os dados resta‐nos criar o controlador para o efeito. Mas antes disso
vamos preparar a nossa classe modelo para guardar este tipo de dados. Lembre‐se que estamos a
criar um formulário para registro de usuários e dados sensíveis como a password não serão
armazenados no formato em que são inseridos. A palavra passe será transformada antes de ser
armazenada recorrendo à função de hashing sha1 utilizando uma chave salt para impedir a
obtenção da senha através de dicionários de hash conhecidos. Ao modelo * & <% '&! ($(
serão acrescentados os seguintes métodos:
4($(
( + & ! 67( ; '9
:
1
7' XI ! IY , *6 6990
# )
7' XI( ; 'IY , *67' XI ! IY 7( ; '90
7' 0

' 69
:
7' XI* & %&IY , 7 $ # (* # 6I* & %&I90
7$ $ , 7 $ # ! 67 $ # (* # 6I( ;'I990
7' XI( ;'IY , 7$ $XI( ; 'IY0
7' XI ! IY , 7$ $XI ! IY0
7' XI&% !IY , 7 $ # (* # 6I&% !I90

7 $ #'3 # 6I* & I8 7' 90

E
4#

O método &F & guarda os dados, depois de codificar a password. Usando o método
& do Active Record a inserção de dados não poderia ser mais simples, basta um array
associativo em que o índice corresponde ao nome do campo na tabela e depois passá‐lo como
argumento da função & . Para obter os dados enviados pelo formulário podem usar o
método 7 $ # (* #( 6I %&I9 ou acessar diretamente ao respectivo elemento no
array post: 7< > XI %&IY. O método $ $ ; ' é responsável apenas por gerar um
hash e um salt para a senha. Por fim, no controlador * & 8 vamos criar um método &F &
que, neste exemplo, será responsável por criar as regras e executar o ciclo de validação:

4($(

' 69
:
2- #
7. 5 F, 6
6
I5 &!'I ,# I* & %&I8
I! 3&!I ,# I" %& '& *S I8
I *!& I ,# I &)* &'_% <!& F $X Y_% /<!& F $XM YI
98
6
I5 &!'I ,# I( ;'I8
I! 3&!I ,# I ! + &I8
I *!& I ,# I &)* &'_% <!& F $X`Y_% .$& X. 5 %YI
98
6
I5 &!'I ,# I. 5 %I8
I! 3&!I ,# I 5 % CD '& ! + &I8
I *!& I ,# I &)* &'I
98
6
I5 &!'I ,# I&% !I8
I! 3&!I ,# I % !I8
I *!& I ,# I &)* &'_+ ! '<&% !I
9
90

3 # 10 0 2- 2-
7 $ #5 %<+ ! ' # 67. 5 F90
4 2-
667 $ #5 %<+ ! ' # 699,,1A > 9
:
2- -
-
7 $ #! ' # 6I* & &F & I90
E

:
2-
7 $ #* & <% '&! # ' 690
# #"
6I* & *..& I90
E
E

4#

Nesse exemplo, recorremos ao método de criar um array com todas as regras de validação a
aplicar. Nesse array, cada elemento possui três campos:

5 &!': possui o nome do campo a avaliar, deverá obrigatoriamente corresponder ao id do

elemento do formulário que fornecerá esses dados.
! 3&!: contém uma identificação do campo, compreensível pelos usuários, a aparecer na
mensagem de erro.
 *!& : aqui são declaradas as regras a ser aplicadas ao campo, as mais comuns são:
&)* &', campo obrigatório; % <!& F $ % /<!& F $, definem os limites de
tamanho em caracteres dos dados inseridos; + ! '<&% !, endereço de correio
eletrônico válido, etc.

A estrutura 5 no exemplo garante a execução do ciclo de validação. Na primeira chamada ao

controlador, invocada pelo usuário, a validação falha sempre sem qualquer erro, por isso é exibida
a view com o formulário. O usuário ao enviar os dados faz com que o controlador seja de novo
invocado e a validação executada. Se falhar será reexibido o formulário com as respectivas
mensagens de erro. Caso os dados estejam corretamente inseridos, serão guardados na base de
dados. Após o armazenamento o controlador os redireciona para uma página de sucesso que não
foi listada neste exemplo, dada a sua simplicidade deixo‐a ao critério de cada um.