3724 Pdflinguagemprog

CURSO DE SISTEMAS Linguagem
DE INFORMAÇÃO
de Programação
www.esab.edu.br
Linguagem de
Programação
Vila Velha (ES)

2014
Escola Superior Aberta do Brasil
Diretor Geral
Nildo Ferreira
Diretora Acadêmica
Beatriz Christo Gobbi
Coordenadora do Núcleo de Educação a Distância
Beatriz Christo Gobbi
Coordenadora do Curso de Administração EAD
Rosemary Riguetti
Coordenador do Curso de Pedagogia EAD
Claudio David Cari
Coordenador do Curso de Sistemas de Informação EAD
David Gomes Barboza
Produção do Material Didático-Pedagógico

Delinea Tecnologia Educacional / Escola Superior Aberta do Brasil
Diretoria Executiva Designer Educacional

Charlie Anderson Olsen Aline Batista
Larissa Kleis Pereira Revisão Gramatical
Margarete Lazzaris Kleis Bárbara Seger Zeni
Conteudista Designer Gráfico
Egon Sewald Junior Laura Rodrigues
Coordenação de Projeto Neri Gonçalves Ribeiro
Andreza Regina Lopes da Silva Diagramação
Supervisão de conteúdo Dilsonir José Martins Junior
Renata Oltramari Equipe Acadêmica da ESAB
Liderança Técnica Design Gráfico Coordenadores dos Cursos
Fernando Andrade Docentes dos Cursos
Liderança Técnica Revisão Gramatical
Tiago Costa Pereira
Laís Gonçalves Natalino
Copyright © Todos os direitos desta obra são da Escola Superior Aberta do Brasil.
www.esab.edu.br
Av. Santa Leopoldina, nº 840
Coqueiral de Itaparica - Vila Velha, ES
CEP 29102-040
Apresentação
Caro estudante,
Seja bem-vindo à disciplina de Linguagem de Programação. Esta disciplina faz parte

do núcleo de formação básica do curso de Sistemas de Informação, que tem como
objetivo o desenvolvimento tecnológico da computação. Serão trabalhados conceitos
de programação, especificamente a linguagem PHP (Hypertext Preprocessor).
A Linguagem de Programação servirá como base para o desenvolvimento de

aplicações web, de forma a possibilitar que você produza sites dinâmicos, com
interação com o usuário, fazendo uso de formulários, controle de seções e
gerenciamento de arquivos. A linguagem PHP permite a interação com banco de
dados e, com esse conhecimento, você poderá, por exemplo, implementar um
cadastro de clientes ou usuários, manipular e gravar dados de formulários ou mesmo
codificar lojas virtuais. A linguagem é criada e mantida por uma comunidade de
desenvolvedores, sendo, portanto, open-source, o que significa que você poderá
desenvolver aplicativos sem pagar licença de uso para distribuição. Trata-se de
uma linguagem extremamente simples para um iniciante, mas que oferece muitos
recursos para o programador profissional.
Utilizaremos como Ambiente Integrado de Desenvolvimento (IDE, sigla para

Integrated Development Environment) o software Eclipse PDT, mantido pela Eclipse
Foundation e de uso livre, sem pagamento de licenças. Um IDE é um ambiente de
desenvolvimento no qual pode-se editar, depurar e visualizar o código, além de
acompanhar a execução, passo a passo, do programa, controlando a execução e o
código de origem. Assim, um IDE tem recursos que você não encontra em um editor
de textos comum, como no Bloco de Notas. Também utilizaremos o servidor Apache,
a fim de hospedar as nossas aplicações – a instalação dessas ferramentas será vista
mais à frente.
Para essa disciplina, utilizaremos como bibliografia básica os livros de Manzano

e Toledo (2008), Meloni (2000) e Thomson e Welling (2005) e, como bibliografia
complementar, poderá ser usado o livro de Nielsen e Loranger (2007).
Esperamos que esta disciplina possa lhe acrescentar os conhecimentos necessários

para o desenvolvimento de aplicações web com diversas características.
Bons estudos!
Objetivo
Proporcionar, de maneira prática, conhecimentos para que você seja capaz de
desenvolver aplicações web com interação com o usuário, controle de seções e
gerenciamento de arquivos. Dessa forma, ao final da disciplina, você deverá contar
com a capacidade de desenvolver aplicações completas voltadas para web em
linguagem PHP. Os temas serão apresentados, principalmente, através de exercícios
práticos.
Habilidades e competências
• Desenvolver aplicações web utilizando PHP, compreendendo a sua arquitetura.
• Desenvolver aplicações web gerenciando arquivos.
• Desenvolver aplicações web com verificação de formulários, gerenciamento de
cookies, seções, upload de arquivos e segurança.
• Analisar as aplicações web estruturadas e organizadas, interativas.
• Analisar, planejar, projetar, desenvolver e testar sistemas em ambientes web.
• Compreender os critérios de bom funcionamento de aplicações web, com
gerenciamento de seções e arquivos, buscando o seu uso.
Ementa
Introdução à programação para web utilizando a linguagem PHP (Personal
Home Page). Arquitetura de aplicações para internet. JavaScript para a criação
de websites dinâmicos e interativos. Programação com execução na máquina-
cliente e na máquina-servidor, bem como vantagens, desvantagens e limitações.
Definição e implementação das funcionalidades: verificação de formulários,
gerenciamento de cookies, seções, upload de arquivos e segurança.
Sumário
1. Desenvolvimento prático de website - parte 1.................................................................7
2. Desenvolvimento prático de website - parte 2...............................................................13
3. Introdução à PHP...........................................................................................................23
4. História da linguagem PHP............................................................................................30
5. Arquitetura de aplicação web com PHP..........................................................................34
6. Efetuando a instalação e a configuração do servidor Apache
e de ferramenta de edição PHP......................................................................................39
7. Embutindo PHP no HTML...............................................................................................48
8. Tipos de dados PHP........................................................................................................53
9. Utilizando operadores em PHP.......................................................................................60
10. Utilizando instruções condicionais – parte 1..................................................................67
11. Utilizando instruções condicionais – parte 2..................................................................74
12. Utilizando instruções de repetição – parte 1..................................................................80
13. Utilizando instruções de repetição – parte 2..................................................................86
14. Desenvolvendo uma página simples com uso de PHP....................................................92
15. Armazenando e recuperando dados – parte 1.............................................................100
16. Armazenando e recuperando dados – parte 2.............................................................106
17. Utilizando vetores e matrizes – parte 1........................................................................112
18. Utilizando vetores e matrizes – parte 2........................................................................118
19. Manipulando strings....................................................................................................125
20. Desenvolvendo aplicativo, manipulando strings..........................................................134
21. Manipulando expressões regulares – parte 1...............................................................140
22. Manipulando expressões regulares – parte 2...............................................................145
23. Desenvolvendo uma aplicação e manipulando dados
em forma de arquivos – parte 1...................................................................................151
24. Desenvolvendo uma aplicação e manipulando dados
em forma de arquivos – parte 2...................................................................................156
25. Reutilizando o código..................................................................................................163
26. Escrevendo funções – parte 1......................................................................................171
30. Desenvolvendo aplicação utilizando funções...............................................................198
31. Utilizando orientação a objetos....................................................................................207
32. Escrevendo classes com herança..................................................................................215
33. Escrevendo classe, sobrecarregando e sobrescrevendo métodos..................................223
34. Tratando exceções........................................................................................................229
35. Exercícios resolvidos – parte 1.....................................................................................234
36. Exercícios resolvidos – parte 2.....................................................................................244
37. Desenvolvendo uma aplicação coesa – parte 1............................................................255
38. Desenvolvendo uma aplicação coesa – parte 2............................................................262
39. Controlando sessões.....................................................................................................269
40. Definindo padrões de codificação................................................................................278
41. Depurando o código.....................................................................................................284
42. Gerando documentos RTF e PDF...................................................................................290
43. Desenvolvendo aplicações completas com PHP – parte 1............................................298
Glossário.............................................................................................................................342
Referências.........................................................................................................................351
Desenvolvimento prático de
1 website - parte 1
Objetivo
Desenvolver uma aplicação prática de site, considerando os
conhecimentos de HTML e CSS.
Nas disciplinas anteriores você desenvolveu algumas competências e

habilidades necessárias para o estudo de Linguagem de Programação
voltada para internet; agora, na presente disciplina, trabalharemos com
o uso de uma linguagem de processamento de scripts, como é o caso
do Hypertext Preprocessor (PHP). Iniciaremos com o desenvolvimento
prático de website e, para isso, utilizaremos como principal referência o
trabalho de Manzano e Toledo (2008).
Essas competências serão reavivadas através do desenvolvimento de uma

aplicação prática de um website em HTML. Você deve se recordar que
HTML é uma linguagem de marcação utilizada para produzir páginas
na web, ou seja, os documentos HTML podem ser interpretados por
navegadores.
1.1 Desenvolvendo uma página simples usando HTML

Manzano e Toledo (2008) afirmam que um documento (página) HTML
é um arquivo de texto simples contendo códigos (comandos) que têm
como base etiquetas de identificação (conhecidas pelo termo inglês
“tag”), que são comandos de formatação da linguagem e especificam
os elementos de texto (títulos, parágrafos, tabelas, hiperlinks etc.). As
definições das linguagens utilizadas na internet são mantidas pela W3C.
As etiquetas (tags) são palavras entre parênteses angulares (< e >)

com comandos de formatação que definem os elementos, podendo
ter atributos (que determinam como será formatado). O elemento é
finalizado com uma barra junto ao primeiro parêntese angular (</). Entre
www.esab.edu.br 7
o início e o fim da tag poderão ser inseridos valores ou outras tags (filhos,
que podem ser outros elementos ou texto).
Você poderá recordar tais conceitos desenvolvendo um documento

HTML. Vamos testar isso na prática? Para tanto, abra o bloco de notas
ou o seu editor de texto (caso esteja utilizando outro sistema operacional
que não seja o Microsoft Windows).
Código 1 – Exemplo de documento HTML

01 <html>
02 <head>
03 <title>
04 Título do documento exemplo, para barra de
títulos do navegador
05 </title>
06 </head>
07 <body>
08 Aqui você deve colocar o corpo da página
(dados e tags)
09 </body>
10 </html>
Fonte: Elaborado pelo autor (2014).
O exemplo contido no Código 1 apresenta tag HTML, obrigatória e

responsável por definir o início e o final do código escrito em HTML. Ele
é iniciado na linha 1 e finalizado na linha 10. Observe que, para fechar
uma tag, utilizamos uma barra antes do nome (</html>, nesse caso).
A linha 2 traz a tag que define o cabeçalho do documento HTML,

enquanto a linha 3 apresenta a abertura do título, definido na linha 4. As
linhas 5 e 6 fecham essas tags. Da mesma forma é definido o corpo do
documento, com a determinação da tag <body> na linha 7, o texto do
corpo na linha 8 e a tag sendo fechada na linha 9.
Salve esse documento com a extensão .html. Para fazer isso no bloco
de notas, você pode utilizar as aspas (por exemplo, use o menu Salvar e
digite “teste.html” e clique no botão “Salvar”).
www.esab.edu.br 8
O resultado desse documento, ao ser aberto no navegador Internet
Explorer, bem como a sua definição no bloco de notas, pode ser visto na
Figura 1.
Figura 1 – Documento HTML no bloco de notas e seu resultado no navegador.

Fonte: Elaborada pelo autor (2014).
Agora você deve criar o documento HTML usando formatos, por meio
das tags <h1>, <h2>, ..., <h6>, em que <h2> é um subtítulo de <h1>,
<h3> é um subtítulo de <h2> e, assim, até o limite de seis. Dizer que h1
é subtítulo de h2 implica na formatação de subtópicos e visa criar, de
forma automática, uma diferenciação de tamanho da fonte, para que seja
dada importância maior a títulos de hierarquia maior.
Código 2 – Exemplo de documento HTML, com uso de formatos

01 <html>
02 <head>
03 <title>
04 Exemplo com uso de cabeçalhos
05 </title>
06 </head>
07 <body>
08 <h1>
09 Exemplo com formato 1
10 </h1>
11 <h2>
13 </h2>
14 <h3>
16 </h3>
17 </body>
18 </html>
www.esab.edu.br 9
O Código 2 apresenta um documento HTML com uso de formatos,
como pode ser observado na criação do formato 1, iniciado na linha 8,
com seu conteúdo na linha 9 e o encerramento na linha 10. Da mesma
forma, o formato 2 é criado na linha 11, tem seu conteúdo na linha 12 e
é encerrado na linha 12. O resultado pode ser visto na Figura 2.
Figura 2 – Documento HTML com uso de formatos no bloco de notas e seu resultado no navegador.
Estudo complementar
O uso do “ç” tem como objetivo inserir o
caractere “ç”, utilizando o padrão ISO. Sem isso não
temos a garantia de que, quando da alteração do
idioma ou do navegador, o caractere será escrito
de forma correta.
A tabela de acentos e caracteres pode ser obtida
clicando aqui.
No item seguinte você aprenderá a aplicar uma formatação usando

estilos. Confira!
www.esab.edu.br 10
1.2 Formatando a página utilizando CSS
Os estilos que você aplicará na formatação podem ser definidos de modo
interno (uso das tags <style> como conteúdo de <head>) ou de modo
externo, com a criação de um arquivo de formatação CSS. Com o CSS você
é capaz de estabelecer padrões de formatação e aplicá-los no seu documento.
Segundo Manzano e Toledo (2008), a estrutura sintática de uma instrução

CSS é formada por uma propriedade e pela definição de um valor.
O Código 3 apresenta um exemplo de formatação de estilo, contendo

valores diferenciados para a propriedade “color”, que define a cor do texto.
Código 3 – Exemplo de documento HTML com uso de formatos e estilos

01 <html>
02 <head>
03 <title>
04 Exemplo com uso de cabeçalhos com
estilos
05 </title>
06 <style type=”text/css”>
07 h1 {color: #FF0000;}
08 h2 {color: #00FF00;}
09 p {color: rgb(0,0,255);}
10 </style>
11 </head>
12 <body>
13 <h1>Este cabeçalho é vermelho</h1>
14 <h2>Este cabeçalho é verde</h2>
15 <p>Este parágrafo é azul</p>
16 </body>
17 </html>
A formatação dos estilos h1, h2 e p são feitas das linhas 6 a 10, de forma
a especificar uma formatação padrão para cada um deles. Ao utilizar um
estilo, como o uso do h1 na linha 13, ele assume a formatação definida
no estilo. O resultado desse teste pode ser visto na Figura 3.
www.esab.edu.br 11
Figura 3 – Documento HTML com uso de formatos e estilo, no bloco de notas e seu resultado no navegador.
Para a formatação você pode alterar propriedades como background

(cor do fundo da área de documento), color (cor da fonte), font-size
(tamanho da fonte) e font-family (nome das fontes a serem usadas).
Estudo complementar
A documentação relacionada aos padrões HTML e
CSS pode ser obtida no sítio da W3C, clicando aqui. A
página da W3C no Brasil é encontrada clicando aqui.
Nesta unidade você relembrou e colocou em prática conhecimentos

relacionados ao uso do HTML e dos estilos CSS. Já na unidade 2 serão
trabalhadas as utilizações de formulário e de validações com uso de
JavaScript.
www.esab.edu.br 12
Desenvolvimento prático de
2 website - parte 2
Objetivo
Desenvolver uma aplicação prática de site considerando os
conhecimentos de formulários e JavaScript, elaborando páginas com
certo dinamismo e executando validações do lado-cliente.
Na unidade 1 você desenvolveu um documento HTML simples,

utilizando CSS e, na presente etapa, você continuará essa retomada com
relação ao uso do HTML, gerando formulários e construindo validações
com uso de JavaScript. Para tanto, você utilizará os conhecimentos
adquiridos na unidade anterior (HTML e estilos CSS), de forma a
construir um formulário, com validações e com estilos formatados.
Continuaremos nesta unidade nos referenciando ao trabalho de Manzano
e Toledo (2008) e Meloni (2000) e vamos começar nos aprofundando
um pouco mais em como desenvolver um formulário usando HTML.
2.1 Desenvolvendo um formulário usando html

Inicialmente vamos retomar conceitos de criação de tabela, visto que esse
conhecimento pode ser necessário para o design dos objetos em nossa página.
Para criar tabelas, você deve utilizar a tag <table>. Para gerar uma linha
dentro da tabela, usamos a tag <tr> e, para criar uma coluna, usamos a
tag <td>. O número de linhas se dá pelo número de ocorrências da tag
<tr>, enquanto o número de colunas é determinado pelo número de
vezes que utilizamos a tag <td>. Meloni (2000) alerta que o fechamento
incorreto de uma tag de tabela (ou o seu não fechamento) pode causar
grandes problemas no layout do documento.
www.esab.edu.br 13
O Código 4 apresenta uma tabela com duas linhas e duas colunas.
Observe:
Código 4 – Exemplo de documento HTML com uso de formatos e estilos

01 <html>
02 <head>
03 <title>
04 Exemplo com tabelas
05 </title>
06 <body>
07 <table border=”1”>
08 <tr>
09 <td>linha1, coluna 1</td>
11 </tr>
12 <tr>
14 <td>linha 2, coluna 2</td>
15 </tr>
16 </table>
17 </body>
18 </html>
A tabela é criada na linha 7, com a propriedade referente à borda

(largura) definida com valor 1. Você pode determinar estilos (cores,
fontes, tamanhos) nessas propriedades, conforme visto na unidade 1.
Dentro do conteúdo da tabela é criada a primeira linha, na linha 8

do código, com a tag <tr>. A nona linha gera a primeira coluna e o
conteúdo refere-se, portanto, ao valor da célula da primeira coluna da
primeira linha. Da mesma forma, é criada a segunda coluna na linha
10 e, logo abaixo, é fechada a primeira linha. Repete-se o procedimento
entre as linhas 12 e 15 para criarmos a segunda linha da tabela, que é
encerrada na linha 16.
www.esab.edu.br 14
O resultado desse teste pode ser visto na Figura 4.
Figura 4 – Documento HTML com uma tabela apresentada no navegador.

Após relembrar o uso de tabelas, você deverá criar um documento com

uso de formulário. Os formulários têm como objetivo mandar dados ao
servidor e são utilizados no envio de informações de pesquisa e compra
eletrônica, entre outros. O formulário é utilizado por meio da tag <form>.
É necessário definir o objetivo do formulário para definir o layout, ou
seja, como serão apresentados os componentes de entrada de dados.
Para a criação de formulários você deve ter definidas algumas propriedades:
• action: informa o endereço de internet para o qual o conteúdo do

formulário será enviado. Se o parâmetro for omitido, o endereço
corrente será usado.
• method: informa o método de transferência dos dados que será
usado pelo parâmetro action, podendo ser:
• get: valor-padrão, usado quando se deseja enviar os dados de
um formulário ao final do endereço URL, seguindo o formato
endereço?nome=valor. Dessa forma, os dados podem ser vistos na
barra de endereços do navegador; e
• post: faz com que os dados do formulário sejam enviados em um
bloco de dados endereçado ao URL definido no action, sendo
o método mais indicado por não ser apresentado na barra de
endereços.
• enctype: especifica o método de submissão dos dados quando usar o
método post.
www.esab.edu.br 15
O valor padrão desse parâmetro é application/x-www-form-urlencoded,
no qual os dados são enviados de forma codificada. Quando se remete
um arquivo (entrada de dados do tipo file), você deve usar o valor
multipart/form-data para esse parâmetro (dados são passados em
multipartes, ou seja, em pacotes). Segundo Manzano e Toledo (2008), é
comum o uso do valor text/plain para esse parâmetro, de modo a mandar
os dados de maneira formatada.
Por sua vez, a tag <input> é utilizada para criar campos de entrada de
dados. Você pode usar os parâmetros:
• name: nome do elemento do formulário (botão, caixa de texto etc.).

• type: tipos de dados que serão usados para esse campo. Define o
formato da entrada, podendo ser:
• text: caixa de texto, recebendo dados do tipo caractere;
• password: caixa de texto, utilizado para campos de senha,
escondendo os valores digitados;
• radio: tem a forma de um botão circular, permitindo a seleção de
uma opção dentre as opções definidas;
• checkbox: tem a forma de um botão quadrado, permitindo a
seleção de mais de uma opção dentre as opções definidas;
• submit: botão que terá como objetivo enviar os dados do
formulário ao endereço (action). Deve ter atribuído o valor do
parâmetro value;
• reset: botão que terá como objetivo limpar os dados do
formulário, voltando aos valores-padrão. Deve ter atribuído o
valor do parâmetro value;
• hidden: campo invisível cujo conteúdo é enviado com os dados,
mas não é apresentado ao usuário;
• file: especifica a possibilidade de anexar um arquivo para ser
enviado como upload. Exige que o formulário use o método post
e enctype=multipart/form-data; e
• image: permite que uma imagem seja utilizada como botão do
tipo submit.
• Size: tamanho do campo no formulário. Usado principalmente para
caixa de textos (text) e senhas (password). O valor-padrão (caso
omitido) é de 20 caracteres.
www.esab.edu.br 16
• maxlegth: tamanho máximo de caracteres. Usado para caixas de
texto e senhas.
• value: valor-padrão do conteúdo do campo, podendo ser um texto
digitado, predefinido ou o título de um botão.
• checked: utilizado em botões do tipo radio e checkbox, referindo a
opção selecionada.
• accesskey: tecla de atalho.
Você pode usar entradas de dados por meio da tag <select>, que
permite a criação de uma lista de opções predefinidas, aceitando valores
para os parâmetros name, size (número de linhas que aparecerão na
tela) e multiple, devendo, este último, ser definido quando houver a
possibilidade de seleção de mais de uma opção, usando a tecla “Ctrl”.
Deve-se usar a tag interna <option> para se definir as opções.
A tag <textare>a deve ser usada quando se deseja a entrada de textos

com várias linhas e colunas. Já a tag <button> permite a apresentação de
botões personalizados, devendo-se escolher o parâmetro type, entre os
valores submit e reset, tendo o seu comportamento definido por ambos.
Meloni (2000) alerta que, quando você cria formulários, os atributos name
devem ser únicos, pois se tornam variáveis interpretadas pelo seu script.
A Figura 5 mostra um exemplo de formulário cujo layout foi definido

pelo uso de tabelas e também o seu resultado no navegador.
www.esab.edu.br 17
Figura 5 – Documento HTML com formulário, no bloco de notas e seu resultado no navegador.
Para desenvolver o exemplo, você deverá utilizar o Código 5. Observe:
Código 5 – Documento HTML com formulário no bloco de notas e seu resultado no navegador
01 <html>
02 <body>
03 <form action=»mailto:seuemail@seuemail.
com” method=”post” enctype=”text/plain”>
04 <h1>Este formulário envia um e-mail
para o endereço especificado.</h1>
05 <table border=0>
06 <tr>
07 <td> Nome:</td>
08 <td> <input type=”text” name=”name”
value=”seunome” size=”20”></td>
09 </tr>
10 <tr>
11 <td> Endereço:</td>
12 <td> <input type=”text”
name=”email” value=”seumail” size=”20”></td>
13 </tr>
14 <tr>
15 <td> Mensagem:</td>
16 <td> <textarea rows=5 cols=60
name=”comentario”>comentario</textarea></td>
17 </tr>
18 <tr>
www.esab.edu.br 18
19 <td colspan=2> Eu tenho uma
bicicleta: <input type=”checkbox” name=”bike”
checked></td>
20 </tr>
21 <tr>
22 <td colspan=2> Eu tenho um
carro: <input type=”checkbox” name=”carro”
checked></td>
23 </tr>
24 <tr>
25 <td> Qual é o seu estado? </td>
26 <td>
27 <select name=”estado”>
28 <option>RS</option>
29 <option>SC</option>
30 <option>PR</option>
31 <option>RJ</option>
32 <option>SP</option>
33 </select>
34 </td>
34 </tr>
36 </table>
37 <input type=”submit” value=”Enviar”>
38 <input type=”reset” value=”Limpar”>
39 </form>
40 </body>
41 </html>
Note que o alinhamento dos componentes de entrada só foi possível com

a utilização de tabelas. Além disso, nesse exemplo foram usados vários
tipos de componentes de entrada de dados, sendo que a sua escolha
depende do objetivo do formulário. No entanto, o que acontece se o
usuário colocar uma informação qualquer que não seja válida? Validações
são possíveis, do lado-cliente, através de uso de scripts, com o JavaScript,
que você verá a seguir.
www.esab.edu.br 19
2.2 Desenvolvendo validações utilizando JavaScript
Além de dar dinamismo à página executando uma ação – que, no exemplo
anterior, a ação realizada era a de enviar um e-mail com os dados do
formulário, feita diretamente usando apenas componentes do formulário – ,
a utilização de scripts permite agregar certa lógica de programação à pagina,
através de testes condicionais e de laços de repetição, entre outros. Os
scripts são executados do lado do cliente (navegador).
Para o nosso exemplo, usaremos JavaScript para validar um e-mail.

Lembre-se de que um e-mail deve:
E-mail
Usar @. Possuir pelo menos um ponto
Possuir algum caractere após o caractere depois do @ e
Não possuir espaços.
antes e algum caractere após possuir algum caractere após
o @. o ponto.
Quadro 1 – Características obrigatórias de um e-mail.

Sendo assim, vamos alterar o nosso formulário. Adicione à linha de

criação da caixa de texto uma chamada para validacaoEmail, passando o
texto do campo com nome “email” ao perder o foco (onblur), ficando:
<input type=”text” name=”email” onblur=”validacaoEmail(email)”

value=”seuemail” size=”30”> e o script contido no Código 6.
Código 6 – Formulário com a validação de e-mail

01 <script language=”Javascript”>
02 function validacaoEmail(field) {
03 usuario = field.value.substring(0, field.
value.indexOf(“@”));
04 dominio = field.value.substring(field.
value.indexOf(“@”)+ 1, field.value.length);
05 if ((usuario.length >=1) && (dominio.
length >=3) && (usuario.search(“@”)==-1) &&
(dominio.search(“@”)==-1)
06 && (usuario.search(“ “)==-1) &&
(dominio.search(“ “)==-1) && (dominio.
search(“.”)!=-1)
www.esab.edu.br 20
07 && (dominio.indexOf(“.”) >=1)&&
(dominio.lastIndexOf(“.”) < dominio.length -
1)) {
08 alert(“E-mail valido”);
09 } else {
10 alert(“E-mail invalido”); }
11 }
12 </script>
Na função JavaScript, criada junto ao Código 6, a primeira linha

define a linguagem que deve ser utilizada para o processamento dos
comandos. Na segunda linha, definimos a função, dando a ela um nome
e determinando quais parâmetros serão aceitos (nesse caso, ele recebe um
parâmetro chamado “field”).
A partir da terceira linha, temos comandos específicos do JavaScript: A

linha 3 obtém o texto de parte da variável Field, iniciando na posição 0
(início da variável) até a posição onde se encontra o símbolo “@”. Ou
seja, se a variável Field tiver o valor email@em.com, ele iria copiar os
valores a partir da posição 0, com 5 posições, retornando valor “email”
para ela.
A linha 4 retorna os valores após a posição posterior ao símbolo “@”, do

tamanho da variável.
As linhas 5, 6 e 7 fazem parte de uma única instrução (IF) e impõem

testes lógicos que serão explicados um a um. Caso todos os testes lógicos
forem verdadeiros, ele executa a linha 8, apresentando a mensagem
“E-mail válido” e, em caso contrário, executa o alerta “E-mail inválido”,
contido na linha 10. Segue a explicação dos testes lógicos:
• (usuario.length >=1) que o tamanho da variável usuário (do texto

que exista antes do “@”) seja maior ou igual a 1
• (dominio.length >=3) que o tamanho da variável domínio (do texto
que tem após do “@”) seja maior ou igual a 3
• (usuario.search(“@”)==-1) search retorna a posição da variável
usuário na qual se encontra o símbolo “@” e testa se é igual a -1 (não
encontrado)
www.esab.edu.br 21
• (usuario.search(“ ”)==-1) teste se existe espaço na variável usuário,
segundo explicação dada acima
• (dominio.search(“.”)!=-1) teste se existe o símbolo “.” na variável
usuário, segundo explicação dada acima. Nesse caso retorna
verdadeiro, caso exista.
• (dominio.indexOf(“.”) >=1) testa se a posição onde se encontra o “.”
não é a primeira posição da variável domínio
• (dominio.lastIndexOf(“.”) < dominio.length - 1)) testa se a posição
onde encontra o “.” da variável é menor que seu tamanho. O
resultado disto consiste em testar se a última posição não é “.”
O resultado do Código 6 pode ser visto na Figura 6:
Figura 6 – Documento HTML com formulário e script de validação de e-mail.

Nesta unidade vimos que é possível receber informações do usuário e

interagir através de formulários. Vimos também que o desenvolvimento
do layout do formulário pode ser feito utilizando tabelas e que os dados
informados pelo usuário podem ser validados com o uso do JavaScript.
Agora você está pronto para iniciar a programação PHP, que é o assunto
da próxima unidade. Vamos em frente?
www.esab.edu.br 22
3 Introdução à PHP
Objetivo
Apresentar os conceitos da linguagem de programação PHP,
diferenciando linguagem de programação interpretada e linguagem
de programação compilada.
Nas unidades 1 e 2 você desenvolveu páginas HTML que interagem com

o usuário, recebendo informações através de formulários e promovendo a
validação de dados por meio das scripts, formatando-as através de folhas
de estilos CSS. O foco da disciplina agora é a linguagem PHP; assim, na
presente unidade veremos alguns conceitos relacionados à Linguagem
de Programação e às diferenças entre uma linguagem compilada e uma
linguagem interpretada, para que você seja capaz de entender como o PHP
traduz seus códigos. Utilizaremos, para isso, os textos de Meloni (2000).
Vamos começar estudando o que é PHP. Preparado para começar esse

estudo? Então, vamos lá!
3.1 O que é PHP?

PHP (um acrônimo recursivo para PHP: Hypertext Preprocessor,
originalmente Personal Home Page) é um conjunto de scripts processado
no lado-servidor e utilizado para gerar conteúdo dinâmico na internet
(MELONI, 2000). Trata-se de uma linguagem interpretada.
Seu uso permite o desenvolvimento de aplicações web, de forma a

possibilitar a produção de conteúdos dinâmicos, interagindo com o usuário.
A linguagem é criada e mantida por uma comunidade de desenvolvedores,
sendo, portanto, open-source. Isso significa que você não precisa pagar
licença de uso da linguagem para construir e distribuir aplicativos.
www.esab.edu.br 23
O PHP permite que você utilize scripts de forma embutida ao
documento HTML, ou seja, contém HTML juntamente com códigos
que “executam scripts” ou “comandos”. A linguagem PHP possibilita
também o desenvolvimento de aplicativos GUI, por meio de uma
biblioteca chamada PHP-GTK. Porém, o seu propósito principal é o
desenvolvimento de aplicativos web velozes, simples e eficientes. Suas
principais características são:
• velocidade e robustez;
• pode-se desenvolver de forma estruturada e ou utilizar-se de
orientação a objetos;
• é independente de plataforma (portabilidade);
• tipagem dinâmica: você pode criar as variáveis de qualquer tipo a
qualquer parte do código;
• sintaxe similar a C/C++ e ao Perl;
• open-source: você não precisa pagar licenças para desenvolvê-lo
ou distribuí-lo e pode contribuir para a melhoria da linguagem de
forma voluntária (e se aproveitar das melhorias realizadas por outros
desenvolvedores);
• server-side: o cliente faz a requisição e o servidor devolve o
documento HTML processado.
A Figura 7 mostra um exemplo de código PHP integrado ao HTML.
Acompanhe:
Figura 7 – Código PHP integrado ao HTML.

A linguagem PHP é interpretada. Mas o que isto significa? No próximo

tópico você poderá conhecer a diferenciação.
www.esab.edu.br 24
3.2 Diferenças de programação compilada e
interpretada
Como você já estudou anteriormente em outras disciplinas, o
processador do computador entende apenas a linguagem de máquina.
Dessa forma, quando criamos um programa em uma Linguagem de
Programação de alto nível, precisamos de uma ferramenta que traduza o
programa para a linguagem de máquina, permitindo que o processador
o compreenda. Dois tipos comuns de ferramentas que realizam essa
tradução são os compiladores e os interpretadores.
Para entender o papel dessas ferramentas, vamos fazer uma analogia

com os idiomas falados pelo mundo. Suponha que o processador só
compreenda uma língua muito antiga, por exemplo, o latim. Nesse caso,
precisamos mandar comandos para o processador sempre em latim, pois
é a única língua que ele entende. Porém, nem todos nós sabemos falar
latim. Algumas pessoas falam português, outras, espanhol, ou inglês. Para
nos comunicarmos com o processador, precisamos de um tradutor.
Uma forma de realizar a tradução seria escrevermos todo o texto em um

papel e entregá-lo ao tradutor. Ele traduz o texto inteiro para o latim e
nos devolve. A seguir, repassamos o texto em latim para o processador,
pois, estando transcrito nesse idioma, a ferramenta irá entendê-lo.
Porém, outra forma de realizar a tradução seria irmos até o processador

e levarmos o tradutor junto. Registramos, então, os comandos para o
processador na nossa língua, e o tradutor realiza uma tradução simultânea
desses comandos, ou seja, para cada comando que falarmos, o tradutor
traduz para o latim exatamente o que falamos, e o processador executa
aquele comando. Dessa forma, cada comando é traduzido e executado um
a um. No mundo das linguagens de programação existem esses mesmos
tipos de tradutores. O tradutor que pega o texto inteiro em um papel,
traduz para o latim (ou para a linguagem de máquina) e nos devolve, é
chamado de compilador. Um compilador da linguagem C é um tradutor
que entende C e traduz os comandos em C para a linguagem de máquina.
Por outro lado, o tradutor que realiza a tradução simultânea, comando
por comando, durante a execução, é chamado de interpretador.
www.esab.edu.br 25
Quando falamos de linguagens de programação, porém, poucas
linguagens no mundo possuem tanto um compilador quanto um
interpretador. Criar um compilador ou um interpretador é uma tarefa
difícil, e geralmente os criadores da linguagem desenvolvem apenas
um dos dois. Além disso, a maioria das linguagens são criadas com um
objetivo em mente, e para cumprir esse objetivo, muitas vezes é mais
apropriado usar um compilador ou um interpretador.
Por exemplo, como é de se imaginar, a tradução simultânea realizada pelo

interpretador deixa o programa mais lento, porque cada comando precisa
ser primeiro traduzido antes de ser executado. Por isso, para linguagens
como C e C++, que são usadas em sistemas de alto desempenho, o uso
de um compilador acaba sendo melhor.
Apesar do desempenho menor, o uso de um interpretador traz também

vantagens, pois interpretadores permitem mais flexibilidade ao código,
maior controle contra falhas, mais facilidade em gerenciar os recursos,
entre outras vantagens. Essas vantagens só existem porque a tradução
do programa durante a execução permite que se tenha um controle
maior a respeito da execução de cada instrução. Linguagens usadas
em programação web como JavaScript e PHP geralmente possuem
interpretadores.
Quando uma linguagem possui um compilador, dizemos que ela é uma

linguagem compilada. Linguagens que fazem uso de interpretadores são
chamadas de linguagens interpretadas.
A Figura 8 apresenta as diferenças entre a execução de um programa

compilado e um programa interpretado:
www.esab.edu.br 26
Execução
PS
Programa
Fonte
IM
Saída
Interpretador
Dados de
Entrada
Execução de programas com linguagem interpretada.

Compilação
PC PM
CM
Programa Programa
Compilador
Fonte Objeto
Execução
PM
Dados de
Programa Saída
Entrada
Objeto
Execução de programas com linguagem compilada.

Figura 8 – Processo de execução em linguagens compiladas e interpretadas.
Fonte: Adaptada de < http://marcelino.com.sapo.pt/CMan/Chap1.htm>.
Veja que, na execução utilizando um interpretador, mostrada mais

acima, o programa fonte e os dados de entrada são fornecidos para o
interpretador, que realiza a tradução de cada comando e gera os dados
de saída (fornecidos pelo processador após executar cada comando).
Quando se usa um compilador, em um primeiro momento, o programa
fonte inteiro é compilado, gerando o que chamamos de programa
objeto, já traduzido para a linguagem de máquina. Quando esse
programa for executado, então, o processador só precisa ler as instruções
do programa objeto e executá-las, gerando os dados de saída.
www.esab.edu.br 27
A linguagem PHP, foco de nosso estudo, é uma linguagem interpretada,
o que possibilita maior flexibilidade no desenvolvimento de soluções,
dada a maior interação no momento de se gerar os códigos computáveis
pelo sistema operacional, o que é feito no momento de seu uso.
A linguagem PHP é muito utilizada no mundo e, muitas vezes, aparece

em nosso dia a dia sem que possamos perceber. No próximo tópico
veremos como ela é utilizada na web em aplicações com as quais
frequentemente lidamos.
3.3 Aplicações da linguagem PHP

Com o PHP podemos elaborar aplicações web que exijam requisitos
como autenticação e sistemas dinâmicos, ou no desenvolvimento de
aplicações que contenham notícias, sistemas com envio de e-mails, lojas
virtuais, redes sociais etc. Ou seja, aplicamos o PHP quando necessitamos
de interação com usuário na web. Você facilmente encontrará exemplos
de aplicações para internet com PHP, e isto apenas navegando na rede.
A Wikipédia é um exemplo de aplicação web de grande porte

desenvolvida em PHP, com as validações de senhas, os formulários de
edição e a publicação de artigos, a seleção e o upload de fotos. Na Figura
9 esses elementos são bastante perceptíveis. Ao verificarmos a barra de
endereços, percebemos que a página utilizada é “index.php”.
Figura 9 – Página de login da Wikipédia.

Fonte: <http://pt.wikipedia.org/>.
www.esab.edu.br 28
Da mesma forma, podemos observar o uso de PHP na rede social
Facebook. Veja a Figura 10:
Figura 10 – Página de login do Facebook.

Fonte: <https://www.facebook.com/>.
Viu só como o PHP é muito utilizado na web? Com ele podemos

desenvolver aplicações completas para uso na internet.
No entanto, você sabe como surgiu o PHP? Confira esse assunto na

unidade 4.
www.esab.edu.br 29
4 História da linguagem PHP
Objetivo
Apresentar a história da linguagem PHP.
Vimos, na unidade 3, que o PHP é uma linguagem interpretada,

portável e open-source. No entanto, para que possamos dar continuidade
aos estudos, você deve conhecer um pouco da origem, da história e da
evolução dessa linguagem, a fim de compreender o potencial do PHP. O
trabalho de Meloni (2000) embasará a presente unidade.
4.1 Gênese do PHP

Com a criação da internet e a sua popularização, fez-se necessária
a criação de ambientes e de linguagens que possibilitassem o
desenvolvimento de aplicativos com interação.
Já existiam linguagens de scripts, como VB-Script. Porém, estas eram

estruturadas em arquiteturas Microsoft, ou seja, dependiam da utilização
exclusiva de produtos da Microsoft para manter seu funcionamento, o
que resultava na necessidade de pagamento de licenças. Assim, tiveram
início as tecnologias estruturadas em em Java, uma implementação da
Sun (hoje da Oracle), já independente de plataformas. A linguagem
PHP surgiu então como alternativa open-source e com curva menor de
aprendizado, mas sem perder a robustez.
Segundo Meloni (2000), o PHP foi criado por Rasmus Lerdorf em 1995,
com o nome Personal Home Page Tools, a fim de substituir um conjunto
de scripts de linguagem Perl que ele utilizava no desenvolvimento de
sua página pessoal. Como mais funcionalidades foram requeridas,
Lerdorf escreveu uma implementação C muito maior, que era capaz
de comunicar-se com base de dados e que possibilitava aos usuários
www.esab.edu.br 30
desenvolver simples aplicativos dinâmicos para a internet. Em 1997 foi
lançado o novo pacote da linguagem com o nome de PHP/FI, trazendo a
ferramenta Forms Interpreter (FI), um interpretador de comandos SQL.
O PHP/FI incluía algumas funcionalidades básicas do PHP que

nós conhecemos hoje, usando variáveis no estilo Perl, interpretação
automática de variáveis vindas de formulário e sintaxe embutida no
HTML. A sua própria sintaxe era similar à do Perl, porém, muito mais
limitada, simples e um pouco inconsistente.
Com base em conceitos de software livre, Lerdorf disponibilizou o código

do PHP/FI para que todos pudessem utilizá-lo, além de auxiliar em seu
desenvolvimento e na correção de erros. Assim, com a contribuição de
outros indivíduos, o PHP tornou-se uma Linguagem de Programação.
Um grupo organizado chamando The PHP Group é o responsável por

manter a linguagem, bem como por receber as propostas de melhorias e
decidir se elas devem ou não ser incorporadas. Sendo assim, o PHP é um
software livre, licenciado sob a PHP License, uma licença incompatível
com a General Public License (GPL), devido a restrições no uso do
termo PHP. Isto significa que você pode usar a linguagem PHP, mas não
se apropriar de seu nome.
Você acabou de observar como surgiu a linguagem PHP, mas tal

linguagem passou por grande evolução. Vamos conferir?
4.2 Evolução da linguagem PHP

A evolução da linguagem PHP se baseou no conceito de software aberto.
“Com o espírito de desenvolvimento de software de código aberto,
desenvolvedores de todo o mundo iniciaram suas contribuições ao PHP/
FI” (MELONI, 2000, p. 2).
Assim, a abertura de códigos para que a comunidade pudesse auxiliar no

desenvolvimento da linguagem foi fundamental para a evolução do PHP.
Segundo Meloni (2000), em 1997, mais de 50.000 sites da web estavam
utilizando o PHP/FI para desempenhar diversas tarefas, como conexão
com banco de dados e exibição de resultados dinâmicos, entre outras.
www.esab.edu.br 31
Para sua reflexão
Qual foi a importância da disponibilização e da
abertura dos códigos para a comunidade, de
forma a tornar o PHP um software aberto? Você
acha que esse formato continua contribuindo para
a evolução da PHP?
A resposta a essa reflexão forma parte de sua
aprendizagem e é individual, não precisando ser
comunicada ou enviada aos tutores.
Mais tarde, com a implementação assistida fundamentalmente por Zeev

Suraski e Andi Gutmans, o interpretador foi reescrito, sendo o PHP3
lançado em junho de 1998, conforme indica Meloni (2000). Essa versão
incluía suporte para múltiplas plataformas (não somente Linux, como
anteriormente) e servidores da web; diversos bancos de dados; Simple
Network Management Protocol (SNMP) e Internet Message Access Protocol
(IMAP); e suporte básico à programação orientada a objeto. Porém, foram
encontrados problemas de compatibilidade com a versão anterior.
No ano de 1999, Suraski e Gutmans estabeleceram em Israel,

oficialmente, a empresa Zend Technologies, responsável pelo
desenvolvimento de novos mecanismos. Pouco depois, a comunidade
de desenvolvedores lançou o PHP4, que tinha uma boa compatibilidade
com o PHP3, e incorporou o mecanismo Zend Engine, que
proporcionou melhor desempenho e possibilitou a programação
orientada a objetos.
Nessa versão, os maiores problemas enfrentados foram os erros na criação

de cópias de objetos, isto porque a linguagem ainda não trabalhava com
apontadores.
Tal falha foi resolvida na versão 5, que passou a trabalhar com

apontadores. Assim, quando se atribui um objeto a uma variável, na
www.esab.edu.br 32
verdade não se copia o objeto, mas sim um apontador para ele (um
ponteiro para o conteúdo original). Se se modificar o objeto original,
todas as outras referências a ele também sofrerão a alteração.
O PHP5 foi lançado em julho de 2004, depois de um longo

desenvolvimento e vários pré-releases. Ele introduziu, principalmente,
a Zend Engine2.0, possuindo suporte total à programação orientada a
objetos e apresentando uma significativa melhoria em sua performance.
A Figura 11 apresenta uma linha do tempo contendo as principais

versões do PHP e suas respectivas datas de lançamento, sendo que um
detalhamento maior é apresentado junto ao PHP 5.
95
97
98
00
04
05
06
09
12
13
19
19
19
20
20
20
20
20
20
20
PH 1”
I2
P3
P4
P5
5.1
5.2
5.3
5.4
.11
P/F
P
PH
PH
PH
5.4
“PH
Figura 11 – Linha do tempo das versões da linguagem PHP.

A versão 6.0 ainda não tinha previsão de lançamento até o momento de

encerramento da confecção deste material.
Na unidade 5 veremos como se dá o processamento e a arquitetura das

aplicações PHP.
www.esab.edu.br 33
Arquitetura de aplicação web com
5 PHP
Objetivo
Apresentar as diferenças da programação com execução na máquina-
cliente e na máquina-servidor, bem como vantagens, desvantagens e
limitações.
Agora que passou por uma contextualização, você pode se perguntar: por
que devo usar o PHP? Por que não usar JavaScript? Algumas respostas
podem ser dadas com relação à arquitetura de aplicações web. Nessa
unidade você poderá comparar as arquiteturas client-side, lado-cliente,
por exemplo, com uso de JavaScript, e a arquitetura server-side, ou seja,
com o processamento do lado do servidor, como acontece no PHP.
5.1 Validações de dados na máquina-cliente com

JavaScript: vantagens e desvantagens
Quando utilizamos validações desenvolvidas com JavaScript, não são
feitas requisições ao servidor, ou seja, a validação acontece na máquina-
cliente (nesse caso, onde se encontra o navegador). Essa classe de
aplicativos é chamada de client-side ou local. Desse modo, é executada
no computador-cliente, responsável pela requisição de um recurso web.
Na Figura 12 se observa um processo client-side sendo executado sem
qualquer conexão com sistemas computacionais externos.
www.esab.edu.br 34
Ação client-side
Requisição
Cliente Servidor
Página
Normal
Arquivos
Figura 12 – Arquitetura client-side.

Observe que o cliente faz a requisição da página e todas as informações são

transferidas para ele. O processamento das validações é feito junto ao cliente
e a carga desse processamento também fica com o computador cliente.
O JavaScript é o principal exemplo de script no qual o processamento

ocorre no lado-cliente, apesar de existirem outras linguagens de script.
Ao carregar a página HTML, são carregados também os códigos

JavaScripts incorporados no HTML. O resultado da execução do código
é apresentado diretamente no navegador.
Através do JavaScript pode-se dar dinamismo às páginas, sendo possível,

por exemplo, alterar o valor de uma entrada de dados do formulário ou
devolver o resultado de uma validação. A maior vantagem é a economia
de banda, ou seja, de tráfego da rede, proporcionando uma resposta mais
rápida ao usuário.
Como todo o código JavaScript está no próprio navegador, o usuário tem

acesso a ele e pode manipulá-lo através de alguns programas, o que faz
com que as linguagens de script sejam inseguras.
Além disso, o usuário pode desabilitar o JavaScript de seu navegador, o

que causaria, simplesmente, o não funcionamento de sua aplicação web.
No próximo tópico você verá as vantagens e as desvantagens de utilizar o

JavaScript para a realização dessas validações.
www.esab.edu.br 35
5.2 Validações de dados com PHP: vantagens e
desvantagens
Algumas linguagens, como o PHP, funcionam em arquitetura server-
side, ou seja, geram conteúdos dinâmicos, processados no servidor, e os
transformam em HTML, que são então enviados para o cliente. Assim, o
cliente não tem acesso ao código-fonte da aplicação.
Observe o esquema da Figura 13:
Requisição
Cliente Página Dinâmica Servidor
Arquivos Dados
Figura 13 – Arquitetura server-side.

Através do esquema de arquitetura server-side, demonstrado na Figura

13, podemos observar que a requisição feita pelo cliente é processada no
servidor, que então devolve o documento HTML, pronto, ao cliente.
Este, por consequência, não tem acesso ao código, recebendo somente os
arquivos resultantes da execução desse script.
A Figura 14 demonstra a arquitetura da linguagem PHP. Observe:
www.esab.edu.br 36
Formulário Banco de dados
1
Requisição
HTTP / HTTPs Script PHP
2
3
Interpretador
Navegador PHP Arquivo
4
HTML
Resultado
5 HTML
Página Web
E-mail
Figura 14 – Arquitetura de aplicação PHP.
Fonte: <www.php.net>.
Nela podemos notar alguns pontos numerados:
1. o usuário, por meio de um formulário/página, envia ao servidor uma

requisição, a qual pode conter dados;
2. o interpretador PHP processa essa requisição, junto ao servidor,
interpretando e processando, podendo realizar buscas em outras
fontes de dados;
3. o interpretador pode efetuar buscas em fontes de dados, de forma a
ter uma resposta interativa;
4. o interpretador PHP monta uma resposta HTML referente à
requisição, com a resposta interpretada em 2 e 3;
5. o servidor responde ao navegador somente o HTML resultado,
sem dar acesso diretamente à base de dados ou às informações que
exigem maior segurança.
Como desvantagens podemos citar que essa arquitetura aumenta o
tamanho da seção HTTP, ou seja, são trafegados mais dados durante o
uso. A arquitetura server-side também consome mais recursos do servidor.
Além disso, algumas respostas, dependendo da banda, podem exigir mais
tempo, visto que, a cada requisição, é feita uma chamada ao servidor.
www.esab.edu.br 37
Porém, observamos que a robustez e, principalmente, que a segurança
proporcionada pela arquitetura são grandes vantagens, suficientes para
levarem à escolha dessa linguagem, principalmente se os formulários são
muito complexos.
Conhecendo a arquitetura da linguagem PHP, estamos prontos para

começar o estudo prático. Confira esse assunto na unidade 6.
www.esab.edu.br 38
Efetuando a instalação e a
6 configuração do servidor Apache e
de ferramenta de edição PHP
Objetivo
Apresentar o servidor Apache, demonstrando a sua necessidade
para o desenvolvimento de aplicações web com PHP, e demonstrar
a instalação do servidor Apache e de ferramentas de edição de PHP
gratuitas (Eclipse).
Na unidade 5 você pôde entender o funcionamento da PHP com

linguagem interpretada mediante processamento no lado-servidor.
Agora, vamos colocar a mão na massa? Ou melhor, no teclado?
Nesta unidade você acompanhará a instalação do PHP e das ferramentas

que você precisa para desenvolver aplicações web com essa linguagem.
Vamos instalar o servidor Apache com os módulos de PHP habilitados e, em
seguida, o Eclipse, uma IDE para que possamos criar e editar documentos.
6.1 O que é o servidor Apache?

O Apache (Apache HTTP Server) é um servidor compatível com o
protocolo HTTP livre e de código aberto (MELONI, 2000). Ele é
mantido pela Apache Software Foundation e, por ser livre e aberto, pode
ser usado sem pagamento de licenças e você, caso queira, pode baixar os
códigos e sugerir melhorias ou corrigir erros.
Nele você pode hospedar suas aplicações (inclusive as aplicações PHP).

O servidor Apache é o mais popular entre os servidores web e pode ser
instalado em várias plataformas, como Windows, Linux, Novell Netware,
OS/2, UNIX, FreeBSD, entre outras.
No próximo tópico veremos como instalar o servidor Apache HTTP

Server nos sistemas operacionais Microsoft Windows e Linux.
www.esab.edu.br 39
6.2 Instalando o servidor Apache
Para proceder com a instalação, acesse o site da apache <http://httpd.
apache.org/> e encontre, na lateral esquerda, o hiperlink “download”.
Na página a ser aberta, selecione a versão para instalação no sistema
operacional que você usa. Selecione as versões com o radical “x86”, caso
seu MS-Windows seja 32 bits, ou “x64”, caso use uma versão 64 bits. Se
você utiliza Linux, deverá encontrar versões com “UNIX source”.
Caso você esteja usando Windows poderá utilizar o instalador, que o

ajudará no processo de instalação e seleção da porta que será utilizada
para execução (80 ou 8080). Você pode configurar esse aspecto
posteriormente, de forma a utilizar a porta padrão (a porta 80 é a porta
padrão da internet). Uma porta é um ponto físico de um dispositivo e
serve para possibilitar as entradas e saídas de informações. A Figura 15
mostra uma tela do instalador:
Figura 15 – Instalador do Apache.

www.esab.edu.br 40
Inicie o servidor, executando o arquivo httpd.exe na pasta bin, dentro da
pasta de instalação padrão do servidor apache, escolhida na instalação.
Caso esteja utilizando Linux, coloque o arquivo baixado em um diretório

acessível (como /usr/local/) e o descompacte, utilizando “gunzip [nome_
do_arquivo].gz”. Esse comando criará um arquivo *tar, que deverá ser
executado com “tar –xvf [nome_do_arquivo].tar” para criar o subdiretório
/usr/local/apache_[versao]/ com os diretórios. Configure, manualmente,
editando o arquivo httpd.conf, conforme explica Meloni (2000).
Modifique a entrada de ServerRoot para que aponte para o nível máximo do diretório
Apache;
Modifique a entrada de ServerAdminpara configurar e-mail do administrador;
Modifique a entrada de ServerName para ajustar o nome do servidor;
Modifique a entrada de DocumentRoot para que ele aponte para o diretório onde
estão os documentos HTML. (MELONI, 2000, p. 8)
Agora, inicie o servidor, executando o arquivo httpd da pasta que

instalou o Apache, ou seja, “/usr/local/apache_[versao]/httpd”.
Independentemente do sistema operacional utilizado, teste o

funcionamento do seu servidor, abrindo a página “http://localhost” em
seu navegador. Caso tenha alterado a porta (diferente de 80), utilize
“http://localhost:n_porta”, modificando o número da porta. O servidor
deve retornar uma mensagem de sucesso, como apresentado na Figura
16.
www.esab.edu.br 41
Figura 16 – Mensagem de retorno do Apache, demostrando que está funcionando corretamente.
Agora você pode configurar o PHP para rodar sobre o Apache. Caso
você esteja usando Windows, você deve baixar uma versão estável
(preferencialmente a mais recente) do PHP contida em <http://windows.
php.net/download/>. Selecione as versões com o radical “x86” caso
seu MS-Windows seja 32 bits, ou “x64”, caso use uma versão 64 bits.
Você pode escolher a versão “instalador” que fará todo o trabalho para
você, configurando o PHP no Apache. Caso escolha a versão “binários e
fonte”, você deve seguir esses passos:
• descompacte o conteúdo do arquivo zip em um diretório de sua

escolha, por exemplo, C:\PHP\;
• depois que o conteúdo do pacote PHP for extraído, copie o php.
ini-production para php.ini dentro da mesma pasta de onde foi
extraído. O arquivo php.ini diz para o PHP como se configurar e
como trabalhar com o ambiente no qual ele está rodando.
Caso você tenha usado a versão instalador, o servidor será configurado
automaticamente. Caso tenha utilizado a versão sem instalador, você
precisa inserir essas três linhas para o arquivo httpd.conf de configuração
do Apache para configurar o binário CGI:
ScriptAlias /php/ “c:/php/”
www.esab.edu.br 42
AddType application/x-httpd-php .php
# Para o PHP 4
Actionapplication/x-httpd-php “/php/php.exe”
ou
# Para o PHP 5
Actionapplication/x-httpd-php “/php/php-cgi.exe”
Lembre-se de substituir a pasta, na primeira linha, caso tenha alterado o

local de instalação. Caso tenha executado corretamente, isso é suficiente
para fazer o PHP funcionar no seu Windows.
Se estiver utilizando Linux, Meloni (2000) ensina que você deve copiar
o arquivo para um diretório acessível (/usr/local/) e descompactar o
arquivo baixado, utilizando “gunzip [nome_do_arquivo].gz”. Esse
comando irá criar um arquivo *.tar, que deverá ser executado com “tar
–xvf [nome_do_arquivo].tar” para gerar o subdiretório /usr/local/php/
com os diretórios.
Ainda segundo Meloni (2000), a instalação padrão criará o PHP como

extensão .cgi. Você deverá, então, executar o seguinte script de instalação:
• digite ./setup no prompt de comando (pasta do php);

• o instalador solicitará a resposta de algumas perguntas de
configuração;
• para criar o executável do CGI, digite make no prompt de comando.
Para testar, use o comandmaketest;
• copie o binário criado, chamado de php, para o diretório cgi-bin do
servidor web;
• copie o arquivo chamado php4.ini-dist do diretório cgi-bin e o
renomeie para php4.ini.
www.esab.edu.br 43
Adicione as linhas no arquivo de configuração httpd.conf do Apache:
# Para o PHP 4
AddType application/x-httpd-php4 .php4 .phtm
Action application/”x-httpd-php4/cgi-bin/php”
ou
# Para o PHP 5
AddType application/x-httpd-php5 .php5 .phtm
Action application/”x-httpd-php5 /cgi-bin/php “
Caso tenha executado corretamente, isso é suficiente para fazer o PHP

funcionar no seu Linux.
Com a instalação do PHP, você está pronto para desenvolver aplicações

web. Porém, para este estudo, vamos utilizar o Eclipse PDT, uma
ferramenta de desenvolvimento que veremos no próximo tópico.
Estudo complementar
A documentação sobre Apache e a instalação
do servidor HTTP Apache e PHP podem ser
encontradas clicando aqui ou, na sua versão em
português, clicando aqui.
www.esab.edu.br 44
6.3 O que é eclipse?
Eclipse é um projeto com vários subprojetos relacionados ao
desenvolvimento de sistemas. Para PHP, existe o Eclipse PHP
Development Tools Project (PDT), uma Integrated Development
Environment (IDE), ou seja, uma ferramenta para desenvolvimento.
Para fazer a instalação, baixe a versão mais recente em <http://www.
eclipse.org/pdt/downloads/> e descompacte-a, deixando-a pronta para o
uso. Não são necessários outros passos para a instalação.
Nas unidades seguintes vamos aprofundar o estudo sobre PHP no

HTML, conhecer variáveis, operadores matemáticos e muito mais. Até lá!
Fórum
Caro estudante, dirija-se ao Ambiente Virtual de
Aprendizagem da instituição e participe do nosso
Fórum de discussão. Lá você poderá interagir com
seus colegas e com seu tutor de forma a ampliar,
por meio da interação, a construção do seu
conhecimento. Vamos lá?
www.esab.edu.br 45
Resumo
Na unidade 1 você passou por uma revisão de assuntos que serão

necessários para o encaminhamento desta disciplina. Você estudou, por
meio de exemplo prático, o desenvolvimento de páginas – utilizando
HTML básico – e a sua formatação – utilizando páginas de estilo CSS.
Dando continuidade à revisão, você estudou o uso de tabelas para o

desenvolvimento do layout de formulários, para que sejam gerados
aplicativos simples para a coleta de informações utilizando a web. Você
pôde fazer uma validação, do lado-cliente, utilizando JavaScript.
A partir da unidade 3, iniciamos o estudo do PHP, linguagem foco desta

disciplina. Você teve acesso à definição de PHP (Hypertext Preprocessor)
e pôde observar a sua função para o desenvolvimento de aplicações web.
O PHP é uma linguagem interpretada e que você pode diferenciar das
linguagens compiladas, isso porque, na linguagem PHP, os códigos são
traduzidos e têm a sua execução imediata. As principais características do
PHP são velocidade e robustez; pode-se desenvolver de forma estruturada
e/ou utilizar-se de orientação a objetos; portabilidade; tipagem
dinâmica; sintaxe similar a C/C++ e ao Perl; open-source; e server-side
(processamento do lado-servidor).
Na unidade 4 você estudou a história do PHP, desde a sua concepção e

motivação (em 1995) até a versão 5, atual, lembrando que, na trajetória
da PHP, existe um ponto importante a ser considerado: o processo
de melhoria, isso por se tratar de um código aberto, ou seja, uma
comunidade de desenvolvedores pode alterar e melhorar a linguagem.
A arquitetura da linguagem PHP foi abordada na unidade 5, de modo

a possibilitar a comparação entre sistemas nos quais o processamento
acontece do lado do cliente (cliente-side) e sistemas nos quais o
processamento acontece do lado do servidor (server-side). A questão
www.esab.edu.br 46
de segurança foi abordada quando do estudo da arquitetura da PHP,
mostrando que o servidor recebe uma requisição do cliente, monta o
documento HTML (podendo acessar banco de dados, arquivos ou outras
fontes) e devolve somente esse documento HTML processado, que é
apresentado ao cliente (navegador).
Na unidade 6 o processo de instalação das ferramentas foi abordado de

forma prática. Foi exposto o processo de instalação do Apache HTTP
Server – nas versões para Microsoft Windows e Linux –, bem como o
processo de configuração da linguagem PHP para que esta funcione no
supracitado servidor. Foi apresentado também o processo de instalação
do Eclipse PDT, IDE que será utilizado para o desenvolvimento de
páginas PHP.
www.esab.edu.br 47
7 Embutindo PHP no HTML
Objetivo
Apresentar o uso das tags PHP nas páginas HTML.
Nas unidades anteriores você desenvolveu documentos HTML

simples utilizando CSS, gerando formulários e construindo validações
com o uso de JavaScript. Além disso, estudou a linguagem PHP,
conhecendo seu histórico, arquitetura e deixou o ambiente pronto para
iniciar o desenvolvimento de páginas dinâmicas. Vamos começar nos
aprofundando um pouco mais em como desenvolver formulários usando
HTML inserindo comandos PHP. Para isso, continuaremos, nesta
unidade, nos referenciando ao trabalho de Meloni (2000).
7.1 Criando e distribuindo um script PHP

Segundo Meloni (2000), o código de linguagem PHP existe juntamente
com o HTML, esteja ele embutido em um código HTML ou se
o próprio código determinar a saída HTML. Quando é feita uma
requisição, a partir do cliente (navegador), o mecanismo PHP (servidor
de aplicação) a processa, executa o script PHP e imprime os resultados
(seguindo padrões do documento HTML) no lugar do script,
retornando, portanto, um documento HTML que, ao ser respondido ao
cliente, será exibido ao usuário através de seu navegador. Resgatamos um
esquema apresentado anteriormente, na Figura 17:
www.esab.edu.br 48
Requisição
Cliente Servidor
Página Dinâmica
Arquivos Dados
Figura 17 – Arquitetura server-side.
Dessa forma, ao processar o documento com os códigos PHP, inseridos

em uma página HTML, é desenvolvida somente a página (documento
HTML) criada, de forma que o cliente não tem acesso algum aos códigos
ou diretamente aos dados, recebendo documento processado, na forma
de HTML.
Para inserir um código PHP em um documento HTML, o código deve

ficar separado das marcações (tags) do HTML e o mecanismo padrão
para a chamada PHP é a delimitação do algoritmo entre “<%php” e
“?>”, como mostrado no código a seguir.
Código 7 – Mecanismo de inserção de código PHP

01 <%php
02 // coloque aqui o seu código PHP
03 ?>
Quando a requisição for feita, serão processados todos os comandos que

estiverem entre a tag de abertura do script PHP, que pode ser vista na
linha 1 do Código 7, e a tag de fechamento, constante na linha 3. Não
existe a necessidade de se usar três linhas, podendo, em caso de códigos
simples, não se utilizar a quebra de linha, definindo o script em apenas
uma linha.
Você pode usar também a tag “<script language=php>”, que é fechada

com </script>, ou o código entre “<?” e “?>”. Você pode utilizar qualquer
uma das opções.
www.esab.edu.br 49
Agora, vamos desenvolver nosso primeiro código PHP embutido em
um documento HTML. Para isso, iremos desenvolver um documento
comum; porém, o seu corpo conterá um comando PHP simples.
Acompanhe no código a seguir:
Código 8 – Primeiro código PHP

01 <html>
02 <head>
03 <title>
04 Meu primeiro código PHP
05 </title>
06 </head>
07 <body>
08 <?php
09 echo ‘<P> Olá Mundo! Usando PHP!</P>’;
10 ?>
11 </body>
12 </html>
Com exceção das linhas 8, 9 e 10, o Código 8 apresenta um documento

HTML comum. Abra seu editor de textos predileto (logo usaremos a
IDE Eclipse PDT), crie um documento com o código descrito e salve
como “primeiro.php”.
Copie esse arquivo no diretório de distribuição do seu Apache HTTP

Server (pasta htdocs). Lembre-se de garantir que este esteja funcionando
(iniciado). Agora abra o arquivo no seu navegador através do endereço
<http://localhost/primeiro.php> ou <http://127.0.0.1/primeiro.php>.
No momento que o navegador tenta abrir esse endereço, o servidor

processa esse arquivo, utilizando a PHP para isso. O comando echo ‘<P>
Olá Mundo! Usando PHP!</P>’;, que consta na linha 9 do Código 8,
é então processado, escrevendo no documento html <P> Olá Mundo!
Usando PHP!</P>. Dessa forma, o documento que é retornado ao
navegador é o documento HTML já processado. O caracter especial “\n”
insere uma quebra de linha ao final.
O resultado da requisição pode ser observado na Figura 18.
www.esab.edu.br 50
Figura 18 – Resultado da requisição.
Observe, na Figura 18, que a página apresenta as frases Olá Mundo!

Usando PHP! em seu corpo.
Agora que você observou a estrutura de um documento com código PHP

embutido, vamos entender o documento retornado da requisição, ou
seja, o que é recebido pelo navegador.
7.2 Observando o documento retornado

Você pode observar o código que retornou em seu navegador através
da ferramenta de exibição de código-fonte. A Figura 19 apresenta essa
ferramenta sendo utilizada no navegador Internet Explorer.
Figura 19 – Resultado da requisição e código-fonte.

www.esab.edu.br 51
Dessa forma, observa-se que o usuário não tem acesso ao código-fonte
da PHP, mas ao documento processado como resposta. O código que
retorna ao navegador pode ser visto no próximo código.
Código 9 – Código resultante do processamento de primeiro.php

01 <html>
02 <head>
03 <title>
04 Meu primeiro código PHP
05 </title>
06 </head>
07 <body>
08 <P> Olá Mundo! Usando PHP!</P>
09 </body>
10 </html>
Ao comparar o Código 8 com o Código 9 observamos que as linhas 8, 9

e 10 do Código 8 foram processadas, retornando o equivalente na linha
8 do Código 9. As outras linhas ficam inalteradas, pois não são alteradas
por script PHP.
Nesta unidade vimos como inserir códigos PHP em um documento

HTML utilizando os códigos entre “<?php” e “?>”, “<?” e “?>” ou
usando as tags “<script language=php>” e “</script>”. Assim, podemos
produzir páginas dinâmicas, desenvolvendo scripts que serão processados
do lado-servidor.
Na unidade 8 vamos conhecer os tipos de dados que podemos utilizar no

PHP. Vamos em frente?
www.esab.edu.br 52
8 Tipos de dados PHP
Objetivo
Apresentar a declaração e o uso de variáveis conhecendo o escopo.
Na unidade anterior você desenvolveu um script simples utilizando PHP

e pôde observar o resultado processado, a saber, o documento HTML
que foi gerado pelo processamento no servidor e retornado ao cliente,
bem como o seu resultado no navegador. Continuaremos, nesta unidade,
nos referenciando ao trabalho de Meloni (2000) e estudando o uso de
variáveis, ou seja, guardar valores em memória para utilizar no script.
Na linguagem PHP, as variáveis não têm definição inicial de tipo, ou seja,

podem receber valores de tipos diferentes durante a execução. As variáveis
devem ter seu nome iniciado com cifrão ($) e não podem ser iniciadas
com numerais. No entanto, podem conter números e sublinhado (_) em
seu nome, que deve ser significativo.
8.1 Tipos de variáveis

Segundo Meloni (2000, p. 34), existem dois tipos de variáveis na
linguagem PHP: escalar e vetores.
As variáveis escalares contêm somente um valor por vez, enquanto os vetores contêm
uma lista de valores ou outros vetores (produzindo um vetor multidimensional).
Nesta etapa de nosso estudo focaremos nas variáveis escalares, enquanto

o estudo de vetores será feito nas unidades 17 e 18.
Ainda segundo Meloni (2000), podemos associar alguns tipos de valores

a essas variáveis escalares.
www.esab.edu.br 53
• Inteiros: números inteiros sem decimais, como 1, 2013, 999987 ou
-345. Utiliza 8 bits da memória para guardar seus valores, tendo,
portanto um limite que depende da plataforma, mas gira em torno
de 2 bilhões (positivo e negativo). Pode ser representado pela
notação decimal, mais natural para nós, mas aceita notações octal e
hexadecimal. Por exemplo, o decimal 981 é igual ao octal “01725” e
o hexadecimal “0x3D5”.
• Número com ponto flutuante ou duplo (float ou double): números
com casas decimais. Exemplos de números decimais: -1.56,
568.9887 e 9 (sim, você pode utilizar números com ponto flutuante
para receber valores inteiros, mas reservará maior espaço em
memória para ele – apesar de que a PHP faz a conversão para você.
Veremos isso mais à frente). Quando o limite do inteiro é alcançado
(número muito grande), ele usará um número com ponto flutuante.
• Strings: informações de texto e/ou números (inclusive símbolos),
especificados com uso de aspas simples (‘) ou duplas (“).
• Booleano ou lógico: pode receber valores true (verdadeiro) ou false
(falso). É composto por um bit, ou seja, representado por 0 (falso,
desligado) e 1 (verdadeiro, ligado).
• Objetos: utilizado quando aplicamos programação orientada a objeto,
recebe valores de propriedades e métodos definidos na classe a que
esse objeto faz parte. Utilizaremos mais à frente (unidades 31 a 33).
• Recursos: tipo especial de variável. É utilizado para controlarmos
arquivos, conexões de internet e conexão com banco de dados.
Também será visto mais à frente.
Agora que você conhece os tipos de variáveis, vamos aplicar?
8.2 Declaração de variáveis

Na linguagem PHP não existe a necessidade de se declarar as variáveis antes
da utilização, como ocorre em outras linguagens. Nela, quando usamos
uma variável com nome ainda não utilizado (ou nome utilizado, porém,
em outro escopo, como veremos mais à frente) é criado um novo espaço
de memória, ou seja, a definição do tipo variável ocorre quando atribuímos
valor a ela, a linguagem atribui o tipo para essa variável também.
www.esab.edu.br 54
O nome das variáveis deve seguir algumas características, como
observamos em Meloni (2000, p. 274):
• Elas iniciam com cifrão ($)

• Elas não iniciam com um caracter numérico.
• Elas podem conter números e o caracter sublinhado (_).
• Elas diferenciam maiúsculas e minúsculas.
Sendo assim, quando atribuímos um valor a uma variável, a linguagem
cria espaço em memória que pode ser utilizado posteriormente,
referindo-se ao seu nome. Para criarmos uma variável texto (string) com
o valor “valor minha variável”, devemos atribuir esse valor com o símbolo
igual (=) da seguinte forma:
$minha_variavel = ‘valor minha variável’;
Vejamos outros exemplos:
Inteiros
$a = 1;
$b = -534;
Reais
$c = 15.098;
$d = -9874.098;
Cadeia de Caracteres (Strings)
$texto = ‘sou uma string’;
Você pode se referir a outra variável dentro de uma string, que será
trocada no momento da execução do script, por exemplo:
www.esab.edu.br 55
$num = 86; //inteiro
$text = ‘Eu vou repetir esse processo $num vezes’; //string
Quando executar o script, a variável $text receberá valor “Eu vou repetir
esse processo 86 vezes”.
Dica
Utilize nomes de variáveis que sejam fáceis de
serem entendidos. Por exemplo, se você usar $u
para armazenar a string que contém o nome de
usuário e $s para armazenar a string com a senha,
poderá perder tempo para efetuar alterações.
Se utilizar $usuario e $senha, por exemplo, o
entendimento é facilitado, principalmente quando
se trata de desenvolvimento em equipe, no qual
uma pessoa deve entender o código desenvolvido
por outra pessoa.
Vamos criar um exemplo. Acompanhe o código a seguir.
Código 10 – Código PHP com utilização de variáveis

01 <html>
02 <head>
03 <title>
04 Meu primeiro código PHP com variáveis
05 </title>
06 </head>
07 <body>
08 <?php
09 $texto = ‘texto do corpo do html’;
10 echo $texto;
11 $texto = ‘<br> novo valor do texto’;
12 echo $texto;
13 ?>
14 </body>
15 </html>
www.esab.edu.br 56
O Código 10 cria um script PHP que, ao ser processado, retornará um
HTML ao cliente – um documento, como pode ser visto no código a
seguir.
Código 11 – Processamento de código PHP com utilização de variáveis

01 <html>
02 <head>
03 <title>
04 Meu primeiro código PHP com variáveis
05 </title>
06 </head>
07 <body>
08 texto do corpo do html
09 <br> novo valor do texto
10 </body>
11 </html>
12 </body>
Compare os Códigos 10 e 11, este último representa o processamento do

Código 10. Observe que, no Código 10, a linha 8 inicia o uso do script,
que é terminado na linha 11. Isso significa que o que está entre as linhas
8 e 13 será processado pelo PHP.
Na linha 9 temos o comando $texto = ‘texto do corpo do html’; que cria

a variável $texto e atribui o conteúdo entre as aspas a essa variável.
Na linha 10 temos o comando echo $texto; que exibe (escreve no

documento que será retornado) o valor da variável $texto, ou seja,
escreverá texto do corpo do html no documento a ser retornado (Código
11). Isso é visto na linha 8 do Código 5. Retornando ao Código 10
observamos, na linha 11, nova atribuição de valor para a variável, e na
linha 12 o comando echo para exibir o valor. Nesse caso atribuímos,
além do texto a ser mostrado no navegador, uma tag para formatação do
HTML. O resultado é visto na linha 9 do Código 11.
As demais linhas são mantidas da mesma forma, gerando, portanto,

o documento HTML, que podemos ver no Código 11. Tal resposta é
transparente para o usuário, pois o resultado aparece em seu navegador,
www.esab.edu.br 57
como pode ser visto na Figura 20. Para processar o arquivo e testar,
abra o seu editor de textos, copie o conteúdo do Código 10 e salve-o na
pasta htdocs de seu servidor Apache HTTP Server com o nome variavel.
php para distribuí-lo (logo esse processo será natural, quando se quiser
“distribuir” a página). Para abrir em seu navegador, utilize o endereço
<http://localhost/variavel.php> ou <http://127.0.0.1/variavel.php>.
Figura 20 – Resultado da requisição e código-fonte.

Caso queira observar o resultado em HTML, da mesma forma que foi

apresentado no Código 11, exiba o código-fonte do seu navegador.
A utilização da variável depende do contexto no qual ela foi criada, que

chamamos de escopo, assunto do nosso próximo tópico.
8.3 Escopo de variáveis

O escopo de uma variável é o contexto no qual ela foi definida e
determina como e por quem podem ser acessados os seus valores. A
maioria das variáveis é local, ou seja, os valores podem ser acessados
no fluxo normal de execução do script, sem a interferência de outras
execuções, a saber, de outras requisições provenientes de outros clientes.
As variáveis locais existem somente durante a execução do script, sendo
eliminadas, assim como os seus valores, no final da execução.
www.esab.edu.br 58
Assim como as variáveis locais, a variável global é definida no
fluxo normal da execução do script, porém, pode ser utilizada em
subprogramas (funções), os quais serão vistos mais adiante.
Além das variáveis locais e globais, temos as variáveis de sessão (uma

sessão pode ser criada quando o usuário entra na aplicação web,
sendo destruída no final da execução, que pode navegar por diversos
scripts). Dessa forma, o valor é compartilhado por todos os scripts que
compartilham a mesma sessão.
Nesta unidade você viu como criar e utilizar variáveis, ou seja, como
armazenar dados atribuindo valores e, assim, definindo o seu tipo. Na
unidade 9 veremos operações para manipular e alterar os valores dessas
variáveis.
Tarefa dissertativa
Caro estudante, convidamos você a acessar o
Ambiente Virtual de Aprendizagem e realizar a
tarefa dissertativa.
www.esab.edu.br 59
9 Utilizando operadores em PHP
Objetivo
Apresentar a utilização de operadores matemáticos e lógicos em PHP.
Na unidade 8 você viu como utilizar variáveis em scripts PHP e pôde

perceber que apenas atribuindo valores não temos muitas aplicações
para essas variáveis. Assim, nesta unidade, veremos operações com
essas variáveis; os operadores são símbolos que representam uma ação
específica. Utilizaremos, para isso, os textos de Meloni (2000).
Você viu, também na unidade anterior, o operador de atribuição (=).

Preparado para aprender novos operadores? Então, vamos lá!
9.1 Operadores matemáticos

Operadores matemáticos são aqueles referentes a ações matemáticas
como somar, subtrair, multiplicar e dividir. Vamos ver, neste item,
operadores aritméticos e de atribuição, lembrando que podemos
utilizar essas ações para variáveis numéricas, mas também para somar
(concatenar) strings.
Você poderá efetuar operações com valores ou variáveis. Por exemplo,

você pode fazer uma operação de adição, atribuindo a variável $soma,
com números:
$soma = 9 + 1;
Essa linha atribuiria o valor 10 à variável $soma. Você pode também

efetuar a operação com outras variáveis, como pode ser visto no exemplo
apresentado no código a seguir.
www.esab.edu.br 60
Código 12 – Operação de adição utilizando variáveis
01 $a = 5;
02 $b = 4;
03 $soma = $a + $b;
Note que, ao efetuar a operação constante na linha 3, onde referenciamos

a variável $a, é utilizada a referência do valor desta no momento da
execução, que, nesse exemplo, é 5. Da mesma forma, o valor de $b, no
momento que é executada a linha 3, para esse algoritmo, é 4. Logo, o
valor atribuído à variável $soma é a soma de 5 e 4, ou seja, é atribuído
valor 9.
A Tabela 1 apresenta os operadores aritméticos e mostra um exemplo de

aplicação, bem como o resultado, para os valores de $a = 5 e $b = 4.
Tabela 1 – Operadores aritméticos.

Operador Nome Exemplo de uso Resultado da operação
+ Adição $c=$a+$b; $c=9
- Subtração $c=$a-$b; $c=1
* Multiplicação $c=$a*$b; $c=20
/ Divisão $c=$a/$b; $c=1.25
% Módulo ou “resto” $c=$a%$b; $c=1
Fonte: Adaptada de Meloni (2000).
Para concatenar, ou seja, somar duas (ou mais) strings, o operador é “.”,
como pode ser visto no próximo código.
Código 13 – Operação de concatenação

01 $texto1 = ‘Olá ‘;
02 $texto2 = ‘Mundo’;
03 $texto = $texto1 . $texto2;
Para o exemplo do Código 13, o valor atribuído à variável $texto é Olá

Mundo, ou seja, a soma (concatenação) dos valores das duas variáveis.
www.esab.edu.br 61
Além dos operadores aritméticos e do operador de atribuição “=”, temos
outros valores de atribuição combinados com operadores aritméticos. Os
operadores de atribuição incluem também “+=”, “-=“ e “.=”.
O operador “+=” soma o valor à direita ao valor da variável à esquerda e

atribui esse novo valor a essa variável.
Da mesma forma, o operador “-=” atribui a diferença (subtração) entre

a variável à esquerda e o valor da direita à variável. O operador “.=”
concatena as strings, atribuindo o novo valor à variável. Observe o
código a seguir.
Código 14 – Operação de adição utilizando operador de atribuição +=

01 $a = 5;
02 $a += 1;
03 $a -= 4;
04 $s = ‘eu quero ‘;
05 $s .= ‘café’;
No exemplo mostrado no Código 14, a primeira linha atribui valor 5 à

variável a. Na linha 2, o valor 1 é somado ao valor da variável $a (que
nesse instante é 5), atribuindo o novo valor para essa variável. Ou seja,
após a execução dessa linha, o valor de $a é 6. Na terceira linha, o valor 6
é subtraído de 4 e o novo valor (ou seja, 2) é atribuído à variável.
A linha 4 atribui valor “eu quero ” para a nova variável $s, que é
concatenada, na linha 5, com a string “café”, e o novo valor é atribuído a
essa variável, que passa a ter como valor “eu quero café”.
Ainda temos operadores incrementais, usados quando queremos

incrementar ou decrementar um número inteiro. Se tivermos uma
variável $i com valor 4, por exemplo, a execução de $i++; atribuiria
seu valor a somar 1 a ele mesmo, ou seja, 5. Da mesma forma, $i--;
decrementa valor, diminuindo 1 a ele mesmo.
Do mesmo modo que podemos efetuar operações matemáticas, podemos

realizar operações lógicas através de comparações. Veremos esse assunto
no próximo tópico.
www.esab.edu.br 62
9.2 Operadores Lógicos
Os operadores lógicos efetuam comparações que sempre retornam valores
lógicos (booleanos) verdadeiros ou falsos. São usados, geralmente, com
comandos condicionais ou de repetição – tais comandos serão abordados
nas próximas unidades.
Seguindo com os operadores lógicos, a Tabela 2 apresenta operadores

de comparação. Se considerarmos os valores $a = 5 e $b=4, teremos o
resultado na quarta coluna.
Tabela 2 – Operadores lógicos

Operador Nome Exemplo de uso Resultado da operação
== Igual a $a==$b Falso
!= Não igual a, diferente $a!=$b Verdadeiro
> Maior que $a>$b Verdadeiro
< Menor que $a<$b Falso
>= Maior ou igual que $a>=$b Verdadeiro
<= Menor ou igual que $a<=$b Falso
O operador lógico não (representado pelo símbolo !) atribui valor

falso, caso o valor que está sendo negado seja verdadeiro, e atribui valor
verdadeiro, caso o valor negado seja falso. Por exemplo, tomemos a
operação !(5>6). A parte 5>6 retorna valor falso e sua negação retorna,
portanto, verdadeiro. Ou seja, !(5>6) é verdadeiro.
Da mesma forma, se a variável booleana $x for verdadeira, !$x tem valor

falso.
Por sua vez, algumas operações lógicas são mais complexas, sendo
necessária mais de uma comparação. Para isso, são utilizados conectores.
O “e” é representado por “&&” e retorna valor verdadeiro quando as
sentenças que ele conecta têm valor verdadeiro.
www.esab.edu.br 63
O operador “ou” (“||”) retorna verdadeiro quando ao menos um dos
valores da sentença é verdadeiro. A Tabela 3 apresenta os valores que
seriam retornados a partir dos valores 1 e 2, com os conectores “e” e “ou”.
Tabela 3 – Conectores lógicos

Resultado da operação, Resultado da operação,
Valor 1 Valor 2
com conector “e” (&&) com conector “ou” (||)
Verdadeiro Verdadeiro Verdadeiro Verdadeiro
Verdadeiro Falso Falso Verdadeiro
Falso Verdadeiro Falso Verdadeiro
Falso Falso Falso Falso
Por exemplo, o valor da sentença (5>3)&&(4>=4) é verdadeiro, visto

que o resultado das duas sentenças conectadas é verdadeiro; ou seja, 5>3
(cinco é maior que três) é verdadeiro e 4>=4 (quatro é maior ou igual a
quatro) é verdadeiro.
Vamos colocar em prática o que vimos referente a operadores

matemáticos e lógicos? Vamos em frente!
9.3 Exemplos de operações matemáticas e lógicas

Para exercitar, usaremos um script PHP embutindo ao HTML. Salve o
conteúdo do Código 15 e faça distribuição (salvando como “calculadora.
php” na pasta htdocs de seu servidor Apache HTTP Server). Para abrir
em seu navegador, utilize o endereço <http://localhost/calculadora.php>
ou <http://127.0.0.1/calculadora.php>.
www.esab.edu.br 64
Código 15 – Exemplo de script PHP com operações matemáticas e lógicas
01 <html>
02 <body>
03 <?php
04 $a = 5;
05 $b = 9;
06 $soma = $a + $b;
07 echo ‘resultado da soma: ‘ . $soma;
08 echo ‘<br>’;
09 $subtracao = $a - $b;
10 echo ‘resultado da subtracao: ‘ . $subtracao;
11 echo ‘<br>’;
12 $multiplicacao = $a * $b;
13 echo ‘resultado da multiplicacao: ‘ .
$multiplicacao;
14 echo ‘<br>’;
15 $divisao = $a / $b;
16 echo ‘resultado da divisao: ‘ . $divisao;
17 $maior = $a > $b;
18 $menor = $a < $b;
19 ?>
20 </body>
21 </html>
No Código 15 o script PHP encontra-se entre as linhas 3 e 19. Nas

linhas 4 e 5 são atribuídos os valores 5 e 9 para as variáveis $a e $b,
respectivamente. Na sexta linha é atribuído o valor 14 (5 + 9) à variável
$soma. A linha 7 executa o comando echo, exibindo a string “resultado
da soma:” e concatenando ao valor da variável $soma. Dessa forma, essa
linha escreverá resultado da soma: 14 no retorno. A linha 8 escreverá
<br> no documento, gerando uma quebra de linha. A operação de
subtração é executada na linha 9 e exibida na linha 10, com o comando
echo, concatenando o valor da variável $subtracao. Da mesma forma,
são executadas operações de multiplicação na linha 12 (e atribuída à
variável $multiplicacao) e a operação de divisão é realizada na linha 15
(atribuindo o valor à variável $divisao).
A linha 17 apresenta uma operação lógica: como o valor de $a é 5 e de $b

é 9, o valor de $a>$b é falso, atribuindo esse valor à variável maior, ou seja,
a variável maior recebe valor falso. Da mesma forma, a variável $menor,
www.esab.edu.br 65
na linha 18, recebe o valor verdadeiro, pois 5<9 (cinco é menor que nove).
Não executamos ação com essas variáveis, neste momento, pois, para isso,
precisamos estudar os testes lógicos, assunto da próxima unidade.
Nesta unidade vimos como utilizar variáveis em operações matemáticas

e lógicas e fixamos o conhecimento através de um exemplo prático.
Agora você está pronto para utilizar variáveis, dando certo dinamismo a
aplicações. Vamos descrever algoritmos com comandos condicionais?
Atividade
Chegou a hora de você testar seus conhecimentos
em relação às unidades 1 a 9. Para isso, dirija-se ao
Ambiente Virtual de Aprendizagem (AVA) e responda
às questões. Além de revisar o conteúdo, você estará
se preparando para a prova. Bom trabalho!
www.esab.edu.br 66
Utilizando instruções condicionais
10 – parte 1
Objetivo
Apresentar o uso de condicionais if, else, elseif.
Você estudou, nas unidades anteriores, como declarar variáveis, atribuir

valores e fazer operações utilizando essas variáveis. A partir deste ponto,
estudaremos comandos com testes lógicos condicionais. Os textos de
Meloni (2000) servirão como base teórica para esta unidade. Dado o
aumento da complexidade, iniciaremos o uso do Eclipse PDT para criar
os scripts PHP e distribuí-los.
Ao abrir o Eclipse PDT, aponte o workspace para a pasta htdocs de seu

servidor Apache HTTP Server. Dessa forma, a distribuição pode ser feita
automaticamente, sem que seja necessário copiar os arquivos. Você pode
configurar o seu servidor Apache HTTP Server para utilizar qualquer
pasta, mas, para isso, seria necessário alterar as configurações.
Saiba mais
Você pode assistir a um vídeo com a abertura do
Eclipse PDT, configuração do workspace, criação de
um código PHP e seu uso, clicando aqui.
10.1 Utilizando o condicional “if”

Os algoritmos são séries de comandos que executam certa tarefa,
com início e fim. Para o funcionamento de diversos algoritmos, são
necessários desvios da execução, dependendo de algumas condições.
Por exemplo, se a média do aluno for maior ou igual a 7, o aluno está
aprovado, ou mesmo se está chovendo, pegue um guarda-chuva.
www.esab.edu.br 67
Essa função de executar testes lógicos e, caso a condição seja atendida
(valor verdadeiro), é realizada através do comando “if ” (se traduzido para
a língua portuguesa, seria equivalente a “se”). Sua sintaxe é:
Código 16 – Sintaxe do comando if

01 if (<condição>) {
02 <comandos>
03 }
No Código 16 observamos que <condição> é um teste lógico e

<comandos> equivale ao comando ou conjunto de comandos a serem
executados caso a condição seja verdadeira. Se a <condição> não
for verdadeira, o código “será ignorado e o programa irá continuar”
(MELONI, 2000, p. 279).
O Código 17 apresenta a parte do script que calcula a média de três

notas e executa se a média do aluno for maior ou igual a 7, escreverá ‘o
aluno está aprovado’.
Código 17 – Script PHP com teste condicional

01 <html>
02 <body>
03 <?php
04 $nota1 = 5;
05 $nota2 = 9;
06 $nota3 = 10;
07 $media = ($nota1 + $nota2 + $nota3) / 3;
08 If ($media >= 7){
09 echo ‘o aluno está aprovado’;
10 }
11 ?>
12 </body>
13 </html>
Vamos analisar o Código 17: as linhas 4, 5 e 6 atribuem valores às

variáveis $nota1, $nota2 e $nota3, respectivamente. Na sétima linha, é
calculada a média, somando o valor das três variáveis ($nota1, $nota2
www.esab.edu.br 68
e $nota3) e dividindo por 3, atribuindo o valor da operação (cujo
resultado é 8, para esse caso) à variável $media. Na linha 8 é feito o teste
lógico (media >=7), cujo resultado é verdadeiro (8 é maior ou igual a
7), provocando a execução do bloco que está entre {“ (na linha 8) e “}
(na linha 10), ou seja, o comando da linha 9 é executado, escrevendo “o
aluno está reprovado” no documento que retornará ao cliente.
Para testar essa aplicação, no Eclipse PDT crie um novo projeto local
(através do menu File -> New -> “Local PHP Project”) com o nome
“unidade10”. Dentro do projeto “unidade10”, crie um novo Arquivo
PHP (“PHP File”) com o nome “media.php” e copie o texto do Código
9. Você pode salvar o arquivo e executar através do seu navegador
através do endereço <http://localhost/unidade10/media.php> ou
<http://127.0.0.1/unidade10/media.php>. Porém, o Eclipse PDT tem
um navegador interno que abre diretamente o seu arquivo através do
botão “Run media”, do menu Run -> Run ou do atalho “Ctrl + F11”.
Observe a Figura 21:
Figura 21 – Eclipse PHP com arquivo “media.php” e do navegador interno, com o resultado da execução.
A Figura 21 apresenta a interface do Eclipse PDT com o Código 17

inserido. Para executar conforme instrução anteriormente apresentada,
clique na barra de ferramentas no botão com a imagem de um círculo
verde com uma flecha branca dentro dele. É o botão “Run media”.
www.esab.edu.br 69
No próximo tópico, veremos instruções que complementam o comando “if”.
10.2 Utilizando o “else” e “elseif”

O comando “if ” executa o bloco de comandos caso a condição seja
verdadeira; no entanto, muitas vezes gostaríamos de executar outros
comandos caso a condição seja falsa. “Para oferecer uma série alternativa
[...] adicione o comando else na estrutura para executar uma seção de
códigos quando a condição for FALSE” (MELONI, 2000, p. 280, grifo
do autor). A tradução de else é “senão”. Dessa forma, teríamos:
Código 18 – Sintaxe do comando if

01 if (<condição>) {
02 <comandos A>
03 } else {
04 <comandos B>
05 }
Observando o Código 18, o bloco <comandos A> seria executado caso

a condição fosse satisfeita (valor verdadeiro) e o bloco B seria executado
caso a condição fosse falsa.
O Código 19 apresenta um complemento do Código 18, imprimindo a

string “o aluno não está aprovado” (linha 4) caso a condição, apresentada
na primeira linha media >= 7, seja falsa. Acompanhe:
Código 19 – script PHP com teste condicional

01 If ($media >= 7){
03 } else {
04 echo ‘o aluno não está aprovado’;
05 }
Porém, caso a condição não seja verdadeira e exista a necessidade de um

novo teste lógico (ou seja, um novo teste, caso o primeiro tenha valor
falso), utiliza-se o comando elseif e uma nova condição. Por exemplo,
www.esab.edu.br 70
caso o aluno não seja aprovado, mas a média seja superior a 5, o aluno
estará em exame. Caso essa condição também não seja satisfeita, o aluno
estará reprovado. O código a seguir apresenta o bloco de comandos que
satisfaz o algoritmo requisitado.
Código 20 – Script PHP com teste condicional

01 If ($media >= 7){
03 } elseif ($media>=5) {
04 echo ‘o aluno está em exame’;
05 } else {
06 echo ‘o aluno está reprovado’;
07 }
Suponhamos que a $media tenha valor 8, conforme exemplo anterior:

dessa forma, o teste da linha 1 será satisfeito e será executado o comando
da linha 2, ignorando o resto do código.
Porém, se a $media tiver valor 6.5, o primeiro teste não será satisfeito
(será falso, porque 6.5 não é maior ou igual a 7) e o fluxo continuará
com o teste da linha 3, que, dessa vez satisfará a condição (6.5 é maior ou
igual a 5) e executará o comando da linha 4.
O comando da sexta linha só seria executado se as condições anteriores

fossem falsas.
Vamos colocar em prática as instruções condicionais? No próximo tópico

construiremos um exemplo de aplicação.
www.esab.edu.br 71
10.3 Exemplo prático de utilização de condicionais
Para a fixação dos conhecimentos, vamos desenvolver um problema e
construir o script PHP para resolvê-lo. O problema é referente a um
processo de venda.
Atribua valores para o valor unitário (em reais) e quantidade da

mercadoria (em unidades). Caso o valor da venda alcance R$ 100,00,
será atribuído desconto de 10%. Do contrário, o desconto será de 5%. O
script pode ser visto no Código 21.
Código 21 – Script PHP para o exemplo de venda

01 <html>
02 <head>
03 <title>Venda</title>
04 </head>
05 <body>
06 <?php
07 $valor_unitario = 4.50;
08 $quantidade = 200;
09 $valor_total = $valor_unitario * $quantidade;
10 if ($valor_total>= 100){
11 $desconto = $valor_total * 10 /100;
12 } else {
13 $desconto = $valor_total * 5 /100;
14 }
15 $valor_final = $valor_total - $desconto;
16 echo 'Valor unitário = ' . $valor_unitario . '
e quantidade = ' . $quantidade . '<BR>';
17 echo 'Valor total: ' . $valor_total. '<BR>';
18 echo 'Valor desconto: ' . $desconto. '<BR>';
19 echo 'Valor final, com desconto: ' . $valor_
final;
20 ?>
21 </body>
22 </html>
www.esab.edu.br 72
O Código 21 traz a resolução do problema proposto. As linhas 7 e
8 apresentam a atribuição dos valores às variáveis $valor_unitario e
$quantidade. Na nona linha é atribuído à variável $valor_total o valor
da multiplicação das variáveis citadas anteriormente. O teste lógico é
encontrado na linha 10, ou seja, se o $valor_total for maior ou igual a
100, o comando da linha 11 é executado. Caso o resultado seja falso, é
executado o comando da linha 13. Tanto a linha 11 quanto a linha 13
atribuem valor à variável $desconto. Em seguida, o valor final é calculado
e são apresentadas as saídas com o comando echo nas linhas 16 a 19.
Crie um novo arquivo PHP, nesse projeto, com o conteúdo do Código

21, salve e execute.
Agora você já conhece os comandos condicionais utilizando a instrução

“if ” e executando blocos de instruções, caso a condição testada seja
verdadeira, e complementando com “else” e “elseif ”, caso o teste lógico
seja falso. Na unidade 11 veremos condicionais utilizando o comando
switch. Vamos lá?
www.esab.edu.br 73
Utilizando instruções condicionais
11 – parte 2
Objetivo
Apresentar o uso de condicionais: switch.
Você estudou, na unidade 10, como utilizar testes condicionais

utilizando os comandos “if ”, “else”, “elseif ”. Porém, em alguns casos, o
número de testes “em sequência” é grande, aumentando a complexidade.
Para essas situações temos como alternativa o comando “switch”, que
estudaremos nesta unidade. Os textos de Thomson e Welling (2005)
serão utilizados como referência.
11.1 Utilizando switch para várias opções

O comando switch é similar a uma série de comandos “if ” juntos,
testando o valor de uma variável ou expressão com operador de
igualdade. Seu uso é indicado, portanto, quando testamos uma mesma
variável com uma série de valores, conforme nos apresentam Thomson e
Welling (2005). Sua sintaxe pode ser observada no código a seguir.
Código 22 – Sintaxe do comando switch

01 switch (<variável ou expressão>) {
02 case <opcao1>:
03 <Comandos1>
04 break;
05 case <opcao2>:
06 <Comandos2>
07 break;
08 case <opcao3>:
09 <Comandos3>
10 break;
11 ...
12 default:
13 <Comandos4>
14 }

www.esab.edu.br 74
O comando switch testa, portanto, uma variável ou expressão. Na
linha 1 do Código 22 observamos a sintaxe da instrução. Na segunda
linha, comparamos o valor da variável ou expressão da linha 1 com
o valor de <opcao1>. Caso o resultado da igualdade seja verdadeiro,
serão executados os comandos que vêm após o símbolo “:” (nesse caso,
representado por <Comandos1> na linha 3 e também o comando da
linha 4). Inserimos o comando break para parar a execução dos testes
posteriores, ou seja, ao encontrar a igualdade, executa seus referidos
comandos e interrompe a execução.
Caso a variável não seja igual à <opcao1>, será feito o teste de igualdade
com a <opção2>, que, caso tenha resultado verdadeiro, executará o bloco
composto por <comandos2> e o comando break, das linhas 6 e 7.
Caso ele não encontre nenhuma igualdade, serão executados os

comandos definidos após “default” (<comandos4>).
Agora vamos construir um teste lógico, com várias opções, utilizando

“switch” na prática. Vamos em frente!
11.2 Exemplo prático de utilização de condicionais

Vamos transformar uma série de comandos “if ” em switch. Imagine
que você esteja selecionando um meio de transporte para se deslocar
entre dois pontos e o faz através de um código, no qual 1 é “bicicleta”, 2
representa “carro”, 3 equivale a “ônibus”, o código 4 é “taxi” e qualquer
outro código representa que o meio selecionado é “caminhando”. O
próximo código nos mostra a solução desse problema com o uso de “if ”.
www.esab.edu.br 75
Código 23 – Resolução do problema com if
01 <html>
02 <body>
03 <?php
04 $codigo = 1;
05 if ($codigo = 1) {
06 $meio_de_transporte = 'bicicleta';
07 }
08 elseif ($codigo = 2) {
09 $meio_de_transporte = 'carro';
10 }
12 $meio_de_transporte = 'ônibus';
13 }
15 $meio_de_transporte = 'taxi';
16 }
17 else {
18 $meio_de_transporte = ' caminhando';
19 }
20 echo 'meio de transporte: ' . $meio_de_
transporte;
21 ?>
22 </body>
23 </html>
Observe a complexidade do Código 23, com quatro testes lógicos

alinhados, ou seja, em sequência. Vamos, então, transformar esse código,
para torná-lo mais facilmente inteligível.
O Código 24 apresenta a solução para o mesmo problema com o

comando switch:
www.esab.edu.br 76
Código 24 – Resolução do problema com switch
01 <html>
02 <body>
03 <?php
04 $codigo = 1;
05 switch ($codigo){
06 case 1:
08 case 2:
10 case 3:
12 case 4:
14 default:
16 }
transporte;
18 ?>
19 </body>
20 </html>
O Código 24 mostra uma redução de complexidade ao utilizarmos

o comando switch. Na linha 5 determinamos que a comparação de
igualdade do comando será a variável $codigo. Na linha 6 testamos se a
variável de comparação é igual a 1, executando o comando de atribuição
presente na linha 7. O teste se repete para as igualdades aos valores 2, 3
e 4 nas linhas 8, 10 e 12, respectivamente. E ele irá executar, por padrão,
o comando da linha 15, conforme definido pela linha 16. Observe
que, mesmo que ele encontre a igualdade, ele continuará efetuando
a comparação de igualdade dos outros testes. Para evitar essa situação
e provocar a parada, caso seja localizada uma condição verdadeira de
igualdade, devemos inserir o comando break após o fim do bloco de
comandos que devem ser executados. O próximo código apresenta o
mesmo código, agora com as paradas. Acompanhe.
www.esab.edu.br 77
Código 25 – Resolução do problema com switch e break
01 <html>
02 <body>
03 <?php
04 $codigo = 1;
05 switch ($codigo){
06 case 1:
08 break;
09 case 2:
11 break;
12 case 3:
14 break;
15 case 4:
17 break;
18 default:
20 }
transporte;
22 ?>
23 </body>
24 </html>
Dessa forma, ao encontrar a igualdade da linha 6, por exemplo, ele

executa o comando da linha 7 e, ao encontrar o comando break da linha
8, encerra a execução desse “switch”. Caso não seja satisfeita a condição
de igualdade, será executado o próximo teste (na linha 9), e assim
sucessivamente.
www.esab.edu.br 78
11.3 Operador ternário
O operador ternário é, basicamente, uma forma de se escrever teste
lógico “if ” e “else” em uma única linha, com a sintaxe:
<condição> ? <comando1> : <comando2>.
Ou seja, caso a condição seja verdadeira, o retorno será <comando1>;

caso contrário, retornará <comando2>.
O Código 20, por exemplo, poderia ser escrito em somente uma linha,
sendo:
echo $media >= 7 ? ‘o aluno está aprovado’ : ‘o aluno não está aprovado’;
Ou seja, caso o resultado seja verdadeiro para $media >= 7
Também podemos fazer atribuições usando o operador ternário, por

exemplo:
$mensagem = $media >= 7 ? ‘o aluno está aprovado’ : ‘o aluno não está

aprovado’;
Vimos, nesta unidade, comandos alternativos para realizarmos testes

lógicos: “switch”, aplicados para testes lógicos alinhados, testando a
igualdade de uma mesma variável com diversos valores; e o operador
ternário, utilizado em testes simples.
Na unidade 12 vamos estudar as estruturas de repetição, ou seja,

comandos da linguagem PHP que possibilitam a execução de um bloco
de comandos repetidas vezes. Vamos em frente?
www.esab.edu.br 79
Utilizando instruções de repetição
12 – parte 1
Objetivo
Apresentar a estrutura de fluxo de repetições: while, for, foreach.
Você desenvolveu scripts com testes lógicos nas unidades anteriores. No

entanto, se você tivesse que refazer uma ou mais ações repetidas vezes,
como o faria? Copiaria o código conforme o número de repetições?
Nesta unidade, utilizaremos instruções para elaborar essas repetições e

referenciaremos o trabalho de Meloni (2000).
12.1 Utilizando o comando de repetição “while”

O comando while executa um bloco de comandos várias vezes enquanto
uma condição lógica for verdadeira. Imagine que você retornou ao
Ensino Fundamental, ficou de castigo e deve escrever a frase “eu
aprenderei PHP” cem vezes, mas, em vez de escrever no quadro, deve
escrever no corpo do texto de um documento HTML, em seu navegador.
O Código 26 apresenta a solução de uma forma bem complicada:
Código 26 – Repetindo a frase

01 <html>
02 <body>
03 <?php
04 echo ‘1 - eu aprenderei PHP <br>’;
... ...
104 ?>
105 </body>
106 </html>
www.esab.edu.br 80
Observe que seria necessário repetir o conteúdo da linha 4 cem vezes! De
outro modo, utilizando o comando while, podemos controlar a repetição
do comando dessa linha, utilizando um teste lógico e uma variável
para determinar o número de vezes, que deve ser repetido. A sintaxe do
comando “while” é apresentada no código a seguir.
Código 27 – Sintaxe comando while

01 while <condição> {
02 <comandos>
03 }
Caso o resultado da condição seja verdadeiro, ele executará o bloco de

comandos representado por <comandos>. Ao final, ele retorna e executa
novamente o teste e, mantendo o resultado verdadeiro para a condição,
executa novamente o bloco de comandos. Se o resultado for negativo,
ele terminará a execução das repetições e continuará com o fluxo do
programa após a linha que fecha o bloco (nesse caso, a linha 3).
O próximo código apresenta o uso do while para resolver o problema

apresentado anteriormente, junto ao Código 27:
Código 28 – Repetindo a frase utilizando comando while

01 <html>
02 <body>
03 <?php
04 $i = 1;
05 while ($i <=100) {
06 echo $i . ‘ - eu aprenderei PHP <br>’;
07 $i++;
08 }
09 ?>
10 </body>
11 </html>
Na linha 4 do Código 28 criamos uma variável $i para controlar as

repetições, atribuindo o valor 1 a ela. Ao executar a linha 5, o teste lógico
($i<=100) é realizado e, como o valor de $i é 1, o resultado é verdadeiro,
www.esab.edu.br 81
executando, então, o bloco que compreende o comando while (linhas 6 a
8). Executando a linha 6, o retorno será ‘1 - eu aprenderei PHP <br>’. Na
linha 7, é incrementada a variável $i, que passa a ter valor 2. Ao encontrar
o fim do bloco do comando while, na linha 8, retorna-se à linha 5 e faz-
se um novo teste. Como o resultado é verdadeiro (2 é menor ou igual a
100), ele volta a executar o bloco das linhas 6 a 8 (escrevendo a frase “2
- eu aprenderei PHP <br>” e incrementando a variável $i, que agora tem
valor 3) e retorna à linha 5. Ele repete isso até que o valor de $ seja igual a
101. Nesse caso, ao retornar à linha 5, o teste lógico terá resposta falsa e o
fluxo do programa continua a partir da linha 9.
Vale lembrar que, se a variável de controle não for incrementada (linha

7), o seu valor será sempre o mesmo e, caso o teste lógico seja verdadeiro,
repetirá o comando infinitamente (chamamos de loop infinito).
Outro ponto importante: o comando while efetua repetições enquanto

o teste lógico resultar verdadeiro, ou seja, não são necessariamente
comparações numéricas, podendo se tratar de uma comparação entre
textos, números ou mesmo uma variável booleana, por exemplo.
Uma alternativa à instrução “while” é a instrução “for”, que veremos no

próximo tópico.
12.2 Utilizando o comando de repetição “for”

Assim como o comando while, o comando for é uma estrutura
de repetição, no entanto, ele possui, em sua estrutura, controle de
incremento ou decremento numérico. Dessa forma, com ele não é
possível fazer outro tipo de comparação, sendo permitido, somente, o
controle numérico das repetições. O comando aceita três parâmetros, que
são:
• inicialização da variável de controle: executado somente na primeira

execução. Cria a variável e atribui valor de início;
• teste lógico, que define o número de repetições: executado antes da
interação, definindo se o bloco de comandos será executado ou não;
www.esab.edu.br 82
• expressão a ser executada no final de cada interação: normalmente usada
para alterar o valor da variável, incrementando ou decrementando.
Assim, a sintaxe é apresentada através do exemplo, no Código 29, que
traz a repetição da frase usando o comando for.
Código 29 – Repetindo a frase utilizando comando for

01 <html>
02 <body>
03 <?php
04 for( $i = 1; $i <= 100; $i++ ){
06 }
07 ?>
08 </body>
09 </html>
Observe que, com o comando for, na linha 4 ele inicia a variável

$i com valor 1, executando até que $i seja menor ou igual a 100 e
incrementando o valor de $i a cada interação. Dessa forma, a linha 5 será
executada 100 vezes.
Além das instruções “while” e “for”, a instrução “foreach” pode ser

utilizada para percorrer um vetor. Vamos lá?
12.3 Utilizando o comando de repetição “foreach”

O comando foreach é uma estrutura de repetição que funciona somente
com vetores e lançará um erro quando da tentativa de utilizá-lo em uma
variável de qualquer tipo diferente ou em variáveis não inicializadas. Ele
executa o comando passando por todas as posições do vetor. Esse assunto
será visto mais à frente, quando estudarmos vetores.
Nesta unidade você estudou estruturas de repetição usando comandos

while e for, além de ver rapidamente o comando foreach. Na unidade
13 vamos continuar estudando as estruturas de repetição utilizando o
comando “do..while”. Vamos em frente!
www.esab.edu.br 83
Resumo
Você iniciou os seus estudos, na unidade 7, desenvolvendo scripts PHP.

Os códigos PHP devem ser inseridos entre os delimitadores “<?php” e
“?>, da tag “<script language=php>”, que é fechada com </script>, ou
“<?” e “?>”. Dessa forma, você define quais códigos serão inseridos e
processados dada uma requisição. Após salvar o arquivo do PHP na pasta
htdocs do Apache HTTP Server, você pode, portanto, executar a sua
aplicação PHP no navegador. Também pudemos observar o código-fonte
(no formato HTML) gerado pelo PHP.
Abordamos o uso de variáveis na unidade 8. Você estudou como declarar

as variáveis e os seus tipos. A declaração da variável é feita no momento
da atribuição de valores, podendo receber valores dos tipos inteiro,
número de ponto flutuante, string, booleana (lógica), objetos e recursos.
Na unidade 9 foram estudados operadores matemáticos e lógicos.

Os operadores matemáticos são utilizados em cálculos e operações
matemáticas, enquanto os operadores lógicos são utilizados para
comparações (testes lógicos que retornam verdadeiro ou falso). Também
foram vistos conectores lógicos. As operações lógicas aprendidas na
unidade 8 serviram como base para as unidades seguintes.
Os testes lógicos, usando a instrução if, foram abordados na unidade 10,

de forma a executar um bloco de comandos caso uma condição tenha
valor verdadeiro. Também foram estudadas as instruções else e elseif,
atribuindo comandos caso a condição do teste lógico não seja satisfeita.
Na unidade 11, você estudou o comando switch para aplicar em testes

lógicos em sequência. Foi abordado, também, o uso do operador
ternário, efetuando instruções condicionais em apenas uma linha.
www.esab.edu.br 84
As instruções de repetição foram estudadas na unidade 12. Essas
estruturas são utilizadas para efetuar comandos, ou blocos de comandos,
repetidas vezes. Foram abordadas as instruções while e for. A instrução
foreach foi citada.
www.esab.edu.br 85
Utilizando instruções de repetição
13 – parte 2
Objetivo
Apresentar a estrutura de fluxo de repetições “do..while” e
desenvolver um exemplo.
Na unidade 12 utilizamos os comandos “while” e “for” para repetirmos

uma instrução ou um bloco de instruções. Nesta unidade veremos o
comando “do..while” que tem, também, a função de efetuar repetições e
vamos desenvolver um exemplo. Para isso, utilizaremos como base teórica
Meloni (2000).
Apesar de ter função sinônima, a instrução “do..while” tem algumas

peculiaridades quando comparada à instrução “while”. Vamos lá?
13.1 Utilizando o comando de repetição “do..while”

Da mesma forma que a instrução “while”, a instrução “do..while” executa
a repetição de um bloco de comandos enquanto a condição (teste lógico)
for verdadeira. Porém, os dois comandos se diferem pelo fato de que,
no “while”, o teste lógico é realizado no início do bloco de comandos, já
com o uso do “while..do”, o teste é realizado no final.
Essa peculiaridade gera uma diferença: o bloco de comandos do “do..

while” é executado ao menos uma vez, mesmo que o primeiro teste
lógico seja falso.
O Código 30 apresenta a sintaxe do comando do..while. Observe:
Código 30 – Sintaxe comando while

01 do {
02 <comandos>
03 } while <condição>;
www.esab.edu.br 86
No Código 30 observamos que, com a sintaxe do comando “do..while”,
o bloco de comandos é executado uma vez e o teste lógico só é realizado
após a execução. Caso a condição seja verdadeira, o fluxo do programa
promove a volta à linha 1 e executa novamente o bloco de comandos.
Isso é feito enquanto a condição tiver resultado verdadeiro. Quando a
condição for falsa, o fluxo volta a seguir normalmente, ou seja, segue na
linha logo abaixo da linha 3.
O Código 31 apresenta um exemplo de repetição utilizando o comando

“do..while”. Veja:
Código 31 – Repetindo a frase utilizando comando while

01 <html>
02 <body>
03 <?php
04 $i = 1;
05 do {
07 $i++;
08 } while ($i <=100);
09 ?>
10 </body>
11 </html>
O Código 31 apresenta o comando while repetindo 100 vezes uma

instrução de saída, ou seja, que geraria as linhas do exemplo no
navegador:
1 – eu aprenderei PHP
(...)
Obviamente, não escreveríamos neste texto as 100 linhas. Para

demonstrar o exemplo, colocamos o “(...)” que representa as linhas 3 a
99. O código é similar ao Código 29, que você pôde ver na unidade 12.
www.esab.edu.br 87
Vamos imaginar que, na linha 4, atribuímos 150 à variável $i, ou seja,
escrevemos “$i = 150;”. O fluxo do programa iria executar o bloco do
comando do..while (visto que ele ainda não realizou o teste lógico) e,
com a execução da linha 6, teríamos a saída “150 - eu aprenderei PHP”.
Somente na linha 8 encontraremos o teste lógico que, com o valor falso
(150 não é menor ou igual a 100), não se repetiria mais, seguindo o fluxo
natural na linha 9.
Na unidade 14 desenvolveremos uma aplicação web com estrutura de

repetição.
13.2 Exemplo prático de utilização de estruturas de

repetição
Para que possamos desenvolver aplicações web com repetições, a seguinte
informação será útil: se você quiser interromper a execução de instrução de
repetição, fazendo com que o fluxo passe a seguir após o fim do bloco, você
deve utilizar o comando “break;”. Caso ele seja encontrado no meio do bloco
de comandos de uma instrução “while;”, por exemplo, ele interromperá a
execução e terminará a repetição do ponto em que foi encontrado.
Para exercitarmos, vamos criar um script em PHP para mostrar 20

números da sequência de Fibonacci.
Figura 22 – Exemplo de uso da sequência de Fibonacci (mercado financeiro e Biologia).

Fonte: <http://shutterstock.com>.
www.esab.edu.br 88
A sequência inicia com 0 e 1 e o termo posterior é equivalente à soma
dos dois anteriores, ou seja, o terceiro termo é a soma do primeiro e o
segundo, formando uma série infinita (0, 1, 1, 2, 3, 5, 8, 13 ...), cuja
tendência de aproximação da dízima periódica é 0,33333(...).
A sequência de Fibonacci tem aplicações na análise de mercados financeiros

(análise gráfica de ações) e na Teoria dos Jogos. Também é apontada como
o número da biologia, pois é relacionada, por muitos, como regente da
disposição dos galhos das árvores ou das folhas em uma haste, no arranjo
do cone da alcachofra, do abacaxi ou no desenrolar da samambaia.
Dessa forma, temos que obter os dois primeiros termos e a sua soma, que
equivalerá ao terceiro termo. Na próxima interação, devemos guardar
o segundo e terceiro termos, cuja soma atribuirá valor ao quarto e
assim sucessivamente, repetindo 18 vezes (como já conhecemos os dois
primeiros termos, para encontrarmos 20 termos, teremos que repetir 18
vezes). O Código 32 apresenta a solução desse problema.
www.esab.edu.br 89
Código 32 – Repetindo a frase utilizando o comando while
01 <html>
02 <body>
03 <?php
04 /* Inicializa variáveis com os primeiros
05 valores da sequência Fibonacci */
06 $a = 0;
07 $b = 1;
08 $cont = 3;
09 /* para mostrar os primeiros 2 termos*/
10 echo $a."<br>".$b."<br>";
11 while ($cont <= 20)
12 {
13 /* Define novos valores a partir dos dois
anteriores */
14 $soma = $a + $b;
15 /* mostra na tela o termo referente a
soma*/
16 echo $soma."<br>";
17 /* o segundo item de uma interação, será o
primeiro termo da próxima intereção*/
18 $a = $b;
19 /* a soma de uma interação (próximo termo),
será o segundo termo da próxima intereção*/
20 $b = $soma;
21 $cont++;
22 }
23 ?>
24 </body>
25 </html>
No Código 32 as variáveis são criadas e iniciadas nas linhas 6 e 7,

atribuindo valores 0 e 1 para as variáveis $a e $b, respectivamente, as
quais armazenam o primeiro e o segundo termo de cada interação. Na
linha 8 atribuímos valor 1 para a variável de controle $cont. Essa variável
será utilizada para o teste lógico (controlar as repetições) na linha 11,
após fazer a saída dos dois termos na linha 10. Na primeira interação a
variável $cont tem valor 3 (pois já temos os dois primeiros termos) e,
dessa forma, o teste lógico é verdadeiro (3 é menor ou igual a 18). Na
linha 14 essa variável é atribuída à soma, que equivale ao terceiro termo.
Nessa interação, a soma é 1 (0+1), que é apresentada na tela na linha 16.
Na linha 18, o primeiro termo da próxima interação é o segundo termo
www.esab.edu.br 90
da interação atual, recebendo, nesse ponto, valor 1. O segundo termo (da
próxima interação) recebe o valor da soma na linha 20 e, nesse ponto,
$a tem valor 1 e $b tem valor 2. A variável $cont é incrementada em 1
(armazenando, agora, 4) e o fluxo é retornado à linha 11 para executar
novamente o teste lógico. O teste lógico é verdadeiro e o fluxo repetirá
a execução, cuja soma será 3 (apresentada na tela) e $a e $b receberão,
portanto, 2 e 3 para a próxima interação. Na décima oitava interação, o
valor de $cont, ao ser incrementado, armazenará valor 21 e, ao retornar
ao teste lógico, este será falso. Dessa forma, o fluxo volta a ser executado
após o bloco do comando “while” e vai para a linha 23, que encerra a
execução do script.
Salve seu script na pasta “htdocs” do seu servidor Apache HTTP (se
você estiver utilizando Eclipse PDT e tiver configurado o workspace
para apontar para essa pasta, ao salvar o arquivo ele ficará disponível para
execução, ou seja, será distribuído automaticamente).
Nesta unidade você foi apresentado ao comando de repetição “do..while”

e pôde ver as diferenças em relação às instruções de repetição “while”.
Além disso, praticamos esse comando mostrando 20 termos de uma
sequência de números (Fibonacci) e repetindo a sua execução.
Na unidade 14 desenvolveremos uma aplicação prática, selecionando

dados em formulário HTML e processando as informações através de
scripts PHP.
www.esab.edu.br 91
Desenvolvendo uma página
14 simples com uso de PHP
Objetivo
Desenvolver uma aplicação simples de pedido com uso de PHP e
aplicar os conhecimentos aprendidos nesta unidade.
Nas unidades anteriores vimos comandos básicos para desenvolvimento

de aplicações web com PHP, como atribuição de variáveis (e seus tipos),
operações matemáticas e lógicas, testes condicionais e laços de repetição.
Nesta unidade vamos utilizar esses conhecimentos para desenvolver
páginas simples, porém interativas, utilizando PHP. Para isso, nos
apoiaremos em Meloni (2000). Vamos em frente!
14.1 Desenvolvendo um formulário com HTML,

recuperando a data e hora com PHP
Até agora, nós criamos somente scripts PHP, os quais são executados
no momento em que são carregados, isto é, sem interação direta com
o usuário. Agora, vamos formatar um documento HTML que, com
um clique no botão (submeter o formulário), executará um script PHP.
Novamente, iremos aplicar os conceitos encontrados em Meloni (2000),
que aborda, nas páginas 40 a 44, os códigos utilizados para a criação de
formulários e submissão ao processamento de um script PHP.
Imagine que você vai comprar uma bebida. Para isso, precisa escolher
uma bebida em uma caixa de seleção (combobox) e também a
quantidade desta. Dessa maneira, a resposta deve ser a quantidade de
bebida, bem como a hora em que foi feito o pedido.
Inicialmente, vamos definir um formulário HTML para que possamos

obter esses dois valores. O Código 33 mostra esse formulário.
www.esab.edu.br 92
Código 33 – Formulário em HTML para seleção de bebidas
01 <html>
02 <head>
03 <title> Formulário de compra de bebidas. </
title>
04 </head>
05 <body>
06 <form method="POST" action="">
07 <table border=0>
08 <tr>
09 <td> Escolha uma bebida:</td>
10 <td> <SELECT name="bebida">
11 <OPTION value="1"> Café </OPTION>
12 <OPTION value="2"> Suco </OPTION>
13 <OPTION value="1"> Refrigerante
</OPTION>
14 <OPTION value="1"> Cerveja </
OPTION>
15 </SELECT>
16 </td>
17 </tr>
18 <tr>
19 <td> Quantidade: </td>
20 <td> <INPUT type="text"
name="quantidade" size=5> </td>
21 </tr>
22 </table>
23 <INPUT type="submit" value="Enviar">
24 </form>
25 </body>
26 </html>
O Código 33 apresenta um formulário HTML para a seleção de uma

bebida por meio de um combobox chamado “bebida”. Observam-se
quatro opções de bebidas nas linhas 11 a 14 e suas quantidades, a partir
de uma caixa de texto chamada “quantidade”. O botão “Enviar” submete
o formulário, que ainda não teve a sua ação definida (linha 6) – essa ação
irá chamar o script PHP.
Para testar o código, crie um arquivo e salve-o como “formulario_bebida.

php”. Caso esteja usando o Eclipse PDT e com workspace apontando
para a pasta “htdocs”, o arquivo será salvo automaticamente nessa pasta.
Caso contrário, salve na pasta “htdocs” do seu Apache HTTP Server.
www.esab.edu.br 93
Agora vamos descrever o script PHP que processará os valores lidos nesse
formulário e escreverá a resposta solicitada. O Código 34 apresenta o
script PHP que fará esse processamento.
Código 34 – Script PHP para o processamento do pedido de bebida

01 <?php
02 $quantidade = $_POST["quantidade"];
03 $bebida = $_POST["bebida"];
04 date_default_timezone_set('America/Sao_
Paulo');
05 echo "Você comprou $quantidade
unidades de bebida $bebida na data " .
date('d-m-Y H:i:s');
06 ?>
Na linha 2 do Código 34 obtivemos a variável quantidade, que foi

enviada pelo método post do formulário que chama esse script.
Observe que a variável corresponde ao nome do componente do
formulário o qual foi definido com o uso de “<INPUT type=”text”
name=”quantidade” size=5>”. Da mesma forma, obteve-se, na linha
3, o valor que foi enviado pela variável bebida (valor de 1 a 4, conforme
a opção). A linha 5 escreve um texto trocando os valores das variáveis
$quantidade e $bebida e chamando a função date(), uma função
do PHP que retorna o horário do servidor (horário de Greenwich),
conforme explica Meloni (2000). Para que possamos recuperar o valor,
considerando o fuso horário brasileiro, utilizamos a função date_default_
timezone_set(), na linha 4, que tem como função definir a “zona de
tempo” ou fuso horário (essa opção só está disponível a partir da versão
PHP 5.1). Dessa forma, a chamada da linha 5 (função date()) passa a
retornar a hora local. Então, salve esse código como “bebida.php”.
Estudo complementar
A lista de parâmetros possíveis para a função
date() pode ser obtida clicando aqui.
www.esab.edu.br 94
Para chamar esse código, devemos alterar a linha 6 do Código 34,
de modo a chamar o script “bebida.php”. Isso é feito incluindo-se a
chamada do script no parâmetro “action”, que passa a ser escrito da
seguinte forma: “<form method=”POST” action=”bebida.php”>”. Salve
novamente esse formulário e execute (com o botão “Run” do seu Eclipse
PDT ou abrindo o endereço no seu navegador). Lembre-se de confirmar
se o seu servidor Apache HTTP Server está ativo.
A Figura 23 mostra a resposta-código no Eclipse PDT e também o

processamento em um navegador.
Figura 23 – Eclipse PHP ao fundo, navegação em “formulario_bebida.php”

e resposta com o processamento de “bebida.php”.
Ao fundo da Figura 23 observamos o código de “bebida.php” e, em primeiro

plano, foi colado o processamento de “formulario_bebida.php”, que obtém
as informações através de um formulário e chama a execução de “bebida.
php”, cuja resposta também se encontra em primeiro plano, à direita.
Agora que você desenvolveu um formulário que passa informações para

um script PHP que, por sua vez, processa essas informações, vamos
utilizá-las e aplicar testes lógicos?
www.esab.edu.br 95
14.2 Utilizando comando “if..else” para determinar
um retorno
Vamos continuar utilizando o aplicativo de escolha da bebida. Mas agora,
com base nessa escolha, o script deve apresentar o valor total da compra,
considerando que cada opção tem um preço. As opções de bebida são:
“café”, “suco”, “refrigerante” e “cerveja”, que custam, respectivamente,
1.50, 3.00, 2.50 e 3.50 (utilizamos pontos para separar as casas decimais,
pois essa é a notação da linguagem PHP – e maioria das linguagens).
Não será necessário alterar o formulário de envio, mas alteraremos o

script “bebida.php” para que ele seja capaz de fazer esse cálculo.
O Código 35 apresenta uma adição ao Código 34, tornando-o capaz de

efetuar tais testes. Dessa forma, o arquivo “bebida.php” foi alterado.

01 <?php
Paulo');
06 if ($bebida = 1) {
08 } elseif ($bebida = 2) {
12 } else {
14 }
15 $valor_total = $valor_unitario *
$quantidade;
16 echo "Valor total da compra é $valor_
total";
17 ?>
www.esab.edu.br 96
Dessa forma, foram inseridas as linhas de 6 a 14, a fim de realizar o teste
lógico com base no valor da variável $bebida, atribuindo valor referente à
variável $valor_unitário, conforme descrito. A linha 15 atribui à variável
$valor_total o valor da multiplicação das variáveis $valor_unitario e
$quantidade, apresentando seu valor na linha 16.
Salve o arquivo e execute a partir do “formulario_bebida.php”, de modo

a chamar o script corrigido. Talvez seja necessário reiniciar seu servidor
Apache HTTP Server.
Agora, o aplicativo interage com o usuário e tem respostas diferentes

conforme suas escolhas, ou seja, trata-se de um aplicativo interativo e
dinâmico. Seguindo em frente, você aprenderá a utilizar os comandos de
repetição, assunto abordado no próximo tópico. Vamos lá?
14.3 Desenvolvendo uma contagem utilizando

estrutura de repetição
Imagine que, agora, precisamos “servir” quantos copos de bebida forem
solicitados simplesmente apresentando na tela a frase “servindo copo i” e
repetindo-a conforme o número de copos.
Iremos impor um contador que inicia em 1 e repete a frase “servindo

copo x”, considerando o número de repetições equivalente ao número de
copos. Dessa forma, temos o Código 36 mostrando o script alterado.
www.esab.edu.br 97
01 <?php
Paulo');
06 if ($bebida = 1) {
12 } else {
14 }
15 $valor_total = $valor_unitario *
$quantidade;
16 echo "Valor total da compra é $valor_
total";
17 for($n_copo=1; $n_copo <= $quantidade; $n_
copo++){
18 echo “<br> servindo copo $n_copo”;
19 }
20 ?>
No Código 35, foram inseridas as linhas de 17 a 19, gerando, portanto, o

Código 36. A linha 17 estabelece um laço de repetição, criando a variável
$n_copo, inicializando-a com valor 1, determinando que as repetições
devem ser executadas até que a $n_copo seja menor ou igual a variável
$quantidade e incrementando 1 a $n_copo a cada interação.
Salve o arquivo e execute a partir do “formulario_bebida.php”, de modo

a chamar o script corrigido. Talvez seja necessário reiniciar seu servidor
Apache HTTP Server.
Pronto! Nosso aplicativo deve responder ao definido pelo problema,

lendo informações através de formulário e processando suas informações.
www.esab.edu.br 98
Nesta unidade desenvolvemos um aplicativo dinâmico e interativo, que
contém um formulário que chama um script PHP, processando o pedido
de bebida, utilizando os valores passados pelos formulários e efetuando
testes lógicos e estruturas de repetição.
Porém, todas as vezes que o servidor é parado ou a página é recarregada,

os dados são perdidos. Assim, nas próximas unidades, vamos salvar e
recuperar dados em arquivos-texto.
www.esab.edu.br 99
Armazenando e recuperando dados
15 – parte 1
Objetivo
Apresentar o uso de arquivos externos, salvando dados e
possibilitando a sua recuperação posterior.
Na unidade 14 desenvolvemos um aplicativo web dinâmico, capaz de

interagir com o usuário, efetuar testes lógicos e laços de repetição. Porém,
os dados inseridos nos formulários não são salvos, ou seja, são perdidos
a cada execução. Nesta unidade vamos observar o uso de arquivos,
gravando e recuperando os dados gravados. Para isso, utilizaremos
Meloni (2000) como base de nossos estudos.
15.1 Salvando dados em arquivos

Para salvar arquivos, a linguagem PHP dispõe da função “fopen”, capaz
de criar um arquivo novo – ou abrir um já existente – e nele salvar
informações a serem utilizadas posteriormente.
A função fopen recebe dois argumentos e retorna um ponteiro ao

arquivo. Você deve passar o nome do arquivo (caminho inteiro) e o
modo de gravação. A sintaxe do comando fopen é:
<variavel_ponteiro> = fopen(<caminho>, <modo>);
O modo de gravação, segundo Meloni (2000, p. 61, grifo nosso), pode

ser um dos seguintes:
• r: Abre o arquivo existente para ler os dados existentes. O ponteiro é colocado no

início do arquivo, antes de qualquer dado;
• r+: Abre o arquivo existente para ler dados existentes ou gravar novos dados. O
ponteiro é colocado no início do arquivo, antes de qualquer dado;
www.esab.edu.br 100
• w: Abre um arquivo somente para gravação, criando o arquivo caso não exista, ou
deletando todo seu conteúdo, caso exista. Coloca o ponteiro no início do arquivo;
• w+: Abre o arquivo existente para ler dados existentes e gravar novos dados. O
ponteiro é colocado no início do arquivo, antes de qualquer dado;
• a: Abre um arquivo somente para gravação, criando o arquivo caso não exista, mas
não deleta o conteúdo, caso o arquivo exista. Coloca o ponteiro no final do arquivo,
depois de todos os dados;
• a+: Abre o arquivo existente para ler dados existentes e gravar novos dados, criando
um novo arquivo, caso não exista, mas não deleta o conteúdo, caso o arquivo exista.
Coloca o ponteiro no final do arquivo, depois de todos os dados.
Portanto, caso queira abrir o arquivo apenas para leitura, você pode
utilizar o modo r (read – escrever). Para gravar dados, você pode utilizar
o modo a (append – acrescentar). Estes serão os modos mais utilizados.
Dica
É necessário que o arquivo seja acessível ao servidor,
ou seja, que não se trate de uma pasta protegida.
Normalmente, você deve apontar o caminho do
arquivo para alguma pasta do Apache ou que
esteja “aberta” a esse servidor por meio de suas
configurações, de modo a possibilitar o acesso.
Caso esteja utilizando Windows (ou ambiente do
servidor), use a barra invertida, como no endereço
“c:\\Apache\\htdocs\\arquivo.txt”.
Caso esteja utilizando Linux, use o formato desse
sistema operacional, como no exemplo “usr/local/
apache/htdocs/arquivo.txt”.
Para gravar (inserir dados), podemos utilizar os comandos fwrite e fputs,

que têm o mesmo propósito. A sintaxe de fwrite é:
fwrite(<variavel_ponteiro>, <dados>);
www.esab.edu.br 101
Ao abrir, utilizar (para leitura ou gravação de dados) e finalizar o uso do
arquivo é necessário fechá-lo, de modo a salvá-lo e deixá-lo novamente
disponível. A sintaxe é:
fclose(<variavel_ponteiro>);
Caso não feche o arquivo, ele pode ficar indisponível para uso ou não
salvar suas alterações.
Para abrir ou criar um arquivo, caso não exista, é necessário salvar dados
e fechar, para isso, executar as operações anteriormente citadas (fopen,
fwrite e fclose).
O Código 37 apresenta a abertura do arquivo salvo e depois fechado.
Código 37 – Script PHP para abrir um arquivo

01 <?php
02 $arquivo = fopen(“c:\\Apache\\htdocs\\
dados.txt”, “a+”);
03 fwrite($arquivo, “este é um novo arquivo”);
04 close($arquivo);
05 ?>
Fonte: Adaptado de Meloni (2000).
Na linha 2 do Código 37 é aberto apenas o arquivo “c:/Apache/htdocs/

dados.txt” no modo a+, que permite ler e gravar dados. A linha 3 grava,
no arquivo, o texto “este é um novo arquivo”, e em seguida o arquivo é
fechado na linha 4.
A Figura 24 apresenta o código no Eclipse PDT e o conteúdo do arquivo

criado na pasta definida após a execução desse script.
www.esab.edu.br 102
Figura 24 – Eclipse PHP com código ao fundo e arquivo txt salvo com a execução.
Na figura, podemos observar que o conteúdo foi inserido. Se

executarmos mais algum comando fwrite() ou executarmos novamente o
script, os dados serão inseridos ao final do arquivo.
Agora que podemos gravar arquivos, precisamos recuperá-los para utilizar

os dados criados. Esse é o assunto do próximo tópico.
15.2 Recuperando dados dos arquivos

Após a abertura do arquivo usando fopen, a leitura dos dados pode ser
feita através do comando fread, que recebe dois parâmetros: o ponteiro
do arquivo e o tamanho a ser recuperado. O comando fget tem a mesma
função e lê a linha em que se encontra posicionada a leitura. A sintaxe do
fread é:
fread(<variavel_ponteiro>, <tamanho>);
O Código 38 apresenta a recuperação da informação gravada

anteriormente.
www.esab.edu.br 103
Código 38 – Script PHP para recuperar dados de um arquivo
01 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01
Transitional//EN" "http://www.w3.org/TR/html4/
loose.dtd">
02 <html>
03 <head>
04 <meta http-equiv="Content-Type" content="text/
html; charset=ISO-8859-1">
title>
06 </head>
07 <body>
08 <?php
09 $arquivo = fopen('c:\\Apache\\htdocs\\
cliente.txt', 'r');
10 $textoLinha=fread($arquivo,
filesize('c:\\Apache\\htdocs\\cliente.txt'));
11 echo $textoLinha;
12 ?>
13 </body>
14 </html>
Vamos entender o Código 38: na linha 9 o arquivo é aberto e na linha

10 a informação desse arquivo (apontada por $arquivo) é recuperada
e apresentada na tela, através da instrução “echo”. Como não estamos
controlando o tamanho dos campos e/ou o total do arquivo, vamos
recuperar o conteúdo total pelo tamanho do arquivo. Para isso,
utilizamos a função “filesize()”, obtendo o tamanho do mesmo arquivo.
Observe a Figura 25.
Figura 25 – Eclipse PHP com código ao fundo e execução no navegador.

www.esab.edu.br 104
A Figura 25 traz o Eclipse PDT com o Código 40 ao fundo e sua
execução, em navegador, apresentando o resultado do processamento.
Observe que os dados que foram apresentados são os mesmos que foram
inseridos no arquivo através do Código 38 (Figura 24). Dessa forma,
salvamos um dado em um arquivo e recuperamos esse mesmo dado para
apresentar na tela.
Nesta unidade vimos os comandos para abrir, gravar, ler e fechar

arquivos, com o objetivo de armazenar e recuperar dados. Na unidade
16 aplicaremos, de forma prática, o conteúdo desta unidade, salvando
arquivos a partir de um formulário e apresentando seus dados.
www.esab.edu.br 105
Armazenando e recuperando dados
16 – parte 2
Objetivo
Desenvolver a aplicação e o uso de arquivos externos, salvando dados
e possibilitando a sua recuperação posterior.
Na unidade 15 vimos os comandos para abrir, gravar, ler e fechar

arquivos, com o objetivo de armazenar e recuperar dados. Agora,
salvaremos dados a partir de um formulário e apresentaremos os dados
gravados, desenvolvendo uma aplicação prática, novamente com base em
Meloni (2000).
Mãos à obra!
16.1 Desenvolvendo tela para salvar dados do cliente

Vamos imaginar que exista a necessidade de se criar um formulário no
qual são cadastrados os clientes de uma empresa que vende bebidas. Para
salvar os dados dos clientes, vamos construir um formulário que contenha
o nome, a idade, o sexo (selecionando duas opções) e o e-mail do cliente,
que será salvo em um arquivo-texto. O uso dos componentes está seguindo
instruções encontradas em Meloni (2000), páginas de 40 a 44.
O Código 39 apresenta o formulário que obtém as informações do cliente

e as envia (submete) a um script PHP, que processará e salvará no arquivo.
www.esab.edu.br 106
Código 39 – Formulário para obter dados de cliente
loose.dtd">
02 <html>
03 <head>
title>
06 </head>
07 <body>
08 <form action="cliente_salvar.php"
method="POST" id=form_bebida>
09 <table border=0>
10 <tr>
11 <td> Nome: </td>
12 <td> <INPUT type="text" name=nome
size=50 id=quantidade> </td>
13 </tr>
14 <tr>
15 <td> Idade: </td>
16 <td> <INPUT type="text" name=idade
size=4> </td>
17 </tr>
18 <tr>
19 <td> Sexo:</td>
20 <td> <SELECT name=sexo id=sexo>
21 <OPTION value="1"> Masculino </
OPTION>
22 <OPTION value="2"> Feminino </
OPTION>
23 </SELECT>
24 </td>
25 </tr>
26 <tr>
27 <td> E-mail: </td>
28 <td> <INPUT type="text" name=email
size=30> </td>
29 </tr>
30 </table>
32 </form>
33 </body>
34 </html>
www.esab.edu.br 107
Vamos salvar o Código 39 com o nome “cliente_formulario.php”.
Observe que na linha 8 a ação do formulário chama o script “cliente_
salvar.php”, que será desenvolvido a seguir.
O Código 40 apresenta o script para salvar, no arquivo “cliente.txt”,

as informações enviadas pelo formulário. Para isto, devemos obter as
variáveis enviadas (nesse caso, pelo método “post”), formar um texto
concatenando os valores e salvar no arquivo-texto.
Código 40 – Script para salvar os dados em arquivo

01 <?php
02 $nome = $_POST["nome"];
03 $idade = $_POST["idade"];
04 $email = $_POST["email"];
05 $sexo = ($_POST["sexo"] ==1) ?
'Masculino' : 'Feminino';
cliente.txt', 'a+');
07 fwrite($arquivo,
"$nome#$idade#$email#$sexo\r\n");
08 fclose($arquivo);
09 echo "Os dados de $nome foram salvos
corretamente";
10 ?>
Nas linhas de 2 a 5 do Código 40 são recuperadas as informações

enviadas pelo formulário através do método “post”, lembrando que elas
são recuperadas com o nome do componente do formulário que enviou
a informação. A linha 5 tem como peculiaridade a conversão do código
enviado pelo componente “sexo” (um combobox – caixa de seleção
– com valores 1 para masculino e 2 para feminino) para o texto a ser
salvo. Na linha 6 é aberto o arquivo em uma pasta acessível (lembre-se
de apontar para uma pasta válida e acessível de seu computador) com
o modo “a+”, que permite a leitura e a inserção. A linha 7 concatena as
variáveis, separando-as com o símbolo “#”. Ao final da linha, é incluído
“\r\n” para inserir a quebra de linha ao final da string. Na linha 8 o
arquivo é fechado.
A Figura 26 apresenta o resultado desse processo.
www.esab.edu.br 108
Figura 26 – Navegação em “cliente_formulario.php”, resposta com o
processamento de “cliente_salvar.php” e arquivo “cliente.txt” salvo.
Podemos observar, no plano de fundo da Figura 26, o formulário para

obter dados do cliente. Os dados foram preenchidos e, ao clicar no botão
“Enviar”, é chamado o script “cliente_salvar.php”, que salva os dados
no arquivo e apresenta mensagem na tela, como pode ser visto no plano
intermediário. Em primeiro plano podemos ver o arquivo salvo com os
dados enviados pelo formulário.
Se você executar novamente o script “cliente_formulario.html”, ele irá

salvar os dados a partir do final do arquivo, ou seja, criando uma nova
linha a cada chamada.
Agora que você pode salvar o arquivo, você também pode recuperar
essas informações a qualquer momento. Veremos como fazer isto no
próximo tópico.
www.esab.edu.br 109
16.2 Desenvolvendo tela para apresentar dados do
cliente
Para recuperar os dados salvos no arquivo, vamos apresentá-los em um
documento que os contenha linha a linha. Como visto na unidade
15, devemos abrir o arquivo, ler seus dados e fechá-los. O Código 41
apresenta o código que executa essa função:
Código 41 – Script para recuperar os dados do arquivo e apresentar na tela

loose.dtd">
02 <html>
03 <head>
05 <title> Lista de dados de clientes. </title>
06 </head>
07 <body>
08 <?php
cliente.txt', 'r');
10 while (!feof($arquivo)){
11 echo fgets($arquivo) . '<br>';
12 }
14 ?>
15 </body>
16 </html>
O Código 41 obtém os dados do arquivo “cliente.txt”, como pode ser

visto em sua abertura na linha 9 (lembre-se de apontar para a mesma
pasta e arquivo que foi criado). A abertura foi feita no modo “r”, de
modo a ler o arquivo, apontando a leitura para o seu início. Como
podemos ler várias linhas, foi incluído o laço de repetição enquanto o
teste lógico “feof($arquivo)” for falso, na linha 10. Essa função retorna
verdadeiro quando estiver apontando para o final do arquivo, ou seja, a
cada leitura de linha, ele aponta para a linha abaixo enquanto o arquivo
não tiver chegado ao seu fim.
www.esab.edu.br 110
Na linha 11, temos a linha do texto na posição na qual se encontra o
cursor. Dessa vez, utilizando o comando “fgets” que recupera a linha
em que a leitura está posicionada e reposiciona para a linha seguinte,
apresentamos, na tela, o comando “echo” (observe que é concatenado
com “<br>” para inserir uma nova linha no HTML resultante). O
arquivo é fechado na linha 13.
O resultado da execução desse script pode ser visto na Figura 27.
Figura 27 – Leitura do arquivo e resultado na tela.

Como efetuamos a inserção de duas linhas (executamos duas vezes o

script de formulário que chamou o salvamento do arquivo), ao executar o
script ele gerou duas linhas no HTML resultante do processamento.
Até agora não vimos como manipular tais textos de modo a separar os
campos, no entanto, isto será feito mais à frente, na unidade 19.
Nesta unidade manipulamos dados de clientes, lendo-os a partir de um

formulário e salvando-os em um arquivo. Também recuperamos esses
dados e os mostramos na tela. Nas próximas unidades vamos estudar o
uso de variáveis capazes de guardar uma lista de dados – os vetores e as
matrizes.
www.esab.edu.br 111
Utilizando vetores e matrizes –
17 parte 1
Objetivo
Apresentar o uso e a manipulação de vetores (arrays) e dos comandos
de manipulação.
Na unidade 8 você pôde ver que as variáveis podem ser escalares ou

vetores, mas só estudou as variáveis escalares, que eram capazes de
armazenar somente um único valor. Nesta unidade veremos a utilização
de variáveis vetoriais unidimensionais. Seguiremos com Meloni (2000)
como base para nossos estudos. Vamos em frente?
17.1 O que são vetores e matrizes?

Segundo Meloni (2000, p. 34), “[...] variáveis escalares contêm somente
um valor por vez, enquanto vetores contêm uma lista de valores ou
outros vetores (produzindo um vetor multidimensional)”. Normalmente
chamamos de vetores quando temos somente uma dimensão (uma
lista, sem que tenhamos outra “lista dentro da lista”, gerando os vetores
multidimensionais).
A Figura 28 apresenta graficamente um exemplo de vetor e mostra como

são guardados seus valores.
$a
$a[0] $a[1] $a[2] $a[3] $a[4]

1 2 4 8 16
Figura 28 – Representação gráfica de vetor.
www.esab.edu.br 112
Na representação gráfica da Figura 28, uma variável $a (um vetor)
armazena cinco valores (1, 2, 4, 8 e 16).
Por sua vez, os vetores multidimensionais são chamados de matrizes,

principalmente quando se trata de duas dimensões. Essa definição deve
ser cuidadosa, isto porque, diferentemente de outras linguagens, nas
quais se pode definir o número de dimensões (definindo tamanho, como,
3x4 – 3 linhas e 4 colunas), na linguagem PHP temos um vetor dentro
do vetor.
A Figura 29 apresenta graficamente um vetor multidimensional (ou uma

matriz, considerando a definição).
$a $a[0][0] $a[0][0]
$a[0] 2 0
$a[1] $a[1][0] $a[1][1] $a[1][2]
$a[2] 2 0 0
$a[3] $a[2][0] $a[2][1]
$[4] 2 0
$a[3][0] $a[3][1] $a[3][2]
2 0 0
$a[4][0] $a[4][1] $a[4][2]
2 0 0
Figura 29 – Representação gráfica de uma matriz.
Na Figura 29 podemos observar que para a variável $, foram definidas

cinco posições (numeradas de 0 a 4) e, para a posição 0 foram definidas
três novas posições, ou seja, a posição 0 – da posição 0 ($a[0][0]) –
armazena, segundo essa figura, o valor 2.
www.esab.edu.br 113
Conhecendo as diferenças e tomando esse cuidado quando usamos o
termo matriz, vamos começar a usar esses tipos de variáveis?
17.2 Declarando e utilizando vetores

Para utilizar vetores, assim como as variáveis escalares, a declaração se
dá no momento no qual os utilizamos. São referenciados os espaços
da variável através de um índice numérico entre “[]” (colchetes). Para
utilizar uma variável que guarda cinco valores, por exemplo, contendo
textos com nomes de cores, podemos utilizar a atribuição de valores,
como mostra o Código 42.
Código 42 – Vetor de cinco posições contendo textos

01 $cores[0] = “vermelho”;
02 $cores[1] = “azul”;
03 $cores[2] = “amarelo”;
04 $cores[3] = “branco”;
05 $cores[4] = “preto”;
Nesse código a linha 1 cria a posição 0 da variável $cores, atribuindo

valor “vermelho”. Observe que para manipular a posição 0 da variável
$cores usamos “$cores[0]”. Da mesma forma, as demais linhas criam os
outros espaços, atribuindo os valores correspondentes.
Para obter o valor armazenado em uma posição da variável, agimos da

mesma forma, ou seja, se quiséssemos imprimir o valor armazenado
na quarta posição da variável cores, utilizaríamos a instrução “echo
$cores[5]” (lembrando que os índices se iniciam em 0).
Vale lembrar que o índice é um número inteiro, ou seja, se tivermos uma

variável inteira, podemos utilizá-la para referenciar uma posição desse
vetor, como pode ser visto no Código 43.
Código 43 – Vetor de cinco posições contendo textos

01 $i = 4;
02 echo $cores[$i];
www.esab.edu.br 114
Levando em consideração a declaração do Código 42, o Código 43
cria uma variável $i com valor 4 na linha 1 e, ao escrever a posição $i
(com valor 4), buscará o valor da quinta posição, ou seja, $cores[4], que
equivale ao valor “preto”.
Isso permite que se percorra um vetor utilizando estrutura de repetição,

como apresentado no Código 44.
Código 44 – Percorrendo um vetor utilizando for

01 for ($i=0; $i<=4; $i++){
02 echo $cores[$i] . “<br>”;
03 }
O Código 44 cria uma variável $i, inicializada com valor 0, e a repete

até que o valor de $i seja menor ou igual a 4, incrementando 1 a cada
interação. Na primeira interação será impresso o valor de $cores[0], ou
seja, “vermelho”. Na segunda interação, será impresso o valor “azul”,
equivalente à posição $cores[1]. Esse código imprimiria, com uma
quebra de linha (<br>), os valores do vetor.
Quando vimos estruturas de repetição, na unidade 12, foi citado que o

comando foreach percorria vetores.
Código 45 – Percorrendo um vetor utilizando foreach

01 foreach ($cores as &$cor) {
02 echo $cor . “<br>”;
03 }
Podemos observar no Código 45 que a variável $cores é percorrida e, a

cada interação (iniciada no primeiro elemento, repetindo até o último
elemento) atribui-se o valor referente à interação da variável cor.
Dessa forma, na primeira interação, será buscado o primeiro elemento

(posição 0) do vetor $cores, com valor definido no Código 42 como
sendo “vermelho” e atribui a variável cor. Para essa interação, qualquer
www.esab.edu.br 115
operação com a variável $cor utilizará esse valor. Ao terminar o bloco de
comandos, ele retorna ao início do laço de repetição e atribui o valor do
próximo elemento à variável $cor e, assim, repete o bloco de comandos
até o último elemento do vetor.
Observe que, dessa forma, mesmo que você não saiba quantos elementos
temos no vetor, ele percorrerá todos os elementos.
Agora que você já estudou como criar e percorrer um vetor, vamos ver
algumas operações a serem feitas com esses vetores.
17.3 Desenvolvendo operações com vetores

Você também pode utilizar a função embutida array() “[...] para
determinar manualmente valores para uma array [...]”, como apresenta
Meloni (2000, p. 282).
Para criar o vetor usando essa função, você pode atribuir a uma variável
o valor da chamada dessa função com os termos a serem inseridos. Ou
seja, podemos inserir vetor $cores com os mesmos valores do Código
44, utilizando o comando “$cores = array(“vermelho”, “azul”, “amarelo”,
“branco”, “preto”);”
Para adicionar um elemento em um vetor, você pode utilizar a função

array_push, que recebe dois ou mais parâmetros: o vetor que sofrerá
adição e os elementos que serão adicionados, quantos forem desejados.
A adição sempre ocorre no final do vetor. Para adicionar a cor “verde”
ao vetor $cores, por exemplo, poderíamos usar o comando “array_
push($cores, “verde”);”. O comando array_unshift executa a mesma
função, porém, adiciona elementos no início do vetor, alterando os
índices dos elementos existentes.
Caso queira redefinir a posição do ponteiro para a primeira posição, você

pode usar o comando “reset(vetor)”. Assim, quando usar comandos como
foreach, ele será reiniciado, apontando para seu início (primeiro elemento).
www.esab.edu.br 116
Para retirar o último elemento do vetor, você pode usar o comando
array_pop, assim como usar o comando array_shift para retirar o
primeiro elemento.
Neste momento do nosso estudo, tais comandos estão sendo apenas

citados, no entanto, estes serão abordados, nas próximas unidades,
conforme a necessidade. Assim, é importante que você saiba de sua
existência.
Estudo complementar
Nas últimas versões, os vetores representam
mapas ordenados, possibilitando o controle
através de uma chave, sem que isto interfira no
modo usado anteriormente para se fazer a gestão
das variáveis vetoriais. Você pode pesquisar mais
sobre isto no material disponível clicando aqui.
Nesta unidade observamos que, para armazenar vários valores de mesmo

tipo e uma única variável, usamos variáveis dimensionais, como vetores.
Eles são capazes de armazenar um conjunto de valores. Porém, nesta
unidade, utilizamos somente variáveis com uma dimensão; já na unidade
18, utilizaremos vetores multidimensionais.
Tarefa dissertativa
www.esab.edu.br 117
Utilizando vetores e matrizes –
18 parte 2
Objetivo
Apresentar o uso e a manipulação de matrizes (arrays) e dos
comandos de manipulação.
Na unidade 17 vimos e utilizamos variáveis que são capazes de

armazenar vários valores usando vetores unidimensionais. Nesta unidade,
abordaremos os vetores multidimensionais, utilizando Meloni (2000)
como base para nossos estudos.
18.1 Declarando e utilizando matrizes (vetores

bidirecionais)
As matrizes (vetores bidimensionais) são utilizadas quando precisamos
guardar “informações de informações”, ou seja, quando utilizamos um
vetor para guardar informações de uma posição de vetor.
Como vimos na unidade 17, os vetores multidimensionais são vetores

dentro de vetores.
A Figura 29, já apresentada na unidade 17, é novamente reproduzida

para relembrar o funcionamento a partir de uma representação gráfica.
www.esab.edu.br 118
$a $a[0][0] $a[0][0]
$a[0] 2 0
$a[1] $a[1][0] $a[1][1] $a[1][2]
$a[2] 2 0 0
$a[3] $a[2][0] $a[2][1]
$[4] 2 0
$a[3][0] $a[3][1] $a[3][2]
2 0 0
$a[4][0] $a[4][1] $a[4][2]
2 0 0
Figura 29 – Representação gráfica de uma matriz.
Nesse exemplo foi criada uma variável $a como um vetor de cinco

posições, porém, a posição $a[0] guarda outro vetor, de duas posições:
posições $a[0][0] e $a[0][1].
Para atribuir valores, assim como em vetores unidirecionais, utilizamos a

referência de sua posição: para atribuir valor 2 à posição 0 do vetor contido
na posição 0 de $a, atribuímos a posição referenciada, por “[]” (colchetes):
$a[0][0] = 2;
Com formato sinônimo ao uso de vetores dimensionais, as atribuições

utilizadas em vetores dimensionais valem para os multidimensionais.
Para percorrer todas as posições de $a, por exemplo, podemos utilizar o

comando foreach, como mostra o Código 46.
Código 46 – Percorrendo uma matriz utilizando foreach

01 foreach ($a as &$linhas_a) {
02 foreach ($linhas_a as &$elemento_a) {
03 echo $elemento_a . “<br>”;
04 }
www.esab.edu.br 119
Considerando a matriz representada na Figura 29, ao executar a primeira
linha do Código 46, na primeira interação será atribuído à variável
$linhas_a o primeiro elemento de $a, que, por sua vez, é um vetor
composto pelos valores 2 e 0 (posições $a[0][0] e $a[0][1], com valores
2 e 0 respectivamente). O comando da segunda linha percorre o vetor
$linhas_a, ou seja, para essa interação o vetor composto pelos elementos
2 e 0. Dessa forma, atribui-se o valor 2 para a variável $elemento_a
na primeira interação e imprime seu valor (concatenado com o texto
“<br>”, que fará uma quebra de linha no documento HTML). Por sua
vez, ele termina as interações do comando mais interno, ou seja, percorre
o vetor atribuído $linha_a, atribuindo o valor de $a[0][1] (segundo
elemento do vetor em questão) à variável $elemento_a.
Ao terminar de percorrer esse vetor, o fluxo retorna ao primeiro laço de

repetição, o qual atribui à variável $linha_a a segunda posição do vetor
$a, que, por usa vez, é outro vetor com três posições e elementos com
valor 2, 0 e 0, respectivamente.
Dessa forma, o comando irá repetir quantos elementos existirem na

variável $a, percorrendo todas as linhas e todas as colunas (ou todo o
vetor e todo o vetor contido dentro do primeiro vetor).
Após estudarmos como criar e percorrer matrizes, vamos desenvolver

operações com elas?
18.2 Desenvolvendo operações com matrizes

Da mesma forma que a atribuição de valores, todas as operações
referentes a vetores unidimensionais valem para os multidimensionais.
Para criar um vetor multidimensional utilizando a instrução array

podemos usar:
www.esab.edu.br 120
Código 47 – Percorrendo uma matriz utilizando foreach
01 $a = array(
02 array(2,0),
03 array(2,0, 0),
04 array(2,0),
05 array(2,0, 0),
06 array(2,0, 0),
07 );
O Código 47 apresenta a criação da matriz representada na Figura 29.

A instrução contida nesse código poderia estar contida em somente uma
linha, terminando com o símbolo “;”, mas, para facilitar o entendimento,
essa instrução foi dividida. Na linha 1 é criada a variável $a como sendo
um vetor. Como ele recebe cinco parâmetros (cada linha, entre 2 e 6,
equivale a um parâmetro da instrução array contida na linha 1), cria-se
um vetor de cinco posições. Porém, o primeiro parâmetro equivalente à
posição $a[0] cria um vetor dentro dessa posição. Esse novo vetor tem
duas posições com valores 2 e 0, respectivamente. Dessa forma, a posição
$a[0][0] recebe valor 2 e a posição $a[0][1] recebe valor 1. O segundo
parâmetro (que consta na linha 3 e equivale à segunda posição de $a) cria
um novo vetor com três posições com valores 2,0 e 0, respectivamente. A
explicação se repete para as linhas 4, 5 e 6.
Para explicar melhor, vamos utilizar um exemplo: imagine que você

precisa armazenar as notas de 15 alunos. Assim, teremos um vetor de
15 posições, no qual cada posição armazenará as notas de cada aluno.
Por sua vez, cada aluno pode ter até três notas armazenadas em um
vetor (ou seja, um vetor com as notas dentro de uma posição do vetor
de alunos – temos um vetor dentro de um vetor, o que equivale ao vetor
multidimensional).
Vamos considerar que o primeiro aluno teve notas 7, 8 e 7. Para

armazenar as notas dos alunos, poderíamos utilizar três atribuições.
www.esab.edu.br 121
Código 48 – Atribuindo valores à matriz de notas
01 $nota[0][0] = 7;
02 $nota[0][1] = 8;
03 $nota[0][2] = 7;
04 $nota[1][0] = 6;
05 $nota[1][1] = 7;
06 $nota[1][2] = 8;
No Código 48 observamos que, na linha 1, é atribuído 7 à posição [0]

[0] da matriz $nota, o que equivale à primeira nota do primeiro aluno.
A segunda linha atribui valor à segunda nota do primeiro aluno, ou seja,
a $nota[0][1]. Observe que o primeiro índice, nesse caso, representa
o aluno, enquanto o segundo índice diz respeito à nota desse aluno,
formando uma matriz.
Poderíamos atribuir esses mesmos valores usando o comando array(),

como é visto no Código 49.
Código 49 – Atribuindo valores à matriz de notas

01 $nota = array(
02 array(7, 8 7),
03 array(6,7,8)
04 );
Os Códigos 48 e 49 executam exatamente as mesmas atribuições, apenas

utilizando formatos diferentes. Caso tenhamos a necessidade de mostrar
na tela essas notas, poderíamos percorrer a matriz obtendo as notas,
utilizando o comando foreach, como mostrado no Código 46.
Nesta unidade você observou o uso de variáveis multidimensionais

(matrizes) e viu como criar e atribuir valores. Vale lembrar que as
operações vistas na unidade 17, para vetores unidirecionais, são válidas
para os vetores multidimensionais. Na próxima unidade, vamos
manipular textos (strings).
www.esab.edu.br 122
Atividade
www.esab.edu.br 123
Resumo
Na unidade 13 demos continuidade aos assuntos relacionados a laços de

repetição, que são utilizados quando precisamos repetir um comando ou
um bloco de comandos. Vimos também as diferenças entre as instruções de
repetição “while” e “do..while” e pudemos praticar, mostrando 20 termos
de uma sequência de números (Fibonacci) e repetindo a sua execução.
Na unidade 14 desenvolvemos aplicativos web, utilizando os conceitos

aprendidos nas outras unidades. Descrevemos um aplicativo que contém
um formulário que chama um script PHP, processando o pedido de
bebida, utilizando os valores passados pelos formulários e efetuando
testes lógicos e estruturas de repetição.
Na unidade 15 vimos os comandos para abrir, gravar, ler e fechar arquivos,

com o objetivo de armazenar e recuperar dados. Já na unidade 16,
aplicamos esses comandos, de forma prática, salvando arquivos a partir
de um formulário e apresentando seus dados. Esses comandos são fopen,
fwrite, fread e fclose, respectivamente. Os conhecimentos vistos na unidade
16 foram exercitados, salvando dados de um formulário e aplicando-os.
Para armazenar vários valores de mesmo tipo e uma única variável usamos
variáveis dimensionais, como vetores. Eles são capazes de armazenar um
conjunto de valores e seus usos foram vistos na unidade 17.
Na unidade 18 vimos as variáveis multidimensionais (em mais de uma

direção), como as matrizes, que podem guardar vários dados.
www.esab.edu.br 124
19 Manipulando strings
Objetivo
Apresentar comandos para manipulação de strings, formatando,
unindo e dividindo, comparando, localizando e substituindo.
Nas unidades anteriores utilizamos variáveis escalares de diversos tipos e

vetores. Nesta unidade veremos como manipular o tipo string por meio
de funções específicas da PHP, de modo a ser capaz de formatar, unir
duas ou mais variáveis, comparar, localizar e encontrar partes do texto
e substituir a parte encontrada por outro texto. Para isto, utilizaremos
como base teórica Thomson e Welling (2005). A partir de agora, quando
você localizar um código inserido no texto, não encontrará a frase “salve
(..)” ou “execute”, ficando implícito que você deve salvá-lo e executá-lo.
Vamos lá?
19.1 Formatação de strings

Variáveis strings são capazes de armazenar quaisquer valores
alfanuméricos, incluindo letras, números e caracteres especiais (“#”,
por exemplo). Você frequentemente terá que manipular essas variáveis,
efetuando operações com elas de modo a possibilitar a sua utilização.
A função strlen() obtém a quantidade de caracteres de uma

string retornando um número inteiro. Por exemplo, a instrução
“strlen(“teste”);” retornaria valor 5.
A função substr() recupera parte de uma string, obtendo os caracteres a

partir de uma posição definida por um número de caracteres. Por exemplo,
“substr(‘frase longa’, 2, 5);” recupera cinco posições a partir da posição 2,
ou seja, “ase l” (lembre-se de que uma string começa na posição 0).
www.esab.edu.br 125
Para eliminar excesso de espaços (no início e/ou no final de uma variável
string), você pode usar as funções trim(), ltrim() e rtrim(). De acordo com
Thomson e Welling (2005, p. 110), os caracteres que essas funções eliminam
“[...] por padrão são nova linha e retorno do carro (\n e \r), tabulações
horizontais (\t e \x0B), caracteres de final de linha (\0) e espaços”.
A função ltrim() remove os espaços em branco do início de uma string.

Por sua vez, a função rtrim() elimina o excesso de espaços do final de
uma string, enquanto a função trim() “[...] remove os espaços em branco
do início e do final de uma string” (THOMSON; WELLING, 2005, p.
110). As funções recebem um parâmetro (a string original) e retornam
uma string com os valores sem os espaços. Sua sintaxe pode ser vista
através do exemplo “$novaString = trim($string);”.
Caso a variável $string armazenasse o valor ‘ teste de retirada dos

espaços. ’, a função retornaria e, consequentemente, atribuiria valor
‘teste de retirada dos espaços.’ à variável $novaString. Observe que os
espaços em branco no início (logo após o “‘” e anterior ao “’”) foram
eliminados nesse exemplo.
A função n12br() também recebe uma string como parâmetro e retorna

uma string, substituindo todas as novas linhas pela tag XHTML <br
/> (ou pela tag HTML <br> para as versões anteriores a 4.0.5). Seu
uso é tido como útil quando precisamos apresentar uma string longa
(com quebras de linha) no navegador. Seu uso é frequente, portanto,
combinando com a função ‘echo’, como ‘echo n12br($stringLonga);’.
Para formatar uma string para armazenamento (seja esse armazenamento

em banco de dados, seja em arquivo-texto, como vimos nas unidades
anteriores), podemos ter a necessidade de reformatar uma string
visualmente, isto porque certos caracteres são válidos em uma string,
mas podem causar problemas quando inseridos em banco de dados,
por exemplo. Caracteres problemáticos são aspas (simples e duplas),
barra invertida e o caractere NULL. Para escapar deles, utilize uma
barra invertida, ou seja, para utilizar “ (aspas duplas), aplique \“ (barra
invertida + aspas). Para usar uma barra invertida, utilize \\ (assim, ele
grafará uma barra). Para colocar a barra invertida antes de caracteres
especiais de uma string, podemos usar a função AddSlashes(). Para retirar
a barra, podemos utilizar a função StripSlashes().
www.esab.edu.br 126
A função AddSlashes() recebe uma string e retorna uma string
reformatada, aplicando a barra invertida quando necessário. Uma string
“$string = ‘Minha string tem “ uma aspas’;”, ao ser reformatada, por
exemplo, com “$stringReformatada = AddSlashes($string);”, atribuiria
‘Minha string tem \“ uma aspas’ à variável $stringReformatada.
Por sua vez, a função StripSlashes(), que também recebe uma string e
retorna uma string reformatada, remove as barras.
Além da necessidade de formatar, podemos ter a necessidade de dividir

uma string para examinar as suas partes, ou mesmo para obter os
componentes de uma frase ou de uma expressão (como os componentes
de um e-mail). A função explode() recebe uma string que contém um
separador (o que delimita a separação) e uma string com o texto a ser
dividido, podendo estabelecer um limite (através de um parâmetro
inteiro numérico). Por exemplo, para atribuir um vetor com as partes
de um e-mail, pode-se utilizar “$vetor = explode(‘@’, $email);”. Caso a
variável e-mail tenha valor ‘exemplo@php.net’, seria atribuído à variável
$vetor um vetor unidirecional com dois elementos, sendo $vetor[0] =
‘exemplo’ e $vetor[1] = ‘php.net’.
Na unidade 16 constava o Código 41, que recupera dados de cliente

em um arquivo-texto, apresentando os dados de uma linha de forma
concatenada, utilizando “#” como separador. Vamos recuperar a imagem
previamente apresentada por meio da Figura 30.
Figura 30 – Leitura do arquivo e e exibição na tela.

A Figura 30 apresenta a recuperação de duas linhas de um arquivo,

no qual os dados estão concatenados e separados por “#”. Se, em vez
de simplesmente mostramos na tela, utilizássemos a função explode,
www.esab.edu.br 127
poderíamos tratar melhor os dados e apresentá-los melhor na tela,
conforme apresentado no Código 50 (com base no Código 41).
Código 50 – Script para recuperar os dados do arquivo, apresentando-os, formatados, na tela

loose.dtd">
02 <html>
03 <head>
06 </head>
07 <body>
08 <?php
09 $arquivo = fopen('C:\\wamp\\www\\
unidade19\\cliente.txt', 'r');
10 echo '<table>';
12 $cliente = explode('#', fgets($arquivo));
13 echo '<tr>';
14 foreach ($cliente as &$valor){
15 echo '<td style="border:1px solid black">'.
$valor. '</td>';
16 }
17 echo '</tr>';
18 }
20 ?>
21 </body>
22 </html>
Comparando com o Código 41, no Código 50 foi incluída a linha 10,

que adiciona uma tabela, e, na linha 12, é atribuído o valor da linha,
já dividido com o separador “#” a um vetor $cliente (substituindo o
comando “echo (fgets($arquivo))”, que apresentava o valor na tela, sem
formatação). Na linha 13 é criada uma linha da tabela e as linhas 14 e
15 percorrem o vetor $cliente, criando uma coluna com o valor para
cada posição do vetor (ou seja, do valor da linha “explodido”). O estilo
de formatação foi criado apresentando bordas apenas para facilitar a
observação. A linha 17 fecha a tag que insere a linha da tabela. Observe
que, para cada linha do arquivo, será criada uma linha dessa tabela. Dessa
forma, podemos apresentar os dados com melhor formatação, como
pode ser visto na Figura 31.
www.esab.edu.br 128
Figura 31 – Leitura e apresentação do arquivo na tela, formatando os dados em uma tabela.
Com a Figura 31 você pode facilmente observar a formatação dos dados

utilizando uma tabela.
Da mesma forma que precisamos dividir uma string (atribuindo-a em

um vetor), podemos precisar uni-la. Para isso, utilizamos as funções
implode() e join(), que são idênticas. Se usarmos a instrução “$email
= join(‘@’, $vetor);”, juntaremos os elementos do vetor. Por exemplo,
utilizando a função join passando @ e um vetor com cinco valores (0, 1,
5, 2 e 3), resultaria “0@1@5@2@3”.
Na próxima seção veremos como comparar as duas strings que estamos

manipulando.
19.2 Comparação entre strings

As comparações, até o momento, foram feitas utilizando-se ==,
independentemente do tipo de variável que estamos comparando.
A função strcmp() compara duas strings, retornando 0 caso as

duas strings sejam iguais. Sua sintaxe é “$int = strcmp(<variavel1>,
<variavel2>);”. A função retornará um número maior que zero se
<variavel1> for maior (vier depois, caso fosse feita uma ordenação
alfabética) que <variavel2>. Caso <variavel2> for maior que <variavel1>,
retornaria um valor menor que zero.
www.esab.edu.br 129
Além de comparação, essa função pode ser utilizada para ordenação de
variáveis. A função strcasecmp() é idêntica, exceto por não diferenciar
maiúsculas e minúsculas.
Agora que vimos algumas funções para manipular strings, na próxima

seção vamos utilizar funções para encontrar partes de uma string em
outra string mais longa.
19.3 Localizando partes de uma string em outra

Para encontrar uma string dentro de outra (maior, mais longa) na
linguagem PHP, você pode utilizar as funções strstr(), strchr(), strrchr() e
stristr(). Caso você tenha um texto longo e queira encontrar uma palavra
(ou uma letra), a sintaxe da função strstr() é:
“<variavel de retorno> = strstr(<string longa>, <string a ser procurada>);”

em que o retorno da função será, caso encontre a <string a ser
procurada>, o texto da <string longa> a partir da primeira ocorrência em
que foi encontrada, como no exemplo do Código 51.
Código 51 – Script para localizar parte de uma string em outra mais longa
loose.dtd">
02 <html>
03 <body>
04 <?php
05 $palheiro = 'Texto longo a ser procurado,
ser encontrado’;
06 $agulha = 'ser';
07 echo strstr($palheiro, $agulha);
08 ?>
09 </body>
10 </html>
Observe a linha 10 do Código 51, na qual é procurada a string “ser” em

uma string mais longa (“Texto longo a ser procurado, longo”). O retorno
da execução desse código é a apresentação, na tela, do texto “longo a ser
procurado, ser encontrado”, ou seja, a partir da primeira ocorrência da
palavra procurada “ser”.
www.esab.edu.br 130
Caso não encontre nenhuma ocorrência, retornará o texto “false”.
A função strchr() funciona da mesma forma e com as mesmas
características da strstr(). As variantes da função strstr() são: stristr(), que
não faz distinção entre maiúsculas e minúsculas; e a função strrch(), que
retorna o texto a partir da última ocorrência da string procurada (caso
seja aplicada no Código 51, trocando a função strstr() por strrch(), o
retorno seria “ser”).
Caso você precise apenas saber a posição, utilizamos a função strpos(),

que retorna a posição da primeira ocorrência, e a função strrpos(), que
retorna a posição da última ocorrência. A função strpos() tem como
terceiro parâmetro, que é opcional, um índice que indica a posição na
qual deve ser iniciada a busca. Caso você queira procurar a segunda
ocorrência de uma string, por exemplo, deve começar no ponto logo
após a ocorrência da primeira, como pode ser visto no Código 52.
Código 52 – Script para localizar parte de uma string em outra mais longa
loose.dtd">
02 <html>
03 <body>
04 <?php
05 $palheiro = 'Texto longo a ser procurado,
ser encontrado';
06 $agulha = 'ser';
07 $achou = true;
08 $intInicio = 0;
09 while ($achou == true) {
10 $achou = strpos($palheiro, $agulha,
$intInicio);
11 if ($achou != false) {
12 echo 'Encontrou na posição '. $achou .
'<br>';
13 $intInicio = $achou + strlen($agulha);
14 $achou = true;
15 }
16 }
17 ?>
18 </body>
19 </html>
www.esab.edu.br 131
O Código 52 apresenta código que procura várias ocorrências da
palavra ‘ser’ em uma string com valor ‘Texto longo a ser procurado,
ser’, armazenada na palavra $palheiro. A primeira interação procura a
palavra iniciando a busca na primeira posição (controlada pela variável
$intInicio, inicializada na linha 8 com o valor 0). O presente código
procura até achar alguma ocorrência, controlado pela variável $achou.
Na linha 10 é armazenado o número inteiro da posição encontrada ou o
valor false, caso não encontre. Caso encontre (teste diferente de false, ou
seja, um número) apresenta, na tela a literal, ‘Encontrou na posição ’ e a
posição que encontrou (armazenada na variável $achou). Na linha 13, ele
soma o tamanho da palavra ‘ser’ ao valor de início, para que a próxima
busca seja iniciada na posição que termina a ocorrência encontrada e
altera novamente a variável de controle, de modo a executar de novo.
Desse modo, você pode localizar uma ou mais ocorrências de uma string
dentro de outra. Mas, e se você precisar substituir uma parte de string?
Vamos ao próximo tópico e veremos como fazer isso.
19.3 Substituindo partes de uma string em outra

Para substituir parte de uma string, podemos utilizar a função str_
replace(). O comando “$strSubstituida = str_replace(‘ser’, ‘estar’,
$palheiro);”, com os valores apresentados no Código 52, armazenaria a
literal “Texto comprido a estar procurado, estar encontrado”. Observe
que ele trocou todas as ocorrências nas quais aparecia a string “ser” pela
string “estar”.
Vimos, nesta unidade, como manipular strings. Vamos colocar em

prática? Na unidade 20 faremos um exemplo prático.
www.esab.edu.br 132
Fórum
www.esab.edu.br 133
Desenvolvendo aplicativo,
20 manipulando strings
Objetivo
Desenvolver pequena aplicação, comparando, localizando e
substituindo partes de uma string.
Na unidade 19 utilizamos algumas funções para manipular o tipo string, de

modo a ser capaz de formatar, unir variáveis, comparar, localizar e encontrar
partes do texto e substituir a parte encontrada por outro texto. Nesta
unidade utilizaremos Meloni (2000) e Thomson e Welling (2005) para
consultar as funções. Vamos fixar os conceitos através de exemplo prático?
20.1 Formatando o CEP

Para começarmos o nosso trabalho, vamos recuperar o Código 39, da
unidade 16, que contém um formulário para a obtenção de dados de um
cliente para compra de bebida, incluindo um campo para salvarmos o
endereço do cliente.
O Código 53 apresenta, então, o formulário que obtém as informações

do cliente e as envia (submete) a um script PHP, que processará e
salvará no arquivo, efetuando as formatações e os testes de validação
necessários. Novamente, o uso dos componentes está seguindo instruções
encontradas em Meloni (2000).

Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
02 <html>
03 <head>
04 <meta http-equiv="Content-Type" content="text/html;
charset=ISO-8859-1">
05 <title> Formulário de compra de bebidas. </title>
06 </head>
07 <body>
www.esab.edu.br 134
08 <form action="cliente_salvar.php" method="POST"
id=form_bebida>
09 <table border=0>
10 <tr>
11 <td> Nome: </td>
12 <td> <INPUT type="text" name=nome size=50
id=quantidade> </td>
13 </tr>
14 <tr>
16 <td> <INPUT type="text" name=idade size=4> </td>
17 </tr>
18 <tr>
19 <td> Sexo:</td>
21 <OPTION value="1"> Masculino </OPTION>
22 <OPTION value="2"> Feminino </OPTION>
23 </SELECT>
24 </td>
25 </tr>
26 <tr>
28 <td> <INPUT type="text" name=email size=30> </td>
29 </tr>
30 <tr>
31 <td> Endereço completo: </td>
32 <td> <INPUT type="text" name=endereco size=60> </
td>
33 </tr>
34 <tr>
35 <td> Cidade: </td>
36 <td> <INPUT type="text" name=cidade size=30> </td>
37 </tr>
38 <tr>
39 <td> CEP: </td>
40 <td> <INPUT type="text" name=cep size=8> </td>
41 </tr>
42 <tr>
43 <td> Telefone: </td>
44 <td> <INPUT type="text" name=telefone size=20> </
td>
45 </tr>
46 </table>
48 </form>
49 </body>
50 </html>
www.esab.edu.br 135
Foram adicionadas as linhas 30 a 41 para salvar o endereço, a cidade e o
CEP. Vamos alterar o Código 40 de modo a formatar o CEP. Lembre que
o CEP tem oito números e deve ser colocado um hífen na sexta posição.
Dessa forma, iremos obter cinco posições do CEP, concatenar um hífen

e chegar às três últimas posições. O Código 54 apresenta a alteração
necessária para salvar o CEP, formatando:
Código 54 – Script que recupera as informações enviadas e formata o CEP

01 <?php
05 $sexo = ($_POST["sexo"] ==1) ?
06 $endereco = $_POST["endereco"];
07 $cidade = $_POST["cidade"];
08 $telefone = $_POST["telefone"];
09 $cep = $_POST["cep"];
10 $cepFormatado = substr($cep, 0, 5) . '-' .
substr($cep, 5, 3);
11 echo $cepFormatado;
12 ?>
No Código 54 a linha 8 obtém o valor enviado, pelo método post, do input

“cep”. Para obter parte do valor da variável $cep, utilizaremos a função
substr(), conforme instruções de Thomson e Welling (2005). Dessa forma,
na linha 9, tem-se os cinco primeiros caracteres, concatena-se um caractere
“-“ e obtém-se os três caracteres a partir da sexta posição, apresentando, na
tela, o CEP formatado, como pode ser visto na Figura 32.
www.esab.edu.br 136
Figura 32 – Formulário para inserção de dados e resultado, apresentando CEP formatado.
A Figura 32 apresenta, ao fundo, o formulário para inserção dos dados

do cliente e, mais à frente, o CEP formatado com o processamento do
script do Código 54.
Agora que obtivemos e formatamos o CEP, vamos fazer operações com o

endereço, localizando parte do texto.
20.2 Localizando parte do endereço

Imagine que você “receba” dados do endereço enviado pelo método post,
contendo o endereço completo, mas precise somente do nome da rua, ou
seja, dos dados contidos até a primeira ocorrência de vírgula.
Para isto, vamos obter a posição da primeira ocorrência da vírgula usando

a função strpos() e, para copiar em outra variável o valor entre a primeira
posição e a posição encontrada, usaremos a função substr(), conforme
instrução de Thomson e Welling (2005). Observe o Código 55.
www.esab.edu.br 137
Código 55 – Script que recupera as informações enviadas e formata o logradouro
01 <?php
05 $sexo = ($_POST["sexo"] ==1) ?
substr($cep, 5, 3);
12 $pos = strpos($endereco, ',');
13 if ($pos != false) {
14 $logradouro = substr($endereco, 0, $pos);
15 } else {
16 $logradouro = $endereco;
17 }
18 echo ‘<br>’. $logradouro;
19 ?>
No Código 55 a linha 11 obtém a posição na qual se encontra a primeira

ocorrência da vírgula da variável $endereco, armazenando o resultado
na variável $pos. Caso encontre uma vírgula (teste da linha 12), será
executada a linha 13, obtendo parte do texto, iniciando a primeira posição
pelo número de posições que encontrou a primeira vírgula (armazenada
na variável $pos). Caso não encontre, obtém o texto todo da variável
$endereco. Em qualquer caso, apresenta o valor do logradouro.
Dessa forma, o nosso código que formata o CEP e obtém o logradouro

do endereço está pronto! Vamos ao próximo tópico, substituindo valores?
www.esab.edu.br 138
20.3 Substituindo parte do endereço
Caso o $endereco retorne um endereço com parte da string ‘Rua’ e você
queira formatar, substituindo por ‘R.’, usaremos a função str_replace(),
conforme Thomson e Welling (2005). O Código 56 apresenta a solução.
Código 56 – Script que recupera as informações enviadas e formata o logradouro

01 <?php
05 $sexo = ($_POST["sexo"] ==1) ?
substr($cep, 5, 3);
12 $pos = strpos($endereco, ',');
13 if ($pos != false) {
14 $logradouro = substr($endereco, 0, $pos);
15 } else {
16 $logradouro = $endereco;
17 }
18 echo ‘<br>’. $logradouro;
19 $logradouroNovo = str_replace('Rua', 'R.',
$logradouro);
20 echo $logradouroNovo
21 ?>
No Código 56 foram inseridas as linhas 18 e 19, quando comparado ao

Código 55. A linha 18 obtém o logradouro, trocando a literal ‘Rua’ por
‘R.’, armazenando na variável $logradouroNovo, na linha 19.
Nesta unidade manipulamos dados de clientes, lendo-os a partir de

um formulário que formata, localiza e copia parte do endereço e
substitui parte desse logradouro. Também recuperamos esses dados e
os mostramos na tela. Nas próximas unidades estudaremos o uso de
expressões regulares.
www.esab.edu.br 139
Manipulando expressões regulares
21 – parte 1
Objetivo
Apresentar o uso e expressões regulares, definindo expressões e os
seus conjuntos de caracteres e subexpressões.
Nas unidades anteriores manipulamos o tipo string efetuando várias

operações. Nesta unidade veremos o uso de expressões regulares,
utilizando Thomson e Welling (2005) para dar suporte a nosso trabalho.
Vamos lá?
21.1 O que são expressões regulares?

Expressão regular é “[...] uma maneira de descrever um padrão em uma
parte do texto. As correspondências exatas (ou literais) [...] são uma
forma de expressão regular.” (THOMSON; WELLING, 2005, p. 89).
As expressões regulares permitem indicar um metassignificado, podendo,

por exemplo, estabelecer um padrão que deve ocorrer no início e no fim de
uma string, qual parte deve ser repetida ou quais caracteres em um padrão
devem ser de um tipo particular. Para o CEP de um endereço observamos
que o padrão são cinco caracteres numéricos, um hífen e três caracteres
numéricos. Podemos dizer que temos uma expressão regular com esse
padrão. Pode-se utilizar ocorrências literais de caracteres especiais.
A linguagem PHP aceita expressões regulares compatíveis com Pearl

(PCRE – expressões regulares compatíveis com Pearl, em tradução livre)
e o tipo compilado pela PHP, chamado de POSIX. Vamos focar no
estudo das expressões POSIX no próximo tópico.
www.esab.edu.br 140
21.2 Definindo expressões e seus conjuntos de
caracteres e subexpressões
Para definir uma expressão regular podemos utilizar conjuntos de
caracteres, determinando, dessa forma, um padrão. Encontramos, por
exemplo, junto às palavras cat, nat e mat, um padrão, definido por uma
letra e o radical “at”.
Para criar esse conjunto de caracteres ao qual um elemento deve

pertencer, utilizamos qualquer coisa (caracteres alfabéticos, numéricos
ou especiais que representem o elemento) incluída em colchetes, ou
seja, “[“ e “]”. Por exemplo, para definir um conjunto de caracteres para
a primeira posição de uma expressão, podemos usar “[a-z]at”. Dessa
forma, essa expressão identifica strings cat, sat, mat, entre outras (ou
seja, qualquer caractere que seja uma letra válida, definindo um intervalo
entre a e z – não numérico ou caracteres especiais), não identificando 0at
ou #at.
Quando usamos a barra invertida (“\”), significa que se trata de um

literal, ou seja, exatamente esse caractere.
Para definirmos um ou outro, podemos usar [um|outro], ou seja,

separado com pipe (|).
Quando um caractere não pode fazer parte de um conjunto, usamos ^

(representando “não”), por exemplo, [^a-z]. Alguns operadores podem
ser usados, como o operador “^”, que indica que a expressão deve se
iniciar com a string dada, e o operador “$”, que define que a expressão
deve ser finalizada.
A linguagem PHP apresenta conjunto de caracteres definidos, como

pode ser observado na Tabela 4.
www.esab.edu.br 141
Tabela 4 – Classe de caracteres para utilização nas expressões regulares no estilo POSIX.
Classe POSIX Intervalo Localiza
[:upper:] [A-Z] Letras maiúsculas.
[:lower:] [a-z] Letras minúsculas.
[:alpha:] [A-Za-z] Letras maiúsculas e minúsculas, caracteres alfabéticos.
[:alnum:] [A-Za-z0-9] Letras e números, caracteres alfanuméricos.
[:digit:] [0-9] Números, dígitos decimais.
[:xdigit:] [0-9A-Fa-f] Números, dígitos hexadecimais.
[:punct:] [.,!?:...] Sinais de pontuação.
[:blank:] [ \t] Espaço e TAB (guias).
[:space:] [ \t\n\r\f\v] Caracteres de espaço em branco.
[:cntrl:] - Caracteres de controle.
[:graph:] [^ \t\n\r\f\v] Caracteres imprimíveis.
[:print:] [^\t\n\r\f\v] Imprimíveis e o espaço.
Fonte: Adaptada de Thomson e Welling (2005).
A Tabela 4 apresenta classes de caracteres, de modo a facilitar a definição

de expressões regulares, não demandando, dessa forma, que se defina
todos os caracteres, um a um.
Da mesma forma que você pode definir um tipo e quantas vezes esse tipo
se repete, através de alguns símbolos ou chaves “{“ e “}”; o símbolo “?”
significa zero ou um (uma ou nenhuma ocorrência); o asterisco (“*”)
representa zero, um ou mais; o símbolo “+” representa um ou mais, ou
seja, no mínimo um. Quando usamos chaves, determinamos número
exato, mínimo ou máximo, em que {x} é o número exato de vezes e
{n,m} representa que podemos ter de n até m ocorrências.
Podemos dizer que o CEP deve iniciar com cinco caracteres numéricos,
ter um hífen e terminar com três caracteres numéricos, não aceitando
outros caracteres e podendo ser definido por: “^[0-9]{5}-[0-9]{3}$”.
Nessa expressão, determinamos que números (determinados por [0-9])
são repetidos cinco vezes (determinado por [5]), um hífen, e mais três
números ([0-9]{3}), e não aceita nenhum outro caractere ao final.
www.esab.edu.br 142
Thomson e Welling (2005) apresentam como aplicações possíveis a
busca pela ocorrência de palavras em algum texto – procurando em
uma variável string a ocorrência dos padrões especificados em uma
expressão (por exemplo, em um e-mail de cliente, obter ocorrência de
palavras chaves para encaminhar o e-mail, com palavras como “compra”,
“serviço ao cliente” ou “troca”, ou seja, da expressão “compra| serviço ao
cliente|troca”); e para validação do e-mail.
A Tabela 5 apresenta exemplos de operadores comuns das expressões

regulares:
Tabela 5 – Operadores comuns usados para definir expressões regulares.

Operador Propósito
. (ponto) Corresponder a qualquer caractere único
^ (circunflexo) Corresponder à string vazia que ocorre no início de uma linha ou string
$ (símbolo do
Corresponder à string vazia que ocorre no final de uma linha
dólar)
A Corresponder a uma letra maiúscula A
a Corresponder a uma letra minúscula a
\d Corresponder a qualquer dígito único
\D Corresponder a qualquer caractere não dígito
\w Corresponder a qualquer caractere alfanumérico; um sinônimo é [:alnum:]
[A-E] Corresponder a qualquer letra maiúscula A, B, C, D ou E
[^A-E] Corresponder a qualquer caractere, exceto à letra maiúscula A, B, C, D ou E
X? Corresponder a nenhuma ou a uma letra maiúscula X
X* Corresponder a zero ou mais letras maiúsculas X
X+ Corresponder a uma ou mais letras maiúsculas X
X{n} Corresponder exatamente a n letras maiúsculas X
Corresponder a pelo menos n e não mais do que m letras maiúsculas X; se
X{n,m}
você omitir m, a expressão tenta corresponder pelo menos nX
Corresponder uma sequência de pelo menos um abc e def; abc e def
(abc|def)+
corresponderiam
Fonte: <http://www.ibm.com/developerworks/br/library/os-php-regex1/>.
A Tabela 5 apresenta operadores e sua aplicação para a definição

de expressões regulares. Para isso, você deve combinar o uso desses
operadores, de modo a definir expressões.
www.esab.edu.br 143
A Tabela 6 apresenta exemplos de expressões regulares e de sua aplicação.
Tabela 6 – Exemplos de expressões regulares.

Tipo Expressão regular Exemplo
Data (dd/mm/
^([0-9]|[0,1,2][0-9]|3[0,1])/([\d]|1[0,1,2])/\d{4}$ 21/12/2007
aaaa)
Numero Decimal ^\d*[0-9](\.\d*[0-9])?$ 234.342
Arquivos world-domination.
^[a-zA-Z0-9-_\.]+\.(pdf|txt|doc|csv)$
Documentos pdf
^([0-9a-zA-Z]+([_.-]?[0-9a-zA-Z]+)*@[0-9a-zA-
E-mail info@lymas.com.br
Z]+[0-9,a-z,A-Z,.,-]*(.){1}[a-zA-Z]{2,4})+$
Codigo Cor HTML ^#?([a-f]|[A-F]|[0-9]){3}(([a-f]|[A-F]|[0-9]){3})?$ #00ccff
Arquivo de new-pic_company.
^[a-zA-Z0-9-_\.]+\.(jpg|gif|png)$
Imagem jpg
^((25[0-5]|2[0-4][0-9]|1[0-9]{2}|[0-9]{1,2})\.){3}
Endereco IP 192.168.0.1
(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[0-9]{1,2})$
Arquivos ^[a-zA-Z0-9-_\.]+\. company-
Multimedia (swf|mov|wma|mpg|mp3|wav)$ presentation.swf
Data Formato
^\d{4}-(0[0-9]|1[0,1,2])-([0,1,2][0-9]|3[0,1])$ 2005-09-02
Mysql
Telefone (BR) ^$?\d{2}$?[\s-]?\d{4}-?\d{4}$ (11) 5555-1977
Codigo Postal
^([A-Z][0-9]){3}$ V2B2S3
(EUA)
Hora (HH:MM) ^([0-1][0-9]|[2][0-3])(:([0-5][0-9])){1,2}$ 12:29
^(http[s]?://|ftp://)?(www\.)?[a-zA-Z0-9-\.]+\. http://www.
URL
(com|org|net|mil|edu|ca|co.uk|com.au|gov|br)$ google.com
Telefone ^(([0-9]{1})*[- .(]*([0-9a-zA-Z]{3})*[-
1.245.532.3422
Internacional .)]*[0-9a-zA-Z]{3}[- .]*[0-9a-zA-Z]{4})+$
Fonte: <http://www.marciobrasil.net.br/expressao-regular/exemplos-de-expressoes-regulares-regex-ou-er.html>.
A Tabela 6 apresenta exemplos, mas você pode criar e utilizar diversos

padrões de conjunto de caracteres para definir expressões regulares que
se encaixem ao seu uso. Assim, é possível usar a sua criatividade e definir
conjuntos conforme a sua necessidade.
Vimos, nesta unidade, os principais conceitos de expressões regulares

e como as definimos. Na unidade 22 vamos utilizar as expressões
regulares, que aprendemos a definir nesta unidade, localizando padrões,
comparando com um texto e utilizando essa comparação para validações.
www.esab.edu.br 144
Manipulando expressões regulares
22 – parte 2
Objetivo
Apresentar o uso e expressões regulares, localizando, substituindo e
aplicando para validações.
Na unidade 21 você viu como definir expressões regulares, que são

padrões de partes de textos que podem ser comparadas, localizadas,
substituídas. Nesta unidade você poderá fazer essas operações, utilizando
as expressões definidas anteriormente. O texto de Thomson e Welling
(2005) servirá como embasamento.
22.1 Localizando, substituindo e aplicando

expressões regulares
Neste tópico vamos aplicar as expressões regulares para localização e
substituição de strings, de forma a encontrar padrões de texto. “Localizar
substrings é a principal aplicação das expressões regulares [...]. As duas
funções disponíveis são ereg() e eregi().” (THOMSON; WELLING,
2005, p. 94).
A função ereg() pesquisa uma string, procurando correspondência com

a expressão regular. Retorna TRUE se o padrão (expressão regular) for
encontrado na string pesquisada e FALSE, caso contrário. A função
eregi() é idêntica à função ereg(), exceto por não distinguir maiúsculas e
minúsculas.
O Código 57 apresenta a pesquisa de um padrão para validar CEP.
www.esab.edu.br 145
Código 57 – Script para validação de CEP
loose.dtd">
02 <html>
03 <head>
05 <title> Validação de e-mail. </title>
06 </head>
07 <body>
08 <?php
09 $cep = "88034-000";
10 $padraoCEP = "^[0-9]{5}-[0-9]{3}$";
11 $avaliaCep = ereg($padraoCEP, $cep);
12 if(!$avaliaCep) {
13 echo "CEP nao Valido";
14 }
15 else
16 {
17 echo "CEP Valido";
18 }
19 ?>
20 </body>
21 </html>
Observe o Código 57: na linha 9 é definido um valor string que será usado
para localizar (ou não) uma expressão regular. Na décima linha é definida,
armazenando na variável $padraoCEP, a expressão regular, ou seja, o
padrão do texto. Vamos entender o que significa essa expressão regular.
Tabela 7 – Análise da expressão regular apresentada no Código 57.

O texto deve começar com o padrão, ou seja, começar desse ponto. Caso
não fosse definido esse operador, códigos postais como abc89010-098
^
poderiam ser considerados válidos (pois o padrão seria encontrado
dentro do texto).
Define que o texto deve, em uma extensão de exatamente cinco
[0-9]{5} caracteres, ser um caractere dentro do intervalo entre 0 e 9, ou seja,
números (caractere numérico).
- Define que o texto deve ter um hífen.
[0-9]{3} Define um caractere numérico de extensão 3.
$ Define que o texto deve finalizar ao final do padrão.
www.esab.edu.br 146
A Tabela 7 mostra, de forma detalhada, a formação da expressão regular
que representa o CEP brasileiro válido. Ele determina, portanto, que um
CEP tem cinco números, um hífen e três números.
Dica
As funções ereg() e eregi() são consideradas
depreciadas a partir da linguagem PHP 5.3. Logo,
utilize a versão correspondente, aplicando a
função preg_match(), compatível por PCRE.
O Código 58 apresenta exemplo de validação de e-mail.
Código 58 – Script para validação de e-mail

loose.dtd">
02 <html>
03 <head>
06 </head>
07 <body>
08 <?php
09 $cep = "88034-000";
10 $padraoCEP = "/^[0-9]{5}-[0-9]{3}$/";
11 $avaliaCep = preg_match($padraoCEP, $cep);
13 echo "CEP nao Valido";
14 }
15 else
16 {
17 echo "CEP Valido";
18 }
19 ?>
20 </body>
21 </html>
www.esab.edu.br 147
Podemos observar, no Código 58, a definição da expressão regular,
na linha 10, de forma sinônima ao encontrado no Código 57, apenas
definindo o símbolo de início e fim da expressão, necessário para uso
com a função preg_match(). Essa função é vista na linha 11 e seu
funcionamento é idêntico à função ereg().
No próximo tópico vamos desenvolver validações para e-mail e telefone

utilizando expressões regulares.
22.2 Desenvolvendo validação com expressão regular:

caso e-mail e telefone
Da mesma forma que definimos um padrão para CEP por meio de
uma expressão regular, podemos definir expressões regulares para buscar
padrões em e-mail e telefone.
O padrão para e-mail é definido por: iniciar com um caractere alfabético,

podendo ser seguido por vários caracteres alfanuméricos, sublinhado
(_) ou ponto (.) ou hífen (-); o símbolo de @; um ou mais caracteres
alfabéticos; um ponto (.); caracteres alfabéticos e ponto.
Dessa forma, a expressão regular que refere ao e-mail seria: “/^[a-z][a-z0-

9_\.\-]*@[a-z0-9_\.\-]*[a-z0-9_\-]+\.[a-z]{2,4}$/i”
Por sua vez, o telefone pode ser visto como uma cadeia de números no
formato (xx)xxxxx-xxxx (considerando o nono dígito para móveis, em
algumas regiões). Temos, portanto, a expressão “/^$[0-9]{2}$[0-9]{4,5}-
[0-9]{4}$/” definindo o formato de um telefone.
O Código 59 apresenta validações de CEP, e-mail e telefone.
www.esab.edu.br 148
Código 59 – Script para validação de e-mail, telefone e CEP
Transitional//EN" "http://www.w3.org/TR/html4/loose.
dtd">
02 <html>
03 <head>
06 </head>
07 <body>
08 <?php
09 $cep = "88034-000";
10 $email = 'teste@teste.com.br';
11 $telefone = '(11)99555-5555';
12 $padraoCEP = "/^[0-9]{5}-[0-9]{3}$/";
13 $padraoEmail = "/^[a-z][a-z0-9_\.\-]*@[a-z0-9_\.\-
]*[a-z0-9_\-]+\.[a-z]{2,4}$/i";
14 $padraoTelefone = "/^$[0-9]{2}$[0-9]{4,5}-[0-9]
{4}$/";
15 $avaliaCep = preg_match($padraoCEP, $cep);
16 $avaliaEmail = preg_match($padraoEmail, $email);
17 $avaliaTelefone = preg_match($padraoTelefone,
$telefone);
19 echo "CEP nao Valido <br>";
20 }
21 Else
22 {
23 echo "CEP Valido <br>";
24 }
25
26 if(!$avaliaEmail) {
27 echo "Email nao Valido <br>";
28 }
29 else
30 {
31 echo "Email Valido <br>";
32 }
33 if(!$avaliaTelefone) {
34 echo "Telefone nao Valido <br>";
35 }
36 else
37 {
38 echo "Telefone Valido <br>";
39 }
40 ?>
41 </body>
42 </html>

www.esab.edu.br 149
Podemos observar, no Código 59, a definição das expressões regulares
nas linhas 12 (padrão de CEP), 13 (padrão de e-mail) e 14 (padrão de
telefone). A linha 15 armazena o resultado da busca do padrão de CEP,
na variável $avaliaCep (booleana). Da mesma forma, são armazenadas
as buscas de e-mail e telefone para que, entre as linhas 18 e 39, sejam
apresentados os resultados dessas validações. Para testar esse código e
a sua eficácia, altere os valores atribuídos às variáveis $cep, $email e
$telefone e execute, observando o resultado.
Nesta unidade efetuamos buscas de expressões regulares em variáveis

strings, de modo a garantir a validação do formato. Nas próximas
unidades vamos aplicar esses conceitos para continuar o desenvolvimento
do aplicativo de dados do cliente, agora aplicando validações.
www.esab.edu.br 150
Desenvolvendo uma aplicação e
23 manipulando dados em forma de
arquivos – parte 1
Objetivo
Desenvolver uma aplicação empregando os conhecimentos
aprendidos nesta unidade, salvando informações para posterior uso.
Na unidade 22 utilizamos expressões regulares para efetuar validações e

buscas baseadas em padrões. Nesta unidade vamos aplicar esses conceitos,
dando continuidade ao desenvolvimento do aplicativo de dados do
cliente, agora aplicando validações. Usaremos Thomson e Welling (2005)
como base para as validações e Meloni (2000) para embasamento das
interações com outros formulários, usando método post de submissão
dos dados do formulário.
23.1 Desenvolvendo formulário com dados de clientes

para entrada de dados
Você já desenvolveu um aplicativo que obtém dados de um cliente
através de um formulário. Da mesma forma, o Código 60 apresenta um
formulário para a obtenção dos dados do cliente, utilizando conceitos
apresentados por Meloni (2000).

dtd">
02 <html>
03 <head>
05 <title> Formulário de compra de bebidas. </title>
06 </head>
07 <body>
www.esab.edu.br 151
08 <form action="salvarClienteValidando.php"
09 <table border=0>
10 <tr>
11 <td> Nome: </td>
12 <td> <INPUT type="text" name=nome size=50
id=quantidade> </td>
13 </tr>
14 <tr>
16 <td> <INPUT type="text" name=idade size=4> </td>
17 </tr>
18 <tr>
19 <td> Sexo:</td>
21 <OPTION value="1"> Masculino </OPTION>
22 <OPTION value="2"> Feminino </OPTION>
23 </SELECT>
24 </td>
25 </tr>
26 <tr>
28 <td> <INPUT type="text" name=email size=30> </
td>
29 </tr>
30 <tr>
32 <td> <INPUT type="text" name=endereco size=60>
</td>
33 </tr>
34 <tr>
36 <td> <INPUT type="text" name=cidade size=30> </
td>
37 </tr>
38 <tr>
39 <td> CEP: </td>
40 <td> <INPUT type="text" name=cep size=8> </td>
41 </tr>
42 <tr>
44 <td> <INPUT type="text" name=telefone size=20>
</td>
45 </tr>
46 <tr>
48 <td> <INPUT type="text" name=telefone size=12>
</td>
www.esab.edu.br 152
49 </tr>
50 </table>
52 </form>
53 </body>
54 </html>
Alteramos a linha dos códigos anteriores (veja Código 52), tendo,

no Código 60, uma chamada a um novo código denominado
“salvarClienteValidando.php”, na linha 8, que será desenvolvido no
próximo tópico. Aqui, seguimos orientações de Meloni (2000), da
mesma forma que aplicamos na unidade 15.
23.2 Validando utilizando expressões regulares

O formulário envia, portando, dados, via método post, de nome, idade,
sexo, e-mail, endereço completo, cidade e CEP do cliente. Observamos
que a idade só pode aceitar caracteres numéricos e que o e-mail e o CEP
têm definição de formato, já que podemos utilizar expressões regulares
para definir o seu padrão.
Código 61 – Script que recebe os dados pelo método post e efetua validações
01 <?php
05 $sexo = ($_POST["sexo"] ==1) ? 'Masculino' :
'Feminino';
10 if (strlen($cep)== 8){
substr($cep, 5, 3);
12 } else {
13
14 }
15 $padraoIdade = "/^[0-9]{1,3}/";
16 $padraoCEP = "/^[0-9]{5}-[0-9]{3}$/";
www.esab.edu.br 153
]*[a-z0-9_\-]+\.[a-z]{2,4}$/i";
18 $padraoTelefone = "/^$[0-9]{2}$[0-9]{4,5}-[0-9]
{4}$/";
19 $avaliaCep = preg_match($padraoCEP, $cepFormatado);
20 $avaliaemail = preg_match($padraoEmail, $email);
$telefone);
22 $avaliaIdade = preg_match($padraoIdade, $idade);
23 $erro = false;
26 $erro = true;
27 }
28 if(!$avaliaemail) {
30 $erro = true;
31 }
32
35 $erro = true;
36 }
37 if(!$avaliaIdade) {
38 echo "Idade nao Valida <br>";
39 $erro = true;
40 }
41 if (!$erro) {
42 echo "Dados validados com sucesso!";
43 }
44 ?>
No Código 61 são validados dados conforme descrito (CEP, e-mail,

telefone, idade). A linha 15 define a expressão regular referente à
idade, ou seja, um a três algarismos numéricos. A validação da idade é
desenvolvida procurando se a variável lida (obtida pelo método post) é
encontrada no padrão, como pode ser visto na linha 22. Caso o resultado
dessa busca seja falso (não encontrou o padrão), o teste lógico contido
na linha 37 será verdadeiro e os comandos das linhas 38 e 39 serão
executados, apresentando tela de erro (“Idade nao Valida”). Tal validação
segue orientações de Thomson e Welling (2005).
www.esab.edu.br 154
Da mesma forma, são feitas validações das variáveis $cep e com o padrão
de CEP ($padraoCEP), estabelecido na linha 16; da variável $email com
o padrão $padraoemail, estabelecido na linha 17; da variável $telefone,
com o padrão $padraoTelefone, estabelecido na linha 18.
Nesta unidade definimos as validações através de expressões regulares,

deixando-as prontas para o salvamento. Na unidade 24 vamos salvar esses
dados, formatados e validados em arquivo-texto, e que, posteriormente,
serão recuperados e apresentados em uma tabela.
www.esab.edu.br 155
Desenvolvendo uma aplicação e
24 manipulando dados em forma de
arquivos – parte 2
Objetivo
aprendidos nesta unidade, salvando informações para posterior uso.
Na unidade 23 definimos as validações através de expressões regulares,

deixando-as prontas para o salvamento. Agora, vamos salvar e recuperar
usando arquivo-texto e apresentando os dados em uma tabela. Vamos
utilizar os códigos criados na unidade 23 para darmos continuidade e
aplicaremos, basicamente, as orientações de Thomson e Welling (2005)
para as validações e de Meloni (2000) para salvar arquivos-texto. Vamos lá?
24.1 Salvando os dados em arquivo

Para salvar os dados vamos reaproveitar códigos já desenvolvidos para a
validação e formatação, contidos no Código 61. Vamos, então, incluir
instruções para salvar os dados em um arquivo-texto – caso as validações
sejam bem sucedidas, ou seja, não gerem nenhum erro. Acompanhe o
Código 62.
Código 62 – Script que recebe os dados pelo método post, efetua validações e salva arquivo
01 <?php
05 $sexo = ($_POST["sexo"] ==1) ? 'Masculino' :
'Feminino';
www.esab.edu.br 156
substr($cep, 5, 3);
12 } else {
13
14 }
15 $padraoIdade = "/^[0-9]{1,3}/";
16 $padraoCEP = "/^[0-9]{5}-[0-9]{3}$/";
]*[a-z0-9_\-]+\.[a-z]{2,4}$/i";
18 $padraoTelefone = "/^$[0-9]{2}$[0-9]{4,5}-[0-9]
{4}$/";
19 $avaliaCep = preg_match($padraoCEP, $cepFormatado);
20 $avaliaemail = preg_match($padraoEmail, $email);
$telefone);
22 $avaliaIdade = preg_match($padraoIdade, $idade);
23 $erro = false;
26 $erro = true;
27 }
30 $erro = true;
31 }
32
35 $erro = true;
36 }
37 if(!$avaliaIdade) {
38 echo "Idade nao Valida <br>";
39 $erro = true;
40 }
41 if (!$erro) {
42 $arquivo = fopen('c:\\Apache\\htdocs\\clienteValidado.
txt', 'a+');
43 fwrite($arquivo, "$nome#$idade#$email#$sexo#$end
ereco#$cidade$telefone\r\n");
45 echo "Os dados de $nome foram salvos
corretamente";
46 } else {
47 echo "Dados não foram validados! Corrija-os.";
48 }
49 ?>
www.esab.edu.br 157
Ao Código 61 foram inseridas as linhas 41 a 48, que, caso nenhuma das
validações seja negativa (e, consequentemente, o valor da variável $erro
seja falso), irá salvar o arquivo, conforme orientações de Meloni (2000).
Dica
Caso você use o símbolo “;” para separar os valores,
você pode salvar o arquivo com o tipo (valores
separados por vírgula, em tradução), que tem
extensão .csv. Desse modo, poderá abrir o arquivo
utilizando Microsoft Excel ou Calc do pacote
LibreOffice.
As Figuras 33 e 34 apresentam os resultados das validações.
Figura 33 – Formulário para inserção de dados e resultado (erro).

Na Figura 33 observamos uma tela de seleção dos dados do cliente através

de formulário e, em plano superior, o resultado das validações. Nesse
caso, há uma mensagem de erro. Note que o CEP contido no formulário
tem nove dígitos numéricos e, por esse motivo, não é validado, gerando a
mensagem de erro e não salvando o registro no arquivo.
www.esab.edu.br 158
Agora, veja com atenção a Figura 34.
Figura 34 – Formulário para inserção de dados e resultado.

Ao contrário do que mostra a Figura 33, na Figura 34 o plano superior

apresenta, como resultado da execução do script PHP, mensagem de
sucesso. Observando o Código 62, verificamos que a mensagem de
sucesso só é apresentada após salvar os dados no arquivo, ou seja, caso ele
apresente essa tela, o registro deve encontrar-se no arquivo.
Agora, com os dados salvos corretamente, podemos apresentá-los na tela.
24.4 Apresentando dados salvos em arquivos

O processo de salvar o arquivo, observado no Código 62, salva os
dados do cliente em uma linha de arquivo-texto, separado por “#”. Para
visualizar os dados, vamos obter os dados da linha e dividi-los usando
a função explode(), a fim de chegarmos a um vetor com os dados do
cliente, quando cada posição do vetor é um dado valor. O Código 63
apresenta os dados na tela.
www.esab.edu.br 159
Código 63 – Apresentação dos dados do cliente
dtd">
02 <html>
03 <head>
06 </head>
07 <body>
08 <?php
clienteValidado.txt', 'r');
10 echo '<table>';
12 $cliente = explode('#', fgets($arquivo));
13 echo '<tr>';
14 foreach ($cliente as &$valor){
15 echo '<td style="border:1px solid black">'. $valor.
'</td>';
16 }
17 echo '</td>';
18 }
20 ?>
21 </body>
22 </html>
A linha 12 do Código 63 apresenta a função explode(), atribuindo ao

vetor $cliente os dados que são recuperados do arquivo-texto, dividindo
pelo marcador #. É, então, criada uma linha da tabela (tag <tr>) para
cada interação e, para cada dado, uma coluna da tabela, preenchendo as
células com os valores. O resultado pode ser visto na Figura 35.
www.esab.edu.br 160
Figura 35 – Apresentando dados recuperados.
A Figura 35 apresenta os dados contidos no arquivo-texto em um

formato de tabela, visto que os dados foram separados. Como nosso
arquivo continha apenas uma linha (registro de um cliente), nossa tabela
apresentou somente uma linha. Caso o conteúdo do arquivo apresentasse
mais registros, para cada registro teríamos uma linha da tabela.
Nesta unidade completamos nosso exemplo, definindo as validações

através de expressões regulares, formatando e salvando em arquivo-texto.
Também apresentamos os dados em uma tabela, facilitando a visualização.
Na unidade 25 vamos ver como reaproveitar código usando funções.
Atividade
www.esab.edu.br 161
Resumo
Na unidade 19 utilizamos algumas funções para manipular o tipo string,

sendo possível formatar, unir variáveis, comparar, localizar partes do
texto e substituir essas partes encontradas por outros textos.
Utilizamos funções como substr() para obter parte do texto; trim()

para eliminar o excesso de espaços; n12br para adicionar quebra de
linha padrão HTML/XHTML; AddSlashes() para adicionar aspas
e StripSlashes() para retirá-las; explode() para separar uma variável
(apontando um marcador) e join() para juntar; strcmp() para comparar
e strstr() para localizar uma string dentro de outra; e, enfim, strreplace(),
para trocar partes de uma string.
Na unidade 20 elaboramos aplicativos para a fixação desses conteúdos,

formatando o CEP usando substr(), localizando parte do endereço
usando strPos() e alterando com o uso de str_replace().
Introduzimos e vimos como definir expressões regulares na unidade 21.

Para isso, estudamos tipos, símbolos e denotações, bem como alguns
exemplos definidos.
Na unidade 22 utilizamos as expressões regulares para efetuar buscas de

padrões e, com isso, efetuar validações, como uma validação de e-mail.
Uma aplicação prática, com a leitura de dados de cliente em um

formulário e o seu processamento em um script PHP foi desenvolvida na
unidade 23. Nela observamos e definimos validações, deixando os dados
prontos para serem gravados em um arquivo.
Na unidade 24, dando continuidade à aplicação prática, salvamos os

dados validados no arquivo-texto e os recuperamos, usando a função
explode() para dividir a string e separar os dados.
www.esab.edu.br 162
25 Reutilizando o código
Objetivo
Apresentar a necessidade de reutilização de um código,
demonstrando economia de tempo e custo, bem como facilitando a
manutenção e gerando confiabilidade.
Nas unidades anteriores, utilizamos dados salvos em arquivos-texto

e também formatações de texto, os quais permitem que dados sejam
salvos e que, consequentemente, seja possível realizar sua leitura
posteriormente, sem que ocorra qualquer perda na finalização
da execução do script. Nesta unidade veremos os conceitos e os
benefícios da reutilização do código, informações importantes para
o desenvolvimento de projetos sustentáveis, com menor custo e de
manutenção facilitada. Para isso, utilizaremos como base teórica
Thomson e Welling (2005). Vamos em frente!
25.1 Explicando a crise no desenvolvimento

Nas últimas décadas, com a popularização dos computadores, houve a
ampliação do uso de softwares, assim como o aumento nos custos de
desenvolvimento de novas soluções. Essas consequências, por sua vez,
fizeram com que os desenvolvedores de softwares repensassem os seus
métodos de criação.
Essa popularização aumentou, também, a concorrência entre as empresas

fabricantes de softwares e, além da disputa em relação à qualidade
do produto (cumprimento dos requisitos funcionais e requisitos não
funcionais, ou seja, se o programa de computador realiza suas funções
de forma correta, com exatidão, segurança, facilidade de uso e com
tempo de resposta compatível), há a disputa relacionada aos preços e
ao tempo de desenvolvimento. Esta, por sua vez, acaba por obrigar as
empresas a reestruturarem os processos de desenvolvimento, de modo a
diminuir custos e tempo e a possibilitar a prática de melhores preços e
entregas mais rápidas, mantendo a qualidade do software e respeitando o
orçamento e o prazo estipulados e concordados.
www.esab.edu.br 163
A dificuldade de manutenção soma-se a esses motivos, o que resulta
em um desenvolvimento desorganizado e, caso haja a necessidade de
alteração de um requisito, são demandadas mudanças em códigos.
Dessa forma, um desenvolvimento que não seja bem estruturado ou
organizado exigirá um tempo maior para entendimento do código e,
consequentemente, maior tempo e custo para a elaboração da alteração.
A crise de software refere-se, portanto, a um conjunto de problemas

encontrados no desenvolvimento e na manutenção de software, e se
relaciona, principalmente, aos métodos de planejamento e de engenharia
de requisitos. Também se refere aos métodos de construção com ênfase
na reutilização e no reaproveitamento de código – o que veremos na
próxima seção –, tendo como objetivo principal o aumento da satisfação
do cliente e a garantia da qualidade do software.
25.2 Custo x reutilização de código

Como vimos anteriormente, a crise do software e a crescente
concorrência na área exigiram cuidados relacionados à diminuição de
custos. Isso passa, também, pela reutilização de códigos, ou seja, implica
no aproveitamento de um código que já foi escrito para determinada
função para a execução dessa mesma função toda vez que ela for
necessária, seja dentro do mesmo aplicativo, seja em outras aplicações.
Segundo Thomson e Welling (2005, p. 96), “[...] um dos objetivos dos

engenheiros de software é reutilizar código em vez de escrever código
novo”. Os autores completam que o objetivo dessa reutilização é reduzir
custos, aumentar a confiabilidade e melhorar a consistência. Durante a
vida útil de um software são aplicados mais tempo e recursos em manter,
modificar, testar e documentar do que escrevendo-o.
Por exemplo, imagine um sistema com cadastro de clientes, vendedores

e fornecedores, no qual todos podem cadastrar um e-mail. Para cada
cadastro, teríamos uma validação de e-mail e, caso o código não fosse
reaproveitado, escreveríamos, nesse caso, três vezes a validação de e-mail
que executa a mesma função.
www.esab.edu.br 164
Caso tenhamos uma biblioteca de códigos e nela seja mantida uma
função de validação de e-mail, podemos utilizar essa mesma função a
partir dos três cadastros. Dessa forma, será necessário escrever o código
uma vez, apenas executando a função a partir dos três cadastros, como
podemos ver na Figura 36.
Cadastro de cliente
Cadastro de vendedor Função validação e-mail
Cadastro de fornecedor
Figura 36 – Três cadastros, obtendo uma única função de validação.

Na Figura 36 observamos que a função de validação fica em um arquivo

PHP (visto no lado direito da figura), acessível ao código e que valida
os três cadastros (que estão do lado esquerdo) de forma que qualquer
alteração feita nessa função de validação de e-mail reflita nas validações
dos três cadastros.
Agora imagine que, se você trabalhar em outro projeto que também exija
a validação de e-mail, você poderá aproveitar a função já escrita, não
precisando escrevê-la novamente (ou “reinventar a roda”, jargão comum
entre os desenvolvedores).
Além do custo, a confiabilidade e a consistência nas manutenções são

assuntos relacionados ao reuso de software e serão estudados na próxima
seção.
www.esab.edu.br 165
25.3 Ganhos relacionados à manutenção e à
confiabilidade
Recuperando o exemplo citado, vamos considerar um sistema contendo
três validações de e-mail, uma em cada cadastro. Se a estrutura de nomes
do domínio da internet que compõe o e-mail (após o @) fosse alterada,
seriam necessárias alterações nas três validações. Imagine, agora, que você
altere duas validações e se “esqueça” de alterar a validação do e-mail no
cadastro de clientes. O que aconteceria?
Com a reutilização de uma mesma função validando o e-mail, a

manutenção seria mais fácil, visto que alterando e testando uma única
função garantiríamos o funcionamento desse requisito nos três cadastros.
Thomson e Welling (2005) completam que, se o seu código estiver

funcionando em algum lugar da organização – por exemplo, caso
você tenha escrito o código de validação de e-mail em outro projeto
–, provavelmente esse código existente e “maduro” seja mais confiável
do que um código fresco e “verde”. Os autores salientam, ainda, que a
reutilização do código acarreta menos trabalho para o desenvolvedor/
programador, isso caso o código original tenha sido bem escrito e
elaborado de forma modular.
25.4 Como reutilizar código escrito em outros

arquivos?
Para reutilizar um código carregando funções escritas em outro arquivo
PHP, utilizamos as instruções require() e include(). Elas adicionam o
conteúdo do arquivo no ponto em que são chamados no código PHP.
Para um melhor entendimento, utilizaremos a função require(),

reaproveitando a definição de cabeçalho e rodapé em HTML, de modo a
não reescrevê-lo diversas vezes quando o usarmos em um aplicativo web.
Inicialmente, vamos definir um cabeçalho padrão para o nosso aplicativo.

O Código 64 apresenta esse cabeçalho.
www.esab.edu.br 166
Código 64 – Cabeçalho do aplicativo
loose.dtd">
02 <html>
03 <head>
05 <style>
06 h1 { color:white; font-size:24pt; text-
align:center}
07 .menu {color:white; font-size:12pt; text-
align:center}
08 .dados { color:white; font-size:10pt; text-
align:left}
09 .dados2 { color:white; font-size:14pt; text-
align:center}
10 .creditos {color:white; font-size:8pt; text-
align:center}
11 </style>
12 </head>
13 <body>
14 <table width=100% border=0>
15 <tr bgcolor=black>
16 <td align=left width=100>
17 <img src="http://www.esab.edu.br/wp-content/
uploads/2013/07/icon-biblioteca.png">
18 </td>
19 <td>
20 <h1> Sistema Web Teste </h1>
21 </td>
22 </tr>
O Código 64 apresenta o cabeçalho do nosso sistema web. Observe que

nas linhas 5 a 9 ele estabelece folha de estilos, a qual pode ser utilizada
em qualquer documento que reutilize nosso cabeçalho. Ele também
apresenta uma tabela com uma imagem (como se fosse uma logomarca)
e um texto “Sistema Web Teste”, formatado pelo estilo h1 na linha
20. Observe que as tags <html> e <body> são abertas, porém, não são
fechadas, pois serão inseridas nos outros documentos. Salve o conteúdo
desse código como header.inc.
Agora vamos escrever o nosso rodapé, conforme vemos no Código 65.
www.esab.edu.br 167
Código 65 – Rodapé do aplicativo
01 <table width=100% bgcolor=black border=0>
02 <tr>
03 <td span class="creditos">Desenvolvido por
Egon Sewald Junior </span></td>
04 </tr>
05 </body>
06 </html>
Observe que, no Código 65, é utilizado um estilo definido no header.

inc e as tags <body> e <html> também são fechadas, sendo, portanto,
utilizadas de forma combinada. Salve como footer.inc.
Em seguida, vamos desenvolver dois códigos em PHP, que reutilizam

header.inc e footer.inc.
O Código 66 apresenta um exemplo de reuso dos códigos escritos. Para

que possamos executar o código, posteriormente, salve o arquivo (por
exemplo, Unidade25Teste1.php).
Código 66 – Exemplo de teste com reuso

01 <?php
02 require('header.inc');
03 echo '<table width=100% bgcolor=black
border=0>';
04 echo '<tr>';
05 echo '<td span class="dados">Teste de reuso</
span></td>';
06 echo '</tr>';
07 require('footer.inc');
08 ?>
Na linha 2 do Código 66, está o comando que insere o conteúdo

do arquivo header.inc, presente no Código 64 e, na linha 7, insere o
conteúdo do arquivo footer.inc do Código 65. Dessa forma, é como
“copiar e colar” o conteúdo dos arquivos nos pontos que são incluídos.
As linhas 3 a 6 criam uma tabela e inserem o texto “Teste de reuso”,
formatando com um estilo criado no arquivo incluído (no header.inc).
www.esab.edu.br 168
O Código 67 apresenta nova aplicação, também reusando os arquivos.
Observe.
Código 67 – Exemplo de uma página com reuso

01 <?php
03 echo '<table width=100% bgcolor=black
border=0>';
04 echo '<tr>';
05 echo '<td span class="dados2">Teste de reuso
2</span></td>';
06 echo '</tr>';
08 ?>
Assim como no Código 66, o Código 67 reutiliza os arquivos header.

inc e footer.inc, mas faz uso de outro estilo, também criado no arquivo
incluso header.inc. Para que possamos executar esse código, salve o
arquivo com nome diferente do arquivo salvo no Código 66 (por
exemplo, Unidade25Teste2.php) O resultado da execução dos Códigos
66 e 67 pode ser visto na Figura 37.
Figura 37 – Resultado dos códigos aplicando reuso.

A Figura 37 apresenta, do lado esquerdo, o resultado da execução do

Código 66 e, ao lado direito, a execução do Código 67. Observe que,
com o aproveitamento dos códigos contidos no cabeçalho e rodapé, não
foi necessário reescrever o código, de modo a ganhar escala e produzir
mais códigos com menos tempo. Caso necessite alterar o padrão de
visualização do cabeçalho, alterando o arquivo header.inc, por exemplo,
o efeito seria aplicado na execução dos outros códigos, sem a exigência de
novas alterações.
www.esab.edu.br 169
Nesta unidade vimos os benefícios – como a diminuição de tempo e custo
de desenvolvimento e maior facilidade na manutenção – e o exemplo de
reuso de código. Nas próximas unidades vamos fazer reuso por meio da
utilização de funções, de modo a estruturar nossas aplicações.
www.esab.edu.br 170
26 Escrevendo funções – parte 1
Objetivo
Apresentar uso de funções require() e include() para
reaproveitamento de código.
Na unidade 25, reutilizamos o código de um arquivo incluindo-o em

outro arquivo, o que promove economia de tempo para o desenvolvimento
e para a manutenção e diminui custos. Nesta unidade vamos estruturar
o código por meio de funções, melhorando o entendimento e facilitando
o reaproveitamento. Nos basearemos, para isso, em Thomson e Welling
(2005) e em Meloni (2000). Vamos em frente.
26.1 O que é uma função?

Ao procurar em um dicionário, encontraremos várias definições para
função. Em computação temos duas definições principais: uma está
relacionada à Engenharia de Software e significa um comportamento,
ou seja, a definição de um algoritmo, com um objetivo, início e fim,
de modo a resolver um problema ou uma funcionalidade; a segunda
definição, que está relacionada ao processo de desenvolvimento e
construção de programas de computador, define função como uma
sub-rotina, que retorna um valor (assim como na definição de função
na matemática). É, portanto, um “pedaço” do código que resolve um
problema específico, parte do problema maior que define o problema.
“Uma função é um módulo autocontido de código que prescreve uma
interface chamada, realiza uma tarefa e opcionalmente retorna um
resultado.” (THOMSON; WELLING, 2005, p. 104).
O uso de funções tem como principais objetivos a decomposição de

problemas em partes menores, de modo a facilitar o entendimento do
código para desenvolvimento e manutenção e; estruturar o problema
de modo a facilitar seu reaproveitamento, reduzindo o uso de códigos
duplicados em um programa.
www.esab.edu.br 171
Uma função tem uma assinatura que é composta pelo seu nome, pelos
parâmetros que a função recebe e que regulam seu funcionamento,
por um retorno opcional e pelo seu corpo, ou seja, o algoritmo que a
regula. Na matemática, usamos uma função para associar um conjunto
de domínio e um conjunto de imagem. Por exemplo, usando F(x) =
x*2, podemos dizer que F(2) = 2 * 2, logo, F(2) = 4. Se relacionarmos
com o uso de funções na programação, podemos dizer que o parâmetro
x recebeu valor 2 (substituímos x por 2) e que o retorno da função é 4.
Porém, na matemática, as funções não têm nome e no desenvolvimento
precisamos nomeá-las (o que, nesse caso, poderíamos chamar de dobro).
Para chamar uma função sem parâmetros, podemos executar a instrução

nome_da_função();. Nesse caso, também são ignorados os retornos da
função.
Até esse ponto de nossos estudos, fizemos a utilização de diversas

funções, mas sem detalhes mais densos. Na próxima seção vamos
observar algumas funções predefinidas pela linguagem PHP.
26.2 Funções definidas pela linguagem PHP

Fizemos, até então, a utilização de diversas funções, porém, sem grandes
detalhes e definições, muitas vezes sem mesmo definir que estávamos
aplicando uma função.
A linguagem PHP tem um conjunto de funções predefinidas para

resolver diversos problemas: testes lógicos, laços de repetição, manipular
strings e expressões regulares, enviar e-mail, gestão de arquivos-texto
(abrir, ler, gravar, fechar etc.), reaproveitar código, acessar bancos de
dados, tratar exceções, controlar sessões e cookies, gerar relatórios em
PDF e RTF, entre outros problemas já resolvidos. Utilizar as funções
já definidas poupa tempo, fazendo com que não haja a necessidade
de desenvolver uma resolução para esses problemas, reaproveitando as
soluções já encontradas – reutilizando código, nesse caso, de terceiros.
Meloni (2000) apresenta várias funções, chamadas por ele de “embutidas”.

Aqui vamos fazer um resumo das funções apresentadas pelo autor, citando
aquelas já estudas e apresentando as funções que ainda não foram vistas.
www.esab.edu.br 172
Várias das funções apresentadas por Meloni (2000) e utilizadas por nós
nas unidades 17 e 18, como as funções de manipulação de arrays (função
array() – que cria um vetor; função array_push() – que adiciona um
elemento ao final do vetor; função array_unshift() – que retira elemento
do vetor; e função reset() – que retrocede o cursor de navegação para a
primeira posição).
Também fizemos uso de funções para manipulação de arquivos

(filesystens), como aquelas aplicadas nas unidades 15 e 16: fopen() – que
abre arquivo; fread() – que lê dados de uma linha do arquivo; fputs()
– que escreve dados no arquivo-texto, fclose() – que fecha o arquivo.
Às funções já utilizadas podemos somar as funções de manipulações de
arquivos. A Tabela 8 apresenta algumas funções, suas definições, sintaxes
e exemplos de uso.
Tabela 8 – Funções de manipulação de arquivos.

Função Definição Sintaxe Exemplo de uso
Verifica se um nome
de arquivo já existe. if (file_exists(‘c:\teste.txt’)) {
file_exists() file_exists(nome_arq);
Retorna um valor }
booleano.
Cria um diretório. O
usuário da PHP deve ter mkdir(nome_arq,
mkdir() mkdir(‘/home/local’, 0755);
permissões para escrita mode);
no diretório específico.
Tem como objetivo
renomear um arquivo. O
rename(nome_arq, rename(‘index.html’,
rename() usuário da PHP deve ter
novo_nome_arq); ‘index2.html’);
permissões para escrita
Remove um diretório. O
usuário da PHP deve ter
rmdir() rmdir(nome_diretorio); rmdir(‘/home/user/arq’);
Deleta um arquivo do
sistema de arquivos. O
unlink(‘/home/usr/index.
unlink usuário da PHP deve ter unlink(nome_arq);
html’);
copy(‘/home/usr/index.
copy Copia um arquivo copy(origem, destino); html’, ‘/home/usr2/index.
html’);
www.esab.edu.br 173
As funções de manipulação de datas são apresentadas em Meloni
(2000). Na unidade 14, utilizamos a função date(). Também podemos
utilizar a função time(), que retorna a hora atual do sistema, marcada
em segundos, retornando um número inteiro longo. Sua sintaxe é
simplesmente time(); e, para exibir a hora do sistema, poderíamos usar a
instrução echo time();.
Meloni (2000) apresenta o uso de funções matemáticas. A Tabela 9 traz

um conjunto desse tipo de função,
Tabela 9 – Funções matemáticas.

Função Definição Sintaxe Exemplo de uso
Arredonda uma fração
round(2.56); retorna 3
round() para o número inteiro round(num_fração);
mais próximo.
ceil() para cima até o número ceil(num_fração);
inteiro mais próximo.
floor() para baixo até o número floor(num_fração);
inteiro mais próximo.
number_format number_format (1200.45,
Retorna a versão (número, casas_ 2, ‘,’, ‘.’); retorna ‘1.200,45’,
number_
formatada de um decimais, separador_ com vírgula como
format()
número decimal, separador_ separador decimal e ponto
milhar); como separador de milhar.
Retorna o valor de um
pow (número,
pow() número, elevado a uma pow(3, 4); retorna 81
potência);
potência informada.
Retorna a raiz quadrada
sqrt() sqrt (número); sqrt(4); retorna 2
de um número.
Retorna um número
rand(1, 20); retorna
randômico (aleatório)
rand() rand(min, max) qualquer número entre 1
dentro de uma faixa de
e 20
número
As funções de manipulação de expressões regulares e de string têm seu

uso demonstrado por Meloni (2000) e sua aplicação consta nas unidades
19 a 22.
www.esab.edu.br 174
Também são apresentadas, pelo autor, funções para uso de banco de
dados e funções para controle de sessões e cookies. Essas últimas, serão
estudadas mais à frente, com maior atenção.
Saiba mais
A documentação oficial da PHP apresenta
referência de funções e extensões, por categoria,
disponível clicando aqui. É uma ótima fonte de
referência, que pode ser utilizada em caso de
dúvidas no uso de funções da PHP, apresentando
exemplos.
O Código 68 apresenta o uso de algumas funções predefinidas,

combinadas para testar se um arquivo existe, ler um arquivo (com
conteúdo ‘24#2#345’), executar operações matemáticas (elevar ao cubo)
com seus dados e apagá-lo após seu uso.
www.esab.edu.br 175
Código 68 – Exemplo de funções predefinidas
loose.dtd">
02 <html>
03 <head>
06 </head>
07 <body>
08 <?php
09 $nome_arquivo = 'C:\\wamp\\www\\unidade19\\
numero.txt';
10 if (file_exists($nome_arquivo)){
11 $arquivo = fopen($nome_arquivo, 'r');
12 echo '<table>';
14 $numeros = explode('#', fgets($arquivo));
15 foreach ($numeros as &$valor){
16 echo '<tr><td style="border:1px solid
black">'. $valor. '</td>';
17 echo '<td style="border:1px solid black"> ao
cubo </td>';
18 echo '<td style="border:1px solid black">'.
pow($valor,3). '</td></tr>';
19 }
20 echo '</table>';
21 }
23 unlink($nome_arquivo);
24 } else {
25 echo ‘o arquivo não existe’;
26 }
27 ?>
28 </body>
29 </html>
O Código 68 apresenta solução para o enunciado. Na linha 9 é atribuído

o valor do nome do arquivo a ser usado nos outros comandos, como
na linha 10, em que é usado esse valor junto à função file_exists()
determinando se o arquivo existe ou não. Caso exista, utiliza outra
função predefinida para abri-lo e, para cada linha, atribuirá o valor,
explodido com o caractere de separação (#) a um vetor. Para isso, foi
www.esab.edu.br 176
utilizada, na linha 14, a função explode(). Foram criadas três colunas,
cada uma contendo três linhas: uma linha para o valor, outra com o texto
“ao cubo” e uma terceira com o resultado da função pow(), que eleva
o valor inicial a uma potência, nesse caso, ao cubo (3), como pode ser
visto na linha 18. A linha 22 apresenta a função fclose(), necessária para
efetuar o fechamento do arquivo – caso não seja executada, o arquivo
permanece aberto, não sendo possível efetuar outra leitura (pois estará
em uso). A função unlink() é utilizada na linha 23 com o objetivo de
apagar o arquivo. O resultado de sua execução pode ser visto na Figura
38.
Figura 38 – Resultado de código utilizando funções predefinidas.

A Figura 38 apresenta, no seu lado esquerdo, a execução do código

lendo o arquivo, processando, efetuando cálculo e apagando o arquivo.
Em seu lado direito, a figura mostra uma nova execução e retorna
uma mensagem de que o arquivo não existe, pois o arquivo não foi
encontrado (já que foi apagado na primeira execução).
Vale, neste momento, demonstrar, com a Figura 39, que, caso a forma de
usar a função esteja errada, aparecerá um erro no momento da execução
do código.
Figura 39 – Resultado de código com erro, chamada de função inexistente.

www.esab.edu.br 177
Isso ocorre, como vimos na Figura 39, porque a linguagem PHP é
interpretada e os erros só aparecem no momento da execução. Na
imagem, podemos observar que são apontadas as posições do código
onde não foram encontradas as funções. Nesse caso, a função não
encontrada (o erro) está na linha 6. Os erros podem ser causados pelo
nome incorreto (ou inexistente), uso de parâmetros incorretos ao chamar
a função ou a não localização de uma função presente em um arquivo
que não foi incluído, o que a torna inacessível. Os erros acontecem de
forma similar com funções predefinidas pela linguagem PHP e funções
definidas pelo desenvolvedor, assunto da unidade 27.
Nesta unidade vimos o conceito de funções e sub-rotinas e algumas

funções predefinidas na linguagem PHP, de uso comum. Na unidade
27 veremos como escrever e utilizar funções, desenvolvendo funções
próprias para estruturar nosso código e facilitar o reuso.
Tarefa dissertativa
www.esab.edu.br 178
Objetivo
Apresentar uso de funções, escrevendo e chamando funções escritas.
Nas unidades anteriores, entendemos a importância do reuso de código,

aplicando funções predefinidas disponíveis na linguagem PHP. Nesta
unidade estudaremos como criar e utilizar funções estruturando nosso
código. Para isso, teremos como base teórica Thomson e Welling (2005).
Vamos lá?
27.1 Escrevendo funções

Você pode utilizar várias funções predefinidas para resolver diversos
problemas, economizando tempo de desenvolvimento. Mas, segundo
Thomson e Welling (2005), o verdadeiro poder de uma linguagem
de programação está na possibilidade de criar suas próprias funções,
resolvendo problemas específicos e que não foram previstos pelos
criadores da linguagem.
Escrevemos funções quando um conjunto de instruções e comandos

pode ser reutilizado, ou seja, sua execução pode ser realizada para
reutilização em vários pontos de seus scripts ou em vários scripts.
Também escrevemos funções quando um bloco representa a resolução
de um problema, de modo a estruturar o código e melhorar o
entendimento, facilitando o desenvolvimento e a manutenção.
Para criar ou declarar uma função, iniciamos com a palavra function,

fornecendo o nome da função, opcionalmente os parâmetros necessários
(entre parênteses) e o código que será executado toda vez que a função
for chamada. Uma estrutura comum para a função, sem parâmetros,
pode ser vista no Código 69.
www.esab.edu.br 179
Código 69 – Declaração comum de função
01 function nome_da_funcao () {
02 bloco_de_comandos_que_serão_executados
03 }
O Código 69 apresenta a definição de uma função sem parâmetros,

chamada nome_da_funcao que, ao ser chamada, executaria os comandos
que estariam entre os colchetes, os quais delimitam o início e o fim do
bloco da função, nesse caso representado pela linha 2.
O Código 70 apresenta a criação de uma tabela com uma célula e dentro

o valor Teste.
Código 70 – Declaração de função tabela

01 function criaTabela () {
02 echo '<table width=100% border=0>';
03 echo '<tr>';
04 echo '<td>Teste</td>';
05 echo '<td>Coluna 2</td>';
06 echo '</tr>';
07 }
Quando essa função – cujo nome foi definido, na linha 1 do Código

70, como criarTabela – é chamada, serão executadas as linhas 2 a 6,
que retornam ao documento uma tabela, uma linha e uma coluna,
preenchem a célula com o texto “Teste” e retornam outra coluna,
preenchendo a célula com o texto “Coluna 2”.
Com relação à definição do nome das funções, elas devem representar o

que ela faz, de forma representativa. Algumas restrições são:
• A função não pode ter o mesmo nome de uma função existente.

• O nome da função somente pode conter letras, dígitos e sublinhados.
• O nome da função não pode iniciar com um dígito. (THOMSON; WELLING, 2005, p. 107)
Agora que você já sabe como criar uma função, na próxima seção vamos
aprender a chamar e utilizar funções.
www.esab.edu.br 180
27.2 Chamando funções
Para chamar uma função, como aquela apresentada no Código 70, ou
seja, uma função sem retorno e sem parâmetro, devemos utilizar o nome
da função, seguido de abre e fecha parênteses. Ou seja, para chamarmos a
função definida no Código 69, utilizamos nome_da_funcao();
Assim, cada vez que é executada essa instrução no script PHP, as

instruções definidas na função são executadas.
Da mesma forma, para chamarmos a função definida no Código 70, que

cria uma tabela, podemos observar o Código 71, que a executa dentro do
script.
Código 71 – Exemplo de uso do script, chamando função

loose.dtd">
02 <html>
03 <head>
05 </head>
06 <body>
07 <?php
08 function criaTabela () {
10 echo '<tr>';
11 echo '<td>Teste</td>';
12 echo '<td>Coluna 2</td>';
13 echo '</tr>';
14 }
15 ?>
17 <tr>
20 </td>
21 <td> Título </td> </tr>
22 </table>
23 <h1>
24 <?php
www.esab.edu.br 181
25 criaTabela();
26 ?>
27 </h1>
29 <tr>
30 <td>Desenvolvido por Egon Sewald Junior </
td>
31 </tr>
32 </table>
33 <?php
34 criaTabela();
35 ?>
36 </body>
37 </html>
O Código 71 apresenta script PHP integrado ao documento HTML.

Observe que as linhas 7 a 15 apresentam código PHP com a função
tabela(), bem como as chamadas dessa função, em código apresentado
nas linhas 24 a 26 e 33 a 35. A função, definida entre as linhas 8 e 14
determinam, quando chamada, uma tabela com uma linha e duas colunas
com textos “Teste” e “Coluna 2”, respectivamente. Observe que a primeira
chamada (linha 25, código entre 24 e 26), está dentro de uma tag <h1> (na
linha 23) e </h1> (linha 27). Logo, deve-se respeitar essa formatação.
Como a segunda chamada não segue formatação definida, apresenta a

fonte da tabela como corpo do documento HTML. As tabelas foram
criadas com borda de tamanho 1 apenas com fins didáticos, ou seja, para
ficar claro onde foram criadas.
A Figura 40 apresenta o resultado da execução do Código 71.
Figura 40 – Resultado de código, com chamada de função.

www.esab.edu.br 182
Observe, na Figura 40, que foram executadas duas vezes a função tabela(),
sem que fosse necessário desenvolver duas vezes o mesmo código. Isso fica
visível quando observamos duas tabelas, com uma linha e duas colunas
cada, com o mesmo texto (“Teste” e “Coluna 2”, respectivamente).
Agora que vimos como criar e usar uma função, precisamos entender o
uso dos parâmetros dentro das funções, para que o comportamento da
função possa agir de acordo com esses parâmetros, mas isso é assunto
para a nossa próxima unidade.
Atividade
www.esab.edu.br 183
Objetivo
Apresentar o uso e funções com passagem de parâmetros, bem como
o escopo das variáveis.
Nas unidades anteriores, utilizamos funções predefinidas pela linguagem

PHP e definimos funções próprias, chamando-as. Porém, as funções
podem ter seu comportamento dependente de valores que recebem e,
para isso, utilizamos parâmetros. Nesta unidade veremos como definir
e chamar as funções usando parâmetros. Para isso, teremos como base
teórica Thomson e Welling (2005).
28.1 Funções com uso de parâmetros

Na unidade 27, utilizamos uma função que tinha como objetivo criar
uma tabela com uma linha e duas colunas com valores fixos. E se
tivéssemos que criar essa mesma tabela, mas com valores diferentes,
determinados a cada execução?
Para resolver isso, poderíamos mudar o comportamento da função,

usando parâmetros.
Uma função pode receber parâmetros, que são definidos por variáveis
e podem ser utilizadas dentro dessa função. A definição de parâmetro é
feita entre parênteses, após o nome da função, como podemos observar
no Código 72.
Código 72 – Declaração de função com parâmetro

01 function nome_da_funcao ($parametro1,
$parametro2, ..., parametroN) {
02 bloco_de_comandos_que_serão_executados
03 }
www.esab.edu.br 184
As variáveis que foram definidas na declaração da função podem ser
utilizadas no corpo da função, representada, no Código 72, pela linha
2, e todas as instruções que a possam substituir, para que o objetivo da
função seja cumprido. Veja o Código 73.
Código 73 – Declaração de função tabela

01 function criaTabela ($coluna1, $coluna2) {
03 echo '<tr>';
04 echo '<td>’. $coluna1. ’</td>';
06 echo '</tr>';
07 }
O Código 73 apresenta uma função que recebe dois valores e cria uma
tabela, com uma linha e duas colunas, preenchendo com os valores dos
parâmetros na primeira e segunda coluna, respectivamente.
Para utilizar uma função que usa parâmetros, devemos observar que estas
devem receber valores conforme a sua assinatura (como define a construção
da função), em mesmo número e na mesma ordem em que foi definida.
Assim, alteramos o Código 71 para obtermos o Código 74, no qual a

função criaTabela() utiliza parâmetros.
www.esab.edu.br 185
Código 74 – Exemplo de uso do script, chamando função
loose.dtd">
02 <html>
03 <head>
05 </head>
06 <body>
07 <?php
08 function criaTabela ($coluna1, $coluna2) {
10 echo '<tr>';
13 echo '</tr>';
14 }
15 ?>
17 <tr>
20 </td>
21 <td> Título </td> </tr>
22 </table>
23 <h1>
24 <?php
25 criaTabela(‘Valor primeira coluna’, ‘Valor
Segunda Coluna’);
26 ?>
27 </h1>
29 <tr>
30 <td>Desenvolvido por Egon Sewald Junior </
td>
31 </tr>
32 </table>
33 <?php
34 $valor1 = ‘Segunda tabela – valor 1’;
35 $valor2 = ‘ESAB’;
36 criaTabela($valor1, $valor2);
37 ?>
38 </body>
39 </html>
www.esab.edu.br 186
Observe que, no Código 74, ao chamar a função criaTabela() na linha
25, são passadas como parâmetros, diretamente, duas literais, ‘Valor
primeira coluna’ e ‘Valor Segunda Coluna’. Porém, nas linhas 34 e 35
são criadas duas variáveis, que têm seus valores passados como parâmetro
à função criaTabela(). As duas formas são válidas e o funcionamento da
função é idêntico. O resultado da execução do Código 74 pode ser visto
na Figura 41.
Figura 41 – Resultado de código com chamada de função com parâmetros.

Observe que foram criadas duas tabelas a partir do mesmo código

(reutilizado e reaproveitado) com os valores passados como parâmetro,
como pode ser observado na Figura 41.
Dica
Parâmetro de uma função são todas as variáveis
responsáveis por determinar o comportamento
de uma função, isto é, que definem seu
funcionamento. Se você puder reaproveitar a
função alterando alguma variável para funcionar
para outro valor, essa variável deve ser definida
como parâmetro da função.
Porém, e se alterarmos o valor da variável no corpo da função? A resposta

é dada por meio do escopo das variáveis, que veremos na próxima seção.
www.esab.edu.br 187
28.2 Escopo de variáveis (globais e internas)
“O escopo da variável controla onde ela é visível e utilizável.”
(THOMSON; WELLING, 2005, p. 110). Dessa forma, variáveis criadas
dentro de funções estão no escopo da função, ou seja, são variáveis
locais. Seus valores não podem ser acessados fora da função. Por sua
vez, variáveis globais podem ser criadas fora das funções e ser utilizadas
a partir do momento em que são criadas até o final do arquivo – assim,
essas variáveis têm escopo global. Porém, é possível utilizar a palavra
global para criar uma variável dentro da função que tenha escopo global.
A instrução unset(nome_variavel) exclui manualmente uma variável, não

permitindo que ela seja utilizada e retirando-a do escopo. Assim, se você
utilizar uma variável após ela ser excluída utilizando a função unset(),
um erro será gerado, exatamente do mesmo modo que é gerado erro ao
tentar utilizar uma variável não criada.
As regras do escopo fazem com que, ao passar uma variável como

parâmetro e alterarmos o valor dentro da função, essa alteração não é
replicada ao final, pois ela só é feita no escopo da função – a variável que
originou o valor passado por parâmetro não tem seu valor alterado. Essas
regras são melhores explicadas utilizando o Código 75.
www.esab.edu.br 188
Código 75 – Exemplo explicativo do escopo
01 <?php
02 function fn() {
03 $var = ‘teste interno’;
04 echo ‘fn ’. $var . ‘<br>’;
05 }
06 function fx($var){
07 echo ‘fx ’. $var . ‘<br>’;
08 $var=’novo valor’;
09 echo fx ’.$var . ‘<br>’;
10 }
11 $var = ‘teste externo’;
12 echo $var . ‘<br>’;
13 fn();
15 fx($var);
17 ?>
A execução do Código 75 se inicia no fluxo principal, que começa na

linha 11 e cria uma variável global $var com valor ‘teste externo’. Na
linha 12 escreve esse valor na tela, como retorno. A linha 13 chama a
função fn(), definida na linha 2. Essa função atribui valor a uma variável
de escopo local com nome $var, atribuindo ‘teste interno’, e retorna à
tela, escrevendo esse valor e retornando ao fluxo principal ao fim da
função. Como a alteração acontece em escopo local, ela não altera o valor
da variável global que, ao ser retornada na linha 14, retorna novamente
o valor ‘teste externo’. Na linha 15 é chamada a função fx(), passando
o valor da variável global que, nesse momento, é ‘teste externo’ como
parâmetro. Dessa forma, a primeira linha da função (linha 7) apresenta
retorno ‘teste externo’. Na linha 8 é atribuído, em escopo local, ‘novo
valor’ à variável $var, o que novamente não reflete na variável global e
é apresentado na tela com a instrução da linha 9. Dessa forma, quando
retorna ao fluxo principal, na linha 16, o valor da variável global $var
ainda é ‘teste externo’, sendo novamente apresentado e finalizando o
script. As saídas desse script podem ser vistas na Figura 42.
www.esab.edu.br 189
Figura 42 – Resultado de código demonstrando escopo.
A Figura 42 apresenta o retorno e demonstra que as alterações em escopo

local não refletem no escopo global. Com ela ficam claras essas interações
dos valores das variáveis, respeitando o escopo.
Criamos e utilizamos, nesta unidade, funções com parâmetro – de

forma a possibilitar o reuso da função, alterando o seu comportamento
ao alterar o valor do parâmetro – e vimos, também, o que é escopo,
definindo quando a variável está acessível e possibilitando o seu uso.
Porém, não utilizamos funções retornando valores. Na unidade 29
estudaremos o retorno de valores da execução de uma função. Vamos lá?
www.esab.edu.br 190
Objetivo
Apresentar o uso e as funções com passagem de parâmetros e retorno
de valores.
Nas unidades anteriores utilizamos funções, definindo-as, usando

parâmetros e estudando o escopo das variáveis. Nesta unidade veremos
como utilizar funções para retornar um valor. Para isso, teremos como
base teórica Thomson e Welling (2005). Vamos em frente!
29.1 Retornando valores de funções

Em grande parte dos casos, nossas funções devem retornar respostas ao
código quando são chamadas. Segundo Thomson e Welling (2005),
retornando valores, o código que chamou a função pode escolher como
exibir ou utilizar seu resultado (resposta). Para retornarmos a partir de
uma função, utilizamos a instrução return.
No momento no qual é encontrada essa instrução, o código é

interrompido e retornado ao fluxo principal do código que a chamou.
Caso a instrução return seja utilizada sem um valor, o código da função é
interrompido, voltando o fluxo, mas sem retornar valores ao código que
o chamou, como nos apresentam Thomson e Welling (2005).
Para retornar algum valor (resultado) da função, devemos utilizar a

instrução return seguida do valor retornado. O Código 76 demonstra
a criação e o uso de uma função somar, que recebe dois valores como
parâmetro e retorna o seu resultado.
www.esab.edu.br 191
Código 76 – Função soma retornando valores
01 <?php
02 function somar($n1, $n2) {
03 $total = $n1 + $n2;
04 return $total;
05 }
06 $termo1 = 10;
07 $termo2 = 25;
08 $soma = somar($termo1, $termo2);
09 echo $soma;
10 ?>
Na segunda linha do Código 76, é criada a função somar(), que recebe

dois parâmetros. Na linha 3 é atribuído o valor da soma dos valores
recebidos como parâmetros e esse valor à variável $total. O valor atribuído
é retornado com a instrução da linha 4. O script inicia no fluxo principal,
na linha 6, atribuindo valor 10 à variável $termo1 e, na linha 7, atribui
valor 25 à variável $termo2. A linha 8 atribui à variável $soma o valor que
retorna da função somar(), passando $termo1 e $termo2 como parâmetro.
Nesse momento, é chamada a função contida na linha 2, que retorna
o valor da soma dos parâmetros (10 e 25), ou seja, 35, atribuindo-o à
variável $soma. Em seguida, na linha 9, o fluxo de execução retorna ao
fluxo principal, escrevendo o valor da variável $soma.
Observe que, caso quiséssemos utilizar uma forma diferente do valor

retornado pela função ou usá-la para somar quaisquer outros números,
poderíamos reaproveitar o código sem que houvesse a necessidade de
uma nova escrita. Na próxima seção vamos observar como podemos
utilizar, de formas diferentes, a chamada de uma função.
29.2 Utilizando o valor retornado pela função

Como vimos, podemos utilizar de maneiras diversas o valor retornado
por uma função, inclusive em diferentes projetos, incluindo o arquivo
que contém a função.
O exemplo mostrado no Código 77 apresenta várias formas de utilização

dos valores retornados pela função soma(). Confira!
www.esab.edu.br 192
Código 77– Utilizando a função soma() de diversas formas
01 <?php
03 $total = $n1 + $n2;
04 return $total;
05 }
06 $termo1 = 10;
07 $termo2 = 25;
08 $soma = somar($termo1, $termo2);
09 echo $soma . '<br>';
10 $termo1 = 124;
11 echo somar(178, $termo1) . '<br>';
12 $soma3numeros = somar(15, somar($termo1,
21));
13 echo $soma3numeros . '<br>';
14 ?>
No Código 77 observamos que, além da forma apresentada

anteriormente (chamando a função soma(), passando o valor de
duas variáveis, atribuindo o valor de retorno à uma variável – linha
8 – e apresentando-a logo em seguida), temos outras duas formas de
passagem de parâmetro: na linha 10 atribuímos novo valor (124) à
variável $termo1. Na linha 11, o retorno da função soma – passando
como parâmetro o valor 178 e o valor da variável $termo1 (124) – é
apresentado diretamente na tela, sem a utilização de uma variável para
atribuir seu valor; é como escrever diretamente um valor qualquer. Por
sua vez, na 12ª linha, o resultado retornado da função somar – passando
valor de $termo1 (124) e valor 21 (ou seja, 124 + 21 = 145 – é usado
como segundo parâmetro de nova chamada dessa função. Dessa forma,
inicialmente é processado somar($termo1, 21), que retorna o valor
145 e, em seguida, é chamado somar(15, somar($termo1, 21)); ou
melhor, somar(15, 145), atribuindo, portanto, o valor 160 à variável
$soma3numeros, apresentada logo em seguida.
Agora, vamos desenvolver a função soma(); porém, iremos utilizá-la em

dois scripts diferentes, aplicando, assim, o seu resultado de formas distintas.
www.esab.edu.br 193
Código 78 – Função somar()
01 <?php
03 $total = $n1 + $n2;
04 return $total;
05 }
06 ?>
O Código 78 apresenta script PHP contendo a função somar();

recebendo dois valores e retornando o resultado. Salve o conteúdo desse
código com o nome “matematica.inc”, no qual vamos guardar nossas
funções matemáticas para futura reutilização.
Código 79– Utilizando a função soma() de diversas formas

loose.dtd">
02 <html>
03 <head>
05 <title>Calculadora</title>
06 </head>
07 <body>
08 <?php
09 require('matematica.inc');
10 echo '<h1>'.somar(15,20).'</h1>';
11 ?>
12 </body>
13 </html>
No Código 79, incluímos o script matemática.inc contendo a função e a

chamamos, na linha 10, apresentando o seu resultado alocado dentro de
um documento HTML. O resultado pode ser conferido na Figura 43.
www.esab.edu.br 194
Figura 43 – Resultado de código chamando função reaproveitando código de outro arquivo.
Agora, vamos construir um formulário que envia dois dados via método
post e o seu resultado é processado por um código PHP, que recebe esses
dois dados e chama a função somar(), apresentando o seu resultado.
Código 80 – Formulário para calcular

loose.dtd">
02 <html>
03 <head>
title>
06 </head>
07 <body>
08 <form action="calcula_soma.php"
09 <table border=0>
10 <tr>
11 <td> Primeiro Número: </td>
12 <td> <INPUT type="text" name=numero1
size=12> </td>
13 </tr>
14 <tr>
15 <td> Segundo Número: </td>
size=12> </td>
17 </tr>
18 </table>
20 </form>
21 </body>
22 </html>
www.esab.edu.br 195
O Código 80 apresenta a criação de um formulário HTML com dois
campos de edição de texto, que lerão os números (caixas de texto nomeadas
como numero1 e numero2, criadas respectivamente nas linhas 12 e 16) e
chamarão o script “calcula_soma.php”, que será apresentado a seguir.

loose.dtd">
02 <html>
03 <head>
title>
06 </head>
07 <body>
08 <?php
09 require ('matematica.inc');
10 $numero1 = $_POST["numero1"];
12 $soma = somar($numero1, $numero2);
13 echo '<p>'.$soma .'</p>';
14 ?>
15 </body>
16 </html>
O Código 81 apresenta script PHP que recebe duas variáveis enviadas

pelo método post e calcula a soma, utilizando a função somar() contida
no arquivo requerido matemativa.inc. Ele obtém os dois valores
recebidos através do método post (numero1 e numero2, nas linhas 10
e 11, respectivamente) e chama a função – na linha 12, passando esses
valores como parâmetro. Na linha 13, o resultado é apresentado na tela,
o qual pode ser visto na Figura 44.
www.esab.edu.br 196
Figura 44 – Resultado de código chamando função reaproveitando código de outro arquivo.
A Figura 44 apresenta, no plano inferior, o formulário que, ao ser

atribuído, chama o script PHP que processa os dados enviados. Também
apresenta, mas de forma diferente, o resultado da função somar().
Observe que, apesar da disposição distinta, a regra do funcionamento é a
mesma e foi escrita somente uma vez, ou seja, é reaproveitada.
Nas últimas unidades, vimos como utilizar funções predefinidas, criar

e usar funções com parâmetros e utilizar seu retorno. Dessa forma,
devemos fixar os conteúdos com o desenvolvimento de uma aplicação
prática. Vamos lá?
www.esab.edu.br 197
Desenvolvendo aplicação
30 utilizando funções
Objetivo
aprendidos nesta unidade, utilizando funções.
Nas unidades anteriores, utilizamos funções predefinidas pelo PHP,

criamos funções próprias, lançamos mão de funções com parâmetros e
usamos o seu retorno, fortalecendo questões de estruturação de código,
reaproveitamento e reuso. Nesta unidade vamos desenvolver uma
calculadora, de modo a fixar o aprendizado. Vamos tomar como base os
autores Thomson e Welling (2005). Vamos lá?
30.1 Desenvolvendo a tela de uma calculadora

Para o desenvolvimento de uma tela de calculadora, vamos elaborar
cabeçalhos e rodapés padronizados e usar instrução para reaproveitá-los,
seguindo noções apregoadas por Thomson e Welling (2005) e vistas na
unidade 25. O Código 82 apresenta um cabeçalho padronizado.
www.esab.edu.br 198
Código 82 – Cabeçalho padronizado
loose.dtd">
02 <html>
03 <head>
05 <style>
align:center}
align:center}
08 .dados { font-size:12pt; text-align:left}
09 </style>
10 </head>
11 <body>
13 <tr bgcolor=black>
16 </td>
17 <td>
18 <h1> Sistema Web Teste </h1>
19 </td>
20 </tr>
O Código 82 apresenta o cabeçalho que será utilizado pelas telas de nossa

calculadora, o qual define os estilos usados (linhas 5 a 9). Ele também
determina uma tabela, que possui, em suas células, uma imagem (que
é usada no link) e um título. Novamente, não foram fechadas as tags
<html> e <body>, que serão fechadas no rodapé. Salve o Código 82
como header.inc.
www.esab.edu.br 199
Código 83 – Rodapé padronizado
01 <table width=100% bgcolor=black border=0>
02 <tr>
Egon Sewald Junior </td>
04 </tr>
05 </body>
06 </html>
O Código 83 apresenta uma nova tabela, com uma célula de “créditos”

e o fechamento das tags <body> e <html>, nas linhas 5 e 6, abertas no
código header.inc. Salve o código como footer.inc. Os códigos presentes
no header.inc e no footer.inc serão utilizados nos códigos seguintes, com
o intuito de reutilizar e padronizar.
O Código 84 apresenta o formulário para a leitura dos dados da

calculadora, obtendo dois números e a operação a ser realizada.
www.esab.edu.br 200
01 <?php require('header.inc');?>
02 <form action="calcula.php" method="POST"
id=form_bebida>
03 <table border=0>
04 <tr>
05 <td> Primeiro Número: </td>
size=12> </td>
07 </tr>
08 <tr>
09 <td> Segundo Número: </td>
size=12> </td>
11 </tr>
12 <tr>
13 <td> Operacao: </td>
14 <td>
15 <table>
16 <tr><td><input name="operacao"
type="radio" value="Soma" />Soma</td></tr>
type="radio" value="Subtração" />Subtração</
td></tr>
type="radio" value="Multiplicação"
/>Multiplicação</td></tr>
type="radio" value="Divisão" />Divisão</
td></tr>
20 </table>
21 </td>
22 </tr>
23 </table>
25 </form>
26 <?php require('footer.inc');?>
O Código 84 apresenta um formulário com dois inputs do tipo caixa de

texto, que fazem leitura de dois números, e um input do tipo radio, com
quatro opções que fazem a leitura da operação. Observe que o código de
cabeçalho (constante no arquivo header.inc) é requerido e reaproveitado
na linha 1, e que o rodapé é requerido na linha 26 (constante no arquivo
footer.inc). Na linha 2 do código 84, a ação do formulário pelo método
post chama um código calcula_processa.php. que será responsável por
www.esab.edu.br 201
receber os dados enviados e chamar as funções que efetuam os cálculos.
Salve esse código com o nome calculadora_Formulario.php, para que,
após o desenvolvimento do script que efetua o processamento dos
cálculos, possamos executar. O desenvolvimento dessas funções será
visto na sequência.
30.2 Desenvolvendo funções para operações

matemáticas simples
Para que possamos fazer uso (e reuso, caso necessário) dessa
ferramenta, podemos desenvolver scripts com funções matemáticas,
disponibilizando-as. O Código 85 apresenta as funções matemáticas de
somar, subtrair, multiplicar e dividir.
Código 85 – Funções matemáticas

01 <?php
03 return $n1 + $n2;
04 }
05 function subtrair($n1, $n2) {
06 return $n1 - $n2;
07 }
08 function multiplicar($n1, $n2) {
09 return $n1 * $n2;
10 }
11 function dividir($n1, $n2) {
12 if ($n2 == 0){
13 return 'Não é possível dividir por 0';
14 } else {
15 return $n1 / $n2;
16 }
17 }
18 ?>
O Código 85 apresenta script com as quatro funções matemáticas a

serem utilizadas em nossa calculadora. Observe que a função dividir()
testa se o segundo número é zero, retornando uma mensagem. Além
disso, todas as funções utilizam-se de duas variáveis as quais espera-se que
sejam dois números. Salve esse código como matematica.inc.
www.esab.edu.br 202
Mais adiante iremos tratar exceções, evitando que esse tipo de erro (como
o de divisão por zero) seja mostrado na tela e interrompa a execução do
aplicativo.
No entanto, ainda devemos desenvolver o código que faz o

processamento (recebe as variáveis enviadas pelo método post) e que
executa as funções conforme a operação selecionada.
30.3 Desenvolvendo a chamada das funções e

resultado
Já elaboramos o formulário de seleção dos valores e operação e as funções
matemáticas para criar nossa calculadora. Porém, ainda é necessário o
desenvolvimento de código que processe os valores e a operação e que
devolva o resultado final, o que é feito no Código 86.
www.esab.edu.br 203
Código 86 – Processamento das operações e resultado
01 <?php
04 $operacao = $_POST["operacao"];
05 require ('matematica.inc');
06 switch ($operacao){
07 case $operacao == "Soma":
08 $resultado = somar($numero1, $numero2);
09 $sinal = '+';
10 break;
11 case $operacao == "Subtração":
12 $resultado = subtrair($numero1, $numero2);
13
14 break;
15 case $operacao == "Multiplicação":
16 $resultado = multiplicar($numero1,
$numero2);
17 $sinal = '*';
18 break;
19 case $operacao == "Divisão":
20 $resultado = dividir($numero1, $numero2);
21 $sinal = '/';
22 break;
23 }
26 echo '<tr>';
27 echo '<td> O resultado da operação '.
$numero1 .' '. $sinal . ' '. $numero2 .' é
</td>';
28 echo '<td>'.$resultado.'</td>';
29 echo '</tr>';
31 ?>
O Código 86 obtém as três variáveis enviadas pelo método post, como

pode ser visto nas linhas 2 a 4. Testando o valor da variável obtida, que
contém a operação, é apontada a função (contida no arquivo matematica.
inc), que deve ser executada. O resultado respectivo é atribuído à variável
$resultado. Em seguida, o processamento e o resultado da operação
matemática definem o cabeçalho na linha 24 e apresentam, em uma
www.esab.edu.br 204
tabela, o resultado (criado entre as linhas 25 e 29), além de definir o
rodapé junto à linha 30. Salve esse código como calcula.php, nome
utilizado para chamar o Código 84.
O resultado dos códigos, em conjunto, pode ser visto na Figura 45.
Figura 45 – Resultado da calculadora com uso de funções.

A Figura 45 apresenta, em primeiro plano, a tela de seleção dos valores

e operação (referente ao Código 84, que salvamos como calculadora_
formulario.php) e, em segundo plano, o resultado do processamento
após a execução, chamando o script calcula_processa.php, equivalente
ao Código 86. Observe que as operações utilizam (reutilizam) código de
cabeçalho e rodapé (Códigos 82 e 83, respectivamente), o que também é
feito na utilização de funções (reutilizando o Código 85).
Nas últimas unidades, vimos como utilizar funções predefinidas, como

criar e usar funções com parâmetros e como usar o seu retorno. Também
desenvolvemos uma calculadora aplicando esses conceitos. Nas próximas
unidades veremos conceitos de orientação a objeto, também relacionados
à estruturação e à reutilização de código.
www.esab.edu.br 205
Resumo
Na unidade 25, foram abordados os motivos que levaram à preocupação

com o custo e com o reuso de código. Vimos, também, os benefícios
e exemplos de tal reutilização. Também pudemos observar o uso da
instrução require() para aproveitar códigos, sejam eles documentos
HTML, scripts PHP, folha de estilos etc.
Na unidade 26, vimos como estruturar o código por meio de funções, com
o objetivo de melhorar o entendimento e facilitar o reaproveitamento dos
códigos escritos. Estudamos o conceito de funções e sub-rotinas e algumas
funções predefinidas na linguagem PHP, de uso comum.
Após utilizarmos funções predefinidas, pudemos, na unidade 27,

observar que um dos grandes poderes de uma linguagem é a possibilidade
de desenvolver e de reutilizar as próprias funções. Vimos, então, como
escrever funções próprias para estruturar o nosso código e facilitar o
reuso, e também aprendemos como utilizar essas funções.
Na unidade 28, estudamos como usar funções com parâmetros, os quais

alteram o comportamento das funções, porém, possibilitam o reuso,
fundamentando o seu comportamento nesses parâmetros.
As funções que retornam valores como resultado foram abordadas na

unidade 29, de forma que o código que as chamou possa escolher como
exibir ou utilizar o resultado (resposta) da função. Vimos que, para
retornarmos a partir de uma função, utilizamos a instrução return.
Na unidade 30, desenvolvemos uma calculadora, fixando os conteúdos,

reaproveitando cabeçalho e rodapé, bem como processando as operações
matemáticas através de funções em um arquivo requerido.
www.esab.edu.br 206
31 Utilizando orientação a objetos
Objetivo
Apresentar conceitos de orientação a objeto e a sua aplicação para
reaproveitar código.
Nas unidades anteriores pudemos observar a importância da estruturação

e da reutilização de código e, para isso, utilizamos funções. Nesta e nas
próximas unidades, vamos estudar o conceito de orientação a objeto, de
modo a estruturar o código de uma forma diferente e ampliar o reuso.
Para isso, utilizaremos como base teórica Thomson e Welling (2005).
Vamos lá?
31.1 Conceitos básicos de orientação a objeto

Quando desenvolvemos sistemas ou aplicativos, devemos sempre
procurar entender conceitos fundamentais das funções e ações que
acontecem no mundo para automatizar e desenvolver os algoritmos. Por
exemplo, em um aplicativo de calculadora, o computador deve executar
exatamente a mesma operação e utilizar os mesmos métodos usados por
seres humanos ao efetuar esses cálculos (os resultados de uma mesma
operação realizada no mundo real com bananas ou na calculadora
desenvolvida com uso de computadores devem ser os mesmos). Dessa
forma, a programação da calculadora concentra-se em entender as ações
(do mundo) e executa as operações e funções da mesma forma.
Um dos paradigmas de desenvolvimento de software é a Orientação

a Objetos (OO). A Orientação a Objetos tem aplicação de conceitos
originados do estudo da cognição, de forma a explicar e abstrair o
mundo real observando seus objetos e classificando-os por similaridade.
E a quais objetos estaríamos nos referindo?
www.esab.edu.br 207
Num contexto de software OO, um objeto pode ser quase qualquer item ou conceito –
um objeto físico como uma escrivaninha ou um cliente; ou um objeto conceitual que
só exista no software, como uma área de entrada de texto ou um arquivo. Geralmente,
estamos mais interessados em objetos conceituais incluindo objetos do mundo real que
precisam ser representados no software. (THOMSON; WELLING, 2005, p. 117)
Assim, se tivermos o cadastro de Ana, que é um cliente registrado em

nosso sistema, por exemplo, podemos dizer que Ana é um objeto.
João, outro cliente, também é um objeto. Não se preocupe se o termo
objeto pode ou não ser pejorativo quando aplicado a pessoas, pois, nesse
paradigma, tudo que abstrairmos seria objeto. Acompanhe, a seguir, o
processo de representação de Objetos reais (Figura 46).
Objetos reais Representação dos Objetos
Cliente
Cliente Conta
Conta
Agência
Agência
Figura 46 – Representação de Objetos reais.
A Figura 46 apresenta representações desses objetos, com os atributos

e comportamentos dos objetos do mundo real. Essa representação para
entendimento das ações é chamada de Abstração.
Outros dois conceitos relacionados à orientação a objetos são os atributos

e as operações.
O software orientado a objeto é projetado e construído com um conjunto de objetos

autocontidos tanto com atributos como com operações que interagem para atender
às nossas necessidades. Os atributos são propriedades ou variáveis que se relacionam
ao objeto. As operações são métodos, ações ou funções que o objeto pode realizar
para modificar a si próprio ou para algum efeito externo. (THOMSON; WELLING, 2005,
p. 118)
www.esab.edu.br 208
Ao retomarmos o exemplo anterior, João e Ana (dois objetos) têm
comportamentos em comum (se são clientes, fazem compras, pagam
pelas suas compras etc.). Nesse caso, essas operações, em OO, são
chamadas de métodos. João e Ana devem, ainda, ter informações comuns
preenchidas em seu cadastro (como nome, endereço, telefone, cidade,
limite de crédito etc.). A essas características em comum, em OO, damos
o nome de atributos. Podemos ainda dizer que João e Ana são objetos
(instâncias) da mesma classe (classe Cliente).
Apesar de a orientação a objetos ter se tornado norma em outras

áreas de desenvolvimento (pela força dessa padronização), para o
desenvolvimento web ainda observamos muitos projetos orientados às
funções. A maioria dos projetos web em linguagens scripts é utilizada
dessa forma (orientada a funções e com pouca preocupação com reuso
de código), pois se tratam de páginas com hiperlinks. Porém, aplicações
mais complexas, que necessitem de maior reutilização de código e que
possuam o objetivo de diminuir custos de manutenção, devem utilizar
conceitos como a orientação a objetos.
Como mostrado no exemplo de João e Ana, os objetos podem ser

agrupados em classes. Em uma classe, os objetos devem ter o mesmo
comportamento (métodos) e, apesar da existência de características
que diferem um indivíduo (objeto) do outro, devem ter quantidade de
atributos em comum, que representem a mesma coisa, embora os valores
destes variem de acordo com cada indivíduo. Ao criarmos objetos, a
partir de definição de classe, estamos criando instâncias de uma classe
(que deve receber valores aos atributos definidos).
www.esab.edu.br 209
Classe Cliente Objetos (instâncias) de Cliente
Cliente Joao: Cliente
nome: String nome: Joao
endereço: String endereço: Rua J
cpf: int
alteraNome() Ana: Cliente
alteraEndereco() nome: Ana
alteraCpf() endereço: Rua A
forneceNome()
forneceEndereco()
forneceCpf()
Figura 47 – Representação de objetos reais.
Fonte: http://www.thiagocolares.com.br/?p=261.
A Figura 47 demonstra, ao lado esquerdo, a definição da Classe Cliente,

seus atributos e métodos; ao lado direito apresenta exemplos de objetos
(instâncias) da classe Cliente (Ana e João), cada objeto com suas
definições de atributos.
Segundo Thomson e Welling (2005), uma linguagem é orientada a objeto,

ou seja, permite a Programação Orientada a Objeto (POO), quando
atende aos requisitos de herança, de polimorfismo, de encapsulamento, de
abstração e de associação, além de possibilitar a criação de classes e objetos
(que dizemos ser instâncias da classe à qual pertence).
Vamos conhecer mais profundamente cada um dos requisitos citados.
A herança é o mecanismo que permite uma classe estender uma classe

maior, dando a ela maior especificidade, porém, herdando todos os
seus atributos e métodos. Imagine que, em seu sistema, além da classe
Cliente, temos a classe Fornecedor, que tem vários atributos em comum
(nome, endereço, cidade, telefone) com a classe Cliente. Dessa forma,
criamos uma superclasse Pessoa com os atributos (nome, endereço,
cidade, telefone) e métodos comuns às classes Cliente e Fornecedor.
Assim, a superclasse Pessoa pode herdar os métodos e atributos
específicos daquelas duas outras classes. Por exemplo, a classe Cliente
deve conter o atributo limite de crédito, que não faz parte da classe
www.esab.edu.br 210
Fornecedor; então, caso necessite de alguma manutenção ou alteração
que seja pertinente às classes herdadas, pode-se desenvolvê-las somente
na superclasse (Pessoa) e essas modificações farão efeito nas classes
herdadas (Cliente e Fornecedor), facilitando, dessa forma, a alteração.
Abstração é quando nos concentramos nos aspectos essenciais de um

contexto qualquer, ignorando características menos importantes ou
acidentais. Pessoa, por exemplo, é uma classe abstrata que contém os
aspectos essenciais e comuns entre as classes herdadas.
Quando utilizamos herança, dizemos que a classe abstrata é uma

superclasse e que a classe que herda dela é uma subclasse.
O polimorfismo significa que classes diferentes podem ter comportamentos

diferentes para a mesma operação. Por exemplo, podemos dizer que a
classe Pessoa tem uma operação abstrata “liquida conta”, que consiste
no pagamento do saldo financeiro. Porém, a classe Cliente implementa
essa operação, baixando contas referentes a compras feitas (como quando
João paga sua conta devida), o que aumenta o valor da conta corrente
da empresa. A classe Fornecedor, por sua vez, quando aplica a operação
“liquida conta”, deve receber o valor referente aos produtos fornecidos, ou
seja, diminui o valor da conta corrente da empresa.
O encapsulamento refere-se a deixar “escondidos” os aspectos que se

referem aos objetos (métodos e atributos), possibilitando somente a
chamada, por outros objetos (de outras classes), daqueles que fazem parte
de uma interface. Segundo Thomson e Welling (2005), esta é a principal
vantagem da orientação a objeto, além de possibilitar que o acesso aos dados
de dentro do objeto seja feito através de operações do objeto (interface).
Por sua vez, a associação é a utilização de recursos de um objeto por

outro, ou seja, cria um relacionamento entre as duas classes, podendo ser
uma utilização ou uma definição de parte de (composição).
Na próxima seção utilizaremos um exemplo de herança, demonstrando o

reaproveitamento de código.
www.esab.edu.br 211
31.2 Como herdar uma classe reaproveitando código
Imagine que você deva escrever uma aplicação web para controlar contas
bancárias. Qualquer conta bancária deve ter informações (atributos)
como número da conta, agência, nome do correntista e saldo (valor
monetário que se encontra depositado na conta), e deve apresentar,
como operação (método), o saldo disponível para saque. Para uma
conta corrente normal, o saldo disponível é exatamente o saldo da
conta. Porém, observamos a existência de conta especial, que deve ter
a informação de limite de crédito (ou limite de cheque especial), sendo
que, nesse caso, a operação que apresenta o saldo disponível para saque
deve considerar o saldo da conta somado ao valor do limite de crédito.
Para explicar e demonstrar graficamente, vamos usar o diagrama de

classes da UML, que podemos ver na Figura 48.
Conta
$numero:Integer
$agencia:Integer
$nomeCorrentista:String
$saldo:float
apresentarSaldoDisponível()
ContaNormal ContaEspecial
$limite:float
Figura 48 – Diagrama de classes.

No diagrama de classes, cada “caixinha” representa uma classe e contém

três grupos de informações: nome da classe, seus atributos e seus
métodos. A relação apresentada entre as classes que se encontram na
parte mais baixa da Figura 48 determinam herança ou especificação.
Além disso, a figura apresenta uma classe abstrata Conta (com
atributos numero, agencia, nomeCorrentista e saldo) e método abstrato
(apresentarSaldoDisponivel). Traz, ainda, duas classes herdadas:
www.esab.edu.br 212
ContaNormal e ContaEspecial. A ContaNormal herda os atributos
de Conta e implementa apresentarSaldoDisponivel, apresentando o
valor equivalente ao atributo saldo. A classe ContaEspecial, além de
herdar os atributos de Conta, inclui o atributo limite e implementa
apresentarSaldoDisponivel, apresentando o valor equivalente à soma de
saldo e limite.
Agora, observe que não foram implementadas operações referentes a

depósito e saque. O depósito deve somar um valor ao saldo e o saque
deve diminuir um valor ao saldo. Essas operações (saque e depósito)
são realizadas, da mesma forma, para contas normais e especiais. Logo,
podemos implementar (alterar os códigos, nesse caso, adicionando) os
métodos depositar() e sacar() somente na classe Conta (superclasse),
ação que também afetará as classes que herdam (ContaNormal e
ContaEspecial, nesse caso), como pode ser visto na Figura 49.
Conta
$numero:Integer
$agencia:Integer
$nomeCorrentista:String
$saldo:float
apresentarSaldoDisponível()
sacar($valor:float)
depositar($valor:float)
ContaNormal ContaEspecial
$limite:float
Figura 49 – Diagrama de Classes.

www.esab.edu.br 213
A Figura 49 apresenta as alterações relativas à implementação dos métodos
saque e depósito. Observe que, mudando somente a classe Conta, não é
necessário modificar as classes herdadas. Levando em conta que o banco
tenha vários tipos de contas, podemos concluir que economizaríamos
muito tempo de desenvolvimento ao mudar somente a classe Conta. Logo,
podemos dizer que reaproveitamos o código da classe Conta.
Na unidade 32 vamos aplicar esse conhecimento, desenvolvendo classes

em PHP e utilizando os conceitos de Orientação a Objeto, escrevendo
classes e usando a herança.
Fórum
www.esab.edu.br 214
32 Escrevendo classes com herança
Objetivo
Apresentar exemplo prático de herança, propriedade importante da
orientação a objeto.
Na unidade 31 estudamos conceitos de orientação a objetos, tais como

atributos, métodos e classes, utilizados para estruturar e ampliar o reuso
de código. Nesta unidade vamos criar uma superclasse e herdá-la, de
forma a demostrar o código reusado. Novamente nos basearemos na obra
de Thomson e Welling (2005). Vamos em frente!
32.1 Escrevendo uma superclasse

Na unidade 31 vimos, de maneira conceitual e abstrata, conceitos
de orientação a objetos. Vamos, neste instante, criar uma classe em
PHP, visto que qualquer classe pode se tornar uma superclasse, ao ser
estendida. O foco é definir uma classe e, posteriormente, utilizar uma
subclasse estendida.
A estrutura mínima de uma classe pode ser observada no Código 87.
Código 87 – Estrutura mínima de uma classe

01 class NomeDaClasse
02 {
03 }
O Código 87 apresenta apenas a definição simples de uma classe. A

palavra class é seguida do nome da classe, como podemos ver na primeira
linha. Seus atributos e métodos devem ser escritos internamente aos
símbolos { e }, presentes nas linhas 2 e 3 (que significam início e fim,
assim como em funções ou blocos de comando).
www.esab.edu.br 215
Os atributos são criados como variáveis dentro do bloco de definição
da classe, precedida pela palavra var. Já os métodos devem ser definidos
como funções, também dentro do bloco de definição da classe. Observe o
Código 88, que apresenta uma classe com dois atributos e dois métodos:
Código 88 – Estrutura de uma classe com dois atributos e dois métodos

01 class NomeDaClasse
02 {
03 var $atributo1;
04 var $atributo2;
05 function metodo1()
06 {
07 }
08 function metodo2($parametro1, $parametro2)
09 {
10 }
11 }
Dica
Apesar de não se tratar de uma definição
obrigatória, normalmente utiliza-se nomes de
classes iniciadas com letras maiúsculas e atributos
e métodos com letras minúsculas. Também se
usa letra maiúscula na separação de palavras que
definem o nome da variável, como para classes
(NomeDaClasse), e também para atributos e
métodos (nomeDoAtributo).
A classe definida no Código 88 tem atributos e métodos, porém, estes

não executam nenhuma instrução: sua criação tem como objetivo
demonstrar a estrutura básica de uma classe (estrutura que pode ser
herdada). Observe que o método metodo1(), definido na linha 5, não
recebe parâmetros, e que o método metodo2(), definido na linha 8,
recebe dois parâmetros para a sua execução. Os conhecimentos obtidos
sobre função são aplicados aos métodos da classe, bem como a forma
de aplicar parâmetros (utilizamos da mesma forma os parâmetros
www.esab.edu.br 216
de funções e parâmetro métodos). Assim, o metodo2() deve receber
dois parâmetros; caso contrário (utilizar com número diferente de
parâmetros), apresentará um erro. Para utilizar ou atribuir o valor de
um atributo, você tem acesso a uma variável especial chamada $this.
Thomson e Welling (2005, p. 121, grifo dos autores) complementam que
“[...] se um atributo de sua classe se chama $attribute, você o referencia
como $this->attribute quando configurar ou acessar a variável a partir de
operação dentro da classe.” Dessa forma, seguindo o exemplo da classe
Conta, apresentado na unidade 31 por meio da Figura 48, definimos a
classe Conta no Código 89. Observe.
Código 89 – Estrutura da classe Conta

01 class Conta
02 {
03 var $numero;
04 var $agencia;
05 var $nomeCorrentista;
06 var $saldo;
07 function apresentarSaldoDisponivel ()
08 {
09 echo $this->saldo;
10 }
11 function depositar ($valor)
12 {
13 $this->saldo = $this->saldo + $valor;
14 }
15 function sacar ($valor)
16 {
17 $this->saldo = $this->saldo - $valor;
18 }
19 }
No Código 89 o nome da classe é definido após a palavra class,

conforme a linha 1. Das linhas 3 a 6 são definidos os atributos
$numero, $agencia, $nomeCorrentista e $saldo. A linha 7 cria o método
apresentarSaldoDisponivel(), que, na linha 9, apresenta na tela (através
do echo) o valor que conta no atributo $saldo dessa classe. Da mesma
forma, os métodos depositar, definidos na linha 11, e sacar, linha 15,
recebem, como parâmetro, um valor que altera o valor da variável $saldo,
somando ou diminuindo, conforme o caso.
www.esab.edu.br 217
Para utilizar um objeto, devemos criar instância de uma classe. Por
exemplo, para criar a conta de João, devemos criar um objeto – o que
chamamos de instância – da classe Conta (mais tarde, veremos que
Conta é uma classe abstrata e que não pode ser instanciada, porém,
nesse momento, quando não utilizamos a herança, o exemplo é valido).
Para isso, devemos inicializar os atributos principais com os valores
desse novo objeto, passando parâmetros à instrução new, conforme a
definição de método especial chamado construtor (ou constructor, do
inglês). O construtor é executado no momento que se cria (instancia)
o objeto e “[...] normalmente ele realiza tarefas úteis de inicialização,
como configurar atributos com valores iniciais sensíveis ou criar outros
objetos necessários para esse objeto” (THOMSON; WELLING, 2005,
p. 121). Caso a classe não tenha um construtor definido, um objeto da
classe é criado sem inicialização de atributos, e não devem ser utilizados
parâmetros à instrução new.
Os construtores são declarados da mesma forma que outros métodos,

porém, têm o mesmo nome da classe; assim, os construtores são
chamados automaticamente quando o objeto dessa classe é criado.
Por exemplo, para criar um objeto do tipo conta, devemos definir os
atributos $numero, $agencia, $nomeCorrentista e $saldo, conforme
consta no Código 90. Acompanhe:
Código 90 – Construtor da classe Conta

01 function Conta ($numero, $agencia,
$nomeCorrentista, $saldoInicial)
02 {
03 $this->numero = $numero;
04 $this->agencia = $agencia;
05 $this->nomeCorrentista = $nomeCorrentista;
06 $this->saldo = $saldoInicial;
07 }
Para criar um objeto da classe Conta deve-se passar, como parâmetro,

valores para número, agência, nome do correntista e saldo inicial da
conta, nessa ordem (como definimos na linha 1 do Código 90), sendo
atribuídos os valores às variáveis $numero, $agencia, $nomeCorrentista e
$saldoInicial. A linha 3 atribui ao atributo $numero do objeto (acessado
www.esab.edu.br 218
através de $this->numero) o valor do parâmetro $numero. Da mesma
forma, nas linhas 4, 5 e 6 do Código 90, são atribuídos valores aos outros
atributos do objeto ($this->agencia, $this->nomeCorrentista e $this-
>saldo). Caso não tenha sido definido construtor para a classe, o objeto é
criado sem valores ou inicialização de variáveis.
Apesar de ainda não criar (instanciar) objetos dessa classe, ao

acrescentarmos o construtor (constante no Código 90) à classe
definida no Código 89, possibilitamos a criação dos objetos. Porém, no
exemplo definido na unidade 31, a classe Conta é abstrata e tem duas
especificações (heranças). Uma delas (ContaNormal) será definida na
próxima seção.
32.2 Escrevendo uma classe herdando a superclasse

Para definir uma classe herdando atributos e métodos definidos na
superclasse, utilizamos o termo extends, como apresentado no Código 91.
Código 91 – Estrutura da classe ContaNormal

01 class ContaNormal extends Conta
02 {
03 }
O Código 91 mostra a definição da classe ContaNormal, que herda

os atributos e os métodos de Conta. Caso tenhamos que desenvolver
atributos ou métodos específicos para a classe estendida, eles devem ficar
de modo interno aos símbolos { e }.
Ao herdar os atributos, a criação de um objeto do tipo ContaNormal

deve ser feita respeitando as regras (e definição de parâmetros) do
construtor definido em Conta.
Para criar um objeto instanciando uma classe, utilizamos a instrução

new sucedido pelo nome da classe do objeto. Caso a classe tenha um
construtor definido com parâmetros, a instrução new deve receber os
parâmetros definidos; ou “()” caso não tenha definição de parâmetros
para construtor, ou a classe não tenha um construtor definido.
www.esab.edu.br 219
Para criarmos um objeto da classe ContaNormal (a conta do João, por
exemplo), atribuímos a uma variável o objeto criado com a instrução
new, como, por exemplo, contaJoao = new ContaNormal(10003, 2345,
‘João’, 4500.00);. O comando apresentado cria um objeto da classe
ContaNormal, com o número 10003, a agência 2345 e com saldo inicial
de R$ 4.500,00, cujo correntista chama-se João, e atribui à variável
contaJoao um apontador desse objeto criado.
A partir do momento em que o objeto é instanciado, seus métodos e

atributos podem ser utilizados dependendo de sua visibilidade, o que
veremos adiante.
32.3 Utilizando métodos e propriedades da

superclasse
A partir do momento em que criamos um objeto de uma classe,
podemos utilizar seus métodos e acessar ou atribuir valor às suas
propriedades. Após criar o objeto (e atribuir a ele uma variável), podemos
utilizar seus atributos usando o nome do objeto criado, seguido dos
símbolos “->” e do nome do atributo ou método. Ou seja, se criarmos o
objeto contaJoao = new ContaNormal(10003, 2345, ‘João’, 4500.00);,
podemos obter os valores de saldo (isso depende da visibilidade, como
veremos adiante) usando contaJoao->saldo ou efetuar um depósito
(de R$ 400 reais) nessa conta, utilizando o método depositar() usando
contaJoao->depositar(400);.
Para que você compreenda melhor esse processo, o Código 92 apresenta

um exemplo de definição de classes Conta (superclasse) e ContaNormal
(que herda de Conta), bem como cria um objeto $contaJoao da classe
ContaNormal efetuando operações, atribuindo valores e chamando
métodos dessa classe, referenciando o objeto apontado por contaJoao.
Observe com atenção.
www.esab.edu.br 220
Código 92 – Exemplo de uso de Classes, instanciando objetos e chamando métodos
01 <?php
02 class Conta{
03 var $numero;
04 var $agencia;
05 var $nomeCorrentista;
06 var $saldo;
07 function apresentarSaldoDisponivel(){
08 echo $this->saldo . '<br>';}
09 function depositar ($valor){
10 $this->saldo = $this->saldo + $valor;}
11 function sacar ($valor){
12 $this->saldo = $this->saldo - $valor;}
13 function Conta ($numero, $agencia,
$nomeCorrentista, $saldoInicial){
14 $this->numero = $numero;
15 $this->agencia = $agencia;
16 $this->nomeCorrentista = $nomeCorrentista;
17 $this->saldo = $saldoInicial;}
18 }
19 class ContaNormal extends Conta{ }
20 $contaJoao = new ContaNormal(10003, 2345,
'João', 4500.00);
21 $contaJoao->apresentarSaldoDisponivel();
22 $contaJoao->depositar(200);
23 $contaJoao->apresentarSaldoDisponivel();
24 ?>
No Código 92 é definida a classe Conta, seus atributos e métodos

(como já mostrado anteriormente) e ContaNormal (que herda de
Conta). Observe que a class ContaNormal não tem métodos e atributos
definidos, mas herda os métodos e atributos definidos na superclasse
Conta – nas próximas unidades vamos criar novos métodos, mas
neste momento, você deve entender que os métodos e atributos são
herdados. Assim, na linha 20 inicia-se o fluxo principal de execução,
criando um objeto $contaJoao da classe contaNormal com valores
de inicialização (levando em consideração que são herdados métodos
da superclasse, inclusive seu construtor, executado no momento da
instância do objeto, com a instrução new). Neste momento, o valor do
atributo $saldo é atribuído com valor 4500. Na linha 21, é chamado o
método apresentarSaldoDisponivel(), definido na superclasse Conta (nas
www.esab.edu.br 221
linhas 7 e 8), sem parâmetros de entrada, executando comando echo e
apresentando o valor do atributo $saldo (que, nesse momento, é 4500).
Na linha 22 é chamado o método depositar, passando como parâmetro
valor 200, que é, portanto, como definido na linha 10, somado ao
atributo $saldo, que passa a ter valor 4700. Novamente é chamado o
método apresentarSaldoDisponivel(), que apresenta, na tela, valor 4700.
Você observou como criar uma classe e utilizar a herança. Porém, foi
possível notar que a classe que herdou atributos e métodos não criou
novos atributos ou novos métodos, tampouco alterou o comportamento
de um método. Na unidade 33 vamos herdar uma classe que efetue essas
alterações, sobrecarregando e sobrescrevendo métodos.
www.esab.edu.br 222
Escrevendo classe,
33 sobrecarregando e sobrescrevendo
métodos
Objetivo
Apresentar exemplo prático de herança, sobrescrevendo e
sobrecarregando métodos da superclasse.
Na unidade 32 utilizamos herança criando uma superclasse e lançando

mão de seus métodos e definição de atributos. Nesta unidade vamos
sobrecarregar e sobrescrever métodos nas subclasses. Para isso,
utilizaremos as concepções teóricas de Thomson e Welling (2005).
33.1 Visibilidade dos atributos e métodos

Para falarmos de sobrecarga devemos, antes, entender a visibilidade,
a qual possibilita o encapsulamento (quesito que oculta o código não
acessível por outras classes). Segundo Thomson e Welling (2005), você
pode utilizar modificadores private e protected para controlar o que é
herdado; assim, se um atributo ou método é atribuído como private,
ele não pode ser utilizado/alterado, sendo acessível somente pela classe
que o define. Caso o atributo ou método seja atribuído como protected,
ele poderá ser acessado tanto pela classe que a define quanto pelas suas
classes estendidas (filhas). Os métodos e atributos públicos podem ser
chamados por qualquer outra classe ou parte do código.
Normalmente não se deixa os atributos disponíveis para acesso público

(public), mantendo-os como privados (private) ou protegidos (protected)
e definindo interfaces (utilizando métodos públicos get e set) para
escrever ou ler seus valores, como pode ser verificado no exemplo do
Código 93.
www.esab.edu.br 223
Código 93 – Estrutura da classe Conta, com modificadores de acesso
01 class Conta
02 {
03 private $saldo;
04 public setSaldo($value){
05 $this->saldo = $value;
06 }
07 public getSaldo (){
08 return $this->saldo;
09 }
O Código 93 apresenta uma nova definição, a de visibilidade, na qual

o atributo $saldo é privado, ou seja, não pode ser acessado por outra
classe, mas somente por objetos da classe Conta. Na classe são definidos,
porém, métodos públicos para escrever e recuperar o valor desse atributo
(definir interface), de forma a possibilitar sua escrita e recuperação a
partir de outras classes. Isso permite que sejam feitas validações, testes
ou definições de regras de negócios referentes a esse atributo, sem que
isso “apareça” para as outras classes que as utilizam, uma vez que essas
operações ficam ocultas ou encapsuladas.
33.2 Sobrecarregando métodos

A sobrecarga em PHP é diferente da apresentada por outras linguagens
– em outras linguagens a sobrecarga permite escrever métodos com
o mesmo nome, mas com tipos diferentes ou número diferente de
atributos, e a escolha entre os métodos com o mesmo nome (chamar
um ou outro método), se dá pelo número de parâmetros utilizados. Na
PHP, a sobrecarga provê recursos para “criar” dinamicamente atributos
ou métodos, ou seja, ler e escrever atributos não acessíveis (não definidos
na Classe). Essas entidades dinâmicas são processadas por métodos que
estabelecem ações relativas a esses atributos não acessíveis. Por exemplo,
o método __set() é executado ao se escrever dados (atributos) para
membros inacessíveis. Ele solicita dois parâmetros, sendo o primeiro o
nome do atributo e o segundo o valor a ser atribuído a ele.
www.esab.edu.br 224
O Código 94 apresenta o uso do __get e __set em dados não acessíveis.
Observe.
Código 94 – Exemplo de sobrecarga

01 <?php
02 class Teste {
03 var $dados;
04 public function __set($name, $value)
05 {
06 echo "Setando $name com valor $value
<br>";
07 $this->dados[$name] = $value;
08 }
09 public function __get($name)
10 {
11 return $this->dados[$name];
12 }
13 }
14 $objetoTeste = new Teste();
15 $objetoTeste->a = 10;
16 echo "Obtem valor ". $objetoTeste->a;
17 ?>
O Código 94 define uma classe com o nome Teste, que tem um atributo
privado (logo, não acessível) chamado dados. Apresenta que, ao setar
atributos inacessíveis (atributos que não foram definidos na classe,
como chamado na linha 15), chamará o método __set(), atribuindo o
valor à variável com o nome definido (nesse caso, “a”). Por sua vez, ao
chamar __get(), obtém o valor desse mesmo dado com nome “a”. O
uso da sobrecarga não é tão comum quanto o da sobrescrita, que será
apresentado na próxima seção.
www.esab.edu.br 225
33.3 Sobrescrevendo métodos
Neste momento vamos mostrar uma subclasse declarando novos
atributos ou métodos. Sobrescrevemos métodos quando escrevemos
novos atributos, métodos ou redeclaramos um atributo para que ele
receba um valor inicial diferente, por exemplo.
Novamente referenciando o exemplo apresentado na unidade 31,

com Conta, ContaNormal e ContaEspecial, observamos que a classe
ContaEspecial é uma especificação (herda de) Conta, mas deve definir o
atributo $limite. O Código 95 apresenta um exemplo de sobrecarga com
a definição de estrutura da classe ContaEspecial. Observe.
Código 95 – Estrutura da classe ContaEspecial

01 class ContaEspecial extends Conta
02 {
03 var $limite;
04 }
A linha 1 do Código 95 define a classe com nome ContaEspecial,

herdando (estendendo) a classe Conta. Dessa forma, todos os atributos e
métodos definidos na superclasse são herdados e o novo atributo $limite
é definido. Portanto, a classe ContaEspecial define cinco atributos:
$numero, $agencia, $nomeCorrentista, $saldo (definidos na superclasse
e herdados) e $limite (definido na classe ContaEspecial). Além disso, os
métodos definidos na superclasse são, da mesma forma, herdados.
No entanto observamos, nesse momento, que o construtor da

classe ContaEspecial deve receber os cinco valores (em vez dos
quatro definidos na classe Conta), além da alteração do método
apresentarSaldoDisponivel(), que deve apresentar novo comportamento,
retornando à soma de $saldo e $limite. O Código 96 apresenta a
alteração referente à sobrescrita do método apresentarSaldoDisponivel(),
como você pode observar.
www.esab.edu.br 226
Código 96 – Estrutura da classe ContaEspecial sobrescrevendo método
02 {
03 var $limite;
05 {
06 echo $this->saldo + $this->limite. '<br>';
07 }
08 }
Nas linhas de 4 a 7 do Código 96 é escrito, novamente, o método

apresentarSaldoDisponivel(), na classe ContaEspecial. Ele não altera o
comportamento das classes Conta e ContaNormal, mas, quando chamado
por objetos da classe ContaEspecial, estabelece que se apresente, na tela, a
soma dos atributos $saldo e $limite, ou seja, com comportamento diferente.
Porém, segundo Thomson e Welling (2005, p. 126, grifo dos autores), “[...]
a palavra-chave parent permite chamar a versão original da operação da classe
pai”. Ou seja, se, em algum momento, quisermos chamar a versão original de
apresentarSaldoDisponivel(), podemos utilizar parent::apresentarSaldoDispo
nivel() a partir de objetos da classe ContaEspecial.
O Código 97 apresenta a sobrescrita do construtor, porém, aproveita

o código do construtor definido no pai, utilizando a palavra parent.
Observe com atenção.
Código 97 – Estrutura da classe ContaEspecial sobrescrevendo método

02 {
03 var $limite;
05 {
06 echo $this->saldo + $this->limite. '<br>';
07 }
08 function ContaEspecial ($numero, $agencia,
$nomeCorrentista, $saldoInicial, $limite)
09 {
10 parent::Conta($numero, $agencia,
$nomeCorrentista, $saldoInicial);
11 $this->limite = $limite;
12 }
13 }
www.esab.edu.br 227
Na linha 8 do Código 97 é definido o construtor (com o nome da
classe), que recebe os cinco valores iniciais dos atributos $numero,
$agencia, $nomeCorrentista, $saldo e $limite. Como na classe pai
(superclasse, ou seja, Conta) o construtor define e atribui o valor para
quatro atributos ($numero, $agencia, $nomeCorrentista e $saldo),
chamamos o construtor da classe pai com uso do parent, na linha 10, e
atribuímos o atributo $limite, específico dessa classe, na linha 11.
Nesta unidade você viu conceitos de visibilidade de métodos e

atributos, sobrecarga e sobrescrita, de forma a criar classes, estruturando
e reutilizando código. Na unidade 34 vamos estudar o conceito de
exceções, de forma a tratar os erros. Vamos lá?
Saiba mais
O portal PHP Classes apresenta uma biblioteca
de classes prontas para utilização, com o
intuito de aproveitar o trabalho feito por outros
desenvolvedores e aumentar ainda mais o
potencial de reuso. Clique aqui e conheça, ainda,
alguns tutoriais e fóruns que podem esclarecer
dúvidas e solucionar problemas.
www.esab.edu.br 228
34 Tratando exceções
Objetivo
Apresentar os conceitos de tratamento e exceção, a classe exception e
definições de exceções.
Nas unidades anteriores estudamos o uso da orientação a objetos na

estruturação e na reutilização de código. Nesta unidade veremos o uso
e o tratamento de exceções. Para isso, utilizaremos como base teórica
Thomson e Welling (2005). Vamos em frente?
34.1 Por que tratar exceções?

Quando chamamos de forma incorreta uma função ou executamos uma
operação matemática utilizando uma variável com conteúdo textual
(lembre-se de que, na PHP, as variáveis não têm especificação de tipo),
a execução dos scripts pode lançar erros, os quais chamamos também
de exceções. Tratar exceções significa oferecer um tratamento aos erros,
de forma a apresentar tais exceções de modo mais amigável, para que
o usuário entenda o motivo do erro ou mesmo para desviar o fluxo
da execução para um novo caminho (que pode ser o de correção das
informações que causaram o erro).
Para tratar exceções você deve “proteger” uma parte do código através de
um bloco try. O Código 98 apresenta a estrutura do bloco try, veja.
Código 98 – Estrutura do bloco try

01 try
02 {
03 // o codigo entra aqui
04 }
05 catch (<tipo da exceção>)
06 {
07 // manipula exceção
08 }
Fonte: Adaptado de Thomson e Welling (2005).
www.esab.edu.br 229
Segundo Thomson e Welling (2005, p. 143), “[...] se algo estiver errado
dentro do bloco try, você pode fazer o que chamamos de lançar uma
exceção”. Os autores se referem a erro em código entre as linhas 2 e 4,
representado pelo comentário na linha 3 do Código 98.
Em caso de erro, o fluxo de execução é transferido ao bloco catch, que

testa o tipo da exceção (mais adiante veremos que existem vários tipos
predefinidos de exceção, além daqueles criados pelo desenvolvedor).
Thomson e Welling (2005, p. 144) esclarecem que podemos “[...] ter
mais de um bloco catch associado a um único bloco try. Usar mais de um
faz sentido se cada bloco catch estiver esperando pegar um tipo diferente
de exceção”. Quando uma exceção é gerada, a PHP procura um bloco
catch correspondente.
Além das exceções geradas pela linguagem PHP (como erros), o

desenvolvedor pode lançar uma exceção. Para lançar uma exceção, a
linguagem PHP permite que seja usada a instrução throw, que ativa os
mecanismos de tratamento de exceções. A instrução throw recebe como
parâmetro um objeto, que, normalmente, é uma instância da classe
Exception ou de alguma classe estendida de Exception, podendo ser
usado da seguinte forma: throw new Exception(‘mensagem’, código);
O Código 99 apresenta uma exceção lançada pelo desenvolvedor e seu

tratamento. Acompanhe com atenção.
Código 99 – Exemplo de tratamento de exceção

01 <?php
02 try {
03 throw new Exception('Erro gerado pelo
usuário', 0);
04 }
05 catch (Exception $e){
06 echo 'Exceção código '. $e->getCode()
.': '. $e->getMessage().' na linha '.
$e->getLine();
07 }
08 ?>
www.esab.edu.br 230
O Código 99 apresenta, dentro de um bloco try, o lançamento de uma
exceção com código 0 e mensagem “Erro gerado pelo usuário”, como
mostra a linha 3. Ao encontrar uma exceção, o fluxo é desviado para o
catch, encontrado na linha 5, que obtém a exceção e a controla através
da variável $e. A linha 6 apresenta, na tela, um texto com dados contidos
nessa variável, sendo que tais dados seguem o estabelecido na classe
Exception, assunto da próxima seção.
34.2 Classe Exception

A classe Exception vem “embutida” na linguagem PHP, sendo que seu
construtor (método que é chamado quando criamos um objeto dessa
classe, como vimos na unidade 33) solicita dois parâmetros: mensagem e
código da exceção.
A classe Exception disponibiliza os seguintes métodos, como nos

apresentam Thomson e Welling (2005, p. 145):
• getCode() – Retorna o código conforme passado ao construtor.

• getMessage() – Retorna a mensagem conforme passado ao construtor.
• getFile() – Retorna o caminho completo para o arquivo onde a exceção foi gerada.
• getLine() – Retorna o número da linha onde a exceção foi gerada.
• getTrace() – Retorna um array contendo um backtrace onde a exceção foi gerada.
• getTraceAsString() – Retorna a mesma informação que getTrace, formatada como string.
• __toString() – Permite simplesmente ecoar um objeto Exception, dando todas as
informações dos métodos anteriores.
Os métodos descritos são utilizados para recuperar informações/dados da
exceção, ou seja, disponibilizam as informações para que se possa utilizá-las
de uma forma diferente, adequando-se à necessidade quando necessário.
O Código 99, apresentado na seção anterior, mostra a instrução echo

‘Exceção código ‘. $e->getCode() .’: ‘. $e->getMessage().’ na linha
‘. $e->getLine();, na linha 6, que concatena textos definidos pelo
desenvolvedor com o valor dos métodos descritos na classe Exception.
www.esab.edu.br 231
34.3 Definindo exceções
Assim como estudamos nas unidades anteriores, você pode herdar classes
com sobrescrita de métodos, de forma a resolver problemas específicos,
como, por exemplo, modificar a mensagem de erro padrão. Se você
quiser apresentar o erro em uma tabela (em vez da apresentação de
simples mensagem de erro padrão), você pode sobrescrever o método __
toString(). O método __toString(), definido na classe Exception, retorna
como texto e pode ser chamado simplesmente usando a instrução echo
na variável que guarda a exceção.
O Código 100 apresenta a definição de uma classe de exceção que herda

atributos e métodos da classe Exception e gera uma exceção baseada nesta
nova classe. Observe.
Código 100 – Definição e uso de exceção

01 <?php
02 class MinhaExcecao extends Exception {
03 function __toString(){
04 return '<table> <tr><td><strong>Exceção ' .
$this->getCode()
05 .'</strong> '. $this->getMessage().' em '
06 . $this->getFile().' na linha '. $this-
>getLine()
07 .'</td></tr></table><br />';
08 }
09 }
10 try {
11 throw new MinhaExcecao ('Um erro terrível
aconteceu', 42);
12 }
13 catch (MinhaExcecao $e){
14 echo $e;
15 }
16 ?>
Na linha 2 do Código 100 é criada uma classe, chamada MinhaExcecao,

estendida da classe Exception. Isso significa que a classe MinhaExcecao
www.esab.edu.br 232
herda as definições de Exception. Na linha 3 é sobrescrita a função __
toString(), ou seja, quando usarmos essa classe para gerar uma exceção
e escrevermos usando instrução echo, por exemplo, será retornada uma
tabela, definida entre as linhas 4 e 7, concatenando valores oriundos
dos métodos getCode(), getMessage(), getFile() e getLine() – que não
foram sobrescritos e que retornam no mesmo formato definido na classe
geradora (Exception). A definição do método se encerra na linha 8,
enquanto a da classe se encerra na linha 9. O fluxo principal do Código
100 se inicia na linha 10, protegida com o bloco try, e, na linha 11, é
gerada uma exceção do tipo MinhaExcecao (criada anteriormente), com
a mensagem ‘Um erro terrível aconteceu’ e código 42. O tratamento,
feito no bloco catch (que intercepta os erros e os trata), na linha 13,
trata erros do tipo MinhaExcecao, exatamente o erro criado na linha 11.
Logo, será executada a linha 14, escrevendo o erro – ou seja, chamando o
método __toString(). Dessa forma, é apresentado o erro na tela. Observe.
Figura 50 – Resultado da exceção definida.

Na Figura 50 é apresentado o erro, formatado em uma tabela, conforme

definido na linha 11 do Código 100. Observe que, sobrescrevendo a
função, foi possível especificar como formatar o seu retorno.
Da mesma forma, você pode criar suas exceções e usá-las conforme a

necessidade.
Nesta unidade você viu como tratar exceções e como lançar novas
exceções, principalmente a partir da classe Exception. Nas próximas
unidades vamos desenvolver exercícios, apresentando resposta possível
para reforçar o aprendizado.
www.esab.edu.br 233
35 Exercícios resolvidos – parte 1
Objetivo
Desenvolver exercícios e apresentar sua solução.
A unidade 34 abordou o uso e o tratamento de exceções. Conhecemos

a definição de uma classe de exceção que herda atributos e métodos da
classe Exception e gera uma exceção baseada nesta nova classe. Nesta
unidade apresentaremos exercícios de criação de classe e aplicação de
sobrecarga, sendo que você poderá observar solução possível para cada
um deles. Para isso, utilizaremos novamente como base teórica Thomson
e Welling (2005). Vamos lá?
35.1 Exercício criando uma classe e uma subclasse

Neste momento, como forma de exercitar seus conhecimentos sobre
classe e subclasse, você deve elaborar um aplicativo web para uma loja
virtual que define cadastro de aniversariantes. Para isso, você deve criar
uma classe de aniversariantes e um formulário que, ao ser processado,
utiliza essa classe. Defina as informações que deverão ser salvas, como
nome, data de aniversário, e-mail, telefone, características pessoais e
CPF. A classe deve receber essas informações e utilizar métodos para
salvar em um arquivo texto e validar dados. Você deve validar se a data
de aniversário (utilizando expressões regulares) e o CPF (efetuando
cálculo de verificação de dígito verificador) são válidos. Apresente, na
tela, mensagem de sucesso de gravação ou de correções de validação e
desenvolva cabeçalho e rodapé para serem reutilizados durante nossa
aplicação. Atenção! A resposta é dada a seguir, mas tente elaborar o
exercício antes.
www.esab.edu.br 234
Resposta:
A primeira parte da elaboração desta resposta consiste na criação de

cabeçalhos e rodapés padronizados para nossa loja virtual, como mostra o
Código 101.
Código 101 – Cabeçalho

loose.dtd"> //nome do arquivo cabecalho.inc
02 <html>
03 <head>
05 <style>
06 h1 { color:black; font-size:24pt; text-
align:center; background-color: #96E102;
07 .corpo {text-align:left; font-size:12pt}
08 .creditos {font-size:8pt; text-align:center}
09 </style>
10 </head>
11 <body>
13 <tr bgcolor=#96E102>
15 <img src="http://www.amirjf.com/img/
criancas05.png" height= 100px width=100px;}
>
16 </td>
17 <td>
18 <h1> Aniversariantes </h1>
19 </td>
20 </tr>
O Código 101 apresenta a definição do cabeçalho. Nele, são

determinados os estilos (linhas 6 a 9) e o início do corpo do documento,
definindo uma tabela com uma imagem da web. Mais uma vez, não
foram fechadas as tags de corpo do documento e HTML, que são
fechadas no rodapé, cujo código encontra-se a seguir. Salve o arquivo
como cabecalho.inc. Observe.
www.esab.edu.br 235
Código 102 – Rodapé
01 <table width=100% border=0> //nome do arquivo
rodape.inc
02 <tr>
03 <td span class="creditos"
align="center">Desenvolvido por Egon Sewald
Junior </td>
04 </tr>
05 </body>
06 </html>
O Código 102 apresenta, portanto, o rodapé com definição de

mensagem de crédito, que será apresentada nas páginas que o utilizam, e
o fechamento das tags de corpo e HTML. Lembre-se de que o conteúdo
a ser mostrado deve apresentar o cabeçalho em seu início e o rodapé no
seu final, com o conteúdo dinâmico entre os dois. Salve o arquivo como
rodape.inc.
Agora vamos desenvolver a classe de aniversariantes, a qual recebe os

dados, efetua as validações, processa o arquivo e apresenta o resultado. O
Código 103 traz a definição da classe.
Código 103 – Classe Aniversariante

1 <?php //nome do arquivo aniversarianteClasse.
inc
2 class Aniversariante {
3 var $nome, $email, $caracteristicas, $cidade,
$telefone, $cpf, $dataNascimento;
4 function validaEmail($email){
5 $padraoEmail = "/^[a-z][a-z0-9_\.\-]*@[a-z0-
9_\.\-]*[a-z0-9_\-]+\.[a-z]{2,4}$/i";
6 $avaliaemail = preg_match($padraoEmail,
$email);
8 echo 'E-mail Inválido';
9 } else {
10 return $email;
11 }
12 }
13 function validaData($data){
www.esab.edu.br 236
14 $padraoData = "/^ [0-9]{2}\/ [0-9]{2}\/[0-9]
{4}$/i";
15 $avaliaData = preg_match($padraoData,
$data);
16 if(!$avaliaData) {
17 echo 'Data Inválida';
18 } else {
19 return $data;
20 }
21 }
22 function validaTelefone($telefone){
23 $padraoTelefone = "/^$[0-9]{2}$[0-9]{4,5}-
[0-9]{4}$/";
24 $avaliaTelefone = preg_
match($padraoTelefone, $telefone);
26 echo 'Telefone Inválido';
27 } else {
28 return $telefone;
29 }
30 }
31 function validaCPF($cpfOriginal){
32 $cpf = trim($cpfOriginal);
33 $padraoCpf = "/^[0-9]{3}\.[0-9]{3}\.[0-9]
{3}-[0-9]{2}$/";
34 $avaliaCpf = preg_match($padraoCpf, $cpf);
35 $cpf = preg_replace("/[^0-9]/", "", $cpf);
36 if((!$avaliaCpf) || (strlen($cpf) == 11) )
{
37 $d1 = 0;
38 $d2 = 0;
39 for($i = 0; $i < 9; $i++){
40 $d1 += $cpf[$i] * (10 - $i);
41 }
42 $r1 = $d1 % 11;
43 $d1 = ($r1 > 1) ? (11 - $r1) : 0;
44 for($i = 0; $i < 9; $i++) {
45 $d2 += $cpf[$i] * (11 - $i);
46 }
47 $r2 = ($d2 + ($d1 * 2)) % 11;
48 $d2 = ($r2 > 1) ? (11 - $r2) : 0;
49 if (substr($cpf, -2) == $d1 . $d2){
50 return $cpfOriginal;}
51 else {
52 echo 'CPF Invalido';
53 }
54 } else {
55 echo 'CPF Invalido';
www.esab.edu.br 237
56 }
57 }
58 function Aniversariante ($nome, $email,
$caracteristicas, $telefone, $cpf,
$dataNascimento){
59 $this->nome = $nome;
60 $this->email = $this->validaEmail($email);
61 $this->caracteristicas = $caracteristicas;
62 $this->telefone = $this-
>validaTelefone($telefone);
63 $this->cpf = $this->validaCPF($cpf);
64 $this->dataNascimento = $this-
>validaData($dataNascimento);
65 }
66 function salvaArquivo($nomeArquivo){
67 $arquivo = fopen($nomeArquivo, 'a+');
68 fwrite($arquivo, $this->nome.';'.$this-
>email.';'.$this->telefone.';'.$this-
>caracteristicas.';'.$this->cpf.';'. $this-
>dataNascimento. “\r\n”);
70 echo '<table> <tr><td>Os dados de <strong>'
. $this->nome.'</strong> '. ' foram salvos
corretamente</td></tr></table><br />';
71 }
72 }
73 ?>
No Código 103 é definida a classe Aniversariante na linha 2 e seus

atributos são definidos na linha 3 ($nome, $email, $caracteristicas,
$cidade, $telefone, $cpf, $dataNascimento). Para definição de classe,
são utilizados conceitos constantes em Thomson e Welling (2005). Na
linha 4 é determinada a validação de e-mail, recebendo o parâmetro,
definindo expressão regular e testando a partir dela (instruções da linha
5 a 11). Caso seja encontrado erro na validação (utilizando expressão
regular), uma exceção é lançada (na linha 8) e uma mensagem é
exibida. Da mesma forma, são definidas as validações de data (método
definido nas linhas 13 a 21, utilizado para data de nascimento), telefone
(linhas 22 a 30) e de CPF (linhas 31 a 57). Também são definidos os
métodos construtor, entre as linhas 58 e 65, que chamam as validações
e atribuem valor aos atributos no momento no qual é criado a instância;
e salvaArquivo(), que salva as informações já atribuídas a uma instância
dessa classe, escrevendo um arquivo texto (linhas 66 a 71).
www.esab.edu.br 238
O Código 104 utiliza a classe Aniversariante criada (constante no
arquivo aniversarianteClasse.inc), recebendo dados enviados pelo método
post (pelo formulário a ser criado) e utilizando-se da classe Cliente para o
processamento das informações. Observe.
Código 104 – Script que recebe dados enviados por método post e utiliza classe Aniversariante
01 <?php //nome do arquivo salvarAniversariante.
php
02 require('aniversarianteClasse.inc');
03 require('cabecalho.inc');
04 $nomeArquivo = 'c:\\wamp\\www\\pacote6\\
aniversariante.txt';
06 $datanascimento = $_POST["datanascimento"];
08 $caracteristicas = $_
POST["caracteristicas"];
10 $cpf = $_POST["cpf"];
11 $aniversariante = new Aniversariante($nome,
$email, $caracteristicas, $telefone, $cpf,
$datanascimento);
12 $aniversariante
->salvaArquivo($nomeArquivo);
13 require('rodape.inc');
14 ?>
O Código 105 apresenta código que recebe informações, enviando

ao script definido anteriormente (Código 104) para utilizar a classe
Aniversariante para processamento. Observe que ela também reutiliza
código do cabeçalho e rodapé descritos, além de requerer o arquivo
no qual se encontra a definição da classe (linhas 2, 3 e 13, quando se
reaproveita código usando require()). As informações são enviadas por
formulário, o qual efetua a leitura destes dados através do método post,
enviando ao script definido no Código 104. Veja.
www.esab.edu.br 239
Código 105 – Formulário para cadastro dos aniversariantes
1 <?php require('cabecalho.inc');?>
2 <form action="salvarAniversariante.php"
3 <table border=0>
4 <tr>
5 <td> Nome: </td>
size=50 id=nome> </td>
7 </tr>
8 <tr>
9 <td> CPF: </td>
10 <td> <INPUT type="text" name=cpf
size=14> </td>
11 </tr>
12 <tr>
13 <td> Data Nascimento: </td>
name=datanascimento size=10> </td>
15 </tr>
16 <tr>
size=30> </td>
19 </tr>
20 <tr>
22 <td> <INPUT type="text" name=telefone
size=12> </td>
23 </tr>
24 <tr>
25 <td> Características: </td>
name=caracteristicas size=60> </td>
27 </tr>
28 </table>
30 <INPUT type="" value="Limpar">
31 </form>
32 <?php require('rodape.inc');?>
www.esab.edu.br 240
O Código 105 define um documento HTML, que, por sua vez, define
um formulário e envia ao script de processamento. Para isso, são
utilizados elementos de inserção do tipo caixa de textos (text), botão de
submissão (submit) e botão para limpar as informações do formulário
(reset). Observe que o código reaproveita cabeçalho e rodapé, que são
escritos, portanto, uma vez só. O resultado da execução dos códigos pode
ser visto na Figura 51.
Figura 51 – Resultado da execução.

A Figura 51 apresenta, em primeiro plano, um formulário de seleção das

informações da classe Aniversariantes. Os dados foram enviados com erro
no telefone e apresentados na tela no centro da figura, com o objetivo de
evidenciar o erro. Após a correção dos dados e o novo envio, é mostrada
a mensagem de sucesso, como pode ser visto do lado direito da figura.
Porém, para isso, acessamos somente propriedades criadas na definição
do código. Para acessar e gravar dados criados em tempo de execução,
usamos a sobrecarga, assunto da próxima seção.
www.esab.edu.br 241
35.2 Exercício sobrecarregando métodos
Com base no exercício anterior, utilize a sobrecarga para salvar atributos
não declarados. Você deve, no script que processa o recebimento das
variáveis no método post, obter a data e hora atuais, atribuir a um
atributo não declarado e, ao salvar o arquivo texto, salvar também o valor
dessa variável. Novamente utilizaremos conceitos definidos em Thomson
e Welling (2005) para efetuar a sobrecarga.
Resposta:
Para descrever a solução desse problema, vamos aproveitar os códigos

desenvolvidos no exercício anterior. Os códigos completos serão
disponibilizados no final da próxima unidade.
Código 106 – Classe Aniversariante com sobrecarga

$telefone, $cpf, $dataNascimento, $dados;
4 {
6 }
8 {
10 }
O Código 106 apresenta alterações principais do script que contém

a classe Aniversariante, presente no Código 103. Nesse código, que
compartilha a linha 1, observe que, na linha 2, foi adicionado outro
atributo: $dados. Ele será usado como vetor de atributos não nomeados e
é usado na reescrita dos métodos __set() e __get(), de modo a possibilitar
a escrita e a leitura. Quando salvar o arquivo texto (no método
salvaArquivo()), troque a linha fwrite($arquivo, $this->nome.’;’.$this-
>email.’;’.$this->telefone.’;’.$this->caracteristicas.’;’.$this-
>cpf.’;’.$this->dataNascimento.”\r\n”); por fwrite($arquivo, $this-
www.esab.edu.br 242
>nome.’;’.$this->email.’;’.$this->telefone.’;’.$this->caracteristicas.
‘;’.$this->cpf.’;’.$this->dataNascimento.’;’. $this->data.“\r\n”);, de modo
a gravar a data (adição em negrito), que será criada dentro de $dados.
Para criar o atributo, altere o Código 104 adicionando a linha

$aniversariante->data = time(); antes da chamada de salvar arquivo.
Dessa forma, será criado um atributo (dentro de $dados) e será também
lido no momento de salvar o arquivo texto, utilizando a sobrecarga.
Nesta unidade você desenvolveu exercícios relacionados à criação e ao uso

de classes e também aplicou sobrecarrega. Nas próximas unidades vamos,
novamente, desenvolver exercícios, aplicando conceitos de sobrescrita de
métodos e tratamento de exceções. Vamos em frente!
Tarefa dissertativa
www.esab.edu.br 243
36 Exercícios resolvidos – parte 2
Objetivo
Desenvolver exercícios e apresentar a sua solução.
Na unidade 35 você viu exercícios de criação de classe e aplicação de

sobrecarga. Nesta unidade você terá novos exercícios, aplicando conceitos
de sobrescrita de métodos e tratamento de exceções e, novamente, poderá
observar a solução possível. Mais uma vez utilizaremos como base teórica
Thomson e Welling (2005).
36.1 Exercício sobrescrevendo métodos

Aproveitando o exercício resolvido na unidade 35, no qual
desenvolvemos um cadastro de aniversariantes, imagine que você, além
de amigos brasileiros, deseja cadastrar aniversariantes que moram nos
Estados Unidos, o que provocaria alteração na validação do telefone,
que respeitaria as regras de numeração desse país. Altere o formulário, de
forma a especificar se é residente no Brasil ou no exterior e desenvolva
classe estendida, de forma a aproveitar o código já escrito, alterando
somente a validação de telefone, que agora respeita novas regras. No
script que processa os dados enviados, direcione a instância à classe
original, quando residente no Brasil, ou à classe estendida, a ser criada,
com a alteração de validação de telefone.
Resposta:
Para descrever a solução desse problema, vamos aproveitar os códigos

desenvolvidos na unidade 35. No final da presente unidade, será
disponibilizado o código completo, agrupando todas as alterações.
www.esab.edu.br 244
Vamos, então, criar uma nova classe AniversarianteExterior, que herda
atributos e métodos da classe Aniversariante, como mostra o Código
101, que deve ser adicionado ao Código 103.
Código 107 – Classe AniversarianteExterior

01 class AniversarianteExterior extends
Aniversariante{
03 echo $telefone;
04 $padraoTelefone = "/^[$0-9${3} [0-9]{3}-[0-
9]{4}$/";
$telefone);
07 echo 'Telefone EUA Inválido', 4;
08 } else {
10 }
11 }
12 }
A definição de classe estendida segue também o definido por Thomson

e Welling (2005). O Código 107 apresenta as adições realizadas no
script que contém a classe Aniversariante. Na linha 1 é criada uma
classe estendida (que herda) a partir da classe Aniversariante. Como
todos os atributos e métodos são aproveitados, exceto a validação de
telefone, somente essa função deve ser sobrescrita. A classe estendida
(filha) sobrescreve o método validaTelefone(), de forma a dar um novo
comportamento, atendendo a necessidades mais específicas. A linha 4
estabelece nova expressão regular, que aceita telefones americanos, além
de mostrar uma mensagem de erro um pouco diferente. Poderíamos
também ter transformado a expressão regular em uma variável global e
sobrescrito somente a expressão.
Para que possamos obter a origem do aniversariante, vamos adicionar ao

formulário uma entrada do tipo seleção (select). O Código 108 é, então,
adicionado ao Código 105.
www.esab.edu.br 245
Código 108 – Formulário para cadastro dos aniversariantes
01 <tr>
02 <td> Origem: </td>
03 <td> <select name="origem">
<option value="1">Brasil</option><option
value="2">EUA</option></select> </td>
04 </tr>
Agora devemos alterar o código do script que recebe as variáveis enviadas

pelo formulário por método post, de forma a receber o valor da seleção e
direcionar a classe a ser criada, como mostra o Código 109.
Código 109 – Classe AniversarianteExterior

01 $origem = $_POST["origem"];
02 if ($origem == '1'){
$datanascimento);
04 } else {
05 $aniversariante = new
AniversarianteExterior($nome, $email,
$datanascimento);
06 }
A linha que consta $aniversariante = new Aniversariante($nome, $email,

$caracteristicas, $telefone, $cpf, $datanascimento); no Código 104 deve
ser alterada para receber as linhas presentes no Código 103, substituindo
esse trecho do código anteriormente definido. Dessa forma, recebemos a
variável “origem” enviada por post e, caso a origem seja igual a 1 (Brasil),
criará uma instância da classe Aniversariante. Caso contrário (EUA),
criará uma instância da classe AniversarianteExterior. Observe o claro
aproveitamento do código. As alterações foram pequenas, apenas para
definir o seu funcionamento.
Pronto! A sobrescrita foi desenvolvida e podemos criar aniversariantes

residentes no Brasil e nos EUA com validações corretas! Na próxima
seção exercitaremos o uso de exceções.
www.esab.edu.br 246
36.2 Exercício utilizando exceções
Para o desenvolvimento dos exercícios anteriores, as validações
apresentavam somente uma mensagem de erro. Em caso de erro de
validação, lance uma exceção.
Resposta:
Para a solução deste exercício será alterado somente o Código 103 (com
as mudanças descritas no Código 107, no exercício anterior), de modo
a lançar e tratar as exceções. O Código 110 apresenta as alterações
realizadas para este fim.
Código 110 – Classe Aniversariante e AniversarianteExterior com tratamento de Exceções

1 <?php //nome do arquivo aniversarianteClasse.
inc
$telefone, $cpf, $dados;
5 {
7 }
9 {
11 }
9_\.\-]*[a-z0-9_\-]+\.[a-z]{2,4}$/i";
$email);
16 throw new Exception('E-mail Inválido', 3);
17 } else {
18 return $email;
19 }
20 }
21 function validaData($data){
22 $padraoData = "/^ [0-9]{2}\/ [0-9]{2}\/[0-9]
{4}$/i";
23 $avaliaeData = preg_match($padraoData,
$data);
www.esab.edu.br 247
24 if(!$avaliaData) {
25 echo 'Data Inválida';
26 } else {
27 return $data;
28 }
29 }
31 $padraoTelefone = "/^$[0-9]{2}$[0-9]{4,5}-
[0-9]{4}$/";
34 throw new Exception('Telefone Inválido', 4);
35 } else {
37 }
38 }
39 function validaCPF($cpfOriginal){
40 $cpf = trim($cpfOriginal);
41 $padraoCpf = "/^[0-9]{3}\.[0-9]{3}\.[0-9]
{3}-[0-9]{2}$/";
42 $avaliaCpf = preg_match($padraoCpf, $cpf);
43 $cpf = preg_replace("/[^0-9]/", "", $cpf);
44 if((!$avaliaCpf) || (strlen($cpf) == 11) )
{
45 $d1 = 0;
46 $d2 = 0;
47 for($i = 0; $i < 9; $i++){
48 $d1 += $cpf[$i] * (10 - $i);
49 }
50 $r1 = $d1 % 11;
51 $d1 = ($r1 > 1) ? (11 - $r1) : 0;
52 for($i = 0; $i < 9; $i++) {
53 $d2 += $cpf[$i] * (11 - $i);
54 }
55 $r2 = ($d2 + ($d1 * 2)) % 11;
56 $d2 = ($r2 > 1) ? (11 - $r2) : 0;
57 if (substr($cpf, -2) == $d1 . $d2){
58 return $cpfOriginal;}
59 else {
60 throw new Exception('CPF Invalido', 4);
61 }
www.esab.edu.br 248
62 } else {
63 throw new Exception('CPF Invalido', 4);
64 }
65 }
66 function Aniversariante ($nome, $email,
$caracteristicas, $telefone, $cpf){
67 try {
69 $this->email = $this->validaEmail($email);
71 $this->telefone = $this-
>validaTelefone($telefone);
72 $this->cpf = $this->validaCPF($cpf);
73 $this->dataNascimento = $this-
>validaData($dataNascimento);
74 }
76 echo '<table> <tr><td><strong>Exceção
' . $e->getCode() .'</strong> '.
$e->getMessage().' em '. $e->getFile().'
na linha '. $e->getLine() .'</td></tr></
table><br />';
77 }
78 }
>email.';'.$this->telefone.';'.$this-
>caracteristicas.';'.$this->cpf.';'. $this-
>dataNascimento.';'. $this->data.”\r\n”);
84 }
85 }
86 class AniversarianteExterior extends
Aniversariante{
88 echo $telefone;
$padraoTelefone = "/^[$0-9${3} [0-9]{3}-
[0-9]{4}$/";
$avaliaTelefone = preg_
if(!$avaliaTelefone) {
throw new Exception('Telefone Inválido', 4);
www.esab.edu.br 249
} else {
return $telefone;
}
}
}
?>
No Código 110 foram inseridos os tratamentos de erros, gerados a cada

erro de validação. As inserções foram feitas, nesse código, nas linhas 16,
25, 51, 54 e 82. Também é tratada, no construtor, a criação do objeto,
que trata de forma que, em caso de exceção lançada, é definida mensagem
em uma tabela, retornando ao documento padrão. O tratamento é feito
usando o bloco try iniciado na linha 58 e interceptado pela instrução
catch, presente na linha 65. As definições de tratamento de exceções, uso
do try, catch e throw se baseiam em Thomson e Welling (2005).
Dessa forma é possível, portanto, tratar as exceções. Como definido

na unidade 35, os outros códigos completos (o Código 110 representa
a versão com todas as alterações de seu script) são então transcritos,
levando em consideração as alterações definidas nos exercícios. O Código
111 apresenta o formulário de seleção das informações.
Código 111 – Formulário de cadastro de aniversariantes

1 <?php require('cabecalho.inc');?>
2 <form action="salvarAniversariante.php"
3 <table border=0>
4 <tr>
5 <td> Nome: </td>
size=50 id=nome> </td>
7 </tr>
8 <tr>
9 <td> CPF: </td>
size=14> </td>
11 </tr>
12 <tr>
13 <td> Data Nascimento: </td>
www.esab.edu.br 250
name=datanascimento size=10> </td>
15 </tr>
16 <tr>
size=30> </td>
19 </tr>
20 <tr>
size=12> </td>
23 </tr>
24 <tr>
25 <td> Características: </td>
name=caracteristicas size=60> </td>
27 </tr>
28 <tr>
29 <td> Origem: </td>
30 <td> <select name="origem">
<option value="1">Brasil</option><option
value="2">Exterior</option></select> </td>
31 </tr>
32 </table>
34 <INPUT type="reset" value="Limpar">
35 </form>
36 <?php require('rodape.inc');?>
No Código 111 são definidas, então, entradas para a seleção dos dados,
os quais serão enviados, via método post, ao script definido no Código
112, que representa o processamento dessas variáveis enviadas, a
instância e o uso das classes:
www.esab.edu.br 251
Código 112 – Script que recebe dados enviados por método post e utiliza classe Aniversariante
1 <?php
2 require('aniversarianteClasse.inc');
3 require('cabecalho.inc');
aniversariante.txt';
7 $datanascimento = $_POST["datanascimento"];
8 $caracteristicas = $_
POST["caracteristicas"];
11 $origem = $_POST["origem"];
12 if ($origem == '1'){
$datanascimento);
14 } else {
15 $aniversariante = new
AniversarianteExterior($nome, $email,
$datanascimento);
16 }
17 $aniversariante->data = time();
18 $aniversariante->salvaArquivo($nomeArquivo);
19 require('rodape.inc');
20 ?>
O Código 112 processa as variáveis recebidas pelo método post, gera a

instância da classe a ser criada –Aniversariante ou AniversarianteExterior,
conforme a necessidade – e chama o método que salva os dados. Os
arquivos requeridos de cabeçalho e rodapé não foram alterados após a
sua criação em exercício da unidade 35. Dessa forma, você tem acesso a
todos os códigos definidos.
Nesta unidade você desenvolveu novos exercícios, aplicando conceitos

de sobrescrita de métodos e tratamento de exceções, complementando
os exercícios relacionados à criação e ao uso de classes da unidade 35.
Nas próximas unidades serão tratados aspectos de coesão e boa escrita de
códigos. Vamos lá?
www.esab.edu.br 252
Atividade
www.esab.edu.br 253
Resumo
A unidade 31 apresentou conceitos de Orientação a Objetos (OO), de

modo a estruturar de uma forma diferente e ampliar o reuso. Conceitos
como classes, objetos, herança, abstração, polimorfismo, encapsulamento
e associação foram apresentados.
Na unidade 32 foi utilizada a herança, criando uma superclasse e usando os

seus métodos e definição de atributos. Os conceitos apresentados na unidade
31 foram, portanto, aplicados, de forma a clarificar o reuso do código.
A sobrecarga e a sobrescrita de atributos e métodos foram assunto da

unidade 33, a fim de se aproveitar o código definido em outras classes.
Dessa forma, aproveitamos os códigos escritos em classes, descrevendo
as especificações (características especiais, diferentes) nas classes que as
estendem (herdam).
Na unidade 34 estudamos como tratar exceções e lançar novas exceções,

principalmente a partir da classe Exception. Dessa forma, foi possível
definir novas exceções e tratar erros do sistema.
Nas unidades 35 e 36 foram realizados exercícios e apresentadas soluções,

com o objetivo de fixar o conteúdo apresentado. Foram realizados
exercícios com uso de classes, herança, sobrecarga, sobrescrita e exceções.
www.esab.edu.br 254
Desenvolvendo uma aplicação
37 coesa – parte 1
Objetivo
aprendidos nesta unidade, utilizando funções, reutilizando código e
tratando exceções.
Nas unidades 35 e 36 resolvemos exercícios utilizando conceitos de

reutilização de software e, posteriormente, pudemos ver a sua resolução.
Nesta unidade vamos desenvolver aplicação também utilizando esses
conceitos. Aplicaremos, novamente, conceitos de Thomson e Welling
(2005) como base teórica. Vamos lá?
37.1 Continuidade do aplicativo da unidade 24,

reaproveitando função de validação de CPF
Da mesma forma que criamos uma função de validação de CPF, vamos
escrever uma biblioteca – ou seja, um arquivo com essa validação – e usá-lo
em outras classes. Para isso, criaremos um arquivo chamado “Validacoes.
inc” com a função ValidaCPF(), que recebe como parâmetro o CPF, ou
seja, uma sequência de números, e responde com o valor do CPF, caso
seja válido, ou com 0 caso não tenha sido chamada com um valor de CPF
válido. O Código 113 apresenta o arquivo com a função definida.
Código 113 – Definição de arquivo contendo função de validar CPF

1 <?php
2 function validaCPF($cpf){
3 $cpfSemEspacos = trim($cpf);
4 $padraoCpf = "/^[0-9]{3}\.[0-9]{3}\.[0-9]
{3}-[0-9]{2}$/";
5 $avaliaCpf = preg_match($padraoCpf,
$cpfSemEspacos);
6 $cpfSemFormatacao = preg_replace("/[^0-
9]/", "", $cpfSemEspacos);
7 if((!$avaliaCpf) ||
(strlen($cpfSemFormatacao) == 11) ){
www.esab.edu.br 255
8 $d1 = 0;
9 $d2 = 0;
10 for($i = 0; $i < 9; $i++){
11 $d1 += $cpfSemFormatacao[$i] * (10 -
$i);
12 }
13 $r1 = $d1 % 11;
14 $d1 = ($r1 > 1) ? (11 - $r1) : 0;
15 for($i = 0; $i < 9; $i++) {
$i);
17 }
18 $r2 = ($d2 + ($d1 * 2)) % 11;
19 $d2 = ($r2 > 1) ? (11 - $r2) : 0;
20 if (substr($cpfSemFormatacao, -2) == $d1
. $d2){
21 return $cpfSemEspacos;}
22 else {
23 return 0;
24 }
25 } else {
26 return 0;
27 }
28 }
29 ?>
O Código 113 apresenta um arquivo PHP (que pode ser salvo com
qualquer extensão) que será requerido em um ou mais scripts. Na linha
2 é definida a assinatura da função, sendo possível observar que a função
recebe um parâmetro. A linha 3 utiliza o método trim para retirar os
espaços que poderiam estar no início ou no fim do texto e causar erro.
As linhas 4 e 5 determinam, respectivamente, uma expressão regular
e se o padrão é encontrado atribuem o resultado dessa validação à
variável $avaliaCPF. A linha 6 atribui à variável $cpfSemFormatacao
o valor de $cpfSemEspacos, retirando a formatação (pontos e hífen) e
deixando somente os dígitos numéricos. A linha 7 avalia se a resposta
da comparação com a expressão regular é verdadeira e se o tamanho dos
caracteres é igual a 11 (tamanho exato do CPF válido). Caso a expressão
testada na linha 7 seja positiva, continua o fluxo de testes (linhas 8 a 24)
e, caso negativa, retorna valor 0 para a função, como encontrado na linha
26. Os comandos entre 8 e 19 calculam o valor dos dígitos verificadores
www.esab.edu.br 256
do CPF, que são comparados com os últimos dois dígitos do CPF
passado como parâmetro e, em caso positivo, retorna o valor do CPF
(linha 21) e, caso negativo, retorna o valor 0 (linha 23).
Para utilizar a função de validação de CPF criada nesse arquivo, podemos

requerer o arquivo com essa função usando a instrução require, como
pode ser visto no Código 114.
Código 114 – Utilizando função de validar CPF definida em outro arquivo

1 <?php
2 require('Validacoes.inc');
3 class Cliente {
4 var $nome, $email, $endereco, $cidade,
$telefone, $cpf;
5 function validaCPFInterno($cpf){
6 return validaCPF($cpf);
7 }
8 function Cliente ($nome, $email, $endereco,
$cidade, $telefone, $cpf){
10 $this->email = $email;
11 $this->endereco = $endereco;
12 $this->cidade = $cidade;
13 $this->telefone = $telefone;
14 $this->cpf = $this-
>validaCPFInterno($cpf);
15 }
>email.';'.$this->endereco.';'.$this-
>cidade.';'.$this->telefone.';'.$this-
>cidade.';'.$this->cpf.”\r\n”);
21 }
22 }
cliente.txt';
www.esab.edu.br 257
30 $cliente = new Cliente($nome, $email,
$endereco, $cidade, $telefone, $cpf);
31 if ($cliente->cpf==0){
32 echo '<table> <tr><td> CPF Invalido</td></
tr></table><br />';
33 } else {
34 $cliente->salvaArquivo($nomeArquivo);
35 }
36 ?>
As instruções do Código 114 utilizam o código de Validacoes.

inc, desenvolvido junto ao Código 113. Ao utilizar o código,
como observamos na linha 2, usando a instrução require(), o texto
desenvolvido anteriormente é “colado” exatamente nesse ponto, ou
seja, é como se tivéssemos copiado o texto integral do arquivo e colado
nessa posição. Dessa forma, a função escrita no arquivo fica disponível
para uso. Na linha 3 é definida a classe cliente e, na linha subsequente,
são definidas as variáveis. A linha 5 define uma função com nome
validaCPFInterno, recebendo um parâmetro. Essa função faz chamada à
função definida no arquivo Validacoes.inc, ou seja, reaproveita o código
desenvolvido, retornando ao fluxo de operação o valor que retornou
da função requerida. Assim, reaproveitamos o código previamente
definido e, caso tenhamos outras classes que necessitem de validação
do CPF, não seriam necessárias implementações repetidas, podendo-
se requerer de forma igual. As linhas 8 a 15 definem o construtor,
ou seja, o comportamento a ser seguido no momento de criação do
objeto da classe Cliente, que, portanto, deve receber como parâmetro
seis valores, que são definidos nas variáveis $nome, $email, $endereco,
$cidade, $telefone e $cpf, respectivamente. A linha 14, que faz parte do
construtor, inicia a variável $cpf do objeto com o valor que é recebido
da função validaCPFInterno(), que, por sua vez, reaproveita o código
definido anteriormente. As instruções encontradas entre as linhas 16 e
21 determinam o salvamento de dados em arquivo texto, possibilitando
a sua recuperação quando desejado. A linha 22 finaliza a definição da
classe Cliente. Os comandos 23 a 35 correspondem ao fluxo inicial do
arquivo, que obtém valores enviados por método post, cria uma instância
da classe Cliente (atribuindo-a à variável $cliente, como visto na linha
30) e, caso o valor da variável $cpf do objeto seja igual a 0 (lembre-se de
www.esab.edu.br 258
que é o valor definido em caso de erro na validação do CPF), apresenta
mensagem de erro (“CPF Inválido”); caso contrário, salva em arquivo
texto, chamando a função salvaArquivo(), da linha 34. Para utilizar
esse arquivo, salve com o nome clienteClasse.php, que será utilizado
posteriormente.
Com a definição de classe Cliente, devemos escrever um formulário que

obtenha essas informações, chamando esse código criado. Veremos essa
definição e o resultado de uso na próxima seção.
37.2 Desenvolvendo um formulário de cadastro

de clientes – pessoa física com base nas classes de
cliente
Tendo desenvolvido o código que cria objetos da classe Cliente a partir
de variáveis obtidas através do envio por método post das definições da
Classe e aproveitando código de validação de e-mail, devemos construir
um formulário, denominado clienteFormulario.php, que efetue a leitura
dessas variáveis e as envie através do método post. O Código 115 mostra
a definição desse formulário.
www.esab.edu.br 259
Código 115 – Utilizando função de validar CPF definida em outro arquivo
1 <?php require('header.inc');?>
2 <form action="cliente.php" method="POST"
id=form_cliente>
3 <table border=0>
4 <tr>
5 <td> Nome: </td>
size=50 id=quantidade> </td>
7 </tr>
8 <tr>
9 <td> CPF: </td>
size=14> </td>
11 </tr>
12 <tr>
size=30> </td>
15 </tr>
16 <tr>
18 <td> <INPUT type="text" name=endereco
size=60> </td>
19 </tr>
20 <tr>
22 <td> <INPUT type="text" name=cidade
size=30> </td>
23 </tr>
24 <tr>
size=20> </td>
27 </tr>
28 </table>
30 </form>
No Código 115 (clienteFormulario.php ) utilizamos os arquivos de

cabeçalho (‘header.inc’) e rodapé (‘footer.inc’) através das linhas 1 e
31, respectivamente. O objetivo do uso dessa requisição também está
relacionado ao reuso do código. Nesse sentido você pode retomar o
estudo sobre aproveitamento de códigos contidos no cabeçalho e no
rodapé das unidades anteriores, de forma a reaplicar esse conceito.
www.esab.edu.br 260
Caso não sejam aplicados os arquivos determinados, a linguagem gerará
erro do seu uso. Observe atentamente que, na linha 2, é chamado um
script PHP, que se trata do código salvo previamente (Código 115) e
reaproveitado. Dessa forma, quando requisitado, o código definido
executa funções desse formulário.
A Figura 52 apresenta o resultado da execução desse formulário.
Figura 52 – Resultado da execução dos códigos definidos na unidade.

A Figura 52 apresenta um formulário que obtém as informações e

as envia ao código definido através de mensagens do método post,
chamadas com a submissão dos valores do formulário. No script aplicado
na submissão é criado objeto da classe Cliente e, caso as validações
sejam positivas, salva o arquivo e apresenta mensagem de sucesso; caso
contrário, apresenta erro na tela.
Nesta unidade você desenvolveu um arquivo que contém funções

que podem ser reaproveitadas e o aplicou dentro de uma função de
uma classe específica. Esse processo possibilita o reaproveitamento
do código (utilizando-o em mais arquivos ou classes) e, em caso de
manutenção, possibilita a alteração em ponto único. Na unidade 38
serão acrescentados elementos de tratamento de exceção e encontro de
erros possíveis. Vamos lá?
www.esab.edu.br 261
Desenvolvendo uma aplicação
38 coesa – parte 2
Objetivo
aprendidos nesta unidade, utilizando Orientação a Objeto.
Na unidade 37 foi criado arquivo com validação de CPF para que

pudesse ser reaproveitado. Definiu-se a classe Cliente, que utiliza a
validação e, por último, foi definido um formulário que possibilitasse a
leitura dos dados e os aplicasse, salvando os arquivos textos somente se a
validação fosse positiva. Veremos, nesta unidade, como tratar exceções e
encontrar erros. Para isso, utilizaremos Thomson e Welling (2005) como
base teórica. Vamos lá?
38.1 Definindo exceções e tratando erros

Dando continuidade ao problema definido na unidade 37, podemos
apresentar um erro, em caso de insucesso na validação, além de impossibilitar
a tentativa de salvar registro no arquivo texto sem que seus dados tenham
sido “aprovados”. O Código 116 apresenta, portanto, a evolução do Código
113 (Validacoes.inc), inclusive acrescentando novas funções que podem ser
utilizadas em validações (telefone, e-mail, CEP e números), e, em todos os
casos, o insucesso geraria um erro apresentado na tela.
Código 116 – Arquivo de validação

1 <?php
2 function validaCPF($cpf){
3 $cpfSemEspacos = trim($cpf);
4 $padraoCpf = "/^[0-9]{3}\.[0-9]{3}\.[0-9]
{3}-[0-9]{2}$/";
5 $avaliaCpf = preg_match($padraoCpf,
$cpfSemEspacos);
6 $cpfSemFormatacao = preg_replace("/[^0-
9]/", "", $cpfSemEspacos);
7 if((!$avaliaCpf) ||
(strlen($cpfSemFormatacao) == 11) ){
www.esab.edu.br 262
8 $d1 = 0;
9 $d2 = 0;
10 for($i = 0; $i < 9; $i++){
$i);
12 }
13 $r1 = $d1 % 11;
14 $d1 = ($r1 > 1) ? (11 - $r1) : 0;
15 for($i = 0; $i < 9; $i++) {
$i);
17 }
18 $r2 = ($d2 + ($d1 * 2)) % 11;
19 $d2 = ($r2 > 1) ? (11 - $r2) : 0;
20 if (substr($cpfSemFormatacao, -2) == $d1
. $d2){
21 return $cpfSemEspacos;}
22 else {
23 throw new Exception('CPF Inválido',
1);;
24 }
25 } else {
26 throw new Exception('CPF Inválido', 1);;
27 }
28 }
29 function validaNumeros($numero){
30 $padraoNumeros = "/^[0-9]{1,3}/";
31 $avalianumero = preg_match($padraoNumeros,
$numero);
32 if(!$avalianumero) {
33 throw new Exception('Numero Inválido', 2);
34 } else {
35 return $idade;
36 }
37 }
38 function validaCep($cep){
substr($cep, 5, 3);
41 } else {
42
43 }
44 $padraoCEP = "/^[0-9]{5}-[0-9]{3}$/";
45 $avaliaCep = preg_match($padraoCEP,
$cepFormatado);
47 throw new Exception('CEP Inválido', 3);
48 } else {
www.esab.edu.br 263
49 return $cepFormatado;
50 }
51 }
9_\.\-]*[a-z0-9_\-]+\.[a-z]{2,4}$/i";
$email);
56 throw new Exception('E-mail Inválido', 4);
57 } else {
58 return $email;
59 }
60 }
62 $padraoTelefone = "/^$[0-9]{2}$[0-9]{4,5}-
[0-9]{4}$/";
65 throw new Exception('Telefone Inválido', 5);
66 } else {
68 }
69 }
70 ?>
O Código 116 (Validacoes.inc) apresenta, nas linhas 23 e 26, a definição

de uma exceção, com código 1 e texto “CPF Inválido”. Da mesma forma,
foram incluídas funções de validação pertinentes, como CEP, telefone,
e-mail e numerais.
Ainda assim, a exceção lançada deve ser tratada no código que a chama.
Assim, o Código 117 apresenta as alterações definidas a partir do
Código 114.
www.esab.edu.br 264
Código 117 – Arquivo de validação
1 <?php
2 require('Validacoes.inc');
3 class Cliente {
$telefone, $cpf;
5 function validaCPFInterno($cpf){
6 return validaCPF($cpf);
7 }
8 function validaTelefoneInterno($telefone){
9
10 }
11 function validaemailInterno($email){
12
13 }
$cidade, $telefone, $cpf){
15 try {
17 $this->email = $this-
>validaemailInterno($email);
20 $this->telefone = $this->validaTelefoneInt
erno($telefone);
21 $this->cpf = $this-
>validaCPFInterno($cpf);
22 }
24 throw $e;
25 }
26 }
>email.';'.$this->endereco.';'.$this-
>cidade.';'.$this->telefone.';'.$this-
>cidade.';'.$this->cpf.”\r\n”);
32 }
33 }
cliente.txt';
www.esab.edu.br 265
41 try {
$endereco, $cidade, $telefone, $cpf);
44 }
table><br />';
47 }
48 ?>
No Código 117 são, portanto, captadas as variáveis enviadas por Post,

que servem como parâmetros para a criação de instâncias e tratando os
erros, caso eles sejam lançados na definição da função.
Observe que, nas linhas 14 a 26, é definido o constructor, que, por sua
vez, chama a validação das variáveis. Das linhas 15 a 22 temos um bloco
que utiliza o try para interceptar a exceção e, nesse caso, a exceção é
novamente lançada. Isso é feito para que, em caso de erros encontrados
nas validações dos valores, a aplicação possa executar o código que monta
a mensagem de erro, como podemos ver nas linhas 34 e 44.
Novamente o erro é tratado, mas, dessa vez, é lançado através de

mensagem de erro e comando echo ‘’; dessa forma, em caso de exceção, o
fluxo é interrompido e não salva essas informações.
No próximo item veremos a definição de alguns erros de código e como

encontrá-los.
www.esab.edu.br 266
38.2 Testando e encontrando erros
Para confirmar o funcionamento de nossa aplicação e observar se os
erros estão sendo tratados, vamos elaborar um plano de testes. Para isso,
vamos montar uma tabela com quatro testes possíveis: no primeiro teste
criaremos um erro para e-mail; no segundo, forçaremos um erro no
telefone; para o terceiro teste vamos criar um erro para CPF; e, em nosso
último teste, os dados deverão ser validados e o arquivo salvo. Observe
que são validados dados de e-mail, telefone e CPF. A Tabela 10 mostra os
valores inseridos e o resultado esperado.
Tabela 10 – Planejamento do teste.

Teste 1 Teste 2 Teste 3 Teste 4
E-mail Teste.teste.com teste@teste.com teste@teste.com teste@teste.com
Telefone (11)99999-9999 (111)99-9999 (11)99999-9999 (11)99999-9999
Coloque seu CPF
CPF Coloque seu CPF Coloque seu CPF alterando um Coloque seu CPF
dígito qualquer
Mensagem
Mensagem de Mensagem de
de erro 1 –
erro 4 – e-mail erro 5 – telefone Dados gravados
Resultado CPF inválido
inválido (linha inválido (linha corretamente no
Esperado (linha 23 ou
56 do arquivo 65 do arquivo arquivo texto
26 do arquivo
Validacoes.inc) Validacoes.inc)
Validacoes.inc)
A Tabela 10 mostra o planejamento de erros. Em casos tratados, a

mensagem de erro definida deve ser aquela referente ao teste realizado.
Caso o teste 1 seja realizado, espera-se que o resultado seja erro (tratado)
referente a e-mail inválido. Qualquer resultado diferente (outro erro, em
qualquer outra linha do código que não a esperada) força a alteração dos
códigos de forma a garantir o funcionamento esperado. Os tipos de erros
serão detalhados na unidade 41.
Portanto, planejando testes teremos maior assertividade na realização dos

códigos. Assim, temos os erros esperados (e tratados) e, caso ocorra um
erro não esperado, devemos observar, na mensagem do erro, o arquivo e
a linha nos quais o erro ocorre, tratando ou corrigindo tal erro.
www.esab.edu.br 267
Continuando o aplicativo desenvolvido na unidade 37, nesta unidade
você complementou a aplicação desenvolvendo tratamento de exceções.
Dessa forma, o aplicativo, que já reaproveitava código utilizando funções
definidas em um arquivo aplicando em método de classe específica,
possibilita código reaproveitável com tratamento de exceções. Na
unidade 39 vamos controlar sessões, de forma a aproveitar dados de um
script em outro, mesmo que em páginas diferentes. Em frente!
www.esab.edu.br 268
39 Controlando sessões
Objetivo
Apresentar sessões com uso de cookies, bem como o uso de variáveis
de sessão.
Nas unidades anteriores foi desenvolvido um aplicativo que efetua a

leitura de dados de um cliente, realizando validações que utilizavam
expressões regulares e operações com elas, salvavam os dados em arquivo
texto e tratavam possíveis exceções. No entanto, caso tenhamos que
manter alguma ligação entre dados que são definidos durante o tempo
que o usuário está utilizando a aplicação, precisamos fazer uso de sessões
e cookies. Nesta unidade vamos controlar sessões utilizando cookies, nos
fundamentando teoricamente em Thomson e Welling (2005).
39.1 O que é controle de sessão?

Em uma aplicação corriqueira, ao executar um script PHP que faz o link
com outra página ou arquivo, as variáveis que foram criadas/utilizadas não
podem ser reaproveitadas pela nova página exibida. “A ideia de controle de
sessão é ser capaz de monitorar um usuário durante uma única sessão em
um Web site” (THOMSON; WELLING, 2005, p. 328). Dessa forma,
enquanto o usuário estiver navegando pela aplicação, podemos controlar
algumas variáveis a serem utilizadas durante esse período.
As sessões do PHP tem por base um ID único de sessão, um número criptograficamente

aleatório. Esse ID é gerado pelo PHP e armazenado no lado cliente pelo tempo de vida de
uma sessão. Ele pode ser armazenado no computador de um usuário em um cookie ou
passado junto com URLs. (THOMSON; WELLING, 2005, p. 328)
A variável global $_SESSION armazena as informações que podem ser

acessadas durante a existência da sessão. Assim, podemos utilizar variáveis
a partir de $_SESSION, que podem ser criadas em uma classe, arquivo
e, desde que esteja na mesma sessão de navegação, utilizar esse valor em
outra classe ou arquivo.
www.esab.edu.br 269
Para iniciar uma sessão, podemos utilizar a instrução session_start().
Em caso de uso da função sem argumentos, uma sessão é procurada ou
criada, caso não exista.
Dessa forma, o PHP procura o identificador de uma sessão, seja em

argumentos do protocolo HTTP, seja armazenado em um cookie: caso o
identificador seja encontrado, conclui que já existe uma sessão e recupera as
variáveis registradas; caso contrário, assume que não existe uma sessão, gera
um novo identificador (SID) e, consequentemente, cria uma nova sessão.
Considerando que um cookie é uma pequena parte de informações que

os scripts podem armazenar em uma máquina-cliente, quando o usuário
inicia a navegação em uma URL, o navegador pesquisa a existência de
cookies armazenados localmente e, caso encontre informação relevante, a
devolve ao servidor.
Para utilizar cookies para controlar uma sessão devemos configurá-los,

assunto que veremos na próxima seção.
39.2 Configurando cookies e armazenando id da

sessão
A linguagem PHP implementa funções que fazem configuração e
controle de cookies. A função setcokie() configura manualmente um
cookie, tendo como retorno um valor booleano (verdadeiro ou falso) que
determina a criação do cookie (ou não).
Sua sintaxe é:
setcookie ( string $name [, string $value [, int $expire = 0 [, string $path [, string
$domain [, bool $secure = false [, bool $httponly = false ]]]]]])
www.esab.edu.br 270
Apenas o argumento $name é obrigatório e determina o nome do cookie.
O valor do cookie, atribuído à variável $value, pode ser lido através de
$_COOKIE[‘nome do cookie’]. O tempo que expira o cookie, ou seja,
o tempo no qual a informação é valida após o fechamento da sessão, é
definido pelo parâmetro $expire. Caso configurado como 0, a sessão
expira após o fechamento do navegador. Normalmente o controle de
tempo de expiração da sessão é gerido usando a função time() somada
ao tempo, em segundos, para determinar quanto tempo o cookie é
válido após o fechamento. O caminho no servidor é representado pela
variável $path: o valor ‘/’ disponibiliza o cookie por todo o domain e,
se passarmos ‘/foo/’, disponibilizamos o cookie para o diretório ‘/foo/’ e
seus subdiretórios. A variável $domais determina o domínio para qual o
cookie está disponível, como ‘www.exemplo.com.br’. A variável $secure
indica se o cookie poderá ser transmitido somente com uma conexão
segura (https), enquanto a variável httponly determina se o cookie
estará disponível somente sob o protocolo http, não deixando o cookie
disponível, por exemplo, para ser acessível por linguagens de script.
Caso a criação do cookie através dessa função aconteça, o resultado será

verdadeiro (True). Em caso de falha, o retorno será falso.
O Código 118 apresenta um exemplo de definição de um cookie.
Código 118 – Criando Cookie

1 <?php
2 $value = 'alguma coisa de algum lugar';
3 setcookie("CookieTeste", $value);
4 ?>
Na linha 2 do Código 118 é definido um valor a ser armazenado no

cookie. Na linha 3 é criado o cookie com o nome “CookieTeste” e com
o valor definido na linha 2. O Código 119 apresenta o conteúdo desse
cookie criado.
www.esab.edu.br 271
Código 119 – Visualizando o conteúdo do Cookie
1 <?php
2 echo $_COOKIE["CookieTeste"];
3 print_r($_COOKIE);
4 ?>
A linha 2 do Código 119 utiliza a variável $_COOKIE de modo

a apresentar o seu valor. Nesse caso, apresenta o valor da variável
CookieTeste, definida no Código 118, ou seja, apresenta na tela o valor
‘alguma coisa de algum lugar’ (linha 2). A linha 3 apresenta os valores de
todos os cookies definidos. Com a definição do CookieTeste retornaria,
na tela, o valor Array ( [CookieTeste] => alguma coisa de algum lugar )
Para criar uma sessão e gravar o seu identificador (id) em um cookie,

utilizaremos o Código 120.
Código 120 – Criando cookie e salvando SID

1 <?php
2 session_start();
3 setcookie("sessaoID", session_id());
4 ?>
O Código 120 cria uma sessão simples através do método utilizado na

linha 2 e armazena o seu ID no cookie com o nome sessaoID, através do
comando da linha 3. O Código 121 consome o cookie criado.
Código 121 – Visualizando conteúdo do cookie com SID

1 <?php
2 echo $_COOKIE["sessaoID"];
3 ?>
O Código 121 simplesmente apresenta o ID da sessão criada na tela.
www.esab.edu.br 272
Deve ter ficado claro para você que o objetivo de demonstrar o uso
de sessão e de cookies, até este momento, é o de possibilitar o uso de
informações oriundas de um script em outro, ou seja, impedir que dados
sejam perdidos com uma nova requisição feita ao servidor, que abre um
novo recurso ou página. Na próxima seção programaremos uma sessão
simples e veremos como a implementamos.
Para sua reflexão

O uso de cookies possibilita o controle de
atividades realizadas pelo usuário, facilitando o
atendimento quando se leva em consideração os
gostos e as preferências do usuário para aproximar
as informações relevantes (o critério de relevância
é o histórico, ou seja, se uso uma mesma
informação por diversas vezes, é mais relevante).
Porém, como você observa o uso da leitura de
cookies para fins de propaganda?
39.3 Implementando sessões simples

Para entendermos o uso de sessões e de cookies vamos fazer um aplicativo
simples, que efetua leitura do nome do usuário e apresenta esse valor em
outros dois scripts, além de salvar um cookie com o valor. Caso já tenha
visitado a página, encontre o valor do cookie que estará preenchido na
caixa de edição com o devido valor.
Inicialmente, vamos desenvolver um formulário que efetua a leitura do

nome do usuário e define um botão que será processado por outro script
PHP, iniciando uma sessão e que salvará o valor para o cookie. Caso já
exista um cookie, carrega o valor na caixa de texto de login.
www.esab.edu.br 273
O Código 122 apresenta a definição de formulário, bem como o teste se
existe o cookie.
Código 122 – Formulário de login

01 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0
Transitional//EN" "http://www.w3.org/TR/
xhtml1/DTD/xhtml1-transitional.dtd">
02 <html xmlns="http://www.w3.org/1999/xhtml">
03 <head>
04 <title>Login</title>
05 </head>
06 <body>
07 <div id=form2>
08 <form name="form1"
id="form1" method="post" action="pagina1.
php">
09 <fieldset >
10 Usuario: <br />
11 <input type="text" name="login" id="login"
size="20" maxlength="20" value = <?php
12 if (isset($_COOKIE["login"])) {
13 echo $_COOKIE["login"];
14 } else {
15 echo "";
16 }?>/>
17 <br /><input
type="submit" value="Efetuar Login" />
18 </fieldset>
19 </form>
20 </div>
21 </body>
22 </html>
O Código 122 define um formulário, como vários que já desenvolvemos

até então. Na linha 8 observamos que o processamento desse formulário
chama um script chamando pagina1.php, que será desenvolvido no
Código 122. Na definição da caixa de texto, na linha 13, o valor da
propriedade value chama um pequeno script que testa a existência de
cookie. Caso exista, como testado na linha 14, o valor apresentado como
valor da caixa de texto será o valor contido no cookie e, caso contrário,
escreve valor vazio. A primeira execução (não criou o cookie) apresenta a
página com a caixa de texto sem conteúdo.
www.esab.edu.br 274
Para o processamento é necessária a leitura das informações enviadas pelo
método post, o qual deve criar a sessão salvando a variável de sessão e
também o cookie, como pode ser observado no Código 123.
Código 123 – Processando valor enviado, criando cookie e sessão

01 <?php
02 session_start();
03 $login = $_POST['login'];
04 $_SESSION["login"] = $login;
05 setcookie("login", $login);
06 echo 'O Usuário '. $_SESSION["login"] . '
está logado';
07 echo "<a href='pagina2.php'> Próxima página
</a>";
08 ?>
Lembre-se de salvar o Código 123 como pagina1.php, como foi

definido no Código 122. Na linha 2 do Código 123 é criada a sessão. O
processamento do valor enviado no formulário anterior é feito obtendo
o valor da variável $_POST, como observado na linha 3. A linha 4
apresenta a criação da variável de sessão chamada login, com o valor
recebido do formulário anterior e, na linha 5, é criado o cookie com
o mesmo valor. Ao cookie não foi definido tempo de expiração e ele
possibilita que, na próxima vez que for feita a chamada do script definido
no Código 122, o valor da caixa de texto seja preenchido com o último
login. A linha 6 apresenta uma mensagem contendo o valor da variável
de sessão. Para chamarmos novo script e observarmos que as variáveis
de sessão são mantidas utilizamos uma referência, como na linha 7. O
Código 124 apresenta novo script.
Código 124 – Visualizando conteúdo da variável de sessão

01 <?php
02 session_start();
03 echo 'O Usuário '. $_SESSION["login"] . '
ainda está logado, recuperando valor da
variável';
04 ?>
www.esab.edu.br 275
Novamente, lembre-se de salvar o Código 124 como pagina2.php,
como foi definido na linha 7 do Código 123. Na linha 2, chamando o
método session_start(), visto a existência de sessão, é recuperada a sessão
existente. A linha 3 apresenta valor da variável de sessão, mostrando que
é possível recuperar tal informação enquanto mantemos a navegação.
A Figura 53 mostra o resultado da execução dos scripts.
Figura 53 – Resultado da execução dos códigos definidos na unidade.

A Figura 53 nos apresenta, da esquerda para a direita, o resultado do

script definido no Código 122 e que cria o formulário, solicitando dado
do usuário. Nesse teste apresentado, o valor “user” foi dado como entrada
na caixa de texto e submetido o formulário; o script definido no Código
123 é apresentado na segunda janela, mostrando que foi processado o
valor enviado e que foi possível recuperar o valor de variável de sessão;
a terceira janela apresenta o resultado do Código 124, novamente
recuperando valor da variável de sessão. A última janela mostra,
novamente, execução do Código 122, porém, dessa vez, recuperando o
valor da variável salva no cookie.
Nesta unidade foram apresentados conceitos de sessão e uso de cookies.

Foi demonstrado como o valor de variáveis de sessão pode ser recuperado
enquanto se mantém tal sessão, de modo a possibilitar a continuidade
na navegação, aproveitando dados dos scripts anteriores. Na unidade
40 vamos abordar assunto relacionado às boas práticas da codificação.
Vamos lá?
www.esab.edu.br 276
Estudo complementar
O controle de sessões e cookies é assunto de artigo
“Cookies e Sessões em PHP”, escrito por João
Martins. Nele o autor apresenta o uso e alguns
exemplos práticos de cookies e sessões. Você pode
acessar o material clicando aqui.
www.esab.edu.br 277
40 Definindo padrões de codificação
Objetivo
Apresentar a utilização de padrões de desenvolvimento de código
de forma a construir projetos sustentáveis e com boa capacidade de
manutenção.
Na unidade 39 foram estudados conceitos de controle de sessão e cookies.

Em todas as unidades desenvolvidas até este momento foram criados vários
códigos, porém, em todos os casos apresentados foi pensada a codificação
desenvolvida por uma única pessoa. Em projetos maiores é necessária
uma padronização de forma a garantir o entendimento do código pelos
membros da equipe, o que será estudado nesta unidade. Utilizaremos
Thomson e Welling (2005) como referencial teórico.
40.1 Escrevendo código sustentável

O trabalho em equipe, ou seja, o fato de uma pessoa poder executar
alterações em código desenvolvido por terceiros, bem como casos de
projetos complexos ou de um número grande de processos dificultarem
a recuperação de memória sobre o trabalho e, com isso, o entendimento
dos códigos, revelam a preocupação com relação à manutenção de
códigos. Tais problemas exigem do desenvolvedor investir um pouco de
tempo para o entendimento dos códigos, para que, desse modo, possa
efetuar manutenções corretivas (quando se corrige uma falha do sistema)
ou manutenções evolutivas (quando se promove a evolução do software),
principalmente com o incremento de novas funções.
Sendo assim, para que a manutenção seja possível e os projetos possam

“durar” por um bom tempo, tornando-se projetos sustentáveis (códigos
sustentáveis), ou seja, não sendo abandonados pela dificuldade de se manter
os códigos, é necessária a presença de algumas características no código.
www.esab.edu.br 278
Uma das grandes necessidades para a manutenção de códigos é a
definição de padrões de codificação. Esses padrões de desenvolvimento
de códigos representam o estilo de escolha de nomes de variáveis e de
métodos, diretivas para comentários em códigos.
Thomson e Welling (2005) esclarecem que a definição de nomes de

variáveis e métodos visa:
• tornar o código mais fácil para leitura, de modo a conseguir ler

o código praticamente da maneira como leria uma frase em seu
idioma;
• tornar nomes de identificadores mais fáceis de lembrar.
Os nomes das variáveis e dos métodos devem descrever o seu conteúdo,
ou seja, ao visualizarmos o nome da variável, devemos entender
rapidamente o seu funcionamento. Por exemplo, ao salvar o nome de
alguém, utilize uma variável como $sobrenome. Para salvar dados sobre
data de nascimento, por exemplo, $dataNascimento seria um bom nome.
Segundo Thomson e Welling (2005), você deve escolher como

definir padrão sobre a utilização de maiúsculas e minúsculas. Nesse
sentido, $dataNascimento, $data_nascimento e $datanascimento são
formatos diferentes de escrita e, ao definir um padrão, este deve ser
compartilhado para que todos os atores envolvidos no desenvolvimento
sigam o mesmo modelo.
O uso de comentários tem como objetivo esclarecer pontos do código

ou mesmo clarificar ou adicionar ao código um texto que pode ser
usado como lembrete. Thomson e Welling (2005) defendem o uso de
comentários nos seguintes casos:
• arquivos (scripts completos ou arquivos includes): cada arquivo deve

conter um comentário definindo que arquivo é esse, sua função,
quem o escreveu e quando foi atualizado;
• funções: os comentários devem especificar o que faz a função, qual
entrada ela espera e o retorno definido;
www.esab.edu.br 279
• classes: os comentários devem definir o propósito da classe e, para
métodos, deve-se considerar a mesma forma de uso de comentários
de funções;
• fragmentos de código dentro de um script ou função: dependendo
da complexidade, é pertinente comentar códigos de modo a facilitar
o entendimento de suas partes ou conjunto de instruções;
• código completo: quando da definição de códigos complexos,
ou daqueles que demandaram várias horas de desenvolvimento,
é importante descrever o seu funcionamento para facilitar o
entendimento.
Thomson e Welling (2005) completam que os códigos devem ser
comentados à medida que se avança, evitando o retorno para inserir os
comentários após o término da codificação.
Para sua reflexão

Caso você tenha que efetuar alterações em código
escrito por outra pessoa, como você espera que o
código seja escrito para efetuar tais manutenções?
40.2 Otimizando código

A otimização de códigos está diretamente ligada ao desempenho de
sua execução. Thomson e Welling (2005, p. 399) apresentam algumas
otimizações simples para melhoria do desempenho dos códigos:
• Minimize a geração de conteúdo estático a partir do PHP. Se todo o fragmento de

HTML que você produzir vier de echo ou print(), isso exigirá muito mais tempo. [...]
Isso também se aplica a gerar dinamicamente imagens de botão - talvez você queira
utilizar PHP para gerar botões uma vez e então reutilizá-los conforme necessário. Se
você estiver gerando páginas puramente estáticas a partir de funções ou modelos
toda vez que a página carregar, considere executar as funções ou utilizar modelos
uma vez e salvar o resultado.
www.esab.edu.br 280
• Utilize as funções de string em vez de expressões regulares sempre que possível. Elas
são mais rápidas.
• Utilize onde for possível strings de aspas simples em vez de strings de aspas duplas.
O PHP avalia strings de aspas duplas, procurando variáveis de substituição. As strings
de aspas simples não são avaliadas. Por outro lado, se elas tiverem aspas simples,
provavelmente o conteúdo é estático. Revise o que está fazendo e veja se pode
eliminar completamente a string transformando em HTML estático.
Dessa forma, tomando esses pequenos cuidados mencionados por
Thomson e Welling (2005), assim como os cuidados em relação às
conexões de banco de dados, o código pode ficar mais fácil de entender,
além de desempenhar suas funções com melhor performance.
40.3 Testando o código

Revisar e testar o código são atividades básicas que normalmente não
são completamente atendidas no desenvolvimento de aplicativos. É
comum executar o sistema em dois ou três casos e considerar o teste
como conclusivo, o que se mostra um equívoco, visto que muitos erros
podem ter passado despercebidos ou mesmo o teste pode ter considerado
somente o fluxo correto de execução, não observando que o usuário pode
seguir um caminho alternativo, o qual não foi impedido pela aplicação.
Sabe-se que é impossível eliminar todos os bugs contidos em um

aplicativo. No entanto, de acordo com Thomson e Welling (2005, p.
400), uma boa revisão pode diminuir:
• Erros que você não enxergou;

• Casos de teste sobre os quais você não pensou;
• Otimização;
• Melhoras na segurança;
• Componentes existentes que você poderia utilizar para melhorar parte do seu código;
• Funcionalidade adicional.
www.esab.edu.br 281
Observe que, diminuindo a ocorrência dos elementos mencionados
anteriormente, a percepção de qualidade da aplicação, sob o ponto de
vista do usuário, é alterada positivamente.
É uma boa prática encontrar um companheiro de código, ou seja, algum

colega que não esteja com o olhar “viciado” somente na observação das
regras de negócio válidas e implementadas, mas que possa apontar erros.
Outra prática que vem crescendo é o uso de testes automatizados, nos

quais softwares efetuam testes com base em saídas esperadas, as quais são
relacionadas às suas entradas.
Além disso, podemos encontrar testadores na web que podem representar

os usuários, simulando a utilização dos aplicativos. Dessa forma, quando
você acreditar que eliminou a maioria dos erros, pode disponibilizar o
aplicativo para um grupo de usuários que encontrarão novos erros e/
ou farão a aplicação amadurecer, o que chamamos de teste beta. O
levantamento de erros pelos usuários, durante o teste beta, é relatado ao
desenvolvedor da aplicação de forma a possibilitar a sua correção antes de
liberar a versão final, que chega com número menor de erros.
Por fim, destacamos que boas práticas de teste de código tendem a

contribuir fortemente com a qualidade final do aplicativo desenvolvido.
Nesta unidade estudamos boas práticas que objetivam a melhoria no

entendimento do código e na manutenibilidade de testes. Na unidade 41
vamos utilizar depuração de código para entendermos o funcionamento
dos scripts, passo a passo, podendo, inclusive, ser aplicada para testes
mais minuciosos. Vamos lá?
www.esab.edu.br 282
Estudo complementar
É crescente o número de ferramentas que
possibilitam o teste automatizado, no qual não é
diretamente utilizado um usuário para efetuar os
testes. O artigo “Automação de testes funcionais
com Selenium”, de Ismayle de Sousa Santos e
Pedro de Alcântara dos Santos Neto, aborda o
conceito dos testes automatizados e apresenta a
ferramenta Selenium. Disponível clicando aqui.
www.esab.edu.br 283
41 Depurando o código
Objetivo
Apresentar o uso de depuradores, de forma a encontrar erros de
sintaxe, erros de tempo de execução e erros de lógica.
Na unidade 40 estudamos padrões de codificação para aumentar o

desempenho da manutenção da aplicação e alterações de códigos,
tanto corretivas quanto evolutivas. Um dos pontos estudados foi o
planejamento de testes que visam contribuir com a qualidade final do
aplicativo desenvolvido, como o teste beta. Nesta unidade veremos o
processo de busca por erros (erros de sintaxe, erros de tempo de execução
e erros de lógica) a partir da utilização de depuradores. Nos basearemos
em Thomson e Welling (2005). Vamos lá?
41.1 Encontrando erros de sintaxe

Para entendermos o processo de busca de erros, temos que entender o
que significa sintaxe. Em qualquer idioma, linguagem ou língua há regras
e instruções de como devem ser construídas as orações e instruções.
Isso vale tanto para idiomas, como o português e o inglês, quanto para
linguagens de programação, como a PHP. Na verdade, até este ponto
você encontrou diversas vezes a definição de instruções e o uso da palavra
sintaxe. Anteriormente, vimos que a sintaxe é o conjunto de regras
que define as sequências corretas dos elementos e comandos. Se você
conseguiu construir os códigos até este momento, teve que respeitar essas
regras de definição de sintaxe.
Thomson e Welling (2005) apontam que se uma pessoa não cumprir

todas as regras de sintaxe ao comunicar-se usando um idioma, como
inglês ou português, o conteúdo pode ser suficiente para o entendimento;
no entanto, este não é o caso das linguagens de programação, como
reiteram os autores. Thomson e Welling (2005, p. 403) completam:
www.esab.edu.br 284
Se um script não seguir as regras do PHP – isto é, contiver erros de sintaxe – o
analisador de sintaxe do PHP não será capaz de processar parte do script ou todo
o script. As pessoas são boas em inferir informações a partir de dados parciais ou
contraditórios. Os computadores não.
Uma das regras fundamentais da linguagem PHP dita que uma

instrução deve ser terminada com ponto e vírgula, que strings devem ser
delimitadas por aspas e que os parâmetros passados a uma função devem
ser separados por vírgula e incluídos entre parênteses. Se desobedecermos
a uma dessas regras, nosso script não funcionará e, provavelmente, gerará
uma mensagem de erro. O Código 125 apresenta um erro de sintaxe:
Código 125 – Script com erro de sintaxe

01 <?php
02 $date = date('m.d.y);
03 ?>
Observe que, na linha 2 do Código 125, a chamada da função date, que

exige como parâmetro uma string com o formato da data a ser apresentada
(por exemplo: ‘dd/mm/yyyy’ apresenta uma data com dois dígitos para
dia, dois dígitos para mês e quatro dígitos para ano, separados por barra
“/”), recebe uma string sem a devida delimitação, ou seja, as aspas não são
fechadas. Ao ser executada (lembre-se de que a PHP é uma linguagem
interpretada, como vimos na unidade 3, logo, o erro só é apresentado na
execução), o script gera um erro, apresentado na Figura 54.
Figura 54 – Resultado da execução dos códigos com erro de sintaxe.

A Figura 54 traz um erro de sintaxe (syntaxe error), mostrando que era

esperado o fechamento da string no arquivo processado e determinando
a linha na qual acontece o erro: nesse caso, na linha 2 (line 2).
www.esab.edu.br 285
Dica
O não fechamento de blocos corresponde a um
erro de sintaxe que, ao ser apresentado, define a
linha final como local do erro, no qual é esperado
$end. Dessa forma, procure um bloco que é aberto
(com “{“), mas sem ser devidamente fechado
(com “}”). Nesse caso, o erro é apresentado como
se ocorresse no final do arquivo, apesar de não se
tratar exatamente de uma falha nesse local.
Os erros de sintaxe são, portanto, aqueles que desrespeitam as regras

definidas na linguagem. Após a sua localização, esses erros são facilmente
corrigidos. Na próxima seção veremos erros de tempo de execução.
41.2 Encontrando erros de tempo de execução

Os erros de tempo de execução podem ser mais difíceis de encontrar
e corrigir. Acontecem quando a instrução não contém erro algum de
sintaxe, mas alguma condição ou dependência para a execução do
comando não é respeitada. Um exemplo disso é o uso de arquivos
requeridos: se adicionarmos a instrução require (‘arquivoInexistente.
php’); e esse arquivo não existir ou tiver a permissão de leitura negada,
apesar de não existir erro algum de sintaxe – todas as regras são
respeitadas –, a condição de existência (ou de acesso ao arquivo) do
arquivo não é respeitada.
Outro exemplo acontece quando dividimos um número por zero. Muitas

vezes o erro pode até não ser apresentado e em outras ocasiões sim, o
que pode intrigar o programador. Isso se dá, principalmente, quando é
recebido parâmetro (ou resultado de um cálculo preliminar) usado em
uma divisão. O Código 126 apresenta um exemplo disto.
www.esab.edu.br 286
Código 126 – Script com erro de tempo de execução – divisão por zero
01 <?php
02 function divisao ($n1, $n2){
03 return $n1/$n2;
04 }
05 echo divisao(10, 5);
06 echo divisao(10, 0);
07 ?>
O Código 126 apresenta uma função que efetua cálculo de divisão

entre dois números enviados por parâmetro, como definido na linha 2,
e com retorno definido na linha 3. Já as linhas 5 e 6 apresentam duas
chamadas da mesma função. Ao executar o Código 126, observamos que
a chamada da linha 5 apresenta o resultado esperado (mostrando, na tela,
o número 2), enquanto a chamada à função divisao() realizada na linha 6
apresenta erro de divisão por zero.
Os principais erros de tempo de execução são enumerados por Thomson

e Welling (2005, p. 404), observe:
• Chamada de funções que não existem;

• Ler ou gravar arquivos;
• Interações com MySQL ou outros bancos de dados;
• Conexões com serviços de redes;
• Falha na verificação dos dados de entrada.
Dessa forma, mesmo que sintaxe e todas as regras de definição de
instruções sejam respeitadas, o script pode apresentar erros. Os tipos de
erros mencionados pelos autores são os principais, porém, não são os
únicos. Tenha cuidado ao se deparar com o erro e procure identificar o
motivo, para, posteriormente, efetuar a sua correção. Ainda temos os
erros de lógica, que serão apresentados na próxima seção.
www.esab.edu.br 287
41.3 Encontrando erros de lógica
Os erros de lógica são os mais difíceis de encontrar ou eliminar, pois não
apresentam mensagens de erro na tela, visto que a aplicação atende a
todos os quesitos de sintaxe e de tempo de execução. Porém, não atende
às regras de definição da execução, que norteiam a escrita do script.
Como exemplo consideremos o cálculo de médias de alunos, contendo
três notas. Nesse caso, a aplicação calcula a média ponderada entre as
notas e, caso seja maior ou igual a 7, é apresentada na tela a mensagem
de aprovação. O Código 127 apresenta o desenvolvimento desse script,
porém, com erro de lógica.
Código 127 – Script com erro de lógica

01 <?php
02 $n1 = 10;
03 $n2 = 9;
04 $n3 = 10;
05 $media = ($n1 + $n2 + $n3) / 3;
06 if ($media <=7){
07 echo 'Aprovado';
08 } else {
09 echo 'Reprovado';
10 }
11 ?>
Aparentemente, não existe nada de errado com o Código 127. Porém,

ao executar, apesar de o cálculo da média com as variáveis definidas nas
linhas 2, 3 e 4 atribuir a média 9.66 e o aluno estar aprovado, o resultado
apresentado na tela é “Reprovado”. Isso ocorre porque a lógica aplicada
na linha 6 está invertida. A instrução if, na linha 6, apresenta o teste
como menor ou igual (<=) e o correto é maior ou igual (>=). Alterando o
teste lógico, o script executa corretamente o objetivo.
Dessa forma, os erros de lógica merecem um cuidado maior e uma visão

mais detalhada do código quando ocorrerem.
www.esab.edu.br 288
Nesta unidade foram apresentados conceitos de testes para depuração
e alguns exemplos de como encontrar erros de sintaxe, erros de tempo
de execução e erros de lógica. Na unidade 42 estudaremos a criação de
documentos RTF e PDF para gerar relatórios em nossas aplicações web.
Saiba mais
O Portal de PHP da comunidade portuguesa de
PHP apresenta como configurar o Apache e o
Eclipse PDT para fazer o debug (depuração), ou
seja, efetuar a execução com paradas ou passo a
passo (cada um dos comandos), podendo obter
os valores intermediários das execuções. Dessa
forma, conhecendo os valores intermediários,
o processo de correção de erros é facilitado.
Disponível clicando aqui.
www.esab.edu.br 289
42 Gerando documentos RTF e PDF
Objetivo
Apresentar o desenvolvimento de documentos RTF e PDF.
Na unidade 41 foram estudados conceitos relacionados ao processo de

busca de erros para melhorar a qualidade do aplicativo e como identificar
erros de sintaxe, erros de tempo de execução e erros de lógica. Nesta
unidade estudaremos como criar relatórios gerando arquivos RTF e PDF,
utilizando como base teórica Thomson e Welling (2005). Vamos lá?
42.1 Gerando um RTF

Documentos Rich Text Format (RTF) trazem uma boa gama de
possibilidades de formatação de texto, apresentando flexibilidade de layout
e de formatação da página impressa. Trata-se de um formato suportado por
grande parte dos editores de textos (LibreOffice Writer, Microsoft Word,
Write etc.) e que apresenta semelhança com o HTML, com sintaxe e
palavras-chave para transportar as definições de formatação.
A solução apresentada por Thomson e Welling (2005) para gerar um

documento RTF passa pelo desenvolvimento de um modelo RTF usando
marcadores que serão substituídos por textos na aplicação, mostrando,
portanto, um novo arquivo, mesclando os dados.
A seguir vamos escrever um modelo RTF para o desenvolvimento de um

relatório, utilizando um editor de texto de sua preferência e, a partir daí,
preencher o relatório com dados de nossa aplicação e disponibilizá-lo ao
usuário da aplicação. Observe com atenção a Figura 55.
www.esab.edu.br 290
Figura 55 – Escrevendo modelo de RTF usando Write.
A Figura 55 mostra um arquivo RTF elaborado no Write, aplicativo que é

instalado com o Windows. Você pode elaborar o documento em qualquer
editor de sua preferência. Nosso documento apresenta uma imagem e
texto. Observe que o texto inclui marcadores como <<nome>> para marcar
o local onde serão inseridos os dados dinâmicos (que serão substituídos por
valores de nossa aplicação). Por conveniência, usamos os símbolos maior e
menor duplamente em sequência para delimitar, mas poderíamos utilizar
outro qualquer. De todo modo, é importante que não apareça o símbolo
marcador em locais nos quais o texto não deva ser substituído.
Agora vamos desenvolver o script que recebe os dados que serão atribuídos
em nosso documento e que monta o documento final, salvando-o e
disponibilizando ao usuário. O Código 128 apresenta tal definição.
www.esab.edu.br 291
Código 128 – Script com desenvolvimento de documento RTF a partir de modelo
01 <?php
02 $nome = 'seu nome';
03 $curso = 'seu curso';
04 $cidade = 'Florianópolis';
05 $data = '01 de janeiro de 2014';
06 $nomeArquivo = 'testeRelatorio.rtf';
07 $rtf = file_get_contents($nomeArquivo);
08 $rtf = str_replace('<<nome>>', $nome, $rtf);
09 $rtf = str_replace('<<curso>>', $curso,
$rtf);
10 $rtf = str_replace('<<cidade>>', $cidade,
$rtf);
11 $rtf = str_replace('<<data>>', $data, $rtf);
12 header('Content-type: application/rtf');
13 header('Content-Disposition: attachment;
filename=Relatorio.rtf');
14 echo $rtf;
15 ?>
O Código 128 apresenta, nas linhas 2 a 5, atribuição de variáveis que

substituirão os valores dos marcadores em nosso modelo, onde você
deve substituir por seus dados. Essas variáveis poderiam ser recebidas
por método post de um formulário ou recuperadas de outra forma. Na
linha 6 é atribuído à variável $nomeArquivo o endereço de nosso arquivo
modelo. Nesse caso não foi definido endereço completo, pois o modelo
encontra-se na mesma pasta que o arquivo PHP. Caso use uma pasta de
modelos, utilize o caminho interno (relativo ao PHP) para chegar até o
arquivo. Na linha 7 a instrução file_get_contents() obtém o conteúdo do
arquivo modelo (cujo endereço foi atribuído à variável $nomeArquivo),
atribuindo-o à variável $rtf. A linha 8 procede a substituição do texto do
marcador <<nome>> pelo valor da variável $nome da variável $rtf, que
contém o conteúdo do nosso modelo. Em nosso modelo utilizamos o
marcador <<nome>> duas vezes, logo, ele substituirá as duas vezes. Da
mesma forma, os outros marcadores utilizados no modelo são substituídos
por valores, nas linhas 8 a 11. As linhas 12 e 13 atribuem valores ao
cabeçalho do arquivo, definindo se este se trata de um documento RTF
e o modo com que deve ser aberto como anexo à aplicação, o que é feito
com o nome ‘Relatorio.rtf ’. A linha 14 exibe o conteúdo que apresenta
uma tela para download do arquivo que pode ser aberto.
www.esab.edu.br 292
Executando o Código 128 será apresentado o documento. Observe a
Figura 56 com o resultado.
Figura 56 – Tela de download e resultado.

A Figura 56 traz, em seu lado esquerdo, o resultado da execução do

script, apresentando tela de download (para baixar o arquivo) e, em seu
lado direito, o documento resultante da execução. Observe que esse
documento, se comparado ao documento apresentado na Figura 55,
apresenta a mesma estrutura e formatação com as substituições definidas.
Na próxima seção utilizaremos esse modelo, porém, apresentando um

documento PDF para o usuário.
42.2 Gerando um PDF a partir de um modelo

Thomson e Welling (2005) apresentam um grande número de soluções
para a geração de documentos Portable Document Format (PDF),
como utilizar um PDF de modelo (que necessita do Adobe Acrobat,
uma ferramenta paga) ou usar uma biblioteca específica para o
desenvolvimento de documentos PDF: PDFlib.
Faremos uso de uma estratégia semelhante para a geração de PDF,

utilizando uma biblioteca com maior difusão atualmente entre os
desenvolvedores de aplicações PHP, chamada FPDF. O F significa Free,
isto por se tratar de uma ferramenta gratuita.
www.esab.edu.br 293
Para utilizar essa biblioteca, primeiramente faça o download de sua
última versão no site <http://www.fpdf.org/>, na seção de downloads.
Em seguida, descompacte os arquivos em uma pasta, sendo preciso
copiar, para a pasta na qual está seu script, o arquivo fpdf.php e a pasta
fonts, necessária para o funcionamento da classe.
Vamos demonstrar o funcionamento da classe FPDF criando um

exemplo, definido no Código 129.
Código 129 – Script com desenvolvimento de documento RTF a partir de modelo

01 <?php
02 $nome = 'seu nome';
03 $curso = 'seu curso';
04 $cidade = 'Florianópolis';
05 $data = '01 de janeiro de 2014';
06 require_once 'fpdf.php';
07 $pdf = new FPDF();
08 $pdf->AddPage('P', 'A4');
09 $pdf->Image('icon-biblioteca.png', 10,8,22);
10 $pdf->SetFont('Arial', 'B', 15);
11 $pdf->Cell(80);
12 $pdf->Cell(30, 10, 'Relatório teste', 0, 0,
'C');//'Pessoas' centralizado no meio da
página
13 $pdf->Ln(20);
14 $pdf->SetFont('Arial', '', 11);
15 $pdf->Cell(90, 6, 'O presente relatório foi
desenvolvido por '. $nome . 'aluno do curso
'. $curso .', demonstrando o uso do PDF.',
0);
16 $pdf->Ln(10);
17 $pdf->Cell(90, 6, $cidade . ', '. $data);
18 $pdf->Ln(20);
19 $pdf->Cell(90, 6, $nome);
20 $pdf->Output('testeRelatorio.pdf', 'D');
21 ?>
O Código 129 apresenta, nas linhas 2 a 5, atribuição de variáveis que

serão adicionadas ao nosso arquivo PDF. Assim como fizemos com o
modelo RTF, essas variáveis poderiam ser recebidas por método post de
um formulário ou recuperadas de outra forma. Na linha 6 é solicitada
a inclusão do arquivo fdpf.php, ou seja, vamos reutilizar o código desse
www.esab.edu.br 294
arquivo, o qual contém a classe FPDF. Mas atenção! Lembre-se de que o
arquivo deve estar na pasta na qual se encontra o nosso script. Na linha
7 é criada a instância dessa classe e esta é atribuída à variável $pdf. Essa
variável será utilizada para as operações até a geração do PDF. Na linha
8 é executado método que inclui uma nova página, que, nesse caso, é no
formato A4. A linha 9 insere uma imagem usando o método image, que
pode receber como parâmetro o caminho da imagem, as coordenadas
x e y da imagem, a largura da imagem, a altura da imagem, o tipo da
imagem (pdf, png etc.) e um link que será adicionado à imagem –
somente o caminho é obrigatório. A linha 10 altera a configuração de
fonte, definindo tamanho, efeito (‘B’ representa negrito ou bold, em
inglês) e tamanho. Na linha 10 o texto definido é negritado, tamanho
15, enquanto o método SetFont definido na linha 14 define o texto sem
efeito de tamanho 11. A linha 11 apresenta o uso do método Cell() e
define um espaço de texto (chamado célula) que, nesse caso, não tem
texto. O método Cell() é aplicado também na linha 12. Os parâmetros
do método Cell() são, respectivamente: a largura da célula (caso usar
0, estenderá até o lado direito da página, ocupando 100% da largura),
a altura da célula, o texto a ser inserido na célula, a borda (0 para sem
borda, 1 para inserir borda), o local onde será iniciada a escrita após
a função (0 fica à direita, 1 no início da próxima linha, 2 abaixo), o
alinhamento (L à esquerda, C centralizado e R alinhado à direita) e o
fundo que será inserido (true ou false).
Na linha 13 chamamos o método Ln(), que define uma linha em branco

do tamanho que é definido o parâmetro. Observe que, na linha 15, os
textos que constam no nosso modelo são concatenados com o valor das
variáveis, deixando o documento PDF com os dados definidos. Por fim,
o método Output envia o documento ao navegador, recebendo como
parâmetro o nome do arquivo e o destino (I envia o arquivo para o
navegador com a opção de ‘salvar como’; D envia o arquivo ao navegador
para download; e F salva o arquivo em uma pasta local). Executando o
Código 129 será apresentado o documento PDF.
Nesta unidade estudamos a criação de documentos RTF e PDF para

gerar relatórios em nossas aplicações Web. Nas próximas unidades
desenvolveremos um aplicativo completo, de modo a fixar o conteúdo
estudado. Até lá!
www.esab.edu.br 295
Resumo
Na unidade 37 reforçamos o conceito de reutilização de código

desenvolvendo um arquivo que contém funções que podem ser
reaproveitadas e aplicando-o dentro de uma função de uma classe
específica. Esse processo possibilitou o reaproveitamento do código
(utilizado em mais arquivos ou classes) e, em caso de manutenção,
permite também a alteração em ponto único.
O aplicativo desenvolvido na unidade 37 foi utilizado como base para

a unidade 38, na qual complementamos a aplicação desenvolvendo
tratamento de exceções, de forma a possibilitar o uso das funções
definidas de maneira mais elegante e coesa, podendo apresentar a exceção
de uma maneira mais confortável ao usuário.
Os conceitos de sessão e uso de cookies foram apresentados na unidade

39. Nesta unidade foi demonstrado como o valor de variáveis de
sessão pode ser recuperado enquanto se mantém tal sessão, de modo a
possibilitar continuidade na navegação e aproveitamento dos dados dos
scripts anteriores.
Na unidade 40 estudamos boas práticas que objetivam a melhoria no

entendimento do código, na manutenibilidade e nos testes. Foi estudado
o uso de nomes padronizados para variáveis, funções, arquivos etc., de
modo a facilitar a compreensão do código. Também apresentamos o
uso de comentários para facilitar esse entendimento. Foram abordadas
pequenas dicas para otimizar o código, deixando-o com melhor
desempenho, além de demonstrar o planejamento e a execução de testes.
Os conceitos de depuração e testes foram abordados na unidade 41.

Nela foi definido como acontecem erros de sintaxe e erros de tempo
de execução, bem como erros de lógica, e vimos alguns cuidados para
encontrá-los e corrigi-los.
www.esab.edu.br 296
Na unidade 42 estudamos a criação de documentos RTF e PDF a partir
de modelos para gerar relatórios em nossas aplicações web.
www.esab.edu.br 297
Desenvolvendo aplicações
43 completas com PHP – parte 1
Objetivo
aprendidos nesta unidade, desenvolvendo códigos limpos com uso de
sessões e, também, um carrinho de compras.
Nas unidades anteriores, aprendemos os principais conceitos e

desenvolvemos aplicações utilizando a linguagem PHP. Nesta
unidade, iniciaremos o desenvolvimento de uma aplicação completa
– uma loja virtual, que será complementada nas próximas unidades.
Desenvolveremos as telas de cadastro de clientes, além dos controles de
sessão utilizados no módulo de administração do sistema. Aplicaremos,
novamente, conceitos de Thomson e Welling (2005) como base teórica.
Vamos lá?
43.1 Desenvolvendo controle de sessão

Para o desenvolvimento da aplicação web a ser elaborada, ou seja, um
carrinho de compras, utilizaremos conceitos de reaproveitamento de
código, apresentados por Thomson e Welling (2005). Então, para que
possamos construir a tela de acesso à aplicação, a qual define a sessão e
o usuário, nosso primeiro passo é o desenvolvimento de cabeçalhos e
rodapés que serão reaproveitados em toda a nossa aplicação. O Código 130
apresenta o cabeçalho da aplicação, que foi desenvolvido considerando o
layout de toda a aplicação, contendo os dados de estilo (CSS).
www.esab.edu.br 298
Código 130 – Cabeçalho da aplicação
loose.dtd">
2 <html>
3 <head>
5 <style>
align:center}
7 h2 { color:000099; font-size:24pt; text-
align:center}
8 h3 { color:000099; font-size:20pt; text-
align:center}
align:center}
10 .dados { color:black; font-size:12pt; text-
align:left}
11 .creditos {color:white; font-size:8pt; text-
align:center}
12 .dadosLogin {color:white; font-size:8pt;
text-align:left}
13 .produtos {font-size:14; text-align:left;
color:000099}
14 .produto-nome {font-size:36; text-
align:center; color:000099}
15 .produto-valor{font-size:16; text-
align:left; color:000099}
16 .botao{width: 59px;height:18px;border:solid
0px;font-family:Calibri, Arial, sans-serif;
color:#fff; font-weight:bold;
17 </style>
18 </head>
19 <body>
21 <tr bgcolor=000033>
22 <td align=left width=100><img src="http://
www.esab.edu.br/wp-content/uploads/2013/07/
icon-biblioteca.png"></td>
23 <td><h1> Loja on-line </h1></td>
24 </tr>
25 </table>
www.esab.edu.br 299
O Código 130 apresenta, na linha 2, a abertura de nossos documentos
(lembre-se de que todo documento HTML a ser retornado deve ser
delimitado pelas tags <html> e </html>). Entre as linhas 5 e 17, são
estabelecidas as folhas de estilo, de forma a utilizar tais definições (de
fontes, de tamanhos, de efeitos etc.) em qualquer script que reutilize o
nosso cabeçalho. Ele também apresenta uma tabela, aberta na linha 20,
que contém uma célula, definida na linha 22, com uma imagem (como
se fosse uma logomarca) e outra célula contendo o texto “Loja on-line”,
formatado pelo estilo h1, conforme definido na linha 23. Na linha 25, a
tabela, iniciada na linha 20, é fechada. Observe que as tags <html> (linha
2) e <body> (linha 19) são abertas, porém, não são fechadas, pois serão
inseridas no rodapé. Salve o conteúdo desse código como header.inc.
Agora vamos escrever o nosso rodapé, conforme consta no Código 131.
Código 131 – Rodapé da aplicação

1 <table width=100% bgcolor=000033 border=0>
2 <tr>
<coloque aqui seu nome> </span></td>
4 </tr>
5 </table>
6 </body>
7 </html>
No Código 131 é definida uma tabela, entre as linhas 1 e 5, com uma

célula, contendo texto de crédito pelo desenvolvimento da aplicação,
onde você pode colocar o seu nome. Observe que utilizamos um estilo
definido no header.inc, e também que as tags body e html estão fechadas
nas linhas 6 e 7, sendo, portanto, utilizados (os Códigos 130 e 131) de
forma combinada. Salve como footer.inc.
Após a consolidação do cabeçalho e do rodapé, devemos definir um

formulário para o acesso à aplicação. Esse formulário deve iniciar uma
sessão e obter dados de um cookie, para preencher o usuário conforme
dado desse cookie. Veja o Código 132.
www.esab.edu.br 300
Código 132 – Script para acesso à aplicação
loose.dtd">
2 <?php session_start();
3 require('header.inc');?>
4 <form name="form1" id="form1" method="post"
action="index.php">
5 <table>
6 <tr>
7 <td>Usuario:</td>
8 <td>
9 <input type="text" name="login" id="login"
size="20" maxlength="20" value =
10 <?php
11 if (isset($_COOKIE["login"])) {
12 echo $_COOKIE["login"];
13 } else {
14 echo “”;
15 }?>/>
16 </td>
17 </tr>
18 <tr>
19 <td>Senha:</td>
20 <td><input type="password" name="senha"
id="senha" size="20" maxlength="20"/>
21 </td></tr>
22 <tr>
23 <td colspan="2">
24 <input type="submit" value="Efetuar Login"
/>
25 </td>
26 </tr>
27 </table>
28 </form>
O Código 132 define um formulário que efetua a leitura de usuário e

de senha, que serão enviados pelo método post à página, a ser definida,
chamada index.php, conforme apresentado na linha 4. Na linha 9 é
definida uma entrada, do tipo caixa de texto, para o login, onde o valor
inicial recebe o valor de um script PHP definido entre as linhas 10 e
15. Esse script verifica se existe o cookie com nome login e, caso exista,
retorna o valor desse cookie; caso contrário (não existe), o script retorna
www.esab.edu.br 301
o valor “”. Esse valor retornado é atribuído à propriedade value (valor).
São definidos, ainda, componentes para a senha (do tipo password) e
botão para submeter o formulário, além de reaproveitarmos o cabeçalho
e o rodapé, utilizando instrução require().
O processamento do formulário é feito pelo script index.php, que

corresponde à página principal da aplicação, definida no Código 133.
Código 133 – Script da tela principal

1 <?php
2 session_start();
3 if (isset($_POST["login"])){
4 $login = $_POST["login"];
5 $senha = $_POST["senha"];
6 }
7 else {
8 $login = "";
9 $senha = "";
10 }
12 if (($login == "admin") and ($senha ==
"admin")){
15 echo '<table><tr><td>Logado com usuário
administrador</td></tr></table> ';
16 } else {
17 echo '<table> <tr><td><strong>Login
inválido </td></tr><tr><td> <a href="login.
php">Voltar</a></td></tr></table>';
18 }
20 ?>
O Código 133 apresenta o processamento da tela de acesso ao sistema,

verificando, na linha 3, inicialmente, se o script recebeu variável chamada
login por método post. Caso tenha recebido, obtém os valores enviados
para login e senha, atribuindo as variáveis $login e $senha nas linhas
4 e 5. Caso não tenha recebido as variáveis, atribui valor zerado para
elas. Na linha 12, verifica se foram enviados valores admin para o login
e admin para a senha, escrevendo mensagem de sucesso (logado com
usuário administrador) na linha 15, em caso de resultado verdadeiro; ou
www.esab.edu.br 302
mensagem de login inválido (linha 17), com link para a tela de login,
em caso contrário. O código deve ser salvo com o nome index.php. A
linha 15 será reescrita para definir links para acesso às telas utilizadas
na administração do sistema, por exemplo, o formulário de cadastro de
clientes, assunto da próxima seção.
43.2 Desenvolvendo cadastro de clientes

Para a inserção de dados do cliente, um formulário deve ser definido. O
Código 134 apresenta um formulário HTML com tais definições.
Código 134 – Formulário para entrada de dados do cliente

1 <?php
2 session_start();
4 <form action="cliente.php" method="POST"
id=form_cliente>
5 <table border=0 class=”dados”>
6 <tr><td> Nome: </td><td> <INPUT
type="text" name=nome size=50 id=quantidade>
</td></tr>
7 <tr><td> CPF: </td> <td> <INPUT
type="text" name=cpf size=14> </td></tr>
8 <tr><td> E-mail: </td><td> <INPUT
type="text" name=email size=30> </td></tr>
9 <tr><td> Endereço completo: </
td><td><INPUT type="text" name=endereco
size=60> </td></tr>
10 <tr><td> Cidade: </td><td> <INPUT
type="text" name=cidade size=30> </td></tr>
11 <tr> <td> Telefone: </td><td> <INPUT
type="text" name=telefone size=20> </td></
tr>
12 <tr> <td> CEP: </td><td> <INPUT
type="text" name=cep size=20> </td></tr>
13 <tr> <td> Login: </td><td> <INPUT
type="text" name=login size=20> </td></tr>
14 <tr> <td> Senha: </td><td> <INPUT
type="password" name=senha size=20> </td></
tr>
15 </table>
17 <br><a href="index.php">Voltar</a>
18 </form>
www.esab.edu.br 303
O Código 134 mostra um formulário que define componentes de
entrada de dados para a leitura dos campos nome, CPF (ou CNPJ),
e-mail, endereço completo, cidade, telefone, CEP, usuário e senha
(para usar no acesso), entre as linhas 6 e 14. Para o design de nosso
formulário, foi definido o uso de tabela aplicando a folha de estilo com
o nome “dados”, definido no arquivo header.inc. O botão de submissão
executa o método post, chamando o script cliente.php (definido na
linha 4), a ser definido na próxima seção. Salve o arquivo com o nome
“clienteFormulário.php”.
43.3 Salvando arquivo de cadastro de cliente

Para processar o envio de dados, vamos utilizar a orientação a objeto,
defendida por Thomson e Welling (2005), de forma a possibilitar um
reuso efetivo. Observe o Código 135, que define a classe Cliente.
www.esab.edu.br 304
Código 135 – Script com classe Cliente
1 <?php
2 class Cliente {
$telefone, $cpf_cnpj, $criador, $login,
$senha;
$cidade, $telefone, $cep, $cpf_cnpj, $login,
$senha){
5 try {
6 session_start();
8 $this->email = $email;
11 $this->telefone = $telefone;
12 $this->cep = $cep;
13 $this->cpf_cnpj = $cpf_cnpj;
14 $this->criador = $_SESSION["login"];
15 $this->login = $login;
16 $this->senha = $senha;
17 }
19 throw $e;
20 }
21 }
24 fwrite($arquivo, $this->nome.”;”.$this-
>email.”;”.$this->endereco.”;”.$this-
>cidade.”;”.$this->telefone.”;”.$this-
>cep.”;”.$this->cpf_cnpj.”;”.$this-
>criador.”;”.$this->login.”;”.$this-
>senha.”;\n”);
26 }
27 }
28 ?>
www.esab.edu.br 305
O Código 135 define a classe Cliente e, na linha 3, são definidos os
atributos. Também é definido, entre as linhas 2 e 21, um constructor,
recebendo dados iniciais necessários (recebidos pelos parâmetros
$nome, $email, $endereco, $cidade, $telefone, $cep, $cpf_cnpj, $login,
$senha), no momento no qual é criado algum objeto instanciado. Nesse
constructor é atribuído, além dos valores recebidos, o valor da variável
de sessão (atribuída quando acessa o sistema) que armazena o login
do usuário que cria o registro, como pode ser observado na linha 14.
Em caso de erro, é lançada uma exceção, definida na linha 19. Ainda é
definido o método salvaArquivo, que salva o arquivo com os dados do
objeto, como o nome recebido como parâmetro. Salve esse script como
clienteClasse.php.
Para processar os dados enviados, vamos escrever um script que recebe

tais dados por método post e utiliza a classe Cliente. Esse script é
definido no Código 136.
www.esab.edu.br 306
Código 136 – Script que processa formulário, utilizando classe Cliente
1 <?php
2 require('clienteClasse.php');
13 try {
$endereco, $cidade, $telefone, $cep, $cpf,
$login, $senha);
15 $nomeArquivo = 'c:\\apache\\ htdocs\\
cliente.txt';
. $nome.'</strong> '. ' foram salvos
18 echo '<table> <tr><td><a href="Principal.
php">Menu Principal </a></td></tr></table>';
19 }
table><br />';
22 echo '<table> <tr><td><a
href="clienteFormulario.php">Voltar </a></
td></tr></table>';
23 }
25 ?>
O Código 136 (cliente.php) recebe os dados enviados por método post

(pelo formulário), como definido pelo código entre as linhas 3 e 11. Na
linha 14, é criada instância de cliente (com os dados de inicialização)
e, em caso de sucesso, chama o método salvaArquivo, apresentando
mensagem de sucesso na linha 17 (ou de insucesso, em caso de erro,
executando o tratamento de exceção das linhas 20 a 23).
www.esab.edu.br 307
Nesta unidade, iniciamos o desenvolvimento de uma aplicação completa,
definindo cabeçalhos e rodapés que serão reutilizados, tela de acesso
e entrada de dados de cliente. Para isso, aplicamos conhecimento de
formulários, programação orientada a objetos, controle de sessão, cookies
e tratamento de exceções. Nas próximas unidades, continuaremos o
desenvolvimento de nossa aplicação.
Para sua reflexão

As aplicações PHP, desenvolvidas por você durante
essa disciplina, tiveram seus dados salvos em
arquivos texto. Porém, a PHP permite o uso de
bancos de dados relacionais. Como você imagina o
uso de banco de dados para o desenvolvimento de
aplicações integradas com a PHP?
www.esab.edu.br 308
Objetivo
Na unidade 43, foram definidas telas de login e de cadastro de clientes de

nossa aplicação. Dando continuidade, nesta unidade vamos desenvolver
cadastro de produtos, incorporando a ele o envio de arquivos para salvar
uma foto para o produto. Thomson e Welling (2005) nos fornecerão a
base teórica. Vamos em frente!
44.1 Desenvolvendo cadastro de produtos

Para a inserção de dados de produtos, deve ser definido um formulário.
Porém, para uma loja virtual, ao menos uma foto do produto é necessária.
Portanto, é preciso fazer o envio de arquivos (upload) de imagens.
Para que um formulário possa enviar um arquivo, é necessário que a

propriedade enctype seja definida como “multipart/form-data”, como
nos mostram Thomson e Welling (2005, p. 310), ao complementarem
que a definição permite “[...] que o servidor saiba que um arquivo está
vindo junto com as informações regulares de um formulário”. Os autores
completam que o tipo de entrada file deve ser usado.
O formulário definido no Código 137 apresenta a inserção de dados de

produtos.
www.esab.edu.br 309
Código 137 – Formulário para entrada de dados de produtos
1 <?php
2 session_start();
4 <form enctype="multipart/form-data"
action="produto.php" method="POST" id=form_
produto>
5 <table border=0>
6 <tr><td> Código: </td><td> <INPUT
type="text" name=codigo size=50 id=codigo>
</td></tr>
7 <tr><td> Nome: </td><td> <INPUT type="text"
name=nome size=50 id=nome> </td></tr>
8 <tr><td> Caracteristicas do produto:
</td><td> <INPUT type="text"
name=caracteristicas size=3000
id=caracteristica> </td></tr>
9 <tr><td> Valor: </td><td> <INPUT type="text"
name=valor size=30 id=valor> </td></tr>
10 <tr> <td> <input type="hidden" name="MAX_
FILE_SIZE" value="1000000"> Arquivo: </
td><td><input name="userfile" type="file"></
td></tr>
11 </table>
13 <br><a href="index.php">Voltar</a>
14 </form>
Podemos observar, no Código 137, a definição do formulário conforme

enfatizado por Thomson e Welling (2005), com o tipo “multipart/
form-data” na linha 4. São desenhadas entradas de dados para código do
produto, nome, características do produto e valor (linhas 6 a 9), além
da entrada do tipo file para envio (upload) do arquivo, na linha 10.
Nessa linha, é definido um tipo escondido para delimitar o tamanho
máximo de envio de arquivo e, logo após, ainda na linha 10, é definida
a entrada de dados do tipo de arquivo. Esse arquivo deve ser processado,
salvando no servidor, e tal processamento, assim como a classe para
reaproveitamento de classe, é definido na próxima seção. Salve o arquivo
com o nome “produtoFormulario.php”
www.esab.edu.br 310
44.2 Salvando arquivo de cadastro de produtos
Para processar o envio de dados, vamos novamente utilizar a orientação
a objeto, defendida por Thomson e Welling (2005). Observe o Código
138, que define a classe Produto.
Código 138 – Script com classe Produto

1 <?php
2 class Produto {
3 private $codigo, $nome, $caracteristicas,
$valor, $imagem, $criador;
4 function Produto ($codigo, $nome,
$caracteristicas, $valor){
5 try {
6 session_start();
7 $this->codigo = $codigo;
10 $this->valor = $valor;
11 $this->criador = $_SESSION["login"];
12 }
14 throw $e;
15 }
16 }
17 function setImagem($imagemTemp){
18 $this->imagem=$imagemTemp;
19 }
20 function getImagem(){
21 return $this->imagem;
22 }
23 function getNome(){
24 return $this->nome;
25 }
26 function getCaracteristicas(){
27 return $this->Caracteristicas;
28 }
29 function getValor(){
30 return $this->valor;
31 }
32 function getCodigo(){
www.esab.edu.br 311
33 return $this->codigo;
34 }
37 fwrite($arquivo, $this->nome.”;”.$this-
>caracteristicas.”;”.$this->valor.”;”.$this-
>imagem.”;”.$this->criador.'\n');
39 }
40 }
41 ?>
O Código 138 apresenta a definição da classe Produto. Observe

que, diferente da classe Cliente, a classe Produto define, na linha 3,
seus atributos com visibilidade private (privado). Assim, somente a
própria classe pode operar diretamente, sendo necessário definir uma
interface para atribuir e obter esses dados. Das linhas 2 a 16 é definido
o constructor, recebendo o valor inicial para os atributos ($codigo,
$nome, $caracteristicas, $valor), além de atribuir valor para o atributo
$criador, que obtém o usuário da sessão. Para esses atributos, foram
definidos métodos para leitura (get), das linhas 20 a 34. Para o atributo
$imagem, também é definido o método setImagem, entre as linhas 17 e
19, que tem o objetivo de definir a interface de atribuição de dados a esse
atributo. Nesse atributo é salvo apenas o caminho da imagem, de forma
a possibilitar a sua exibição. Desse modo, assim como desenvolvido
na classe Cliente, é definido, entre as linhas 35 a 39, um método
salvarArquivo(), o qual abre o arquivo utilizando a instrução fopen();
adiciona uma linha ao arquivo com os dados do produto, separado por
vírgula, utilizando a instrução fwrite(); e fecha o arquivo com a instrução
fclose. Salve esse script como ProdutoClasse.php.
Para obter os dados enviados pelo método post e utilizar a classe

para inseri-los, é definido um conjunto de instruções, como pode ser
observado no Código 139.
www.esab.edu.br 312
Código 139 – Script que processa formulário, utilizando classe Produto
1 <?php
2 require('ProdutoClasse.php');
4 $codigo = $_POST["codigo"];
5 $caracteristicas = $_POST["caracteristicas"];
6 $valor = $_POST["valor"];
7 if (is_uploaded_file($_FILES['userfile']['tmp_
name'])) {
8 $nomeArquivo = 'images/'.$_
FILES['userfile']['name'];
9 if (!move_uploaded_file($_FILES['userfile']
['tmp_name'], $nomeArquivo)){
10 throw new Exception('Erro ao carregar
arquivo', 0);
11 }
12 } else {
13 throw new Exception('Erro ao carregar
arquivo', 0);
14 }
15 try {
16 $produto = new Produto($codigo, $nome,
$caracteristicas, $valor);
17 $produto->setImagem($nomeArquivo);
18 $nomeArquivo = 'c:\\apache\\htdocs\\
produtos.txt';
19 $produto->salvaArquivo($nomeArquivo);
. $nome.'</strong> '. ' foram salvos
22 echo '<table> <tr><td><a href="Principal.
php">Menu Principal </a></td></tr></table>';
23 }
table><br />';
27 echo '<table> <tr><td><a
href="produtoFormulario.php">Voltar </a></
td></tr></table>';
28 }
30 ?>
www.esab.edu.br 313
O Código 139 recebe os dados enviados pelo formulário no método
post. Porém, para o cadastro de produtos, diferentemente do cadastro de
clientes, é enviado um arquivo (que deve conter a imagem). Na linha 7
é verificado se o arquivo foi enviado, utilizando a função is_uploaded_
file() e acessando parâmetro da variável $_FILES[‘userfile’][‘tmp_name’],
que “[...] é onde o arquivo foi temporariamente armazenado no servidor
Web” (THOMSON; WELLING, 2005, p. 311). Em caso de insucesso
(desviaria para o bloco else, iniciado na linha 9), leva à linha 13, onde é
lançado erro. Na linha 8, é definido o valor do arquivo a ser salvo, sendo
concatenados o nome obtido e o valor ‘images/’, definindo, assim, a pasta
a ser salvo o arquivo. Você deve se lembrar de criar essa pasta dentro da
pasta na qual está o script (por exemplo, a pasta “c:\apache\htdocs”),
de modo a garantir acesso aos arquivos. É verificado, na linha 9, se o
arquivo não foi movido da pasta onde está temporariamente armazenado
para o arquivo com nome definido na linha 8. Em caso de valor
verdadeiro ao teste lógico, significa que não é possível copiar o arquivo
e, por esse motivo, é lançado erro na linha 10. Em caso de sucesso nos
testes lógicos (enviou arquivo e conseguiu mover para a pasta final), é
criado objeto da classe Produto, na linha 16, com dados de inicialização
(new Produto($codigo, $nome, $caracteristicas, $valor);). É atribuído o
nome do arquivo ao atributo $imagem, utilizando a interface definida,
como observado na linha 17; já a linha 18 define o nome do arquivo,
para que, na linha 19, seja chamado o método salvaArquivo(), salvando o
arquivo texto.
Para que, a partir da página inicial, possamos acessar o cadastro de

clientes e produtos, devemos alterar a linha 15 do arquivo index.php,
que é definido no Código 133, para que, em vez de apresentar uma
mensagem de sucesso, apresente link para as telas de cadastro. Para isso,
substitua a linha 15 pelas duas linhas definidas no Código 140, para
acessar e testar com o usuário logado.
Código 140 – Alterações em index.php

1 echo '<tr><td><a href="clienteFormulario.
php">Cadastro de Clientes </a></td></tr>';
2 echo '<tr><td><a href="produtoFormulario.
php">Cadastro de Produtos </a></td></tr>';
www.esab.edu.br 314
O Código 140 apresenta links, nas suas linhas, que levam às telas de
cadastro com os formulários, definidas nos Códigos 134 e 137, com
nomes “clienteFormulario.php” e “produtoFormulario.php”.
Nesta unidade continuamos o desenvolvimento da aplicação, criando

formulário e scripts para cadastramento de produtos e utilizando,
além dos conhecimentos revistos, o envio (upload) de arquivos. Nas
próximas unidades, vamos elaborar o carrinho de compras, para ser
utilizado pelo cliente.
www.esab.edu.br 315
Objetivo
Nas unidades 43 e 44, desenvolvemos formulários e classes de cliente

e produtos, para que possamos fazer a administração do sistema. Nesta
unidade, vamos desenvolver o carrinho de compras para que o cliente
possa visualizar os produtos e realizar suas compras. Utilizaremos, como
base teórica, conceitos de Thomson e Welling (2005). Vamos lá?
45.1 Desenvolvendo carrinho de compras

Uma aplicação de e-commerce (nesse caso, uma loja online), deve
apresentar os produtos cadastrados e permitir a escolha da quantidade
do produto a ser comprada para que os clientes possam fazer a sua
seleção, ou, como definem Thomson e Welling (2005), receber pedidos
de mercadorias e serviços. Para essa loja online, será definido o layout,
construído por meio de tabelas com duas colunas. Cada coluna
apresentará, em destaque, o nome do produto, bem como os dados
desse produto e uma entrada da quantidade de produto que o cliente irá
comprar. Além disso, ao definir a compra, deve-se observar se o usuário
já está logado. Caso não esteja, o cliente deverá ser encaminhado até a
tela de acesso, para, somente após esse procedimento, conseguir abrir o
carrinho de compras para a confirmação do pedido.
O Código 141 apresenta o script necessário para o funcionamento

conforme descrito.
www.esab.edu.br 316
Código 141 – Script com a loja virtual
1 <?php
2 session_start();
3 require("header.inc");
4 $nomeArquivo = 'c:\\apache\\htdocs\\produtos.
txt';
5 if (file_exists($nomeArquivo)){
6 $arquivo = fopen($nomeArquivo, 'r');
7 $contadorColunas = 0;
8 echo '<form action="carrinho.php"
method="post" name="frmcarrinho"><table>';
10 $produto = explode(';', fgets($arquivo));
11 $codigo = $produto[0];
12 $nome = $produto[1];
13 $caracteristica = $produto[2];
14 $valor = $produto[3];
15 $imagem = $produto[4];
16 if ($contadorColunas == 0){
17 echo'<tr>';
18 }
19 echo'<td width=50%><table>';
20 $contadorColunas=+1;
21 echo '<tr><td class="produto-nome"
colspan="2">'.$nome.'</td></tr>';
22 echo '<tr><td><img src="'. $imagem. '"
width="200" length="200" /></td>';
23 echo '<td> <table
class="produtos"><tr><td>Caracteristicas: </
td><td>'.$caracteristica.'</td><tr>';
24 echo '<tr><td> Valor:</td><td
class="produto-valor">'.$valor.'</td><tr>';
25 echo '<input type="hidden"
name="txtprod['.$codigo.'][0]" value="'.
$codigo.'">';
$nome.'">';
$caracteristica.'">';
$valor.'">';
$imagem.'">';
www.esab.edu.br 317
30 echo '<tr><td> Quantidade:</td><td> <input
type="text" name="txtprod['.$codigo.'][5]"
size=3 id=quantidade value="0"></td><tr>';
31 echo '<tr><td><input type="image"
src="images/carrinho.gif" onClick="java
script: document.forms[0].submit();"></
td><tr></table> </td><tr>';
32 echo '<tr><td colspan="2">&nbsp</td></tr>';
33 echo'</table></td>';
34 if ($contadorColunas == 2){
35 echo '</tr>';
36 $contadorColunas = 0;
37 }
38 }
40 echo '</td></tr></table>';
41 } else {
42 echo 'O arquivo não existe';
43 }
44 echo '</form>';
46 ?>
O Código 141 percorre o arquivo de produtos, obtendo os seus dados e

mostrando-os na tela. O nome do arquivo é definido na linha 4; ele deve
apontar o mesmo arquivo que você utilizou para cadastrar os produtos.
Caso o arquivo exista, ele é aberto, atribuindo o seu conteúdo à variável
$arquivo, na linha 6. Caso contrário, exibe uma mensagem de erro,
definido na linha 42. A variável $contadorcoluna é inicializada com valor
0, na linha 7, para que, a cada duas colunas, seja inserida uma tag <tr> e,
com isso, uma nova linha na tabela, a fim de gerarmos o layout definido.
A linha 8 define o formulário, isto porque o envio dos dados para o

processamento, na próxima tela, é feito utilizando o método post, além
de incluir a tag <table>, que define a tabela com as duas colunas a serem
criadas. Dessa forma, é criada a linha 9, definindo que o processamento
será realizado no script carrinho.php. O código entre as linhas 9 e 38 é
executado para cada linha do arquivo, isto enquanto não chegar ao final
do arquivo, instrução definida na linha 9. Na linha 10 é utilizada função
explode() para atribuir à variável $produto um vetor contendo todas as
www.esab.edu.br 318
informações da linha (ou seja, equivalente a um produto), separando
pelo símbolo ponto e vírgula, definido no momento que salvamos o
arquivo. A ordem de posição de cada campo no arquivo é equivalente
à ordem segundo a qual eles foram salvos no arquivo, e definidos no
Código 138. Dessa forma, são obtidos os dados e atribuídos em variáveis
com nomes relevantes, para facilitar o entendimento, no trecho entre
as linhas 11 e 15. Caso seja a primeira coluna da linha (teste lógico
realizado na linha 16), insere a tag <tr>, criando uma linha da tabela.
Como teremos duas colunas por linha da tabela, a cada interação (para
cada produto) é criada uma coluna, com tamanho de 50% da largura
da tela. Dentro dessa coluna, é criada uma nova tabela, para que sejam
formatados os dados de cada produto. Essa instrução de definição de
colunas é realizada na linha 19. A linha 20 incrementa 1 ao contador de
colunas. A linha 21 atribui ao conjunto de duas colunas o texto contendo
o nome do produto. Na linha 22 é definida a imagem que será mostrada,
lembrando que guardamos o endereço do arquivo junto aos dados do
produto. As linhas 23 e 24 apresentam os dados de características e valor
do produto. Observe que os dados são formatados com estilos definidos
no cabeçalho (header.inc).
Das linhas 25 a 29 são definidos os componentes escondidos para um

vetor chamado txtprod, que é enviado, no método post, para posterior
leitura. A linha 30 define um componente de entrada, para que o cliente
possa definir o número de produtos que deseja adquirir na compra,
cujo valor é atribuído ao índice 5 do vetor txtprod. Desse modo, cada
posição do vetor conterá os dados dos produtos, inclusive a quantidade
escolhida pelo usuário. Na linha 30, é incluída uma imagem que, quando
clicada, chama um script javascript, cuja função é submeter o formulário.
Sua funcionalidade, nesse caso, fica equivalente a uma entrada do tipo
“submit”. A linha 33 fecha a tabela interna com os dados do produto
e fecha a coluna (lembrando que, em nosso layout, teremos duas por
linha). Caso se trate da segunda coluna da linha, é inserido o seu
fechamento (com a tag </tr>) e é zerado o contador de colunas, como
definido no trecho entre as linhas 34 e 37. Após a execução de todas as
linhas do arquivo, a linha 39 fecha o arquivo, enquanto a tabela, criada
na linha 8, é fechada na linha 40. Já o formulário é fechado na linha 44.
Salve esse script como loja.php.
www.esab.edu.br 319
Tal código é capaz de mostrar a tela de pedidos e enviar os dados, via
método post, ao script carrinho.php. definido na próxima seção.
Para sua reflexão

As aplicações web que efetuam a comercialização
de produtos e serviços devem ter aspecto
atraentes. Como você observa o uso de conceitos
de design, como a definição de cores e layouts, no
desenvolvimento de suas aplicações?
45.2 Validando dados do pedido e tela de finalização

de pedido
Os dados enviados pelo script loja.php devem ser processados, de forma
a somar aos produtos inseridos na cesta de compras, caso já existam.
Também deve garantir que, para o processamento, o usuário esteja
logado; caso contrário, deve desviar o usuário para que ele efetue o
acesso. Para armazenar as informações sobre a cesta de mercadorias e
manter a informação do login, você deve usar informações de sessão,
obtendo valor com $_SESSION[nome_da_variável]. O Código 142
define a execução desse processamento.
Código 142 – Script com processamento do carrinho

1 <?php
2 function imprimeProduto ($produto){
3 echo '<tr><td><img src="'. $produto[4].
'" width="40" length="40" /></
td>><td>'.$produto[1].'</td>
<td>'.$produto[3].'</td><td>'.$produto[5].'</
td><td>'.$produto[6].'</td> </tr>';
4 }
5 session_start();
6 if (isset($_POST["txtprod"])){
7 $produtos = $_POST["txtprod"];
www.esab.edu.br 320
8 $_SESSION["txtprod"] =$produtos;
9 }
10 if (!isset($_SESSION["login"])) {
11 header("Location: login.php", TRUE);
12 }
14 echo '<table class="produtos">';
15 echo '<tr> <td>&nbsp</td><td>Produto:</
td><td>Valor: </td><td>Quantidade: </
td><td>Total: </td></tr>';
16 if (isset($_SESSION["cesta"])){
17 $cesta = $_SESSION["cesta"];
18 $contador = count($cesta);
19 foreach ($cesta as $produto){
20 imprimeproduto($produto);
21 }
22 }else {
23 $contador = 0;
24 }
25 if (isset($produtos)){
26 foreach ($produtos as $produto){
27 if ($produto[5]<>0){
28 $produto[6]=$produto[3]*$produto[5];
29 imprimeproduto($produto);
30 $cesta[$contador]=$produto;
31 $contador=+1;
32 }
33 }
34 $_SESSION["cesta"]=$cesta;
35 }
36 echo '<tr> <td colspan="5"><a
href="ConfirmaPedido.php"
class="botao">Confirma Pedido <a></td></tr>';
37 echo '<tr> <td colspan="5"><a href="loja.
php" class="botao">Continuar comprando <a></
td></tr>';
38 echo '</table>';
40 ?>
www.esab.edu.br 321
As primeiras linhas do Código 142 definem função com o objetivo
de reutilização de código e serão explicadas quando forem utilizadas,
nas linhas 20 e 29. A linha 6 observa se o script recebe informação via
método post. Tal teste lógico garante que o script não apresente erro
quando for chamado por outra tela sem enviar parâmetros por post.
Caso seja recebida informação pelo método post, enviada por outro
formulário, atribui à variável $produtos o valor da variável txtprod,
enviada por post, que também tem seu valor atribuído à variável de
sessão txtprod. Isto é feito para que, em caso de inexistência de usuário
ativo, o usuário possa ser encaminhado para a tela de acesso e consiga,
posteriormente, continuar a operação. O teste de existência de login
é realizado na linha 10, através da variável de sessão e, caso não seja
encontrado, utiliza a instrução header(“Location: login.php”, TRUE);,
como mostrado na linha 11, para redirecionar para o script de login,
interrompendo a execução do restante do script.
As linhas 14 e 15 definem a tabela e uma linha com dados a serem

inseridos no documento antes de processar a cesta. Caso exista a
variável cesta (teste lógico definido na linha 16), isso significa que já
houve processamento e que, portanto, deve-se obter os dados dessa
cesta existente (e armazenada com a variável de sessão). Assim, é
preciso processar na tela os dados de tal cesta, chamando a função
imprimeProduto(), que tem como objetivo imprimir dados dos
produtos e atualizar o contador com o número de itens existentes na
cesta. Caso exista alguma informação no vetor $produtos (em caso
de existir dados enviados via post ou recuperados da sessão), esse
vetor deve ser percorrido, calculando o total da venda, adicionando a
cesta e imprimindo os produtos cuja quantidade seja diferente de 0.
Essas operações são realizadas das linhas 27 a 32. A linha 34 atualiza
a variável de sessão $cesta, de forma a atribuir o valor com os novos
produtos inseridos. Nas linhas 36 e 37 são definidos links para a tela de
acompanhamento do pedido ou da loja, para a continuidade da compra.
A linha 38 fecha a tabela com os dados. Dessa forma, os dados são
atualizados, levando em consideração tanto a cesta previamente existente
quanto os novos produtos inseridos. Também considera o fato de poder
ser retornado da tela de acesso.
www.esab.edu.br 322
Para o funcionamento da tela de acesso junto à loja virtual (não somente
para a administração do sistema), são necessárias alterações no script
index.php, de forma a considerar o acesso de clientes (e percorrendo a
tabela cliente para encontrar usuário e senha correspondente). O Código
143 apresenta o código do script index.php com as devidas alterações.
Código 143 – Script da tela principal, modificado

1 <?php
2 function clienteLogin ($login, $senha) {
3 $encontrou = FALSE;
4 $nome_arquivo = ' c:\\apache\\ htdocs\\
cliente.txt';
5 if (file_exists($nome_arquivo)){
6 $arquivo = fopen($nome_arquivo, 'r');
7 while ((!$encontrou) and (!feof($arquivo))){
8 $cliente = explode(';', fgets($arquivo));
9 if (($login == $cliente[8]) and ($login ==
$cliente[9])){
10 $encontrou = TRUE;
13 }
14 }
15 return $encontrou;
16 }
17 }
18 session_start();
19 if (isset($_SESSION["login"])) {
20 $login = $_SESSION["login"];
21 } else {
22 $login = "";
23 }
24 if ($login == "admin") {
25 $senha = "admin";
26 }elseif (isset($_POST["login"])){
29 } else {
30 $login = "";
31 $senha = "<>";
32 }
www.esab.edu.br 323
33 if (($login == "admin") and ($senha ==
"admin")){
37 echo '<table> ';
38 echo '<tr><td><a href="clienteFormulario.
php">Cadastro de Clientes </a></td></tr>';
39 echo '<tr><td><a href="produtoFormulario.
php">Cadastro de Produtos </a></td></tr>';
40 echo '</table>';
41 } elseif (($senha == "<>")or
(clienteLogin($login, $senha))) {
42 if (isset($_SESSION["txtprod"])){
43 header("Location: carrinho.php", TRUE);
44 } else {
46 header("Location: loja.php", TRUE);
47 }
48 } else {
50 echo '<table> <tr><td><strong>Login
inválido </td></tr><tr><td> <a href="login.
php">Voltar</a></td></tr></table>';
51 }
52 ?>
No Código 143, o trecho entre as linhas 2 e 17 apresenta função para

procurar, percorrendo as linhas do arquivo de clientes e verificando se
o login e a senha correspondam a alguma informação de um cliente.
Caso encontre referência de usuário e senha em algum cliente, retorna
valor verdadeiro à função, além de atribuir valores às variáveis de sessão
e ao cookie, com dados do login; caso contrário, retorna o valor falso.
O script pode iniciar sem receber nenhuma informação de login e,
dessa forma, não deve responder positivamente a nenhum teste de
senha. Assim, na linha 30, caso não tenha sido enviado dado, atribui
valor “” à variável login e uma senha predefinida, que é testada na linha
41. Observe que esse bloco de códigos é adicionado para responder a
usuários de clientes, usuários da loja virtual. Dessa forma, se já existir
uma compra (fez a compra sem acessar e direcionou para login), testada
na linha 42 através do conteúdo da variável de sessão, redireciona ao
www.esab.edu.br 324
carrinho. Caso não exista uma compra, redireciona à loja e permite
a compra, já com o acesso realizado. Desse modo, o script continua
respondendo ao processamento do login, mas redireciona à loja (em
caso de não existir login e nem variável post), podendo ser usado para
encaminhar ao sistema de administração (cadastro de clientes e produtos)
e à loja virtual.
Nesta unidade desenvolvemos o carrinho de compra com a tela

de confirmação, aplicando fortemente conceitos de controle de
sessões. Adicionamos aos conceitos aplicados o uso de script em
linguagem javascript, simulando a submissão do formulário e o uso do
header(“Location :”) para redirecionar páginas. Nas próximas unidades,
vamos elaborar impressão dos relatórios e envio de e-mail com a
confirmação dos pedidos.
Estudo complementar
As aplicações de comércio eletrônico vêm
ganhando espaço e a sua utilização tem
aumentado mundialmente. O texto “E-Commerce
como Ferramenta de Vendas”, elaborado pelo Prof.
Vicente Martin Mastrocola, da ESPM-SP, expõe a
utilização dessa ferramenta. Você pode acessar o
material clicando aqui.
www.esab.edu.br 325
Objetivo
sessões e, também, um carrinho de compras
Nas unidades 43, 44 e 45, desenvolvemos uma aplicação web capaz de

administrar o sistema (cadastrar produtos e clientes) de uma loja virtual.
Recuperando os conceitos de Thomson e Welling (2005), estudados
na unidade 42, veremos como oferecer ao cliente a possibilidade de
imprimir um relatório com o resumo do seu pedido de compra, com
base nos modelos RTF e PDF. Vamos lá?
46.1 Desenvolvendo relatório RTF com resumo do

pedido
Na unidade 42, aprendemos como gerar documentos RTF a partir de
um modelo. Visto que é possível a compra de vários produtos, você deve
elaborar um modelo RTF contendo uma tabela com quatro colunas,
sendo que, a cada linha, o marcador que será utilizado para a substituição
deve conter uma numeração, que pode ser controlada com código,
através de um contador.
A Figura 57 apresenta um modelo do relatório em RTF.
www.esab.edu.br 326
Figura 57 – Modelo RTF.
Observe que as quatro colunas da tabela compreendem produto, valor,

quantidade e valor total. Elas serão utilizadas para a formação do documento
final, sendo substituídas pelos valores relacionados à compra realizada.
Para a substituição dos marcadores, temos o Código 144.
Código 144 – Script com relatório em RTF

1 <?php
2 session_start();
3 $cesta=$_SESSION["cesta"];
4 $nomeArquivo = 'testeRelatorio.rtf';
5 $rtf = file_get_contents($nomeArquivo);
6 $contador=0;
8 if ($produto[5]<>0){
9 $contador=+1;
10 $rtf = str_replace('<<produto'.$contador.
'>>', $produto[1], $rtf);
11 $rtf = str_replace('<<valor'.$contador.
12 $rtf = str_replace('<<quantidade'.$contador.
13 $rtf = str_replace('<<total'.$contador.
14 }
15 }
16 for ($i=$contador+1; $i<=10; $i++){
www.esab.edu.br 327
17 $rtf = str_replace('<<produto'.$i. '>>', '',
$rtf);
18 $rtf = str_replace('<<valor'.$i. '>>', '',
$rtf);
19 $rtf = str_replace('<<quantidade'.$i. '>>',
'', $rtf);
20 $rtf = str_replace('<<total'.$i. '>>', '',
$rtf);
21 }
22 header('Content-type: application/rtf');
23 header('Content-Disposition: attachment;
filename=Relatorio.rtf');
24 echo $rtf;
25 ?>
O Código 144 obtém, na linha 3, a cesta de produtos, lendo o valor da

variável de sessão $cesta, que contém o vetor dos produtos selecionados.
Percorrendo o vetor, substitui marcador, concatenando contador, que
equivale à ordem que está no vetor. A substituição dos valores ocorre
entre as linhas 7 e 14. Após a substituição dos valores, completa a
substituição dos marcadores, aplicando “” para todos os campos,
iniciando com o número de produtos na cesta, somando 1, até completar
10 registros, como indicado na linha 16. Assim, simula como se estivesse
apagando as linhas excedentes.
Na próxima seção, utilizaremos a geração de arquivos em PDF para gerar

o relatório com resumo do pedido.
46.2 Desenvolvendo relatório PDF com resumo do

pedido
Um relatório PDF pode ser desenvolvido para que o cliente possa
imprimir o resumo de seu pedido de compra. Os documentos PDF
têm maior aceitação, pois são mais difíceis de alterar e porque leitores
de arquivos desse tipo são comuns em diversas plataformas. E, como
visto na unidade 42, existem diversas maneiras ou bibliotecas que geram
arquivos PDF. Portanto, utilizaremos, novamente, a biblioteca FPDF.
www.esab.edu.br 328
Para utilizar a biblioteca, caso não tenha feito o download quando
acompanhou a unidade 42, faça o download da última versão (<http://
www.fpdf.org/>, na seção de downloads). Descompacte os arquivos
(caso não o tenha feito) em uma pasta, sendo necessário copiar, para a
pasta onde está seu script, o arquivo fpdf.php e a pasta fonts, que a classe
utiliza para seu funcionamento.
O Código 145 apresenta solução para a geração do documento PDF, com

base na variável de sessão cesta, que armazena dados da cesta de produtos.
Código 145 – Script com relatório em PDF

1 <?php
2 session_start();
4 require_once 'fpdf.php';
5 $pdf = new FPDF();
6 $pdf->AddPage('P', 'A4');
7 $pdf->Image('images/icon-biblioteca.png',
10,8,22);
8 $pdf->SetFont('Arial', 'B', 15);
9 $pdf->Cell(80);
10 $pdf->Cell(30, 10, 'Pedido de Compra', 0, 0,
'C');
11 $pdf->Ln(20);
13 $pdf->Cell(30, 10, 'Detalhamento da
compra:', 0, 0, 'C');
14 $pdf->Ln(10);
15 $pdf->Cell(30);
16 $pdf->Cell(50, 6, 'Produto:',0);
17 $pdf->Cell(40, 6, 'Valor: ',0);
18 $pdf->Cell(50, 6, 'Quantidade: ', 0);
19 $pdf->Cell(40, 6, 'Total: ',0);
20 $pdf->Ln(10);
21 $contador=0;
23 if ($produto[5]<>0){
25 $pdf->Image($produto[4],10,46+($contador *
30), 22, 22);
26 $pdf->Ln(10);
27 $pdf->Cell(30, 6, '', 0);
www.esab.edu.br 329
28 $pdf->Cell(50, 6, $produto[1],0);
29 $pdf->Cell(40, 6, $produto[3],0);
30 $pdf->Cell(50, 6, $produto[5], 0);
31 $pdf->Cell(40, 6, $produto[6], 0);
32 $pdf->Ln(10);
33 $contador=+1;
34 }
35 }
36 $pdf->Ln(30);
37 $pdf->Cell(90, 6, 'Relatório finalizado');
38 $pdf->Output('Pedido.pdf', 'D');
39 ?>
No Código 145 é obtida a cesta de produtos, lendo o valor da variável

de sessão $cesta, que contém vetor dos produtos selecionados, na linha
3. A linha 4 efetua a requisição do script externo, que deve estar em uma
pasta acessível. A linha 5 cria um objeto da classe FPDF, que contém
métodos e propriedades para criação do arquivo PDF, com o uso da
instrução new FPDF(). A linha 6 define a inclusão de uma nova página
do tipo A4. Definida a nova página, as linhas posteriores são elaboradas
para preencher o documento. Na linha 7 é inserida a imagem, definindo
a origem da imagem, posições na horizontal e vertical, além da definição
do tamanho (essas definições são parâmetros para o método Image()).
Na linha 8 é definida a nova formatação de fonte: os textos criados com
o método Cell() posteriores seguem o padrão corrente. Uma célula de
tamanho 80 pontos em branco é criada na linha 9, e, na linha 10, é
criada uma célula com o texto “Pedido de Compra”. É inserida uma
linha de altura igual a 20 pontos, na linha 11, deixando espaço em
branco, e, na linha 12, é feita uma nova definição de fonte, a ser utilizada
com os próximos textos a inserir. O trecho entre as linhas 16 a 19 define
o texto referente a uma linha de cabeçalho da tabela, enquanto o trecho
entre as linhas 22 e 34 define textos referentes aos produtos vendidos,
percorrendo o vetor com a cesta.
www.esab.edu.br 330
Na linha 25 é inserida a imagem do produto e, para posicioná-la junto
ao relatório, é realizado um cálculo, somando o ponto de início e 30
pontos a cada produto (tamanho da linha inserida ao final), de forma
que a imagem correspondente fique ao lado do texto do produto. Assim,
é definido o relatório, considerando tanto quantos forem os produtos
que façam parte da cesta. Na linha 37 é inserida a mensagem “Relatório
Finalizado” e o arquivo é disponibilizado com a instrução echo, na linha
38. Salve o script como imprimePedido.php. O resultado pode ser visto
com a Figura 58.
Figura 58 – Resultado da execução do script, gerando documento PDF de pedido de compra.

A Figura 58 apresenta o resultado do documento PDF criado a partir de

uma cesta, com a execução do Código 145, desde que a sessão esteja ativa
(e a variável de sessão $cesta contenha os dados da compra).
Nesta unidade desenvolvemos resumos do pedido a partir dos modelos

RTF e PDF, possibilitando ao cliente a impressão do resumo do pedido
de compra ao final do fechamento do pedido. Nas próximas unidades,
vamos desenvolver script para acompanhamento do pedido (finalização),
além de possibilitar a emissão dos relatórios e o envio de e-mail com a
confirmação dos pedidos.
www.esab.edu.br 331
Objetivo
Nas unidades anteriores, você desenvolveu uma aplicação web,

adicionando recursos a cada passo. Aprendemos a desenvolver relatórios
RTF e PDF para possibilitar ao cliente imprimir o resumo do pedido de
compra que realizou na loja virtual. Nesta unidade, vamos desenvolver
script para o acompanhamento do pedido, quando é realizada a sua
finalização, salvando-o em arquivo e disponibilizando os relatórios. E
também quando é apresentada a opção para o cancelamento, apagando o
arquivo salvo e limpando a cesta de produtos. Os conceitos de Thomson
e Welling (2005) e Meloni (2000) formarão a base teórica desta unidade.
47.1 Desenvolvendo a tela de acompanhamento de

pedidos
Após a confirmação de compra, normalmente as aplicações com loja
virtual apresentam uma tela de acompanhamento, na qual podem
ser executadas operações relacionadas ao pedido, como impressão,
cancelamento, entre outras.
Com o processamento do pedido, também deve ser salvo um arquivo

texto com esses dados. O Código 146 apresenta script para definição da
tela de acompanhamento do pedido.
Código 146 – Script da Tela de Acompanhamento de Pedido

1 <?php
2 function salvaPedido ($cestaProdutos,
$nomeArquivo){
www.esab.edu.br 332
4 foreach ($cestaProdutos as $produto){
5 if ($produto[5]<>0){
6 fwrite($arquivo, $produto[0].”;”
.$produto[1].”;” .$produto[2].”;”
.$produto[3].”;” .$produto[4].”;”
.$produto[5].”;” .$produto[6].”;\n”);
7 }
8 }
9 fclose($arquivo);
10 }
12 session_start();
14 $nomeArquivo = $nomeArquivo = 'c:\\apache\\
htdocs\\ Pedido.txt';
15 salvaPedido($cesta, $nomeArquivo);
16 $html = '<h2>Pedido de Compra</h2><br>';
17 $html = $html. '<h3>Detalhamento da
compra:</h3>';
18 $html = $html. '<table class="produtos">';
19 $html = $html. '<tr> <td>&nbsp</
td><td>Produto:</td><td>Valor: </
td><td>Quantidade: </td><td>Total: </td></
tr>';
21 if ($produto[5]<>0){
22 $html = $html. '<tr><td><img src="'.
$produto[4]. '" width="40" length="40"
/></td>><td>'.$produto[1].'</
td> <td>'.$produto[3].'</
td><td>'.$produto[5].'</
23 }
24 }
25 $html = $html. '</table>';
26 echo $html;
27 echo '<br>';
28 echo '<a href="imprimePedido.php"
class="botao">Imprimir Pedido <a><br>';
29 echo '<a href="enviaEmail.php"
class="botao">Enviar E-mail <a>';
30 echo '<a href="cancelarPedido.php"
class="botao">Cancelar Pedido <a>';
31 require('footer.inc')
32 ?>
www.esab.edu.br 333
O Código 146 apresenta, em suas linhas iniciais, função para salvar o
pedido em arquivo texto, definida entre as linhas 2 e 10. A função recebe
como parâmetro a cesta e o nome do arquivo, percorrendo o vetor de cesta
e salvando no arquivo, onde cada linha equivale a um produto comprado.
Para a definição da cesta, é recuperada, na linha 13, a variável de sessão
$cesta, que contém os dados dos produtos do pedido confirmado.
Observe, no Código 146, que uma estratégia diferente foi utilizada:

atribuir os dados do documento HTML a ser retornado em uma variável
e apresentá-la ao final. Essa estratégia, em termos práticos, não altera o
resultado final, e foi elaborada justamente para que você pudesse observar
e comparar, escolhendo aquela que considere mais adequada. Dessa
forma, o trecho entre as linhas 16 e 26 define o documento HTML que,
somado ao cabeçalho e rodapé requeridos, gera resposta ao navegador.
Nesse trecho, as instruções das linhas 20 a 23 são repetidas para cada
item da cesta. Salve o script como confirmaPedido.php. O resultado
pode ser observado na Figura 59.
Figura 59 – Resultado da execução do script, tela de acompanhamento do pedido.

A Figura 59 traz o resultado da execução do script, apresentando os

produtos que compõem a cesta, com links para as operações definidas.
Dessas operações, você desenvolveu, na unidade 46, a geração de arquivo
PDF, sendo necessário, para a finalização da aplicação, desenvolver
as operações de envio de e-mail e cancelamento do pedido, as quais
estudaremos na seção seguinte. Vamos lá?
www.esab.edu.br 334
47.2 Desenvolvendo o cancelamento de pedido
Considerando que o pedido de compra é salvo em arquivo texto, após
a sua confirmação, e fica armazenado em variável de sessão, podemos
cancelar as operações apagando o arquivo que contém os dados e destruir
a variável de sessão que armazena esses dados. Para isso, o uso das funções
unlink() e unset() são apresentadas por Thomson e Welling (2005) e
Meloni (2000). Dessa forma, um script simples pode ser definido, como
consta no Código 147.
Código 147 – Script de Cancelamento de Pedido

1 <?php
2 unlink ('c:\\apache\\ htdocs\\ Pedido.txt');
3 unset($_SESSION["cesta"]);
4 header("Location: index.php", TRUE);
5 ?>
O Código 147 define a instrução, utilizando função unlink() na linha 2,

que apaga o arquivo texto com dados do pedido. Desse modo, o arquivo
deixa de existir e os dados não poderão mais ser recuperados. A instrução
da linha 3 utiliza função unset(), que destrói a variável. Dessa forma, a
variável de sessão é eliminada e também não pode mais ser recuperada. A
linha 4 apresenta instrução que redireciona para o script index.php, que
contém a tela principal da aplicação web. Assim, os dados relacionados
ao pedido e armazenados em variáveis de sessão e arquivo texto são
excluídos, o que, em termos práticos, cancela o pedido.
Nesta unidade desenvolvemos tela para acompanhamento do pedido,

possibilitando ao cliente chamar as operações de impressão, envio de
e-mail e cancelamento do pedido. Na última unidade, desenvolveremos
a operação de envio de e-mail com a confirmação do pedido, além de
estudarmos como disponibilizaríamos nossa aplicação na web.
Tarefa dissertativa
www.esab.edu.br 335
Objetivo
Das unidades 43 a 47, resolvemos exercícios utilizando conceitos de

reutilização de software. Nesta unidade, vamos desenvolver a função de
envio de e-mail. As concepções de Thomson e Welling (2005) servirão
novamente como base teórica. Vamos lá?
48.1 Desenvolvendo e-mail de aviso de confirmação

de pedido
Assim como observamos várias formas de geração de PDF, com várias
bibliotecas, podemos executar o envio de e-mail utilizando diferentes
estratégias. Thomson e Welling (2005) nos apresentam o envio de e-mail
utilizando biblioteca sendmail. Porém, tal biblioteca só é capaz de enviar
e-mail através de servidores sem autenticação – e nem estamos falando de
autenticação segura. Assim, por questões de segurança, é raramente utilizada.
A partir dessa constatação, vamos usar a biblioteca PHPMailer, um

projeto aberto, através do qual pode-se baixar os códigos-fonte e efetuar
alterações, caso necessário. Essa biblioteca pode ser baixada na página do
projeto (<http://sourceforge.net/projects/phpmailer/>), junto ao Source
Forge. Os arquivos devem ser descompactados na pasta PHPMailer, dentro
da pasta onde se encontra o projeto. Dessa forma, a biblioteca fica acessível
para utilização. Lembre-se que, para o envio de e-mail, você deve dispor de
e-mail válido para configurar o envio. O Código 148 apresenta script que
envia e-mail do pedido a partir dos dados de envio inseridos.
www.esab.edu.br 336
Código 148 – Script envio de e-mail
1 <?php
2 session_start();
3 require_once('PHPMailer/class.phpmailer.php');
5 $destinatario = 'emaildocliente@xxx.com;
6 $assunto = 'Pedido de Compra';
7 $html = '<h1>Pedido de Compra</h1><br>';
8 $html = $html. '<h2>Detalhamento da
compra:</h2><br>';
9 $html = $html. '<br><table>';
10 $html = $html. '<td>Produto:</td><td>Valor:
</td><td>Quantidade: </td><td>Total: </td>';
12 if ($produto[5]<>0){
13 $html = $html. '<tr><td>'.$produto[1].'</
td> <td>'.$produto[3].'</
td><td>'.$produto[5].'</
14 }
15 }
16 $html = $html. '</table>';
17 $Email = new PHPMailer();
18 $Email->SetLanguage("br");
19 $Email->IsSMTP();
20 $Email->SMTPAuth = true;
21 $Email->Host = 'mail.servidorDeEnvio.com.br;
22 $Email->Username = 'usuarioDoEmail';
23 $Email->Password = SenhaDoEmail';
24 $Email->Port = '587';
25 $Email->IsHTML(true);
26 $Email->From = utf8_decode (strip_
tags(trim(emailDeEnvio)));
27 $Email->FromName = utf8_
decode('nomeDeEnvio’);
28 $Email->AddAddress($destinatario); // para
quem será enviada a mensagem
29 $Email->Subject = $assunto;
30 $Email->Body .= $html;
31 if(!$Email->Send()){
32 echo "<p>A mensagem não foi enviada. </p>";
33 echo "Erro: " . $Email->ErrorInfo;
34 }else{
35 header("Location: index.php", TRUE);
36 }
37 ?>
www.esab.edu.br 337
Na linha 3 do Código 148, observamos que, para possibilitar o envio
do e-mail, é requerido arquivo da biblioteca. Na linha 5, é definido o
e-mail do destinatário, ou seja, para qual endereço o e-mail será enviado,
atribuindo à variável $destinatario. Você também poderia obter o
endereço para o envio no cadastro ou definir uma entrada de dado. A
linha 6 atribui à variável $assunto o valor “Pedido de compra”. O trecho
entre as linhas 7 e 16 define o conteúdo do corpo do e-mail, em formato
HTML, de maneira similar ao definido na tela de acompanhamento
do pedido. Para utilizar a biblioteca, é criada uma instância da classe
PHPMailer e atribuído à variável $Email, na linha 17. São necessárias
configurações de envio, realizadas através de métodos definidos na classe
PHPMailer, acessíveis, portanto, ao objeto criado. Dessa forma, são
configuradas a linguagem (linha 18), a definição que trata de um servidor
SMTP (linha 19) e a definição que trata da autenticação SMTP (linha
20). Ainda são configurados os dados do servidor de envio: na linha
21 você deve definir o servidor de e-mail que será utilizado para fazer
o envio, ou seja, deve trocar a informação do parâmetro; na linha 22,
você deve configurar o usuário de e-mail que será utilizado para enviar;
e, na linha 23, você precisa trocar a informação, inserindo a senha do
usuário, definido na linha 22. Na linha 24 é definida a porta de envio: as
portas mais comuns utilizadas por servidores SMTP são 25 e 587. Como
o corpo do e-mail utilizado é em formato HTML, deve-se configurar
através de método IsHTML com valor verdadeiro. As linhas 26 a 30
definem dados do envio e, na linha 31, é realizado o envio, retornando
valor verdadeiro em caso de sucesso. Em caso de insucesso (valor falso
para o retorno), as linhas 32 e 33 serão executadas, apresentando
mensagem de erro; em caso de sucesso, a página será redirecionada para a
tela principal.
Dessa forma, concluímos a definição de nossa aplicação web para

loja virtual. Na próxima seção, você estudará conceitos básicos, os
quais devem ser conhecidos para distribuir a aplicação, ou seja, para
disponibilizar a aplicação de forma que ela seja acessível a um cliente ou
usuário, através de endereço válido para internet.
www.esab.edu.br 338
Para sua reflexão
A partir dos conhecimentos adquiridos na
disciplina sobre PHP, como você vê, agora, essa
linguagem? Qual é o seu ponto de vista com
relação ao seu uso?
48.2 Distribuindo a aplicação

Para que uma aplicação web fique disponível para utilização, ela deve
estar armazenada em um servidor acessível. O serviço de armazenamento
é comumente chamado de hospedagem. Portanto, a publicação
ou a distribuição de uma aplicação PHP consiste, basicamente, na
transferência dos arquivos que constituem a sua aplicação para o servidor
de hospedagem. Esse processo é necessário quando o desenvolvimento
ocorre em um computador diferente daquele que hospedará a página
acessível ao usuário.
O primeiro passo é a definição de onde será hospedada a aplicação: caso

haja um servidor com acesso à internet, ele poderá ser utilizado. Porém,
tendo em vista questões de manutenção de esquemas de disponibilidade
(garantia de redundância do fornecimento de energia elétrica e link de
internet) e segurança (políticas contra invasão, acesso físico e atualização
das versões, diminuindo a vulnerabilidade), é mais comum a contratação
de um serviço de hospedagem. Quando da escolha do serviço de
hospedagem, esses pontos devem ser considerados, além do preço
praticado; no entanto, deve-se garantir que as tecnologias são compatíveis
– nesse caso, principalmente em relação à versão do PHP utilizada (caso
você utilize um banco de dados para armazenamento, deve garantir que o
servidor aceita a instalação dessa base).
www.esab.edu.br 339
Para acessar a aplicação através de um endereço (por exemplo, <www.
esab.edu.br>), é necessário ter posse de um domínio válido. O domínio
é o nome que compõe o endereço, direcionando o usuário ao endereço
físico no qual a aplicação está hospedada. Para adquirir um domínio
terminado com .br (domínio brasileiro), o registro é realizado pelo
site <registro.br>. Após a confirmação da compra do domínio, deve-
se configurar o servidor de domínio, disponibilizado pela empresa que
hospedará a aplicação.
Com o serviço de hospedagem contratado, a distribuição da aplicação

deve garantir que todos os arquivos necessários para o funcionamento da
aplicação estejam disponíveis. Um dos grandes problemas enfrentados
na distribuição se deve a endereços relativos usados dentro de seu código
(se usar endereços absolutos, como “c:\algo\exemplo”, você sempre terá
problemas para disponibilizar a sua aplicação). Assim, você deve garantir
que os arquivos estejam disponibilizados com a mesma estrutura de
pastas, principalmente no que diz respeito às imagens.
A cópia dos arquivos normalmente é realizada utilizando protocolo

FTP (File Transfer Protocol). Após a cópia, garanta, efetuando testes,
que as operações continuem funcionando e que as dependências (como
cabeçalhos, rodapés, includes, requires) estão sendo corretamente
direcionadas, de modo a não criar erros indesejados.
Caso tenha realmente tomado todos os cuidados, a distribuição está

correta e o seu software estará disponível para utilização!
Nesta unidade, concluímos o desenvolvimento da aplicação web para

uma loja online e estudamos como distribuir ou publicar nossa aplicação
na internet.
Atividade
www.esab.edu.br 340
Resumo
Na unidade 43, iniciamos o desenvolvimento de uma aplicação

completa, definindo cabeçalhos e rodapés que serão reutilizados, tela de
acesso e entrada de dados de cliente. Para isso, aplicamos conhecimento
de formulários, programação orientada a objetos, controle de sessão,
cookies e tratamento de exceções.
O desenvolvimento da aplicação foi continuado na unidade 44, criando

formulário e scripts para cadastramento de produtos. Para isso utilizamos,
além dos conhecimentos estudados anteriormente, o envio (upload) de
arquivos, usado, nesse caso, para o envio da imagem do produto.
Ainda no desenvolvimento da aplicação, na unidade 45 desenvolvemos

o carrinho de compras com a tela de confirmação. Utilizamos conceitos
já estudados de controle de sessões e o uso de script em linguagem
javascript, simulando a submissão do formulário, além do uso do
header(“Location :”) para redirecionar páginas.
Na unidade 46, foram desenvolvidos os resumos do pedido,

possibilitando ao cliente a impressão do resumo, ao final do fechamento
do pedido, através de documento RTF e arquivos PDF.
Dando continuidade ao desenvolvimento da aplicação, na unidade 47 foi

desenvolvido script para o acompanhamento do pedido (finalização do
pedido), bem como a possibilidade de emissão dos relatórios e de envio
de e-mail com a confirmação dos pedidos, além de definição de script
para cancelamento do pedido.
Na unidade 48, concluímos o desenvolvimento da aplicação com a

construção de operação de envio de e-mail com a confirmação do
pedido. Por fim, estudamos como disponibilizar a aplicação na web.
www.esab.edu.br 341
Glossário
Administração do sistema
O termo administração do sistema refere-se à gestão e à configuração
do sistema, em área específica ou com privilégio especial, de modo a
possibilitar a sua utilização com base nos parâmetros configurados. R
Backtrace
Mostra a função que estava sendo executada quando foi gerado o erro. R
Biblioteca de códigos
É uma coleção de subprogramas e rotinas utilizados no desenvolvimento
de software. Contém código e dados auxiliares, de forma a serem
reutilizados em programas independentes, possibilitando o
compartilhamento e a alteração de código e de dados. R
Bug
Erro ou defeito na lógica de um programa de computador que o impede
de funcionar corretamente. R
Código sustentável
O termo refere-se à característica da aplicação de ser facilmente mantida
(efetuar manutenções preventivas e correções, por longo período de
tempo, de forma a possibilitar a sua utilização pelo usuário). R
Combobox
Também chamada de caixa de combinação, é um elemento da interface
gráfica de um programa ou página que combina uma caixa de texto com
uma listagem de opções para preenchimento da caixa. R
www.esab.edu.br 342
Concatenar
É a “soma” de textos, ou seja, a união do conteúdo de duas strings.
Concatenando o texto “php” e “teste”, teríamos uma string com o
conteúdo “phpteste”. R
Criptograficamente
Codificação de dados para impedir a sua compreensão por quem não
conhece o código. R
CSS
Cascading Style Sheets que, em tradução livre, significa “Folha de Estilos
em Cascata”. Permite a determinação dos estilos a serem utilizados e
define o layout de documentos HTML. R
Depuração
Processo de encontrar erros de uma aplicação de modo a melhorar a sua
qualidade, garantindo o bom funcionamento. R
Distribuição
Tradução do termo “deployment”, utilizado de forma frequente dentro
do processo de desenvolvimento (ciclo de vida) do software para designar
o processo de disponibilização ao usuário, para que este possa fazer
uso do software. Para aplicações web, está relacionado à instalação do
documento no servidor, possibilitando a sua utilização. R
Dízima periódica
Um número que, quando escrito no sistema decimal, apresenta uma
série infinita de algarismos decimais que, a partir de certo algarismo, se
repetem em grupos de um ou mais algarismos. R
www.esab.edu.br 343
E-commerce
Comércio eletrônico ou e-commerce é um conceito aplicável a qualquer
tipo de negócio que implique a transferência de informação através de
dispositivos eletrônicos, sobretudo utilizando a internet. Compreende
sítios destinados à negociação entre consumidores, sítios de leilões ou
comércio de bens e serviços entre organizações. R
Estender
Cria uma extensão que, no contexto de orientação a objeto, significa criar
uma subclasse (herança), herdando os métodos e atributos da superclasse,
e podendo adicionar novos métodos e atributos, especializando-a
(definindo de forma mais detalhada). R
Formatação de texto
Preparação do texto através de organização visual, realce e estrutura,
alterando posicionamento, fonte, tamanho etc. R
Formatar
Definir um formato. No contexto de manipulação de variáveis string,
significa especificar a forma através da qual se apresentará a informação,
ou seja, a disposição gráfica. R
Funções
Forma de executar um determinado grupo de códigos com o objetivo de
reaproveitar códigos, melhorando a performance de desenvolvimento. R
GUI
Graphical User Interface que, em tradução livre, significa Interface
Gráfica do Usuário. Permite a utilização de dispositivos digitais e a sua
interação através de elementos gráficos, como ícones. R
www.esab.edu.br 344
Hexadecimal
Sistema de numeração de base 16, no qual cada símbolo pode guardar
valores que podem ser (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F). R
Hiperlink
Uma hiperligação é uma referência de um documento que liga a outro
documento, texto ou imagem. R
Horário de Greenwich
O Greenwich Mean Time, ou horário médio de Greenwich, é conhecido
como o marcador oficial de tempo. Os fusos horários recebem
decréscimo de horas quando percorridos a oeste, e a leste recebem o
incremento. Dizer que o fuso horário é GMT-03:00 significa dizer que a
hora atual equivale a duas horas a menos do horário de Greenwich. R
HTML
Abreviação de HyperText Markup Language, que significa “Linguagem
de Marcação de Hipertexto”. R
IMAP
Internet Message Access Protocol, traduzido como “Protocolo de Acesso
à Mensagem da Internet”. Trata-se de um protocolo de gerenciamento de
correio eletrônico, que permite o envio e o recebimento de e-mails. R
Javascript
Trata-se de uma linguagem de programação interpretada e implementada
como parte dos navegadores web para que as páginas que contenham
scripts pudessem ser executadas do lado do cliente, interagindo com
o usuário sem a necessidade de processamento realizado pelo servidor.
Desse modo, ela controla o navegador, alterando o conteúdo do
documento exibido. R
www.esab.edu.br 345
Layout
É uma palavra inglesa, em português «leiaute». Significa plano, arranjo,
esquema, design, projeto. No contexto de uma página web, significa a
forma como ela está arranjada ou que seus componentes estão alocados
na tela. R
Logado
Palavra criada a partir do uso de sistemas que exigem autenticação
(login). Significa que o usuário foi autenticado (confirmado por algum
método que garanta sua identidade) e está conectado. R
Loop
A tradução de loop, no contexto de programação de computadores, é
“repetição”. R
Manutenção
É o processo de melhoria e otimização de um software já em
funcionamento (produção) e também de correção de erros e defeitos. As
melhorias podem estar relacionadas a solicitações de clientes e a restrições e
regulações oriundas do governo (mudança de legislação, por exemplo). R
Manutenibilidade
Capacidade do software (ou da aplicação) de ser mantido/receber
manutenção, ou seja, alterações preventivas, corretivas e evolutivas para
manter o funcionamento da aplicação. R
Metassignificado
Significa “além do significado”, ou seja, são significados que dão
significados a outras coisas. No contexto do uso de expressões regulares,
significa que o significado do padrão de texto dado auxilia na definição
do significado das palavras que seguem esse padrão. R
www.esab.edu.br 346
Octal
É um sistema de numeração cuja base é 8, ou seja, utiliza 8 símbolos
para a representação de quantidade. Para converter um número decimal
em octal, pode-se efetuar divisões sucessivas por 8. Por exemplo: ao
converter 67 (decimal) para octal, teremos 62/8 = 7 resto 6, ou seja 76.
Na linguagem PHP, a representação do octal inicia com 0. Nesse caso, o
número decimal 62 é igual ao número decimal 062. R
Open-source
Código aberto. Possibilita o acesso a códigos que foram utilizados para
sua construção, permitindo alterações e melhorias, bem como uso livre,
dependendo da sua licença. R
Otimização
Relacionada à melhoria do desempenho da aplicação. Otimizar uma
aplicação significa, portanto, melhorar o seu desempenho. R
Parâmetro
São variáveis que definem o comportamento da função, ou seja, são
dadas na sua entrada e a sua execução depende desses valores. R
PDFlib
É uma biblioteca utilizada para criar documentos PDF a partir do
conteúdo do banco de dados. Esse recurso disponibiliza todas as funções
necessárias para gerar documentos PDF com texto, gráficos, imagens e
elementos interativos. R
Perl
Perl é uma linguagem de programação utilizada em aplicações, sendo
destacado o seu uso no desenvolvimento web. R
www.esab.edu.br 347
Planejamento
Está relacionado às definições de como se deve executar o
desenvolvimento do software, principalmente no que diz respeito
às atividades tipicamente problemáticas, como análise econômica,
organização do projeto (incluindo equipes e responsabilidades),
estruturação das tarefas, cronograma do projeto, análise e gestão de risco
e estimativa de custos. R
Pre-releases
Antes do lançamento; são versões de teste. R
Programação orientada a objeto

É um paradigma de análise, projeto e programação de sistemas de
software com base na definição e na interação entre diversas unidades
de software, chamadas objetos. Nesse paradigma implementa-se
um conjunto de classes que define os objetos presentes no sistema
de software. Cada classe determina as operações, o comportamento
(definido nos métodos), os estados e as informações possíveis (atributos)
de seus objetos, além de seus relacionamentos. R
Redundância
No contexto apresentado, esse termo está relacionado à duplicidade
de ambientes, dispositivos ou estruturas, de modo a garantir o seu
funcionamento, para que, em caso de falha da primeira estrutura, a
segunda desempenhe o papel de forma transparente para o usuário. R
Requisitos funcionais
Definem as funções e os objetivos de um sistema ou de parte dele,
determinando as suas entradas (quais informações são entradas) e as
saídas esperadas, bem como o seu comportamento. Definem cálculos,
manipulação de dados e como deve ser efetuado o processamento que
determina o que um sistema, idealmente, será capaz de realizar. R
www.esab.edu.br 348
Requisitos não funcionais
Definem a qualidade do software em relação a desempenho, usabilidade,
confiabilidade, segurança, disponibilidade, manutenibilidade e
tecnologias envolvidas, ou seja, as características do software ou como os
requisitos funcionais devem ser construídos para atender aos padrões de
qualidade definidos. R
Sequência de Fibonacci
É uma sequência de números naturais (inteiros e com sinal positivo)
na qual os primeiros dois termos são 1 e 1 e cada termo subsequente
corresponde à soma dos dois precedentes. R
Similaridade
No conceito de orientação a objetos, a similaridade representa a
semelhança quando duas ou mais classes irão compartilhar os mesmos
atributos e/ou métodos. R
Sintaxe
É o conjunto de regras que definem as sequências corretas dos elementos
e comandos. R
SNMP
Simple Network Management Protocol, traduzido como “Protocolo
Simples de Gerência de Rede”, é um protocolo da camada de aplicação
da gerência típica de redes, a fim de facilitar o intercâmbio de informação
entre os dispositivos. R
Source Forge
Repositório de códigos-fonte fundamentado na web e utilizado por
desenvolvedores para controlar e manter projetos de softwares de código
aberto (open source) de modo colaborativo. R
www.esab.edu.br 349
SQL
Structured Query Language, traduzido como “Linguagem de Consulta
Estruturada”. É a linguagem de pesquisa e de consulta padrão para banco
de dados relacionais. R
Sun
Sun Microsystems é uma subsidiária da Oracle Corporation, fabricante
de computadores e semicondutores. É responsável por uma gama de
produtos open-source. R
UML
Sigla de Unified Modeling Language, ou Linguagem de Modelagem
Unificada. É uma linguagem de modelagem que permite que os
desenvolvedores utilizem seus diagramas padronizados, que usam
denotação gráfica e definem significados, semântica. R
Vulnerabilidade
Brecha de segurança, ou seja, ponto vulnerável que possibilita acesso
indevido ou não autorizado. R
W3C
World Wide Web Consortium, consórcio internacional com cerca de
400 membros, agregando empresas, órgãos governamentais, comunidade
acadêmica e organizações independentes. R
Workspace
Espaço de trabalho do Eclipse, onde são salvos os arquivos referentes ao
código e à configuração de projetos. R
Zend Engine
Interpretador reescrito do PHP. Introduzido na versão 4, foi melhorado
para o PHP 5. R
www.esab.edu.br 350
Referências
MANZANO, J. A. N. G.; TOLEDO, S. A. de. Guia de orientação e

desenvolvimento de sites: HTML, XHTML, CSS e JavaScript. São Paulo:
Érica, 2008.
MELONI, J. C. Fundamentos de PHP. Rio de Janeiro: Ciência Moderna, 2000.
THOMSON, L.; WELLING, L. PHP e MySQL: desenvolvimento web. 3. ed.

São Paulo: Érica, 2005.
www.esab.edu.br 351

3724 Pdflinguagemprog

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

3724 Pdflinguagemprog

Enviado por

Direitos autorais:

Formatos disponíveis

CURSO DE SISTEMAS Linguagem

Vila Velha (ES)

Produção do Material Didático-Pedagógico

Diretoria Executiva Designer Educacional

Seja bem-vindo à disciplina de Linguagem de Programação. Esta disciplina faz parte

A Linguagem de Programação servirá como base para o desenvolvimento de

Utilizaremos como Ambiente Integrado de Desenvolvimento (IDE, sigla para

Para essa disciplina, utilizaremos como bibliografia básica os livros de Manzano

Esperamos que esta disciplina possa lhe acrescentar os conhecimentos necessários

Nas disciplinas anteriores você desenvolveu algumas competências e

Essas competências serão reavivadas através do desenvolvimento de uma

1.1 Desenvolvendo uma página simples usando HTML

As etiquetas (tags) são palavras entre parênteses angulares (< e >)

Você poderá recordar tais conceitos desenvolvendo um documento

Código 1 – Exemplo de documento HTML

Fonte: Elaborado pelo autor (2014).

O exemplo contido no Código 1 apresenta tag HTML, obrigatória e

A linha 2 traz a tag que define o cabeçalho do documento HTML,

Figura 1 – Documento HTML no bloco de notas e seu resultado no navegador.

Código 2 – Exemplo de documento HTML, com uso de formatos

Fonte: Elaborado pelo autor (2014).

No item seguinte você aprenderá a aplicar uma formatação usando

Segundo Manzano e Toledo (2008), a estrutura sintática de uma instrução

O Código 3 apresenta um exemplo de formatação de estilo, contendo

Código 3 – Exemplo de documento HTML com uso de formatos e estilos

Fonte: Elaborado pelo autor (2014).

Para a formatação você pode alterar propriedades como background

Nesta unidade você relembrou e colocou em prática conhecimentos

Na unidade 1 você desenvolveu um documento HTML simples,

2.1 Desenvolvendo um formulário usando html

Código 4 – Exemplo de documento HTML com uso de formatos e estilos

Fonte: Elaborado pelo autor (2014).

A tabela é criada na linha 7, com a propriedade referente à borda

Dentro do conteúdo da tabela é criada a primeira linha, na linha 8

Figura 4 – Documento HTML com uma tabela apresentada no navegador.

Após relembrar o uso de tabelas, você deverá criar um documento com

Para a criação de formulários você deve ter definidas algumas propriedades:

• action: informa o endereço de internet para o qual o conteúdo do

• name: nome do elemento do formulário (botão, caixa de texto etc.).

A tag <textare>a deve ser usada quando se deseja a entrada de textos

A Figura 5 mostra um exemplo de formulário cujo layout foi definido

Para desenvolver o exemplo, você deverá utilizar o Código 5. Observe:

Fonte: Elaborado pelo autor (2014).

Note que o alinhamento dos componentes de entrada só foi possível com

Para o nosso exemplo, usaremos JavaScript para validar um e-mail.

Quadro 1 – Características obrigatórias de um e-mail.

Sendo assim, vamos alterar o nosso formulário. Adicione à linha de

<input type=”text” name=”email” onblur=”validacaoEmail(email)”

Código 6 – Formulário com a validação de e-mail

Fonte: Elaborado pelo autor (2014).

Na função JavaScript, criada junto ao Código 6, a primeira linha

A partir da terceira linha, temos comandos específicos do JavaScript: A

A linha 4 retorna os valores após a posição posterior ao símbolo “@”, do

As linhas 5, 6 e 7 fazem parte de uma única instrução (IF) e impõem

• (usuario.length >=1) que o tamanho da variável usuário (do texto

Figura 6 – Documento HTML com formulário e script de validação de e-mail.

Nesta unidade vimos que é possível receber informações do usuário e

Nas unidades 1 e 2 você desenvolveu páginas HTML que interagem com

Vamos começar estudando o que é PHP. Preparado para começar esse

3.1 O que é PHP?

Seu uso permite o desenvolvimento de aplicações web, de forma a

Figura 7 – Código PHP integrado ao HTML.

A linguagem PHP é interpretada. Mas o que isto significa? No próximo