PHP e Desenvolvimento WEB

com Ferramentas Open Source

Por Érika Focke
http://www.erikafocke.com.br

Proibida cópia não autorizada.

 Índice

1 - Introdução ...................................................................................................................... 4
1.1 A História do PHP............................................................................................... 4
Aplicações WEB – Por quê?..................................................................................... 4
Características do PHP ............................................................................................ 4
2 - LINUX: por onde começar ............................................................................................. 6
2.1 Estrutura de Diretórios........................................................................................ 6
2.2 Permissões......................................................................................................... 7
2.3 Comandos básicos ............................................................................................. 7
3 - HTTP e HTML : Noções............................................................................................... 12
3.1 HTTP ................................................................................................................ 12
3.2 HTML – Tags Básicas ...................................................................................... 12
4 - Iniciando em PHP ........................................................................................................ 17
4.1 Primeira página ................................................................................................ 17
4.2 PHP: Sintaxe básica ......................................................................................... 17
4.2.3 Comentários .................................................................................................. 19
4.3 Tipos................................................................................................................. 19
4.4 Transformação de tipos .................................................................................... 20
Coerções.......................................................................................................... 21
Transformação explícita de tipos ..................................................................... 21
Com a função settype ...................................................................................... 22
4.5 Variáveis.......................................................................................................... 22
4.6 Arrays ............................................................................................................... 23
4.7 Constantes ....................................................................................................... 24
4.8 Variáveis Pré-Definidas - SuperGlobais ........................................................... 25
5 - Funções de Saída........................................................................................................ 27
5.1 echo.................................................................................................................. 27
5.2 printf.................................................................................................................. 27
6 - Expressões .................................................................................................................. 28
6.1 Operadores....................................................................................................... 28
Operadores de Atribuição ................................................................................ 28
Operadores Aritméticos.................................................................................... 28
Operadores de Comparação............................................................................ 29
Operadores de Incremento/Decremento .......................................................... 29
Operadores Lógicos ......................................................................................... 30
Operadores de String ....................................................................................... 30
6.2 Ordem de precedência dos operadores............................................................... 31
7 - Formulários HTML ....................................................................................................... 32
7.1 A Tag FORM .................................................................................................... 32
7.2 A tag INPUT ..................................................................................................... 32
7.3 A tag SELECT .................................................................................................. 33
7.4 A tag TEXTAREA ............................................................................................. 33
8 - Tratando Formulários................................................................................................... 35
8.1 - HTTP GET - $_GET ....................................................................................... 35
8.2 - HTTP POST - $_POST .................................................................................. 36

2
 8.3 – O Array $_FILES ........................................................................................... 36
8.4 – Dicas para seu formulário.............................................................................. 36
9 - Estruturas de Controle ................................................................................................. 37
9.1 – Condicionais ..................................................................................................... 37
9.1.1 - IF..................................................................................................................... 37
9.1.2 ELSE................................................................................................................. 38
9.1.3 ELSEIF (ou else if)............................................................................................ 38
9.1.4 SWITCH............................................................................................................ 39
9.2 – Repetição.......................................................................................................... 39
9.2.1 WHILE............................................................................................................... 39
9.2.2 DO..WHILE ....................................................................................................... 40
9.2.3 FOR .................................................................................................................. 40
9.3 Quebra de fluxo ................................................................................................... 41
9.3.1 Break................................................................................................................. 41
9.3.2 Continue............................................................................................................ 41
10 - Modularização............................................................................................................ 42
10.1 Inclusão de Arquivos .......................................................................................... 42
10.2 Funções .............................................................................................................. 42
10.3 Argumentos com valores pré-definidos (default) ................................................ 43
10.4 Passagem de parâmetros por referência............................................................ 44
11 - Banco de Dados ........................................................................................................ 46
11.1 Sistema de Banco de Dados .............................................................................. 46
11.2.1 Referência da Linguagem................................................................................ 47
11.2.2 Sintaxe Detalhada ........................................................................................... 48
11.2.3 Modificadores de tipos ..................................................................................... 51
12 - PHP e MySQL – Integração....................................................................................... 53
13 - Cookies e Sessões .................................................................................................... 55
13.1 - Cookies ........................................................................................................ 55
13.2 - Sessões........................................................................................................ 57
14. Manipulação de Arquivos ............................................................................................ 58
14.1 FOPEN ........................................................................................................... 58
14.2 FEOF .............................................................................................................. 59
14.3 FGETS............................................................................................................ 59
14.4 FWRITE.......................................................................................................... 59
14.5 FILE_EXISTS ................................................................................................. 60
14.6 Outras funções de interesse para manipulação de arquivos .......................... 60
15 - Upload de Arquivos.................................................................................................... 61
16 - Regular Expressions.................................................................................................. 63
17 - Manipulação de Imagens ........................................................................................... 66
18 - Apêndice .................................................................................................................... 67
18.1 Tratamento de erros .......................................................................................... 67

3
 1 - Introdução

1.1 A História do PHP

A linguagem PHP foi concebida durante o outono de 1994 por Rasmus Lerdorf. As primeiras
versões não foram disponibilizadas, tendo sido utilizadas em sua home-page apenas para que ele
pudesse ter informações sobre as visitas que estavam sendo feitas.

A primeira versão utilizada por outras pessoas foi disponibilizada em 1995, e ficou conhecida
como Personal Home Page Tools (ferramentas para página pessoal). Era composta por um
sistema bastante simples que interpretava algumas macros e alguns utilitários que rodavam por
trás das home-pages: um livro de visitas, um contador e algumas outras coisas. Em meados de
1995 o interpretador foi reescrito, e ganhou o nome de PHP/FI; o FI veio de um outro pacote
escrito por Rasmus que interpretava dados de formulários HTML (Form Interpreter). Ele combinou
os scripts do pacote Personal Home Page Tools com o FI e adicionou suporte a mSQL, nascendo
assim o PHP/FI, que cresceu bastante, e as pessoas passaram a contribuir com o projeto.

Estima-se que em 1996 PHP/FI estava sendo usado por cerca de 15.000 sites pelo mundo, e em
meados de 1997 esse número subiu para mais de 50.000. Nessa época houve uma mudança no
desenvolvimento do PHP. Ele deixou de ser um projeto de Rasmus com contribuições de outras
pessoas para ter uma equipe de desenvolvimento mais organizada. O interpretador foi reescrito
por Zeev Suraski e Andi Gutmans, e esse novo interpretador foi a base para a versão 3.

Aplicações WEB – Por quê?

O conceito de Aplicações WEB se aplica a sites dinâmicos com grande flexibilidade que
funcionam como verdadeiros softwares via browser. O grande diferencial de uma aplicação WEB
via browser e um software desenvolvido em Delphi ou outra linguagem compilável está na
portabilidade.

As aplicações via browser têm seu código executado do lado do servidor, e por essa razão, é
independente de plataforma; qualquer navegador abrirá a sua aplicação, em qualquer sistema. E
você não precisará instalar nenhum software adicional, visto que todas as instalações padrão de
sistemas na atualidade já vêm com um browser.

Você poderá chegar em qualquer computador, em casa, no trabalho, na casa de um amigo, e abrir
a sua aplicação, consultar informações e o que mais for possível na sua implementação.
Você pode inclusive desenvolver sua aplicação web compartilhando um mesmo banco de dados
utilizado por uma aplicação desenvolvida em outras linguagens. Isso é interessante para
desenvolver módulos separados para que usuários tenham acesso de consulta a informações da
sua aplicação, mas que as modificações apenas possam ser feitas através de um software em
separado.

Características do PHP
4
o Linguagem Interpretada(não compilada);
o Pré-processada;
o Integração: bancos de dados diversos, arquivos, outras linguagens, scripts;
o Sintaxe baseada em C e Perl.
o Não necessita declaração de variáveis e tipos;
o Centenas de funções prontas pesquisáveis na página php.net;
o Possibilidade de inclusão de arquivos de funções, scripts etc;
o Código mesclável com html, javascript;
o O cliente não necessita de nada “a mais”, nem instalar nenhum programa específico,
precisa apenas do browser;
o Multiplataforma, tanto para servidor quanto para cliente;
o Manipulação de arquivos;
o Manipulação de imagens;
o Geração de documentos xml, wml, pdf, swf, gif, jpeg e png;
o Expressões regulares para validar campos de formulário, por exemplo;
o Integração com uma grande variedade de bancos de dados:
• Oracle
• dBase
• InterBase
• Empress
• FrontBase
• PostgreSQL
• mSQL
• MS-SQL
• Sybase
• ODBC
• e o mais utilizado, MySQL.
(Dentre outros)

5
 2 - LINUX: por onde começar

O Linux é um sistema gratuito e de código aberto, como todos já devem saber, e é uma
plataforma ideal para desenvolvimento, para programação. No caso do desenvolvimento WEB,
entretanto, havia muitas dificuldades no que diz respeito à organização gráfica e visual do site.
Mas hoje a situação é completamente diferente, e o Linux já possui programas gráficos tão bons
quanto os softwares fechados tão conhecidos no mundo gráfico, e todos gratuitos, a grande
maioria de código aberto.

Para começarmos o nosso curso tendo um bom aproveitamento de todas as ferramentas que o
software livre pode nos oferecer, vamos começar com as noções de utilização desse sistema, que
será utilizado como nossa plataforma de desenvolvimento.
O Linux pode parecer muito complicado para algumas pessoas, mas na verdade ele é bem
simples. O que faz as pessoas terem essa impressão é o fato de estarem muito habituadas ao
Windows (tudo é uma questão de costume).

No Linux, pelo menos na maioria das versões, ao iniciar o sistema, ele não irá entrar
automaticamente no modo gráfico como o Windows faz. Algumas pessoas podem se “assustar”
com isso, entretanto quando abrimos o ambiente gráfico vemos que tudo pode ser bem mais
simples.
Há vários bons tutoriais de linux na internet, e no nosso curso apenas passaremos as noções
básicas necessárias para utilização do Linux como plataforma de desenvolvimento WEB. Veremos
sua estrutura de diretórios, permissões e instalação de programas.

2.1 Estrutura de Diretórios

Estrutura da Raiz ( / ) de um sistema Linux:

Arquivos executáveis(binários) de comandos essenciais pertencentes ao sistema e que

bin
são usados com frequência.

boot Arquivos estáticos de boot - inicialização(boot-loader)

dev Arquivos de dispositivos de entrada/saída

Configuração do sistema da máquina local com arquivos diversos para a administração de

etc
sistema.

home Diretórios local(home) dos usuários

lib Arquivos da biblilotecas compartilhadas usados com freqüencia

mnt Ponto de montagem de partição temporárias(cdrom, disquete etc)

root Diretório local do superusuário (root)

sbin Arquivos binários(executáveis) de sistema essenciais

tmp Arquivos temporários gerados por alguns utilitários

6
 Todos os arquivos de usuários gerados por instalações de programas(contém uma sub-
usr
estrutura)

var Informações variáveis

2.2 Permissões
As permissões são um dos aspectos mais importantes do Linux (na verdade, de todos os sistemas
baseados em Unix). Elas são usadas para vários fins, mas servem principalmente para proteger o
sistema e os arquivos dos usuários.
Como você deve saber, somente o super-usuário (root) tem ações irrestritas no sistema,
justamente por ser o usuário responsável pela configuração, administração e manutenção do
Linux. Cabe a ele por exemplo, determinar o que cada usuário pode executar, criar, modificar, etc.
E isso é feito através das permissões.

drwx------ ... 2 wester ............... 512 Jan ... 29 23:30 .. Arquivos/

-rw-rw-r-- ... 1 wester ....... 280232 Dec .. 16 22:41... notas.txt

As linhas acima representam um comando digitado (ls –l) para listar um diretório e suas
permissões. O primeiro ítem que aparece na linha (drwx----- e –rw-rw-r-) é a forma usada para
mostrar as permissões que o diretório “Arquivos” e o arquivo “notas.txt” têm.
Um ponto interessante para lembrar é que o Linux trata todos os diretórios como arquivo também,
portanto, as permissões se aplicam de igual forma para ambos. Tais permissões podem ser
divididas em quatro partes para indicar: tipo, proprietário, grupo e outras permissões. O primeiro
caractere da string indica o tipo de arquivo: se for “d” representa um diretório, se for “-“ equivale a
um arquivo.
Repare agora que no restante da string temos 9 caracteres. Você já sabe o que significa o
primeiro. Os demais são subdivididos em 3 grupos de 3 caracteres, cada um representado o
proprietário, o grupo e todos os demais respectivamente. Pegando a linha 2 do exemplo (-rw-rw-r-)
e dividindo a string em 3 partes, ficaria assim:
• rw- => indicação de permissões do proprietário
• rw- => permissões do grupo que o usuário pertence
• r-- => permissões para os demais usuários
Onde:
• r => leitura (read);
• w => gravação (write);
• x => execução (execution);
• - => sem permissão.

2.3 Comandos básicos

Uma das primeiras coisas que você deve ter bem clara em mente é que o Linux é case-sensitive,
ou seja, letras maiúsculas e minúsculas fazem bastante diferença. “PaLaVRA” é bem diferente de
“palavra”. Por essa razão, a grande maioria dos comandos são com letra minúscula, para seguir
uma espécie de padrão.

7
Abaixo segue uma lista de comandos básicos. Deve se atentar para o fato que cada comando
desses pode possuir vários parâmetros. Em caso de dúvida, digite “man comando” e a página do
manual do comando em questão será exibida.

ls Lista os arquivos, mesmo que dir do DOS.

rm remove arquivos, no formato: rm (arquivo1) [arquivo2] [arquivo3] ...
Exemplo: rm eu.doc / rm leiame.txt manual.html win95.w95
A forma mais utilizada é o “rm –rf arquivo”, para apagar diretórios cheios e
qualquer outra coisa.
cp Copia arquivos, no formato: cp (arquivo1)[arquivo2][...] (destino)
Exemplo: cp teste.doc /home/user/
mv Move ou renomeia um arquivo.
Exemplo: mv arquivo.txt /root -> move o arquivo.txt para o diretório /root
mv arquivo.txt arquivo2.txt -> renomeia arquivo.txt para
arquivo2.txt
cat mostra o conteúdo do arquivo, mesmo que o 'type' no DOS. Deve ser usado
com cautela – se o arquivo for muito grande ou for um arquivo binário, o
resultado pode não ser o esperado.
Exemplo: cat teste.php
more Exibe o conteúdo de um arquivo ou a saída de um comando, página a
página, como no DOS. Como o cat, deve ser usado com cautela.
Exemplo: ls | more
more file.txt
pwd Exibe o diretório em que você se encontra
mkdir Cria um diretório: mkdir nome-do-dir
Exemplo: mkdir teste
clear Limpa a tela
exit / logout Saem da sessão atual
cd Muda para o diretório especificado, igual ao DOS
grep Procura uma string no stream especificado, pode ser por exemplo em uma
saída de um “cat file”.
Exemplo: cat arquivo.txt | grep testando
tar Descompactador/Compactador de arquivos .tgz e .tar.gz. Utiliza-se:
tar –zxvf arquivo.tar.gz -> descompacta o volume arquivo.tar.gz
tar –zcvf userhome.tgz /home/usuario -> cria o volume userhome.tgz a partir
do diretório /home/usuário
date Exibe a data e hora.
pico É um editor básico do modo texto no Linux. Existem vários, talvez o mais
conhecido seja o “vi”, entretanto ele acaba se tornando muito confuso para
quem está iniciando, então quando necessário iremos utilizar o pico.
startx Inicia a sessão do ambiente gráfico no linux (o ambiente gráfico deve estar
devidamente configurado para que funcione).
ps -awx Mostra processos rodando no momento. É importante para que possamos
monitorar um processo e para finalizarmos um processo com problemas.
kill Mata um processo. Precisamos saber o PID do processo para o kilarmos.
Exemplo: kill -9 1012 -> mata o processo de PID 1012
killall Mata um processo pelo nome. Se um processo com aquele nome não existir,
uma mensagem é exibida.
Exemplo: killall -9 mysqld -> mata o processo chamado mysqld.
netstat -vat Mostra portas abertas e conexões ativas no momento.
ln -s Cria um link simbólico (um atalho) para uma pasta ou arquivo.
Exemplo: ln –s diretório-real-source nome-atalho
df Mostra informações sobre hd´s (espaço livre e usado)
ifconfig Mostra informações sobre a placa de rede (se houver uma)
lynx, links Navegadores (browser) em modo texto

8
2.4 Montando/Desmontando volumes
Para acessar um cd-rom ou disquete, você precisa primeiro montar o drive em algum diretório
para que ele se torne acessível.

Montando Cd´s

Já com o cd no driver, utilize o comando mount da seguinte maneira:

shell> mount /dev/cdrom /mnt/cdrom

Lembrando que na instalação padrão do Slackware você só pode utilizar o comando mount se
estiver logado como o superusuário (root).
Também vale lembrar que o diretório /mnt/cdrom já é criado na instalação padrão do Slackware,
porém em outras distribuições isso pode sofrer algumas alterações.

Para retirar o cd, você precisa desmontar o drive antes, através do comando umount:

shell> umount /dev/cdrom

Montando Disquetes

Com o disquete no drive, utilize o comando mount da seguinte maneira:

shell> mount /dev/floppy /mnt/floppy

E após a utilização, antes de retirar o disquete, desmonte o drive utilizando o comando umount:

shell> umount /dev/floppy

2.5 Instalando programas

Ao instalar programas no linux, devemos ter sempre em mente que é imprescindível ler os
arquivos de instalação e documentação que sempre acompanham os programas. Ler com calma
um INSTALL.txt pode poupar você de muita dor de cabeça!

A maioria dos programas atuais pode ser instalada com três comandos:

shell> ./configure
shell> make
shell> make install

O ./configure irá gerar um arquivo Makefile com os caminhos de bibliotecas e outras definições
específicas do seu sistema necessárias para compilar o programa. Alguns programas mais
complexos precisam de vários parâmetros no configure. Por isso é muito importante ler o arquivo
de instalação.

O make irá compilar o programa, e o make install colocará os executáveis, bibliotecas e outros
arquivos nos locais corretos do sistema para serem utilizados.

2.5.1 – Instalação do Servidor WEB

Para começarmos a trabalhar com o PHP, precisamos primeiro deixar nosso servidor WEB pronto
e preparado para interpretar os códigos que vamos escrever. Para tanto, precisamos instalar 3
coisas distintas, que trabalharão integrados: Servidor WEB (Apache), PHP e Banco de
Dados(MySQL).
9
Esta instalação foi feita em um Linux Slackware 10.
Faremos um passo-a-passo da instalação desses softwares no Linux.

Primeiramente, faça o download dos três programas:

Apache 2 - http://www.apache.org
PHP – http://www.php.net
MySQL – http://dev.mysql.com

Descompacte o PHP e o Apache no diretório /root.

shell> tar -zxvf httpd-versao.tar.gz

shell> tar -zxvf php-versao.tar.gz
Descompacte o MySQL no diretório /usr/local:

shell> mv mysql-versao.tar.gz /usr/local

shell> cd /usr/local
shell>tar -zxvf mysql-versao.tar.gz

Instalação do MySQL

Crie um link simbólico para o MySQL no diretório /usr/local:

shell> ln -s /usr/local/mysql-versao /usr/local/mysql

Execute os comandos necessários para a instalação (criação de usuários, bases etc)

shell> groupadd mysql

shell> useradd -g mysql mysql
shell> cd /usr/local/mysql
shell> sh scripts/mysql_install_db --user=mysql
shell> chown -R root .
shell> chown -R mysql data
shell> chgrp -R mysql .
shell> bin/mysqld_safe --user=mysql &

Instalação do Apache

Após entrar no diretório do Apache:

shell> ./configure --prefix=/usr/local/apache --enable-so

shell> make
shell> make install

Instalação do PHP
Após entrar no diretório do PHP:
shell>./configure --with-apxs2=/usr/local/apache/bin/apxs --with-mysql
shell> make
shell> make install

Após a instalação, é necessário copiar o arquivo php.ini para o diretório de bibliotecas:

shell> cp php.ini-recommended /usr/local/lib/php.ini

10
Agora, é necessário fazer alguns ajustes no arquivo de configuração do Apache. Abra o arquivo
httpd.conf, que deve estar no diretório /usr/local/apache/conf:
shell> pico /usr/local/apache/conf/httpd.conf

Adicione a seguinte linha: (isso fará o servidor interpretar arquivos .php e .phtml como scripts php)
AddType application/x-httpd-php .php .phtml

Você pode alterar outras configurações do arquivo httpd.conf para atender melhor às suas
necessidades.
É importante verificar as configurações para o “DocumentRoot”, que é a pasta onde serão
servidos os arquivos para sua página.

Agora, o seu servidor WEB já deverá estar pronto para rodar. Inicie o daemon através do
comando:

shell> /usr/local/apache/bin/apachectl start

Obs: Este comando deverá ser executado sempre que o seu servidor reiniciar, portanto é
necessário adicionar essa linha (e a do MySQL também) aos scripts de inicialização(comumente
/etc/rc.d/rc.local ).

2.5.2 - Programas auxiliares ao desenvolvimento

Para auxiliar no desenvolvimento de aplicações WEB, precisaremos de algumas ferramentas

como editores PHP e Html, programas gráficos etc. Para este curso, fizemos uma seleção de
alguns excelentes programas gratuitos e a maioria open source, todos para linux, e alguns com
versões também para Windows.

A instalação desses programas é simples, dê uma olhada no arquivo INSTALL que vem em cada
um deles, e você não encontrará problemas para instala-los.

Edição Html e PHP

• BlueFish – http://bluefish.openoffice.nl
• Quanta – http://quanta.kdewebdev.org
• Eclipse – http://www.eclipse.org

Edição Html Wysiwyg (what you see is what you get)

• NVU – http://www.nvu.com
Programas Gráficos
• GIMP – http://www.gimp.org

11
 3 – HTTP e HTML : Noções

3.1 HTTP

O HTTP (HyperText Transfer Protocol) é o protocolo responsável pelo funcionamento da World

Wide Web. Torna possível a visualização dos documentos hipermídias, como textos, gráficos,
som, imagem e outros recursos. É um protocolo relativamente simples.

O HTML é uma linguagem em forma de script, utilizada para formatar documentos para utilização
com o protocolo http. Não pode ser considerada uma linguagem de programação, pois não
oferece recursos básicos que uma linguagem de programação possui: variáveis, laços, estruturas
condicionais e etc. O código HTML é escrito através da utilização de etiquetas (tags) que definem
as diversas áreas da página (cabeçalho, título, corpo) e sua formatação.
Os arquivos html são lidos e interpretados localmente pelo programa cliente, que é o browser ou
navegador web.

3.1.2 Transação HTTP

Para que as páginas que solicitamos ao navegador sejam devidamente apresentadas para nós,
todo um processo de solicitação / resposta (request / response) é realizado:

3.2 HTML – Tags Básicas

<html> e </html>
Marca o início e o fim do documento html.

12
<head> e </head>
Marca o inicio e o fim do cabeçalho.

<title> e </title>
Marca o inicio e fim do titulo do documento.

<body> e </body>
Marca o inicio e o fim do corpo do documento.

<html>
<head>
<title>titulo da pagina, que está dentro do cabeçalho.</title>
</head>
<body>
Conteudo da pagina (corpo)
</body>
</html>

Tags de formatação

CÒDIGO RESULTADO
<b> Este texto ficará em negrito </b> Este texto ficará em negrito
<i> Este texto ficará em itálico </i> Este texto ficará em itálico
<b><i>Este texto ficará negrito e Este texto ficará negrito e itálico
itálico</i></b>

Repare que podemos utilizar tags “recursivas”, uma dentro da outra, mas temos que tomar
cuidado para fecharmos essas tags de dentro para fora, caso contrário haverá erros na
formatação da sua página.

<font> </font>
A tag “font” é utilizada para definir a fonte e os atributos a ela relacionados, específicos do texto
que fica entre as tags. Seus atributos específicos são:

face=”fontenome” Tipo da fonte, como: Times, Arial, Verdana, Courier

size=”n”
color=”#nnnnnn”
(cor em hexadecimal)*
O padrão é a Times New Roman, porém esta fonte nunca é
recomendada para sites profissionais. As melhores opções são
fontes sem serifa, Verdana e Arial.
Ex: <font face=”verdana”>Texto em Verdana</font>
Tamanho da fonte em pixels
Ex: <font face=”verdana” size=”10”>Texto aqui</font>
Cor da fonte
Ex: <font color=”#000000”>blabla</font> ( o texto blabla ficará
preto )

<p> </p>
Define um parágrafo dentro das tags, acrescentando uma linha em branco ao fim do parágrafo. É
utilizado para especificar definições de alinhamento, através do atributo align=”forma”.
• align=”center” – alinhamento ao centro
• align=”left” – alinhamento à esquerda (padrão)
13
 • align=”right” – alinhamento à direita

<br>
Quebra de linha. Tag única.

<hn></hn>
Estilos de títulos (header). N pode ser um valor do 1 ao 6 .
Ex: <h1> Titulo </h1>

<hr>
Linha horizontal. Atributo específico: noshade (retira a somba que vem por padrão). Tag Única.
Ex: <hr noshade>
Pode ser especificado também o tamanho e a espessura, através respectivamente das tags
width=””(em pixels ou porcentagem, explicitado pelo sinal %) e size=”” (em pixels).

Imagens

As páginas html, por serem apenas uma seqüência de etiquetas especificadoras, não armazenam
em si próprias as imagens que são exibidas por elas. Dessa forma, o que temos realmente na
página html é um link para a imagem, identificado pela tag IMG, para que no momento em que o
navegador encontrar esta tag, ao invés de apresentar ao usuário o link da imagem(como faria
para um link comum), ele baixe a imagem do servidor e a mostre na tela do usuário, aonde o
script html especifica que ela deve aparecer. A tag IMG é uma tag única, ou seja, não precisa ser
fechada com outra tag. Suporta imagens GIF, JPG e PNG. A imagem aparecerá exatamente no
local onde a tag for colocada. O Atributo específico da tag IMG é o SRC=”imagem”, onde
“imagem” pode ser o caminho relativo do script até a imagem ou um caminho http completo.
Exemplos:

<img src=”linuxfi.gif”> /* a imagem deve estar no mesmo diretório do

arquivo html */
<img src=”imagens/linuxfi.jpg”> /* a imagem deve estar no subdiretório
imagens, da pasta onde o script está */
<img src=”http://www.linuxfi.com.br/imagens/linuxfi.jpg”> /* a imagem
deve estar no endereço especificado */

Links

Os links especificam um texto que, ao ser clicado pelo usuário, fará com que o endereço atribuído
seja aberto no navegador, na mesma janela(por padrão) ou em uma nova janela. É importante
colocar o endereço completo (com o http://) se você estiver querendo direcionar o usuário para um
site externo, pois qualquer coisa sem http:// ou ftp:// na frente será compreendido como um
endereço relativo, de dentro do seu site. Caso o documento apontado não seja um arquivo
interpretável pelo navegador, este perguntará ao usuário se deseja fazer download do documento.

<a href=”http://www.linuxfi.com.br”>Clique Aqui!</a> // o texto “Clique Aqui!” aparecerá com um

link para http://www.linuxfi.com.br. Ao clicar no link, a página especificada será aberta na janela do
documento atual.

<a href=”http://www.linuxfi.com.br” target=”_blank”>Clique Aqui!</a> // A diferença aqui é que ao

clicar no link, uma nova janela do navegador será aberta com a página especificada.

14
Atributos Gerais

Os atributos são utilizados dentro das tags para definirem a formatação daquela área ou objeto na
página. Alguns atributos apenas se aplicam a determinados objetos, e colocá-los em outras tags
não fará nenhuma diferença na aparência da página. Porém muitos atributos se aplicam a vários
objetos diferentes:

bgcolor=”#nnnnnn” Cor de fundo – utilizada em tags como: <body>, <table>, <tr>,

(cor em hexadecimal)* <td>
Ex: <body bgcolor=”#FFFFFF”> (define cor de fundo branca
p/ corpo da pagina)

color=”#nnnnnn” Cor do objeto – utilizada em tags como <font>, <hr>

(cor em hexadecimal)*
Ex: <font color=”#000000”>blabla</font> ( o texto blabla ficará
preto )

background=”imagem.gif” Define uma imagem “imagem.gif” de fundo. Usada em tags:

(caminho da imagem <body>, <td>
relativo ao arquivo, ou
endereço web completo do
Ex: <body background=”linuxfi.gif”> (coloca a imagem
arquivo)
linuxfi.gif como fundo do arquivo)

bgproperties=”fixed” Mantém fixa a imagem de fundo da página, de modo que

quando ela é “rolada” a imagem não se mexe, criando efeito
de marca dágua.
Ex: <body background=”linuxfi.gif” bgproperties=”fixed”>

width=”” Tamanho Horizontal, em pixels ou porcentagem(especificada

com o sinal %). Utilizado para tags <table>, <td>, <hr>
Ex: <td width=”100%”> teste </td>

height=”” Tamanho Vertical(Altura), em pixels ou porcentagem.

Utilizado para tags <table>, <td>.
Ex: <td height=”2” width=”100”> teste </td>
*As cores no HTML são especificadas através de uma notação Hexadecimal que vai do #FFFFFF
(branco) ao #000000 (preto), mas você pode utilizar a notação de cores pelo nome (para as cores
mais comuns) – black, red, blue, green, white, etc.

Tabelas
Talvez uma das coisas mais complexas de serem entendidas inicialmente no html sejam as
tabelas. Você tem que imaginar uma tabela de forma dividida, em várias células. Cada célula de
uma tabela é uma TD, e cada linha (TR) pode conter várias células. Mas o padrão é que o número
de células seja igual para cada linha. Caso você queira unir duas ou mais células, precisará
utilizar o atributo “colspan”.
Cada célula pode ter seus próprios atributos, como cor ou imagem de fundo, largura, altura,
alinhamento.

Exemplo de tabela:

<table width=”100%” bgcolor=”#000000” cellspacing=”1” cellpadding=”0”>

<tr>
<td bgcolor=”#FFFFFF”>Esta é a célula 1, ou seja, a coluna 1 da
primeira linha</td>
<td bgcolor=”#FFFFFF”>Esta é a célula2, ou seja, a coluna 2 da

15
primeira linha</td>
</tr>
<tr>
<td bgcolor=”#FFFFFF”>Esta é a célula 1, ou seja, a coluna 1 da
segunda linha</td>
<td bgcolor=”#FFFFFF”>Esta é a célula2, ou seja, a coluna 2 da
segunda linha</td>
</tr>
</table>

Este código produzirá um resultado semelhante a este:

Esta é a célula 1, ou seja, a coluna 1 da Esta é a célula2, ou seja, a coluna 2 da

primeira linha primeira linha
Esta é a célula 1, ou seja, a coluna 1 da Esta é a célula2, ou seja, a coluna 2 da
segunda linha segunda linha

A borda preta foi produzida pelo efeito criado do fundo da tabela ser preto, e o fundo das células
ser branco, utilizando-se um espaçamento de tamanho 1 de uma célula para outra (gera uma
borda preta).

16
 4 – Iniciando em PHP
Com o PHP, temos uma grande variedade de possibilidades, e o melhor de tudo é que suas
aplicações ficam muito mais “limpas” e legíveis do que aquelas escritas com CGI ou Perl, onde
você precisa escrever um programa com uma série de comandos para poder exibir HTML. O PHP
é mesclável e você pode intercalar com tranqüilidade blocos de código html com blocos de código
php, e ainda pode escrever linhas html como também javascripts, dentro do bloco php.
Além disso, com o PHP você não gera apenas html, pode gerar também documentos pdf,
imagens e até mesmo animações flash, utilizando algumas bibliotecas específicas.

4.1 Primeira página

Vamos colocar no ar nossa primeira página usando PHP. Estamos partindo do pressuposto de
que o seu servidor WEB esteja funcionando e interpretando corretamente as páginas .php como
scripts php.

Crie um arquivo chamado “ola.php” no diretório base do seu servidor WEB (Document_root) com
o seguinte conteúdo:

<html>
<head>
<title>PHP Teste</title>
</head>
<body>
<?php echo "<p>Olá Mundo</p>"; ?>
</body>
</html>

Vá agora até o seu navegador(netscape, mozilla... recomenda-se a utilização do ambiente gráfico

para uma melhor visualização, contudo é possível visualizar através do lynx ou links em modo
texto.) e digite o http://endereço-do-seu-servidor/ola.php para visualizar o resultado. Se você está
usando o servidor local, o endereço será: http://localhost/ola.php ou http://127.0.0.1/ola.php .

Esse script é extremamente simples, talvez a coisa mais simples possível de se fazer com PHP, e
você realmente não precisa usar PHP para gerar esse resultado, com HTML puro você poderia
fazer a mesma coisa. O objetivo aqui é apenas mostrar a aparência básica do código php:
mesclado no meio do html, onde você quiser que a operação e a saída seja gerada, entre as tags
identificadoras “<?php” que abre o bloco e “?>” que fecha o bloco.

Se você tentar rodar este exemplo e ele não mostrar nenhuma mensagem de saída, aparecer
uma caixa de diálogo pedindo para você salvar o arquivo, ou você ver o arquivo em formato de
texto, provavelmente o seu servidor web não está habilitado para interpretar códigos PHP.
Possivelmente houve alguma falha na sua instalação. Dê uma examinada mais atenta à
documentação para encontrar o que pode estar ocasionando o problema.

4.2 PHP: Sintaxe básica

4.2.1 Tags

Quando o PHP interpreta um arquivo, ele simplesmente repassa o texto do arquivo até encontrar
uma das tags especiais que lhe diz para começar a interpretar o texto como código PHP. O
interpretador então executa todo o código que encontra, até chegar em uma tag de fechamento

17
PHP, que novamente o coloca simplesmente repassando texto novamente. Este é o mecanismo
que permite a inclusão de código PHP dentro do HTML: qualquer coisa fora das tags PHP é
deixado como encontrado, enquanto tudo dentro é interpretado e executado.

Há quatro conjuntos de tags que podem ser usadas para marcar blocos de código PHP. Delas,
somente duas (<?php. . .?> e <script language="php">. . .</script>) são sempre disponíveis. As
outras podem ser ativadas ou desativadas a partir do arquivo de configuração php.ini. Enquanto
as formas reduzidas das tags ou no seu estilo ASP serem convenientes, elas não são portáveis
em todas as versões. Além disso, se você pretende incluir código PHP em XML ou XHTML, você
precisará usar a forma <?php ... ?> para compatibilidade com o padrão XML.

No nosso curso, vamos sempre utilizar o padrão, que é a forma: <?php ... ?> .

A tag de fechamento incluirá uma nova linha em branco automaticamente se uma não estiver
presente. Além disso, a tag de fechamento automaticamente implica num ponto e vírgula: você
não precisa ter um ponto e vírgula no fim da última linha de código PHP. Fechar o bloco de PHP
no final do arquivo é opcional.

PHP também suporta a utilização de estruturas como essa:

<?php
if ($expression) {
?>
<strong>Isso é verdadeiro.</strong>
<?php
} else {
?>
<strong>Isto é falso.</strong>
<?php
}
?>

Isso funciona como esperado porque quando o PHP encontra a tag de fechamento ?>, ele
simplesmente começa a imprimir tudo até encontrar outra tag de abertura. Obviamente, o exemplo
acima se aplica a exibição de grandes blocos de texto, uma vez que sair do modo de interpretação
do PHP é geralmente mais eficiente que imprimir todo o texto através de funções como “echo”.

4.2.2 Separador de instruções

Instruções são separadas da mesma forma que o C ou o Perl - cada instrução termina com um
ponto e vírgula.

A tag de fechamento (?>) também implica no fim de uma instrução, então os exemplos seguintes
são equivalentes:

<?php
echo "Isto é um teste";
?>

<?php echo "Isto é um outro teste" ?>

18
4.2.3 Comentários

O PHP suporta comentários do 'C', 'C++' e Unix shell. Por exemplo:

<?php
echo "Isto é um teste"; //Comentário de uma linha no C++

/* Isto é um comentário de mais de uma linha

e aqui temos outra linha */

echo "Isto é um outro teste";

echo "O último teste"; #Comentário no estilo Unix shell
?>

Os comentários de uma linha só têm efeito até o fim da linha ou fim do bloco de código PHP atual,
o que ocorrer primeiro.

4.3 Tipos
O Php suporta oito tipos primitivos:

São quatros tipos básicos:

• boolean – pode ser apenas TRUE e FALSE.

• integer – números inteiros

Atribuições possíveis para números inteiros:

$php = 1234; // inteiro positivo na base decimal

$php = -234; // inteiro negativo na base decimal
$php = 0234; // inteiro na base octal-simbolizado pelo 0
// equivale a 156 decimal
$php = 0x34; // inteiro na base hexadecimal(simbolizado
// pelo 0x) - equivale a 52 decimal.

A diferença entre inteiros simples e long está no número de bytes utilizados para
armazenar a variável. Como a escolha é feita pelo interpretador PHP de maneira transparente
para o usuário, podemos afirmar que os tipos são iguais.

• float - números de ponto flutuante, ou também 'double':

$php = 1.234;
$php = 23e4; // equivale a 230.000

• string – conjuntos de caracteres: “Curso de PHP”. É por natureza um tipo ARRAY.

Strings podem ser atribuídas de duas maneiras:

a) 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)

19
b) utilizando aspas duplas ( " ) - Desta maneira, qualquer variável ou caracter de escape será expandido
antes de ser atribuído.
Exemplo:

<?
$teste = "Brasil";
$php = '---$teste--\n';
echo "$php";
?>
A saída desse script será "---$teste--\n".

<?
$teste = "Brasil";
$php = "---$teste---\n";
echo "$php";
?>

A saída desse script será "---Brasil--" (com uma quebra de linha no final).

A tabela seguinte lista os caracteres de escape:

Sintaxe Significado
\n Nova linha
\r Retorno de carro (semelhante a \n)
\t Tabulação horizontal
\\ A própria barra ( \ )
\$ O símbolo $
\’ Aspa simples
\” Aspa dupla

Dois tipos compostos:

• array – arranjos ou matrizes.

• object – utilizado para programação orientada a objeto.

E finalmente dois tipos especiais:

• resource - utilizado para recursos da linguagem, como manipulação de arquivos,

conexão com banco de dados, por isso não se pode converter um valor para o tipo
resource.

• NULL – comporta apenas o valor “NULL”, insensitive. Está presente em variáveis que
não receberam nenhum valor, apagadas com unset() ou setadas explicitamente para
NULL.

O tipo da variável geralmente não é configurado pelo programador: isto é decidido em tempo de
execução pelo PHP, dependendo do contexto no qual a variável é usada. Porém, existem
maneiras de forçar um tipo específico, ou verificar o tipo da variável, utilizando funções específicas
como gettype(), ou is_type();

4.4 Transformação de tipos

20
A transformação de tipos em PHP pode ser feita das seguintes maneiras:

Coerções

Quando ocorrem determinadas operações (“+”, por exemplo) entre dois valores de tipos
diferentes, o PHP converte o valor de um deles automaticamente (coerção). É interessante notar
que 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.

Exemplo:
$php = “1”; // $php é a string “1”
$php = $php + 1; // $php é o integer 2
$php = $php + 3.7;// $php é o double 5.7
$php = 1 + 1.5 // $php é o double 2.5

Como podemos notar, o PHP converte string para integer ou double mantendo o valor. O sistema
utilizado pelo PHP para converter de strings para números é o seguinte:

• É 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á 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.

Exemplos:
$php = 1 + “10.5”; // $php == 11.5
$php = 1 + “-1.3e3”; // $php == -1299
$php = 1 + “teste10.5”; // $php == 1
$php = 1 + “10testes”; // $php == 11
$php = 1 + " 10testes"; // $php == 11
$php = 1 + "+ 10testes"; // $php == 1

Transformação explícita de tipos

A sintaxe do typecast de PHP é semelhante ao C: basta escrever o tipo entre parênteses antes do
valor.

Exemplo:
$php = 15; // $php é integer (15)
$php = (double) $php // $php é double (15.0)
$php = 3.9 // $php é double (3.9)
$php = (int) $php // $php é integer (3)
// o valor decimal é truncado

Os tipos de cast permitidos são:

21
(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:
$php = 15; // $php é integer
settype($php,double) // $php é double

4.5 Variáveis
As variáveis no PHP são representadas por um cifrão ($) seguido pelo nome da variável. Os
nomes de variáveis no PHP fazem distinção entre maiúsculas e minúsculas.

Nomes de variáveis válidos em PHP seguem o padrão da maioria das linguagens de

programação: devem iniciar com uma letra ou underline ( _ ), seguidos por letras, números ou
underlines.

<?php
$var = "Bob";
$Var = "Joe";
echo "$var, $Var"; // exibe "Bob, Joe"

$4site = 'not yet'; // inválido; começa com um número

$_4site = 'not yet'; // válido; começa com um sublinhado
?>

Existem dois tipos de atribuição a variáveis: por valor e por referência. Na atribuição por valor, a
variável recebe uma cópia do conteúdo real que lhe é atribuído. Ou seja, caso haja uma alteração
no valor da variável ‘original’, o valor da variável copiada continuará o mesmo, não sofrerá
alteração nenhuma.

Na atribuição por referência, a variável se torna um ponteiro para o valor atribuído. Isso significa
que ela na verdade estará apontando para uma posição da memória que corresponde a outra
variável, e se esse valor for modificado, a variável ponteiro estará apontando para o novo valor, e
ao utilizarmos a mesma, seu conteúdo terá sido atualizado. Da mesma forma, se você alterar o
conteúdo da variável ponteiro, estará na verdade alterando o conteúdo da variável real.

A atribuição padrão feita no PHP é feita por valor. Mas você tem a opção (a partir do PHP 4) de
atribuir valores por referência a uma variável. Exemplos:

<?php
$foo = 'Bob'; // Atribui o valor 'Bob' a variável $foo
$bar = &$foo; // Referecia $foo através de $bar.
$bar = "My name is $bar"; // Altera $bar...

22
echo $bar;
echo $foo; // $foo é alterada também.
?>

Uma observação importante a se fazer: somente expressões nomeadas podem ser atribuídas
por referência.

<?php
$foo = 25;
$bar = &$foo; // Esta atribuição é válida.
$bar = &(24 * 7); // Inválido; referencia uma expressão sem nome.

function test()
{
return 25;
}

$bar = &test(); // Inválido.

?>

Escopo de Variáveis

O escopo de uma variável é o contexto onde ela foi definida, e em que parte de código ela é
válida. A maior parte das variáveis do PHP tem somente escopo local. Quando criadas, elas são
válidas daquele ponto da página até o final do documento.

Dentro de funções o escopo das variáveis também é local por padrão, isso significa que uma
variável normal utilizada dentro de uma função não estará disponível para o restante do script.
Existe porém o modificador GLOBAL, que modifica o escopo da variável e a torna global (válida
em qualquer parte do script). Exemplo:

<?php
$a = 1;
$b = 2;

function Soma(){
global $a, $b;

$b = $a + $b;
}

Soma();
echo $b;
?>

O script acima imprimirá “3”. Declarando $a e $b globais na função, todas as referências a essas
variáveis referem-se à sua versão global.

4.6 Arrays
Arrays em PHP podem ser observados como mapeamentos ou como vetores indexados. Mais
precisamente, um valor do tipo array é um dicionário onde os índices são as chaves de acesso.

23
Vale ressaltar que os índices podem ser valores de qualquer tipo e não somente inteiros.
Inclusive, se os índices forem todos inteiros, estes não precisam formar um intervalo contínuo.

Como a checagem de tipos em PHP é dinâmica, valores de tipos diferentes podem ser usados
como índices de array, assim como os valores mapeados também podem ser de diversos tipos. É
importante notar que para índices string, devemos utilizar aspas ou apóstrofes, caso contrário o
interpretador entenderá que se trata de uma constante. Variáveis também podem ser utilizadas
como índice.

Exemplo:
<?
$indice=”teste2”;

$cor[1] = "vermelho";
$cor[2] = "verde";
$cor[3] = "azul";
$cor[‘teste’] = 1;
$cor[$indice] = 2;
?>

Arrays Multidimensionais
Podemos criar arrays multidimensionais, que podem ser vistos como matrizes de ordens variadas.
Exemplo:

<?php

$matriz[1][‘cor’] = “vermelho”;
$matriz[1][‘codigo’] = “1053”;
$matriz[1][‘preco’] = “45,00”;

$matriz[2][‘cor’] = “azul”;
$matriz[2][‘codigo’] =”1054”;
$matriz[2][‘preco’] = “39,90”;

Esse recurso do PHP que, diferentemente de C, pode mesclar tipos diferentes de dados em um
único array, é muito útil para criar estruturas de dados.

4.7 Constantes
Uma constante é um identificador (nome) para um único valor. Como o nome sugere, esse valor
não pode mudar durante a execução do script . Por convenção, o nomes de constantes são
sempre em maiúsculas. Elas são definidas através da função define().

O nome de uma constante tem as mesmas regras de qualquer identificador no PHP. Somente
dados escalares (boolean, integer, float e string) podem ser colocados em constantes.

Você pode obter o valor de uma constante simplesmente especificando seu nome. Diferentemente
de variáveis, você não pode prefixar uma constante com um sinal de $.

Nota: As constantes e variáveis (globais) estão em espaços de nomes diferentes. Isto implica, por
exemplo, que TRUE e $TRUE são geralmente diferentes.

Estas são as diferenças entre constantes e variáveis:

24
• Constantes não podem ter um sinal de cifrão ($) antes delas;

• Constantes só podem ser definidas utilizando a função define(), e não por simples
assimilação;

• Constantes podem ser definidas e acessadas de qualquer lugar sem que as regras de escopo
de variáveis sejam aplicadas;

• Constantes não podem ser redefinidas ou eliminadas depois que elas são criadas;

• Constantes só podem conter valores escalares.

<?php
define("CONSTANT", "Hello world.");
echo CONSTANT; // imprime "Hello world."
echo Constant; // imprime "Constant" e gera um alerta notice.

?>

4.8 Variáveis Pré-Definidas - SuperGlobais

As variáveis pré-definidas do PHP são superglobais, ou seja, são válidas em qualquer escopo do
programa. Você não pode utilizar os nomes das superglobais como identificadores para variáveis
e algumas delas, como a $_SERVER, não podem ser modificadas diretamente por você, pois
dependem de configurações no servidor.

$GLOBALS

Contém um referência para todas as variáveis que são atualmente disponíveis dentro do escopo
global do script. As chaves desse array são os nomes das variáveis globais. $GLOBALS existe
desde o PHP 3.

$_SERVER

Variáveis criadas pelo servidor web ou diretamente relacionadas ao ambiente de execução do

script atual. Exemplos:

• $_SERVER[‘PHP_SELF'] – Refere-se ao nome do arquivo de script atualmente em

uso.

• $_SERVER[‘REMOTE_ADDR'] – O Endereço IP que requisitou a conexão http.

$_GET

Variáveis postadas para o script via método HTTP GET.

$_POST

Variáveis postadas para o script via método HTTP POST.

$_COOKIE

25
Variáveis postadas para o script via cookies HTTP.

$_FILES

Variáveis postadas para o script via transferência de arquivos HTTP.

$_ENV

Variáveis disponíveis no script do ambiente de execução.

$_REQUEST

Variáveis postadas para o script por todos os mecanismos de input(GET, POST, e COOKIE).

$_SESSION

Variáveis que estão atualmente registradas na sessão do script.

26
 5 – Funções de Saída

5.1 echo
exibe uma ou mais strings.

echo “Isso é um exemplo com echo, usando aspas.”;

$var=”ok”;
echo “Ele também imprime variáveis, $var”; /*imprime o texto: Ele também
imprime variávies, ok*/

5.2 printf
exibe uma string formatada. As strings passadas podem ser indexadas para que não seja
necessário repeti-las ou coloca-las na ordem exata em que irão aparecer na string formatadora.

<?php
printf("O %s contém %d portas",$comodo,$portas);
?>

<?php
$format = "O %2\$s contém %1\$d portas.
É um ótimo %2\$s com %1\$d portas.";
printf($format, $portas, $comodo);
?>

27
 6 – Expressões

Expressões são as peças de construção mais importantes do PHP e na maioria das linguagens de
programação. No PHP, quase tudo o que você escreve são expressões. A maneira mais simples e
ainda mais precisa de definir uma expressão é "tudo o que produz/tem um valor".

As formas mais básicas de expressões são constantes e variáveis. Quando você digita "$a = 5",
você está atribuindo '5' para $a. '5', obviamente, tem o valor 5, ou, em outras palavras, '5' é uma
expressão com o valor 5 (neste caso, '5' é uma constante inteira).

Depois desta atribuição, você pode esperar que o valor de $a seja 5 também, assim se você
escrever $b = $a, você pode esperar que $b se comporte da mesma forma que se você
escrevesse $b = 5. Em outras palavras, $a é uma expressão com valor 5 também.

Obviamente, os valores em PHP não têm que ser inteiros, e muito freqüentemente eles não são.
O PHP suporta três tipos de valores escalares: valores inteiros, valores de ponto flutuante e
valores de string (valores escalares são valores que você não pode quebrar em pedaços menores,
diferente de matrizes, por exemplo). O PHP também suporta dois tipos compostos (não-
escalares): matrizes e objetos. Cada um destes tipos de valor podem ser atribuídos a variáveis ou
retornadas de funções.

Um tipo muito comum de expressão são expressões de comparação. Estas expressões são
avaliadas como 0 ou 1, significando FALSE ou TRUE, respectivamente. Este tipo de expressão é
quase sempre utilizado em laços e estruturas condicionais (while, for, if).

6.1 Operadores
Operadores de Atribuição

O operador básico de atribuição é "=". A sua primeira inclinação deve ser a de pensar nisto como
"é igual". Não. Isto quer dizer, na verdade, que o operando da esquerda recebe o valor da
expressão da direita (ou seja, "é configurado para").

$a = 5; // A variável $a recebe o valor 5.

$a=$b; // A variável $a recebe o valor de $b.

Operadores Aritméticos

Lembra-se da aritmética básica da escola? Estes operadores funcionam exatamente como

aqueles.

Exemplo Nome Resultado

$a + $b Adição Soma de $a e $b.
$a - $b Subtração Diferença entre $a e $b.
$a * $b Multiplicação Produto de $a e $b.
$a / $b Divisão Quociente de $a por $b.
$a % $b Módulo Resto de $a dividido por $b.

O operador de divisão ("/") sempre retorna um valor com ponto flutuante, mesmo que os dois
operandos sejam inteiros (ou strings convetidos para inteiros).

28
Existem ainda alguns operadores combinados de atribuição e operação aritmética, iguais aos
existentes na linguagem C:

Exemplo Tipo Significado

$a += $b Adição $a = $a + $b
$a -= $b Subtração $a = $a - $b
$a *= $b Multiplicação $a = $a * $b
$a /= $b Divisão $a = $a / $b
$a =% $b Módulo $a = $a % $b

Operadores de Comparação

Operadores de comparação, como os seus nomes implicam, permitem que você compare dois
valores.

Exemplo Nome Resultado

$a == $b Igual Verdadeiro (TRUE) se $a é igual a $b.
Verdadeiro (TRUE) se $a é igual a $b, e eles são do mesmo tipo
$a === $b Idêntico
(somente para PHP4).
$a != $b Diferente Verdadeiro se $a não é igual a $b.
$a <> $b Diferente Verdadeiro se $a não é igual a $b.
Verdadeiro de $a não é igual a $b, ou eles não são do mesmo tipo
$a !== $b Não idêntico
(somente para o PHP4).
$a < $b Menor que Verdadeiro se $a é estritamente menor que $b.
$a > $b Maior que Verdadeiro se $a é estritamente maior que $b.
Menor ou
$a <= $b Verdadeiro se $a é menor ou igual a $b.
igual
Maior ou
$a >= $b Verdadeiro se $a é maior ou igual a $b.
igual

Operadores de Incremento/Decremento

O PHP suporta operadores de pré e pós-incremento e decremento no estilo C.

Exemplo Nome Efeito

++$a Pré-incremento Incrementa $a em um, e então retorna $a.
$a++ Pós-incremento Retorna $a, e então incrementa $a em um.
--$a Pré-decremento Decrementa $a em um, e então retorna $a.
$a-- Pós-decremento Retorna $a, e então decrementa $a em um.

Em PHP, como em C, há dois tipos de incremento - pré-incremento e pós-incremento. Tanto o

pré-incremento quanto o pós-incremento, essencialmente, incrementam as variáveis, e o efeito
sobre a variável é idêntico. A diferença é com o valor da expressão de incremento. O pré-
incremento, que é escrito '++$variavel', é avaliado como o valor de incremento (o PHP incrementa
a variável antes de ler seu valor, por isso o nome pré-incremento). O pós-incremento, que é
escrito '$variavel++' é avaliado como o valor original da variável, antes de ser incrementada (o
PHP incrementa a variável depois de ler seu valor, por isso o nome 'pós-incremento').

Este exemplo ajudará você a entender melhor a diferença entre eles:

29
<?php
function double($i)
{
return $i*2;
}
$b = $a = 5; /* atribui o valor cinco às variáveis $a e $b */
$c = $a++; /* pós-incremento, atribui o valor original de $a
(5) para $c */
$e = $d = ++$b; /* pré-incremento, atribui o valor incrementado de
$b (6) a $d e $e */

/* neste ponto, tanto $d quanto $e são iguais a 6 */

$f = double($d++); /* atribui o dobro do valor de $d antes

do incremento, 2*6 = 12 a $f */
$g = double(++$e); /* atribui o dobro do valor de $e depois
do incremento, 2*7 = 14 a $g */
$h = $g += 10; /* primeiro, $g é incrementado de 10 e termina com o
valor 24. o valor da atribuição (24) é
então atribuído a $h, e $h termina com o valor
24 também. */

?>

Operadores Lógicos

Os operadores lógicos são muito usados para comparações. Eles são muito importantes, podem
reduzir a quantidade de estruturas encadeadas, facilitando a programação.
Exemplo Nome Resultado
Verdadeiro (TRUE) se tanto $a quanto $b são
$a and $b E
verdadeiros.
$a or $b OU Verdadeiro se $a ou $b são verdadeiros.
Verdadeiro se $a ou $b são verdadeiros, mas não
$a xor $b XOR
ambos.
! $a NÃO Verdadeiro se $a não é verdadeiro.
$a && $b E Verdadeiro se tanto $a quanto $b são verdadeiros.
$a || $b OU Verdadeiro se $a ou $b são verdadeiros.

A razão para as duas variantes dos operandos "and" e "or" é que eles operam com
precedências diferentes.

Operadores de String

Há dois operadores de string. O primeiro é o operador de concatenação ('.'), que retorna a

concatenação dos seus argumentos direito e esquerdo. O segundo é o operador de atribuição de
concatenação ('.='), que acrescenta o argumento do lado direito no argumento do lado esquerdo.

<?php
$a = "Olá ";
$b = $a . "mundo!"; // agora $b contém "Olá mundo!"

$a = "Olá ";
$a .= "mundo!"; // agora $a contém "Olá mundo!"
?>

30
6.2 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:

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 [

31
 7 - Formulários HTML
Os formulários constituem a mais importante ferramenta que devemos aprender sobre HTML para
trabalharmos junto ao PHP. É através dos formulários que vamos interagir com usuários,
transportando valores de uma página para outra, recebendo valores para inserção em tabelas
MySQL etc.

7.1 A Tag FORM

A tag FORM especifica início e final de um formulário. Ela deve englobar quaisquer campos de
formulário que estejam relacionados àquele formulário.
Podem existir vários FORMS dentro de uma página, mas eles não podem ser colocados dentro de
outros. Você pode ter qualquer coisa dentro de um formulário (tabelas, código php, qualquer coisa
html, javascript etc), exceto outro formulário.
Os formulários não são visualmente diferenciados do resto da página.

<FORM ACTION="url" METHOD=”post”> ... </FORM>

Atributos:

ACTION Especifica a página que receberá os dados do formulário e os tratará.

Se não for passada nenhuma ACTION, o documento atual será
utilizado.
METHOD Especifica o método que deve ser usado para enviar os dados para a
página de script. São dois métodos:
GET – o método padrão, envia as variáveis do formulário pela URL da
página de script. Você veria algo como:
http://www.linuxfi.com.br/action.php?var=valor&var2=valor2&var3=valor
3

É mais utilizado para passagens diretas de url+variáveis, sem a

necessidade de que o usuário clique em um botão submit. Não deve
ser utilizada para formulários.
POST – o mais utilizado, envia as variáveis de formulário dentro do
corpo do script action. Dessa maneira pode-se enviar textos e uma
quantidade indeterminada de campos de formulário.
ENCTYPE Utilizada para formulários que utilizam campos de envio de arquivos.
Existe apenas um valor: application/x-www-form-urlencoded .

7.2 A tag INPUT

A tag INPUT é usada para especificar um elemento de entrada simples dentro de um formulário. É
uma tag única (não há uma tag terminadora para ela).
Existem vários tipos de input, o que é definido pelo atributo INPUT.

Type=”text” Entrada de texto (padrão)

Type=”password” Entrada de texto; caracteres digitados serão representados como
asteriscos
Type=”checkbox” Botão marcável(quadrado), pode ser on ou off. Pode-se marcar mais de
um.
Type=”radio” Botão marcável(redondo). Normalmente agrupa-se vários radio buttons
sob o mesmo nome, e o usuário só pode marcar um deles (que dá o

32
 valor da variável criada pelo nome do campo)
Type=”submit” Cria um botão de submit, através do qual o formulário é enviado.
Type=”reset” Limpa todos os campos daquele formulário (ou os coloca com seus
valores padrão).

NAME – Define o nome do campo, e é essencial, pois dá o nome da variável que recebe os
valores passados para o script. Precisa estar presente em todos os campos, menos no submit e
reset.

VALUE – Para campos “text” e “password”, define o valor padrão do campo ao abrir a página do
formulário. Esse valor vai aparecer dentro do campo inicialmente, podendo ser modificado pelo
usuário. Para campos radio e checkbox, define o valor do botão para quando ele está marcado.

CHECKED (sem valor) – Especifica que o radio ou checkbox é marcado por padrão.

SIZE – tamanho físico do campo que aparecerá na tela, em caracteres. Aplica-se apenas a
campos text e password. Se não estiver presente, o valor padrão é 20.

MAXLENGTH – número máximo de caracteres que podem ser digitados dentro de um campo. Se
não estiver presente, o padrão é ilimitado.

7.3 A tag SELECT

Diferente da tag INPUT, a SELECT tem uma tag de abertura e uma de fechamento.
Dentro da tag são especificadas as opções, também sendo abertas e fechadas pela tag OPTION,
e o texto que estiver dentro desta última tag será o texto que aparecerá dentro do menu na
página. Também devemos especificar o valor para cada opção. Exemplo:

<SELECT NAME=”teste”>
<option value=”1”>Essa opção tem valor 1</option>
<option value=”2” selected>Essa opção tem valor 2</option>
<option value=”3”>Essa opção tem valor 3</option>
</SELECT>

O Atributo “selected” define que a opção 2 estará selecionada por padrão.

O parâmetro opcional multiple permite a seleção de mais de uma linha.
O atributo size=”tamanho” especifica o número de linhas visíveis. O padrão é 1(combobox), mas
você pode criar um listbox especificando um tamanho maior.

Ao chegar no script action PHP, haverá uma variável baseada no nome do select (teste), e o valor
dependerá da opção que o usuário escolher.
Vale frisar que podemos colocar códigos PHP em qualquer parte de uma página html, inclusive
dentro de tags e dentro de formulários. Isso é importante para criarmos menus SELECT
dinâmicos, que terão suas opções provenientes de uma tabela MySQL.

7.4 A tag TEXTAREA

A tag TEXTAREA cria uma caixa de texto com mais de uma linha. Seus atributos são:

NAME Dará nome à variável desse campo no script action

ROWS Número de linhas (tamanho vertical, em caracteres)

33
 COLS Número de colunas (tamanho horizontal, cada coluna é um caracter)

Campos TEXTAREA possuem automaticamente barras de rolagem.

Como a SELECT, precisa de uma tag de fechamento. O que vier entre a tag de abertura e a tag
de fechamento será o seu valor padrão (aqui não utilizamos o atributo VALUE).
Exemplo, sem valor padrão:

<TEXTAREA NAME="foo" ROWS=4 COLS=40></TEXTAREA>

Exemplo com valor padrão:

<TEXTAREA NAME="foo" ROWS=4 COLS=40>

Default contents go here.
</TEXTAREA>

O conteúdo padrão precisa ser em texto plano, sem instruções html. Quebras de linha serão
respeitadas (sem precisar usar a tag <br> ).

34
 8 – Tratando Formulários

Agora vamos ver como é feita a passagem de valores de um formulário para um script action
PHP.

Você deve lembrar de quando falamos a respeito das variáveis Globais no PHP. Elas são
responsáveis por guardar valores que devem passar de página para página, como sessões,
cookies, informações do servidor HTTP e formulários.

Nesse momento iremos ver a importância dos nomes dos campos que definimos nos nossos
formulários, pois eles serão a chave de arrays associativos que conterão os valores passados
pelo usuário através do formulário. Você também deve lembrar de quando falamos sobre arrays
associativos, que contém strings como índices e esses índices devem vir ente apóstrofes (ou
aspas, porém apóstrofes são mais recomendados para não causarem confusão com as aspas
utilizadas na sintaxe de vários comandos).

8.1 - HTTP GET - $_GET

$_GET é um array que contém todas as variáveis passadas para o script atual através de um
formulário HTTP GET.

Tomemos por exemplo o seguinte formulário, no documento formulario.htm :

<form method=”GET” action=”formaction.php”>

Digite seu nome:
<input type=”text” name=”nome”><br>
Digite seu telefone:
<input type=”text” name=”fone”>
</form>

E agora veremos o arquivo formaction.php :

<?php

$nome=$_GET[‘nome’];
$fone = $_GET[‘fone’];

echo “Seu nome é $none<BR>”;

echo “Seu telefone é $fone”;
?>

Repare que criamos novas variáveis com os valores das variáveis globais provenientes do
formulário. Isso é feito para facilitar e tornar o código mais claro, pois podemos ter problemas ao
utilizar arrays associativos dentro de comandos como echo ou comandos mysql, por causa dos
apóstrofos ou aspas.

Esse exemplo imprime os dados digitados pelo usuário.

35
8.2 - HTTP POST - $_POST
$_POST é um array que contém todas as variáveis passadas para o script atual através de um
formulário HTTP POST.
O esquema é o mesmo das variáveis $_GET.

Tomemos por exemplo o seguinte formulário, no documento formulario.htm :

<form method=”POST” action=”formaction.php”>

Digite seu nome:
<input type=”text” name=”nome”><br>
Digite seu telefone:
<input type=”text” name=”fone”>
</form>

E agora veremos o arquivo formaction.php :

<?php

$nome=$_POST[‘nome’];
$fone = $_POST[‘fone’];

echo “Seu nome é $none<BR>”;

echo “Seu telefone é $fone”;
?>

Note que a única coisa que vai mudar dos exemplos com GET são o método do formulário
(POST) e o nome do array global ($_POST).

8.3 – O Array $_FILES

$_FILES contém informações de arquivos enviados por formulários. Nós iremos abordar esse
assunto no decorrer do curso pois existem alguns detalhes específicos sobre arquivos que
transformam esse array em um array multidimensional, contudo a idéia é a mesma dos outros
arrays globais de formulários.

8.4 – Dicas para seu formulário

a. Ao trabalharmos com datas (como data de nascimento), o ideal é criar três campos separados,
um para dia, outro para mês e outro para ano. Isso é muito importante para termos controle sobre
cada dado isoladamente, podendo manipula-los para transformar em diferentes formatos de data,
o que é necessário quando trabalhamos com bancos de dados(a maioria guarda a data no
formato ano-mês-dia).

b. Especifique os valores maxwidth e size, para organizar e limitar a quantidade de caracteres que
o usuário pode digitar no campo, pois ao lidar com bancos de dados existirá um tamanho limite
para cada campo de dado da tabela, e caso esse limite seja ultrapassado, alguns dados poderão
ser perdidos.

c. Também é muito importante fazer verificações nos campos de formulário, para evitar erros por
parte do preenchimento do usuário, e isso será visto mais tarde com as funções de Expressões
Regulares.

36
 9 - Estruturas de Controle
As estruturas de controle (laços, estruturas condicionais) são construtores essenciais de uma
linguagem de programação.

No PHP, assim como em C, uma expressão é considerada verdadeira (TRUE) se tiver um valor
diferente de 0. Isso significa que qualquer valor diferente de zero será considerada uma expressão
verdadeira para o PHP, e isso é muito importante quando vamos trabalhar com estruturas de
controle, pois elas utilizam o conceito de verdadeiro e falso para realizarem suas ações.

9.1 – Condicionais

9.1.1 - IF

A construção if (se) é uma das mais importantes implementações de muitas linguagens, incluindo
o PHP. Ela permite a execução condicional de fragmentos de código. O PHP implementa uma
estrutura if que é similar àquela do C:

if (expressao) {

instruções;

expressao é avaliado por seu contexto Booleano. Se expressao for avaliado como TRUE, o PHP
executará instrucoes, e se for avaliado como FALSE, elas serão ignoradas.

Os exemplos a seguir mostrariam “a é maior que b” se $a for maior que $b:

<?php
if ($a > $b) {
echo "a é maior que b";
}

?>

Se $a fosse menor que $b, a instrução echo seria ignorada, e o interpretador pularia para a parte
do código logo após as instruções especificadas no if (após o “}” ).

Caso haja apenas uma instrução, não há necessidade do uso de parênteses, mas a título de
aprendizagem e para evitar confusões, vamos utilizar os parênteses mesmo para estes casos.

Algumas vezes, os iniciantes em linguagens como C e derivados(como é o caso do PHP), se

confundem pelo fato de que você pode usar qualquer expressão válida como controle do IF. Isto
é, você não fica restrito a expressões envolvendo os operadores relacionais e lógicos (como é o
caso em linguagens como Pascal). O interpretador precisa apenas de um valor zero ou diferente
de zero.
Desta maneira, quando queremos verificar se uma variável contém um valor diferente de zero,
podemos simplesmente utilizar:

If($var) echo “Diferente de zero.”;

37
Isso é a mesma coisa de escrever:

if($var != 0) echo “Diferente de zero”;

Contudo, esta maneira é redundante. No caso contrário (se você quer executar o if quando a
variável for igual a zero), basta “negarmos” a expressão com o sinal “!” :

if(!$var) echo “Igual a zero!”;

Isso é a mesma coisa de escrevermos: if($var == 0) echo “Igual a zero”;

Em PHP temos uma função que sempre é muito utilizada, e serve para verificar se uma variável
existe (foi iniciada):

bool isset ( mixed var [, mixed var [, ...]])

Retorna TRUE se a variável existir, e FALSE se ela não existir. Isso é utilizado sempre, para
verificar por exemplo se um certo valor foi passado por formulário.

if(isset($_GET[‘userid’])) {
$id=$_GET[‘userid’];
echo “usuário de id $id”;
}

9.1.2 ELSE

Freqüentemente você vai querer executar uma instrução se uma certa condição for encontrada, e
uma instrução diferente se a condição não for encontrada. Isto é o que o else (se não) faz. else
estende um comando if para executar uma instrução caso a expressão no comando if seja
avaliada como FALSE. Por exemplo, o código a seguir mostraria “a é maior que b” se $a for
maior que $b, e “a NÃO é maior que b” caso contrário:

<?php
if ($a > $b) {
echo "a é maior que b";
} else {
echo "a NÃO é maior que b";
}
?>

O comando else só é executado se a expressão if for avaliada como FALSE, e havendo qualquer
expressão elseif, somente se todas elas forem avaliadas como FALSE também.

9.1.3 ELSEIF (ou else if)

elseif, como seu nome sugere, é uma combinação de if e else. Da mesma forma que o else, ele
estende um comando if para executar uma instrução diferente no caso de a expressão if original
ser avaliada como FALSE. Porém, ao contrário de else, ele executará aquela expressão
alternativa somente se a expressão condicional do elseif for avaliada como TRUE. Por exemplo, o
código a seguir mostraria a é maior que b, a é igual a b ou a é menor que b:

38
<?php
if ($a > $b) {
echo "a é maior que b";
} elseif ($a == $b) {
echo "a é igual a b";
} else {
echo "a é menor que b";
}

?>

É importante lembrar que o ELSE é a última opção, caso nenhuma das outras (if e elseifs) forem
verdadeiras, ele vai ser executado, por isso ele deve vir por último (após o if e todos os elseifs).

9.1.4 SWITCH

A instrução switch é similar a uma série de instruções IFs seguidas. Em muitas ocasiões, você
poderá ter que comparar a mesma variável (ou expressão) com muitos valores diferentes,
executando códigos diferentes dependendo de qual valor ele se encaixar. É exatamente para isso
que a instrução switch serve.

<?php
switch ($i) {
case 0:
echo "i igual a 0";
break;
case 1:
echo "i igual a 1";
break;
case 2:
echo "i igual a 2";
break;
}

?>

9.2 – Repetição
9.2.1 WHILE

Loops while (enquanto) são as formas mais simples de loop no PHP. Eles se comportam como
seus compatíveis em C. O formato básico de um comando while é:

while (expressao) {
instruções;
}

O significado de um comando while é simples. Ele pede que o PHP execute os comandos
aninhados repetidamente, enquanto a expressão do while é avaliada como TRUE. O valor da
expressão é verificada cada vez que se passa no começo do 'loop', desta forma, mesmo que este
valor mude durante a execução do(s) comando(s) aninhado(s), a execução não parará até que o
fim da iteração (cada vez que o PHP executa os comandos dentro do 'loop' é uma iteração). Às
vezes, se a expressão while é avaliada como FALSE logo no início, o(s) comando(s) aninhado(s)
não será(ão) rodado(s) nem uma vez sequer.

39
9.2.2 DO..WHILE

Loops do..while são bem similares aos loops while, exceto pelo fato de que a condição é
verificada apenas no final de cada iteração, em vez de no começo. Por essa razão, a primeira
iteração de um loop do..while é sempre executada (a condição só é verificada no fim da iteração)
enquanto que num while normal, se a expressão é avaliada como FALSE logo “de primeira”, a
execução do loop terminaria imediatamente.

<?php
$i = 0;
do {
echo $i;
} while ($i > 0);

?>

9.2.3 FOR

Loops for são os laços mais complexos em PHP. Eles se comportam como os seus compatíveis
em C. A sintaxe de um loop for é:

for (expr1; expr2; expr3) {

instruções;
}

A primeira expressão (expr1) é avaliada (executada) uma vez incondicionalmente no começo do

loop.

No começo de cada iteração, expr2 é avaliada. Se ela é avaliada como TRUE, o loop continua e
o(s) comando(s) aninhado(s) é(são) executado(s). Se é avaliada como FALSE, a execução do
'loop' termina.

No fim de cada iteração, expr3 é avaliada (executada).

Cada uma das expressões pode ser vazia. expr2 vazia significa que o loop pode rodar
indefinidamente (PHP considera-a implicitamente como TRUE, como em C.

Considere os seguintes exemplos. Todos eles mostram números de 1 a 10:

<?php
/* exemplo 1 */

for ($i = 1; $i <= 10; $i++) {

echo $i;
}

/* exemplo 2 */

for ($i = 1; ; $i++) {

if ($i > 10) {
break;
}
echo $i;
}

/* exemplo 3 */

40
$i = 1;
for (; ; ) {
if ($i > 10) {
break;
}
echo $i;
$i++;
}

/* exemplo 4 */

for ($i = 1; $i <= 10; echo $i, $i++);

?>

9.3 Quebra de fluxo

9.3.1 Break

O comando break pode ser utilizado em laços do, for e while, além do uso já visto no comando
switch. Ao encontrar um break dentro de um desses laços, o interpretador PHP para
imediatamente a execução do laço, seguindo normalmente o fluxo do script.

while ($x > 0) {

...
if ($x == 20) {
echo “erro! x = 20”;
break;
}
...
}

No trecho de código acima, o laço while tem uma condição para seu término normal ($x <= 0),
mas foi utilizado o break para o caso de um término não previsto no início do laço. Assim o
interpretador seguirá para o comando seguinte ao laço.

9.3.2 Continue
O comando continue também deve ser utilizado no interior de laços, e funciona de maneira
semelhante ao break, com a diferença que o fluxo ao invés de sair do laço volta para o início dele.
Vejamos o exemplo:

for ($i = 0; $i < 100; $i++) {

if ($i % 2) continue;
echo “ $i “;
}

O exemplo acima é uma maneira ineficiente de imprimir os números pares entre 0 e 99. O
que o laço faz é testar se o resto da divisão entre o número e 2 é 0. Se for diferente de zero (valor
lógico true) o interpretador encontrará um continue, que faz com que os comandos seguintes do
interior do laço sejam ignorados, seguindo para a próxima iteração.

41
 10 – Modularização

Agora que já vimos as sintaxes básicas da linguagem, vamos partir para a organização dos
nossos scripts PHP.

A modularização é um fator muito importante, tanto para facilitar a programação, quanto para
deixar o código mais limpo e legível, poupando você de muitos problemas posteriores. Com a
utilização de funções, você poupará tempo e inconveniências, tornando a manutenção de seu
sistema uma tarefa muito mais simples.

10.1 Inclusão de Arquivos

A inclusão de arquivos é uma forma básica de modularização, que será mais aproveitada quando
estudarmos funções.

Include() e Require()

A instrução include() inclui e avalia o arquivo informado.

A instrução require() é idêntica à include(), com exceção de como elas manipulam erros.
include() produz um Warning enquanto require() produzirá um Fatal Error. Em outras palavras,
utilize require() se você deseja que um arquivo faltando interrompa o processamento da página.
include() não se comporta da mesma maneira, permitindo que o script continue nessas situações.
Quando um arquivo é incluído, seu código entra no escopo de variável da linha onde a inclusão
ocorre. Qualquer variável disponível da linha onde a chamada da inclusão ocorre estará disponível
para o arquivo incluído, daquele ponto em diante.

10.2 Funções
Funções são blocos de código que podem apenas executar procedimentos sem retornar valor
algum, como também podem retornar algum valor, seja ele de qualquer tipo(strings, inteiros,
arrays, etc).
São essencialmente utilizadas para seqüências de código que precisam ser executadas várias
vezes em partes diferentes do script ou em scripts diferentes.
Para criarmos uma modularização realmente interessante, utilizamos um arquivo separado para
guardarmos nossas funções, incluindo o mesmo em todos os scripts que irão utilizar as funções
definidas.

Uma função pode receber ilimitados argumentos que serão utilizados dentro da mesma, como
também pode não receber argumento nenhum. Argumentos são valores passados como
parâmetro para uma função, que chegam até ela na forma de variáveis locais da função.

Vale salientar que os valores passados para uma função são passados por valor, ou seja, as
modificações dentro da função não alterarão o valor real da variável passada.

O retorno de valores é feito através da função “return”.

Uma função pode ser definida usando-se a sintaxe como a do exemplo abaixo:

42
<?php
function foo ($numero1, $numero2)
{
echo "Exemplo de função.\n";
$soma=$numero1 + $numero2;
return $soma;
}
?>

Neste exemplo, a função recebe 2 números como parâmetro, e retorna o valor da soma dos dois.
No script principal, poderemos chama-la da seguinte maneira:

<?php

$resultado = soma(5,10);
echo “O resultado foi: $resultado”;

?>

Como a função retorna o valor da soma, precisamos colocar esse valor em uma variável. Note
que passamos por parâmetro dois números inteiros, e eles não precisam ser colocados entre
aspas ou apóstrofos. Se os parâmetros fossem strings, precisaríamos coloca-las entre aspas ou
apóstrofos.
Veja agora outro exemplo utilizando variáveis como parâmetros:

<?php

$num1=10;
$num2=5;
$resultado = soma($num1,$num2);
echo “O resultado da soma de $num1 e $num2 eh $resultado.”;

?>

Você tanto pode passar valores literais para a função, como variáveis. É importante seguir a
ordem especificada na declaração da função. E lembre-se que, como o PHP não exige definição
de tipos, você precisa às vezes se certificar que uma variável contém o tipo de dado esperado,
para que seu script execute da maneira que você espera.

10.3 Argumentos com valores pré-definidos (default)

Em PHP é possível ter valores default para argumentos de funções, ou seja, valores que serão
assumidos em caso de nada ser passado no lugar do argumento. Quando algum parâmetro é
declarado desta maneira, a passagem do mesmo na chamada da função torna-se opcional.

function teste($php = “testando”) {

echo $php;
}

teste(); // imprime “testando”

teste(“outro teste”); // imprime “outro teste”

É bom lembrar que quando a função tem mais de um parâmetro, o que tem valor default deve ser
declarado por último:

43
 function teste($figura = circulo, $cor) {
echo “a figura é um “. $figura. “ de cor “ $cor;
}

teste(azul);

/* A função não vai funcionar da maneira esperada, ocorrendo um erro no interpretador. A

declaração correta é a seguinte: */

function teste2($cor, $figura = circulo) {

echo “a figura é um “. $figura. “ de cor “ $cor;
}

teste2(azul);

/* Aqui a função funciona da maneira esperada, ou seja, imprime o texto: “a figura é um círculo
de cor azul” */

10.4 Passagem de parâmetros por referência

Normalmente, a passagem de parâmetros em PHP é feita por valor, ou seja, se o conteúdo da

variável for alterado, essa alteração não afeta a variável original.

Exemplo:

function mais5($numero) {
$numero += 5;
}

$a = 3;
mais5($a); //$a continua valendo 3

No exemplo acima, como a passagem de parâmetros é por valor, a função mais5 é inútil, já que
após a execução sair da função, o valor anterior da variável é recuperado. Se a passagem de
valor fosse feita por referência, a variável $a teria 8 como valor. O que ocorre normalmente é que
ao ser chamada uma função, o interpretador salva todo o escopo atual, ou seja, os conteúdos das
variáveis. Se uma dessas variáveis for passada como parâmetro, seu conteúdo fica preservado,
pois a função irá trabalhar na verdade com uma cópia da variável.
Porém, se a passagem de parâmetros for feita por referência, toda alteração que a função realizar
no valor passado como parâmetro afetará a variável que o contém.

Há duas maneiras de fazer com que uma função tenha parâmetros passados por referência:
indicando isso na declaração da função, o que faz com que a passagem de parâmetros sempre
seja assim; e também na própria chamada da função. Nos dois casos utiliza-se o modificador “&”.
Vejamos um exemplo que ilustra os dois casos:

function mais5(&$num1, $num2) {

$num1 += 5;
$num2 += 5;
}

44
$a = $b = 1;
mais5($a, $b); /* Neste caso, só $num1 terá seu valor alterado, pois a passagem por referência
está definida na declaração da função. */

mais5($a, &$b); /* Aqui as duas variáveis terão seus valores alterados. */

45
 11 – Banco de Dados

11.1 Sistema de Banco de Dados

É um sistema de armazenamento de dados cujo objetivo global é registrar e manter informações.
Um sistema de Banco de Dados envolve quatro componentes maiores: dados, hardware, software
e usuários (atores que participam do processo).
É um Conjunto estruturado de dados de uma empresa ou aplicação, armazenado em computador
e cuja organização é determinada por um modelo de dados definido.

Por que usar bancos de dados ao invés de arquivos:

• Arquivos não permitem o armazenamento de grandes volumes de dados;

• O Sistema de backup é ineficiente;

• O Acesso aos dados é mais complexo;

• Não disponibilizam linguagem de consulta;

• Esquema de dados é limitado;

• Acesso concorrente aos dados por diversos usuários ou aplicações não

apresenta segurança adequada.

Os sistemas de bancos de dados oferecem várias facilidades para a utilização com diferentes
aplicações e finalidades, inclusive restringindo determinados tipos de acesso por usuário
(permissões), o que faz uma diferença essencial no processo de criação de um sistema.

Antes de iniciarmos nosso sistema, devemos criar um projeto bem estruturado de banco de
dados, para atender às nossas necessidades da melhor maneira possível. Um banco de dados
deve ser uma representação “digital” da realidade que queremos armazenar.
Devemos sempre prestar atenção a alguns fatores básicos para aplicarmos ao nosso projeto:

Evitar sempre a redundância de Dados

A redundância de dados é um fator comum em sistemas de dados não-compartilhados. Quando

você tem dados repetidos, gera uma dificuldade maior na manutenção, pois cada vez que uma
alteração é feita, esta alteração tem de ser feita em vários locais diferentes. Dessa maneira você
perde segurança (pois não se pode garantir que todas as vezes essas alterações redundantes
irão funcionar) e processamento (logicamente isso causará uma lentidão maior no sistema).
O compartilhamento de dados é um fator decisivo em um banco de dados, pois elimina a
redundância e evita inconsistência no banco.

Definir regras de acesso para diferentes usuários

É essencial saber quem vai poder acessar o que. O setor de compras, de vendas e a diretoria de
uma empresa têm focos diferentes em um sistema, em um banco de dados. E você deve
especificar que parte do sistema cada um desses setores tem privilégios para acessar, e que tipo
de acesso é esse (apenas leitura, alterações, remoção de dados etc). Isso é um fator essencial
para a segurança do seu sistema.

46
Organizar os dados
É importante criar um bom projeto de banco de dados, organizando tudo o que deve ser
armazenado, tamanhos de campos, necessidades de cada um (se pode ficar em branco ou não,
se precisa ter determinados valores, etc). E isso deve ser feito à mão primeiramente,
documentado, para que você não se perca depois, na hora de utilizar os dados.

11.2 MySQL
Os dados no MySQL são dispostos em forma de tabelas, similares às quais estamos
acostumados nos programas de planilhas e outros que lidam com tabelas. Cada coluna é definida
ao criar-se a tabela, e precisamos especificar o tipo de dado que será armazenado nela.
O MySQL é um banco de dados ideal para Web, pois é leve e oferece uma infinidade de
funcionalidades, possuindo uma verdadeira linguagem própria, onde se é possível utilizar
operadores aritméticos, lógicos(NOT, AND, OR, XOR) e várias funções especiais para
organizarem o resultado de sua pesquisa.

O MySQL suporta uma grande quantidade de tipos de dados, contudo vamos trabalhar com os
mais conhecidos e utilizados. Você pode conferir os outros tipos de dados suportados no manual
do MySQL.
O MySQL é case-insensitive, ou seja, não faz diferenciação entre maiúsculas e minúsculas.
Contudo, o php faz essa diferenciação, para os nomes de campos das tabelas. Por padrão,
devemos definir todos os nomes de campos com letras minúsculas.

11.2.1 Referência da Linguagem

1. Tipos de dados

INT ou Números inteiros.

INTEGER
FLOAT Números de ponto flutuante
DATE Data no formato AAAA-MM-DD
TIME Hora, no formato HH:MM:SS
VARCHAR Strings, tamanho variável de 0 a 255 caracteres
TEXT Texto. Aceita até 65535 caracteres. Existem formas que aceitam mais
caracteres: MEDIUMTEXT e LONGTEXT
ENUM Uma enumeração, na qual o valor do objeto só pode ter um dos valores
especificados na mesma. Ex: enum(‘janeiro’,’fevereiro’,’março’). Aceita até
65535 valores diferentes.
SET Um conjunto de valores, na qual pode-se assumir vários valores dentre os
especificados. Aceita até 64 opções escolhidas.

2. Criação e alteração de estruturas

SHOW Mostra informações sobre bancos de dados e tabelas existentes:

mysql> show databases;
mysql> show tables;
mysql> show columns from tbl_nome;
CREATE Cria bancos de dados e tabelas
mysql> create database db_nome;
mysql> create table tbl_nome ( coluna1 tipo, coluna2 tipo [...] );
DROP Apaga bancos de dados e tabelas inteiras
mysql> drop database db_nome;
mysql> drop table tbl_nome;
ALTER Altera tabelas (adiciona, remove e atualiza – add, drop e change)
mysql> alter table tbl_nome add coluna_nome tipo;
mysql> alter table tbl_nome drop coluna_nome;
47
 mysql> alter table tbl_nome change coluna_nome novo_nome tipo;

3. Inserção/alteração de dados

INSERT Insere dados em uma tabela

mysql> insert into tbl_nome values(‘campo01’,’campo02’,’campo03’);
UPDATE Atualiza dados de uma tabela
mysql> update tbl_nome set
coluna01=’valor01’,coluna02=’valor02’,coluna03=’valor03’ where
chave=’valor’;
DELETE Remove dados de uma tabela
mysql> delete from tbl_nome where chave=’valor’;
SELECT Mostra dados de uma tabela
mysql> select * from tbl_nome;
mysql> select coluna_nome from tbl_nome;

11.2.2 Sintaxe Detalhada

1. CREATE TABLE – cria uma tabela

create table table_nome(

tipo campo(tamanho),
tipo campo2(tamanho),
[...]
);

Exemplo:
mysql> create table exemplo(
varchar nome(30),
unsigned int idade);

Obs:

• Campos são separados por vírgula;

• O tipo de dado vem seguido pelo tamanho em parênteses, caso não seja especificado,
assume-se o tamanho padrão para o tipo escolhido;
• Todos os comandos sql vêm seguidos de um ponto-e-vírgula no final “;”.

2. INSERT – inserindo dados na tabela

insert into tbl_nome values(‘valor1’,’valor2’,[...]);

Exemplo:
mysql> insert into table exemplo values (‘Andre’, 25);
Query OK, 1 row affected (0.00 sec)

A relação de entradas deve vir entre parênteses, separadas por vírgulas, e os dados devem seguir
a ordem em que as colunas foram criadas na tabela.

48
3. SELECT – mostrando dados da tabela
O select pode ser usado para mostrar todos os dados da tabela, todos os dados de uma
determinada coluna, ou dados de uma linha específica, através da cláusula WHERE.

mysql> select * from table02;

+---------+----------+
| field01 | field02 |
+---------+----------+
| 1 | Primeiro |
| 2 | Segundo |
| 3 | Terceiro |
+---------+----------+

mysql> select field01 from table02;

+---------+
| field01 |
+---------+
| 1 |
| 2 |
| 3 |
+---------+

O Select comporta uma grande quantidade de parâmetros que podem modificar a forma que o
resultado aparece na tela. Vamos ver alguns deles:

3.1 ORDER BY
Especifica o campo (ou relação de campos) que será a chave de ordenação do resultado da
pesquisa.

Exemplo:
mysql> select nome, email from alunos order by nome;
+---------------------------+----------------------------+
| nome | email |
+---------------------------+----------------------------+
| Caetano Veloso | caetano_careta@gmail.com |
| Carlos Eduardo Martins | legolas_cem@yahoo.com.br |
| Carolina de Almeira | carol_al84@yahoo.com.br |
| Tereza Batista | terezabatista@yahoo.com.br |
+---------------------------+----------------------------+
Se você especificar mais de um campo para a cláusula order by, a ordenação(no padrão por
ordem alfabética ou do menor para o maior) obedecerá à ordem dos argumentos especificados.

O ORDER BY pode ainda ter dois modificadores: ASC e DESC (ascendente e descendente). Se
você não especificar nada, o padrão é ASC(do menor para o maior). Mas você pode fazer
também:

mysql> select nome, email from alunos order by nome DESC;

+---------------------------+----------------------------+
| nome | email |
+---------------------------+----------------------------+
| Tereza Batista | terezabatista@yahoo.com.br |
| Carolina de Almeira | carol_al84@yahoo.com.br |
| Carlos Eduardo Martins | legolas_cem@yahoo.com.br |
| Caetano Veloso | caetano_careta@gmail.com |
+---------------------------+----------------------------+
Neste caso, a ordenação ficou ao contrário (do maior para o menor).

49
3.2 LIMIT
Este modificador pode ser utilizado para limitar o número de resultados em um SELECT:

mysql> select nome,email from alunos limit 3;

+---------------------+----------------------------+
| nome | email |
+---------------------+----------------------------+
| Tereza Batista | terezabatista@yahoo.com.br |
| Carolina de Almeira | carol_al84@yahoo.com.br |
| Edna Maria Soares | ednamshx@hotmail.com |
+---------------------+----------------------------+

Note que a ordenação acima não está especificada, e o mysql fez uma ordenação baseada na
ordem em que os dados foram inseridos na tabela(essa é a ordenação padrão).

Nós podemos utilizar todos os elementos citados até agora:

mysql> select nome, email from alunos where email LIKE '%hotmail%' order by nome
desc limit 2;
+-------------------+----------------------------+
| nome | email |
+-------------------+----------------------------+
| Juliano Moreira | jmoreira_rock@hotmail.com |
| Edna Maria Soares | ednamshx@hotmail.com |
+-------------------+----------------------------+
*Lembrando que só há diferenciação de maiúsculas para minúsculas nos nomes dos campos. Os
comandos, cláusulas, funções, podem ser escritos de qualquer maneira.

3.3 INNER JOIN

A cláusula inner join serve para unir duas tabelas por um ponto em comum. Vamos usar o
seguinte exemplo: temos uma tabela de alunos, e cada aluno nesta tabela está relacionado a um
curso. A forma ideal de trabalhar com isso é criando uma tabela com a relação de cursos e um
número identificador para cada curso, e será esse número o ponto de ligação entre a tabela de
cursos e a tabela de alunos, pois cada aluno terá o código do curso no seu cadastro.
Com a cláusulas inner join, podemos de certa forma unir as duas tabelas e extrair o resultado de
uma pesquisa dessa união. Exemplo:

mysql> select nome, email, turma_horario from alunos inner join turmas on
alunos.turma_id=turmas.turma_id;
+---------------------------+----------------------------+----------------+
| nome | email | turma_horario |
+---------------------------+----------------------------+----------------+
| Carolina de Almeira | carol_al84@yahoo.com.br | Ter Quin 19:30 |
| Edna Maria Soares | ednamshx@hotmail.com | Ter Quin 19:30 |
| Juliano Ferreira | jferreira_rock@hotmail.com | Ter Quin 19:30 |
| Tereza Batista | terezabatista@yahoo.com.br | Sabado 08:00 |
| Carlos Eduardo Martins | legolas_cem@yahoo.com.br | Sabado 08:00 |
| Felipe Batista dos Santos | felipeba@gmail.com | Sabado 08:00 |
| Caetano Veloso | caetano_careta@gmail.com | Sabado 08:00 |
+---------------------------+----------------------------+----------------+

4. WHERE – Filtrando resultados

O Where é utilizado junto ao SELECT para filtrar os resultados obtidos, e junto ao UPDATE para
especificarmos qual linha deverá sofrer alterações.

SELECT col1,col2 [*] FROM tbl_nome WHERE coln=’valor’ ;

Exemplo:
mysql> select * from table02 WHERE field01=3;

50
+---------+
| field01 |
+---------+
| 1 |
| 2 |
| 3 |
+---------+

4.1 O Operador LIKE

O operador LIKE é utilizado no lugar do “=”, para fazermos pesquisas por campos que contenham
aquela porção de texto especificado (mas não precisa ser idêntico). Exemplo:

mysql> select nome, email from alunos where nome LIKE '%car%';
+------------------------+--------------------------+
| nome | email |
+------------------------+--------------------------+
| Carolina de Almeira | carol_al84@yahoo.com.br |
| Carlos Eduardo Martins | legolas_cem@yahoo.com.br |
+------------------------+--------------------------+

Note que precisamos utilizar um símbolo de ‘%’, este símbolo funciona como um ‘*’, ou seja, a
busca é por um campo “nome” que contenha a string ‘car’, e pode conter qualquer coisa à
esquerda ou à direita dessa string.

5. UPDATE – atualizando entradas na tabela

O Update deve ser usado na maioria das vezes com a cláusula WHERE, para que possamos
especificar qual linha(entrada na tabela) deverá ser atualizada. Caso o WHERE seja omitido,
todas as linhas da tabela sofrerão a alteração. Preste bastante atenção para não modificar todos
os dados da tabela por engano, quando você na verdade só queria modificar 01 valor.

UPDATE table_nome SET col1=’valor1’, col2=’valor2’, […], coln=’valorn’

WHERE col_base=’valor’;

6. DELETE – apagando registros

Sintaxe: DELETE [campo] FROM tabela WHERE condicao;

Se você não especificar o campo, serão apagados todos os campos do registro especificado.

A coisa mais importante a lembrar-se é da condição – se você não configurar uma, excluirá cada
entrada nas colunas especificadas do banco de dados, sem uma confirmação ou uma segunda
chance em muitos casos.

O que há em comum entre: DELETE x UPDATE

Você deve lembrar-se de utilizar uma condição toda vez que atualizar ou excluir. Se você não fizer
isso, todas as linhas na tabela sofrerão a mesma alteração ou exclusão. Mesmo os
programadores mais experientes esquecem a condição, para seu grande constrangimento
profissional. Cuidado para não esquecer a condição.

11.2.3 Modificadores de tipos

O MySQL conta com alguns modificadores de tipos de dados, para modelar os campos de
maneira a se encaixarem melhor nas suas necessidades. Os modificadores são utilizados no

51
momento em que estamos criando as tabelas, ou modificando sua estrutura. Vamos ver alguns
desses modificadores:

1. UNSIGNED

Especifica que o campo numérico é sem sinal. Pode ser usado para todos os campos de tipo
numérico: int, float, double e todos os seus derivados.
Exemplo:

mysql> create table mytable (

nome varchar(100),
idade unsigned int);

2. NOT NULL

O Modificador Not Null define que aquele campo não poderá conter valores vazios, ou seja, cada
vez que um registro novo for adicionado, aquele campo não pode ficar sem um valor. Caso não
seja especificado um valor para aquele campo, o MySQL retornará um erro e o registro não será
adicionado.
Exemplo:

mysql> create table mytable (

nome varchar(100) NOT NULL);

3. AUTO_INCREMENT

Especifica que o campo deverá ser incrementado automaticamente a cada novo registro. Você
deverá passar um valor NULL para esse campo, e ele se encarregará de criar valores únicos para
si.
Esse modificador é sempre usado para criar IDS, campos de identificação dentro de uma tabela.
Veremos a seguir o modificar Primary Key, e um exemplo de criação de um campo ID.

4. PRIMARY KEY

Primary Key, ou Chave Primária, define que aquele registro será a chave primária da tabela, ou
seja, o atributo que diferencia cada registro, um atributo único que é a chave de cada registro.
Existem outros tipos de chave, mas nós só vamos estudar a primária, que é a mais importante.

Quando você cria uma tabela, você deve sempre definir um campo que será o identificador de
cada registro, esse campo terá sempre de ter um valor diferente, pois cada registro é único,
mesmo que possua todos os campos iguais. Esse campo é o campo de chave primária, e
geralmente tem o nome “ID”, ou um nome relacionado.
Exemplo:

mysql> create table usuários (

userid INT NOT NULL PRIMARY KEY AUTO_INCREMENT,
login varchar(20),
senha varchar(20) );

Este exemplo cria uma tabela de logon de usuários, com dois campos de dados (login e senha) e
um campo de identificação de usuário (userid).
Estes campos de identificação são essenciais para modificarmos valores na tabela, sem
corrermos o risco de estarmos alterando o registro errado (ou mais de um registro).

52
 12 – PHP e MySQL – Integração

Aqui você tem uma referência das funções mais utilizadas pelo php para lidar com bancos de
dados MySQL. Existem várias outras, e você pode pesquisa-las no Manual Oficial do PHP.

mysql_connect Abre uma conexão com o servidor MySQL

<?php
$conecta=mysql_connect(“localhost”,”login”,”senha”); ?>

mysql_select_db Seleciona um banco de dados MySQL

<?php
mysql_select_db($conecta,”linuxfi”); ?>

mysql_fetch_array Busca o resultado de uma linha e o coloca como uma matriz

associativa, matriz numérica ou ambas. O índice do array associativo é
o nome do campo na tabela mysql, e o índice numérico vai de 0 até n
colunas, na ordem em que elas foram criadas.
<?php
$resultado=mysql_fetch_array($query); ?>

mysql_num_rows Retorna o número de linhas em um resultado.

<?php
$qtdade=mysql_num_rows($query); ?>

mysql_create_db Cria um banco de dados do MySQL

<?php
mysql_create_db(“db_name”); ?>

mysql_query Realiza uma query mysql.

<?php
$query=mysql_query(“SELECT * FROM usuarios”); ?>

mysql_error Retorna o texto da mensagem de erro da operação anterior do MySQL

<?php
$query=mysql_query(“SELECT * FROM usuarios”) or
die(mysql_error());

53
Exemplos:

Conecta no banco, pega todos os dados da tabela “users” e imprime na tela:

<?php
$connect=mysql_connect(“localhost”,”login”,”senha”) or
die(mysql_error());
mysql_select_db(“linuxfi”);

$query=mysql_query(“SELECT * FROM users”) or die(mysql_error());

while($linha=mysql_fetch_array($query)) {

$nome=$linha[‘nome’];
$end=$linha[‘end’];
$tel=$linha[‘tel’];

echo “Nome: $nome<br>Endereco: $end<br>Telefone: $tel<br><br>”;

?>

Vê quantos registros existem na tabela users:

<?php

$query=mysql_query(“SELECT * FROM users”) or die(mysql_error());

$numregs = mysql_num_rows($query);

echo “A tabela users tem $numregs registros.”;

?>

54
 13 – Cookies e Sessões

13.1 - Cookies
Cookies consistem em um mecanismo criado para guardar dados do lado do cliente (client-side),
possibilitando o acompanhamento ou identificação de usuários. Existe uma função específica para
criar cookies (setcookie()), mas como os cookies fazem parte do cabeçalho http, essa função
precisa ser chamada antes que qualquer outro dado seja enviado ao navegador. Essa função
sofre as mesmas limitações que a função header().
Qualquer cookie enviado por você para o cliente será automaticamente uma variável no PHP,
parecida com as variáveis de formulários, GET e POST, ficando no array $_COOKIES[].

SETCOOKIE
Envia um cookie para o cliente

Sintaxe:
bool setcookie ( string name [, string value [, int expire [, string
path [, string domain [, int secure]]]]])

setcookie() define um cookie para ser enviado junto com o resto dos cabeçalhos HTTP. Como
outros cabeçalhos, cookies devem ser enviados antes de qualquer saída do seu script (esta é uma
restrição do protocolo). Isto requer que você utilize esta função antes de qualquer saída, incluindo
as tags <html> e <head> assim como quaiquer espaços em branco. Se já tiver sido enviada
qualquer saída antes dessa função, setcookie() irá falhar e retornar FALSE. Se setcookie() for
bem sucedida, irá retornar TRUE. Isto não indica que o usuário aceitou o cookie.

Nota: No PHP 4, você pode usar o buffer de saída(output buffering) para enviar dados antes de utilizar esta
função, o que fará com que toda a saída para o browser seja guardada em um buffer no servidor até que
você execute a função. Você poderá fazer isso utilizando as funções ob_start() e ob_end_flush() no seu
script, ou definindo a diretiva de configuração output_buffering no seu php.ini (no servidor WEB).

Parâmetro Descrição Exemplos

'cookiename' é chamado como
name O nome do cookie.
$_COOKIE['cookiename']
O valor do cookie. Este valor é
guardado no computador do Assumindo que name é 'cookiename', este valor é
value
cliente, não guarde informações obtido atraves de $_COOKIE['cookiename']
sensíveis.
O tempo para o cookie expirar.
Este é um timestamp unix
,normalmente você vai defini-lo time()+60*60*24*30 irá fazer com que o cookie
com a função time() mais o expire em 30 dias. Se expire não for definido, o
expire
número de segundos que você cookie irá expirar ao fim da sessão (quando o
queira até que o cookie expire. browser fechar).
Ou você pode usar a função
mktime().
Se for definido '/', o cookie estará disponível para
todo o domain(domínio). Se for definido '/foo/', o
O caminho no servidor para qual cookie estará disponível apenas no diretório /foo/ e
path
o cookie estará disponível. todos os sub-diretórios /foo/bar/ de domain. O valor
padrão é o diretório que o cookie esta sendo
definido.

55
Parâmetro Descrição Exemplos
Para fazer o cookie estar disponível para todos os
subdomínios de example.com então você deve
O domínio que o cookie estará definir como '.example.com'. O . não é requerido,
domain
disponível. mas torna compativel com mais browsers.
Definindo como www.example.com fará o cookie
estar disponível apenas para o subdomínio www.
Indica que o cookie deve ser
transmitido sobre uma conexão
segura HTTPS. Quando for
secure 0 ou 1
definido como 1, o cookie só será
definido se existir uma conexão
segura. O padrão é 0.

Observações:

• Para testar se um cookie foi realmente definido, confira o cookie na próxima vez que a
pagina for carregada e antes que expire. O tempo de expiração é definido pelo parâmetro
expire. Uma maneira fácil de fazer o debug da existência de cookies é simplesmente usar
print_r($_COOKIE); (mostra todos os cookies definidos no momento).
• Cookies devem ser excluídos com os mesmos parâmetros que foram criados. Se o
argumento valor for uma string vazia (""), e todos os outros argumentos forem iguais, então
o cookie com o nome especificado será excluído do cliente.
• Nomes de cookies podem ser definidos como uma matriz de nomes e estarão disponíveis
nos scripts PHP como uma matriz, mas serão guardados como cookies separados no
sistema do usuário. Considere utilizar explode() para definir um cookie com múltiplos
nomes e valores (as informações ficariam em uma variável só, seguindo um padrão de
formatação para serem “retiradas” depois através dessas funções).

<?php
$value = 'something from somewhere';

setcookie ("TestCookie", $value);

setcookie ("TestCookie", $value,time()+3600); /* expira em uma hora */
setcookie ("TestCookie", $value,time()+3600, "/~rasmus/",
".example.com", 1);
?>
<?php
// Mostra um cookie
echo $_COOKIE["TestCookie"];

// Mostra todos os cookies

print_r($_COOKIE);
?>

56
13.2 - Sessões
Suporte a sessões no PHP consiste em uma forma de preservar certos dados através de acessos
subseqüentes. Isto te permite construir aplicações mais personalizadas e aumenta a atração do
seu web site. É através de sessões que podemos fazer um sistema de autenticação onde o
usuário informa login e senha, e faz logon no sistema, estando esses dados em arquivos ou
bancos de dados no servidor.

Um visitante acessando seu web site será identificado por uma id única, a então chamada id de
sessão. Esta id ou é guardada em um cookie do lado do usuário ou estará embutida na própria
URL.

Sessões permitem registrar variáveis para serem passadas de página a página. Quando um
visitante acessa seu site, o PHP checará automaticamente (se session.auto_start está definida
para 1) ou no seu pedido (explicitamente através da session_start() ou implicitamente através da
session_register()) se uma id de sessão especifica foi enviada com o pedido. Se este é o caso, o
ambiente anterior guardado é restaurado.

<?php
session_start();
// Use $HTTP_SESSION_VARS with PHP 4.0.6 or less
if (!isset($_SESSION['count'])) {
$_SESSION['count'] = 0;
} else {
$_SESSION['count']++;
}
?>

Exemplo – Desregistrando uma variável de Sessão (unset)

<?php
session_start();
unset($_SESSION['count']);
?>

Exemplo – Finalizando a sessão (session_destroy – destrói todos os dados de uma sessão)

<?php
session_start();
session_destroy();
?>

O ideal é integrarmos a funcionalidade das sessões com a utilização do MYSQL, criando um

sistema de autenticação.

57
 14. Manipulação de Arquivos

Com o PHP, podemos utilizar manipulação de arquivos, de forma praticamente idêntica à usada
em C. O diferencial é que no PHP também podemos abrir páginas.
Para podermos utilizar um arquivo, precisamos primeiro criar uma variável que será uma
referência para o arquivo especificado, e isso é feito através da função fopen.

14.1 FOPEN
Abre o arquivo(local ou remoto) especificado, retorna uma referência para o arquivo.

Sintaxe:
file fopen ( string filename, string modo [, int use_include_path [,
resource zcontext]])

Se o PHP decidir que filename se refere a um arquivo local, então ele tentará abrir o stream para
aquele arquivo. Esse arquivo precisa ser acessível pelo PHP, então você precisa certificar-se das
permissões do arquivo/pasta especificados, no servidor.
Se filename está na forma "protocolo://...", é assumido que seja uma URL, do protocolo
especificado (http e ftp são aceitos).

modo Descrição
'r' Abre somente leitura; coloca o ponteiro do arquivo no início.
'r+' Abre para leitura e escrita; coloca o ponteiro do arquivo no início.
Abre para escrita somente; coloca o ponteiro do arquivo no começo do arquivo e diminui
'w'
(trunca) o tamanho do arquivo para zero. Se o arquivo não existe, tenta criá-lo.
Abre o arquivo para leitura e escrita; coloca o ponteiro do arquivo no começo e diminui
'w+'
(trunca) o tamanho do arquivo para zero. Se o arquivo não existe, tenta criá-lo.
Abre para escrita somente; coloca o ponteiro do arquivo no final. Se o arquivo não existe,
'a'
tenta criá-lo.
Abre o arquivo para leitura e escrita; coloca o ponteiro do arquivo no final. Se o arquivo não
'a+'
existe, tenta criá-lo.
Cria e abre o arquivo para escrita somente; coloca o ponteiro no início do arquivo. Se o
'x' arquivo já existe, a chamada a fopen() irá falhar, retornando FALSE e gerando um erro
nível E_WARNING. Se o arquivo não existe, tenta criá-lo.
Cria e abre um arquivo para escrita e leitura; coloca o ponteiro do arquivo no início. Se o
'x+' arquivo já existe, a chamada a fopen() irá falhar, retornando FALSE e gerando um erro
nível E_WARNING. Se o arquivo não existe, tenta criá-lo.

Exemplos válidos:

<?php
$handle = fopen ("/home/rasmus/file.txt", "r");
$handle = fopen ("/home/rasmus/file.gif", "wb");
$handle = fopen ("http://www.example.com/", "r");
$handle = fopen ("ftp://user:password@example.com/somefile.txt", "w");
?>

58
14.2 FEOF
Testa pelo fim-de-arquivo (eof) em um ponteiro de arquivo

Sintaxe:
bool feof ( resource handle)

Retorna TRUE se o ponteiro estiver no fim do arquivo (eof) ou um erro ocorrer. Caso contrário
retorna FALSE.

14.3 FGETS
Lê uma linha de um ponteiro de arquivo

Sintaxe:
string fgets ( resource handle [, int length])

Retorna uma string com até length - 1 bytes lidos do arquivo apontado por handle. A leitura acaba
quando length - 1 bytes foram lidos, encontra-se um fim de linha (newline) (que é incluido no valor
retornado) ou no fim de arquivo (EOF) (o que acontecer primeiro). Se nenhum length for
informado, o default é 1Kb, ou 1024 bytes. Se um erro ocorrer, retorna FALSE.

<?php
$handle = fopen ("/tmp/arquivodeentrada.txt", "r");
while (!feof ($handle)) {
$buffer = fgets($handle, 4096);
echo $buffer;
}
fclose ($handle);
?>

14.4 FWRITE
Grava dados em arquivos binários

Sintaxe:
int fwrite ( resource handle, string string [, int comprimento])

fwrite() grava os conteúdos de string para o stream de arquivo apontado por handle. Se o
argumento comprimento é dado, a gravação irá parar depois de que comprimento bytes for escrito
ou o fim da string é alcançada, o que ocorrer primeiro.

fwrite() retorna o número de bytes gravados, ou FALSE em caso de erro

<?php
$filename = 'teste.txt';
$somecontent = "Acrescentando isto no arquivo\n";

// Tendo certeza que o arquivo existe e que há permissão de escrita

primeiro.
if (is_writable($filename)) {

// Em nosso exemplo, nós estamos abrindo $filename em modo de append

(acréscimo).
// O ponteiro do arquivo estará no final dele desde
// que será aqui que $somecontent será escrito com fwrite().
if (!$handle = fopen($filename, 'a')) {
print "Erro abrindo arquivo ($filename)";
exit;

59
 }

// Escrevendo $somecontent para o arquivo aberto.

if (!fwrite($handle, $somecontent)) {
print "Erro escrevendo no arquivo ($filename)";
exit;
}

print "Sucesso: escrito ($somecontent) no arquivo ($filename)";

fclose($);

} else {
print "The file $filename is not writable";
}
?>

14.5 FILE_EXISTS
Checa se um arquivo ou diretório existe

Sintaxe:
bool file_exists ( string nomedoarquivo )

Retorna TRUE se o arquivo ou diretório expecificado por nomedoarquivo existe; FALSE caso
contrário.

14.6 Outras funções de interesse para manipulação de arquivos

(verifique a sintaxe e exemplos dessas funções no manual oficial do PHP):

FSCANF
Interpreta a leitura de um arquivo de acordo com um formato dado.

FGETSS
Idêntico à fgets, exceto que ela tira tags HTML ou PHP do texto que lê.

60
 15 - Upload de Arquivos
O PHP é capaz de receber o upload de qualquer browser que siga a norma RFC-1867 (o que
inclui Netscape Navigator 3 ou posterior, Microsoft Internet Explorer 3 com um patch da Microsoft,
ou posterior sem patch). Isto permite que se faça o upload de arquivos de texto e binários. Com as
funções de autenticação e manipulação de arquivos do PHP, você tem o controle completo de
quem pode fazer o upload de arquivo e o que fazer com o arquivo após seu upload.

Um arquivo pode ser enviado através do http utilizando-se um formulário como o demonstrado
abaixo:

<form enctype="multipart/form-data" action="_URL_" method="POST">

<input type="hidden" name="MAX_FILE_SIZE" value="30000">
Enviar este arquivo: <input name="userfile" type="file">
<input type="submit" value="Enviar Arquivo">
</form>

A "_URL_" no exemplo acima deve ser substituída e apontar para um arquivo PHP que tratará o
formulário recebido. O campo escondido MAX_FILE_SIZE (medido em bytes) deve preceder o
campo de input do arquivo, e seu valor é o tamanho limite aceito para o arquivo (esse campo não
é obrigatório, porém é sempre interessante limitar o tamanho máximo dos arquivos enviados).
Também tenha certeza que seu formulário de upload de arquivo tenha enctype="multipart/form-
data" em outro caso o upload do arquivo não irá funcionar.

As informações sobre o arquivo enviado (que fica inicialmente em um diretório temporário no

servidor) estão num array global $_FILES, que é multidimensional.
Os conteúdos de $_FILES do nosso script de exemplo é como segue. Note que isso assume que
o nome do upload do arquivo é userfile, como o usado no exemplo acima, mas o campo pode
assumir qualquer nome.

$_FILES['userfile']['name']

O nome original do arquivo no computador do usuário.

$_FILES['userfile']['type']

O tipo mime do arquivo, se o browser deu esta informação. Um exemplo pode ser
"image/gif".

$_FILES['userfile']['size']

O tamanho, em bytes, do arquivo.

$_FILES['userfile']['tmp_name']

O nome temporário do arquivo, como foi guardado no servidor.

$_FILES['userfile']['error']

O código de erro associado a este upload de arquivo, caso exista.

61
Exemplo de script php que recebe um arquivo de upload:

<?php
$uploaddir = '/var/www/uploads/';
$uploadfile = $uploaddir. $_FILES['userfile']['name'];
print "<pre>";
if (move_uploaded_file($_FILES['userfile']['tmp_name'], $uploaddir .
$_FILES['userfile']['name'])) {
print "O arquivo é valido e foi carregado com sucesso. Aqui esta
alguma informação:\n";
print_r($_FILES);
} else {
print "Possivel ataque de upload! Aqui esta alguma informação:\n";
print_r($_FILES);
}
print "</pre>";
?>

Se nenhum arquivo for selecionado em seu formulário, o PHP irá retornar $_FILES['userfile']['size']
como 0, e $_FILES['userfile']['tmp_name'] como “none”.

O arquivo será excluído do diretório temporário ao fim do script se não tiver sido movido ou
renomeado.

62
 16 – Regular Expressions
É muito importante realizar uma verificação nos campos de formulário, não apenas para evitar o
envio de dados errados, mas principalmente para aumentar a segurança na hora de lidar com
bancos de dados.

Regular expressions, ou REGEX, são expressões especificadas pelo programador que conterão
os caracteres válidos ou não para determinado campo.

ereg() -> Verifica se a variável bate com a expressão regular, case sensitive

ereg_replace() -> Repõe uma variável por uma expressão regular, case sensitive

eregi() -> Verifica se a variável bate com a expressão regular, case insensitive

eregi_replace() -> Repõe uma variável por uma expressão regular, case insensitive

split() -> Divide uma variável em array usando uma expressão regular como delimitador, case
sensitive

spliti() -> Divide uma variável em array usando uma expressão regular como delimitador, case
insensitive

Para fazermos a verificação no formulário, as funções comumente utilizadas são ereg() e eregi().

16.1 Formando Expressões

As expressões regulares são formadas com combinações de caracteres que representam um
padrão a ser seguido. Os caracteres especiais que especificam quais elementos são aceitos ou
não estão listados a seguir:

^ Início de uma linha

$ Final de uma linha
n? Zero ou apenas uma ocorrência do caracter 'n'
n* Zero ou mais ocorrências do caracter 'n'
n+ Pelo menos uma ou mais ocorrências do caracter 'n'
n{2} Exatamente duas ocorrências do caracter 'n'
n{2,} Pelo menos 2 ou mais ocorrências do caracter 'n'
n{2,4} De 2 a 4 ocorrências do caracter 'n'
. Qualquer caracter
. () Parênteses para expressões grupais
(.*) Zero ou mais ocorrências de qualquer caracter
(n|a) Ou 'n', ou 'a'
[1-6] Qualquer digito compreendido entre 1 e 6
[c-h] Qualquer letra minúscula compreendida entre 'c' e 'h'

63
 [D-M] Qualquer letra maiúscula compreendida entre 'D' e 'M'
[^a-z] Qualquer caracter EXCETO qualquer letra minúscula entre 'a' e 'z'.

Importante: O símbolo '^' só é tido como excessão de uma sequência se ele vier exatamente no
início da sequência especificada. Se ele vier no início da expressão de regex(fora dos parênteses
ou colchetes de expressões), ele será interpretado como "início de linha", e não como termo de
negação. E se ele vier no meio de uma sequência, será interpretado como parte da mesma.

Exemplos:

[^0-9] -> Qualquer caracter exceto digitos de 0 a 9 (ou seja, apenas letras)

[53^a-z] -> Caracteres permitidos: 5, 3, ^, letras de 'a' a 'z'

^.{2} -> Quaisquer 2 caracteres no início da linha

16.2 Função ereg()

Sintaxe: ereg("expressao",$variavel)

Exemplo 1: Verificação de campo de e-mail

<?php
if(! ereg("^([0-9,a-z,A-Z]+)([.,_,-]([0-9,a-z,A-Z]+))*[@]([0-9,a-z,A-
Z]+)([.,_,-]([0-9,a-z,A-Z]+))*[.]([a-z,A-Z]){2,3}([0-9,a-z,A-Z])?$",
$input_email ) ) {
echo "Caracteres Inválidos no campo de e-mail!!!";
}
?>

Explicando a expressão:

^([0-9,a-z,A-Z]+) -> No início da linha, pelo menos uma ou mais ocorrências dos caracteres de 0-
9, ou a-z, ou A-Z

([.,_,-]([0-9,a-z,A-Z]+))* -> Seguidos ou não (Zero ou mais ocorrências) da expressão: ponto ou

underline ou hifen seguidos de caracteres de 0-9, a-z ou A-Z que apareçam pelo menos uma vez
ou mais

[@] -> seguido de arroba

([0-9,a-z,A-Z]+) -> seguidos de pelo menos um ou mais caracteres de 0-9, ou a-z, ou A-Z

([.,_,-]([0-9,a-z,A-Z]+))* -> Seguidos ou não(zero ou mais ocorrências) da expressão: ponto ou

underline ou hifen seguidos de caracteres de 0-9, a-z ou A-Z que apareçam pelo menos uma vez
ou mais

[.] -> seguidos de ponto

([0-9,a-z,A-Z]){2,3} -> Seguidos de 2 a 3 ocorrências de caracteres a-z ou A-Z

([a-z,A-Z])?$ -> Seguidos de uma ou nenhuma ocorrência de caracteres de a-z ou A-Z, no final da
linha

64
A expressão ereg foi precedida de um '!' para retornar seu valor contrário, ou seja, se a variável
$input_email não coincidir com a expressão especificada, ele executa o comando echo
"caracteres inválidos...";
Essa expressão aceita e-mails com pontos, underlines e hifens.

A partir desse exemplo fica fácil criar outras expressões mais simples, como para verificar o
campo de senha:

Exemplo 2: Verificação de campo de login/senha

<?php
if (!ereg("^([A-Z,a-z,0-9,_,-]){4,}", $senha) ) {
echo "Senha com caracteres inválidos";
}
?>

Nesse caso a expressão aceitará caracteres de A-Z, a-z, 0-9, underline e hifen.

65
 17 - Manipulação de Imagens
O PHP é capaz de gerar imagens em vários formatos, dentre eles gif, png, jpg, wbmp, e xpm,
tanto a partir de outras imagens, como criando novas imagens com textos e formas geométricas.
Entretanto, para que estas funcionalidades sejam possíveis, são necessários módulos adicionais
na instalação do PHP, bem como novos atributos no configure. Uma biblioteca adicional é
requerida, a biblioteca GD, e nas versões atuais do PHP (desde o 4.3) existe uma versão desta
biblioteca que acompanha o pacote do PHP. Entretanto, na hora de configura-lo, você precisa
especificar a utilização desta biblioteca com o argumento –with-gd .
A biblioteca JPG precisa ser instalada por fora, você pode fazer o download em
ftp://ftp.uu.net/graphics/jpeg/, e na hora do configure, especificar a opção --with-jpeg-dir=DIR.

Para trabalhar com imagens em PHP, existem várias funções específicas. Vamos citar as mais
utilizadas para criar thumbnails, verificar formato de imagens e mudar o tamanho delas. Lembre-
se que se a compilação do PHP não estiver com suporte à biblioteca GD, não é possível utilizar
estas funções.
Para uma referência completa das funções que trabalham com imagens, pesquise no manual do
PHP.

imagecreatetruecolor(int x_size, y_size)

Essa função retorna um identificador de imagem representando uma imagem branca no tamanho
especificado.

imagecreatefromjpeg(string filename)
Retorna um identificador de imagem representando a imagem obtida com o nome especificado.
Se a imagem não for JPG, ocorrerá um erro.

imagecreatefromgif(string filename)
Retorna um identificador de imagem representando a imagem obtida com o nome especificado.
Se a imagem não for GIF, ocorrerá um erro.

imagejpeg(resource image [, string filename [, int quality]])

Cria uma imagem jpg através do resource especificado como argumento, com o nome
especificado. O argumento “resource image” é um resource criado pelas funções imagecreate ou
imagecreatetruecolor. De maneira similar a esta função, existe a função imagegif(), que cria uma
imagem gif da mesma maneira.

imagesx(resource), imagesy(resource)
Retornam o tamanho horizontal(imagesx) e o tamanho vertical(imagesy) da imagem especificada
como resource.

Exemplo de utilização destas funções em um script de geração de thumbnails:

$thumb = imagecreatetruecolor(120, 90) or die("Cannot Initialize new GD image stream");

$imagem = imagecreatefromjpeg("imagens/foto.jpg") or die("Cannot create imagefromjpeg");

$thumbname="../imagens/miniaturas/foto.jpg";

$imagemw=imagesx($imagem);
$imagemh=imagesy($imagem);

imagecopyresized($thumb,$imagem,0,0,0,0,120,90,$imagemw, $imagemh) or die("Cannot

create Image Resized");

imagejpeg($thumb,$thumbname) or die("Cannot create imagejpeg");

66
 18 – Apêndice

18.1 Tratamento de erros

Existem quatro tipos(até a versão 4.0) de erros no PHP para indicar a gravidade do erro
encontrado ou ocorrido. Eles são:

1. Erros de funções (function errors)

2. Avisos (warnings)
3. Erros de processamento (parser error)
4. Observações (notice)

As mensagens de erro são um elemento nos quais os programadores devem prestar muita
atenção, afinal nenhum programador quer por no ar um sistema onde o primeiro visitante
encontra uma mensagem de erro. Para evitar essas inconveniências use sempre um “@”
antes da chamada as funções que têm maior possibilidade de dar erros, como funções de
manipulação de arquivos e imagens. Mas lembre-se de tratar o erro de alguma maneira, para
que o usuário saiba que alguma coisa não deu certo!

Se a opção track_errors no arquivo php.ini estiver habilitada, a mensagem de erro poderá

ser encontrada na variável global $php_errormsg.

A chamada de uma função ficaria assim:

@strtolower();

Esta função deixaria todos os caracteres da string passada em minúsculo, mas como não foi
passado nenhum argumento, uma mensagem de erro seria exibida.
Porém, como o modificador @ foi especificado, não aparecerão mensagens de erro na tela.

É importante lembrar que as mensagens de erro são essenciais para descobrirmos o que está
havendo com o script, e termos uma idéia do problema para podermos consertá-lo. Mas para
o usuário final, que está acessando a sua página, isso pode gerar uma certa falta de
credibilidade, pois um erro é sempre um erro, vai ser encarado como uma falha por parte de
quem construiu a página, mesmo que o erro seja causado por fatores sobre os quais você não
tem controle. Por isso é importante usarmos o operador @ em alguns casos, mas se
acontecer alguma falha e não sabemos o porquê, retiramos o operador para identificar o erro e
poder consertá-lo o mais rápido possível.

67