Apostila PHP

Faculdade FORTIUM
Curso de Sistemas de Informação
PHP
Prof. Giselle Barbosa Gomes Machado

PHP
_______________________________________________________________________________________________________________________
Sumário
1. Introdução ........................................................................................................................................ 3
1.1. O que é PHP? ............................................................................................................................ 3
1.2. O que pode ser feito com PHP? ................................................................................................ 3
1.3. Como surgiu a linguagem PHP? ............................................................................................... 3
1.4. Visão geral do PHP ................................................................................................................... 4
2. Utilizando TAGS no PHP................................................................................................................ 5
3. Comentários...................................................................................................................................... 5
4. Acessando Variáveis de formulário ................................................................................................ 5
5. Tipos de dados no PHP .................................................................................................................... 5

5.1. Conversão de tipos de dados ..................................................................................................... 6
6. Constantes ......................................................................................................................................... 7
7. Variáveis ........................................................................................................................................... 7
7.1. Variáveis Superglobais............................................................................................................... 7
8. Enviando resultado para o Browser............................................................................................... 8
9. Operadores ....................................................................................................................................... 8
9.1. Aritméticos ................................................................................................................................ 8
9.2. De strings ................................................................................................................................... 8
9.3. De atribuição ............................................................................................................................. 9
9.4. De comparação .......................................................................................................................... 9
9.5. De incremento e decremento ..................................................................................................... 9
9.6. Bit a bit ...................................................................................................................................... 9
9.7. Lógicos .................................................................................................................................... 10
9.8. Precedência ............................................................................................................................. 10
10. Estruturas de controle ................................................................................................................. 11

10.1. Blocos .................................................................................................................................... 11
10.2. Comandos de seleção ............................................................................................................. 11
10.2.1. if .................................................................................................................................. 11
10.2.2. switch .......................................................................................................................... 14
10.3. Comandos de repetição .......................................................................................................... 15
10.3.1. while ............................................................................................................................ 15
10.3.2. do... while ..................................................................................................................... 16
10.3.3. for ................................................................................................................................. 16
10.4. Quebra de fluxo ...................................................................................................................... 17
10.4.1. Break ............................................................................................................................ 17
10.4.2. Continue ....................................................................................................................... 18
~1~
PHP
_______________________________________________________________________________________________________________________
11. Funções.......................................................................................................................................... 18
11.1. Definindo funções ................................................................................................................. 18
11.2. Valor de retorno .................................................................................................................... 19
11.3. Argumentos ........................................................................................................................... 19
11.3.1. Passagem de parâmetros por referência .................................................................... 19
11.3.2. Argumentos com valores pré-definidos (default) ........................................................ 20
11.4. Contexto ................................................................................................................................ 21
11.5. Escopo ................................................................................................................................... 21
12. Manipulando strings .................................................................................................................... 22
13. Arrays ........................................................................................................................................... 24

13.1. Criando Arrays no PHP ......................................................................................................... 24
13.2. Manipulando os elementos de um Array .............................................................................. 24
13.3. Funções para manipulação de Arrays ................................................................................... 24
13.4. Foreach .................................................................................................................................. 26
14. Arquivos ....................................................................................................................................... 27

14.1. Abrindo arquivo .................................................................................................................... 27
14.2. Fechando arquivo .................................................................................................................. 28
14.3. O que fazer com arquivos? .................................................................................................... 28
~2~
PHP
_______________________________________________________________________________________________________________________
1. Introdução
1.1. O que é PHP?
O PHP é acrônimo de Hypertext Preprocessor (pré-processador de hipertexto), uma poderosa

linguagem de programação open source, mundialmente utilizada, principalmente no ambiente Web.
PHP é uma linguagem que permite criar sites WEB dinâmicos, possibilitando uma interação
com o usuário através de formulários, parâmetros da URL e links. A diferença de PHP com relação a
linguagens semelhantes a Javascript é que o código PHP é executado no servidor, sendo enviado para
o cliente apenas html puro. Desta maneira é possível interagir com bancos de dados e aplicações
existentes no servidor, com a vantagem de não expor o código fonte para o cliente. Isso pode ser útil
quando o programa está lidando com senhas ou qualquer tipo de informação confidencial.
O que diferencia PHP de um script CGI escrito em C ou Perl é que o código PHP fica
embutido no próprio HTML, enquanto no outro caso é necessário que o script CGI gere todo o
código HTML, ou leia de um outro arquivo. A home page do PHP está disponível em
http://www.php.net.
1.2. O que pode ser feito com PHP?
Basicamente, qualquer coisa que pode ser feita por algum programa CGI pode ser feita
também com PHP, como coletar dados de um formulário, gerar páginas dinamicamente ou enviar e
receber cookies.
PHP também tem como uma das características mais importantes o suporte a um grande
número de bancos de dados, como dBase, Interbase, mSQL, mySQL, Oracle, Sybase, PostgreSQL e
vários outros. Construir uma página baseada em um banco de dados torna-se uma tarefa
extremamente simples com PHP.
Além disso, PHP tem suporte a outros serviços através de protocolos como IMAP, SNMP,
NNTP, POP3 e, logicamente, HTTP. Ainda é possível abrir sockets e interagir com outros
protocolos.
1.3. Como surgiu a linguagem 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
~3~
PHP
_______________________________________________________________________________________________________________________
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.
Atualmente o uso do PHP3 vem crescendo numa velocidade incrível, e já está sendo
desenvolvida a versão 4 do PHP.
1.4. Visão Geral do PHP
Uma das aplicações mais comuns de qualquer linguagem de criação de scripts de lado do
servidor é processar formulários de HTML.
A primeira coisa, a saber, é que devemos configurar a ação do formulário para ser o nome do
script de PHP que processará as informações. Em geral, o valor do atributo ACTION (em um
arquivo HTML) é o URL que será carregado quando o usuário pressionar o botão Submit. Os dados
que o usuário digitou no formulário serão enviados para este URL via o método especificado no
atributo METHOD, um GET (acrescentado ao fim do URL) ou POST (enviado como um pacote
separado).
A segunda coisa a notar são os nomes dos campos de formulário. Utilizaremos esses nomes
novamente no nosso script de PHP. Por causa disso é importante dar nomes significativos aos
campos de formulário dos quais você possa facilmente se lembrar ao começar a escrever o script de
PHP.
Para embutir código PHP em HTML devemos simplesmente escrever o código PHP dentro
do arquivo HTML.
Exemplo:
<html>
<head>
<title> PHP e MySQL </title>
</head>
<body>
<h1> Meu primeiro programa </h1>
<?php
echo “<p> Código PHP em um arquivo HTML.”;
?>
</body>
</html>
~4~
PHP
_______________________________________________________________________________________________________________________
2. Utilizando TAGS de PHP
O código de PHP no exemplo anterior começou com <?php e acabou com ?>. Isso é
semelhante a todas as tags HTML porque todas começam com um símbolo menor que (<) e
terminam com um símbolo maior que (>). Esses símbolos são chamados tags de PHP que dizem ao
servidor da Web onde o código de PHP começa e onde termina. Qualquer texto entre as tags será
interpretado como PHP. Qualquer texto fora dessas tags será tratado com HTML normal.
3. Comentários
Os comentários em PHP começam com /* e terminam com */, para comentários em bloco.
Exemplo: /* esta linha não será processada pois está como comentário */
Os comentários de linhas iniciam com // ou #.
4. Acessando Variáveis de formulário
Dentro do script de PHP, você pode acessar cada um dos campos de formulário como uma
variável com o mesmo nome do campo de formulário.
Ex:.
Em um arquivo HTML que tenha o seguinte campo de formulário:
<input type=”text” name=”teste” size=20 maxlength=20>
Ao clicar em um botão submit e enviar estes dados para um arquivo PHP, o PHP receberá
uma variável de nome teste contendo o mesmo valor do campo de formulário do HTML.
As variáveis são tratadas pelo PHP com um sinal de $ (cifrão) no início. A variável teste do
exemplo anterior será tratada pelo PHP com $teste.
5. Tipos de dados no PHP
Para saber qual o tipo da variável basta utilizar a função do PHP gettype(). Cuja sintaxe é:
string gettype(variável). O resultado é a descrição do tipo da variável. Apesar da existência desta
função, ela não é muito utilizada, pois além de ser uma função de execução relativamente lenta, as
descrições dos tipos no PHP podem ser alteradas em versões futuras do PHP. Em vez disso o mais
aconselhável é utilizar as funções is_<tipo>, as quais retornam verdadeiro se a variável for do tipo
pesquisado. Sua sintaxe é: bool is_*(variável) <onde o * é o tipo a pesquisar>.
As funções is_* estão disponíveis em: is_interger(), is_string(), is_array(), is_bool(),
is_float(), is_null(), is_object(), is_resource() e is_string().
Existem ainda as funções is_numeric() e is_scalar(). A primeira retorna verdadeiro se a
variável for numérica ou uma string com números, já a segunda retorna verdadeiro se a variável for
~5~
PHP
_______________________________________________________________________________________________________________________
de um dos seguintes tipos escalares: inteiro, string, ponto flutuante ou booleano (arrays, objetos e
recursos não são escalares).
O PHP suporta os seguintes tipos de dados:
Escalares Compostos Especiais

• Integer – Utilizado para • Array – Utilizado para • Recursos (são variáveis
números inteiros; armazenar múltiplos itens especiais do PHP, as quais
• Double ou float ou real – de dados do mesmo tipo referenciam recursos
Utilizado para números (vetor e matriz); externos ao PHP);
reais (números inteiros • Object – Utilizado para • Nulo (null).
muito grandes podem ser armazenar instâncias de
considerados do tipo real Classes.
pelo PHP);
• String** – Utilizado para
uma série de caracteres
(para o PHP uma série é
exatamente um byte);
• Booleanos (true ou false).
**Strings. Para definir uma string, podemos utilizar aspas simples ou aspas duplas. Existem duas
vantagens básicas de utilizar aspas duplas, a primeira é a maior quantidade de caracteres especiais
disponíveis (caracteres escape), a segunda é que variáveis são expandidas quando utilizamos aspas
duplas (ao contrário das aspas simples). A tabela a seguir mostra os caracteres escape disponíveis.
Caracteres Resultado
\n Linefeed (LF)
\r Carriage return (CR)
\t Tab (HT)
\\ Barra invertida
\$ $
\’ Aspas simples
\” Aspas duplas
\0xxx Um número octal
\xXX Um número hexadecimal
5.1. Conversão de tipos de dados
No PHP é possível converter uma variável de um tipo para outro. Para isso deve-se utilizar os
conversores de tipos, os quais estão disponíveis os seguintes:
~6~
PHP
_______________________________________________________________________________________________________________________
• (int), (interger) – converte no tipo inteiro;

• (bool), (boolean) – converte em booleano;
• (float), (double), (real) – converte em ponto-flutuante;
• (string) – converte em string;
• (array) – converte em array;
• (object) – converte em objeto.
Seja a variável $total do tipo integer, para transforma-la em double usamos o seguinte código:
$total = (double)$total;.
Existem ainda outra forma de conversão de tipos de dados que é a automática. Na maioria das
vezes não é necessário a utilização dos conversores citados acima, pois o próprio PHP pode fazer isto
de forma automática. Desta forma, se uma variável é do tipo string e é somada a uma outra variável
do tipo inteiro, o PHP tenta convertê-la em inteiro.
6. Constantes
Como você viu anteriormente, podemos alterar o valor armazenado em uma variável.
Também podemos declarar constantes. Uma constante armazena um valor como uma variável, mas
seu valor é configurado uma vez e, então, não pode ser alterado em outra parte no script.
Declaramos uma constante de nome total e de valor 10: Define(“TOTAL”,10);
As constantes não usam o sinal de cifrão no seu inicio, veja: echo TOTAL;
7. Variáveis
Variáveis no PHP são representadas pelo sina $ (cifrão) seguido de um identificados único. A
regra para formação do identificados é a mesma para uma constante, ou seja:
• Deve iniciar por uma letra ou pelo símbolo subscrito (_);
• Pode conter letra, números ou subscrito (_).
Assim acontece com as constantes, o nome de uma variável é case-sensitive, ou seja, o PHP
diferencia letras maiúsculas de minúsculas, e diferentemente de constantes, não é possível mudar
esse comportamento.
7.1. Variáveis Superglobais
Dentro das variáveis predefinidas, o PHP disponibiliza as chamadas variáveis superglobais,

as quais estão disponíveis em qualquer lugar do script, sem que seja necessário declará-las globais. A
principal finalidade dessas variáveis é facilitar o acesso a dados enviados pelo servidor web (como,
por exemplo, campos de um formulário).
• $GLOBALS: retorna um array associativo com referência para toda e qualquer
variável atualmente disponível no escopo global do script. A chave desse array é o
nome das variáveis.
~7~
PHP
_______________________________________________________________________________________________________________________
• $SERVER: contém as variáveis com informações relativas ao servidor web e ao

ambiente de execução do script (exemplo: DOCUMENT_ROOT e PHP_SELF).
• $_GET: contém as variáveis enviadas pelo método GET.
• $_POST: contém as variáveis enviadas pelo método HTTP POST.
• $_COOKIE: contém as variáveis disponíveis como cookies, as quais são especiais,
gravadas nas máquinas do usuário e recuperada pelo browser.
• $_FILES: esse array contém informações de arquivos enviados pelo computador
cliente para o servidor web.
• $_REQUEST: este é um array com o mesmo conteúdo de $_GET, $_POST e
$_COOKIE juntos.
• $_SESSION: contém as variáveis registradas na sessão corrente.
8. Enviando resultado para o Browser
A propriedade básica do PHP é sua capacidade de enviar os resultados de seus scripts para o
browser, interagindo diretamente com o HTML. Isso é possível de várias formas:
• Comandos de echo e print;
Os comandos de echo() e print() não são realmente funções do PHP. Eles são o
que chamamos de construtores da linguagem, por isso os parênteses não são
obrigatórios. A sintaxe desses comandos são: echo (texto) e print(texto).
• Comando printf.
Sintaxe: printf(formato,[argumento]).
9. Operadores
9.1. Aritméticos
Operador Nome Utilização

+ Adição $a + $b
- Subtração $a - $b
* Multiplicação $a * $b
/ Divisão $a / $b
% Módulo $a % $b
9.2. De strings
Operador Nome
. concatenação
~8~
PHP
_______________________________________________________________________________________________________________________
9.3. De atribuição
Operador Nome
= atribuição simples
+= atribuição com adição
-= atribuição com subtração
*= atribuição com multiplicação
/= atribuição com divisão
%= atribuição com módulo
.= atribuição com concatenação
9.4. De comparação

== igual a $a = = $b
=== idêntico a $a = = = $b
!= não igual a $a != $b
<> não igual a $a <> $b
< menor que $a < $b
> maior que $a > $b
<= menor que ou igual a $a <= $b
>= maior que ou igual a $a >= $b
!= = não idêntico a $a ! = = $b
9.5. De incremento e decremento

++ incremento $a++;
-- decremento &b--;
9.6. Bit a bit

Operador Nome
& “e” lógico
| “ou” lógico
^ ou exclusivo
~ não (inversão)
<< shift left
>> shift right
~9~
PHP
_______________________________________________________________________________________________________________________
9.7. Lógicos
Operador Nome
and “e” lógico
or “ou” lógico
xor ou exclusivo
! não (inversão)
&& “e” lógico
|| “ou” lógico
9.8. Precedência
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) @
~ 10 ~
PHP
_______________________________________________________________________________________________________________________
10. Estruturas de controle
As estruturas a seguir são comuns para as linguagens de programação imperativas, bastando,

portanto, descrever a sintaxe de cada uma delas, resumindo o funcionamento.
10.1. Blocos
Um bloco consiste de vários comandos agrupados com o objetivo de relacioná-los com
determinado comando ou função. Em comandos como if, for, while, switch e em declarações de
funções blocos podem ser utilizados para permitir que um comando faça parte do contexto desejado.
Blocos em PHP são delimitados pelos caracteres “{” e “}”. A utilização dos delimitadores de bloco
em uma parte qualquer do código não relacionada com os comandos citados ou funções não
produzirá efeito algum, e será tratada normalmente pelo interpretador.
Exemplo:
if ($x == $y)
comando1;
comando2;
Para que comando2 esteja relacionado ao if é preciso utilizar um bloco:
if ($x == $y){
comando1;
comando2;
}
10.2. Comandos de seleção
Também chamados de condicionais, os comandos de seleção permitem executar comandos ou

blocos de comandos com base em testes feitos durante a execução.
10.2.1. if
O mais trivial dos comandos condicionais é o if. Ele testa a condição e executa o comando
indicado se o resultado for true (valor diferente de zero). Ele possui duas sintaxes:
if (expressão)
comando;
~ 11 ~
PHP
_______________________________________________________________________________________________________________________
if (expressão):
comando;
...
comando;
endif;
Para incluir mais de um comando no if da primeira sintaxe, é preciso utilizar um bloco,

demarcado por chaves.
O else é um complemento opcional para o if. Se utilizado, o comando será executado se a

expressão retornar o valor false (zero). Suas duas sintaxes são:
if (expressão)
comando;
else
comando;
if (expressão):
comando;
...
comando;
else
comando;
...
comando;
endif;
A seguir, temos um exemplo do comando if utilizado com else:
if ($a > $b)

$maior = $a;
else
$maior = $b;
O exemplo acima coloca em $maior o maior valor entre $a e $b
Em determinadas situações é necessário fazer mais de um teste, e executar condicionalmente

diversos comandos ou blocos de comandos. Para facilitar o entendimento de uma estrutura do tipo:
~ 12 ~
PHP
_______________________________________________________________________________________________________________________
if (expressao1)
comando1;
else
if (expressao2)
comando2;
else
if (expressao3)
comando3;
else
comando4;
foi criado o comando, também opcional elseif. Ele tem a mesma função de um else e um if usados
sequencialmente, como no exemplo acima. Num mesmo if podem ser utilizados diversos elseif’s,
ficando essa utilização a critério do programador, que deve zelar pela legibilidade de seu script.
O comando elseif também pode ser utilizado com dois tipos de sintaxe. Em resumo, a sintaxe
geral do comando if fica das seguintes maneiras:
if (expressao1)
comando;
[ elseif (expressao2)
comando; ]
[ else
comando; ]
if (expressao1) :
comando;
...
comando;
[ elseif (expressao2)
comando;
...
comando; ]
[ else
comando;
...
comando; ]
endif;
~ 13 ~
PHP
_______________________________________________________________________________________________________________________
10.2.2. switch
O comando switch atua de maneira semelhante a uma série de comandos if na mesma

expressão. Frequentemente o programador pode querer comparar uma variável com diversos valores,
e executar um código diferente a depender de qual valor é igual ao da variável. Quando isso for
necessário, deve-se usar o comando switch. O exemplo seguinte mostra dois trechos de código que
fazem a mesma coisa, sendo que o primeiro utiliza uma série de if’s e o segundo utiliza switch:
if ($i == 0)
print “i é igual a zero”;
elseif ($i == 1)
print “i é igual a um”;
elseif ($i == 2)
print “i é igual a dois”;
switch ($i) {
case 0:
break;
case 1:
break;
case 2:
break;
}
É importante compreender o funcionamento do switch para não cometer enganos. O comando

switch testa linha a linha os cases encontrados, e a partir do momento que encontra um valor igual ao
da variável testada, passa a executar todos os comandos seguintes, mesmo os que fazem parte de
outro teste, até o fim do bloco. por isso usa-se o comando break, quebrando o fluxo e fazendo com
que o código seja executado da maneira desejada. Veremos mais sobre o break mais adiante. Veja o
exemplo:
~ 14 ~
PHP
_______________________________________________________________________________________________________________________
switch ($i) {
case 0:
case 1:
case 2:
}
No exemplo acima, se $i for igual a zero, os três comandos “print” serão executados. Se $i
for igual a 1, os dois últimos “print” serão executados. O comando só funcionará da maneira
desejada se $i for igual a 2.
Em outras linguagens que implementam o comando switch, ou similar, os valores a serem
testados só podem ser do tipo inteiro. Em PHP é permitido usar valores do tipo string como
elementos de teste do comando switch. O exemplo abaixo funciona perfeitamente:
switch ($s) {
case “casa”:
print “A casa é amarela”;
case “arvore”:
print “a árvore é bonita”;
case “lampada”:
print “joao apagou a lampada”;
}
10.3. Comandos de repetição
10.3.1. while
O while é o comando de repetição (laço) mais simples. Ele testa uma condição e executa um
comando, ou um bloco de comandos, até que a condição testada seja falsa. Assim como o if, o while
também possui duas sintaxes alternativas:
while (<expressao>)
<comando>;
while (<expressao>):
<comando>;
...
<comando>;
endwhile;
~ 15 ~
PHP
_______________________________________________________________________________________________________________________
A expressão só é testada a cada vez que o bloco de instruções termina, além do teste inicial.
Se o valor da expressão passar a ser false no meio do bloco de instruções, a execução segue até o
final do bloco. Se no teste inicial a condição for avaliada como false, o bloco de comandos não será
executado.
O exemplo a seguir mostra o uso do while para imprimir os números de 1 a 10:
$i = 1;
while ($i <=10)
print $i++;
10.3.2. do... while
O laço do..while funciona de maneira bastante semelhante ao while, com a simples diferença
que a expressão é testada ao final do bloco de comandos. O laço do..while possui apenas uma
sintaxe, que é a seguinte:
do {
<comando>
...
<comando>
} while (<expressao>);
O exemplo utilizado para ilustrar o uso do while pode ser feito da seguinte maneira utilizando
o do.. while:
$i = 0;
do {
print ++$i;
} while ($i < 10);
10.3.3. for
O tipo de laço mais complexo é o for. Para os que programam em C, C++ ou Java, a
assimilação do funcionamento do for é natural. Mas para aqueles que estão acostumados a
linguagens como Pascal, há uma grande mudança para o uso do for. As duas sintaxes permitidas são:
for (<inicializacao>;<condicao>;<incremento>)
<comando>;
~ 16 ~
PHP
_______________________________________________________________________________________________________________________
for (<inicializacao>;<condicao>;<incremento>) :
<comando>;
...
<comando>;
endfor;
As três expressões que ficam entre parênteses têm as seguintes finalidades:
• Inicialização: comando ou sequencia de comandos a serem realizados antes do

inicio do laço. Serve para inicializar variáveis.
• Condição: Expressão booleana que define se os comandos que estão dentro do
laço serão executados ou não. Enquanto a expressão for verdadeira (valor diferente
de zero) os comandos serão executados.
• Incremento: Comando executado ao final de cada execução do laço.
Um comando for funciona de maneira semelhante a um while escrito da seguinte forma:
<inicializacao>
while (<condicao>) {
comandos
...
<incremento>
}
10.4. Quebra de fluxo
10.4.1. Break
O comando break pode ser utilizado em laços de 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;
...
}
~ 17 ~
PHP
_______________________________________________________________________________________________________________________
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.
10.4.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.
11. Funções
11.1. Definindo funções
A sintaxe básica para definir uma função é:
function nome_da_função([arg1, arg2, arg3]) {

Comandos;
... ;
[return <valor de retorno>];
}
Qualquer código PHP válido pode estar contido no interior de uma função. Como a checagem
de tipos em PHP é dinâmica, o tipo de retorno não deve ser declarado, sendo necessário que o
programador esteja atento para que a função retorne o tipo desejado. É recomendável que esteja tudo
bem documentado para facilitar a leitura e compreensão do código. Para efeito de documentação,
utiliza-se o seguinte formato de declaração de função:
tipo function nome_da_funcao(tipo arg1, tipo arg2, ...);
~ 18 ~
PHP
_______________________________________________________________________________________________________________________
Este formato só deve ser utilizado na documentação do script, pois o PHP não aceita a
declaração de tipos. Isso significa que em muitos casos o programador deve estar atento aos tipos dos
valores passados como parâmetros, pois se não for passado o tipo esperado não é emitido nenhum
alerta pelo interpretador PHP, já que este não testa os tipos.
11.2. Valor de retorno
Toda função pode opcionalmente retornar um valor, ou simplesmente executar os comandos e

não retornar valor algum.
Não é possível que uma função retorne mais de um valor, mas é permitido fazer com que uma
função retorne um valor composto, como listas ou arrays.
11.3. Argumentos
É possível passar argumentos para uma função. Eles devem ser declarados logo após o nome
da função, entre parênteses, e tornam-se variáveis pertencentes ao escopo local da função. A
declaração do tipo de cada argumento também é utilizada apenas para efeito de documentação.
Exemplo:
function imprime($texto){
echo $texto;
}
imprime(“teste de funções”);
11.3.1. 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
~ 19 ~
PHP
_______________________________________________________________________________________________________________________
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;
}
$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. */
11.3.2. 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($vivas = “testando”) {

echo $vivas;
}
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:
~ 20 ~
PHP
_______________________________________________________________________________________________________________________
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 é: */
function teste2($cor, $figura = circulo) {

echo “a figura é um “, $figura, “ de cor “ $cor;
}
teste2(azul);
/* Aqui a funcao funciona da maneira esperada, ou seja, imprime o texto: “a figura é um

círculo de cor azul” */
11.4. Contexto
O contexto é o conjunto de variáveis e seus respectivos valores num determinado ponto do

programa. Na chamada de uma função, ao iniciar a execução do bloco que contém a implementação
da mesma é criado um novo contexto, contendo as variáveis declaradas dentro do bloco, ou seja,
todas as variáveis utilizadas dentro daquele bloco serão eliminadas ao término da execução da
função.
11.5. Escopo
O escopo de uma variável em PHP define a porção do programa onde ela pode ser utilizada.
Na maioria dos casos todas as variáveis têm escopo global. Entretanto, em funções definidas pelo
usuário um escopo local é criado. Uma variável de escopo global não pode ser utilizada no interior
de uma função sem que haja uma declaração.
Exemplo:
$vivas = “Testando”;
function Teste() {
echo $vivas;
}
Teste();
~ 21 ~
PHP
_______________________________________________________________________________________________________________________
O trecho acima não produzirá saída alguma, pois a variável $vivas é de escopo global, e não
pode ser referida num escopo local, mesmo que não haja outra com nome igual que cubra a sua
visibilidade. Para que o script funcione da forma desejada, a variável global a ser utilizada deve ser
declarada.
Exemplo:
$vivas = “Testando”;
function Teste() {
global $vivas;
echo $vivas;
}
Teste();
Uma declaração “global” pode conter várias variáveis, separadas por vírgulas. Uma outra
maneira de acessar variáveis de escopo global dentro de uma função é utilizando um array pré-
definido pelo PHP cujo nome é $GLOBALS. O índice para a variável referida é o próprio nome da
variável, sem o caracter $. O exemplo acima e o abaixo produzem o mesmo resultado:
Exemplo:
$vivas = "Testando";
function Teste() {
echo $GLOBALS["vivas"]; // imprime $vivas
echo $vivas; // não imprime nada
}
Teste();
12. Manipulando Strings
Funções para manipulação de strings:
* addslashes(string) - adiciona barras invertidas a string;
* explode(separador,string,limite) - divide uma string retornando as partes em um array;
* implode(separador,array) - retorna uma string representando todos os elementos do array

informado e separando os elementos com o separador informado;
~ 22 ~
PHP
_______________________________________________________________________________________________________________________
* trim(texto, conjunto_caracteres) - elimina espaços em branco do início e do final da

string;
* ltrim(valor, caracteres) - elimina espaços em branco do início da string;
* rtrim(texto,caracteres) – retorna a string informada sem espaços a direita;
* chop() - elimina espaços em branco do final;
* number_format(numero, quantidade_de_casas_decimais, separador_de_casas_decimais,

separador_mil) – quando for necessário formatar um número, para que seja exibido um separador de
milhares e um separador decimal;
* str_ireplace / str_replace(texto_src, texto_rep, texto_princ, cont) – executam a busca e a

substituição de um texto por outro dentro de uma string informada. A diferença entre essas duas
funções está no fato de que str_replace é case sensitive, isto é, diferencia maiúsculas de minúsculas,
enquanto str_ireplace não faz diferença entre maiúsculas e minúsculas. Em texto_src é o texto que
deve ser procurado em texto_princ, text_rep é que irá substituir todas as ocorrências de text_src em
texto_princ, e cont é opcional e se for informada, receberá o número de trocas efetuadas (esse
parâmetro está disponível apenas na versão 5 do PHP);
*str_split(texto, num_caracteres) – retorna um array com os caracteres existentes na string

informada, podendo opcionalmente ser atribuído o tamanho em número de caracteres para cada um
dos elementos do array (o padrão é um caractere para cada elemento do array).
* strlen(texto) - retorna o tamanho da string;
* strrev(texto) - retorna a string de forma invertida;
* strtoupper(texto) – converte a string para letras maiúsculas;
* strtolower(texto) – converte a string para letras minúsculas;
* ucfirst(texto) – coloca o primeiro caractere em letra maiúscula;
* ucwords(texto) - coloca cada primeira letra de cada palavra em maiúscula;
* strpslashes(texto) – desfaz o efeito de addslashes;
* substr(texto,posição_inicial,tamanho) – retorna um pedaço da string informada

(substring);
* strstr(texto, texto_src, texto_troca) – executa a busca e troca de caracteres (um ou vários)

por outros dentro de uma string definida. Procura uma substring dentro de uma string. Retorna a
string a partir da primeira ocorrência da substring;
~ 23 ~
PHP
_______________________________________________________________________________________________________________________
* stristr() - idêntica a strstr(), só que não diferencia maiúsculas de minúsculas;
13. Arrays
Um array, também conhecido como vetor ou lista, é uma das formas elementares de estrutura
de dados presente nas linguagens de programação. No PHP, um array pode conter elementos de
qualquer tipo (inteiro, string, booleano, etc.), diferentemente de outras linguagens que exigem a
definição do array para um único tipo de dado.
Um array pode ser unidimensional ou bidimensional, em que um elemento do array aponta
para outro array.
Os elementos de um array no PHP podem ser acessados por meio de índices (0, 1, 2, ...) ou
por chaves associativas (“cor”, “nome”, ...).
13.1. Criando Arrays no PHP
O PHP disponibiliza dois métodos para criação de arrays:

- pelo método construtor Array(): neste método utilizamos o construtor Array() para informar
ao PHP que a variável será um array. Podemos criar um array vazio ou então informar todos os seus
elementos ou parte deles para criação do array (exemplo: $arr = Array();).
- pelo método criação implícita: neste método não declaramos o array antes de utilizá-lo,
desta forma o PHP, ao encontrar uma referência ao array, automaticamente vai criá-lo. Para tanto
precisamos apenas utilizar colchetes após o nome da variável, informando um índice, uma chave
associativa, ou simplesmente “[ ]”(exemplo: $arr[] = “texto”).
13.2. Manipulando os elementos de um Array
Para acessar os elementos de um array, devemos referenciar a variável seguida de colchetes

“[ ]” e o índice, ou chave associativa (caso não seja informado nem um nem outro, ou seja, somente
os colchetes, o PHP entenderá que se trata da inserção de um novo elemento no array).
O PHP indexa os arrays pela posição 0. Desta forma um array de dez elementos terá índices
variando de 0 a 9.
Caso o índice ou a chave associativa informada não exista no array, o PHP insere um novo
elemento no array, o mesmo acontecendo se informarmos apenas os colchetes. No caso de
informarmos apenas os colchetes, sem nenhum valor (índice ou chave associativa), o PHP pega o
maior índice existente no array (não o último informado, ou o primeiro livre) e soma um a esse
índice (caso o array não exista, o PHP coloca o valor no índice 0).
13.3. Funções para manipulação de Arrays
O PHP disponibiliza uma grande quantidade de funções para manipulação de arrays, as quais
são muito úteis no dia-a-dia da programação.
A função sizeof(array,modo) ou count(array,modo) retorna a quantidade de elementos de um
array. O parâmetro modo é opcional e admite os valores 0 e 1 (ou COUNT_RECURSIVE). Zero é o
valor-padrão e indica ao PHP para contar apenas o primeiro nível do array informado. Caso 1 ou
COUNT_RECURSIVE seja informado, a função retorna o número total de elementos do array,
incluindo todos os níveis existentes.
~ 24 ~
PHP
_______________________________________________________________________________________________________________________
Exemplo:
<?php
$_arr = Array(2,7,”a”=>array(5,8,9),”b”,13,17);
echo count($_arr);
echo “<br/>”;
echo count($_arr, COUNT_RECURSIVE);
?>
O resultado sera 6/9.
* array_values(array) – retorna todos os valores de um array, desprezando os índices

(numéricos ou não);
* array_sum(array) – retorna a soma de todos os elementos numéricos, ou que possam ser convertidos
em números do array.
* array_splice(array, início, tamanho, array_inserção) – retira uma parte do array informado na

função, e caso seja informado, insere outros elementos no array.
* array_slice(array, início, tamanho) – retorna um pedaço do array informado.
* array_search(valor, array, modo) – faz uma pesquisa no array informado, procurando o valor
informado na função. Caso o valor seja encontrado, retorna o índice correspondente no array, caso contrário
retorna FALSE. Se o valor for encontrado várias vezes no array, a função irá retornar o primeiro índice em
que o valor aparece.
* array_reverse(array, manter_indices) – esta função retorna um array na ordem inversa do array

informado, ou seja, o último elemento do array informado será o primeiro elemento do novo array e o
penúltimo será o segundo e assim sucessivamente, até o primeiro elemento do array informado, o qual será o
último do array resultante da função. O parâmetro opcional manter_índices indica à função para realizar a
inversão, porém mantendo os índices do array original.
* array_multisort(array_1, ordem, modo, array_2, ...) – permite a classificação de um ou vários arrays,

sendo possível também estabelecer a ordem de classificação (ascendente ou descendente), bem como o modo
(regular, tratar como numéricos e tratar como strings os valores existentes). Os índices não-numéricos (chaves
associativas) são mantidos, enquanto os numéricos são reindexados. Ordem: SORT_ASC (classificação
ascendente), SORT_DESC (classificação descendente). Modos: SORT_REGULAR (compara os valores da
forma-padrão), SORT_NUMERIC (compara os valores como números), SORT_STRING (compara os valores
como strings).
* array_merge(array_1, array_2, array_3...) – nesta função temos como resultado a combinação de

dois ou mais arrays. Os elementos do segundo array são anexados ao final dos elementos do primeiro array, e
os elementos do terceiro são anexados ao final dos elementos do array resultante da combinação do primeiro
com o segundo e assim sucessivamente.
* array_keys(array, critério) – retorna um array com todos os índices de um array. O critério é

opcional e caso seja informado, faz com que a função retorne apenas os índices cujo valor coincida com o
informado na função.
~ 25 ~
PHP
_______________________________________________________________________________________________________________________
* array_key_exists(índice, array) – verifica se um determinado valor existe como índice do array

informado. Caso exista, retorna TRUE, caso contrário, retorna FALSE.
* array_count_values(array) – retorna um array com a freqüência dos valores existentes (número de

vezes que o valor aparece dentro do array) em um dado array, e os índices desse novo array são os valores
existentes no array original.
* array_chunk(array, tamanho, modo) – o resultado será um array multidimensional contendo os

pedaços do array original conforme o parâmetro tamanho. Caso o parâmetro opcional modo (booleano) seja
informado como TRUE, os índices do array original serão preservados no novo array multidimensional.
* array_change_key_case(array,tipo) – esta função retorna um array em que todas as chaves

associativas do array dado são convertidas em maiúsculas ou minúsculas.
13.4. Foreach
O foreach permite que seja realizada uma varredura completa em arrays, e deve ser utilizado somente
com estes. Quaisquer outras variáveis ou mesmo uma variável não inicializada causará um erro no script. O
que foreach faz é varrer todo o array e retornar seus valores ou opcionalmente suas chaves e valores.
Existem duas sintaxes para foreach. A primeira retorna somente os valores e a segunda retorna tanto
as chaves quanto os valores do array informado. São elas:
1ª – foreach(array as variável_valor);
2ª – foreach(array as variável_chave => variável_valor).
Desta forma temos que a cada iteração o valor do elemento atual, ou a chave e o valor do elemento
atual são retornados nas variáveis especificadas e o ponteiro do array é movido para o próximo elemento do
array. Caso não exista mais nenhum elemento no array o foreach é terminado.
Exemplo:
<?php
$arr = array(10,15,23,56,101,205);
foreach($arr as $vlr){
echo “$vlr <br/>”;
}
$arr_2 = array(“um” => “one”,
“dois” => “two”,
“três” => “three”,
“quatro” => “four”,
“cinco” => “five”);
foreach($arr_2 as $chv => $vlr){
echo “$chv = $vlr <br/>”;
}
?>
Caso o valor informado seja multidimensional, o conteúdo retornado em variável_valor será também
um array. Desta forma, para acessarmos os valores finais deste array, devemos utilizar vários comandos
foreach aninhados, por exemplo:
<?php
$arr[0][0] = 10;
$arr[0][1] = 50;
$arr[1][0] = 12;
$arr[1][1] = 23;
$arr[1][3] = 35;
~ 26 ~
PHP
_______________________________________________________________________________________________________________________
$arr[2][1] = 10;
foreach($arr as $chv => $vlr){
foreach($vlr as $chv_1 => $vlr_1){
echo “\$arr [$chv][$chv_1] = $vlr_1 <br/>”;
}
}
?>
O resultado do script é:
$arr[0][0] = 10
$arr[0][1] = 50
$arr[1][0] = 12
$arr[1][1] = 23
$arr[1][3] = 35
$arr[2][1] = 10
14. Arquivos
De vez em quando é necessário ler, alterar ou criar arquivos no servidor de Internet, como por
exemplo, para criar contadores de acesso, estatísticas de visitas ou guardar algumas informações para
visualizações posteriores que são demoradas para serem criadas pelo servidor, e que não seria muito
bom gerá−las sempre que um visitante as quisesse ver.
O PHP fornece um conjunto de funções muito boas para isto, e com alguns cuidados, os
scripts funcionarão tanto em Windows como em Linux sem nenhuma alteração. Todas essas funções
podem ser encontradas no manual do php, em "Filesystem functions".
14.1. Abrindo arquivo
A primeira função que se deve conhecer para trabalhar com arquivos é a que cria uma ligação
entre o script e o arquivo propriamente dito:
int fopen( string arquivo, string modo [, int usa_include_path] );
Esta função devolve um ponteiro para um arquivo, que é utilizado em outras funções para
lidar com arquivos. O primeiro parâmetro, arquivo, é uma string que indica o local do arquivo a ser
aberto, aqui vai a primeira dica: não utilize o modo de referência do windows, como
c:\www\arquivo.txt, pois não irá funcionar num servidor Linux. Evite também ler e gravar arquivos
fora do diretório onde o seu site está hospedado, às vezes torna−se difícil criar um diretório fora do
diretório do site, e, se um dia quiser transferir o seu site para uma outra máquina, pode acontecer que
esqueça daquele diretório isolado. Vamos supor que o site tem um subdiretório "tmp" e que tem
dentro um arquivo novidades.txt. Para abrir o arquivo usamos:
<?php
$fd = fopen( "tmp/novidades.txt", "r" );
...
?>
~ 27 ~
PHP
_______________________________________________________________________________________________________________________
Note que mesmo que este script seja executado em windows ele irá funcionar. Nada melhor
que programar com uma linguagem que funciona em vários sistemas operacionais sem alterações.
O segundo parâmetro para informar ao PHP que o arquivo deve ser aberto só para leitura, os
modos possíveis podem ser:
r − só leitura, coloca o ponteiro no início do arquivo;
r+ − leitura e gravação, coloca o ponteiro no início do arquivo;
w − só gravação, limpa o arquivo (deixa−o com 0 bytes) e coloca o ponteiro no início do
arquivo. Se o arquivo não existir, tenta criá−lo.
w+ − leitura e gravação, limpa o arquivo (deixa−o com 0 bytes) e coloca o ponteiro no início
do arquivo. Se o arquivo não existir, tenta criá−lo.
a − só gravação, coloca o ponteiro no final do arquivo. Se o arquivo não existir, tenta criá−lo.
a+ − leitura e gravação, limpa o arquivo (deixa−o com 0 bytes) e coloca o ponteiro no final
do arquivo. Se o arquivo não existir, tenta criá−lo.
O terceiro parâmetro é opcional, se seu valor for 1, o php irá procurar nos diretórios
informados na configuração "include_path" do php.ini.
Se a função fopen falhar ao abrir ou ao criar o arquivo, ela retorna false. Note que se for
utilizado o parâmetro "r"(somente leitura) ou "r+" e o arquivo não existir, a função fopen não irá
tentar criá−lo, simplesmente retornará um erro, e mostrará um aviso no browser do utilizador.
14.2. Fechando arquivo
Depois de aberto ou criado o arquivo, é sempre bom deixar a mesa arrumada após o serviço,
portanto devemos fechar o arquivo. É muito fácil:
int fclose( int fp );
O parâmetro fp é o ponteiro de arquivo que foi retornado pela função fopen(), no nosso caso
$fd. Esta função retorna true se o arquivo foi fechado e false se não foi possível fechar o arquivo. O
arquivo precisa ser fechado no mesmo script que o abriu.
14.3. O que fazer com arquivos?
Nem só de abrir e fechar arquivos vive um script php, é necessário fazer alguma coisa com
eles. A "coisa" mais fácil é mostrar o conteúdo do arquivo no browser do utilizador, para isso
utilizamos a função "int fpassthru( int fp )". Então, para mostrar o arquivo novidades.txt, que contém
as últimas notícias da semana diretamente para o browser do utilizador, o script fica assim:
<?php
$fd = fopen( "tmp/novidades.txt", "r" ) or die( "ops, avise o webmaster, tem arquivo
faltando no servidor");
fpassthru( $fd );
?>
A função fpassthru lê a partir da posição atual do ponteiro até ao final do arquivo e fecha o
arquivo, portanto, neste caso não é necessário utilizar a função fclose(). Ao executar este script,
notará que o arquivo novidades.txt saiu com as linhas juntas, para resolver isto coloca um <br> no
final de cada linha do arquivo ou deixa o script entre as tags <pre>. Se tentar colocar alguns scripts
php dentro do arquivo novidades.txt notará que eles serão mostrados no browser do utilizador e não
~ 28 ~
PHP
_______________________________________________________________________________________________________________________
serão processados pelo php. Se quiser adicionar um script php á página, utiliza include ou require. Se
só for necessário mostrar o arquivo novidades diretamente no browser sem precisar de posicionar o
ponteiro, utilize a função readfile, que abre o arquivo, mostra e fecha o mesmo:
<?php
if (!readfile( "tmp/novidades.txt") ) die ("ops, chame o webmaster!");
?>
Claro, existem muitas funções para ler o arquivo: (todas elas dependem do ponteiro do
arquivo, e não do fato de fechar o arquivo)
− string fread( int fp, int tamanho )
Lê o arquivo a partir da posição atual do ponteiro no arquivo até ao tamanho em bytes ou até
o final do arquivo, o que acontecer primeiro, e devolve como uma string.
<?php
// este script faz a mesma coisa que o anterior
if( $fd = fopen( "tmp/novidades.txt", "r" ) ) {
while( !feof( $fd ) ) {
$novidades = fread( $fd, 1024 );
print $novidades;
}
fclose($fd);
}
?>
Enquanto não chegar ao final do arquivo ( feof() ), lê até 1024 bytes do arquivo para a
variável $novidades e imprime seu conteúdo.
− string fgetc( int fp )
Lê só um caractere do arquivo. Não utilize esta função para ler mais do que um caractere de
um mesmo arquivo, não é eficiente, é mais eficiente ler o arquivo em blocos para a memória e fazer
o processamento na memória, pois o acesso ao disco é extremamente lento se comparado com o
acesso à memória, e aceder ao disco para ler um só caractere para processar é um enorme desperdício
de recursos do servidor.
− string fgets( int fp, int tamanho )
Se precisa ler o arquivo linha á linha, utilize esta função. Ela lê até que 1 byte seja lido, que
encontre o final de uma linha (que é incluída no resultado), ou final do arquivo e devolve como uma
string. Para ler até 10 bytes de um arquivo, utilize:
$texto = fgets( $fd, 11 );
− string fgetss( int fp, int tamanho [, string tagspermitidas] )
~ 29 ~
PHP
_______________________________________________________________________________________________________________________
Idêntica à função fgets, só que os tags html e php serão ignoradas. Se for necessário deixar
algumas tags passarem pela função, utilize o parâmetro opcional tagspermitidas, por exemplo, para
ler um arquivo novamente, mas deixe só as tags <br>, <b></b> e <p></p> serem exibidas, use:
$texto = fgetss( $fd, 1024, "<br><b><p>" );
Mesmo podendo selecionar quais tags que podem passar pela função, se este arquivo vier de
fora, ou seja, é um arquivo que uma pessoa manda pela internet para mostra no site, alguém pode
mandar algum código javascript malicioso dentro de uma tag, e executar comandos indevidos na
máquina do visitante do seu site. Cuidado!
array file( string arquivo [, int usa_include_path ] )
Lê o arquivo inteiro e coloca cada linha do arquivo numa tabela. Esta função utiliza como
parâmetro o nome do arquivo, portanto não é necessário abrir nem fechar o arquivo para usar esta
função. Vamos ao exemplo:
Supondo que o arquivo novidades.txt tem uma novidade por linha, similar a este:
novidade.txt:
Nova versão do php acaba de ser lançada!

Linux eleito melhor sistema operativo do mundo!
*Encontrado mais um furo de segurança no dind.
O número de servidores linux cresce a cada dia!
Queremos mostrar cada linha do arquivo novidades com um fundo diferente, e ainda por cima
as linhas que contém um * no início devem ser exibidas em negrito:
<html>
<head>
<title>Novidades</title>
</head>
<body>
<?php
$txt = file("tmp/novidades.txt");
if(!$txt) {
print "Sem novidades por hoje, só o webmaster é que vai
receber um arquivo";
exit();
}
// count retorna o número de índices da tabela
$tot = count($txt);
?>
<table width="500" align="center" bgcolor="white" cellpadding="1"
cellspacing="0">
<?php
for($i=0;$i<$tot;$i++) {
// ct vai ler o primeiro caractere da linha
~ 30 ~
PHP
_______________________________________________________________________________________________________________________
$ct=$txt[$i][0];
// Chop elimina espaços do final da string e finais de linha
também
$linha = Chop($txt[$i]);
// Seleciona a cor de fundo para a linha
if( $cor == "#DCDCDC" )
$cor = "#DCDCFF";
else
$cor = "#DCDCDC";
print "<tr><td bgcolor='$cor'>";
// strip_tags elimina todas as tags html e php, como fgetss
// se a linha começa com um *, le a partir do próximo caractere
// o ponto serve para concatenar as strings
if( $ct == "*" )
print "<b>".strip_tags(substr($linha,1))."</b>";
else
print strip_tags($linha);
print "</td></tr>";
}
?>
</table>
</body>
</html>
~ 31 ~

Apostila PHP

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Apostila PHP

Enviado por

Direitos autorais:

Formatos disponíveis

Faculdade FORTIUM

Curso de Sistemas de Informação

Prof. Giselle Barbosa Gomes Machado

2. Utilizando TAGS no PHP................................................................................................................ 5

4. Acessando Variáveis de formulário ................................................................................................ 5

5. Tipos de dados no PHP .................................................................................................................... 5

8. Enviando resultado para o Browser............................................................................................... 8

10. Estruturas de controle ................................................................................................................. 11

12. Manipulando strings .................................................................................................................... 22

13. Arrays ........................................................................................................................................... 24

14. Arquivos ....................................................................................................................................... 27

O PHP é acrônimo de Hypertext Preprocessor (pré-processador de hipertexto), uma poderosa

1.2. O que pode ser feito com PHP?

1.3. Como surgiu a linguagem PHP?

1.4. Visão Geral do PHP

2. Utilizando TAGS de PHP

Os comentários de linhas iniciam com // ou #.

4. Acessando Variáveis de formulário

5. Tipos de dados no PHP

Escalares Compostos Especiais

5.1. Conversão de tipos de dados

• (int), (interger) – converte no tipo inteiro;

7.1. Variáveis Superglobais

Dentro das variáveis predefinidas, o PHP disponibiliza as chamadas variáveis superglobais,

• $SERVER: contém as variáveis com informações relativas ao servidor web e ao

8. Enviando resultado para o Browser

Operador Nome Utilização

Operador Nome Utilização

9.5. De incremento e decremento

Operador Nome Utilização

9.6. Bit a bit

Precedência Associatividade Operadores

10. Estruturas de controle

As estruturas a seguir são comuns para as linguagens de programação imperativas, bastando,

Para que comando2 esteja relacionado ao if é preciso utilizar um bloco:

10.2. Comandos de seleção

Também chamados de condicionais, os comandos de seleção permitem executar comandos ou

Para incluir mais de um comando no if da primeira sintaxe, é preciso utilizar um bloco,

O else é um complemento opcional para o if. Se utilizado, o comando será executado se a

A seguir, temos um exemplo do comando if utilizado com else:

if ($a > $b)

O exemplo acima coloca em $maior o maior valor entre $a e $b

Em determinadas situações é necessário fazer mais de um teste, e executar condicionalmente

O comando switch atua de maneira semelhante a uma série de comandos if na mesma

É importante compreender o funcionamento do switch para não cometer enganos. O comando

10.3. Comandos de repetição

10.3.2. do... while

As três expressões que ficam entre parênteses têm as seguintes finalidades:

• Inicialização: comando ou sequencia de comandos a serem realizados antes do

Um comando for funciona de maneira semelhante a um while escrito da seguinte forma:

10.4. Quebra de fluxo

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

11.1. Definindo funções

A sintaxe básica para definir uma função é:

function nome_da_função([arg1, arg2, arg3]) {

tipo function nome_da_funcao(tipo arg1, tipo arg2, ...);

11.2. Valor de retorno

Toda função pode opcionalmente retornar um valor, ou simplesmente executar os comandos e

11.3.1. 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

function mais5(&$num1, $num2) {

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

11.3.2. Argumentos com valores pré-definidos (default)

function teste($vivas = “testando”) {