PHP e Mysql

PHP & MySQL
Essentials
www.4linux.com.br
-2
Sumário
Capítulo 1
Introdução
......................................................................................................................................................10
1.1. Objetivos...........................................................................................................................10
1.2. Definição do projeto.........................................................................................................11
1.3. PHP e MySQL - onde vamos chegar ...............................................................................11
1.4. Como funciona um servidor Web ....................................................................................12
1.4.1. URL (Uniform Resource Locator) ou endereço da página
..........................................................................................................................................................14
1.4.2. Protocolo .................................................................................................................................14
1.4.3. Endereço do Servidor : Porta .................................................................................................15
1.4.4. Diretório/Arquivo ...................................................................................................................16
1.4.5. Arquivos índice de diretórios..................................................................................................16
1.5. Instalando o servidor web Apache com suporte ao PHP ...............................................17
1.5.1. Gerenciando pacotes com o Aptitude ....................................................................................17
1.5.2. Instalando o servidor Apache 2 com suporte ao PHP5..........................................................18
Capítulo 2
Breve revisão ao HTML/XHTML ................................................................................................20
2.1. Objetivos...........................................................................................................................20
2.2. Introdução teórica............................................................................................................21
2.3. Conhendo e personalizando o editor Gedit ....................................................................22
2.4. Estrutura básica de uma página HTML/XHTML ...........................................................23
2.5. Um primeiro exercício em HTML/XHTML ....................................................................25
2.5.1. Organizando o exercício ........................................................................................................25
2.5.2. Formulário de Compras .........................................................................................................26
2.6. Páginas estáticas X Páginas dinâmicas ..........................................................................28
Capítulo 3
A solução: PHP ............................................................................................................................29
3.1. Objetivos...........................................................................................................................29
3.3. Características do PHP ...................................................................................................30
3.4. Sintaxe básica .................................................................................................................31
3.5. Variáveis ..........................................................................................................................33
3.5.1. Conceito...................................................................................................................................33
3.5.2. Nomes de variáveis ................................................................................................................34
-3
3.5.3. Tipos de variáveis suportados ...............................................................................................34

3.5.4. Atribuíndo valor a uma variável.............................................................................................35
3.5.5. Atribuíndo valor a Strings ......................................................................................................35
3.6. Exercício Teórico..............................................................................................................37
3.7. Variáveis do PHP .............................................................................................................38
3.7.1. Variáveis de ambiente ............................................................................................................38
3.7.2. Variáveis superglobais ...........................................................................................................38
3.7.3. Constantes ..............................................................................................................................39
3.7.4. Constantes pré-definidas .......................................................................................................39
3.8. Operadores .....................................................................................................................39
3.8.1. Aritméticos .............................................................................................................................40
3.8.2. Operador de strings ...............................................................................................................40
3.8.3. Operador de atribuição ..........................................................................................................41
3.8.4. Operadores bit a bit ...............................................................................................................41
3.8.5. Operadores lógicos ................................................................................................................42
3.8.6. Operadores de comparação ...................................................................................................42
3.8.7. Operadores de incremento e decremento .............................................................................43
3.8.8. Ordem de precedência dos operadores .................................................................................43
3.9. Exercícios Teóricos...........................................................................................................44
Capítulo 4
Integrando o PHP ao HTML .......................................................................................................46
4.1. Objetivos...........................................................................................................................46
4.2. Primeira forma:................................................................................................................47
4.3. Segunda Forma:...............................................................................................................48
4.3.1. Terceira forma:........................................................................................................................48
4.4. Laboratório.......................................................................................................................49
Capítulo 5
Estruturas de controle ...............................................................................................................50
5.1. Objetivos...........................................................................................................................50
5.3. Condição: if/else ..............................................................................................................51
5.4. Condição elseif e switch/case .........................................................................................52
5.4.1. Adicionando ao script .............................................................................................................54
5.5. Laços de Repetição ou Loops .........................................................................................55
5.5.1. Interrompendo uma estrutura de controle ...........................................................................56
5.6. Laboratório.......................................................................................................................56
Capítulo 6
Funções .......................................................................................................................................57
-4
6.1. Objetivo.............................................................................................................................57
6.3. Laboratório.......................................................................................................................59
6.4. Escopo das Variáveis .......................................................................................................59
Capítulo 7
Formulários, GET e POST...........................................................................................................62
7.1. Objetivos...........................................................................................................................62
7.2. Passando variáveis entre scripts.....................................................................................63
7.2.1. Os métodos GET e POST ........................................................................................................63
7.3. Laboratório.......................................................................................................................66
7.4. Criando Links...................................................................................................................66
Capítulo 8
Arrays e Strings...........................................................................................................................68
8.1. Objetivos...........................................................................................................................68
8.2. Arrays...............................................................................................................................68
8.3. Strings..............................................................................................................................69
8.4. Strings vão muito além doque apenas caracteres que representam texto. Com strings
podemos trabalhar com arrays, validação de campos, formatação de texto e até mesmo
criar uma classe de template.
Vamos ver nesse capitulo algumas funções interessantes para se trabalhar com Strings.. 69
8.4.1. str_replace()............................................................................................................................69
8.4.2. strip_tags()...............................................................................................................................70
8.4.3. stristr().....................................................................................................................................70
8.4.4. strcmp()...................................................................................................................................71
8.4.5. Explode e Implode...................................................................................................................71
8.5. Laboratório.......................................................................................................................72
Capítulo 9
Header, Cookies, Sessões ...........................................................................................................73
9.1. Objetivos...........................................................................................................................73
9.2.1. Como utilizar sessões .............................................................................................................74
9.3. Laboratório.......................................................................................................................75
Capítulo 10
Introdução ao Banco de dados MySQL.......................................................................................76
10.1. Objetivos.........................................................................................................................76
10.2. Introdução teórica..........................................................................................................77
10.3. Instalando o MySQL ......................................................................................................77
-5
10.3.1. Melhorando a segurança do banco .....................................................................................78

10.4. Instalando o suporte ao MySQL no PHP 5. ..................................................................80
10.4.1. Instalando uma interface web para gerenciamento do MySQL .........................................80
10.5. Conceitos básicos de Banco de Dados .........................................................................80
10.5.1. Tabelas ..................................................................................................................................80
10.5.2. Registros (ou tupla) ..............................................................................................................81
10.5.3. Colunas (Atributos ou Campos) ...........................................................................................81
10.5.4. Domínio (Tipos de Dados) ....................................................................................................81
10.5.5. Chave ....................................................................................................................................81
10.5.6. Índices ..................................................................................................................................82
10.5.7. Relacionamentos ..................................................................................................................83
10.6. A Linguagem SQL .........................................................................................................83
10.6.1. Alguns padrões de sintaxe para o SQL do MySQL .............................................................84
10.6.2. Tipos de dados mais usados no MySQL ..............................................................................85
10.7. Criando Bancos e Tabelas .............................................................................................86
10.7.1. Criando tabelas ....................................................................................................................87
10.7.2. Obtendo informações sobre o banco e tabelas....................................................................88
10.7.3. Inserindo registros (INSERT) ..............................................................................................88
10.7.4. Atualizando registros (UPDATE) ........................................................................................90
10.7.5. Excluindo registros (DELETE) .............................................................................................91
10.7.6. Selecionando registros (SELECT) .......................................................................................92
10.8. Administração de usuários ..........................................................................................95
10.9. phpMyAdmin .................................................................................................................96
10.10. Construindo a base de dados do website ...................................................................96
10.10.1. Garantindo as permissões de acesso .................................................................................99
10.10.2. Populando o banco. ............................................................................................................99
10.11. Conceitos Avançados...................................................................................................99
10.11.1. Transações..........................................................................................................................99
10.11.2. Prepared Statment............................................................................................................100
10.12. Finalizando ................................................................................................................101
Capítulo 11
Integrando o PHP com MySQL ................................................................................................102
11.1. Objetivos.......................................................................................................................102
11.2. Extensão Melhorada MySQL (mysqli).........................................................................103
11.2.1. Conectando-se ao banco ....................................................................................................103
11.2.2. Executando consultas ........................................................................................................104
11.2.3. Recuperando registros........................................................................................................105
11.2.4. Passando por todos registros .............................................................................................106
11.2.5. Exemplo completo com uso do Modo Orientado a Objeto ................................................107
11.2.6. Prepared Statment..............................................................................................................108
-6
11.2.7. Transactions........................................................................................................................110
11.3. PDO (PHP Data Objects)..............................................................................................111
11.3.1. Conectando-se ao banco ....................................................................................................112
11.3.2. Executando consultas ........................................................................................................113
11.3.3. Executando inserções, exclusões e atualizações...............................................................114
11.3.4. Prepared Statment..............................................................................................................114
11.3.5. Transactions........................................................................................................................116
Capítulo 12
Programação Orientada a Objetos ...........................................................................................117
12.1. Objetivos.......................................................................................................................117
12.2. Introdução teórica........................................................................................................118
12.3. Conceitos .....................................................................................................................118
12.3.1. Classe .................................................................................................................................118
12.3.2. Objeto .................................................................................................................................119
12.3.3. Atributos .............................................................................................................................119
12.3.4. Métodos ..............................................................................................................................119
12.4. Uma classe simples: Pessoa ........................................................................................119
12.5. Herança .......................................................................................................................122
12.6. Encapsulamento ..........................................................................................................124
12.7. Métodos mágicos.........................................................................................................125
12.7.1. __construct .........................................................................................................................125
12.7.2. __destruct ...........................................................................................................................127
12.7.3. __get e __set.........................................................................................................................127
12.7.4. __toString............................................................................................................................130
12.7.5. Outros métodos mágicos ...................................................................................................131
12.8. Classes Abstratas ........................................................................................................131
12.9. Interfaces e Métodos Abstratos...................................................................................132
12.9.1. Interfaces............................................................................................................................132
12.9.2. Métodos Abstratos..............................................................................................................133
12.10. Atributos Estáticos ....................................................................................................133
12.11. Métodos Estáticos .....................................................................................................134
12.12. A mensagem de erro mais louca do PHP .................................................................137
Capítulo 13
Streams......................................................................................................................................138
13.1. Objetivo........................................................................................................................138
13.3. Método fopen ..............................................................................................................139
13.3.1. Gravando informações em arquivos ..................................................................................139
13.3.2. Lendo arquivos ...................................................................................................................140
-7
13.3.3. Fechando arquivos ............................................................................................................140

13.4. Método file ..................................................................................................................140
13.5. Método file_get_contents ............................................................................................141
Capítulo 14
Tratamento de Erros e Exceções..............................................................................................142
14.1. Objetivos.......................................................................................................................142
14.2. Exibição de erros.........................................................................................................142
14.2.1. Função die...........................................................................................................................144
14.2.2. Capturando e Gerando Erros..............................................................................................144
14.2.3. Registro de Erros (Log)......................................................................................................145
14.2.4. Configurando o php.ini.......................................................................................................146
14.3. Tratamento de Exceções..............................................................................................147
14.3.1. Métodos...............................................................................................................................147
Capítulo 15
Construindo uma classe de acesso a dados .............................................................................148
15.1. Objetivos.......................................................................................................................148
15.2. Porque uma classe Tabela? .........................................................................................149
15.3. Construindo a classe tabela ........................................................................................150
15.3.1. config.inc.php – arquivo de configuração..........................................................................150
15.3.2. Atributos da Classe Tabela.................................................................................................151
15.3.3. Construtor ..........................................................................................................................152
15.3.4. Um getter automático.........................................................................................................154
15.3.5. Método para execução de consultas..................................................................................155
15.3.6. Listando (SELECT) registros..............................................................................................157
15.3.7. Recuperando um registro pela chave primária.................................................................159
15.3.8. Excluindo um registro pela chave primária.......................................................................160
15.3.9. Inserindo um registro.........................................................................................................161
15.3.10. Atualizando um registro....................................................................................................163
15.4. Criando um CRUD........................................................................................................166
15.4.1. O que é um CRUD?.............................................................................................................166
15.4.2. Criando as classes filhas ....................................................................................................166
15.4.3. Adicionando um método específico à classe......................................................................167
15.4.4. Exemplo de uso ..................................................................................................................168
Capítulo 16
Separando HTML do PHP: Classe Template............................................................................175
16.1. Objetivo........................................................................................................................175
16.3. Classe Template: pegando e exibindo arquivos de templates....................................177
16.4. Cabecalho do Site Administrativo...............................................................................180
-8
16.5. Cabeçalho do site público............................................................................................182

16.6. Rodapé..........................................................................................................................183
16.7. Abstração de listagem de registros.............................................................................184
16.8. Outros métodos............................................................................................................188
16.8.1. templates/login.html...........................................................................................................197
16.8.2. templates/livroResumo.html...............................................................................................198
16.8.3. templates/livroDetalhe.html ..............................................................................................199
Capítulo 17
Segurança: Sistema de Login...................................................................................................200
17.1. Objetivo........................................................................................................................200
17.2. Classe Seguranca.........................................................................................................201
17.2.1. login.php..............................................................................................................................204
17.2.2. logout.php...........................................................................................................................206
17.2.3. index.php alterado para checar usuário logado................................................................206
REFERÊNCIAS
BIBLIOGRÁFICAS......................................................................................................................207
ANEXOS.....................................................................................................................................209
HTML/XHTML - Referência Básica......................................................................................210
Estrutura Básica de uma página ....................................................................................................210
Tags de Texto ..................................................................................................................................211
Listas ...............................................................................................................................................211
Imagens ..........................................................................................................................................212
Tabelas ............................................................................................................................................212
Formulários .....................................................................................................................................213
Enviando e-mails com o PHP ...............................................................................................217
Verificando o tipo de uma variável ......................................................................................218
Transformação de tipos - Coerções ...............................................................................................219
Transformação explícita de tipos ...................................................................................................221
Conexão segura ....................................................................................................................222
Instalando a ferramenta OpenSSL - (Secure Socket Layer) .........................................................222
Criando uma certificadora local ....................................................................................................222
Criando um site seguro ..................................................................................................................223
Acertando o resolvedor de nomes local .........................................................................................224
Criando uma requisição de certificação ........................................................................................224
Assinando a certificação ................................................................................................................224
Habilitando o site seguro ...............................................................................................................225
Habilitando conexão segura ...........................................................................................................225
Reiniciando o servidor web. ...........................................................................................................225
-9
Capítulo 18
A certificação.............................................................................................................................226
18.1. Questionário ZEND(Inglês).........................................................................................227
Índice de tabelas
Tabela 1: Tipos de Dados no PHP5.........................................................................................34
Tabela 2: Caracteres de Escape..............................................................................................36
Tabela 3: Variáveis Superglobais do PHP...............................................................................38
Tabela 4:Operadores aritméticos ...........................................................................................40
Tabela 5: Operador de string .................................................................................................40
Tabela 6: Operadores de Atribuição.......................................................................................41
Tabela 7: Operadores Bit a Bit................................................................................................41
Tabela 8:Operadores lógicos ..................................................................................................42
Tabela 9: Operadores de comparação ...................................................................................42
Tabela 10:Operadores de incremento/decremento ...............................................................43
Tabela 11:Ordem de precedência dos operadores ................................................................43
Tabela 12: Tabela Clientes......................................................................................................80
Tabela 13:Tabela de Operadores de Comparação .................................................................93
Tabela 14:Tabela Operadores Lógicos ...................................................................................94
Tabela 15: Caracteres de especificação de tipo...................................................................109
Tabela 16: Lista de tipos para método bindParm.................................................................114
Índice de Figuras
Figura 1.1: Como funciona um servidor Web.........................................................................13
Figura 10.1: Tabela Pessoa ....................................................................................................87
Figura 12.1: Classe Pessoa...................................................................................................120
Figura 12.2: Herança de classes..........................................................................................122
Capítulo 1 Introdução - 10
Capítulo 1
Introdução
1.1. Objetivos
• Compreender o mercado atual do PHP;
• Entender o funcionamento de um servidor web;
• Estar apto para instalar o servidor web Apache com suporte ao PHP.
Introdução teórica
Agora iremos definir nosso projeto, ver aonde iremos chegar com o PHP e o
SBGD MySQL.
1.2. Definição do projeto
Nosso projeto será dividido em 4 partes:
◦ Cadastro de Produtos;
◦ Cadastro de Usuário;
◦ Login;
◦ Pedido.
1.3. PHP e MySQL - onde vamos chegar
No mercado atual de desenvolvimento um dos maiores focos é o

desenvolvimento de aplicações para internet - sejam websites, sejam sistemas.
Muitas aplicações que antigamente rodavam exclusivamente em um computador
isolado ou em redes locais hoje são distribuídas através de intranets (redes internas
com recursos da internet) ou extranets (redes internas que se comunicam com
clientes externos).
Estas aplicações necessitam de profissionais que dominem 3 tecnologias

básicas:
• Web Design;
• Uma linguagem de desenvolvimento Web;
• Um banco de dados.
O Web Design é um ramo de criação artística, mas que também envolve a

programação em HTML/XHTML, CSS, e também em linguagens acessórias como
Javascript e Flash. Apesar de ser possível criar inclusive animações (como no caso do
Flash), o Web Design está limitado à criação de páginas ESTÁTICAS, em que o
conteúdo será sempre o mesmo independente de quantas vezes for solicitado.
Linguagens de desenvolvimento Web permitem a criação de páginas

DINÂMICAS, ou seja, que serão diferentes a depender da solicitação, das
informações que foram atualizadas, do usuário que realiza a requisição, etc. Para isto
são instaladas no lado do servidor, ou interagem com recursos do servidor.
Banco de dados são aplicações que armazenam informações de modo

organizado, facilitando a inclusão, exclusão, alteração, exclusão e recuperação destes
dados. Existem várias situações em que os dados estão armazenados em sistemas
especialistas, como servidores de email, sistemas de arquivos, etc, mas o uso mais
intensivo e comum é armazenar em banco de dados.
Entretanto, para utilizar estas tecnologias é preciso um hospedeiro que as

forneça para os clientes: o Servidor Web
1.4. Como funciona um servidor Web
Servidor é um aplicativo que aguarda requisições de clientes, realiza algum

processamento baseado nestas requisições e responde a eles conforme as suas
atribuições.
Servidores Web, a princípio, são "entregadores de arquivos". Recebem

requisições de arquivos (geralmente HTML e imagens) dos clientes e entregam.
Entretanto, são mais inteligentes do que isso, podendo repassar requisições para
outros sistemas, linguagens de programação, etc, receber este processamento e
repassar para o cliente.
No lado do cliente é necessário um aplicativo cliente, conhecido como

navegador ou browser. Ele envia as requisições ao servidor Web e tem a função de
interpretar o código recebido (HTML/XHTML, principalmente), montar a página e
requisitar informações adicionais como imagens e outras mídias.
O protocolo de comunicação utilizado pelos servidores Web é o HTTP

(Protocolo de Transferência de Hipertexto). Sites seguros utilizam o protocolo
HTTPS, que é uma extensão segura do HTTP.
Figura 1.1: Como funciona um servidor Web
Na Figura 1.1: Como funciona um servidor Web ilustra-se o funcionamento

básico de um servidor Web.
É importante perceber que, de modo básico, o servidor Web é um servidor de

páginas HTML/XHTML. Os arquivos HTML/XHTML possuem comandos (tags) que
solicitam outros tipos de arquivos (imagens, animações, etc) ao servidor. Então, uma
única página HTML/XHTML servida pode resultar em várias solicitações adicionais
ao servidor (chamados "hits").
1.4.1. URL (Uniform Resource Locator) ou endereço da página
O endereço de um página web é representado pela URL (Uniform Resource

Locator). Ele é composto de:
• Protocolo
• Endereço do Servidor (normalmente seu nome de host/domínio): porta (a
porta é opcional)
• Recurso no servidor (no caso de serviços Web, diretório/arquivo)
Exemplo:
http://www.4linux.com.br/cursos/php-mysql-web-developer-412.html
1.4.2. Protocolo
Protocolo pode ser compreendido como uma "língua comum" para que dois
computadores troquem informações dentro de um padrão de requisição e respostas,
independente de suas plataformas, ambientes, linguagens de programação, etc.
Isto permite que um computador rodando Windows se comunique com um

outro computador rodando Linux, MacOS, Unix, etc, e independente de fabricantes
de hardware - e vice-versa também.
O protocolo dos servidores Web, como já vimos, é o HTTP (ou HTTPS para
modo seguro). Entretanto, é comuns os navegadores também se comunicarem com
outros serviços com outros protocolos como o FTP.
No caso de uma URL para um endereço web, o protocolo será normalmente

http:// ou https://.
1.4.3. Endereço do Servidor : Porta
O endereço do servidor geralmente é representado geralmente por um FQDN

(Fully Qualified Domain Name - Nome de Domínio Plenamente Qualificado) de um
host DNS (Domain Name System - Sistema de Nomes de Domínios), mas também
pode ser representado pelo seu endereço IP.
O DNS é um sistema que trabalha como uma "agenda telefonica", resolvendo

nomes de domínio para endereços IP, que são a forma direta de comunicação a um
servidor. Todo servidor possui seu endereço IP, e também podemos acessá-lo
diretamente por ele.
Entretanto, existem diversos servidores web com um único IP respondendo

por vários domínios, então neste caso é mandatório utilizar-se o nome de host em
DNS para acessar este serviço.
A porta padrão dos servidores Web é 80 e por isto pode ser omitida na
navegação usual. Se o servidor aguarda requisições em outra porta, é necessário
informá-la após o endereço, separado por dois pontos.
Exemplos de Endereços:
www.4linux.com.br
netclass.hackerteen.com
66.118.142.41
netclass.hackerteen.com:8020
66.118.142.41:8050
Observação: O nome de host www é um padrão para nomes de máquinas que

hospedam um site Web, mas não é uma obrigatoridade. Atualmente é muito comum
sites mais curtos, ou que respondam sem a necessidade desta informação
(redirecionam automaticamente para www). Teste: http://4linux.com.br e veja o que
acontece.
1.4.4. Diretório/Arquivo
Uma vez fechada a conexão com o servidor, então solicitamos um arquivo

específico a ser retornado. Este é solicitado na estrutura diretorio/nome_arquivo.
É importante compreender que existe uma relação direta entre o caminho que
informamos e o sistema de arquivos, pois o servidor Web determina um "caminho
raiz" para os arquivos.
Deste modo, sendo o caminho raiz de um domínio:
/var/www/4linux
Então, se solicitamos o endereço:
http://www.4linux.com.br/cursos/php-mysql-web-developer-412.html
O servidor Web nos retornará o arquivo:
/var/www/4linux/cursos/php-mysql-web-developer-412.html
Este exemplo é um simplificação. Diversos sistemas web modernos utilizam

um recurso chamado de "reescrita de URLs" (URL rewrite), onde um
endereço é redirecionado internamente para arquivos que os processam
dinamicamente, mediante regras determinadas - mas os clientes utilizam
sempre endereços uniformes e fixos.
1.4.5. Arquivos índice de diretórios
Com um pouco de atenção é possível perceber um "furo" neste sistema:

quando não é inforado nenhum arquivo, (exemplo: http://www.4linux.com.br e
http://www.4linux.com.br/cursos, que arquivo será fornecido pelo servidor web?
Neste caso existe uma configuração nos servidores que é DirectoryIndex (ou
semelhante): ele especifíca qual o arquivo que será acessado caso se requisite
apenas um diretório, ou seja, qual o índice do diretório. Os padrões mais comuns são
index.html (padrão Apache) e default.html (padrão ISS, da Microsoft). Quando o
servidor possui vínculo com alguma outra linguagem, é comum que os arquivos desta
linguagem também sejam configurados, como index.php (PHP), index.pl (Perl), etc.
1.5. Instalando o servidor web Apache com

suporte ao PHP
1.5.1. Gerenciando pacotes com o Aptitude
Nosso curso será realizado numa plataforma GNU/Linux utilizando a

distribuição Debian 5.0-Lenny. O gerenciador de pacotes oficial do Debian é o
aptitude. Para o utilizarmos, precisamos inicialmente configurar os repositórios no
arquivo /etc/apt/sources.list. No nosso caso, usaremos um repositório interno.
Configure as fontes como mostrado abaixo :
deb http://192.168.1.1/lenny main contrib non-free
Agora atualizaremos a base de dados local :
# aptitude update
Podemos procurar por pacotes com o comando abaixo. Por exemplo, para
buscar o pacote apache2 :
# aptitude search apache2
Existem vários pacotes. São em sua maioria pacotes de bibliotecas opcionais.

Mas aquele que nos interessa é o apache2
1.5.2. Instalando o servidor Apache 2 com suporte ao PHP5
# aptitude install apache2
Testando a instalação
Abra um navegador e digite a URL:
http://localhost/
Se tudo funcionou bem, vamos instalar o PHP 5 :
# aptitude install php5
Testando a instalação do PHP5
Para testar, é necessário criar um arquivo com extensão .php no diretório raiz
do servidor web, que é /var/www:
# gedit /var/www/phpinfo.php
Coloque neste arquivo o seguinte código:
<?php phpinfo() ?>
E então é possível verificá-lo na endereço:
http://localhost/phpinfo.php
Esta função especial do PHP fornece dados completos sobre a instalação do

servidor Web e do PHP, sendo muito útil no desenvolvimento - mas perigoso em um
ambiente de produção, onde não devemos dar informações excessivas aos clientes.
Agora você está com seu servidor Web com suporte a PHP funcional.
Capítulo 2 Breve revisão ao HTML/XHTML - 20
Capítulo 2
Breve revisão ao HTML/XHTML
2.1. Objetivos
• Rever os conteúdos necessários de HTML;
• Compreender as diferenças de páginas estáticas e páginas dinâmicas.

2.2. Introdução teórica
O HTML (HyperText Markup Language - Linguagem de Marcação de

Hipertexto) é uma linguagem de marcação, ou seja, utiliza TAGS (marcadores) para
indicar início e fim de comandos.
Atualmente utilizamos o padrão HTML 4.01. Entretanto, existe uma outra

especificação, que é o XHTML 1.0, que é uma reformulação do HTML para seguir os
padrões do XML, muito mais rígido, mas também muito mais portável e consistente
que o HTML. O XHTML exige tags em minúsculas e sempre fechadas (abriu, fechou),
atributos sempre com valores e com valores entre aspas simples, entre outras coisas.
O XHTML também não permite formatação dentro das TAGS como o HTML, a
formatação é sempre através de folhas de estilo em cascata (CSS). Isto facilita muito
a vida do programador, além de tornar as páginas mais leves e de carregamento mais
ágil.
Entretanto, HTML e XHTML são muitíssimo parecidos. Neste curso, o

conjunto de TAGS utilizadas são praticamente coincidentes nas duas. A sintaxe será
preferencialmente em XHTML (tags minúsculas, sem formatação no conteúdo) mas
sem rigidez, ou seja, aceitando algumas facilidade do HTML, pois não é objetivo ser
um curso de XHTML/HTML.
Sugere-se que o desenvolvedor em Web domine o XHTML e CSS, para

implementar com padrões mais consistentes seus projetos. Entretanto, não é escopo
deste curso o Webdesign, portanto, apenas tags básicas serão revistas para o bom
andamento do curso.
A seguir será feita uma pequena revisão dos conceitos das TAGS
HTML/XHMTL e criado um pequeno conjunto de páginas com as TAGS básicas para
este curso.
No Apendice A - HTML/XHTML - Tags Básicas você encontra uma referência

básica às tags utilizadas neste exercício.
2.3. Conhendo e personalizando o editor Gedit
Utilizaremos o editor Gedit em nosso curso. Ele é simples, mas possui

alguns recursos úteis que nos ajudarão na edição dos arquivos em
HTML/XHTML e PHP.
Sempre acesse o Gedit como root, pois de outro modo não será possível
salvar os arquivos dentro do diretório /var/www.
Para isto, acesse um terminal como root e digite:
#cd /var/www
#gedit &
O "&" informa que o comando será executado em segundo plano, liberando

o terminal para outros comandos.
Configurações interessantes no Gedit (menu Editar -> Preferências):
• Aba Visualização, ativar Mostrar números de linha;

• Aba Visualização, ativar Destacar parênteses correspondentes;
• Aba Editor, Largura das tabulações: informar 2;
• Aba Editor, ativar Inserir espaços em vez de tabulações.
Outra dica interessante é o realce de sintaxe, que facilita a detecção de erros

de digitação. Para usá-la, ao iniciar um novo arquivo já o salve com a extensão
adequada (.html para HTML, .php para PHP, etc). Caso necessite forçar um realce
específico, utilize o menu Ver -> Modo de destaque e selecione o desejado.
2.4. Estrutura básica de uma página

HTML/XHTML
Os documentos em HTML/XHTML, como já foi mencionado, são estruturas

organizadas em TAGS, que são elementos (palavras chave) entre os sinais < e >. Eles
são comandos de formatação da linguagem. As TAGS possuem abertura e
fechamento, geralmente representadas assim:
1 <b>texto em negrito</b>
2 <p> parágravo </p>
3 <h1> título em primeiro nível </h1>
Algumas TAGS não possuem fechamento (no HTML) ou são "autofechadas",

(no XHTML que exige que toda TAGS tenham fechamento). Isto é comum em
elementos vazios ou que não englobam texto:
4 <br />Quebra de linha

5 <hr />Linha horizontal
6 <input type="text" name="endereco" />
Como toda linguagem de programação, existe um meio de expressar

comentários, trechos que não serão executados, apenas para documentação:
7 
As TAGS podem ter atributos, que no XHTML devem obrigatoriamente ter

valor e este estar entre aspas duplas:
8 <textarea name="observacao" rows="20" cols="50">

9 algum texto
10 </textarea>
Todo documento HTML deveria ter a seguinte estrutura básica (o XHTML

EXIGE):
11 <html>
12 <head>
13
14 <title>Título da página</title>
15 </head>
16 <body>
17 textos, imagens, links, etc...
18 </body>
19 </html>
O documento HTML/XHTML possui dois grandes blocos: o <head> e o <body>.

No <head> são colocadas informações de cabeçalho do arquivo, inclusive o título da
página, inclusão de arquivos externos como CSS e Javascript, definição de metatags
para agilizar pesquisas em sites de busca. No <body> é onde se coloca o conteúdo
propriamente dito da página.
No HTML não há distinção entre tags com caixa baixa ou alta, ou seja <HTML>,
<Html> e <html>, mas o XHTML é rígido e só aceita tags e atributos em minúsculas.
OBSERVAÇÃO:
Olhando com atenção arquivos na internet veremos que a maioria dos

arquivos começam um código como segue:
20 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"

21 "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
Este é o DOCTYPE, ou seja, definição do tipo de arquivo e especificação de

sua especificação DTD(Document Type Definition). Este é um tópico avançado sobre
HTML/XHTML, e foge do escopo deste curso. Você pode saber um pouco mais sobre
isto nas referências abaixo:
Doctype - DTD - Document Type Definition (em português):

http://revolucao.etc.br/archives/doctype-dtd-document-type-definition/
Recommended DTDs to use in your Web document (em inglês):

http://www.w3.org/QA/2002/04/valid-dtd-list.html
2.5. Um primeiro exercício em HTML/XHTML
2.5.1. Organizando o exercício
Para construir um exemplo organizado, vamos criar um diretório base para

nosso exercício. Abra um terminal como root e siga os comandos:
#cd /var/www
#mkdir curso
#cd curso
#mkdir html
#mkdir php
Agora temos o diretório /var/www/curso/html, que pode ser acessado no

navegador pela URL http://localhost/curso/html .
2.5.2. Formulário de Compras
Esta página conterá um pequeno formulário em HTML.
Salve o arquivo abaixo em /var/www/curso/html/comprar.html.
1 <html>
2 <head>
3 <title>
4 Borracharia do Tux
5 </title>
6 </head>
7 <body>
8 <h1>Borracharia do Tux</h1>
9 <form action="processar.html" method="post">
10 <table border="1">
11
12 Item
13 Quantidade
14
15
16 <td>Rodas</td>
17 <td>
18 <input type="text" name="nrodas" size="3" maxlength="3">
19 </td>
20
21
22 <td>Pneus</td>
23 <td>
24 <input type="text" name="npneu" size="3" maxlength="3">
25 </td>
26
27
28 <td>Parafusos</td>
29 <td>
30 <input type="text" name="nparafusos" size="3" maxlength="3">
31 </td>
32
33
34 <td>Como você conheceu a Borracharia do Tux?</td>

35 <td>
36 <select name="find">
37 <option value="a">Na 4Linux</option>
38 <option value="b">Anúncio na TV</option>
39 <option value="c">Internet</option>
40 <option value="d">Indicação</option>
41 </select>
42 </td>
43
44
45 <td colspan="2">
46 <input type="submit" value="Enviar" />
47 </td>
48
49 </table>
50 </form>
51 </body>
52 </html>
Para acessar em seu navegador utilize a URL

http://localhost/curso/html/comprar.html .
Página de recebimento do Formulário:
Salve o arquivo abaixo em /var/www/curso/html/processar.html.
1 <html>
2 <head>
3 <title>
5 </title>
6 </head>
7 <body>
9 <h2>Pedido finalizado.</h2>
10 </body>
11 </html>
Testando: abra no navegador a URL

http://localhost/curso/html/comprar.html, preencha o formulário e
envie. Você será levado para a página processar.html.
2.6. Páginas estáticas X Páginas dinâmicas
Neste exemplo, se preenchemos ou não o formulário, ou se acessamos a

página processar.html diretamente, o resultado é o mesmo, pois são páginas
estáticas, que não interagem com o usuário. No máximo poderíamos usar um recurso
antigo de enviar um email com o formulário.
Por meio de páginas dinâmicas é possível processar este envio de

informações, realizando tarefas como manipulação de banco de dados e gerar então
páginas com respostas a requisições específicas, ou a envio de formulários com
dados de um determinado cliente, por exemplo.
Isto nos permite então criarmos aplicações web dos mais variados tipos, desde
agendas a fóruns, sistemas de documentação, jogos, chats, dentre outros.
O HTML/XHTML é "público", ou seja, o navegador o recupera e pode ser

visualizado facilmente. Entretanto, é possível embutir dentro do HTML/XHTML
código de outras linguagens, que são processados no servidor e então o navegador só
recebe o resultado. Isto permite uma maior segurança.
Para escrever páginas dinâmicas existem várias linguagens, como Active

Server Pages (ASP); Java Server Pages (JSP); além do PHP Hipertext Preprocesor
(PHP), que é o tópico de nosso curso.
Capítulo 3 A solução: PHP - 29
Capítulo 3
A solução: PHP
3.1. Objetivos
• Estar apto a executar os conceitos básicos vistos nesse capítulo.
• Obter noções de variáveis, sintaxe básica e operadores.
O PHP é uma linguagem para programar scripts, livre, gratuita,

independente de plataforma, rápida e muito utilizada para gerar conteúdo
dinâmico na Web, com uma grande biblioteca de funções e extensa
documentação.
É uma linguagem INTERPRETADA com tipagem DINÂMICA.
Foi criado originalmente em 1994 por Rasmus Lerdorf e ao longo de sua
história teve muitas contribuições de outros desenvolvedores. Atualmente o
PHP está em sua versão 5.2.8 (08/12/2008). Sua versão de desenvolvimento
é a 6.
Qualquer pessoa pode baixar através da página principal do PHP -

www.php.net - e de forma gratuita, um módulo que faz com que nosso
servidor Web interprete os scripts escritos nesta linguagem.
3.3. Características do PHP
Esta linguagem de programação está preparada para realizar muitos tipos de

aplicações Web, graças à extensa quantidade de funções com a qual está dotada.
Existem funções que cobrem desde cálculos matemáticos complexos até tratamento
de conexões de rede.
O PHP é uma linguagem poderosa e pode fazer praticamente qualquer coisa

que as linguagens concorrentes. Entretanto, é sempre bom lembrar que cada
linguagem tem suas forças e fraquezas, vantagens e desvantagens.
Uma das principais características do PHP é o suporte a um grande número

de bancos de dados, como dBase, Interbase, mySQL, Oracle, Sybase, PostgreSQL e
vários outros, tornando uma tarefa simples construir uma página, baseada em um
banco de dados, com PHP.
Além disso, o PHP tem suporte a outros serviços através de protocolos, como
IMAP, SNMP, NNTP, POP3 e, logicamente, HTTP. Ainda é possível abrir sockets e
interagir com outros protocolos.
Seu primeiro programa em PHP
Utilizaremos um exemplo simples, em que o PHP trará escrito na página a

frase "Olá Mundo!". Utilize o Gedit para criar este arquivo.
12 <?php
13 echo("Olá Mundo!");
14 ?>
Salve o arquivo em /var/www/curso/php/olamundo.php e abra-o em seu

navegador com a URL http://localhost/curso/php/olamundo.php.
Este exemplo nos mostra o comando echo, que "ecoa" ou envia uma string
como HTML/XHTML. O ideal é que no decorrer do script seja montada uma página
HTML/XHTML perfeitamente formatada para não gerar erros de visualização.
3.4. Sintaxe básica
Para que um arquivo seja interpretado como código PHP é necessário que
ele tenha a extensão .php (ou outra que seja configurada no servidor Web,
o que não é muito comum).
O arquivo pode misturar código em PHP e HTML. Para isto, é preciso

delimitar o conteúdo em PHP com TAGS especiais, que são:
// STANDARD TAGS
<?php
comandos;
?>
// SHORT TAGS
<?
comandos;
?>
// SCRIPT TAGS
<script language="php">
comandos;
</script>
// ASP TAGS
<%
comandos;
%>
As formas mais comuns são as duas primeiras, sendo que o DESEJÁVEL é a

primeira, por sua clareza e não ambigüidade.
A forma SHORT TAG estará disponível apenas se a opção short_open_tags

for definida como on no arquivo de configuração /etc/php5/apache2/php.ini
do PHP5 – o que é uma opção padrão comum nos servidores.
A forma ASP TAG é “Deprecated”, ou seja, será eliminada em uma versão

futura do PHP – ou seja, não a utilize!
Se o arquivo só contém comandos PHP, é posssível omitir a tag de

finalização ( ?> ). Isto também evita que espaços após esta tag causem
problemas com headers já enviados (principalmente em sessões).
No PHP os comandos deve terminar em ponto-e-vírgula (;), como no exemplo

abaixo:
15 phpinfo();
16 echo "testando";
Se faltar o ponto-e-vírgula haverá um erro no script, como abaixo:
17 phpinfo()
18 echo "testando";
Entretanto, estruturas de controle não precisam de ponto e vírgula - como é o

caso do if no exemplo:
19 <?php
20 if ($x == $x) //não precisa de ponto e vírgula
21 {
22 echo 'com ponto e vírgula'; //precisa de ponto e vírgula
23 }
24 ?>
Comentários podem ser nas três formas abaixo:
25 <?php
26 // Comentário de uma única linha,
echo "teste" // ou até o final da linha
27 # Comentário de uma única linha, ou até o final da linha (pouco
usado)
28 /*
29 Comentário em
30 múltiplas linhas
31 */
32 ?>
3.5. Variáveis
3.5.1. Conceito
O PHP é uma linguagem fracamente tipada, ou seja, não exige declaração de

tipos. Além disso, é de tipagem dinâmica: determina o tipo da variável conforme o
valor que lhe é atribuído, podendo ter alterado tipo durante a execução pela simples
atribuição de um valor diferente.
3.5.2. Nomes de variáveis
As variáveis no PHP sempre iniciam com o cifrão ($) seguido de uma letra ou
do caracter "_".
// Variáveis válidas
$dia
$Mes
$_ano
// Variáveis inválidas
$*dia
$9meses
$(nome)
O PHP é case sensitive, ou seja, as variáveis $Mes e $mes são diferentes.
Todo projeto deve ter uma padronização no nome das variáveis. Elas não
devem ser codificadas demais a ponto de não serem claras, nem longas a
ponto de dificultar seu uso. Além disso, deve-se evitar variáveis
complemente em maiúsculas, pois este é um padrão para CONSTANTES.
3.5.3. Tipos de variáveis suportados
PHP suporta os seguintes tipos de dados:
Tabela 1: Tipos de Dados no PHP5
Tipo Macro Tipo Básico Tipo Detalhado

Escalares (scalar) boolean Lógico:
apenas um valor true ou false
0 ou 1
int Decimal: 10, -8765, 0
Octal: 0755, 0140 (inicia com zero)
Hexadecimal: 0x754; 0XFF; -0x1A0
float Decimal: 10.98, -7976,000987

Exponential: 1E6 (1000000), 1.2e2 (120)
string Texto
Outras informações (conteúdo serializado,
como imagens, som, etc.)
Array Conteiner de elementos ordenados (veja
Compostos mais na página REFERENCIA)
(compound)
Objects Conteiner de dados e código
NULL Representa variável sem valor (que é
diferente de ter valor zero ou vazio)
Outros
resource Indica armazenamento de recursos externos,
geralmente manipulados por módulos.
3.5.4. Atribuíndo valor a uma variável
O símbolo de atribuição é o igual ( = ).
33 <?php
34 $teste = "Linux";
35 $total = 867;
36 ?>
3.5.5. Atribuíndo valor a Strings
Strings podem ser atribuídas de duas maneiras:
Utilizando aspas simples ( ' ) - desta maneira, o valor da variável será

exatamente o texto contido entre as aspas (com exceção de \\ e \' - ver tabela abaixo)
Utilizando aspas duplas ( " ) - desta maneira, qualquer variável ou caractere

de escape será expandido antes de ser atribuído.
Teste o exemplo abaixo :
37 <?php
39 $php = '---$teste---\n';
40 echo "$php";
41 ?>
A saída desse script será:
---$teste--\n
Teste este outro exemplo
42 <?php
44 $php = "---$teste---\n";
45 echo "$php";
46 ?>
A saída desse script será:
---Linux---
(com uma quebra de linha no final)
Existe também a sintaxe conhecida como HEREDOC, que utiliza o delimitador

especial <<< seguido de uma palavra chave, que determinará o final da string:
47 <?php
48 $teste = <<<TEXT
49 Uma linha de texto
50 TEXT;
51 ?>
A tabela seguinte lista os caracteres de escape:
Tabela 2: Caracteres de Escape
Sintaxe Significado
\n Nova linha
\r Retorno de carro
\t Tabulação horizontal
\\ A própria barra \
\' Aspas simples '
\” Aspas duplas “
3.6. Exercício Teórico
1. Qual das tags abaixo representa uma ASP TAG:
a) <? ?>
b) <?php ?>
c) <# #>
d) <% %>
2. Como eu declaro uma HEREDOC?
___________________________________________________________________________________
___________________________________________________________________________________
___________________________________________________________________________________
3. Qual a diferença de “aspas duplas” para 'aspas simples' ?
___________________________________________________________________________________
___________________________________________________________________________________
___________________________________________________________________________________
2. Explique o significado dos seguintes caracteres de escape e de um exemplo de

utilização:
\n ->______________________________________________________________________________
\t ->______________________________________________________________________________
\r ->______________________________________________________________________________
3.7. Variáveis do PHP
3.7.1. Variáveis de ambiente
O PHP possui diversas variáveis de ambiente, como a $PHP_SELF, que contém

o nome e o path do próprio arquivo. Algumas outras contém informações sobre o
navegador do usuário, o servidor http, a versão do PHP e outras diversas
informações.
Para ter uma listagem de todas as variáveis e constantes de ambiente e seus

respectivos conteúdos, utilizamos a função phpinfo().
3.7.2. Variáveis superglobais
O PHP possui um conjunto de variáveis reservadas e pré-definidas, de tipo

array, que mantêm diversas informações do programa e do ambiente. Essas variáveis,
são chamadas de superglobais e são de escopo global.
As variáveis superglobais do PHP são:
Tabela 3: Variáveis Superglobais do PHP
Variável Descrição
$GLOBALS Contém uma referência a cada variável disponível no escopo das variáveis
do script. As chaves desta matriz são os nomes das variáveis globais.
$_SERVER Estas variáveis são definidas pelo servidor web, caso contrário são
relacionadas ao ambiente de execução do script atual.
$_GET Variáveis disponíveis no script, oriundas de HTTP GET.
$_POST Variáveis disponíveis no script, oriundas de HTTP POST.
$_COOKIE Variáveis disponíveis no script, oriundas de HTTP cookies.
$_FILES Variáveis disponíveis no script, oriundas do envio de arquivos via HTTP.
$_ENV Variáveis disponíveis no script através do ambiente de execução do script.
$_REQUEST Através desta variável, tem-se acesso ao conteúdo das variáveis $_GET,
$_POST e $_COOKIE.
$_SESSION Variáveis registradas na sessão do script atual.
3.7.3. Constantes
Ao contrário das variáveis, por vezes é interessante definir valores fixos para
todo script, mas também fazendo referência a eles. Estas são as constantes. Por
exemplo, se nosso script faz diversos cálculos usando o número PI, podemos defini-lo
e usá-lo da seguinte forma, utilizando a função define:
52 //Definindo
53 define('PI', 3.1415);
54 //Usando
55 $circunferencia = 2 * PI * $raio;
O padrão é que os nomes de constantes sejam em maiúsculas. Ao contrário

das variáveis, elas não levam o cifrão (%) na frente de seu nome.
3.7.4. Constantes pré-definidas
O PHP possui algumas constantes pré-definidas, indicando a versão do PHP, o

Sistema Operacional do servidor, o arquivo em execução, e diversas outras
informações. Para ter acesso a todas as constantes pré-definidas, podemos utilizar a
função phpinfo(), que exibe uma tabela contendo todas essas constantes pré-
definidas.
3.8. Operadores
Os operadores têm grande utilidade no desenvolvimento. Com eles podemos

comparar e efetuar cálculos entre variáveis, dentre outras atividades.
3.8.1. Aritméticos
Os operadores aritméticos são símbolos utilizados para efetuarmos cálculos

matemáticos.
Só podem ser utilizados quando os operandos são números (integer ou float).

Se forem de outro tipo, terão seus valores convertidos antes da realização da
operação. Além dos operadores básicos listados a seguir, existem várias funções para
cálculos e operações específicos.
Tabela 4:Operadores aritméticos
Operador Significado
+ Adição
- Subtração
* Multiplicação
/ Divisão
% Módulo
3.8.2. Operador de strings
Só há um operador exclusivo para strings:
Tabela 5: Operador de string
. Concatenação
3.8.3. Operador de atribuição
Existe um operador básico de atribuição e diversos derivados. Sempre

retornam o valor atribuído. No caso dos operadores derivados de atribuição, a
operação é feita entre os dois operandos, sendo atribuído o resultado para o
primeiro. A atribuição é sempre por valor, e não por referência.
Tabela 6: Operadores de Atribuição
= Atribuição simples
+= Atribuição com adição
-= Atribuição com subtração
*= Atribuição com multiplicação
/= Atribuição com divisão
%= Atribuição com módulo
.= Atribuição com
concatenação
Exemplo:
56 <?php
57 $a = 7;
58 $a += 2;// $a passa a conter o valor 9
59 $a -= 1;// $a passa a conter o valor 8
60 $a /= 4;// $a passa a conter o valor 2
61 ?>
3.8.4. Operadores bit a bit
Comparam dois números bit a bit. São utilizados em situações muito

específicas na programação :
Tabela 7: Operadores Bit a Bit
& E lógico
| OU lógico
^ OU exclusivo
~ NÃO (inversão)
>> LEFT shift
<< RIGHT shift
3.8.5. Operadores lógicos
Utilizados para inteiros representando valores booleanos . Seu uso mais

comum é em condições de estruturas de controle (Veja Estruturas de controle ).
Tabela 8:Operadores lógicos
and E lógico
or OU lógico
xor OU exclusivo
! NÃO (inversão)
&& E lógico
|| OU lógico
Existem dois operadores para "e" e para "ou", pois eles têm diferentes
posições na ordem de precedência.
3.8.6. Operadores de comparação
As comparações são feitas entre os valores contidos nas variáveis, e não as

referências.
Sempre retornam um valor booleano ("true" ou "false").
Tabela 9: Operadores de comparação
== Igual a
!= Diferente de
< Menor que
> Maior que
<= Menor ou igual a
>= Maior ou igual a

=== Igual em valor e tipo
!== Diferente em valor e/ou
tipo
3.8.7. Operadores de incremento e

decremento
Tabela 10:Operadores de incremento/decremento
++ Incrementa de 1
-- Decrementa de 1
Podemos utilizá-los de duas formas: antes ou depois da variável. Quando

utilizado antes, retorna o valor da variável já incrementado ou decrementado.
Quando utilizado depois, retorna o valor da variável antes de incrementá-la ou
decrementá-la.
Exemplos:
62 <?php
63 $a = $b = 10; // $a e $b recebem o valor 10
64 $c = $a++; // $c recebe 10 e $a passa a ter 11
65 $d = ++$b; // $d recebe 11, valor de $b já incrementado
66 ?>
3.8.8. Ordem de precedência dos operadores
A tabela a seguir mostra a ordem de precedência dos operadores no momento

de avaliar as expressões. Ela está ordenada dos ítens de menor precedência para o
de maior precedência, isto é os últimos operadores são avaliados primeiros:
Tabela 11:Ordem de precedência dos operadores
Precedência Associatividade Operadores

1 Esquerda ,
2 Esquerda or
3 Esquerda xor
4 Esquerda and
5 Direita print
6 Esquerda = += -= *= /= .= %= & = != ~ = < <= >
>=
7 Esquerda ?:
8 Esquerda ||
9 Esquerda &&
10 Esquerda|
11 Esquerda ^
12 Esquerda &
13 Não associa == !=
14 Não associa < >
15 Esquerda << >>
16 Esquerda +-.
17 Esquerda */%
18 Direita ! ~ ++ -- (int) (double) (string) (array)
(object) @
19 Direita [
20 Não associa new
21 Não associa ()
3.9. Exercícios Teóricos
1. Cite um tipo de variável inválida?
________________________________________________________________________________
________________________________________________________________________________
2. Qual a saída da operação: 4%2 ?
________________________________________________________________________________
________________________________________________________________________________
3. Qual a saída da operação: ((4*4)-4.2.1) ?
________________________________________________________________________________
________________________________________________________________________________
4. Se dissermos que DELTA equivale a ((4*4)-4.2.1) e que x' é: (-4+(√∆))/2.4

A saída será:
________________________________________________________________________________
________________________________________________________________________________
5. Qual a solução acima em sintaxe PHP?
________________________________________________________________________________
________________________________________________________________________________
________________________________________________________________________________
________________________________________________________________________________
________________________________________________________________________________
________________________________________________________________________________
Capítulo 4 Integrando o PHP ao HTML - 46
Capítulo 4
Integrando o PHP ao HTML
4.1. Objetivos
• Fazer a integração do HTML no PHP para exibir os dados de forma amigável ao

usuário.
Existem três técnicas básicas de integrar o PHP ao HTML:
• Incluir código PHP no meio do código HTML;
• Dar saída a código HTML através de comandos do PHP (echo, print, printf,
etc.);
• Armazenar o conteúdo a ser exibido numa variável e então dar saída a código
HTML através de comandos do PHP (echo, print, printf, etc.);
4.2. Primeira forma:
67 <html>
68 <head>
69 <title>
71 </title>
72 </head>
73 <body>
75
76 <?php
77 echo '<h2 align="center">Pedido finalizado em ';
78 echo date('H:i, jS F');
79 echo '</h2>';
80 ?>
81
82 </body>
83 </html>
Perceba que utilizando as tags básicas do PHP (no exemplo <?php ?>)
inserimos uma sequência de comandos PHP, que tiveram “saída” através do comendo
echo.
4.3. Segunda Forma:
84 <?php
85 echo '
86 <html>
87 <head>
88 <title>
90 </title>
91 </head>
92 <body>
94 <h2 align="center">Pedido finalizado em ' .
95 date('H:i, jS F') . '</h2>
96 </body>
97 </html>';
98 ?>
Neste outro exemplo, o arquivo é iniciado com a TAG <?php e seguido do

comando echo, que vai concatenar tanto uma string contendo trecho de código
HTML quanto saída de comandos do próprio PHP (date);
4.3.1. Terceira forma:
99 <?php
100 $conteudo = '
101 <html>
102 <head>
103 <title>
105 </title>
106 </head>
107 <body>

109 <h2 align="center">Pedido finalizado em ';
110 $conteudo .= date('H:i, jS F') . '</h2>
111 </body>
112 </html>';
113 echo $conteudo;
114 ?>
Agora o conteúdo é acumulado (concatenado) na variável $conteudo, que é

“echoada” ao final do script.
4.4. Laboratório
1. Criar um formulário de cadastro de Produtos.
2. Criar um formulário de cadastro de Login.
3. Criar um carrinho de compras.

Capítulo 5 Estruturas de controle - 50
Capítulo 5
Estruturas de controle
5.1. Objetivos
• Saber fazer a escolha da estrutura de controle correta para tomada de

decisões.
• Implementar a sintaxe das tomadas de decisões em algorítmo.
As estruturas de controle são elementos básicos nas linguagens de

programação, onde o fluxo do programa pode ser alterado. Basicamente são
divididos em Condicionais e Laços de Repetição ou Loops
5.3. Condição: if/else
O principal comando para controle de fluxo é o if/else. Sua sintaxe é mostrada

abaixo:
if (condição)
comando; // Executado se a condição for true, apenas um comando
if (condição){
comandos // Executado se a condição for true
}
// O uso do else é opcional:

if (condição){
comandos // Executado se a condição for true
}
else{
comandos // Executado se a condição for false
}
// Também pode ser usada uma sintaxe reduzida para atribuição

$sexoExtenso = ($sexo == 'M') ? 'Masculino' : 'Feminino';
A condição é uma expressão lógica que retorna true ou false.

Vamos exercitar esse comando, incrementando nosso código:
115 if( $total == 0) {

116 echo 'Você não selecionou nenhum item!<br />';
117 }
118 else {
119 echo 'Itens comprados: <br />';
120 if ( $_POST['nrodas'] > 0 )
121 echo $_POST['nrodas'] . ' rodas.<br />';
122 if ( $_POST['npneu'] > 0 )
123 echo $_POST['npneu'] . ' pneus.<br />';
124 if ( $_POST['nparafusos'] > 0 )
125 echo $_POST['nparafusos'] . ' parafusos.<br />';
126 }
5.4. Condição elseif e switch/case
Temos ainda que avaliar a combobox que indica a forma pela qual o usuário
conheceu a Borracharia do Tux.
Mas neste caso, temos várias opções, e não apenas um verdadeiro ou falso.
Nesse caso, podemos utilizar os comandos elseif e switch/case. Um mesmo exemplo é
mostrado abaixo com cada uma das formas:
127 // Exemplo de uso do elseif

128 if ($dia=="Sábado"){
129 echo "Fico em casa";
130 }
131 elseif ($dia=="Domingo"){
132 echo "Vou passear";
133 }
134 else{
135 echo "É dia da semana, vou trabalhar!!!";
136 }
137
138 // Exemplo de uso do switch/case

139 switch($dia){
140 case "Sábado":
141 echo "Fico em casa";
142 break;
143 case "Domingo":
144 echo "Vou passear";
145 break;
146 default:
147 echo "É dia da semana, vai trabalhar!!!";
148 }
No switch é importante o uso do break é importante, pois senão o código

será executado até o final do bloco switch. Em algumas circunstâncias isto
pode ser o desejado. O case especial default, apesar de não obrigatório, é
desejável, pois determina um bloco padrão a ser executado caso nenhum
case anterior seja satisfeito.
5.4.1. Adicionando ao script
Qualquer umas das formas de teste e validação podem ser usados no script
processar.php.
149 echo '<p>Você conheceu a Borracharia do Tux ';

150 // Para facilitar, criaremos uma variável de nome $find
151 $find = $_POST['find'];
152 // Opção usando o elseif
153 if($find == 'a')
154 echo 'na 4Linux</p>';
155 elseif($find == 'b')
156 echo 'por anúncio na TV</p>';
157 elseif($find == 'c')
158 echo 'através da internet.</p>';
159 elseif($find == 'd')
160 echo 'por indicação.</p>';
161 else
162 echo 'não sabemos como!</p>';
163
164 // Opção usando o switch

165 switch($find){
166 case 'a':
167 echo 'na 4Linux.</p>'; break;
168 case 'b':
169 echo 'por anúncio na TV.</p>'; break;
170 case 'c':
171 echo 'através da internet.</p>'; break;
172 case 'd':
173 echo 'por indicação.</p>'; break;
174 default:
175 echo 'não sabemos como!</p>'; break;
176 }
5.5. Laços de Repetição ou Loops
Diversas vezes temos de repetir o mesmo código. Por exemplo, listar uma lista
que tenha 4 ítens, não é difícil escrever utilizando 4 linhas com o comando "echo".
Agora imaginamos a dor de cabeça que seria imprimir uma lista de compras com 100
ítens! Nestes casos, utiliza-se o while ou o for.
Estes dois ciclos são muito similares, visto que se pode sempre converter um
ciclo em outro, e vice-versa. A decisão de utilizar um ou outro, é pessoal e tem a ver
com a simplicidade de interpretação. Existem situações onde um while aplica-se com
mais facilidade e em outras o for. O while é bastante utilizado para passar pelos
registro de uma consulta ao banco de dados.
A sintaxe do while é mostrada abaixo:
177 while(condição){
178 //bloco de código
179 }
O bloco de código é repetido até que a condição se torne falsa. Note que é
importante que dentro do ciclo a condição seja alterada em algum momento para
falsa, pois do contrário o programa travará neste loop.
O comando for é exemplificado abaixo:
180 for ($i=1; $i < 6; $i++){

181 //bloco de código a executar
182 echo '<p>Iteração número: ' . $i . '</p>';
183 }
A saída desde loop será:
Iteração número: 1
5.5.1. Interrompendo uma estrutura de

controle
Se for necessário interromper um loop, pode-se utilizar a instrução break.

Esse comando faz com que o script continue a partir da próxima após o loop. O
comando continue faz com que o loop vá direto para a próxima iteração, sem
executar as demais instruções daquele loop. Por fim, o comando exit interrompe a
execução do script PHP.
5.6. Laboratório
Criar uma estrutura de controle que valida quando apresentar o login e o

logout da aplicação, assim como escrever o nome do visitante ou do usuário na tela.
Capítulo 6 Funções - 57
Capítulo 6
Funções
6.1. Objetivo
• Enteder a funcionalidade das funções e usar os escopos de variáveis.
Funções são blocos de código reutilizável. Elas podem ou não solicitar

parâmetros, e podem ou não retornar valores.
Sua sintaxe básica é:
184 <?php
185 function fazerAlgo ($arg_1, $arg_2, /* ..., */ $arg_n)
186 {
187 echo "Exemplo de função.\n";
188 return $valor_retornado;
189 }
190 ?>
A função pode não solicitar argumentos, apenas realizar algum

processamento:
191 <?php
192 function mostrarTitulo ()
193 {
194 echo "<h1>Capítulo 1</h1>";
195 }
196
197 // Utilizando a função

198 mostrarTitulo();
199 ?>
Entretanto, a função pode também solicitar parâmetros e utilizá-los em algum

processamento:
200 <?php
201 function mostrarTitulo ($numero)
202 {
203 echo "<h1>Capítulo $numero";
204 }
206 mostrarTitulo("1");
207 ?>
Mesmo tendo parâmetros, eles podem não ser obrigatórios se tiverem um

valor padrão estabelecido na função:
208 <?php
209 function mostrarTitulo ($numero='1')
210 {
211 echo "<h1>Capítulo $numero</h1>";
212 }
213
214 // Agora a função funciona tanto assim:

215 mostrarTitulo("3");
216
217 // quanto assim, mas então a variável $numero tera valor = 1

218 mostrarTitulo();
219
220 ?>
Uma função pode retornar valores utilizando-se a palavra chave return.
221 <?php
222 function mostrarTitulo ($numero='1')
223 {
224 return "<h1>Capítulo $numero</h1>";
225 }
226

228 echo mostrarTitulo("1");
229 ?>
Qualquer comando que houver depois de um return será ignorado, pois ele
encerra a função.
6.3. Laboratório
Criar uma função para o cabeçalho do site, uma para o menu e outra para o
rodapé.
6.4. Escopo das Variáveis
A regra básica é a seguinte:
• Variáveis definidas dentro da função só são visíveis dentro da função

• Variáveis definidas fora da função não estão disponíveis para a função
• Variáveis SuperGlobais do PHP estão disponíveis em qualquer lugar
Para acessar uma variável externa dentro da função, utiliza-se uma das duas
sintaxes abaixo:
230 <?php
231 $nome = 'Maria';
232 $sobrenome = 'da Silva';
233 $idade = 25;
234 $dataNascimento = '01/01/1984';
235
236 function exibirPessoa ()

237 {
238 // definindo variáveis globais disponíveis para função
239 global $nome, $sobrenome;
240
241 // Isto funciona

242 echo "<p>Nome da pessoa: $nome $sobrenome</p>";
243
244 // Isto não funciona, variável não disponível

245 echo "<p>Idade: $idade</p>";
246
247 // Isto funciona, utilizando variável $GLOBALS

248 echo "<p>Data de Nascimento: " . $GLOBALS['dataNascimento'] .
"</p>";
249 }
250

252 exibirPessoa();
253 ?>
O modificador static força o script a manter o valor da variável entre

execuções do script:
254 function contador(){

255 static $x = 0;
256 return $x++;
257 }
258 echo contador();echo contador();echo contador();
259 // A saída será: 012
// Lembrando que o return acontecerá antes da incrementação da variável
O modificador static é muito utilizado em funções recursivas, já que o

valor de algumas variáveis precisa ser mantido. Ele funciona da seguinte
forma: o valor das variáveis declaradas como estáticas é mantido ao
terminar a execução da função. Na próxima execução da função, ao
encontrar novamente a declaração com static, o valor da variável é
recuperado.
Em outras palavras, uma variável declarada como static tem o mesmo

"tempo de vida" que uma variável global, porém sua visibilidade é restrita ao escopo
local em que foi declarada e só é recuperada após a declaração.
Outro exemplo:
260 <?php
261 function Teste()
262 {
263 echo "$a";
264 static $a = 0;
265 $a++;
266 }
267 ?>
O exemplo acima não produzirá saída alguma. Na primeira execução da

função, a impressão ocorre antes da atribuição de um valor à função, e
portanto o conteúdo de $a é nulo (string vazia). Nas execuções seguintes da
função Teste() a impressão ocorre antes da recuperação do valor de $a, e
portanto nesse momento seu valor ainda é nulo. Para que a função retorne
algum valor o modificador static deve ser utilizado antes da impressão.
Capítulo 7
Formulários, GET e POST
7.1. Objetivos
• Compreender as diferenças entre os métodos GET e POST .
• Aprender a passar váriaveis de um script para outro.

Capítulo 7 Formulários, GET e POST - 63
7.2. Passando variáveis entre scripts
Os scripts PHP são autônomos. Para que recebam interações do usuário

através dos navegadores é preciso utilizar-se dos métodos GET e POST disponíveis
nos servidores Web.
Os dois métodos podem enviar praticamente o mesmo tipo de informação,

entretanto enquanto o GET utiliza-se da URL para enviar as informações, o POST
utiliza o cabeçalho da requisição (ou seja, envia de forma “oculta”). Pela diferença de
meio, o GET possui limitações de tamanho da informação (que variam por navegador,
podendo ser afetados inclusive por proxies) enquanto o POST possui suporte para
largas informações, ainda que este limite varie e possa ser configurado em alguns
servidores Web.
7.2.1. Os métodos GET e POST
O GET é um método do HTTP destinado a enviar dados do cliente para o

servidor. É acionado por meio de um formulário HTML através da diretiva
method="get" incluída na tag <form>.
Quando um formulário HTML utiliza o método GET, o fluxo de dados é

separado do endereço URL através de um ponto de interrogação (?). Esta forma de
endereçamento e separação pode ser observada no campo de endereços do
navegador do usuário. Logo após o formulário ter sido enviado, podemos ver algo
como:
http://www.meusite.com/meuscript.php?campo1=valor1&campo2=valor2
De outro modo, é possível enviar uma informação via método GET sem a
necessidade de formulário, apenas digitando uma URL diretamente na barra de
endereço do navegador.
O POST é outro método do HTTP similar ao GET, porém é acionado por

meio da diretiva method="post" incluída na tag <form>.
Este método faz com que os dados do formulário sejam transmitidos
“ocultos” no cabeçalho (header) da requisição e não apareçam na URL.
Ao escrevermos nossos scripts, devemos sempre lembrar qual método

estamos usando afim de determinarmos se iremos ler os dados do vetor $_POST ou
$_GET.
Sempre que possível, deve-se utilizar o método POST, pois através do

método GET os dados enviados ficam mais expostos através da URL no
navegador, o que representa uma falha de segurança. Entretando, isto é
apenas uma diretriz - a não ser que haja criptografia, os dados de um POST
podem ser capturados no caminho. A segurança é um conjunto de
procedimentos em que esta prática é incluída.
Para recuperar os dados enviados, utilizamos as variáveis superglobais $_GET,

$_POST e opcionalmente $_REQUEST (que recupera ambos valores, além do contido na
variável superglobal $_COOKIES).
Numa requisição feita como segue:
http://www.meusite.com/meuscript.php?
nome=Joao&idade=29&fone[com]=3333.4444&fone[res]=9999.888
É possível recuperar os valores enviados para o script meuscript.php das

seguintes formas:
268 $nome = $_GET['nome'];

269 $idade = $_GET['idade'];
270 $foneComercial = $_GET['fone']['com'];

271 $foneComercial = $_GET['fone']['res'];
272 // ou
273 $nome = $_REQUEST['nome'];
274 $idade = $_REQUEST['idade'];
275 $foneComercial = $_REQUEST['fone']['com'];
276 $foneComercial = $_REQUEST['fone']['res'];
Já um envio realizado pelo formulário abaixo:
277 <form method='post' action='meuscript.php'>

278 Nome: <input type='text' name='nome' /><br/>
279 Idade: <input type='text' name='idade' /><br/>
280 Fone Comercial: <input type='text' name='fone[com]' /><br/>
281 Fone Residencial: <input type='text' name='fone[res]' /><br/>
282 <button type='submit'>Enviar</button>
283 </form>
É possível recuperar os valores enviados para o script meuscript.php das

seguintes formas:
284 $nome = $_POST['nome'];

285 $idade = $_POST['idade'];
286 $foneComercial = $_POST['fone']['com'];
287 $foneComercial = $_POST['fone']['res'];
288 // ou
289 $nome = $_REQUEST['nome'];
290 $idade = $_REQUEST['idade'];
291 $foneComercial = $_REQUEST['fone']['com'];
292 $foneComercial = $_REQUEST['fone']['res'];
A variável superglobal $_REQUEST é útil mas deve ser utilizada com

cuidado. Por não preocupar-se com a origem da informação, pode ser
facilmente alvo de ataque. Portanto, deve ser utilizada como última opção –
o ideal é usar ou $_GET ou $_POST.
7.3. Laboratório
Criar paginas que recebem os parâmetros dos formulários de Cadastro de

Produtos e Usuários.
7.4. Criando Links
O método GET é a escolha automática quando monta-se links. Uma atividade

de programação muito comum para linguagens Web é a montagem de links
dinamicamente, com passagem de parâmetros (variáveis).
Uma forma simples é simplesmente concatenar os valores para montar o

resultado final:
293 $nome = 'joao';

294 $url = '/meuscript.php?nome=' . $nome;
295 echo '<a href="' . $url . '">Editar Nome</a>
Isto gera:
<a href="/meuscript.php?nome=joao">Editar Nome</a>
Entretanto, existem caracteres que não podem ser colocados literalmente na

URL (como espaço), então utiliza-se uma função do PHP para realizar isto, que é o
urlencode.
296 $nome = 'joao da silva';

297 $url = '/meuscript.php?nome=' . $nome;
298 echo '<a href="' . $url . '">Editar Nome</a>';
Isto gera:
<a href="/meuscript.php?nome=joao%20da%20silva">Editar Nome</a>
Apesar do uso deste comando, não é preciso utilizar a função urldecode ao

receber a variável através da variável superglobal $_GET; isto é feito
automaticamente.
Capítulo 8 Arrays e Strings - 68
Capítulo 8
Arrays e Strings
8.1. Objetivos
• Compreender o uso de arrays e strings
• Verificar as funções para trabalhar com Strings
8.2. Arrays
Um array no PHP é atualmente um mapa ordenado. Um mapa é um tipo que

relaciona chaves para valores. Este tipo é otimizado de várias maneiras,
então você pode usá-lo como um array real, ou uma lista (vetor), hashtable
(que é uma implementação de mapa), dicionário, coleção, pilha, fila e
provavelmente mais. Como você pode ter outro array PHP como um valor,
você pode facilmente simular árvores.
A explicação dessas estruturas estão além do escopo desse manual, mas
você pode encontrar exemplos para cada uma dessas estruturas a seguir.
Para mais informações sobre estruturas, refira-se a literatura externa sobre
esses tópicos.
Exemplo de array:
299 $array = array(“iPod”,”iMac”);
Ainda com arrays, posso associá-los a uma lista, fazendo com que variáveis
assumam determinados valores correspondentes aos índices do array.
300 $list(“nome”,”idade”,”sexo”) = array(“joao”,”40”,”M”);
Podemos ainda através de um laço recuperar valores de um array de forma

dinâmica e interativa. Com isso usamos o foreach para facilitar nossas vidas.
301 foreach($array as $valor){

302 echo $valor.”<br />”;
303 }
8.3. Strings
8.4. Strings vão muito além doque apenas caracteres que representam
texto. Com strings podemos trabalhar com arrays, validação de campos,
formatação de texto e até mesmo criar uma classe de template.
Vamos ver nesse capitulo algumas funções interessantes para se trabalhar
com Strings.
8.4.1. str_replace()
A função str_replace() nos permite alterar ocorrências de uma string por

qualquer outra informação que quisermos, com isso, podemos fazer com que o PHP
sempre que encontrar uma ocorrência do tipo %nome% seja substituído por “João”.
304 str_replace(“%nome%”,”João”,”<b>Olá %nome%</b>”)
8.4.2. strip_tags()
Com a função strip_tags() permitimos ao PHP que bloqueie tags HTML de uma
determinada string, mantendo assim uma certa “segurança” ao código gerado.
Isso é valido por exemplo em um sistema de comentários, ao qual eu permito que o
usuário faça uso de tags do tipo “<p>”, “<b>” e “<i>”.
305 strip_tags(“<a href='ola.php'><b><i>Ola

mundo</i></b></a>”,”<b>”)
8.4.3. stristr()
Com stristr() conseguimos fazer buscas de determinadas “palavras” e uma

string, tendo como retorno uma informação booleana.
306 $string='hello world';

if(stristr($string,'earth')===FALSE){
echo “Não encontramos a palavra earth”;
}
8.4.4. strcmp()
Com strcmp conseguimos comparar duas strings, tendo retorno booleano.

Vale ressaltar que essa função é case sensitive, caso queira ignorar maiúsculas e
minúsculas faça uso da função strcasecmp().
307 if(strcmp(“a”,”A”)==0){
308 echo “As strings são iguais”;
309 }
8.4.5. Explode e Implode
Exatamente como o nome diz, essas funções explodem e implodem strings e

arrays.
A primeira, tem por sua vez, a função de explodir uma string dividindo-a em
array.
Com isso conseguimos por exemplo validar um e-mail.
310 $email=”kinn.coelho@4linux.com.br”;
311 $verificacaoEmail = explode(“@”,$email);
312 $verificacaoDominio = explode(“.”$verificacaoEmail[0]);
313 if(verificacaoEmail[0] != “” AND verificacaoDominio[1] !=””)
314 echo “E-mail válido”;
O Implode por sua vez, nos permite transformar um array em uma string.
315 $pessoa['nome'] = ”Kinn”;

316 $pessoa['sobrenome'] = ”Coelho”;
317 $nomeCompleto = implode(“ ”,$pessoa);
318 echo $nomeCompleto.”<br />”;
319 if(is_string($nomeCompleto)){
320 echo “É uma string”;
321 }
8.5. Laboratório
Fazendo uso das funções de Strings, vamos criar nossa engine de template.
Iremos fazer uso do método chamado substituição de parâmetros.
322 $pagina = file_get_contents(“templates/”.$_GET['pag'].”.php”);

323 $corpo = str_replace(array(“%nome%”,”%sobreNome
%”),array(“João”,”Silva”));
324 echo $corpo;
Capítulo 9
Header, Cookies, Sessões
9.1. Objetivos
• Apreder porque e como fazer uso de sessão para armazenar valores.
• Trabalhar com sessão e ver suas funções.

Capítulo 9 Header, Cookies, Sessões - 74
Cada execução de um script em PHP é isolada. Portanto, informações

utilizadas por um script que já encerrou não estão disponíveis para outro script.
Para administrar esta situação existem duas maneiras: ou guardar

informações no cliente (COOKIE) ou no servidor (SESSION). Informações no cliente
são vulneráveis e devem ser utilizadas com parcialidade, e para informações não
vitais.
Já a SESSION armazena no servidor, por padrão em arquivo, valores que o

programador definir. Este arquivo tem um tempo de vida: a partir do último acesso é
contado um tempo, e o próprio Apache trata de realizar a "limpeza" (garbage
collection)de arquivos antigos.
Este tempo de vida é determinado no arquivo de configuração do PHP

localizado em:
/etc/php5/apache2/php.ini
session.gc_maxlifetime = 1440
;(1440 seconds = 24 minutes)
9.2.1. Como utilizar sessões
As sessões são iniciadas com a função:
325 session_start();
Esta função inicia uma sessão entre o servidor e o navegador (e não o

computador!!) e armazena em arquivo (padrão do PHP, pode ser alterado para banco
de dados). Se a seção já existe, ele a carrega.
A partir deste momento, é possível armazenar valores na sessão utilizando o

array SuperGlobal $_SESSION:
Capítulo 9 Header, Cookies, Sessões - 75
327 $_SESSION['login'] = 'jorge';
Enquanto a sessão estiver ativa, qualquer script que a carregar pode fazer uso
desta variável.
Para eliminar uma sessão, primeiro é preciso carregá-la e em seguida

utilizamos uma função de "destruição":
329 session_destroy();
Por padrão o PHP utiliza um COOKIE para armazenar o ID da sessão. Se os

COOKIES estiverem desativados no navegador do cliente, as sessões não funcionam.
A apesar de ser utilizado em poucas soluções, é possível passar o ID da sessão
através da URL.
9.3. Laboratório
Fazendo uso da session, vamos fazer com que produtos sejam adicionados em
nossa sessão e consequentemente no carrinho de compras.
Para isso, vamos assumir que nosso array produtos recebera alguns produtos
como valores, para fins de testes do nosso carrinho.
Ex:
produtos(“iPod”,”iPad”,”iMac”,”Milestone”,”Android”,”ZendStudio”)
Capítulo 10 Introdução ao Banco de dados MySQL - 76
Capítulo 10
Introdução ao Banco de dados MySQL
10.1. Objetivos
• Levantar um SGDB MySQL em ambiente Linux funcional com o PHP.
• Estar apto a criar um database e efetuar query SQL.
• Administrar o database via terminal e interface web.

Um banco de dados é uma coleção de dados estruturados. Ele pode ser

qualquer coisa desde uma simples lista de compras a uma galeria de imagens ou a
grande quantidade de informação da sua rede corporativa. Para adicionar, acessar, e
processar dados armazenados em um banco de dados, é necessário um sistema de
gerenciamento de bancos de dados, no caso o Servidor MySQL.
O Servidor MySQL foi desenvolvido originalmente para lidar com bancos de

dados grandes de maneira muito mais rápida que trabalhar diretamente com os
arquivos. A conectividade, velocidade, e segurança fazem com que o MySQL seja
altamente adaptável para acessar bancos de dados na Internet.
10.3. Instalando o MySQL
Para instalar o MySQL, use o aptitude.
# aptitude install mysql-server-5.0
Testando o banco
A sintaxe do cliente do banco é:
# mysql -u USER -p DATABASE
Exemplo:
mysql> show databases;

mysql> quit;
A configuração padrão do MySQL é muito permissiva, permite o acesso sem

senha.
10.3.1. Melhorando a segurança do banco
Existe um utilitário criado especialmente para resolver esse problema.

Observe a mensagem explícita que ele apresenta logo no início! Leia atentamente as
perguntas, e observe as falhas de segurança existentes antes deste procedimento.
# mysql_secure_installation
NOTE: RUNNING ALL PARTS OF THIS SCRIPT IS RECOMMENDED FOR

ALL MySQL
SERVERS IN PRODUCTION USE! PLEASE READ EACH STEP CAREFULLY!
In order to log into MySQL to secure it, we'll need the current
password for the root user. If you've just installed MySQL, and
you haven't set the root password yet, the password will be blank,
so you should just press enter here.
(SOLICITA SENHA ATUAL DO root, PRESSIONE ENTER)
Enter current password for root (enter for none):
OK, successfully used password, moving on...
Setting the root password ensures that nobody can log into the MySQL
root user without the proper authorisation.
(DEFINIR SENHA DO root? Y)
Set root password? [Y/n] Y
(NOVA SENHA)
New password:
(REPETIR NOVA SENHA)
Re-enter new password:
Password updated successfully!
Reloading privilege tables..
... Success!
By default, a MySQL installation has an anonymous user, allowing anyone
to log into MySQL without having to have a user account created for
them. This is intended only for testing, and to make the installation
go a bit smoother. You should remove them before moving into a
production environment.
(REMOVER USUÁRIOS ANÔNIMOS? Y)
Remove anonymous users? [Y/n] Y
... Success!
Normally, root should only be allowed to connect from 'localhost'. This
ensures that someone cannot guess at the root password from the network.
(DESABILITAR ACESSO REMOTO DO root? Y)
Disallow root login remotely? [Y/n] Y
... Success!
By default, MySQL comes with a database named 'test' that anyone can
access. This is also intended only for testing, and should be removed
before moving into a production environment.
(REMOVER BANCO DE DADOS test E ACESSO A ELE? Y)
Remove test database and access to it? [Y/n] Y
- Dropping test database...
ERROR 1008 (HY000) at line 1: Can't drop database 'test'; database doesn't
exist
... Failed! Not critical, keep moving...
- Removing privileges on test database...
... Success!
Reloading the privilege tables will ensure that all changes made so far
will take effect immediately.
(REINICIAR PRIVILÉGIOS? Y)
Reload privilege tables now? [Y/n] Y
... Success!
Cleaning up...
All done! If you've completed all of the above steps, your MySQL
installation should now be secure.
Thanks for using MySQL!
10.4. Instalando o suporte ao MySQL no PHP 5.
Utilizaremos novamente o aptitude.
aptitude install php5-mysql
Para que o suporte seja ativado, reinicie o Apache:
/etc/init.d/apache2 restart
10.4.1. Instalando uma interface web para

gerenciamento do MySQL
aptitude install phpmyadmin
10.5. Conceitos básicos de Banco de Dados
10.5.1. Tabelas
Todos os dados de um banco de dados relacional (BDR) são armazenados em

tabelas. Uma tabela é uma simples estrutura de linhas e colunas. Cada linha contém
um mesmo conjunto de colunas mas as linhas não seguem qualquer tipo de ordem.
Em um banco/base de dados podem existir uma ou centenas de tabelas. O limitador é
imposto exclusivamente pela ferramenta de software utilizada.
Tabela 12: Tabela Clientes
# CPF Nome1
1 152.487.265-42 João da Silva
2 687.481.682-88 Maria Joaquina
3 001.645.852.12 Agnaldo Souza
10.5.2. Registros (ou tupla)
Cada linha, formada por uma lista ordenada de colunas, representa um

registro (ou tupla). Os registros não precisam necessariamente conter dados em
todas as colunas, os seus valores podem ser nulos.
Formalmente falando, uma tupla é uma lista ordenada de valores, onde cada
valor é do domínio especificado pelo atributo definido no esquema de relação.
10.5.3. Colunas (Atributos ou Campos)
As colunas de uma tabela, são também chamadas de Atributos ou Campos.

Cada atributo/campo pertence a um domínio (tipo de campo), que define os valores
que podem ser associados aquele atributo.
10.5.4. Domínio (Tipos de Dados)
Os Dominios possuem características que definem os possíveis valores que

serão armazenado em um atributo de uma tupla. Por exemplo. Em um campo do tipo
numérico, serão somente armazenados números. Os sistemas de banco de dados
possuem regras para consistir os dados que são armazenados.
10.5.5. Chave
As tabelas relacionam-se umas as outras através de chaves. Uma chave é um

conjunto de um ou mais campos que determinam a unicidade de cada registro.
Por exemplo, se um banco (base) de dados tem como chave Código do Produto
+ ID Sistema, sempre que acontecer uma inserção de dados, o sistema de
gerenciamento de banco (base) de dados irá fazer uma consulta para identificar se o
registro não se encontra gravado na tabela. Caso exista um novo registro não será
criado, sendo que apenas a alteração do registro existente será possível. A unicidade
dos registros, determinada por sua chave, também é fundamental para a criação dos
índices.
Temos dois tipos de chaves:
• Chave Primária: (PK - Primary Key) é a chave que identifica cada registro
dando-lhe unicidade. A chave primária nunca se repetirá. A maioria dos
bancos também exige que ela seja NÃO NULA (NOT NULL) além de única.
• Chave Estrangeira: (FK - Foreign Key) é uma chave formada pela chave
primária de outra tabela e a chave de um campo da tabela que recebe o
relacionamento. Define um relacionamento entre as tabelas e pode ocorrer
repetidas vezes.
Observação 1: Geralmente Chaves Primárias são de apenas um campo, mas

podem ser compostas, ou seja, vários campos fazem parte dela. Isto determina que a
combinação entre os campos é que precisa ser única, e não os campos que
isoladamente a compõe.
Observação 2: Por questão de escopo, chaves estrangeiras não serão tratadas

neste curso.
10.5.6. Índices
O limite de registro em uma tabela é imposto exclusivamente pela ferramenta

de software utilizada. Sendo assim, para a recuperação dos dados é necessário a
existência de mecanismos que facilitem a consulta, proporcionando uma perfomance
aceitável para a mesma. Para isso, os sistemas de bancos de dados relacionais criam
índices das tabelas, sendo que esses índices são atualizados constantemente.
Caso o índice se corrompa por algum motivo, é possível que pesquisas possam
retornar resultados não desejados ou que inserções de chaves duplicadas aconteçam.
Nesse caso o banco de dados será corrompido também. Os sistemas de bancos
(bases) de dados possuem mecanismos de evitar que esses eventos ocorram como
também possibilitam a recuperação dos índices e consistência da tabela caso eles
ocorram.
10.5.7. Relacionamentos
Como o próprio nome sugere, um(a) BDR possui diversos relacionamentos

entre as tabelas existentes.
Um relacionamento é feito ligando-se um campo de uma tabela X com um

campo de uma tabela Y ou tabela estrangeira. Por exemplo, se pedidos (em uma
tabela) estão relacionados a um cliente (em outra tabela), o SGBD poderá bloquear a
remoção deste cliente enquanto ele possuir pedidos registrados. (Observação: no
caso de chaves primárias compostas, a relação se dará entre todos os campos desta
chave)
Existem alguns tipos de relacionamentos possíveis:
• Um para um (1 para 1)
• Um para muitos (1 para N)
• Muitos para muitos (N para N), que não pode ser implementado diretamente
no modelo relacional e tem que ser construído com uma tabela auxiliar.
10.6. A Linguagem SQL
A Linguagem SQL possui, basicamente, três grupos de comandos: DDL, DML

e DCL.
• DDL (Data Definition Language) - Linguagem de Definição de Dados

Permite a criação e alteração de objetos do banco de dados. Apesar de
baseado na SQL padrão, geralmente existem extensões para cada SGDB
utilizado. Os comandos clássicos são:
• CREATE - cria um objeto (uma tabela, por exemplo) dentro do banco de
dados (ou o próprio)
• DROP - apaga um objeto do banco de dados
• ALTER - altera um objeto do banco de dados
• DML (Data Manipulation Language) - Linguagem de Manipulação de
Dados
Permite a alteração dos dados dentro das tabelas. Os mais comuns são:
• SELECT (SELECIONAR) - para seleção de dados em um ou mais
registros
• INSERT (INSERIR) - para inclusão um registro

• UPDATE (ATUALIZAR) - para modificação valores de um registro
• DELETE (EXCLUIR) - para exclusão de um registro
• TRUNCATE (TRUNCAR) - exclui todos registros da tabela
• DCL (Data Control Language) - Linguagem de Controle de Dados
DCL controla os aspectos de autorização de dados e licenças de usuários
para controlar quem tem acesso para ver ou manipular dados dentro do
banco de dados.
Duas palavras-chaves da DCL:
• GRANT - autoriza ao usuário executar ou setar operações
• REVOKE - remove ou restringe a capacidade de um usuário de executar
operações
10.6.1. Alguns padrões de sintaxe para o SQL

do MySQL
Os comando SQL precisam terminar em ponto-e-vírgula ( ; ). Em algumas

situações como quando executados isoladamente ou na tela de comandos SQL é
possível ignorar o ponto-e-vírgula. Porém, em scripts isto é imprescindível. Para a
criação do hábito, todos os comandos aqui apresentados terão a terminação padrão.
Strings (textos) devem estar envolvidos em aspas simples/apóstrofo (') ou

aspas duplas(").
'Isto é um texto válido'

"Caixa d'água"
'Ops... Caixa d'água com erro de sintaxe'
Comentários (texto que não será executado) no SQL é criado colocando

entre /* e */. O MySQL também permite o uso de dois hífens
/*
Isto é um comentário
*/
-- Isto também é um comentário
10.6.2. Tipos de dados mais usados no MySQL
TEXTO
• CHAR(n) - String (texto) de tamanho fixo “n”. Limite 255 caracteres. Usado
quando o texto armazenado é sempre do mesmo tamanho, como em UF, CPF,
CEP
• VARCHAR(n) - String (texto) de tamanho variável até o máximo de “n”.
Limite 65.532k. Usado quando não se sabe o tamanho exato do texto a ser
armazenado, mas apenas seu tamanho máximo, como em Nome, Endereço,
etc.
• ENUM – Objeto de texto que permite definir uma lista dos valores válidos,
armazendo um deles.
• TINYTEXT, TEXT, MEDIUMTEXT, LONGTEXT – Campos texto variáveis,
podendo conter:
- TINYTEXT: of 255 (28 – 1) caracteres
- TEXT: 65,535 (216 – 1) caracteres
- MEDIUMTEXT: 16,777,215 (224 – 1) caracteres
- LONGTEXT: 4,294,967,295 or 4GB (232 – 1) caracteres
DATA
• DATE - Data (o formato armazenado é aaaa-mm-dd, ou 2000-12-31 para 31

de dezembro de 2000)
• TIME – Hora (00:00)
• YEAR – Ano (YYYY) 2K -> 70=1970 to 69=2069
• TIMESTAMP - Data e Hora automática (YYYY-MM-DD HH:MM:SS)
• DATETIME - Data e Hora Simultaneamente (YYYY-MM-DD HH:MM:SS )
NÚMEROS
• FLOAT(n,d) ou DOUBLE(n,d) - números com precisão decimal (n – total de

dígitos, d - casas decimais)
• DECIMAL(n,d) ou NUMERIC(n,d) – números com casas decimais
especificadas (n – total de dígitos, d - casas decimais)
• INTEGER - Dados numéricos inteiros. Possui subtipos conforme tamanho de
valores que aceita: TINYINT, SMALLINT, MEDIUMINT, INT, BIGINT
BINÁRIOS
BLOB - Este tipo de campo é o tipo indicado para armazenar Textos Grandes
“Memos”, Fotos, Gráficos, Ícones, isto é, aparentemente não tem um tipo de dado
que não possa ser armazenado no Campo Blob. Campos Blob´s não podem ser
indexados. Um tipo especial de BLOB é o TEXT, otimizado para texto.
Os campos tipo BLOB possuem subtipos conforme tamanho de valores que

aceita:
• TINYBLOB: of 255 (28 – 1) bytes

• BLOB: 65,535 (216 – 1) bytes
• MEDIUMBLOB: 16,777,215 (224 – 1) bytes
• LONGBLOB: 4,294,967,295 or 4GB (232 – 1) bytes
10.7. Criando Bancos e Tabelas
Criando e utilizando bancos:
CREATE DATABASE cadastro;
Para utilizar o banco tem-se o comando USE:
USE cadastro;
Para facilitar, vamos criar um tabela Pessoa, a seguinte estrutura:
Figura 10.1: Tabela Pessoa
10.7.1. Criando tabelas
A sintaxe básica para criação de tabelas é:
CREATE TABLE nometabela(

nomecampo1 TIPO OPCOES,
nomecampo4 TIPO OPCOES
);
Exemplo:
CREATE TABLE pessoa (

codigo INT NOT NULL AUTO_INCREMENT ,
nome VARCHAR(50) NOT NULL ,
email VARCHAR(50) NULL ,
sexo ENUM('M', 'F') NOT NULL DEFAULT 'M',
data_nascimento DATE NULL ,
escolaridade VARCHAR(30) NULL ,
data_cadastro DATE NULL ,
PRIMARY KEY (codigo)
)
Vamos conhecer as palavras chave utilizadas:
• NOT NULL: o campo não aceita valores nulos

• NULL: o campo aceita valores nulos

• DEFAULT: determina o valor padrão, caso não seja informado
• AUTO_INCREMENT: o campo será autonumerado (tem que ser NOT NULL e
chave primária)
• PRIMARY KEY (codigo): determina que o campo codigo será chaver primária
da tabela
Observação: o nome da tabela é case sensitive, ou seja, cadastro é diferente

de Cadastro que é diferente de CADASTRO.
10.7.2. Obtendo informações sobre o banco e

tabelas
Liste os bancos do servidor:
SHOW DATABASES;
Liste as tabelas do banco :
SHOW TABLES;
Obtenha detalhes da tabela :
DESCRIBE pessoa;
10.7.3. Inserindo registros (INSERT)
Para inserir dados em uma tabela utilizamos o comando INSERT. A sintaxe do

comando INSERT utiliza três blocos:
/* Definindo tabela */
INSERT INTO TABELA

/* Lista de campos separados por vírgula -
se não for informada, serão todos os campos */
( CAMPO1, CAMPO2, CAMPO3, CAMPO4 )
/* Lista de valores a serem inseridos, separados por vírgula */
VALUES ('valor1', 2, '2006-12-31', NULL);
Textos devem estar entre aspas simples ou duplas. As datas no formato aaaa-
mm-dd, também entre aspas simples ou duplas.
Valores NULL Os campos não informados receberão o valor nulo (NULL). Se o

campo foi criado com a opção NOT NULL, isto acarretará um erro. Se possuir a
opção valor padrão (DEFAULT), ao invés de NULL armazenará o valor DEFAULT
especificado. O campo autonumerado sem valor informado será incrementado
automaticamente.
Exemplo na tabela Pessoa:
INSERT INTO pessoa (

codigo ,
nome ,
email ,
sexo ,
data_nascimento ,
escolaridade ,
data_cadastro
)
VALUES (
NULL ,
'João da Silva',
'joao@silva.com.br',
'M',
'1970-10-14',
'Graduado em Administração',
'2009-01-13'
);
10.7.4. Atualizando registros (UPDATE)
Para atualizar dados em uma tabela utilizamos o comando UPDATE. A palavra

chave SET (definir) define os campos a serem alterados. A sintaxe do comando
UPDATE é quase sempre utilizada em conjunto com a cláusula WHERE, restringindo
os registros a serem atualizados. Isto nos gera 3 sintaxes básicas:
Alterando TODOS OS REGISTROS - sem cláusula WHERE:
UPDATE TABELA
/* Lista de campos a serem atualizados separados por vírgula */
SET
CAMPO1 = 'Novo Valor',
CAMPO2 = 45,
CAMPO3 = '2006-12-31';
Alterando APENAS UM REGISTRO ESPECÍFICO - cláusula WHERE filtrando a

chave primária da tabela:
UPDATE TABELA
SET
CAMPO2 = 45,
CAMPO3 = '2006-12-31'
/* Filtrando a chave primária */
WHERE
CAMPO_QUE_É_CHAVE_PRIMÁRIA = 4587
Alterando VÁRIOS REGISTROS - cláusula WHERE filtrando um ou mais

registros da tabela:
UPDATE TABELA
SET
CAMPO2 = 45,
CAMPO3 = '2006-12-31'
/* Filtrando vários registros */
WHERE
CAMPO1 = 'Valor qualquer'
AND CAMPO2 > 2;
UPDATE pessoa SET

nome = 'João da Silva e Souza',
data_nascimento = '1970-10-18'
WHERE
codigo = 1;
10.7.5. Excluindo registros (DELETE)
Para excluir registros em uma tabela utilizamos o comando DELETE. A sintaxe

do comando DELETE é quase sempre utilizada em conjunto com a cláusula WHERE,
restringindo os registros a serem atualizados. Funciona como um SELECT que apaga
os registros selecionados. Isto nos gera 3 sintaxes básicas, como no UPDATE:
Excluindo TODOS OS REGISTROS - sem cláusula WHERE:
DELETE FROM TABELA;
Excluindo APENAS UM REGISTRO ESPECÍFICO - cláusula WHERE filtrando a

chave primária da tabela:
DELETE FROM TABELA
/* Filtrando a chave primária */

WHERE
CAMPO_QUE_É_CHAVE_PRIMÁRIA = 4587
Filtrando VÁRIOS REGISTROS - cláusula WHERE filtrando um ou mais

registros da tabela:
DELETE FROM TABELA
/* Filtrando vários registros */
WHERE
CAMPO1 = 'Valor qualquer'
AND CAMPO2 > 2;
Observação: para limpar (excluir todos os registros de uma tabela),

reiniciando a autonumeração, usamos o comando TRUNCATE:
TRUNCATE TABELA;
DELETE FROM pessoa

WHERE codigo = 1;
10.7.6. Selecionando registros (SELECT)
Seleção é a operação mais utilizada em SQL. Veremos a seguir suas sintaxes

mais básicas, criando gradativamente seleções mais complexas. O comando chave é o
SELECT.
Sintaxe básica :
/* Selecionar */
SELECT
/* Lista de campos separados por vírgula */
CAMPO1, CAMPO2, CAMPO3
/* Da tabela */
FROM TABELA;
Para selecionar todos os campos, utilize o asterisco “*”.
A consulta abaixo seleciona todos registros:
SELECT * FROM TABELA;
Condições
A cláusula WHERE expressa a condição ONDE. É utilizada para:
• Filtrar os registros dada uma ou mais restrições

• Relacionar tabelas
Os campos que serão utilizados na filtragem não precisam ser exibidos no

resultado da consulta.
A clásula WHERE é usada SEMPRE após a lista de tabelas.
Filtrando dados
Para filtrar dados, é necessário usar operadores ou comparadores. Os

operadores básicos são:
Tabela 13:Tabela de Operadores de Comparação
Operador Descrição Exemplo

= igual a CAMPO1 = 'JORGE'
<> diferente de CAMPO1 <> 'JORGE'
> maior que CAMPO1 > CAMPO5
CAMPO1 > 10
< menor que CAMPO1 < CAMPO5
CAMPO1 < 10
>= maior ou igual que CAMPO1 >= CAMPO5
CAMPO1 >= 10
<= menor ou igual que CAMPO1 <= CAMPO5
CAMPO1 <= 10
LIKE como CAMPO1 LIKE '%JORGE%'
BETWEEN entre CAMPO1 BETWEEN
35 AND 50
IN em CAMPO1 IN (1,2,3,4,5)
NOT IN não está em CAMPO1 NOT IN (1,2,3,4,5)
Observação: o símbolo percentual (%) é um coringa para pesquisas em texto,

significa qualquer trecho de texto, inclusive nenhum.
Exemplo:
/* Selecionar todos os campos */

SELECT *
/* da tabela pessoa*/
FROM pessoa
/* onde */
WHERE
/*
o valor do campo NOME comece com 'josé'
e continue com qualquer coisa
(inclusive nada)
*/
NOME LIKE 'josé%';
O MySQL não faz distinção entre maiúsculas e minúsculas e caracteres

acentuados, então José e JOSE são iguais na comparação.
Para filtrar por mais de um campo, utilize as operadores lógicas:
Tabela 14:Tabela Operadores Lógicos
Operador Descrição
OR OU - Um filtro ou outro
AND E - Um filtro e outro filtro
Exemplo :
/* Selecionar todos os campos */

SELECT *
/* da tabela pessoa*/
FROM pessoa
/* onde */
WHERE
/* o valor do campo sexo seja igual a 'M' */
sexo = 'M'
/* OU o valor do campo data_nascimento seja maior que 01/01/1970 */
OR data_nascimento > '1970-01-01';
10.8. Administração de usuários
O controle de acesso ao banco é feito pelo comando GRANT. Com ele é

possível especificar quais ações, determinados usuários em certas localidades podem
executar sobre quais tabelas.
É muito importante salientar que o usuário para o no MySQL é um conjunto e

usuário X host de onde acessa, no formato usuario@host. Ou seja, podem existir dois
usuários com mesmo nome, desde que acessando de hosts diferentes.
No exemplo a seguir sobre é dado permissão sobre todo o banco de dados

livraria para o usuário dono acessando do host localhost o banco de dados livraria,
cuja senha é password.
GRANT SELECT, INSERT, UPDATE, DELETE

ON livraria.*
TO dono@localhost IDENTIFIED BY 'password';
Para ativar a criação do usuário é necessário recarregar a tabela de

privilégios:
FLUSH PRIVILEGES
Como é bastante comum a instalação de aplicativos e sistemas em PHP no

mesmo servidor em que está o MySQL, é corriqueiro criar usuários @localhost,
geralmente um para cada sistema instalado, evitando acessos indevidos.
De mesmo modo, o MySQL por padrão no Debian não permite acessos de

outros hosts. É preciso comentar uma configuração no arquivo /etc/mysql/my.cnf :
bind-address = 127.0.0.1
colocando um símbolo de sustenido (cerquilha) na frente, ficando assim:
#bind-address = 127.0.0.1
Para ativar, reinicia-se o serviço MySQL:
/etc/init.d/mysql restart
10.9. phpMyAdmin
O phpMyAdmin é uma ferramenta de administração do banco de dados

MySQL implementada em PHP, com interface web. É bastante amigável e muito útil
para aquele que não se sentem muito confortáveis com a SQL.
A quase totalidade dos provedores de hospedagem o utilizam como

ferramenta de administração.
Para acessar o phpMyAdmin informe a seguinte URL em seu navegador:
http://localhost/phpmyadmin
10.10. Construindo a base de dados do

website
Seguindo as orientações anteriores, vamos criar as tabelas no banco de dados

que servirão de base para o nosso website.
O exemplo será documentado na linha de comando, mas pode ser executado

no phpMyAdmin.
Criando a base e selecionando-a. No prompt do MySQL digite os comando a

seguir.
create database livraria;

use livraria;
Tabela usuario :
CREATE TABLE usuario (

login char(16) NOT NULL,

nome char(16) NOT NULL,
senha char(40) NOT NULL,
perfil enum('admin','gerente','despacho') NOT NULL,
PRIMARY KEY (login)
);
Tabela categoria :
CREATE TABLE categoria (

cat_id int(10) unsigned NOT NULL auto_increment,
descricao char(60) NOT NULL,
PRIMARY KEY (cat_id)
);
Tabela cliente :
CREATE TABLE cliente (

cliente_id int(10) unsigned NOT NULL auto_increment,
nome char(60) NOT NULL,
endereco char(80) NOT NULL,
cidade char(30) NOT NULL,
uf char(20) default NULL,
cep char(9) default NULL,
PRIMARY KEY (cliente_id)
);
Tabela livro :
CREATE TABLE livro (

isbn char(13) NOT NULL,
autor char(80) default NULL,

titulo char(100) default NULL,
cat_id int(10) unsigned default NULL,
preco float(10,2) NOT NULL,
sumario varchar(1000) default NULL,
PRIMARY KEY (isbn)
);
Tabela pedido:
CREATE TABLE pedido (

pedido_id int(10) unsigned NOT NULL auto_increment,
cliente_id int(10) unsigned NOT NULL,
total float(6,2) default NULL,
data date NOT NULL,
status char(10) default NULL,
entrega_nome char(60) NOT NULL,
entrega_endereco char(80) NOT NULL,
entrega_cidade char(30) NOT NULL,
entrega_uf char(20) default NULL,
entrega_cep char(9) default NULL,
forma_pagto enum('BOLETO','DEPÓSITO','CARTÃO') NOT NULL,
PRIMARY KEY (pedido_id)
);
Tabela pedidoitem :
CREATE TABLE pedidoitem (

peditem_id int(10) unsigned NOT NULL auto_increment,
pedido_id int(10) unsigned NOT NULL,
isbn char(13) NOT NULL,
preco float(10,2) NOT NULL,
quantidade tinyint(3) unsigned NOT NULL,
PRIMARY KEY (peditem_id)
);
10.10.1. Garantindo as permissões de acesso
grant select, insert, update, delete

on livraria.*
to livaria@localhost identified by 'password';
10.10.2. Populando o banco.
Para inserir os dados no nosso banco, vamos utilizar um script já pronto:

populate.sql :
mysql> exit;
mysql -u root -p < populate.sql
10.11. Conceitos Avançados
10.11.1. Transações
Transação é uma sequência de instruções que deverá ser lida como uma
instrução indivisível.
Uma transação deve ser atômica (tudo ou nada), ou seja, ou são todas
operações executadas ou todas são ignoradas.
Sua vantagem é a garantia de integridade. Em especial em operações em que

várias tabelas são afetadas simultaneamente. Um exemplo clássico é a inclusão de
uma Nota Fiscal (uma tabela) e seus itens (outra tabela): a nota fiscal é incluída
primeiro, os itens são vinculados a ela pela sua chave... mas se a gravação falhar
antes do último item, existe um inconsistência.
Se estiver toda operação embutida numa transação, isto não acontece.

Outro efeito da transação é isolar seu processamento do efeito de outras

transações.
O MySQL possui uma sintaxe própria em seus scripts para tratar transações.
Utiliza-se o comando START TRANSACTION antes de um conjunto de operações para
indicar que fazem parte de uma transação; e ao final, mediante uma condição, define-
se se será efetivada toda transação (COMMIT) ou abortada completamente
(ROLLBACK).
Observação: nem todos tipos de motor de banco de dados do MySQL

suportam transações (o padrão MySQL não suporta; normalmente é utilizado o
INNOBD para estas situações).
10.11.2. Prepared Statment
Prepared statment (declaração preparada) é um recurso de banco de

dados (presente também no MySQL) que permite definir uma consulta e executá-las
várias vezes com parâmetros diferentes.
Exemplo
SELECT * FROM pessoa WHERE id = ?
O ? (ponto de interrogação) é chamado de placeholder, que será substituído

por um valor enviado para complementação da consulta.
Vantagens:
• Podem ser utilizadas para aumentar a segurança, pois a lógica da consulta é

verificada em separado dos dados (parâmetros) – separação que ajuda
prevenir ataques de Ataques de SQL Injection;
• Em processamentos em lote (repetitivos, vários inserts ou selects) aumenta
do desempenho global, pois a consulta é "parseada" (testada em sua sintaxe)
apenas uma vez.
Desvantagens:
• Para uma única operação, gera mais requisições (uma para a preparação,
outra para a execução final).
10.12. Finalizando
Este capítulo foi uma breve introdução à linguagem SQL no MySQL. Há

muitos recursos úteis que não caberiam no escopo desta pequena introdução;
maiores informações podem ser obtidas no manual do MySQL:
• Português, referência da versão 4.1:

http://dev.mysql.com/doc/refman/4.1/pt/index.html
• Inglês, referência da versão 5.1:
http://dev.mysql.com/doc/refman/5.1/en/index.html
Capítulo 11 Integrando o PHP com MySQL - 102
Capítulo 11
Integrando o PHP com MySQL
11.1. Objetivos
• Usar métodos de acesso a banco que dão suporte a PHP O.O .
• Usar biblioteca de abstração de dados com suporte a diversos bancos de

dados(MySQL, PostgreSQL, etc).
Neste capítulo abordaremos duas formas básicas de conexão do PHP ao

MySQL : com a Extensão Melhorada MySQL (mysqli) e PHP Data Objects
(PDO).
11.2. Extensão Melhorada MySQL (mysqli)
O PHP 5 possui uma nova biblioteca para conectar-se ao MySQL, chamada

mysqli. A partir da versão 4, foi acrescentado um novo protocolo de conexão ao
MySQL que é muito mais rápido, e essa biblioteca permite tirar vantagem dele.
Ela permite uso na forma procedural (funções) ou orientada a objeto

(classes).
11.2.1. Conectando-se ao banco
Para conectar-se a um banco, utilizamos o comando a seguir.
Modo Orientado a Objeto:
330 // Conexão
331 $conexao = new mysqli('host', 'user', 'password', 'database');
332 if (mysqli_connect_errno()) {
333 echo 'Erro na conexão: ' . mysqli_connect_error();
334 exit;
335 }
336 // Comandos relacionadas à conexão...
337 $conexao->close();
Modo Procedural:
338 $conexao = mysqli_connect('localhost', 'user',

339 'password', 'database');
340 if (!$conexao) {
342 exit;
343 }
344 // Comandos relacionadas à conexão...
345 mysqli_close($conexao);
Vale a pena verificar o resultado da tentativa de conexão, porque o código

restante não funcionará sem uma conexão válida de banco de dados. Por isto foi
colocada uma condição testando a conexão, exibindo a mensagem e abortando o
script.
Apesar de podermos especificar em qual banco de dados pretendemos

trabalhar, é possível alterá-lo:

347 $conexao->select_db(newDatabase);
Modo Procedural:
348 $conexao = mysqli_connect('localhost', 'user', 'password',

'database');
349 mysqli_select_db('$conexao', 'newDatabase');
11.2.2. Executando consultas
As consultas são realizadas através de strings que contém declarações SQL.

Por exemplo:
350 $sql = "SELECT * FROM pessoa";

351 $resultado = $conexao->query($query);
352 // para liberar o resultado da memória após uso
353 $resultado->free();
Modo Procedural:

355 $resultado = $conexao($conexao, $sql);
356 // para liberar o resultado da memória após uso

357 mysql_free_result($resultado);
Observe o fato de que na string de consulta não é necessário colocar o ponto-

e-vírgula no final.
Podemos também consultar o número de linhas retornadas na última consulta:

360 $totalRegistros = $resultado->num_rows;
Modo Procedural:

363 $totalRegistros = mysqli_num_rows($resultado);
Observação: num_rows serve para SELECT. INSERT, DELETE e UPDATE geram

affected_rows.
11.2.3. Recuperando registros
Para extrair o resultado da pesquisa, usamos o comando:

366 // retornando em forma de objeto
367 $registro = $resultado->fetch_object();
368 // retornando em forma de array
369 $registro = $resultado->fetch_assoc();
370
371 Modo Procedural:


375 $registro = mysqli_fetch_object($resultado);
376 // retornando em forma de array
377 $registro = mysqli_fetch_assoc($resultado);
11.2.4. Passando por todos registros
A cada execução do comando anterior, obteremos mais uma linha retornada

pela busca, até que seja retornado nulo. Então é muito simples utilizarmos um laço
de repetição para passar por todos os campos de uma tabela.

379 while($registro = $resultado->fetch_object()) {
380 echo $registro->nome . ' - ' .$registro->email . '<br/>';
381 }
383 while($registro = $resultado->fetch_assoc()) {
384 echo $registro['nome'] . ' - ' .$registro['email'] . '<br/>';
385 }
Modo Procedural:

387 while($registro = mysqli_fetch_object($resultado)) {
388 echo $registro->nome . ' - ' .$registro->email . '<br/>';
389 }
391 while($registro = mysqli_fetch_assoc($resultado)) {
392 echo $registro['nome'] . ' - ' .$registro['email'] . '<br/>';
393 }
11.2.5. Exemplo completo com uso do Modo

Orientado a Objeto
394 <?php
395 // Arquivo conexao.php
396 // Dados para conexão
397 $servidor = 'localhost';
398 $banco = 'cadastro';
399 $usuario = 'cadastro';
400 $senha = 'password';
401
402 // Conexão
403 $conexao = new mysqli($servidor, $usuario, $senha,$banco);
404
405 // Testando se conexão é válida

406 if (mysqli_connect_errno()) {
408 exit;
409 }
410
411 // Selecionando todos registros

413 $result = $conexao->query($sql);
414
415 // Cabeçalho da tabela com total de registros

416 echo '
417 <table>
418 <caption>Total de registros: ' . $result->num_rows .
'</caption>
419 <tr>
420 <td>Código</td>
421 <td>Nome</td>
422 <td>Email</td>
423 </tr>
424 ';
425
426 // Passando por todos os registros e exibindo

427 while($registro = $result->fetch_object()) {
428 echo '
429 <tr>
430 <td>' . $registro->codigo . '</td>
431 <td>' . $registro->nome . '</td>
432 <td>' . $registro->email . '</td>
433 </tr>
434 ';
435 }
436
437 // Finalizando tabela

438 echo '
439 </table>
440 ';
441
442 // Liberando resultado da memória

443 $resultado->free();
444
445 // Encerrando conexao

446 $conexao->close();
447 ?>
Prepared Statment exigem dois passos: a preparação e a execução com

passagem dos parâmetros.
A forma de trabalho é um pouco diferente de uma consulta comum. É preciso:
• Preparar a declaração com o método prepare (orientado a objeto) ou a

função mysqli_prepare (procedural).
• Passar parâmetros com o método bind_param (orientado a objeto) ou a
função mysqli_stmt_bind_param (procedural).
• Executar a declaração com o método execute (orientado a objeto) ou a

função mysqli_stmt_execute (procedural).
• Definir os campos a serem recuperados em variávies com o método
bind_result (orientado a objeto) ou a função mysqli_stmt_bind_result
(procedural).
• Recuperar os registros (com o sem loop através do while) com o método
fetch (orientado a objeto) ou a função mysqli_stmt_fetch
É preciso passar os parâmetros informando seu tipo, conforme a tabela a

seguir:
Tabela 15: Caracteres de especificação de tipo
Caractere Descrição
i corresponde a uma variável de tipo inteiro
d corresponde a uma variável de tipo double
s corresponde a uma variável de tipo string
b corresponde a uma variável que contém
dados para um blob e enviará em pacotes
448 $sql = "SELECT nome, idade, cidade FROM pessoa

449 WHERE sexo = ? AND uf = ?";
450 $sexo = 'M';
451 $uf= 'DF';
452 if ($stmt = $conexao->prepare($sql)) {
453 // A ordem é importante!
454 // Passar a lista de tipos, seguida valores
455 // em forma ou não de variáveis
456 $stmt->bind_param('ss', $sexo, $uf);
457 $stmt->execute();
458 $stmt->bind_result($nome, $idade, $cidade);
459 while ($stmt->fetch()) {
460 echo "{$nome}, {$idade} anos, residente em {$cidade}\n";
461 }
462 $stmt->close();
463 }
Modo Procedural:

466 $sexo = 'M';
467 $uf= 'DF';
468 if ($stmt = mysqli_prepare($conexao, $sql)) {
469 // A ordem é importante!
470 // Passar a lista de tipos, seguida valores
471 // em forma ou não de variáveis
472 mysqli_stmt_bind_param($stmt, 'ss', $sexo, $uf);
473 mysqli_stmt_execute($stmt);
474 mysqli_stmt_bind_result($stmt, $nome, $idade, $cidade);
475 while (mysqli_stmt_fetch($stmt)) {
476 echo "{$nome}, {$idade} anos, residente em {$cidade}\n";
477 }
478 $stmt->close();
479 }
11.2.7. Transactions
A biblioteca mysqli trabalha em modo de AUTOCOMMIT, ou seja, cada

consulta é imediatamente executada.
Portanto, desabilitar o AUTOCOMMIT inicia uma transação, e todas as

consultas executadas após este comando só serão efetivadas com um COMMIT, ou
canceladas com um ROLLBACK.
Os exemplos explicados a seguir detalham o procedimento:

481 // Desabilita autocommit e inicia transação
482 $conexao->autocommit(FALSE);
483 $conexao->query("INSERT INTO pessoa (nome, idade, sexo)

484 VALUES ('João Silva', 25, 'M')");
485 $conexao->query("INSERT INTO pessoa (nome, idade, sexo)
486 VALUES ('Maria Silva', 21, 'F')");
487 /*
488 $conexao->commit retorna TRUE se todas as consultas forem
489 executadas com sucesso, ou FALSE se qualquer uma falhar
490 - neste caso, acontecerá o $conexao->rollback
491 if (!$conexao->commit()) {
492 $conexao->rollback();
493 }
Modo Procedural:
494 $conexao = mysqli_connect('localhost', 'user', 'password',

'database');
495 // Desabilita autocommit e inicia transação
496 mysqli_autocommit($conexao);
497 mysqli_query($conexao, "INSERT INTO pessoa (nome, idade, sexo)
499 mysqli_query($conexao, "INSERT INTO pessoa (nome, idade, sexo)
501 /*
502 mysqli_commit($conexao) retorna TRUE se todas as consultas
forem
503 executadas com sucesso, ou FALSE se qualquer uma falhar
504 - neste caso, acontecerá o mysqli_rollback($conexao)
505 if (!mysqli_commit($conexao)) {
506 mysqli_rollback($conexao);
507 }
11.3. PDO (PHP Data Objects)
O PHP 5.1 Possui nativamente a biblioteca de abstração de banco de dados

PDO (PHP Data Objects). Sua grande vantagem é permitir acesso a vários bancos de
dados suportados pelo PHP numa única classe.
11.3.1. Conectando-se ao banco
Para conectar-se a um banco, utilizamos o comando a seguir.
508 // Conexão utilizando DSN = Data Source Name

509 // Exemplo com MySQL
510 $dsn = 'mysql:host=localhost;dbname=banco';
511 // Exemplo com Postgres
512 $dsn = 'pgsql:host=localhost;dbname=banco';
513 $conexao = new PDO($dsn, 'user', 'password');
O PDO retorna excessões em forma de objeto (visto mais adiante neste curso).
Portanto, é possível utilizar a sintaxe try/catch para capturar e tratar erros.
514 try
515 {
518 $conexao->setAttribute(PDO::ATTR_EMULATE_PREPARES, TRUE);
519 $conexao->setAttribute(PDO::ATTR_ERRMODE,
PDO::ERRMODE_EXCEPTION);
520 }
521 catch (PDOException $e)
522 {
523 echo 'Erro: ' . $e->getMessage();
524 }
11.3.2. Executando consultas
Este é o método para SELECT. Apesar de retornar um OBJETO, utiliza-se de

recursos do PHP 5.1 (chamado SPL) para poder ser iterado com o foreach:

526 $resultados = $conexao->query($sql);
527
528 // Retornando em forma de array associativo

529 foreach ($resultados as $registro)
530 {
531 echo "{$registro['nome']}, {$registro['idade']}\n";
532 }
533 // ou
534 while ($registro = $resultados->fetch())
535 {
536 echo "{$registro['nome']}, {$registro['idade']}\n";
537 }
538
539 // Retornando em forma de objetos

540 $resultado->setFetchMode(PDO::FETCH_OBJ);
541 foreach ($resultado as $registro)
542 {
543 echo "{$registro->nome}, {$registro->idade}\n";
544 }
545 // ou
546 while ($registro = $resultado->fetchObject())
547 {
548 echo "{$registro->nome}, {$registro->idade}\n";
549 }
Podemos também consultar o número de linhas retornadas na última consulta:

551 $resultados = $conexao->query($sql);
552 $totalRegistros = $resultado->rowCount();
Observação: rowCount serve para SELECT. INSERT, DELETE e UPDATE geram

affected_rows.
11.3.3. Executando inserções, exclusões e

atualizações
Método para INSERT, DELETE e UPDATE.
553 $sql = "INSERT INTO pessoa (nome, idade, sexo)

554 VALUES ('João Silva', 25, 'M')";
555 $regAfetados = $conexao->exec($sql);
556 echo "Registros afetados: {$regAfetados}";
O PDO permite o uso tanto do placeholder (ponto de interrogação) quanto de

parâmetros nomeados (padrão :variavel).
O método bindParam pode opcionalmente o tipo e o tamanho da informação

para validá-lo. Os tipos podem ser:
Tabela 16: Lista de tipos para método bindParm
Constante Descrição
PDO::PARAM_BOOL Boolean
PDO::PARAM_NULL Null
PDO::PARAM_INT Integer
PDO::PARAM_STR Char, Varchar
(padrão)
PDO::PARAM_LOB Blob
Para recuperar os dados utiliza-se o método fetch, que recebe como

parâmetro uma constante que determina como ele vai retornar os dados, sendo os
mais comuns PDO::FETCH_ASSOC e PDO::FETCH_OBJ.
Sintaxe com placeholder:

559 $sexo = 'M';
560 $uf= 'DF';
561 $stmt = $conexao->prepare($sql);
562 $stmt->bindParam(1, $sexo, PDO::PARAM_INT);
563 $stmt->bindParam(2, $uf, PDO::PARAM_STR, 12);
564 $resultado = $stmt->execute();
565
566 // Passando pelos registros em modo ASSOC (Array)

567 while ($registro = $stmt->fetch(PDO::FETCH_ASSOC)) {
568 echo "{$registro['nome']}, {$registro->['idade']}\n";
569 }
570 // OU...
571 // Passando pelos registros em modo OBJECT
572 while ($registro = $stmt->fetch(PDO::FETCH_OBJ)) {
573 echo "{$registro->nome}, {$registro->'idade'}\n";
574 }
Sintaxe com parâmetros nomeados:

576 WHERE sexo = :sexo AND uf = :uf";
577 $sexo = 'M';
578 $uf= 'DF';
579 $stmt = $conexao->prepare($sql);
580 $stmt->bindParam(':sexo', $sexo, PDO::PARAM_INT);
581 $stmt->bindParam(':uf', $uf, PDO::PARAM_STR, 12);
582 $stmt->execute();
583
584 // Passando pelos registros em modo ASSOC (Array)

585 while ($registro = $stmt->fetch(PDO::FETCH_ASSOC)) {
586 echo "{$registro['nome']}, {$registro->['idade']}\n";
587 }
588 // OU...
589 // Passando pelos registros em modo OBJECT

590 while ($registro = $stmt->fetch(PDO::FETCH_OBJ)) {
591 echo "{$registro->nome}, {$registro->'idade'}\n";
592 }
11.3.5. Transactions
Uma transação no PDO funciona de modo semelhante à biblioteca MySQL.

Entretanto, como retorna exceção, pode-se utilizar a sintaxe try/catch para capturar
o erro. Possui também um método para iniciar a transação, como vê-se no exemplo
que segue.

595 $conexao->setAttribute(PDO::ATTR_EMULATE_PREPARES, TRUE);
596 $conexao->setAttribute(PDO::ATTR_ERRMODE,
PDO::ERRMODE_EXCEPTION);
597 $conexao->beginTransaction();
598 try
599 {
600 $conexao->exec("INSERT INTO pessoa (nome, idade, sexo)
602 $conexao->exec("INSERT INTO pessoa (nome, idade, sexo)
604 $conexao->commit();
605 }
606 catch (PDOException $e)
607 {
608 $conexao->rollBack();
609 echo 'Erro: ' . $e->getMessage();
610 }
Capítulo 12 Programação Orientada a Objetos - 117
Capítulo 12
Programação Orientada a Objetos
12.1. Objetivos
• Entender os diversos tipos de classes e suas aplicações.
• Implementar Herança e Interface, afim de ter um código que segue os padrões.
• Reunir as informações adquiridas para fechar o conceito de Design Patterns.

Neste capítulo será abordada uma breve revisão do Programação Orientada a

Objetos. Este paradigma propõe-se a resolver os problemas da programação criando
um abstração das coisas reais através de CLASSES. É o paradigma de programação
mais utilizado na atualidade, fazendo parte da maioria das linguagens modernas.
O PHP possui suporte à Orientação a Objeto, porém não completo.

Inicialmente o PHP era uma linguagem procedural e funcional, mas hoje a maioria
dos projetos de ponta software livre utilizando o PHP utilizam a Orientação a Objeto
como paradigma principal.
12.3. Conceitos
Na Orientação a objetos os problemas de programação são enxergados

através da abstração de indíviduos semelhantes em estruturas estáticas chamadas
CLASSES. Quando criamos um INSTÂNCIA desta CLASSE, representando um objeto
único, temos um OBJETO.
12.3.1. Classe
É uma abstração de um conjunto de indíviduos com características e ações

semelhantes, dentro de um contexto que interesse à resolução de um problema de
programação.
As classes são estruturas ESTÁTICAS que representam características e ações

semelhantes de um grupo de entidades. Em programação, podem representar
diversos tipos de entidades como componentes de negócio da aplicação, entidades da
interface, conexão, arquivo, tabelas de um banco de dados, um chat, um fórum, uma
página web, um formulário, etc.
12.3.2. Objeto
É a representação de indivíduo único que é construído com base nas

características e ações de uma classe. Uma INSTÂNCIA de uma classe.
Objetos são estruturas DINÂMICAS baseadas nas estruturas ESTÁTICAS das

CLASSES.
12.3.3. Atributos
Atributos são características fundamentais de uma classe ou de um conjunto

de objetos. Se temos a classe VEÍCULOS, podem ser atributos a COR, NÚMERO DE
RODAS, VELOCIDADE MÁXIMA, QUANTIDADE DE MARCHAS, entre outros.
12.3.4. Métodos
Métodos são açãos, atividades, procedimentos que uma classe pode executar
ou podemos executar com a classe. Se temos a classe VEÍCULOS, podem ser métodos
a ACELERAR, FREAR, VIRAR À DIREITA, VIRAR À ESQUERDA, ANDAR À FRENTE,
ANDAR DE RÉ, entre outros.
12.4. Uma classe simples: Pessoa
Para facilitar o entendimento, vamos começar definindo uma classe simples,

com alguns atributos e apenas um método.
Figura 12.1: Classe

Pessoa
Para utilizar a classe, é preciso criar uma organização em nosso diretório.

Abra um terminal como root e digite os comandos:
cd /var/www/curso
mkdir classes
cd classes
gedit Pessoa.class.php &
Interessante observar o padrão de nomeclatura de extensão do arquivo

utilizado: .class.php. Ele é bastante comum e inclusive sugerido por alguns editores
mais avançados.
Pode-se então criar a classe em PHP neste arquivo:
611 <?php
612 // Definição da classe
613 class Pessoa {
614
615 // Definição de variáveis

616 protected $codigo;
617 public $nome;
618 public $email;

619 public $data_nascimento;
620 public $escolaridade;
621 public $data_cadastro;
622
623 // Definição de método

624 public function enviarEmail ($assunto, $mensagem) {
625 // Enviando email com a função mail
626 mail($this->email, $assunto, $mensagem);
627 echo "<p>Email enviado com sucesso</p>";
628 }
629 }
630 ?>
Algumas sintaxes novas surgiram na definição da classe. Vamos conhecê-las:
• class: Para definição do nome da classe, que ficará englobada entre chaves
• private, public: Definem o encapsulamento, visto mais adiante
• function: Já conhecido, define aqui um método da classe
• $this->email: o $this é uma auto-referência, ou seja, a classe faz uma
referência a um atributo ou método dela mesma, no caso, o atributo email
Para utilizar a classe, vamos utilizar outro arquivo que vai importar o arquivo
da classe mediante o uso do comando include. este arquivo será salvo com o nome
/var/www/curso/testeClasse.php.
631 <?php
632 include('classes/Pessoa.class.php');
633 $joao = new Pessoa;
634 $joao->nome = "João";
635 $joao->email = "joao@teste.com.br";
636 $assunto = 'Teste de envio';
637 $mensagem = 'Olá, pessoa.';
638 echo "Enviando mensagem para " . $joao->nome;
639 $joao->enviarEmail($assunto, $mensagem);
640 ?>
Quando precisamos criar uma instância de uma classe numa variável,

utilizamos a palavra chave new. Então, os métodos e atributos da classe podem ser
referenciados pela variável utilizando-se o símbolo "->".
Neste exemplo, foi atribuído um valor ao atributo nome do objeto $joao, e

depois enviado um email através de seu método enviarEmail.
12.5. Herança
A capacidade de uma classe de absorver, herdar as características e ações de

outra classe. Assim, a classe que DA QUAL se herda é chamaada CLASSE PAI ou
SUPERCLASSE, e a classe que herda de uma outra classe são chamadas CLASSE
FILHA ou SUBCLASSE.
Qual a importância do uso da Herança? O reuso de código. A possibilidade de

não repetir determinado código em vários lugares, além da possibilidade de
correções e ajustes EM CASCATA. Além disso, evita-se o retrabalho, ou a correção de
um código em mais de um lugar. O trabalho de manutenção do cógido se torna muito
mais fácil.
A classe FILHA herda todas os atributos e métodos da classe PAI, e pode criar
outros ou, dentro de certas limitações, alterar os métodos da classe PAI.
Figura 12.2: Herança de classes

No exemplo, foram criadas duas classes derivadas: Professor e Aluno. Para

criá-las no PHP, vamos utilizar dois arquivos.
Primeiro, /var/www/curso/classes/Professor.class.php :
641 <?php
642 // Definição da classe EXTENDIDA = Herança
643 class Professor extends Pessoa {
644

646 public $turmas;
647 public $graduacao;
648 public $especializacao;
649 public $mestrado;
650 public $doutorado;
651
652 // Novo método

653 public function adicionarTurma ($turma) {
654 $this->turmas[] = $turma;
655 }
656 }
657 ?>
Segundo, /var/www/curso/classes/Aluno.class.php :
658 <?php
659 // Definição da classe EXTENDIDA = Herança
660 class Aluno extends Pessoa {
661

663 public $serie;
664 public $nomePai;
665 public $nomeMae;
666
667 // Novo método

668 public function alterarSerie ($serie) {
669 $this->serie = $serie;
670 }
671 }
672 ?>
É importante salientar que estas classes derivadas só podem ser utilizadas se

o arquivo da classe PAI, no caso Pessoa, for incluído antes no arquivo for utilizá-las.
Vamos testar criando o arquivo /var/www/curso/testeClasse2.php:
673 <?php
675 include('classes/Aluno.class.php');
676 $joao = new Aluno;
677 $joao->nome = "João";
678 $serie = 8;
679 $joao->alterarSerie($serie);
680
681 echo "O aluno " . $joao->nome . " está na "

682 . $joao->serie . "ª série";
683 ?>
12.6. Encapsulamento
Encapsulamento é a característica da classe de apresentar ao mundo seus

métodos de forma a proteger os atributos e métodos internos de uso incorreto da
classe, não sendo necessário saber como cada ação é implementada - o que interessa
é que se pode utilizar a classe com determinada finalidade. Através do
encapsulamento podemos utilizar a classe sem saber como é construída
internamente.
Existem três tipos de visibilidade utilizadas pelo encapsulamento para prover

a proteção dos métodos e atributos:
• Pública (public): O atributo ou método pode ser acessado pela classe que o
definiu, pelas classes derivadas desta classe (filhas) e pelas instâncias dessas
classes (objetos).
• Protegida (protected): O atributo ou método pode ser acessado pela classe
que o definiu, pelas classes derivadas desta classe (filhas) mas NÃO pelas
instâncias dessas classes (objetos).
• Privada (private): O atributo ou método pode ser acessado APENAS classe
que o definiu, e JAMAIS pelas classes derivadas desta classe (filhas) ou pelas
instâncias dessas classes (objetos).
Através das palavras chave public, protected e private na frente de um

atributo ou método determinamos sua visibilidade. Esta possibilidade só existe a
partir da versão 5 do PHP.
12.7. Métodos mágicos
Métodos mágicos são métodos especiais do PHP que realizam determinadas

tarefas específicas numa classe. Veremos a seguir alguns deles.
12.7.1. __construct
Executado no momento em que a classe é instanciada, é utilizado para:
• Executar um código que inicialize variáveis ou algo no ambiente para a

criação do objeto
• Receber valores obrigatórios na inicialização do objeto
Podemos alterar a classe Pessoa para que solicite alguns valores em sua
inicialização:
684 <?php
685 class Pessoa {
686
687 protected $codigo;

688 public $nome;
689 public $email;
690 public $data_nascimento;
691 public $escolaridade;
692 public $data_cadastro;
693
694 // Método Construtor

695 public function __construct ($codigo, $nome, $email=null) {
696 $this->codigo = $codigo;
697 $this->nome= $nome;
698 $this->email = $email;
699 }
700
701 // Definição de método

702 public function enviarEmail ($assunto, $mensagem) {
703 // Enviando email com a função mail
704 mail($this->email, $assunto, $mensagem);
705 echo "<p>Email enviado com sucesso</p>";
706 }
707 }
708 ?>
Agora a classe Pessoa só pode ser instanciada se ao menos dois parâmetros

forem indicados, mas também pode ser instanciada se forem passados os três
parâmetros. Teste criando o arquivo /var/www/curso/testeClasse3.php:
709 <?php
711 $joao= new Pessoa(1, "João");
712 $miguel = new Pessoa(2, "Miguel", "miguel@teste.com.br");
713 echo "Primeira pessoa: " . $joao->nome . "<br/>";
714 echo "A pessoa " . $miguel->nome . " tem o email " . $miguel-
>email;
715 ?>
Não é possível acessar diretamente o atributo $joao->codigo ou

$miguel->codigo porque o atributo é PROTEGIDO (protected).
O construtor também é herdado pelas classes filhas como outro metódo

comum.
12.7.2. __destruct
O método mágico __destruct é executado quando o objeto é retirado da

memória. Isto acontece em duas situações.
• Quando a variável é explicitamente retirada da memória, o que é feito com a

função unset()
• Quando o script termina sua execução
Este método é utilizado para forçar o salvamento de um registro antes de

retirá-lo da memória (forçadamente), eliminar arquivos temporários criados pelo
objeto, atualizar contadores de objetos abertos, entre outras utilidades.
12.7.3. __get e __set
Getters e Setters são termos comuns para métodos que recuperam (get) e
definem (set) valores para um atributo da classe. É extremamente comum que
atributos sejam protegidos ou privados, e sejam alterados unicamente através de
métodos para garantir sua integridade.
Mas nem todos os métodos necessitam desta proteção. Entretanto, é muito

comum mesmo assim implementar os métodos getAtributo e setAtributo para
manter a padronização.
Porém... e se forem muitos atributos com comportamento padrão? Então

podem ser "magicamente" acessados com os métodos __get e __set.
Sem o uso dos getters automáticos no arquivo de exemplo

/var/www/curso/getset.php:
716 <?php
717 class Pessoa {
718 protected $id;
719 protected $nome;
720 protected $idade;
721 protected $sexo;
722 }
723
724 $joao = new Pessoa();

725 $joao->id = 1;
726 echo $joao->id;
727 ?>
Isto gera o erro:
Fatal error: Cannot access protected property Pessoa::$id in

/var/www/curso/getset.php on line 10
Pode-se criar um getter e um setter no padrão comum para solucionar esta

situação:
728 <?php
729 class Pessoa {
730 protected $id;
734
735 public function setId($valor) {

736 // convertendo forçadamente a ser um inteiro
737 $this->id = (int) $valor;
738 }
739
740 public function getId() {

741 return $this->id;
742 }
743
744 }
745

747 $joao->setId(1);
748 echo $joao->getId();
749 ?>
Mas, de forma precisa e automática pode-se utilizar os métodos mágicos:
750 <?php
751 class Pessoa {
752 protected $id;
756
757 public function setId($valor) {

758 // convertendo forçadamente a ser um inteiro
759 $this->id = (int) $valor;
760 }
761
762 public function getId() {

763 return $this->id;
764 }
765
766 public function __set($name, $value) {

767 $this->$name = $value;
768 }
769 public function __get($name) {
770 return $this->$name;
771 }
772 }
773

775 $joao->setId(1);
776 $joao->nome = 'João';
777 $joao->idade = 35;
778 $joao->sexo = 'Masculino';
779 echo $joao->getId() . " - " . $joao->nome;
780 ?>
E então todos os atributos estão disponíveis através dos métodos mágicos. Isto
não impede que se tenha métodos personalizados.
12.7.4. __toString
Quando um objeto é tratado como uma string (como num comando echo) ele
gera um erro. Entretanto, é possível determinar como será a saída de um objeto
nesta situação implementando o método mágico __toString.
Veja o exemplo sem uso do __toString com o arquivo

/var/www/curso/toString.php:
781 <?php
782 class meuErro {
783 public $saida = 'Meu erro';
784 }
785 $erro = new meuErro;
786 echo $erro;
787 ?>
Ao rodar este script recebe-se o erro:
Catchable fatal error: Method meuErro::__toString() must return a string

value in /var/www/curso/toString.php on line 6
Agora "corrigindo" com a implementação do método mágico __toString;
788 <?php
789 class meuErro {
790 public $saida = 'Meu erro';
791
792 public function __toString() {

793 return $this->meuErro;
794 }
795 }
796 $erro = new meuErro;
797 echo $erro;
798 ?>
12.7.5. Outros métodos mágicos
O PHP possui outros métodos mágicos, com diversas funcionalidades. São

eles: __construct, __destruct, __call, __callStatic, __get, __set, __isset, __unset, __sleep,
__wakeup, __toString, __set_state e __clone.
Uma lista completa dos métodos mágicos e suas funcionalidades é encontrada

no manual do PHP:
http://www.php.net/manual/pt_BR/language.oop5.magic.php
12.8. Classes Abstratas
Classes abstratas não podem ser instanciadas diretamente. Servem apenas de

base para classes filhas.
No exemplo da classe PAI Pessoa, esta poderia ser definida como ABSTRATA,
apenas servindo de base para as classes Professor e Aluno.
No PHP isto é feito com uso da palavra chave abstract:
799 <?php
800 abstract class Pessoa {
801 // (...)
802 ?>
12.9. Interfaces e Métodos Abstratos
12.9.1. Interfaces
Interfaces são estruturas que defininem que métodos e atributos precisa

implementar, sem definir como esses métodos serão tratados.
As classes então implementam a interface, e uma classe pode implementar

mais de uma interface.
Se executado a seguinte declaração num arquivo de teste

/var/www/curso/interface.php:
803 <?php
804 interface iPessoa {
805 public function enviarEmail() ;
806 }
807 class Aluno implements iPessoa {
808
809 }
810 ?>
Acontecerá o seguinte erro:
Fatal error: Class Aluno contains 1 abstract method and must therefore be
declared abstract or implement the remaining methods
(iPessoa::enviarEmail) in /var/www/curso/interface.php on line 7
Ou seja, é obrigatório implementar o método enviarEmail:
811 <?php
812 interface iPessoa {
813 public function enviarEmail() ;
814 }

816 public function enviarEmail() {
817 echo 'Envia Email';
818 }
819 }
12.9.2. Métodos Abstratos
Métodos abstratos são definidos em classes abstratas. Eles obrigam que as

classes filhas implementem este método, então geralmente só possuem uma chamada
sem nenhum código implementado.
Comportam-se de modo análogo às interfaces, mas apenas para um método.

São comumentes criados em classes abstratas para forçar suas filhas a
implementarem determinado método com os parâmetros definidos na classe pai.
Exemplo:
820 <?php
822 abstract public function enviarEmail($email);
823 }
12.10. Atributos Estáticos
Atributos estáticos tem uma função semelhante à uso em funções. O atributo

definido como estático terá seu valor compartilhado pelas diversas instâncias de uma
classe. Isto tem várias utilidades, como compartilhar conexões ou manter um
contador de instâncias.
Exercite criando e executando o arquivo /var/www/curso/static1.php:
824 class Contador {

825
826 private static $cont = 0;

827
828 public function __construct() {

829 self::$cont++;
830 }
831
832 public function __destruct() {

833 self::$cont--;
834 }
835
836 public function getCont() {

837 return self::$cont;
838 }
839 }
840
841 $obj1 = new Contador;

842 echo $obj1->getCont() . " - ";
843

846

849
850 unset($obj2);
Com o uso de um construtor e um destrutor foi implementado um contador de

objetos. Na primeira instância o contador é definido em 1, e a cada nova
incrementado em 1. Ao ser destruído um objeto, o contador é diminuído em 1.
12.11. Métodos Estáticos
Os métodos estáticos podem ser acessados sem a necessidade de instância da

classe. Isto é especialmente útil para classes acessórias, que servem como biblioteca
de funções de uma área afim.
Vamos testar criando o arquivo /var/www/curso/classes/Data.class.php:
852 <?php
853 class Data {
854
855 // Recebe a data em formato dd/mm/aaaa e formata em aaaa-mm-dd

856 static function formatarBanco ($data){
857 $dataTemp = explode('/',$data);
858 return $dataTemp[2] . '-' . $dataTemp[1] . '-' . $dataTemp[0];
859 }
860
861 // Recebe a data em formato aaaa-mm-dd e formata em dd/mm/aaaa

862 static function formatarTela ($data){
863 $dataTemp = explode('-',$data);
864 return $dataTemp[2] . '/' . $dataTemp[1] . '/' . $dataTemp[0];
865 }
866 }
867 ?>
Para acessar métodos estáticos utilizamos o operador de resolução de escopo

(::).
Crie o arquivo /var/www/curso/testeClasse3.php para testar o seu uso:
868 <?php
869 include('classes/Data.class.php');
870
871 $dataBanco = '2009-01-13';

872 echo 'Convertendo data do banco ' . $dataBanco .
873 ' para data de exibição ' . Data::formatarTela ($dataBanco) ;
874
875 echo '<br/>';

876
877 $dataTela = '31/12/2008';

878 echo 'Convertendo data de exibição ' . $dataTela .
879 ' para data do banco ' . Data::formatarBanco ($dataTela) ;
880
881 ?>
Alguns cuidados devem ser tomados para evitar erros no uso de métodos
estáticos. Primeiro: métodos estáticos são utilizados sem instância da classe, então
não podem utilizar a chamada $this. Em seu lugar, utilizam o self:: .
Se os valores não terão alteração, então utiliza-se CONSTANTES, que são

especificadas com a palavra chave const e possuem obrigatoriamente valor definido.
Vamos alterar a classe Data.class.php para possuir um padrão de separadores

de data (que poderiam ser substituídos em caso de mudança de língua):
882 <?php
883 Class Data {
884 const SEPARADOR_BANCO = '-';
885 const SEPARADOR_TELA = '/';
886
887 // Recebe a data em formato dd/mm/aaaa e formata em aaaa-mm-dd

888 static function formatarBanco ($data){
889 $dataTemp = explode(self::SEPARADOR_TELA,$data);
890 return $dataTemp[2] . '-' . $dataTemp[1] . '-' . $dataTemp[0];
891 }
892
893 // Recebe a data em formato aaaa-mm-dd e formata em dd/mm/aaaa

894 static function formatarTela ($data){
895 $dataTemp = explode(self::SEPARADOR_BANCO,$data);
896 return $dataTemp[2] . '/' . $dataTemp[1] . '/' . $dataTemp[0];
897 }
898 }
899 ?>
A classe Data foi alterada definindo em constantes os separadores "padrão" a

serem utilizados. O exemplo testeClasse3.php será executado sem nenhuma
alteração.
12.12. A mensagem de erro mais louca do PHP
Um erro na utilização do operador de resolução de escopo (::), colocando-o em

local não esperado gera a seguinte mensagem de erro pelo PHP:
Parse error: syntax error, unexpected T_PAAMAYIM_NEKUDOTAYIM,

expecting ',' or ';' in /var/www/curso/eOMeuErroFoiCrer.php on line 12
Esta louca mensagem tem explicação no manual do PHP:
Paamayim Nekudotayim pode parecer, de inicio, uma escolha estranha

para um dois pontos duplo. No entanto, na hora de escrever o Engine da
Zend 0.5 (que provia o PHP3), foi o que a equipe da Zend decidiu.
Realmente significa dois pontos duplo - em Hebreu!
Capítulo 13 Streams - 138
Capítulo 13
Streams
13.1. Objetivo
• Manipular arquivos e suas informações.
A camada Streams do PHP é uma abstração para acesso a arquivos. Stream é

um termo genérico que refere-se a um vasto número de recursos, inclusive conexões
de rede. O PHP possui a possibilidade de ler streams de rede, assim como tornar-se
um serviço que recebe e devolve streams.
Neste capítulo veremos a manipulação de arquivos locais. Para manipular

arquivos no PHP temos três métodos básicos: com a função fopen(), com a função
file() e com a função file_get_contents();
13.3. Método fopen
Para abrir um arquivo em PHP utilizamos a função fopen(), cuja sintaxe é:
900 fopen(filename, mode);
Exemplos :
901 $texto = fopen ("/home/turing/file.txt", "r");

902 $gif = fopen ("/home/linux/file.gif", "wb");
Em Mode é especificado o modo de abertura do arquivo, ou seja, se o arquivo

deve ser aberto para leitura, escrita, etc. Os principais modos de abertura são:
• r Abre o arquivo no modo somente leitura e posiciona o ponteiro no

início do arquivo. O arquivo já precisa estar criado;
• r+ Abre o arquivo para leitura/escrita e posiciona o ponteiro no início do
arquivo;
• w Abre o arquivo no modo somente escrita. Se o arquivo já existir será
sobrescrito. Caso contrário um novo arquivo é criado;
• w+ Abre o arquivo para leitura/escrita. Se o arquivo já existir, será
sobrescrito. Caso contrário um novo arquivo é criado;
• a Abre o arquivo para anexar dados, posicionando o ponteiro no final do
arquivo. Se o arquivo não existir, será criado um novo;
• a+ Abre o arquivo para leitura/anexo, posicionando o ponteiro no final do
arquivo. Se o arquivo não existir será criado um novo.
13.3.1. Gravando informações em arquivos
Para adicionar dados em arquivos utiliza-se a função fwrite().
Exemplo :
903 $fp = fopen('dados.txt', 'a');

904 fwrite($fp, "Acrescentando ao arquivo!\n");
905 fclose($fp);
13.3.2. Lendo arquivos
Para leitura de um arquivo, utiliza-se a função fgets(), que lê um determinado

número de bytes do arquivo informado.
906 $fp = fopen('dados.txt', 'r');

907 // Lê os 20 primeiros caracteres do arquivo
908 $text = fgets($fp, 20);
909 fclose($fp);
Existe também a função fgetc() que permite ler, caractere a caractere, um

arquivo.
13.3.3. Fechando arquivos
Depois de utilizar o arquivo, é necessário que ele seja fechado.
Para tanto utilizamos a função fclose().
910 $fp = fopen('dados.txt', 'r');

911 fclose($fp);
13.4. Método file
Para finalidades mais práticas existe a função file(). Esta função lê um

arquivo completo e armazena cada linha do arquivo como um elemento de um array.
Depois de ler todo o conteúdo do arquivo, file() o fecha automaticamente, não
sendo necessária uma chamada a fclose().
912 <?php
913 $file_lines = file('dados.txt');

914 echo 'Primeira linha:' . $file_lines[0];
915 // Passando por todas linhas do arquivo.
916 foreach ($file_lines as $line) {
917 echo $line . '<br />';
918 }
919
920 // Para evitar problemas com caracteres de quebra de linha

(\n\r)
921 // é interessante utilizar a função rtrim para "limpar"
922 // à direita a string
923 foreach ($file_lines as $line) {
924 echo rtrim($line) . '<br />';
925 }
13.5. Método file_get_contents
Esta função lê um arquivo inteiro para uma variável. Muito útil para arquivos
HTML, por exemplo.
926 $file_html = file_get_contents('dados.html');

927 echo $file_html;
Capítulo 14 Tratamento de Erros e Exceções - 142
Capítulo 14
Tratamento de Erros e Exceções
14.1. Objetivos
• Lidar com os erros deixando o ambiente agradavel ao usuário.
• Tratar excessões para analise e correção dos erros do sistema.
14.2. Exibição de erros
Todas as linguagens de alto nível possuem algum modo de permitir ao

programador receber mensagens de erro e tratar como exibí-las ao usuário final.
Este processo é importante por três motivos:

• Exibir mensagens amigáveis ao usuário final
• Registrar erros para análise posterior
• Debugar em modo de desenvolvimento, com ou sem registro
O PHP, a partir de sua versão 5, possui duas formas de realizar o tratamento,

uma procedural e outra orientada a objeto.
O PHP 5 permite a configuração de quais tipos de erros serão exibidos.
Os erros são referenciados por constantes. Estas constantes estão

disponíveis em:
http://www.php.net/manual/pt_BR/errorfunc.constants.php
(Passe o link para os alunos, também está disponível nos links Depois da Aula)
Alguns erros são fatais, não podem ser capturados e impedem o uso do script.
Por exemplo, erros de sintaxe – entretanto, estes dificilmente chegam na aplicação
final.
Para o desenvolvimento, é sugerido o uso do E_ALL && E_STRICT.
• E_ALL: Todos erros e avisos, como suportado, exceto de nível E_STRICT no

PHP < 6.
• E_STRICT: Notícias em tempo de execução. Permite ao PHP sugerir
mudanças ao seu código as quais irão assegurar melhor interoperabilidade e
compatibilidade futura do seu código.
• Isto é feito com a diretiva error_reporting. Esta diretiva pode ser alterada
de duas formas:
• no arquivo php.ini
• em tempo de execução com a função error_reporting.
14.2.1. Função die
O PHP possui um comando que encerra o script, que é o exit. Ele permite
recebimento de um parâmetro, que é uma mensagem que será exibida ao encerrar o
script.
Historicamente, é mais comum o uso de seu “apelido”, o die. Diversos

comandos que exigem tratamento do tipo “fatal” são realizados com a expressão or
die('mensagem').
No exemplo do slide, a tentativa de conexão, quando não funcionar, vai gerar

o encerramento do script com a exibição do SQL que gerou o erro. Isto,
evidentemente é muito pouco elegante e dá informações excessivas ao usuário final
(aqui serve apenas como exemplo!).
Apesar de não ser uma forma muito elegante, é bastante utilizada,

especialmente em scripts antigos. Em scripts PHP para uso em linha de comando
podem ser um pouco mais adequados, mas em sistemas web seu uso deve ser evitado
em detrimento a um tratamento mais elaborado de erros, como visto a seguir.
Reforçando: como é um recurso que é encontrado em vários scripts, é

estudado aqui para o conhecimento dos alunos, mas seu uso não é incentivado.
14.2.2. Capturando e Gerando Erros
É possível “gerar” ou “disparar” um erro manualmente com a função

trigger_error. Ela gera um erro do tipo E_USER (ou, como segundo parâmetro,
qualquer de suas variantes E_USER_*).
Seu uso é normalmente em conjunto com uma função de tratamento

personalizado definida com a função set_error_handler. Esta função define uma
função personalizada que recebe automaticamente os erros gerados pelo sistema ou
então erros manuais gerados pela função trigger_error.
A função personalizada recebe automaticamente quatro parâmetros:

• errno = o número do erro, que corresponde ao código da constante E_*;

• errstr = o texto (string) com a mensagem de erro;
• errfile = o nome do arquivo onde ocorreu o erro;
• errline = a linha do arquivo onde ocorreu o erro.
Com estas informações é possível montar uma mensagem personalizada, ou

até registrar em arquivo, como veremos em seguida.
14.2.3. Registro de Erros (Log)
A função error_log permite realizar o “log” ou “registro” de um erro. Esta

função permite três métodos:
• 0 – syslog: registro no log padrão do sistema (syslog no Linux, por exemplo);

• 1 – email: envio de um email com a função mail do PHP;
• 3 – adicionar a arquivo: utilizando um arquivo personalizado para gravar o
registro.
• Da mesma forma que a função personalizada de tratamento de erro definida
pela função set_error_handler, também recebe quatro parâmetros:
• errno = o número do erro, que corresponde ao código da constante E_*;
• errstr = o texto (string) com a mensagem de erro;
• errfile = o nome do arquivo onde ocorreu o erro;
• errline = a linha do arquivo onde ocorreu o erro.
14.2.4. Configurando o php.ini
Algumas sugestões para ambiente de desenvolvimento (para produção, o

contrário).
As informações que seguem são da documentação do PHP em:
http://br.php.net/manual/pt_BR/errorfunc.configuration.php
display_errors = On
Isto determina quando os erros devem ser mostrados como parte da saída
ou se devem ser escondidos do usuário.
display_startup_errors = On
Mesmo quando display_errors esta em on, erros que aconteçam durante a
inicialização do PHP não são mostrados. É fortemente recomendado manter
display_startup_errors em off, exceto para procurar erros.
error_reporting = E_ALL | E_STRICT
Define o nível de erros para reportar. (já visto anteriormente).
log_errors = On
Indica se as mensagens de erro do script devem ficar no log de erros do
servidor ou em error_log. Esta opção depende do servidor.
track_errors = On
Se ativado, a última mensagem de erro sempre estará disponível na variável
$php_errormsg. (ou seja, é possível recuperar o último erro apenas com a
manipulação desta variável).
14.3. Tratamento de Exceções
Esta forma de tratamento de erros está disponível para as extensões

(bibliotecas) modernas do PHP 5 que são orientadas a objeto.
Ou seja:
• funções usam o ERROR REPORTING

• extensões modernas usam Exceptions
Exception é um modo de retornar um erro sob a forma de um objeto. É

possível inclusive extender a classe padrão do PHP e criar erros personalizados.
O uso mais simples e comum de Exceptions é a sua captura para tratamento

personalizado. Isto é feito através de uma sintaxe try...catch, onde um código é
executado num bloco try e se ele gerar uma Exception, esta é capturada e tratada no
bloco catch.
14.3.1. Métodos
Com dos métodos da classe Exception é possível personalizar o tratamento

de erros. A classe Exception possui mais informações que a mensagem de erro
padrão do PHP, por isto é mais útil para debug.
Além da mensagem, código do erro, arquivo e linha onde ocorreu o erro, o

classe também possui o TRACE, que mostra todos os arquivos que foram chamados
até o acontecimento do erro. Isto permite “rastrear” (realizar o “trace”) o erro, saber
de onde veio, todo caminho até ele – e isto é muito útil no debug.
getMessage – Obtém a mensagem da exceção

getCode – Obtém o código da exceção
getFile - Obtém o arquivo na qual a exceção ocorreu
getLine – Obtém a linha na qual a exceção ocorreu
getTrace – Obtém a stack trace como um array
getTraceAsString – Obtém a stack trace como uma string
Capítulo 15
Construindo uma classe de acesso a
dados
15.1. Objetivos
• Construir classes de abstração de dados.
• Manipular os dados abstraídos.
• Executar ações no banco de dados.

Capítulo 15 Construindo uma classe de acesso a dados - 149
Neste capítulo construiremos uma classe para facilitar nosso trabalho de

acesso às tabelas de nosso banco de dados.
Mas antes vamos criar uma nova estrutura de diretórios, já pensando em

nosso projeto. Como root execute:
# cd /var/www
# mkdir livraria
# cd livraria
# mkdir admin imagens intro site classes imagensLivros templates
Os diretórios criados terão a seguinte utilidade
• admin: área administrativa do website

• imagens: imagens gerais, ícones utilizados no website
• intro: área de testes iniciais
• site: o website em si
• classes: arquivos de classes
• imagensLivros: imagens dos livros armazenados
• templates: templates HTML de nosso site
Todas as classes serão criadas no diretório correspondente.
15.2. Porque uma classe Tabela?
No capítulo sobre o MySQL vimos que existem quatro operações muito

comuns em uma tabela: selecionar, atualizar, inserir e excluir. O problema é que
precisamos escrever um código personalizado para cada tabela do banco. Se forem 3
ou 4, tudo bem, mas e se forem 150? Para isso, criaremos uma classe abstrata
chamada Tabela, que servirá de base para classes de nosso banco de dados.
Esta não poderá ser utilizada diretamente, pois só será possível definindo
valores para seus atributos básicos.
15.3. Construindo a classe tabela
15.3.1. config.inc.php – arquivo de

configuração
Primeiro, vamos criar o arquivo de configuração de acesso ao banco de dados

e debug: /var/www/livraria/config.inc.php
928 <?php
929 /*
930 * Configurações de acesso ao banco de dados
931 */
932
933 $bdconfig['driver'] = 'mysql'; // Servidor de Banco

de Dados
934 $bdconfig['servidor'] = 'localhost'; // Servidor de Banco
de Dados
935 $bdconfig['usuario'] = 'livrariaUser'; // Usuário de acesso
936 $bdconfig['senha'] = '123456'; // Senha de acesso
937 $bdconfig['banco'] = 'livraria'; // Banco
938 $bdconfig['opcoes'] = array(PDO::MYSQL_ATTR_INIT_COMMAND =>
"SET NAMES utf8"); // Opções do Driver
939
940 // Ativa visualização de consultas SQL

941 $debugBanco = false;
942
943 // Variável de DEBUG

944 $DEBUG = array();
945
946 // Arquivo de log

947 $CONFIG['arquivo_log'] = '/var/www/livraria/livraria.log';
948
949 // Função autoload para carga automática de Classes

950 function __autoload($classe) {
951 include_once("classes/{$classe}.class.php");
952 }
As configurações de banco ficam na variável $bdconfig.
Opções de debug serão ativadas com as variáveis $debugBanco e $DEBUG,

sendo que esta última é inicializada com um array vazio.
Também é configurado um arquivo de log numa variável em array $CONFIG,

que pode ser utilizada futuramente para armazenar outras configurações do sistema.
Ao final, para não precisar de outro arquivo, foi definida a função __autoload,
para carga automática de classes. Desta forma, este é o único arquivo a ser incluído
para funcionamento básico do sistema.
É preciso, evidentemente, criar o banco de dados. Utilizaremos o conteúdo do

anexo Banco de Dados do Projeto.
15.3.2. Atributos da Classe Tabela
Agora faremos a construção por partes, para facilitar. Vamos criar o arquivo
/var/www/livraria/classes/Tabela.class.php e definir os atributos :
953 <?php
954 /*
955 Classe Abstrata Tabela
956 */
957 abstract class Tabela {
958
959 // conexao sera compartilhada entre todas as instâncias

960 private static $conexao;
961
962 // nome da tabela

963 protected $tabela;
964
965 // chave primária da tabela

966 protected $chavePrimaria;

967
968 // Array com lista de campos da tabela

969 protected $campos = array();
970
971 // Array com lista de campo=>legenda

972 protected $legendas = array();
973 }
Todo os atributos são protegidos, pois não queremos que o usuário final tenha
acesso aos valores, a não ser de modo controlado (getters e setters).
Entretanto, temos um atributo static, pois queremos que ele se mantenha

entre as instâncias da classe. Isto é importante, como veremos a seguir no
construtor, para que só tenhamos uma instância da conexão para todas os objetos
Tabela instanciados (através de suas classes filhas).
Alguns métodos só farão sentido quando formos utilizar a tabela, então, mais
adiante os compreenderemos.
15.3.3. Construtor
Agora criamos o construtor que tem a função conectar ao banco de dados.

Note que o atributo conexão é estático, para ser compartilhado entre todas as tabelas
abertas. Ele vai checar se não existe conexão aberta, e utilizando a palavra chave
global acessa a variável $bdconfig, que definimos no arquivo config.inc.php.
Observação: tenha cuidado de incluir os conteúdos adicionais que seguem

sempre ANTES da chave de fechamento final da classe, senão ele torna-se
uma função comum, não pertencente à classe!!!
974 /*
975 * Método construtor
976 * Se conexão não existir, cria, senão, nada a fazer
977 * (reutiliza a criada por outra instância da classe Tabela )

978 */
979 public function __construct() {
980
981 // Recuperando array com configuração de acesso

982 global $bdconfig;
983
984 // Testando se já está definido atributo estático

985 // $conexao. Se não estiver, então realiza a conexão
986 // (se já estiver... não precisa fazer de novo)
987 if (!isset(self::$conexao)) {
988
989 // Montando Data Source Name no formato:

990 // "mysql:host=localhost;dbname=banco";
991 $dsn =
"{$bdconfig['driver']}:host={$bdconfig['servidor']};dbname={$bdco
nfig['banco']}";
992
993 // Usando tratamento de exceção para capturar possível

erro
994 try
995 {
996 // Realizando conexão e armazenando em constante
997 self::$conexao = new PDO($dsn,
998 $bdconfig['usuario'],
999 $bdconfig['senha'],
1000 $bdconfig['opcoes']);
1001 } catch (PDOException $e) {
1002
1003 // Montando mensagem de erro

1004 $erro = '<h1>Erro:</h1><pre>' . $e->getMessage() .
"\n" .
1005 $e->getTraceAsString() . '</pre>' . "\n";
1006
1007 // Gravando erro no log

1008 error_log(date('Y-m-d H:i:s') . " - " . $erro, 3,
$GLOBALS['CONFIG']['arquivo_log']);
1009
1010 // Exibindo erro para o usuário e encerrando script

1011 die($erro);
1012 }
1013 }
1014
1015 } // function __construct
Aqui são utilizados vários conceitos já estudados. Vejamos:
• Linha 9: uso da palavra chave global para ter acesso a uma variável fora do
escopo da função/método, e recuperar as informações do arquivo de
configuração.
• Linha 14: uso do isset com negação (!) no teste lógico, para verificar se a
variável NÃO está definida, e uso do escopo self:: para acessar uma
variável estática da classe;
• Linha 18: montagem do Data Source Name para conexão com a biblioteca
PDO utilizando a variável de configuração importada para o escopo do
método com a palavra chave global;
• Linha 21: utilizando o tratamento de exceção com o try...catch;
• Linha 24: a conexão em si. Notar que é armazenada estaticamente, para
estar disponível para outras instâncias da classe – na segunda instância, este
bloco condicional não é executado, pois a variável já está definida – ver linha
14;
• Linhas 30 a 41: gerando uma mensagem de erro para o usuário final e
gravando no arquivo de log definido na configuração. O uso do método
getTraceString facilita o rastreio do erro.
15.3.4. Um getter automático
Vamos precisar recuperar alguns atributos da classe, mas eles são protegidos.
Então utiliza-se o método mágico __get. Note que não nos interessa setters, pois não
permitiremos alterações, apenas leitura dos atributos.
1016 /*
1017 * Método mágico __get
1018 * Para recuperar atributos

1019 * Note que não interessa implementar o __set!!
1020 */
1021 public function __get($var) {
1022
1023 return $this->$var;

1024
1025 } // function __get
15.3.5. Método para execução de consultas
O próximo método é o query, que centraliza a execução de consultas do

banco. Se o debug estiver ativo, exibe a consulta; isto é útil para termos certeza do
que está acontecendo. Se houver erro de sinxate, haverá log do erro e poderemos
definir se o erro será fatal ou não.
1026 /*
1027 * Método query
1028 * Executa uma consulta através da conexão estabelecida
1029 * Verifica se o debug está ativo
1030 * (variável $debugBanco=true em config.inc.php)
1031 * Retorna um objeto com o resultado da consulta
1032 */
1033 public function query($sql)
1034 {
1035 global $debugBanco;
1036
1037 // Se debug ativado, exibe SQL na tela

1038 if ($debugBanco) $GLOBALS['debugBanco'] .=
"<pre>$sql</pre><hr>";
1039

erro
1041 try
1042 {
1043 // Define o método pelo pelos primeiros caracteres =
SELECT ou select
1044 $type = substr($sql, 0, 6);
1045
1046 // Se for SELECT utiliza o método query do PDO

1047 if ($type == 'SELECT' || $type == 'select') {
1048
1049 $resultado = self::$conexao->query($sql);

1050
1051 // Senão utiliza o método exec do PDO

1052 } else {
1053
1054 $resultado = self::$conexao->exec($sql);

1055
1056 }
1057
1058 return $resultado;

1059
1060 } catch (PDOException $e) {

1061

"\n" .
1065

1068
1069 // Opção de erro fatal

1070 die($erro);
1071
1072 // Opção de erro silencioso

1073 // return false;
1074
1075 }
1076
1077 } // function query
• Linha 13: se o debug está ativo, então inclui no elemento ['debugBanco']

do array $DEBUG a string de SQL para posterior exibição; isto é feito com a
variável superglobal $GLOBALS;
• Linha 19: retirando os primeiro 6 caracteres da consulta para posterior
comparação com a função substr;
• Linha 22: comparando para saber se a consulta é SELECT. Isto é necessário
por que o PDO possui métodos diferentes para SELECT e para outros tipos
de consulta (como INSERT, DELETE e UPDATE);
• Linhas 24 e 29: executando a consulta com os métodos query ou exec,
conforme o tipo definido na condição da linha 22;
• Linha 33: retornando o resultado, que pode ser um objeto com um conjunto
de registros (no caso de select) ou a quantidade de linhas afetadas (no caso
de INSERT, DELETE e INSERT);
• No caso de erro na consulta, será gravado no log, mas o código permite que
o programador opte por dois comportamentos: erro fatal ou apenas log. Isto
não está parametrizado, ou seja, comenta-se um código e libera-se o outro. O
return false permite que seja usado este método como condição.
15.3.6. Listando (SELECT) registros
O método listar realiza selecão de registros. Ele pode opcionalmente solicitar

um filtro (cláusula WHERE), uma ordem (clásula ORDER BY) e um limitador de
registros retornados (cláusula LIMIT).
1078 /*
1079 * Método listar
1080 * Executa uma consulta na tabela, podendo:
1081 * - Recebe (opcionalmente) filtro em formato SQL
1082 * - Recebe (opcionalmente) ordem em formato SQL
1083 * - Recebe (opcionalmente) limite em formato MySQL
1084 * Retorna um objeto com o resultado da consulta
1085 */
1086 public function listar ($filtro=null, $ordem=null,
$limite=null){
1087
1088 // Monta consulta concatenando tabela

1089 $sql = "SELECT * FROM " . $this->tabela;
1090
1091 // Se foi enviado filtro, concatena filtro

1092 if (!is_null($filtro)) { $sql .= " WHERE $filtro";}
1093
1094 // Se foi enviado ordem, concatena ordem

1095 if (!is_null($ordem)){ $sql .= " ORDER BY $ordem";}
1096
1097 // Se foi enviado limite, concatena limite

1098 if (!is_null($limite)){ $sql .= " LIMIT $limite";}
1099
1100 // Retorna objeto com o resultado encontrado

1101 return $this->query($sql);
1102
1103 } // function listar
Este método utiliza três parâmetros opcionais. Realiza um SELECT na tabela

(através do atributo $this->tabela) .
Os parâmetros opcionais recebem as sintaxes do WHERE, ORDER BY e LIMIT.

Se forem informados (ou seja, diferentes de null).
Este método faz uso do método query, que já foi visto.
A sintaxe do LIMIT utilizada é o padrão do MySQL. Isto limita seu uso a

este banco. Para não tornar o exemplo extenso, não se fez um tratamento
desta situação.
O ideal seria testar com switch o driver de banco de dados utilizado (por
exemplo checando a variável $bdconfig['driver'] ou então com o método
self::$conexao->getAttribute(PDO::ATTR_DRIVER_NAME)) e realizar a
sintaxe adequada.
15.3.7. Recuperando um registro pela chave

primária
O método listarPorChave é extremamente útil: retorna um registro pela sua

chave primária.
1104 /*
1105 * Método listarPorChave
1106 * Executa uma consulta filtrando pela chave primária da
tabela
1107 * Recebe um valor que é um id de um registro
1108 * Retorna um objeto com o registro
1109 */
1110 public function listarPorChave ($chave){
1111
1112 // Executa consulta

1113 $resultado = $this->listar($this->chavePrimaria . " =
'$chave'");
1114
1115 // Retorna objeto com o registro encontrado

1116 return $resultado->fetchObject();
1117
1118 } // function listarPorChave
Ele é facilmente implementado, pois a classe possui o atributo chavePrimaria,

e então solicita o valor de uma chave e reutiliza o método listar para recuperar um
único registro. Para facilitar a utilização, já faz o "fecth" para retornar um único
registro em forma de objeto.
15.3.8. Excluindo um registro pela chave

primária
O método excluir também atua através de uma chave primária, o que

implementa uma segurança, evitando riscos de exclusão de muitos registros
simultaneamente.
1119 /*
1120 * Método excluir
1121 * Exclui um registro filtrando pela chave primária da
tabela
1122 * Recebe um id de um registro
1123 * Retorna um objeto com o resultado
1124 */
1125 public function excluir ($chave){
1126 // Monta consulta concatenando tabela, campo que é chave
primária e o valor enviado
1127 $sql = "DELETE FROM " . $this->tabela . "
1128 WHERE " . $this->chavePrimaria . " = '$chave'";
1129
1130 // Retorna objeto com o resultado encontrado

1132
1133 } // function excluir
O método excluir é quase autoexplicativo, também utiliza o mesmo conceito

do método listarPorChave, mas monta o SQL e executa através do método query.
15.3.9. Inserindo um registro
O método inserir é extremamente prático: recebe como entrada um array

contendo um par nome_do_campo => valor., como no exemplo:
1134 $dadosInserir = array(

1135 'nome' => 'Miguel Barbosa',
1136 'email' => 'miguel@teste.com.br',
1137 'data_nascimento' => '1983-10-07',
1138 );
É o que normalmente recebe-se num POSTs de formulários - por isto sua

praticidade.
1139 /*
1140 * Método inserir
1141 * Insere um registro
1142 * Recebe um array que contém itens no formato $campo =>
$valor
1143 * (um $_POST de formulário é uma boa opção)
1145 */
1146 public function inserir ($dados){
1147

erro
1149 try
1150 {
1151 // Testando se é um array, ou abortando;
1152 if(!is_array($dados)) {
1153 throw new Exception('Esperado um Array para Inserir
Registro');
1154 };
1155
1156 } catch (Exception $e) {

1157

"\n" .
1161

1164

1166 die($erro);
1167
1168 }
1169

1171 $sql = "INSERT INTO " . $this->tabela . " (";
1172
1173 // Varre array $dados e atribui $key => $value

1174 // com campo e valor
1175 foreach ($dados as $campo => $valor)
1176 {
1177
1178 // concatena o campo para montar a primeira parte do

INSERT
1179 $campos .= "$campo,";
1180
1181 // concatena o valor para montar a segunda parte do

INSERT
1182 $valores .= "'$valor',";
1183
1184 }
1185
1186 // Elimindo última vírgula e finalizando

1187 $sql .= substr($campos,0,-1) . ") VALUES (";
1188 $sql .= substr($valores,0,-1) . ")";

1189
1190 // Total de registros inseridos (0 ou 1)

1192
1193 } // function inserir
• Para evitar falha por tentativa de utilizar o foreach em uma string (pois tem
que receber um array) então capturou-se uma exceção com o try...catch
entre as linhas 10 e 30;
• Linha 10: teste lógico com o is_array negado (!) para verificar se a variável
enviada $dados é realmente um array, se não for dispara uma exceção;
• Linha 37: o "pulo do gato" do método, varre o array com dados e concatena
separadamente o nome do campo e o valor, para montar as duas partes do
INSERT;
• Linhas 49 e 50: com o substr retira-se a vírgula excedente na lista de
campos e valores;
Colocar todos valores entre aspas simples funciona no MySQL mas pode
causar erro em outros bancos de dados. Isto limita seu uso a este banco.
Para não tornar o exemplo extenso, não se fez um tratamento desta
situação.
O ideal seria testar com switch o driver de banco de dados utilizado (por
exemplo checando a variável $bdconfig['driver'] ou então com o método
self::$conexao->getAttribute(PDO::ATTR_DRIVER_NAME)) e realizar a
sintaxe adequada.
15.3.10. Atualizando um registro
De mesmo modo, o método atualizar também recebe um array com pares

nome_do_campo => valor, mas também a chave primária do registro a ser
atualizado. Outro método extremamente útil.
1194 /*
1195 * Método atualizar
1196 * Atualiza um registro filtrando pela chave primária
1197 * Recebe um array que contém itens no formato $campo =>

$valor
1198 * (um $_POST de formulário é uma boa opção)
1199 * Recebe um id de um registro
1201 */
1202 public function atualizar ($chave, $dados){
1203

erro
1205 try
1206 {
1208 if(!is_array($dados)) {
Registro');
1210 };
1211

1213

"\n" .
1217

1220

1222 die($erro);
1223
1224 }
1225

1227 $sql = "UPDATE " . $this->tabela. " SET ";
1228
1229 // Varre array $dados e atribui $key => $value

1230 // com campo e valor
1231 foreach ($dados as $campo => $valor)
1232 {
1233
1234 // concatena o campo e valor para montar atualização do

campo
1235 $sql .= "$campo = '$valor',";
1236
1237 }
1238
1239 // Eliminando última vírgula

1240 $sql = substr($sql,0,-1);
1241
1242 // Monta restante da condição concatenando campo que é

chave primária e o valor enviado
1243 $sql .= " WHERE " . $this->chavePrimaria . " = '$chave'";
1244
1245 // Total de registros atualizados (0 ou 1)

1247
1248 } // function atualizar
A lógica do método atualizar é semelhante ao do método inserir, apenas

trocando a sintaxe do SQL, e a recebendo também a chave primária, com a qual se
filtrará o registro como consta na linha 50.
15.4. Criando um CRUD
15.4.1. O que é um CRUD?
CRUD é o acrônimo da expressão em língua Inglesa Create, Retrieve,

Update e Delete, usada para definir quatro operações básicas usadas em
bancos de dados relacionais (RDBMS) ou em interface para usuários para
criação, consulta, atualização e destruição de dados.
Fonte: http://pt.wikipedia.org/wiki/CRUD
Boa parte do trabalho "braçal" numa aplicação é CRUD. Por isto, nossa classe
tabela foi criada para facilitar a geração de um CRUD
15.4.2. Criando as classes filhas
Esta parte é bastante mecânica, pois o trabalho "bruto" foi feito pela classe
Tabela. Se não formos utilizar legendas, a criação de classes filhas é muito simples,
bastando extender a classe Tabela e informar os atributos $tabela e
$chavePrimaria:
1249 <?php
1250 class Categoria extends Tabela {
1251 protected $tabela = 'categoria';
1252 protected $chavePrimaria = 'id';
1253 }
1254 ?>
Mas para um uso completo, incluindo a possibilidade de montar

automaticamente formulários e tabelas, é preciso ter a listagem dos campos e
legendas. Na sequência um exemplo com a tabela Categoria, criado no arquivo
/var/www/livraria/classes/Categoria.class.php (para ser automaticamente
carregada pela função __autoload):
1255 <?php
1256
1257 class Categoria extends Tabela {

1258
1259 protected $tabela = 'categoria';

1260 protected $chavePrimaria = 'id';
1261 protected $campos = array('id', 'descricao');
1262 protected $legendas = array(
1263 'id'=>'ID',
1264 'descricao'=>'Categoria'
1265 );
1266 }
15.4.3. Adicionando um método específico à

classe
Uma das características da Herança é que permite que uma classe filha tenha
novos métodos, utilizando-se das facilidade da classe pai.
Por exemplo, vamos criar um método que já traz as categorias em ordem

alfabética.
Inclua o método na classe Categoria:
1267 public function listarAlfabetico() {

1268
1269 return $this->listar(null,'descricao');

1270
1271 }
Que nada mais faz que executar o método listar com um parâmetro para para
ordenação.
15.4.4. Exemplo de uso
O conjunto de arquivos a seguir demonstra como utilizar as classes. Serão

gravados no diretório intro.
Eles criam uma interface chamada de CRUD: Create, Retrieve, Update e

Delete, ou seja, Criar, Recuperar, Atualizar e Excluir.
Já possuímos um arquivo de configuração com o __autoload, então, basta

incluí-lo para termos acesso a todas as classes.
A página inicial é a listagem das categorias em Arquivo

/var/www/livraria/intro/index.php, acessível através da URL :
http://localhost/livraria/intro
A partir dela é possível editar ou excluir um registro da tabela.
1272 <?php
1273 /*
1274 index.php
1275 Lista Categorias
1276 */
1277
1278 // Incluindo arquivo de configuração

1279 include_once('../config.inc.php');
1280
1281 // Criando nova instância da classe Categoria

1282 $tabCategoria = new Categoria;
1283
1284 // Listando categorias com o método listar

1285 $categorias = $tabCategoria->listar();
1286
1287 // Link para inserção de registro

1288 echo '<a href="inserirCategoria.php?id='.$categoria-
>id.'">Nova Categoria</a>';
1289
1290 // Iniciando tabela utilizando legendas da classe Categoria

1291 echo '<table>

1292 <tr>
1293 <th>Ação</th>
1294 <th>'. $tabCategoria->legendas['id'] .'</th>
1295 <th>'. $tabCategoria->legendas['descricao'] .'</th>
1296 </tr>
1297 ';
1298
1299 // Realizando laço com resultado

1300 // Enquanto a atribuição for verdadeira, executa código
1301 // método fetchObject recupera cada registro
1302 // em forma de objeto
1303 while ($categoria = $categorias->fetchObject()) {
1304
1305 // Montando a linha da tabela com link para edição e

exclusão
1306 echo '
1307 <tr>
1308 <td>
1309 <a href="editarCategoria.php?id='.$categoria-
>id.'">editar</a> -
1310 <a href="excluirCategoria.php?id='.$categoria-
>id.'">excluir</a>
1311 </td>
1312 <td>
1313 '.$categoria->id.'
1314 </td>
1315 <td>'.$categoria->descricao.'</td>
1316 </tr>
1317 ';
1318
1319 }
1320
1321 echo '</table>';

O arquivo de edição cria um formulário e carrega um registro baseado em sua

chave primária. O mesmo arquivo é destino do formulário, e então uma condição
testa se um campo do formulário foi enviado, quando então realiza o salvamento.
Este é o arquivo /var/www/livraria/intro/editarCategoria.php
1322 <?php
1323 /*
1324 editarCategoria.php
1325 Exibe registro para edição
1326 Realiza atualização em Banco
1327 */
1328

1331

1334
1335 // Verificando o método de envio (POST) e se existe uma

variável
1336 // Então considera o formulário enviado
1337 if ($_SERVER['REQUEST_METHOD'] == 'POST' &&
isset($_POST['id'])) {
1338
1339 // Se é envio do formulário,

1340 // então recupera via POST o id
1341 $id = $_POST['id'];
1342
1343 // Executando consulta de atualização

1344 if ($tabCategoria->atualizar($id, $_POST)) {
1345
1346 // Tudo bem, retornou um registro atualizado

1347 echo '<h2>Registro Salvo</h2>';
1348
1349 } else {
1350
1351 // Erro, ou houve falha no SQL

1352 // ou nada foi atualizado.
1353 echo "<h2>ERRO ao salvar Registro ou sem alteração</h2>";
1354
1355 }
1356
1357 } else {
1358
1359 // Se não é envio do formulário,

1360 // então recupera via GET o id
1361 $id = $_GET['id'];
1362
1363 }
1364
1365 // Link para retornar à listagem

1366 echo '<a href="index.php">Voltar</a>';
1367
1368 // Recuperando o registro com método listarPorChave

1369 $registro = $tabCategoria->listarPorChave($id);
1370
1371 // Iniciando formulário e enviado para o mesmo arquivo

1372 echo '
1373 <form action="editarCategoria.php" method="post" >
1374 ';
1375
1376 // Recuperando cada campo em loop

1377 // atribuindo às variáveis $campo e $valor
1378 // para montar dinamicamente formulário
1379 foreach ($registro as $campo => $valor)
1380 {
1381 // Recuperando legenda do campo
1382 echo $tabCategoria->legendas[$campo].': '.
1383 '<input type="text" name="'.$campo.'"'.
1384 ' value="'.$valor.'" /><br/>' . "\n";
1385 }
1386
1387 // Encerrando o formulário com um botão Salvar

1388 echo '
1389 <button type="submit">Salvar</button>
1390 </form>
1391 ';
O arquivo de inclusão é bastante parecido com o de edição, mas mostra um

formulário vazio. Com o seu envio, ele insere o registro no banco utilizando o recurso
da classe Tabela.
Este é o arquivo /var/www/livraria/intro/inserirCategoria.php
1392 <?php
1393 /*
1394 inserirCategoria.php
1395 Insere um novo registro em Banco
1396 */
1397

1400

1403

variável
1406 if ($_SERVER['REQUEST_METHOD'] == 'POST' &&
isset($_POST['descricao'])) {
1407
1408 // Executando consulta de inserção

1409 if ($tabCategoria->inserir($_POST)) {
1410
1411 // Tudo bem, retornou um registro incluído

1412 echo '<h2>Registro Salvo</h2><a
href="index.php">Voltar</a>';
1413
1414 } else {
1415

1417 // ou nada foi atualizado.
1418 echo "<h2>ERRO ao salvar Registro ou sem alteração</h2>";
1419
1420 }
1421
1422 } else {
1423
1424 ?>
1425 <form action="inserirCategoria.php" method="post" >
1426 Descrição: <input type="text" name="descricao" value=""
/><br/>
1427 <button type="submit">Salvar</button>
1428 </form>
1429
1430 <?php
1431 }
O arquivo de exclusão, para evitar acidentes, pede confirmação para excluir.

Então envia a solicitação para ele mesmo, com uma variável a mais de confirmação,
para só então realizar a exclusão.
Arquivo /var/www/livraria/intro/excluirCategoria.php ;
1432 <?php
1433 /*
1434 excluirCategoria.php
1435 Exclui um registro
1436 */
1437

1442
1443 // Verificando se foi enviado o id e confirmação (ok)

1444 if($_GET['id'] && $_GET['ok']) {
1445
1446 // Executando consulta de exclusão

1447 if ($tabCategoria->excluir($_GET['id'])) {
1448
1449 // Tudo bem, retornou um registro incluído

1450 echo '<h2>Categoria excluída com sucesso</h2><a
href="index.php">Voltar</a>';
1451
1452 } else {
1453

1455 // ou nada foi excluído.
1456 echo '<h2>ERRO!! Exclusão não efetuada</h2><a
href="index.php">Voltar </a>';
1457
1458 }
1459
1460 } else {
1461
1462 // Solicitação de exclusão, então vamos recuperar o registro

1463 $categoria = $tabCategoria->listarPorChave($_GET['id']);
1464
1465 // Montando links SIM / NÃO

1466 echo '
1467 <h2>Confirma exclusão da categoria?</h2>
1468 <h3>' . $categoria->id . ' - ' . $categoria->descricao .
'</h3>
1469 <a href="index.php">NÃO</a>
1470 <a href="excluirCategoria.php?id=' . $categoria-
>id .'&ok=1">SIM</a>
1471 ';
1472
1473 }
Capítulo 16
Separando HTML do PHP: Classe
Template
16.1. Objetivo
• Organizar o código a tal modo que o HTML não interfira no desenvolvimento

puro do PHP.
• Facilitar a interação do WebDesigner com o Programador.

Capítulo 16 Separando HTML do PHP: Classe Template - 176
Um costume aplicações PHP antigas é a de misturar o código HTML com o

PHP em praticamente todos os arquivos. Este método "funciona", mas gera uma
dificuldade muito grande, por dois motivos:
• Interação complicada entre webdesigner e programador;
• Manutenção complicada pelo tamanho dos arquivos.
Aplicações modernas procuram separar o conteúdo do HTML do código PHP,

ou o que é chamado de lógica de apresentação da lógica de controle. O Design
Pattern MVC é um dos padrões que utiliza esta lógica. Mas antes do advento do MVC
já utilizavam conjuntos de classes ou bibliotecas de funções para separar estas
partes, num método chamado de templating.
Algumas destas ferramentas criam até uma linguagem própria para gerenciar
a lógica de apresentação.
Neste curso vamos sugerir um sistema de templating simples, para exercitar o

conhecimento adquirido.
Sua lógica é ter um diretório (templates) com arquivos HTML que contém
códigos de partes "lógicas" da página (cabecalho, rodape, menu, etc). O conteúdo
dinâmico é incluído com uso de um padrão de substituição: "variáveis" em formato
%VARIAVEL%.
Para dar acesso e garantir segurança na inclusão destes arquivos, será

utilizada uma classe Template, que será composta de métodos estáticos e fará a
substituição das variáveis.
Existe uma limitação: algumas ações como loops e condições não podem ser
incluídas no template. Mas o objetivo não é criar um sistema perfeito e sim exercitar
nosso conhecimento adquirido.
16.3. Classe Template: pegando e exibindo

arquivos de templates
Para garantir que os arquivos só serão incluídos a partir do diretório da

aplicação, vamos definir no arquivo config.inc.php uma variável para evitar acesso
indevido:
1474 $CONFIG['raiz_site'] = '/var/www/460livraria/';
E então segue o arquivo classes/Template.class.php:
1475 <?php
1476 /*
1477 Classe Template
1478 Responsável pela parte visual do sistema
1479 */
1480
1481 class Template {

1482
1483 const TEMPLATE_DIR = 'templates/';

1484
1485 /*
1486 * pegarArquivo
1487 * Pega um arquivo e faz a substituição de seu parâmetros
1488 * Método estático e privado, só pode ser utilizado
1489 * por outros métodos
1490 */
1491 static private function pegarArquivo($arquivo,
$parametros=array()) {
1492
1493 // Recuperando array de configuração

1494 // contido no arquivo config.inc.php
1495 global $CONFIG;
1496
1497 // Usando exceção para tratar erro de inclusão de arquivo

1498 try {
1499
1500 // Montando o diretório até o arquivo

1501 $dir = $CONFIG['raiz_site'] . self::TEMPLATE_DIR;
1502
1503 // Proteção contra XSS

1504 // retirando \, /, ..
1505 $arquivo = str_replace(
1506 array('\\','/','..'),
1507 array('','',''),
1508 $arquivo
1509 );
1510
1511 // Se o arquivo não existe, então dispara exceção

1512 if (!file_exists($dir.$arquivo )) {
1513
1514 throw new Exception("Template $arquivo não

existe.");
1515
1516 } else {
1517
1518 // Recuperando o arquivo para uma variável

1519 $conteudo = file_get_contents($dir.$arquivo);
1520

1522 if(!is_array($parametros)) {
Registro');
1524 }
1525
1526 // Passando por parâmetros para criar

1527 // arrays para substituição
1528 foreach ($parametros as $chave => $valor) {
1529
1530 $de[] = $chave;

1531 $para[] = $valor;
1532
1533 }
1534
1535 // Substituindo parâmetros

1536 $conteudo = str_replace($de, $para, $conteudo);
1537
1538 // Retornando conteúdo

1539 return $conteudo;
1540
1541 }
1542

1544

"\n" .
1548

1551

1553 die($erro);
1554
1555 }
1556
1557 }
1558
1559
1560 /*
1561 * exibirArquivo
1562 * Pega e dá saída um arquivo
1563 */
1564 static public function exibirArquivo($arquivo,
$parametros=array()) {
1565
1566 echo self::pegarArquivo($arquivo, $parametros);

1567
1568 }
1569 }
O código está comentado, mas vale ressaltar cuidados para evitar invasões,
em especial a retirada de carateres que possam montar um caminho forçado a um
arquivo que não esteja no diretório templates. Outra questão é a substituição das
variáveis do template, que é o "pulo do gato" da classe.
O método pegarArquivo é privado para evitar acesso direto; numa abordagem

em que esta classe pudesse ser extendida, ele deveria ser protegido.
O método exibirArquivo é utilizado para dar saída imediata a um arquivo.

Será muito utilizado por outros métodos.
Para compreender o uso da classe, é preciso criar alguns templates e métodos

para acessá-los. Veremos na sequência alguns exemplos.
Observação: os métodos da classe Template serão passados um a um, mas

tenha cuidado de incluir este conteúdos adicionais que seguem sempre
ANTES da chave de fechamento final da classe, senão ele torna-se uma
função comum, não pertencente à classe!!!
16.4. Cabecalho do Site Administrativo
Arquivo de template (templates/cabecalhoAdmin.html). O cabeçalho terá

todas informações até o início do bloco de conteúdo, inclusive os elementos div que
organizam a página.

"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
1571 <html xmlns="http://www.w3.org/1999/xhtml">
1572
1573 <head>
1574 <title>Livraria do Tux</title>
1575 <link rel="stylesheet" type="text/css"

href="../style.css" />
1576 </head>
1577 <body>
1578
1579 <div id="pagina">

1580
1581 <div id="cabecalho">

1582
1583 <h1>Livraria do Tux - Administração</h1>

1584
1585 <div style="clear:both"></div>

1586
1587 </div>
O método correspondente na classe Template é muito simples:
1588 /*
1589 * cabecalhoAdmin
1590 */
1591 static public function gerarCabecalhoAdmin() {
1592
1593 $arquivo = 'cabecalhoAdmin.html';

1594 $parametros = array();
1595 self::exibirArquivo($arquivo, $parametros);
1596
1597 }
Como todos os métodos são estáticos, é utilizada a palavra chave self seguida
do separador de escopo (::).
16.5. Cabeçalho do site público
Template (templates/cabecalhoSite.html):

1599 <html xmlns="http://www.w3.org/1999/xhtml">
1600
1601 <head>
1602 <title>Livraria do Tux</title>
1603 <link rel="stylesheet" type="text/css"
href="../style.css" />
1604 </head>
1605 <body>
1606
1607 <div id="pagina">

1608
1609 <div id="cabecalho">

1610
1611 <div id="vercarrinho">

1612 Total de ítens = %CARRINHO_TOTAL_ITENS%<br />
1613 Valor total = R$ %CARRINHO_VALOR_TOTAL%<br />
1614 <a href="verCarrinho.php">ver carrinho</a>
1615 </div>
1616
1617 <h1>Livraria do Tux</h1>

1618

1620
1621 </div>
Neste template já temos duas variáveis a serem substituídas. Seu uso ficara
mais claro na construção do site público, mas seu método mostra como passar os
parâmetros para a exibição do template.
1622 /*
1623 * cabecalhoSite
1624 */
1625 static public function gerarCabecalhoSite() {
1626
1627 $arquivo = 'cabecalhoSite.html';

1628 $parametros = array(
1629 '%CARRINHO_TOTAL_ITENS
%'=>$_SESSION['itens'],
1630 '%CARRINHO_VALOR_TOTAL%'=>
1631 number_format($_SESSION['tota
l'],
1632 2 , ',', '.')
1633 );
1635
1636 }
16.6. Rodapé
Template (templates/rodape.html):

1638
1639 <div id="rodape">

1640 <h1>Todos os direitos reservados à Livraria do Tux</h1>
1641 </div>
1642
1643 </div>

1644 %DEBUG%
1645 </body>
1646 </html>
No rodapé será exibido DEBUG do sistema, que terá tudo que for enviado
para a variável $DEBUG definida inicialmente no arquivo config.inc.php e as
variáveis superglobais do PHP que são importantes para debugar o sistema.
Para que isto seja possível, veremos as alterações no arquivo config.inc.php:

1647 (...)
1648
1649 // Ativa debug

1650 $debug = true;
1651
1652 // Ativa visualização de consultas SQL

1653 $debugBanco = true;
1654
1655 // Variável de DEBUG

1656 $DEBUG = array();
1657
1658 (...)
Na classe Template então é criado o método correspondente ao arquivo

HTML:
1659 /*
1660 * rodape
1661 */
1662 static public function gerarRodape() {
1663
1664 $arquivo = 'rodape.html';

1666 '%DEBUG%'=>self::debug()
1667 );
1669
1670 }
16.7. Abstração de listagem de registros.
Este método não faz utilização de templates, mas faz uma pequena abstração
de uma listagem dos registros de uma tabela. Isto só é possível porque as
informações sobre os campos e legendas estão disponíveis através das classes
extendidas de cada tabela.
1671 /*
1672 * método gerarTabela
1673 * Recebe o objeto Tabela, um resultado
1674 * e opcionalmente uma lista de campos para listar
1675 */
1676 static function gerarTabela($tabObj, $tabResult,
$campos=false) {
1677
1678 // Iniciando a tabela

1679 $conteudo = '
1680 <table border="1">
1681 <tr>
1682 <th>Ações</th>
1683 ';
1684
1685 // Se foi enviado a variável $campo

1686 // então monta cabeçalho somente com estes
1687 if ($campos) {
1688
1689 // Varrendo a lista de campos enviada

1690 foreach ($campos as $campo) {
1691
1692 // Montando legendas com

1693 // as informações do objeto Tabela
1694 $conteudo .= '
1695 <th>' . $tabObj->legendas[$campo] . '</th>
1696 ';
1697 }
1698
1699 } else {
1700 // Não foi enviada lista de campos
1701 // Varrendo as legendas do objeto Tabela
1702 foreach ($tabObj->legendas as $campo) {
1703
1704 $conteudo .= '

1705 <th>' . $campo . '</th>
1706 ';
1707 }
1708
1709 }
1710
1711 // Finalizando linha de cabeçalho

1712 $conteudo .= '
1713 </tr>
1714 ';
1715
1716 // Passando por registros

1717 // Usando o fetch em padrão ASSOCIATIVO
1718 while ($tabLinha = $tabResult->fetch(PDO::FETCH_ASSOC)) {
1719 // Montando ações (editar e excluir)
1720 // baseado no objeto Tabela
1721 $conteudo .= '
1722 <tr>
1723 <td>
1724 <a href="' . $tabObj->tabela . 'Editar.php?' .
$tabObj->chavePrimaria . "=" . $tabLinha[$tabObj-
>chavePrimaria] . '">
1725 <img src="../imagens/editar.png" alt="editar"
title="Editar"></a>
1726 <a href="' . $tabObj->tabela . 'Excluir.php?' .
$tabObj->chavePrimaria . "=" . $tabLinha[$tabObj-
>chavePrimaria] . '">
1727 <img src="../imagens/excluir.png" alt="excluir"
title="Excluir"></a>
1728 </td>
1729 ';
1730
1731 // Se foi enviado a variável $campo

1732 // então monta cabeçalho somente com estes
1733 if ($campos) {
1734
1735 // Varrendo a lista de campos enviada

1736 foreach ($campos as $campo) {

1737
1738 // Montando valores com

1739 // as informações do array com campos
1740 $conteudo .= '
1741 <td>' . $tabLinha[$campo] . '</td>
1742 ';
1743 }
1744
1745 } else {
1746 // Não foi enviada lista de campos
1747 // Varrendo as campos do registro
1748 foreach ($tabLinha as $campo => $valor) {
1749
1750 // Montando valores

1751 $conteudo .= '
1752 <td>' . $valor. '</td>
1753 ';
1754 }
1755
1756 }
1757
1758 // Finalizando linha

1759 $conteudo .= '
1760 </tr>
1761 ';
1762 }
1763
1764 // Finalizando tabela

1765 $conteudo .= '
1766 </table>
1767 ';
1769 }
Para usar este método, segue o exemplo (que pode ser adaptado para
qualquer tabela):
1770 <?php
1772
1773 echo '<h2>Listar Categorias</h2>';

1774
1775 // Instância da classe

1776 $tabLivro = new Livro;
1777
1778 // Recuperando um grupo de registros

1779 $livros = $tabLivro->listar();
1780
1781 // Para escolher os campos a serem exibidos,

1782 // define-se um array com os campos
1783 $campos = array('id', 'isbn', 'autor', 'titulo');
1784
1785 // Gerando tabela de listagem automaticamente

1786 echo Template::gerarTabela($tabLivro, $livros);
1787
1788 // Gerando apenas com os campos escolhidos

1789 echo Template::gerarTabela($tabLivro, $livros, $campos);
16.8. Outros métodos
Os demais métodos não serão explicados detalhadamente, mas seus

comentários são bastante claros sobre sua utilidade.
Seu uso ficará mais evidente na montagem dos sites administrativo e público,
na continuidade do curso.
1790 /*
1791 * gerarMenuAdmin
1792 */
1793 static function gerarMenuAdmin () {
1794
1795 $conteudo = '

1796 <div id="menucategorias">
1797 <h3>' . $_SESSION['login'] . ' (' . $_SESSION['perfil'] .
')</h3>
1798 <h4>' . $_SESSION['nome'] . '</h4>
1799 <h4>' . $_SESSION['horalogin'] . '</h4>
1800 <h4><a href="logout.php">sair</a></h4>
1801
1802 <h1>Administração</h1>
1803 <ul>
1804 <li><a href="livroListar.php">Listar Livros</a></li>
1805 <li><a href="livroInserir.php">Inserir Livro</a></li>
1806 <li><a href="categoriaListar.php">Listar Categorias</a></li>
1807 <li><a href="categoriaInserir.php">Inserir
Categoria</a></li>
1808 <li><a href="pedidoListar.php">Listar Pedidos</a></li>
1809 </ul>
1810 ';
1811 if(Seguranca::temPerfil('admin')) {
1812
1813 $conteudo .= '

1814 <h1>Sistema</h1>
1815 <ul>
1816 <li><a href="usuarioListar.php">Listar Usuários</a></li>
1817 <li><a href="usuarioInserir.php">Inserir Usuário</a></li>
1818 </ul>
1819 ';
1820
1821 }
1822
1823 $conteudo .= '</div>';

1825
1826 }
1827
1828 /*
1829 * gerarListaCategorias
1830 */
1831 static function gerarListaCategorias () {
1832
1833 $tabCategoria = new Categoria();

1834 $categorias = $tabCategoria->listarAlfabetico();
1835
1836 $conteudo = '

1838 <h1>Categorias</h1>
1839 <ul>'."\n";
1840
1841 while ($cat = $categorias->fetchObject()) {

1842 $conteudo .= '
1843 <li>
1844 <a href="livrosCategoria.php?catid=' . $cat->id . '">
1845 ' . $cat->descricao . '
1846 </a>
1847 </li>'."\n";
1848 }
1849
1850 $conteudo .= '</ul>

1851 </div>';
1852

1854
1855 }
1856
1857 /*
1858 * adminGerar
1859 */
1860 static public function gerarAdmin($conteudo='') {
1861
1862 self::gerarCabecalhoAdmin();
1863 echo self::gerarMenuAdmin();
1864 echo $conteudo;

1865 self::gerarRodape();
1866
1867 }
1868
1869 /*
1870 * siteGerar
1871 */
1872 static public function gerarSite($conteudo='') {
1873
1874 self::gerarCabecalhoSite();
1875 echo self::gerarListaCategorias();
1878
1879 }
1880
1881 static function gerarLivroResumo ($objLivro) {

1883
1884 $arquivo = 'livroResumo.html';

1886 '%IMAGEM%' => $CONFIG['livrosDir'].
$objLivro->isbn.'.jpeg',
1887 '%LIVROID%' => $objLivro->id,
1888 '%TITULO%' => $objLivro->titulo,
1889 '%AUTOR%' => $objLivro->autor,
1890 '%PRECO%' =>
number_format($objLivro->preco, 2 , ',', '.'),
1891 );
1892 return self::pegarArquivo($arquivo, $parametros);
1893
1894 }
1895
1896 static function gerarLivroDetalhe ($objLivro) {

1898
1899 $arquivo = 'livroDetalhe.html';

1900

1906 '%PRECO%' =>
1907 '%SUMARIO%' => nl2br($objLivro-
>sumario),
1908 );
1910
1911 }
1912
1913
1914 /*
1915 * gerarLogin
1916 */
1917 static public function gerarLogin($parametros) {
1918
1919 $arquivo = 'login.html';

1921
1922 }
1923
1924
1925
1926 /*
1927 * método debug
1928
1929 */
1930 private static function debug () {
1931
1932 // Recuperando variável que ativa ou não o debug no

config.inc.php
1933 global $debug, $DEBUG;
1934
1935 // verifica se o debug está ativo

1936 if ($debug) {
1937
1938 $conteudo = '<div id="debug">';

1939
1940 /*
1941 * gerarMenuAdmin
1942 */
1943 static function gerarMenuAdmin () {
1944
1945 $conteudo = '

1947 <h3>' . $_SESSION['login'] . ' (' . $_SESSION['perfil'] .
')</h3>
1948 <h4>' . $_SESSION['nome'] . '</h4>
1949 <h4>' . $_SESSION['horalogin'] . '</h4>
1950 <h4><a href="logout.php">sair</a></h4>
1951
1952 <h1>Administração</h1>
1953 <ul>
1954 <li><a href="livroListar.php">Listar Livros</a></li>
1955 <li><a href="livroInserir.php">Inserir Livro</a></li>
1956 <li><a href="categoriaListar.php">Listar Categorias</a></li>
1957 <li><a href="categoriaInserir.php">Inserir
Categoria</a></li>
1958 <li><a href="pedidoListar.php">Listar Pedidos</a></li>
1959 </ul>
1960 ';
1961 if(Seguranca::temPerfil('admin')) {
1962
1963 $conteudo .= '

1964 <h1>Sistema</h1>
1965 <ul>
1966 <li><a href="usuarioListar.php">Listar Usuários</a></li>
1967 <li><a href="usuarioInserir.php">Inserir Usuário</a></li>
1968 </ul>
1969 ';
1970
1971 }
1972

1975
1976 }
1977
1978 /*
1979 * gerarListaCategorias
1980 */
1981 static function gerarListaCategorias () {
1982
1983 $tabCategoria = new Categoria();

1984 $categorias = $tabCategoria->listarAlfabetico();
1985
1986 $conteudo = '

1988 <h1>Categorias</h1>
1989 <ul>'."\n";
1990
1991 while ($cat = $categorias->fetchObject()) {

1992 $conteudo .= '
1993 <li>
1994 <a href="livrosCategoria.php?catid=' . $cat->id . '">
1995 ' . $cat->descricao . '
1996 </a>
1997 </li>'."\n";
1998 }
1999
2000 $conteudo .= '</ul>

2001 </div>';
2002

2004
2005 }
2006
2007 /*
2008 * adminGerar
2009 */
2010 static public function gerarAdmin($conteudo='') {
2011
2012 self::gerarCabecalhoAdmin();
2013 echo self::gerarMenuAdmin();
2016
2017 }
2018
2019 /*
2020 * siteGerar
2021 */
2022 static public function gerarSite($conteudo='') {
2023
2024 self::gerarCabecalhoSite();
2025 echo self::gerarListaCategorias();
2028
2029 }
2030
2031 static function gerarLivroResumo ($objLivro) {

2033
2034 $arquivo = 'livroResumo.html';


2040 '%PRECO%' =>
2041 );
2043
2044 }
2045
2046 static function gerarLivroDetalhe ($objLivro) {

2048
2049 $arquivo = 'livroDetalhe.html';

2050

2056 '%PRECO%' =>
2057 '%SUMARIO%' => nl2br($objLivro-
>sumario),
2058 );
2060
2061 }
2062
2063
2064 /*
2065 * gerarLogin
2066 */
2067 // Varrendo variável global com informações de debug
2068 foreach ($DEBUG as $chave => $valor) {
2069
2070 $conteudo .= "<h1>$chave</h1>\n<pre>$valor</pre>";

2071
2072 }
2073
2074 // Exibindo variáveis superglobais

2075
2076 $conteudo .=
"<h1>SESSÃO</h1>\n<pre>".print_r($_SESSION,true)."</pre>";
2077
2078 $conteudo .=
"<h1>COOKIE</h1>\n<pre>".print_r($_COOKIE,true)."</pre>";
2079
2080 $conteudo .=
"<h1>POST</h1>\n<pre>".print_r($_POST,true)."</pre>";
2081
2082 $conteudo .=
"<h1>GET</h1>\n<pre>".print_r($_GET,true)."</pre>";
2083
2084 $conteudo .=
"<h1>FILES</h1>\n<pre>".print_r($_FILES,true)."</pre>";
2085

2087 }
2088

2090
2091 }
Templates utilizados são colocados na sequência.
16.8.1. templates/login.html
1 <div id="login">
2 <form method="post" action="login.php">

3 <table>
4 %ERRO%
5 <tr>
6 <th>Login:</th>
7 <td><input type="text" name="login" value="%LOGIN%"></td>
8 </tr>
9 <tr>
10 <th>Senha:</th>
11 <td><input type="password" name="senha"></td>
12 </tr>
13 <tr>
14 <td colspan=2 align="center">
15 <input type="submit" name="entrar" value="Entrar">
16 </td>
17 </tr>
18 <tr>
19 </table>
20 </form>
21 </div>
16.8.2. templates/livroResumo.html
1 <div class="resumolivro">
2 <img src="%IMAGEM%">
3 <h3>
4 <a href="verLivro.php?livroid=%LIVROID%">
5 %TITULO%
6 </a>
7 </h3>
8 <h4>%AUTOR%</h4>
9 <h5>%PRECO%</h5>
10 <a href="verLivro.php?livroid=%LIVROID%">ver
detalhes</a><br>
11 <a href="verCarrinho.php?livroid=%LIVROID%">adicionar ao
carrinho</a>
12 </div>
16.8.3. templates/livroDetalhe.html
1 <div class="resumolivro">
2 <img src="%IMAGEM%">
3 <h3>
4 <a href="verLivro.php?livroid=%LIVROID%">
5 %TITULO%
6 </a>
7 </h3>
8 <h4>%AUTOR%</h4>
9 <h5>%PRECO%</h5>
10 <p>%SUMARIO%</p>
11 <a href="verLivro.php?livroid=%LIVROID%">ver
detalhes</a><br>
12 <a href="verCarrinho.php?livroid=%LIVROID%">adicionar ao
carrinho</a>
13 </div>
Capítulo 17 Segurança: Sistema de Login - 200
Capítulo 17
Segurança: Sistema de Login
17.1. Objetivo
• Manter o sistema seguro, com permissionamento de login.
• Filtrar injections.
17.2. Classe Seguranca
14 <?php
15
16 class Seguranca {
17
18 /*
19 * método autenticar
20 * Recebe usuário e senha e realiza autenticação
21 * Retorna true ou false
22 * Se for true, inicia sessão com dados do usuário
23 */
24 static public function autenticar($usuario, $senha) {
25
26 // Iniciando instânca da tabela usuário

27 $tabUsuario = new Usuario;
28
29 // O filtro testa login e senha com MD5

30 $filtro = "login = '" . $_POST['login'] ."' AND senha =
md5('" . $_POST['senha'] . "')";
31 $usuario = $tabUsuario->listar($filtro);
32
33 // Verifica se retornou conteúdo e quantas linhas (0 ou

1)
34 if($usuario && $usuario->rowCount()) {
35
36 // Inicia sessão
37 session_start();
38
39 // Recupera o registro
40 $usuarioLogin = $usuario->fetchObject();
41
42 // Alimenta variável de sessão

43 $_SESSION['login'] = $_POST['login'];
44 $_SESSION['horalogin'] = date('d/m/Y H:i');
45 $_SESSION['nome'] = $usuarioLogin->nome;
46 $_SESSION['perfil'] = $usuarioLogin->perfil;
47
48 // Retorna verdadeiro
49 return true;
50
51 } else {
52
53 // Não confere usuário e senha,

54 // inicia e destrói sessão para limpá-la
55 session_start();
57
58 // Retorna falso
59 return false;
60
61 }
62
63 }
64 /*
65 * método estaConectado
66 * Testa se o usuário está conectado
67 * Se não estiver, destrói sessão e
68 * envia para tela de login
69 */
70 static public function estaConectado() {
71
72 // inicia ou conecta-se a uma sessão

73 session_start();
74
75 // Verifica se a sessão possui

76 // uma variável que foi definida no login
77 if(!isset($_SESSION['login'])) {
78
79 // se não houver, destrói a sessão e redireciona

81 header('Location:login.php');
82
83 }
84
85 }
86
87
88
89
90
91 /*
92 * método temPerfil
93 * Checa se usuário está no perfil solicitado
94 * ou numa lista de perfis(em array)
95 */
96
97 static public function temPerfil($perfil) {

98
99 // Se perfil não é array, "transforma" em array

100 if(!is_array($perfil)) $perfil = array($perfil);
101
102 // Testa se o perfil do usuário na sessão está

103 // na lista de perfis enviados
104 if (in_array($_SESSION['perfil'], $perfil)) {
105
106 // Retorna verdadeiro, está no perfil

107 return true;
108
109 } else {
110
111 // Retorna falso, não está no perfil

112 return false;
113
114 }
115
116 }
117 /*
118 * método checaAcesso

119 * Verifica se usuário tem acesso
120 * Se não tem, redireciona para página de
121 * Acesso Negado
122 */
123 static public function checaAcesso($perfil) {
124
125 // Se perfil não é array, "transforma" em array

126 if(!is_array($perfil)) $perfil = array($perfil);
127
128 // Testa se o perfil do usuário na sessão está

129 // na lista de perfis enviados
130 if (!in_array($_SESSION['perfil'], $perfil)) {
131
132 // Se não está na lista de perfis, redireciona

133 header('Location:acessoNegado.php');
134
135 }
136
137 }
138
139 }
17.2.1. login.php
140 <?php
141

143 include_once("../config.inc.php");
144
145 // Iniciando parâmetros para template de login

146 $parametros = array('%ERRO%'=>'', '%LOGIN%'=>'');
147

variável

150 if($_SERVER['REQUEST_METHOD'] == 'POST' &&
isset($_POST['login'])){
151
152 // Usando classe Seguranca para realizar autenticação

153 if(Seguranca::autenticar($_POST['login'], $_POST['senha'])) {
154
155 // Se foi autenticado, redireciona para index

156 header('Location:index.php');
157
158 } else {
159
160 // Não autenticou, então altera os parâmetros

161 // do template de login para emitir
162 // mensagem de erro e mostrar o login digitado
164 '%ERRO%'=>
165 '<caption>Usuário ou Senha não
conferem</caption>',
166 '%LOGIN%'=>$_POST['login'],
167 );
168
169 }
170
171 }
172
173 // Não é gerado o template de admin padrão,

174 // pois já contém menu
175 // Cabecalho, formulário de login e rodapé
176 // são gerados individualmente e tem saída com echo
177 echo Template::gerarCabecalhoAdmin();
178 echo Template::gerarLogin($parametros);
179 echo Template::gerarRodape();
17.2.2. logout.php
180 <?php
181
182 // Reconecatando e destruindo a cessão

185
186 // Redirecionando para tela de login

187 header('Location:login.php');
17.2.3. index.php alterado para checar usuário

logado
188 <?php
189

192
193 // Checando se está conectado

194 Seguranca::estaConectado();
195
196 // Gerando template do site administrativo

197 Template::gerarAdmin('');
REFERÊNCIAS
BIBLIOGRÁFICAS
ECO, UMBERTO. Como se faz uma tese em Ciências Humanas. 6.ª

edição. Lisboa: Editorial Presença. 1995.
Homepage oficial de Umberto Eco, website: http://www.umbertoeco.it/.

Acesso em 26 de abril de 2010.
ANEXOS
HTML/XHTML - Referência Básica - 210
HTML/XHTML - Referência Básica
Este documento é uma referência rápida às tags básicas do HTML/XHTML.

Não é um curso completo tampouco uma referência completa.
Estrutura Básica de uma página
<html>

<head>

<title>
Título da Página
</title>

<style type="text/css">estilo.css</style>
</head>

<body>
Corpo da página
</body>
</html>
Tags de Texto
<h1>Título Nível 1</h1>

<p>Parágrafo</p>
Quebra de linha<br />
Linha Horizontal<hr />
Listas
Uma lista não ordenada

<ul>
<li>Primeiro</li>
<li>Segundo</li>
<li>Terceiro</li>
</ul>
Uma lista ordenada
<ol>
<li>Primeiro</li>
<li>Segundo</li>
<li>Terceiro</li>
</ol>
Listas de definição
<dl>
<dt>Homossexual</dt>
<dd>Sabão em pó para lavar os órgão genitais</dd>
<dt>Promoção</dt>
<dd>Algo para um cara grande (feminino diminutivo: pra
mocinha)</dd>
</dl>
Imagens
<img src="caminho/confirmar.jpg" alt="confirmar" />
Tabelas
<table>
<caption>Título da tabela (XHTML)</caption>

<thead>
<tr>
<th>Nome</th>
<th>Idade</th>
<th>Local</th>
</thead>

<tfoot>

<td colspan="3">Total de Pessoas: 03</td>
</tfoot>
<tbody>
<tr>
<td>João Guedes</td>
<td>31</td>
<td>Santa Maria – RS</td>
</tr>
<tr>
<td>Mário Carvalho</td>
<td>28 anos</td>
<td>Salvador – BA</td>
</tr>
<tr>
<td>Cristiane Ramalho</td>
<td>23 anos</td>
<td>Barreiras – BA</td>
</tr>
</tbody>
</table>
Formulários
<form action="destino.php" method="post">


<fieldset>
<legend>Legenda do fieldset</legend>


<label for="um">Texto: input type text</label>
<input id="um" type="text" name="um" size="20"value="123456" />
<br/>
<label for="dois">Senha: input password</label>

<input id="dois" type="password" name="dois" size="20"
value="123456" />
<br />
<label for="tres">Área de texto: textarea </label>

<textarea class="semTabela" name="tres" cols="50" rows="3">
Aqui temos texto em profusão
</textarea>
<br />
</fieldset>
<fieldset>
<legend>Um grupo para seleção</legend>
<label for="quatro">Select: select</label>

<select id="quatro" name="quatro">
<optgroup label="Premiados">
<option value="1">primeiro</option>
<option value="1">segundo</option>
<option value="1">terceiro</option>
</optgroup>
<optgroup label="Sofredores">
<option value="1">quarto</option>
<option value="1">quinto</option>
<option value="1">sexto</option>
</optgroup>
</select>
</fieldset>
<fieldset>
<legend>Input Checkbox</legend>

<input type="checkbox" name="seis" value="1" />
Marque este<br />
<input type="checkbox" name="sete" value="1" />

Marque este também<br />
<input type="checkbox" name="oito" value="1" />
E este também
</fieldset>
<fieldset >
<legend>Input Radio</legend>

<input type="radio" name="nove" value="1" />Marque este<br />
<input type="radio" name="nove" value="1" />Ou este<br />
<input type="radio" name="nove" value="1" />Ou este
</fieldset>
<fieldset >
<legend>Botões</legend>

<button type="submit" name="dez">Enviar</button>

<button type="reset" name="dez">Limpar</button>

<input type="submit" name="dez" value="Enviar" />

<input type="reset" name="dez" value="Limpar" />
</fieldset>
</form>
Enviando e-mails com o PHP - 217
Enviando e-mails com o PHP
O comando mail() é usado para enviar mensagens de texto simples. Este

comando conta com o sistema de correio local para distribuir e-mails. Assim, se seu
sistema não contar com um programa de correio local, como o sendmail ou postfix,
este comando não funcionará. Veja sintaxe e exemplo abaixo:
bool mail(string to, string subject, string message[, string

additional_headers]);
Exemplo :
198 mail("contato@4linux.com.br","Assunto","Corpo da mensagem");
O programa que envia o e-mail é configurado na diretiva sendmail_path do

arquivo php.ini.
Verificando o tipo de uma variável - 218
Verificando o tipo de uma variável
O PHP utiliza checagem de tipos dinâmica, ou seja, uma variável pode conter
valores de diferentes tipos em diferentes momentos da execução do script. Por este
motivo não é necessário declarar o tipo de uma variável para usá-la. O interpretador
PHP decidirá qual o tipo daquela variável, verificando o conteúdo em tempo de
execução.
Ainda assim, é permitido converter os valores de um tipo para outro desejado,

utilizando casting ou a função settype(), descrita logo adiante.
Nem sempre é possível saber qual o tipo de uma variável em determinado

instante se não contar com a ajuda de algumas funções que verificam isso. A
verificação pode ser feita de duas maneiras:
1 - Utilizando a função gettype(), em que a sintaxe é a seguinte:
string gettype(mixed var);
2 - Utilizando as funções is_*(). São elas:
• is_array()
• is_bool()
• is_float()
• is_integer()
• is_null()
• is_numeric()
• is_object()
• is_resource()
• is_scalar()
• is_string()
onde a sintaxe é a seguinte:
bool is_<tipo> (mixed var);
A função retorna TRUE se var é do tipo indicado, e FALSE se não.
A palavra mixed indica que a variável var pode ser de diversos tipos. E a
função pode retornar as seguintes strings: integer, double, string, array, object e
unknown type.
Dica: Nunca use gettype() para testar um certo tipo, a string devolvida
poderá sofrer alterações em uma versão futura. Ao invés, use as funções is_*.
Transformação de tipos - Coerções
Quando ocorrem determinadas operações (soma "+", por exemplo) entre dois
valores de tipos diferentes, o PHP converte o valor de um deles automaticamente
(coerção). Se o operando for uma variável, seu valor não será alterado.
O tipo para o qual os valores dos operandos serão convertidos é determinado

da seguinte forma: se um dos operandos for float, o outro será convertido para float,
senão, se um deles for integer, o outro será convertido para integer.
Veja este exemplo:
199 <?php
200 $php = "1";// $php é a string "1"
201 $php = $php + 1; // $php é o integer 2
202 $php = $php + 3.7; // $php é o double 5
Como podemos notar, o PHP converte string para integer ou float mantendo o
valor.
O sistema utilizado pelo PHP para converter strings em números é analisado o

início da string:
• Se contiver um número, ele será avaliado. Senão, o valor será 0 (zero);

• O número pode conter um sinal no início ("+" ou "-");
• Se a string contiver um ponto em sua parte numérica a ser analisada, ele
será considerado, e o valor obtido será float/double;
• Se a string contiver um "e" ou "E" em sua parte numérica a ser analisada, o
valor seguinte será considerado como expoente da base 10, e o valor obtido
será double.
Teste o exemplo abaixo
203 <?php
204 $php = 1 + "10.5";// $php == 11.5
205 echo '<p>' . $php . '</p>';
206 $php = 1 + "-1.3e3"; // $php == -1299
207 echo '<p>' . $php . '</p>';
208 $php = 1 + "teste10.5"; // $php == 1
209 echo '<p>' . $php . '</p>';
210 $php = 1 + "10testes"; // $php == 11
211 echo '<p>' . $php . '</p>';
212 $php = 1 + " 10testes";// $php == 11
213 echo '<p>' . $php . '</p>';
214 $php = 1 + "+ 10testes"; // $php == 1
215 echo '<p>' . $php . '</p>';
216 $php = 1 + "- 10testes"; // $php == 1
217 ?>
Transformação explícita de tipos
A sintaxe do typecast de PHP é semelhante ao de C: basta escrever o tipo

entre parênteses antes do valor .
Exemplo:
218 <?php
219 $php = 15; // $php é integer (15)
220 $php = (double) $php;// $php é double (15.0)
221 $php = 3.9; // $php é double (3.9)
222 $php = (int) $php;// $php é integer (3)
223 // o valor decimal é truncado
224 ?>
Os tipos de cast permitidos são:
• (int), (integer) muda para integer;

• (real), (double), (float) muda para float;
• (string) muda para string;
• (array) muda para array;
• (object) muda para objeto.
Com a função settype
A função settype() converte uma variável para o tipo especificado, que pode
ser "integer", "double", "string", "array" ou "object".
Exemplo:
225 <?php
226 $php = 15; // $php é integer
227 settype($php,double);// $php é double
Conexão segura - 222
Conexão segura
O site que implementamos, fora as funcionalidades que ainda faltam, não pode
ser utilizado para
uma finalidade séria em hipótese alguma. Isso porque, no formulário de

pagamento, o usuário envia vários dados incluindo o número do cartão de crédito.
Entretanto, os dados não são criptografados e podem ser facilmente interceptados e
visualizados por intrusos.
Para resolver esse problema, precisamos embaralhar os dados antes de serem

enviados, de modo que se porventura sejam interceptados, não possam ser
compreendidos. Somente o servidor sabe como desenbaralhar a informação. Essa
funcionalidade é provida pelo servidor web e é transparente aos scripts PHP. Vejamos
como prosseguir para habilitar a conexão segura com o servidor.
Instalando a ferramenta OpenSSL - (Secure

Socket Layer)
# aptitude install openssl
Criando uma certificadora local
A autenticidade de um site é assinada por uma organização certificadora

oficial. Como estamos
apenas fazendo alguns testes, criaremos nossa própria organização

localmente. Vejamos como fazer isso:
# mkdir /root/ssl
# cd /root/ssl
# /usr/lib/ssl/misc/CA.sh -newca
Uma série de perguntas são feitas. Preencha-as conforme o quadro abaixo. A

demais perguntas podem ser simplesmente respondidas com <ENTER>.
Enter PEM pass phrase: 123456

Verifying - Enter PEM pass phrase: 123456
Country Name (2 letter code) [AU]:BR
State or Province Name (full name) [Some-State]:SP
Locality Name (eg, city) []:Sao Paulo
Organization Name (eg, company) [Internet Widgits Pty Ltd]:Certificadora
Organizational Unit Name (eg, section) []:TI
Common Name (eg, YOUR name) []:www.certificadora.com.br
Email Address []:suporte@certificadora.com.br
Se tudo ocorreu bem, aparecerá uma mensagem informando que a

certificadora foi criada.
Criando um site seguro
Precisamos criar um domínio virtual que aceite conexão segura. Crie um

arquivo chamado livraria dentro do diretório /etc/apache2/sites-available:
NameVirtualHost <Seu IP>

<VirtualHost www.livraria.com.br>
DocumentRoot /var/www/livraria
SSLEngine On
SSLCertificateFile /root/ssl/newcert.pem
SSLCertificateKeyFile /root/ssl/newkey.pem
ServerName www.livraria.com.br
ServerAdmin suporte@livraria.com.br
ErrorLog /var/log/apache2/livaria.com.br-error.log
CustomLog /var/log/apache2/livaria .com.br-access.log common
</VirtualHost>
Acertando o resolvedor de nomes local
Entretanto, o DNS irá resolver o nome acima para outro IP. Precisamos incluir
uma entrada no arquivo /etc/hosts:
<Seu IP> www.livraria.com.br
Criando uma requisição de certificação
Agora que temos uma certificadora, precisamos solicitar a ela a assinatura do

nosso site. Digitem o comando abaixo:
# cd /root/ssl
# /usr/lib/ssl/misc/CA.sh -newreq
E preencham conforme o quadro abaixo. Atentem para a URL fornecida, que

deve ser a mesma configurada no VirtualHost do Apache.
Enter PEM pass phrase: 1234

Verifying - Enter PEM pass phrase: 1234
Country Name (2 letter code) [AU]:BR
State or Province Name (full name) [Some-State]:SP
Locality Name (eg, city) []:Sao Paulo
Organization Name (eg, company) [Internet Widgits Pty Ltd]:Livraria do
Tux
Organizational Unit Name (eg, section) []:TI
Common Name (eg, YOUR name) []:www.livraria.com.br
Email Address []:suporte@livaria .com.br
Assinando a certificação
Uma vez que a certificadora tem uma requisição, devemos então assiná-la.
Digitem o comando abaixo.
A senha solicitada é da certificadora, isto é, 123456. Respondam com y e o

site estará então certificado.
# /usr/lib/ssl/misc/CA.sh -sign
Habilitando o site seguro
O comando abaixo disponibiliza o VirtualHost que criamos. Responda

conforme indicado:
# a2ensite
Site name? livraria
Habilitando conexão segura
# a2enmod ssl
For fim, habilite a porta de conexão segura 443. Adicione a seguinte linha ao
arquivo /etc/apache2/ports.conf :
Listen 443
Reiniciando o servidor web.
Para que as ações tenham resultado, devemos reinicializar o servidor. Ao ser

solicitada, utilize a senha do servidor, isto é, 1234.
/etc/init.d/apache2 restart
Tente acessar o site com a URL:
https://www.livraria.com.br
Visualize o certificado apresentado no browser.

Capítulo 18
A certificação
• A prova:
◦ A prova é composta de 70 questões em inglês com 90 minutos de duração.
◦ Temos em média 1min e 2seg por questão na prova.
◦ A prova é mista de questões dos seguintes tipos:
▪ Múltipla-escolha
▪ Discursiva
▪ Somatória
Questionário ZEND(Inglês) - 227
18.1. Questionário ZEND(Inglês)
1. Which of the following functions will sort an array in

ascending order by value, while preserving key associations?
-asort()
-usort()
-krsort()
-ksort()
-sort()
2. A fingerprint of a string can be determined using which of the

following?
-md5()
-hash()
-fingerprint()
-None of the above
3. Consider the following XML document

<?xml version="1.0" encoding="ISO-8859-1" ?>
<!DOCTYPE html
PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en"
lang="en">
<head>
<title>XML Example</title>
</head>
<body>
<p>
Moved to <<a
href="http://example.org/">http://www.example.org/</a>.>
<br>
</p>
</body>
</html>
What is wrong with this document, and how can it be corrected?
-The document is completely valid

-All special XML characters must be represented as entities
within the -content of a node
-All tags must be closed
-You cannot specify a namespace for the attribute
-The DOCTYPE declaration is malformed
4.
<?php
$a = array(
1 => 'red',
'green',
'blue',
'purple' => array(
'house' => 'dog',
'food' => 'meal',
'here' => 'gone',
'hello' => array(
5 => 'goodbye',
8 => 'something',
'correct')));
?>
Which of the following print statements will output the string
“correct”?
-print $a['purple][4][3];
-print $a['purple']['hello'][9];
-print $a[2][4][3];
-print $a[2][4][9];
-print $a[4]['hello'][9];
5. If you would like to store your session in the database, you

would do which of the following?
-It requires a custom PHP extension to change the session handler

-Implement the session_set_save_handler() function
-Create functions for each session handling step and use
session_set_save_handler() to override PHP’s internal settings
-Configure the session.save_handler INI directive to your session
class
6. Consider the following PHP script:
get_socket($host1, $port1),
‘data’ => str_pad(“”, 500000, “A”));
$write_map[] = array(‘fr’ => get_socket($host2, $port2),
‘data’ => str_pad(“”, 500000, “B”));
$write_map[] = array(‘fr’ => get_socket($host3, $port3),
‘data’ => str_pad(“”, 500000, “C”));
do {
$write_sockets = array();
foreach($write_map as $data) {
$write_sockets[] = $data['fr'];
}
$num_returned = stream_select($r = null, $write_sockets, $e =
null, 30);
if($num_returned) {
foreach($write_sockets as $fr) {
foreach($write_map as $index => $data) {
if($data['fr'] === $fr) {
$len = fwrite($fr, $data['buf']);
if($len) {
$data['buf'] = substr($data['buf'], $len);
if(empty($data['buf'])) {
fclose($data['fr']);
unset($write_map[$index]);
}
}
}
}
}
}
} while(??????????);
?>
What should go in the ??????? above for this script to function

properly?
-$num_returned > 0
-$len > 0
-!empty($data['buf'])
-count($write_sockets)
-count($write_map)
7. Using flock() to lock a stream is only assured to work under

what circumstances?
-When running in a Linux environment local filesystem

-When accessing the stream of the local filesystem
-When running in a Windows environment and accessing a share
-When accessing a bi-directional stream
-When accessing a read-only stream
8. Which PCRE regular expression will match the string PhP5-

rocks?
-/^[hp1-5]*\-.*/i
-/[hp1-5]*\-.?/
-/[hp][1-5]*\-.*/
-/[PhP]{3}[1-5]{2,3}\-.*$/
-/[a-z1-5\-]*/
9. The ______ keyword is used to indicate an incomplete class or

method, which must be further extended and/or implemented in
order to be used.
final
protected
incomplete
abstract
implements
10. What is the output of?

function apple($apples = 4)
{
$apples = $apples / 2;
return $apples;
}
$apples = 10;
apple($apples);
echo $apples;
10
11 . Which of the following is the best way to split a string on

the “-=-” pattern?
They all are equally proper methods

str_split($string, strpos($string, “-=-”))
preg_split(“-=-”, $string);
explode(“-=-” $string);
12. Consider the following PHP script fragment:

createElement(‘title’);
$node = ????????
$title->appendChild($node);
$head->appendChild($title);
?>
What should ??????? be replaced with to add a node with the value
of Hello, World!
-$dom->createTextNode(“Hello, World”);
-$dom->appendElement($title, “text”, “Hello, world!”);
-$dom->appendTextNode($title, “Hello, World!”);
-$dom->createElement(‘text’, “Hello, World”);
-None of the above
13. Implementing your own PDO class requires which steps from the
list below?(choose 3)
-Extending the PDOStatement Class

-Set the PDO::ATTR_STATEMENT_CLASS parameter
-Call the PDO::setStatementClass() method
-Extend the PDO class
-Set the PDO::ATTR_USE_CLASS paramater
14. Which from the following list is not an approrpiate use of an
array?
-As a list
-All of these uses are valid
-As a Lookup Table
-A Stack
-As a hash table
15. What variable reference would go in the spots indcated

by ????? in the code segment below?
-$msg{$i}
-ord($msg);
-chr($msg);
-substr($msg, $i, 2);
16. When is it acceptable to store sensitive information in an

HTTP cookie?
-Only under extremely controlled situations

-When the cookie is sent over a secure HTTP request
-When it is encrypted
-It is always acceptable
17. Consider the following PHP string representing an SQL

statement:
$query = “UPDATE users SET password=’$password’ WHERE
username=’$username’”;
Which of the following values for $username or $password would

change the behavior of this query when executed?
-None of the above

-$username = “foobar\’ WHERE username=’admin’”;
-$password = “foobar’ WHERE username=’admin’ –:”;
-$username = “foobar\’ WHERE username=’admin’”;
-$password = “\”foobar\” WHERE username=\”admin\”";
18. When attempting to prevent a cross-site scripting attack,

which of the following is most important?
-Not writing Javascript on the fly using PHP

-Filtering Output used in form data
-Filtering Output used in database transactions
-Writing careful Javascript
-Filtering all input
19. In a situation where you want one and only one instance of a
particular object, the ________ design pattern should be used.
20. Which of the following list of potential data sources should

be considered trusted?
-None of the above

-$_ENV
-$_GET
-$_COOKIE
-$_SERVER
21. Which of the following php.ini directives should be disabled

to improve the outward security of your application?
-safe_mode
-magic_quotes_gpc
-register_globals
-display_errors
-allow_url_fopen
22. The _______ method will be called automatically when an

object is represented as a string.
-getString()
-__get()
-__value()
-__toString()
-__getString()
23. Which functions would be needed to translate the following

string:
I love PHP 5
to the following?
5 PHP EVOL I
(choose 2)
-mirror()
-strtoupper()
-toupper()
-str_reverse()
-strrev()
24. When embedding PHP into XML documents, what must you ensure
is true in order for things to function properly?
-Disabling of the short_tags PHP.ini directive

-Enabling the asp_tags PHP.ini directive
-That you have XPath support enabled in PHP 5
-That your XML documents are well-formed
-None of the above, PHP can be embedded in XML in all cases.

PHP e Mysql

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

PHP e Mysql

Enviado por

Direitos autorais:

Formatos disponíveis

PHP & MySQL

3.5.3. Tipos de variáveis suportados ...............................................................................................34

10.3.1. Melhorando a segurança do banco .....................................................................................78

13.3.3. Fechando arquivos ............................................................................................................140

16.5. Cabeçalho do site público............................................................................................182

• Compreender o mercado atual do PHP;

• Entender o funcionamento de um servidor web;

1.2. Definição do projeto

Nosso projeto será dividido em 4 partes:

1.3. PHP e MySQL - onde vamos chegar

No mercado atual de desenvolvimento um dos maiores focos é o

Estas aplicações necessitam de profissionais que dominem 3 tecnologias

O Web Design é um ramo de criação artística, mas que também envolve a

Linguagens de desenvolvimento Web permitem a criação de páginas

Banco de dados são aplicações que armazenam informações de modo

Entretanto, para utilizar estas tecnologias é preciso um hospedeiro que as

1.4. Como funciona um servidor Web

Servidor é um aplicativo que aguarda requisições de clientes, realiza algum

Servidores Web, a princípio, são "entregadores de arquivos". Recebem

No lado do cliente é necessário um aplicativo cliente, conhecido como

O protocolo de comunicação utilizado pelos servidores Web é o HTTP

Figura 1.1: Como funciona um servidor Web

Na Figura 1.1: Como funciona um servidor Web ilustra-se o funcionamento

É importante perceber que, de modo básico, o servidor Web é um servidor de

1.4.1. URL (Uniform Resource Locator) ou endereço da página

O endereço de um página web é representado pela URL (Uniform Resource

Isto permite que um computador rodando Windows se comunique com um

No caso de uma URL para um endereço web, o protocolo será normalmente

1.4.3. Endereço do Servidor : Porta

O endereço do servidor geralmente é representado geralmente por um FQDN

O DNS é um sistema que trabalha como uma "agenda telefonica", resolvendo

Entretanto, existem diversos servidores web com um único IP respondendo

Observação: O nome de host www é um padrão para nomes de máquinas que

Uma vez fechada a conexão com o servidor, então solicitamos um arquivo

Deste modo, sendo o caminho raiz de um domínio:

Então, se solicitamos o endereço:

O servidor Web nos retornará o arquivo:

Este exemplo é um simplificação. Diversos sistemas web modernos utilizam

1.4.5. Arquivos índice de diretórios

Com um pouco de atenção é possível perceber um "furo" neste sistema:

http://www.4linux.com.br/cursos, que arquivo será fornecido pelo servidor web?

1.5. Instalando o servidor web Apache com

1.5.1. Gerenciando pacotes com o Aptitude

Nosso curso será realizado numa plataforma GNU/Linux utilizando a

Configure as fontes como mostrado abaixo :

deb http://192.168.1.1/lenny main contrib non-free

Agora atualizaremos a base de dados local :

# aptitude search apache2

Existem vários pacotes. São em sua maioria pacotes de bibliotecas opcionais.

1.5.2. Instalando o servidor Apache 2 com suporte ao PHP5

# aptitude install apache2

Abra um navegador e digite a URL:

Se tudo funcionou bem, vamos instalar o PHP 5 :

# aptitude install php5

Testando a instalação do PHP5

Coloque neste arquivo o seguinte código:

<?php phpinfo() ?>

E então é possível verificá-lo na endereço:

Esta função especial do PHP fornece dados completos sobre a instalação do

Breve revisão ao HTML/XHTML

• Rever os conteúdos necessários de HTML;

• Compreender as diferenças de páginas estáticas e páginas dinâmicas.

2.2. Introdução teórica