Apostila PHP

“Deus é fiel!
Sem Ele nada somos e nada faríamos”
Prof° Alexandre EUGÊNIO da Silva
Rua da Quitanda 185

Centro - Rio de Janeiro - RJ
Telefone: (021) 2233-4982 / 2233-6186 cursoadonai@yahoo.com.br
Curso Adonai Disciplina Linguagem PHP
SUMÁRIO
1. Estrutura e visão geral da linguagem
1.1. Interação entre PHP e HTML
1.2. Identificadores
1.3. Variáveis
1.4. Constantes
1.5. Operadores
1.6. Estruturas de controle
2. Arrays
3. Manipulação de strings
4. Utilização de funções
5. Conceitos e implementação de orientação a objeto:
5.1. Classe
5.2. Objeto
5.3. Herança
5.4. Criação de objetos
5.5. Controle de acesso
Profº Alexandre Eugênio da Silva Página 1

1. Estrutura e visão geral da linguagem
PHP (um acrônimo recursivo para "PHP: Hypertext Preprocessor") é uma linguagem de script Open
Source de uso geral, muito utilizada e especialmente utilizada para o desenvolvimento de aplicações
Web.
Programas ou aplicaçãos desenvolvidas para WEB através de uma linguagem de script como PHP
possuem um escopo muito diferente em relação aos mesmos desenvolvidos para Desktop
(programas que rodam no computador do usuário).
Primeiramente alguns conceitos devem ser muito bem entendidos para que possamos analisar o
comportamento desse tipo de desenvolvimento:
Scripts – Um script como o próprio nome sugere, nada mais é que uma sequência de rotinas ou
instruções que nos retornarão um resultado esperado.
Dentro do contexto WEB, os scripts são arquivos de texto1 os quais colocamos os códigos-fonte da
linguagem de programação utilizada.
Server Side – Existem scripts do tipo “Server Side”, os mesmo são interpretados (processados /
executados) pelo Servidor WEB que os retornam para o Navegador WEB cliente.
Client Side – Scripts do tipo “Client Side”, são interpretados (processados / executados) pelo
Navegador WEB do cliente. O script “Client Side”, mais utilizado no mundo é o JAVASCRIPT.
1 – Arquivo de texto – Este arquivo texto possuirá a extensão da linguagem empregada. Exemplo: .php para script PHP; .asp
para linguagem ASP; .aspx para linguagem .NET; .jsp para linguagem JAVA para WEB.

1.1. Interação entre PHP e HTML
Página PHP
Crie um novo arquivo chamado ola.php e coloque-o em seu diretório root do seu servidor web com o
seguinte conteúdo:
Ex.: Nosso primeiro script PHP: ola.php
<html>
<head>
<title>PHP Teste</title>
</head>
<body>
<?php echo "<p>Olá Mundo</p>"; ?>
</body>
</html>
Use o seu navegador para acessar o arquivo pelo endereço de seu servidor web, ao final do endereço
coloque o arquivo "/ola.php" como referência.
Quando o desenvolvimento é local você usará uma url como esta http://localhost/ola.php ou
http://127.0.0.1/ola.php.
Se tudo foi configurado corretamente, o arquivo irá ser interpretado pelo PHP e irá mostrar a
seguinte mensagem de saída no seu navegador:
Saída no navegador Código-fonte
Olá Mundo <html>

<head>
<title>PHP Teste</title>
</head> <body>
<p>Olá Mundo</p>
</body>
</html>
Note que isto não é como em um script CGI. O arquivo não precisa ser executável ou especial em
nenhum aspecto. Pense nesse arquivo como um arquivo HTML normal mas com a diferença que ele
pode conter algumas tags especiais à mais que permitem a você fazer coisas mais interessantes do
que somente páginas HTML estáticas.
Este exemplo é extremamente simples e você realmente não precisa usar o PHP para criar uma
página como esta. Tudo o que ele faz é mostrar uma mensagem Olá Mundo usando a declaração
echo() do PHP.
O objetivo do exemplo é mostrar o formato especial das tags do PHP. Neste exemplo nós usamos
<?php para indicar que à partir daquele ponto começa um código PHP. Então nós colocamos uma
declaração de fechamento para indicar que o script PHP acabou, usando a tag ?>. Você pode usar o
PHP em qualquer parte do seu código HTML, e também pode usar várias tags de abertura e
fechamento no mesmo arquivo.

1.2. Identificadores
Os identificadores são os nomes de variáveis, funções e classes. Há algumas regras simples sobre
indentificadores:
• Os identificadores podem ser de qualquer comprimento e podem consister em letras,

números, sublinhados e sinais de cifrão;
• Os identificadores não podem iniciar com um dígito;
• Diferenciam letras maiúsculas e minúsculas. Os nomes de funções são uma exceção a essa
regra.
• Uma variável pode ter o mesmo nome que uma função. Mas isso é confuso e deve ser
evitado.
• Além disso, você não pode criar uma função com o mesmo nome de outra.
<?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
$täyte = 'mansikka'; // válido; 'ä' é um caracter ASCII (extendido) 228
?>
1.3. Variáveis
As variáveis no PHP são representadas por um cifrão ($) seguido pelo nome da variável. Os nomes
de variável no PHP fazem distinção entre maiúsculas e minúsculas.
$this é uma variável especial que não pode ser atribuída.
Tipos
Booleanos
Este é o tipo mais fácil. Um booleano expressa um valor de verdade. Ele pode ser TRUE ou FALSE.
Sintaxe
Para especificar um literal booleano, use as palavras chave TRUE ou FALSE. Ambas são insensitivas
ao caso.
<?php
$foo = True; // assimila o valor TRUE para $foo
?>

Usualmente você pode utilizar algum tipo de operador que retorne um valor booleano, e passá-lo
para uma estrutura de controle.
<?php
// == é um operador que testa
// igualdade e retorna um booleano
if ($action == "mostrar_versao") {
echo "A versão é 1.23";
}
// isto não é necessário ...
if ($exibir_separadores == TRUE) {
echo "<hr>\n";
}
// ... porque você pode simplesmente escrever isso:
if ($exibir_separadores) {
echo "<hr>\n";
}
?>
Convertendo para booleano
Para converter explicitamente um valor para booleano, utilize-se dos modificadores (bool) ou
(boolean). Entretanto, na maioria dos casos, você não precisa utilizar o modificador, desde que
qualquer valor será convertido automaticamente se um operador, função ou estrutura de controle
requerer um argumento booleano.
Veja também Manipulação de tipos.
Quando convertendo para booleano, os seguintes valores são considerados FALSE:
• o próprio booleano FALSE

• o inteiro 0 (zero)
• o ponto flutuante 0.0 (zero)
• uma string vazia e a string "0"
• um array sem elementos
• o tipo especial NULL (incluindo variáveis não definidas)
Qualquer outro valor é considerado TRUE (incluindo qualquer recurso).
Aviso
-1 é considerado TRUE, como qualquer valor não zero (negativos ou positivos)!
<?php
var_dump((bool) ""); // bool(false)
var_dump((bool) 1); // bool(true)
var_dump((bool) -2); // bool(true)
var_dump((bool) "foo"); // bool(true)
var_dump((bool) 2.3e5); // bool(true)
var_dump((bool) array(12)); // bool(true)
var_dump((bool) array()); // bool(false)
var_dump((bool) "false"); // bool(true)
?>

Inteiros
Um inteiro é um número do conjunto Z = {..., -2, -1, 0, 1, 2, ...}.
Sintaxe
Inteiros podem ser especificados em notação decimal (base 10), hexadecimal (base 16) ou octal
(base 8), opcionalmente precedido de sinal (- ou +).
Para usar a notação octal, você precisa preceder o número com um 0 (zero). Para utilizar a notação
hexadecimal, preceda número com 0x.
Literais inteiras
<?php
$a = 1234; // número decimal
$a = -123; // um número negativo
$a = 0123; // número octal (equivalente a 83 em decimal)
$a = 0x1A; // número hexadecimal (equivalente a 26 em decimal)
?>
Números de ponto flutuante
Números de ponto flutuante ("floats", "doubles" ou "números reais") podem ser especificados
utilizando qualquer uma das sintaxes seguintes:
<?php
$a = 1.234;
$b = 1.2e3;
$c = 7E-10;
?>
Strings
Uma string é uma série de caracteres. No PHP, um caracter é o mesmo que um byte, ou seja, há
exatamente 256 caracteres diferentes possíveis.
Nota: Não há nenhum problema nas strings se tornarem muito grandes. Não há nenhum limite para
o tamanho de strings imposta pelo PHP, então não há razão para se preocupar com strings longas.
Sintaxe
• apóstrofo
• aspas
Apóstrofos
A maneira mais simples para especificar uma string é delimitá-la entre apóstrofos (também
conhecido por aspas simples).
Para especificar um apóstrofo você precisará "escapá-lo" com um contra barra (\), como em muitas
outras linguagens. Se uma contra barra precisa ocorrer antes de um apóstrofo ou no final da string,
você precisa duplicá-la.
Note que se você tentar escapar qualquer outro caracter, a contra barra também será impressa!
Então geralmente não é necessário escapar a própria contra barra.

Nota: Diferentemente das duas outras sintaxes, variáveis e seqüências de escape para caracteres
especiais não serão substituídas quando elas ocorrerem dentro de strings delimitadas por apóstrofes.
<?php
echo 'isto é uma string comum';
echo 'Você pode incluir novas linhas em strings,

dessa maneira que estará
tudo bem';
// Imprime: Arnold disse uma vez: "I\'ll be back"

echo 'Arnold disse uma vez: "I\'ll be back"';
// Imprime: Você tem certeza em apagar C:\*.*?

echo 'Você tem certeza em apagar C:\\*.*?';
// Imprime: Você tem certeza em apagar C:\*.*?

echo 'Você tem certeza em apagar C:\*.*?';
// Imprime: Isto não será substituido: \n uma nova linha

echo 'Isto não será substituido: \n uma nova linha';
// Imprime: Variaveis $também não $expandem

echo 'Variaveis $também não $expandem';
?>
Aspas
Se a string é delimitada entre aspas ("), o PHP entende mais seqüências de escape para caracteres
especiais:
Seqüências de escape
Seqüência Significado
\n fim de linha (linefeed ou LF ou 0x0A (10) em ASCII)
\r retorno de carro (carriage return ou CR ou 0x0D (13) em ASCII)
\t TAB horizontal (HT ou 0x09 (9) em ASCII)
\\ contra barra ou barra invertida
\$ sinal de cifrão
\" Aspas
Arrays
Um array no PHP é atualmente um mapa ordenado. Um mapa é um tipo que relaciona valores para
chaves. Este tipo é otimizado de várias maneiras, então você pode usá-lo como um array real, ou
uma lista (vetor), hashtable (que é uma implementação de mapa), dicionário, coleção, pilha, fila e
provavelmente mais. Como você pode ter outro array PHP como um valor, você pode facilmente
simular árvores.
Um array pode ser criado com o construtor de linguagem array(). Ele pega certo número de pares
separados por vírgula chave => valor .
array( chave => valor )
// chave pode ser tanto string ou um integer

// valor pode ser qualquer coisa

<?php
$arr = array("foo" => "bar", 12 => true);
echo $arr["foo"]; // bar
echo $arr[12]; // 1
?>
A chave pode ser tanto um integer ou uma string. Se a chave é uma representação padrão de um
integer, ele será interpretado assim (por exemplo, "8" será interpretado como 8, enquanto "08" será
interpretado como "08"). Floats em chaves são truncados para integer.
O valor pode ser qualquer tipo PHP:
<?php
$arr = array("somearray" => array(6 => 5, 13 => 9, "a" => 42));
echo $arr["somearray"][6]; // 5
echo $arr["somearray"][13]; // 9
echo $arr["somearray"]["a"]; // 42
?>
Se omitir a chave quando fornece um novo item, o maior índice inteiro é obtido, e a nova chave será
esse máximo + 1. Se você especificar uma chave que já possui um valor assimilada a ela, então o
valor é sobrescrito.
<?php
// Esse array é como ...
array(5 => 43, 32, 56, "b" => 12);
// ... este array
array(5 => 43, 6 => 32, 7 => 56, "b" => 12);
?>
Você pode também modificar um array existente explicitamente assimilando valores nele.
Isto é feito apenas assimilando valores para o array enquanto especificando a chave em colchetes.
Você pode omitir a chave, colocando um par vazio de colchetes ("[]").
$arr[chave] = valor;
$arr[] = valor;
// chave tanto um integer ou string
// valor pode ser qualquer coisa

Se $arr não existir ainda, ele será criado. Então isto é um meio alternativo para especificar um array.
Para mudar um certo valor, apenas assimile um novo valor para um elemento especificado por sua
chave. Se você quiser remover um par chave/valor, você deve aplicar unset() neste par.
<?php
$arr = array(5 => 1, 12 => 2);
$arr["x"] = 42; // Isto acrescenta um novo elemento
// para o array com a chave "x"
unset($arr[5]); // Isto remove um elemento do array
unset($arr); // E isto apaga todo o array
?>
Objetos
Inicialização de objetos
Para inicializar um objeto, você usa a instrução new, criando uma instância do objeto em uma
variável.
<?php
class MinhaClasse
{
function metodo()
{
echo "Executando metodo.";
}
}
$bar = new MinhaClasse;
$bar->metodo();
?>
Convertendo para objeto
Se um objeto é convertido para objeto, ele não é modificado. Se um valor de outro tipo é convertido
para objeto, uma nova instância da stdClass é criada. Se o valor é NULL, a nova instância estará
vazia. Arrays convertem para um objeto com propriedades chamadas pelas chaves do array e com
os respectivos valores. Para qualquer outro valor, uma variável membro chamada scalar irá conter o
valor.
<?php
$obj = (object) 'palavra';
echo $obj->scalar; // exibe 'palavra'
?>
1.4. 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. As constantes são case-sensitive (distinguem letras
maiúsculas e minúsculas) por padrão. Por convenção os nomes de constantes são sempre em
maiúsculas.
O nome de uma constante tem as mesmas regras de qualquer identificador no PHP. Um nome de
constante válida começa com uma letra ou sublinhado, seguido por qualquer número de letras,
números ou sublinhados.

Nomes de constantes válidos e inválidos
<?php
// Nomes de constantes válidos
define("FOO", "alguma coisa");
define("FOO2", "alguma outra coisa");
define("FOO_BAR", "alguma coisa mais");
// Nomes de constantes inválidas
define("2FOO", "alguma coisa");
?>
O escopo de uma constante é global. Você pode acessar constantes de qualquer lugar em seu script
sem se preocupar com o escopo.
Sintaxe
Você pode definir uma constante utilizando-se da função define(). Quando uma constante é definida,
ela não pode ser mais modificada ou anulada.
Somente dados escalares (boolean, integer, float e string) pode ser colocados em constantes. Não
defina constantes do tipo resource (recurso).
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 $. Você também pode utilizar a
função constant() para ler o valor de uma constante, se você precisar obter seu valor
dinamicamente. Utilize get_defined_constants() para obter a lista de todas as constantes definidas.
Estas são as diferenças entre constantes e variáveis:
• 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 a regras de escopo
de variáveis sejam aplicadas;
• Constantes não podem ser redefinidas ou eliminadas depois que elas são criadas; e
• Constantes só podem conter valores escalares.
Definindo Constantes
<?php
define("CONSTANT", "Hello world.");
echo CONSTANT; // imprime "Hello world."
echo Constant; // imprime "Constant" e gera um aviso de alerta.
?>

1.5. Operadores
Operadores Aritméticos
Exemplo Nome Resultado

-$a Negação Oposto de $a.
$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, a não ser que os dois
operados sejam inteiros (ou strings que são convertidas para inteiros) e numéricos inteiramente
divisíveis, em outro caso um inteiro é retornado.
Operadores de Atribuição
O operador básico de atribuição é "=". Isto quer dizer, na verdade, que o operando da esquerda
recebe o valor da expressão da direita (ou seja, "é configurado para").
O valor de uma expressão de atribuição é o valor atribuído. Ou seja, o valor de "$a = 3" é 3. Isto
permite que você crie algumas expressões como:
<?php
$a = ($b = 4) + 5; // $a é igual a 9 agora e $b foi configurado como 4.
?>
Além do operador básico de atribuição, há "operadores combinados" para todos os operadores

aritméticos, de array e string que permitem a você pegar um valor de uma expressão e então usar
seu próprio valor para o resultado daquela expressão. Por exemplo:
<?php
$a = 3;
$a += 5; // configura $a para 8, como se disséssemos: $a = $a + 5;
$b = "Bom ";
$b .= "Dia!"; // configura $b para "Bom Dia!", como em $b = $b . "Dia!";
?>
Operadores de Comparação
Operadores de comparação, como os seus nomes implicam, permitem que você compare dois
valores. Você pode se interessar em ver as tabelas de comparação de tipos, que tem exemplo das
várias comparações entre tipos relacionadas.

Operadores de comparação

$a == $b Igual Verdadeiro (TRUE) se $a é igual a $b.
$a === $b Idêntico Verdadeiro (TRUE) se $a é igual a $b, e eles são do mesmo tipo
(introduzido no PHP4).
$a != $b Diferente Verdadeiro se $a não é igual a $b.
$a <> $b Diferente Verdadeiro se $a não é igual a $b.
$a !== $b Não idêntico Verdadeiro de $a não é igual a $b, ou eles não são do mesmo tipo
(introduzido no PHP4).
$a < $b Menor que Verdadeiro se $a é estritamente menor que $b.
$a > $b Maior que Verdadeiro se $a é estritamente maior que $b.
$a <= $b Menor ou igual Verdadeiro se $a é menor ou igual a $b.
$a >= $b Maior ou igual Verdadeiro se $a é maior ou igual a $b.
Se você comparar um inteiro com uma string, a string é convertida para um número. Se você
comparar 2 strings numéricas, elas serão comparadas como inteiras. Estas regras também se
aplicam ao comando switch.
<?php
var_dump(0 == "a"); // 0 == 0 -> true
var_dump("1" == "01"); // 1 == 1 -> true
var_dump("1" == "1e0"); // 1 == 1 -> true
switch ("a") {
case 0:
echo "0";
break;
case "a": // nunca é alcançado porque "a" já foi combinado com 0
echo "a";
break;
}
?>
Para vários tipos, comparações são feitas de acordo com a seguinte tabela (em ordem).
Comparação com vários tipos
Tipo do 1º operando Tipo do 2º operando Resultado

null ou string string Converte NULL para "", numérico ou
comparação léxica
bool or null qualquer Converte para bool, FALSE < TRUE
object object Classes nativas podem definir como são
comparadas, classes diferentes são
incomparáveis. Classes de mesmo tipo –
comparação de propriedades
string, resource ou string, resource ou number Transforma strings e resources para
number números
array array Array com menos membros é menor, se a
chave do operando 1 não é encontrada no
operando 2, então os arrays são
incomparáveis, caso contrário - compara
valor por valor (veja o seguinte exemplo)
array qualquer array é sempre maior
Object qualquer object é sempre maior
Transcrição do padrão de comparação de array

<?php
function comparacao_array($op1, $op2)
{
if (count($op1) < count($op2)) {
return -1; // $op1 < $op2
} elseif (count($op1) > count($op2)) {
return 1; // $op1 > $op2
}
foreach ($op1 as $key => $val) {
if (!array_key_exists($key, $op2)) {
return null; // incomparavel
} elseif ($val < $op2[$key]) {
return -1;
} elseif ($val > $op2[$key]) {
return 1;
}
}
return 0; // $op1 == $op2
}
?>
Operador Ternário
Outro operador condicional é o operador ?: (ou ternário).
Atribuindo um valor padrão
<?php
$action = (empty($_POST['action'])) ? 'default' : $_POST['action'];
// o mesmo que
if (empty($_POST['action'])) {
$action = 'default';
} else {
$action = $_POST['action'];
}
?>
A expressão (expr1) ? (expr2) : (expr3) é avaliada para expr2 se expr1 é avaliada como TRUE, ou
expr3 se expr1 é avaliada como FALSE.
Nota: Note que o operador ternário é um comando, e ele não é avaliado para uma variável, mas
para o resultado do comando. Isto é importante saber se você quer retornar uma variável por
referência. O comando return $var == 42 ? $a : $b; em uma função que retorna por referência
conseqüentemente não irá funcionar e será avisado nas últimas versões do PHP.
Nota: É recomendado evitar "stacking" de expressões ternárias. O comportamento do PHP quando

usando mais de um operador ternário no único comando não é óbvio:

Comportamento do ternário (não recomendado)
<?php
// o seguinte aparenta imprimir 'true'
echo (true?'true':false?'t':'f');
// conteudo, a saída acima é 't'
// isto por causa da expressão ternário se avaliada da esquerda para direita
// o seguinte é a versão mais óbvia do mesmo código acima
echo ((true ? 'true' : 'false') ? 't' : 'f');
// aqui, você pode ver que a primeira expressão é avaliada para 'true', que
// por sua vez avalia para (bool)true, assim retornando a parte true da
// segunda expressão ternária.
?>
Operadores de controle de erro
O PHP suporta um operador de controle de erro: o sinal 'arroba' (@). Quando ele precede uma
expressão em PHP, qualquer mensagem de alerta ou erro que possa ser gerada por aquela
expressão será ignorada.
<?php
/* Erro de arquivo intencional */
$my_file = @file ('arquivo_nao_existente') or
die ("Falha abrindo arquivo: '$php_errormsg'");
// Isto funciona para qualquer expressão, não apenas para funções:

$value = @$cache[$key];
// você não receberá nenhum aviso se a chave $key não existir.
?>
Nota: O operador @ funciona somente em expressões. Uma regra simples para lembrar disso: se
você pode pegar o valor de alguma coisa, você pode prefixar isso com o @. Assim, você pode
prefixar chamadas de variáveis, funções e include()s, constantes e afins. Você não pode prefixar
definições de funções ou classe, estruturas condicionais como o if, foreach e assim por diante.
Nota: O prefixo de controle de erro "@" não desabilita mensagens que são resultado de erros de
interpretação (parse errors).
Operadores de Execução
O PHP suporta um operador de execução: acentos graves (``). Note que não são apóstrofes! O PHP
tentará executar o conteúdo dos acentos graves como um comando do shell; a saída será retornada
(isto é, ela não será simplesmente descarregada para a saída; ela pode ser atribuída a uma
variável). A utilização do operador contra-apóstrofo é idêntica a função shell_exec().
<?php
$output = `ls -l`;
echo "<pre>$output</pre>";
?>
Nota: O operador de execução fica desabilitado quando safe mode está ativo ou shell_exec() está
desabilitado.
Operadores de Incremento/Decremento
O PHP suporta operadores de pré e pós-incremento e decremento no estilo C.

Nota: Os operadores incremento/decremento não afetam valores booleanos. Decrementando valores

NULL não há efeito também, mas incrementando resulta em 1.
Operadores de Incremento / Nome Efeito

Decremento Exemplo
++$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.
Aqui está um script de exemplo simples:
<?php
echo "<h3>Pós-incremento</h3>";
$a = 5;
echo "Deve ser 5: " . $a++ . "<br />\n";
echo "Deve ser 6: " . $a . "<br />\n";
echo "<h3>Pré-incremento</h3>";
$a = 5;
echo "Deve ser 6: " . ++$a . "<br />\n";
echo "<h3>Pós-decremento</h3>";
$a = 5;
echo "Deve ser 5: " . $a-- . "<br />\n";
echo "<h3>Pré-decremento</h3>";
$a = 5;
echo "Deve ser 4: " . --$a . "<br />\n";
?>
Operações aritmétricas em variáveis caracter
<?php
$i = 'W';
for ($n=0; $n<6; $n++) {
echo ++$i . "\n";
}
?>
O exemplo acima irá imprimir:
X
Y
Z
AA
AB
AC
Operadores Lógicos

$a and $b E Verdadeiro (TRUE) se tanto $a quanto $b são verdadeiros.
$a or $b OU Verdadeiro se $a ou $b são verdadeiros.
$a xor $b XOR Verdadeiro se $a ou $b são verdadeiros, mas não 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. (Veja Precedência de Operadores.)
Ilustrando operadores lógicos
<?php
// "&&" tem maior precedência que "and"
$a = false && true;
$b = true and false;
var_dump($a, $b);
// "||" tem maior precedência que "or"

$c = false || true;
$d = true or false;
var_dump($c, $d);
?>
O exemplo acima irá imprimir algo similar a:
bool(false)
bool(true)
bool(true)
bool(true)
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 e
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 .= "mundo!"; // agora $a contém "Olá mundo!"
?>
O operador + acrescenta os elementos da direita no array da esquerda, contudo, chaves duplicadas

NÃO são sobrescritas.
<?php
$a = array("a" => "maçã", "b" => "banana");
$b = array("a" =>"pêra", "b" => "framboesa", "c" => "morango");
$c = $a + $b; // Uniao de $a e $b
echo "União de \$a e \$b: \n";
var_dump($c);

$c = $b + $a; // União de $b e $a
echo "União de \$b e \$a: \n";
var_dump($c);
?>
Quando executado, o script produz uma saída assim:
União de $a e $b:
array(3) {
["a"]=>
string(5) "maçã"
["b"]=>
string(6) "banana"
["c"]=>
string(6) "morango"
}
União de $b e $a:
array(3) {
["a"]=>
string(4) "pêra"
["b"]=>
string(10) "framboesa"
["c"]=>
string(6) "morango"
}
Elementos do array são iguais para efeitos de comparação se eles possuem o mesmo valor e chave.
Comparando arrays
<?php
$a = array("maçã", "banana");
$b = array(1 => "banana", "0" => "maçã");
var_dump($a == $b); // bool(true)
var_dump($a === $b); // bool(false)
?>
Operadores de tipo
instanceof é usado para determinar se um variável do PHP é uma objeto instânciado de uma certa
classe:
Usando instanceof com classes

<?php
class A {}
class B {}
$a = new A;
var_dump($a instanceof A);
var_dump($a instanceof B );
?>

bool(true)
bool(false)
instanceof pode também ser usado para determinar se uma variável é um objeto instanciado de uma
classe que herda de uma classe pai:
Usando instanceof com herança

<?php
class ClasseMae { }
class MinhaClasse extends ClasseMae { }
$a = new MinhaClasse;
var_dump($a instanceof MinhaClasse);
var_dump($a instanceof ClasseMae);
?>
bool(true)
bool(true)
Por fim, instanceof pode também ser usado para determinar se uma variável é um objeto instanciado
de uma classe que implementa uma interface:
Usando instanceof para classe

<?php
interface MinhaInterface {}
class MinhaClasse implements MinhaInterface { }

var_dump($a instanceof MinhaClasse);
var_dump($a instanceof MinhaInterface);
?>
bool(true)
bool(true)
Embora instanceof é usualmente usado com um nome de classe literal, ele pode também ser usado
com outro objeto ou uma variável string:
Usando instanceof com outras variáveis

<?php
interface MinhaInterface {}
class MinhaClasse implements MinhaInterface {}
$b = new MinhaClasse;
$c = 'MinhaClasse';
$d = 'NaoMinhaClasse';
var_dump($a instanceof $b); // $b é um objeto da classe MinhaClasse
var_dump($a instanceof $c); // $c é uma string 'MinhaClasse'
var_dump($a instanceof $d); // $d é uma string 'NaoMinhaClasse'
?>

bool(true)
bool(true)
bool(false)
1.6. Estruturas de controle
if
A construção if é 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 aquela do C:
if (expressao)
instrucoes
Uma expressão é avaliada por seu contexto booleano. Se expressão for avaliado como TRUE, o PHP
executará as instruções, e se for avaliado como FALSE, ele será ignorado.
Os exemplos a seguir mostrariam “a é maior que b” se $a for maior que $b:
<?php
if ($a > $b)
echo "a é maior que b";
?>
Normalmente você vai querer ter mais que uma instrução executada condicionalmente. E é claro,
não há necessidade de englobar cada instrução com uma cláusula if. Em vez disso, você pode colocar
várias instruções em um agrupamento de comandos. Por exemplo, este código mostraria “a é maior
que b” se $a for maior que $b, e então atribuiria o valor de $a para $b:
<?php
if ($a > $b) {
$b = $a;
}
?>
Comandos if podem ser aninhados indefinidamente dentro de outros comandos if, o que faz com que
você complete a flexibilidade para a execução condicional de várias partes do seu programa.
else
Normalmente 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 faz. Else interpreta a saída
de um comando if para executar uma instrução, caso a expressão no comando if seja avaliada como
FALSE o else será executado.
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) {
} else {
echo "a NÃO é maior que b";
}
?>
elseif
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”:
<?php
if ($a > $b) {
} elseif ($a == $b) {
echo "a é igual a b";
} else {
echo "a é menor que b b";
}
?>
Podem haver vários elseifs dentro da mesma instrução if. A primeira expressão elseif (se houver)
que for avaliada como TRUE será executada. No PHP, você também pode escrever 'else if' (em duas
palavras) e o comportamento será idêntico a um 'elseif' (em uma só palavra).
O comando elseif só é executado se a expressão if precedente e quaisquer expressões elseif

anteriores forem avaliadas como FALSE, e a expressão elseif atual for avaliada como TRUE.
while
Loops while são o tipo mais simples de criar um laços em PHP. Eles se comportam como seus
compatíveis em C. O formato básico de um comando while é:
while (expressao)
instrucoes
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 é
verificado 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.
Como no comando if, você pode agrupar múltiplos comandos dentro do mesmo laço while
englobando um grupo de instruções com chaves, ou usando a sintaxe alternativa:
while (expressao):
instrucoes
...
endwhile;


Os exemplos a seguir são idênticos, e ambos imprimem números de 1 até 10:
<?php
/* exemplo 1 */
$i = 1;
while ($i <= 10) {
echo $i++; /* o valor impresso será
$i depois do acréscimo
(post-increment) */
}
/* exemplo 2 */
$i = 1;
while ($i <= 10):
echo $i;
$i++;
endwhile;
?>
do-while
Loops do-while são bem similares aos loops while, exceto pelo fato de que a condição é verificada no
fim de cada iteração em vez de no começo. A diferença principal dos loops while regulares é que a
primeira iteração de um loop do-while é garantidamente executada (a condição só é verificada no fim
da iteração) enquanto que ele pode não rodar necessariamente em um loop while normal (a condição
é verificada no começo de cada iteração, se ela é avaliada como FALSE logo no começo, a execução
do loop terminaria imediatamente).
Há apenas uma sintaxe para loops do-while:
<?php
$i = 0;
do {
echo $i;
} while ($i > 0);
?>
O loop acima rodaria exatamente uma vez, desde que depois da primeira iteração, quando a
condição é verificada, ela é avaliada como FALSE ($i não é maior que zero 0) e a execução do loop
termina.
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)

instrucoes
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 ou conter múltiplas expressões separadas por vírgulas. Em
expr2, todas as expressões separadas por vírgula são avaliadas mas o resultado é obtido pela última
parte. expr2 vazia significa que o loop pode rodar indefinidamente (PHP considera-a implicitamente
como TRUE, como em C). Isto pode não ser tão inútil quanto você pode pensar, pois freqüentemente
você pode querer terminar o 'loop' usando uma instrução break condicional em vez de usar a
expressão-verdade do for.
Considere os seguintes exemplos. Todos eles mostram números de 1 até 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 */
$i = 1;
for (; ; ) {
if ($i > 10) {
break;
}
echo $i;
$i++;
}
/* exemplo 4 */
for ($i = 1, $j = 0; $i <= 10; $j += $i, print $i, $i++);
?>
Obviamente, o primeiro exemplo parece ser o mais bonito (ou talvez o quarto), mas você pode
perceber que a possível utilização de expressões vazias em laços for se torna prático em algumas
ocasiões.
foreach
O PHP4 inclui um construtor foreach, muito parecido com o Perl e outras linguagens. Isto oferece
uma maneira fácil de iterar sobre matrizes. foreach funciona somente com arrays, e lançará um erro
se tentar utilizá-lo em uma variável de qualquer tipo diferente ou em variáveis não inicializadas.
Há duas sintaxes:
foreach (expressao_array as $valor)

instrucoes
foreach (expressao_array as $chave => $valor)
instrucoes
A primeira forma varre uma dada matriz dada por expressao_array. Em cada 'loop', o valor do
elemento corrente é atribuído a $valor e o ponteiro interno da matriz é avançado em uma posição
(assim, no próxima iteração você estará olhando para o próximo elemento).
A segunda forma faz a mesma coisa, exceto pelo fato de que a chave do elemento atual será
atribuído à variável $chave em cada iteração.

A partir do PHP 5, é possível iterar objetos também.
Nota: Quando o foreach inicia sua primeira execução, o ponteiro interno da matriz é zerado
automaticamente para o primeiro elemento do array. Isto significa que você não precisa chamar
reset() antes de um loop foreach .
A partir do PHP 5, você pode modificar facilmente os elementos da matriz precedendo $value com &.
Isto irá definir uma referência ao invés de copiar o valor.
<?php
$arr = array(1, 2, 3, 4);
foreach ($arr as &$value) {
$value = $value * 2;
}
// $arr is now array(2, 4, 6, 8)
unset($value); // quebra a referência com o último elemento
?>
Nota: No foreach é possível utilizar o operador '@' para evitar mensagens de erro.
Você pode ter notado que os seguintes itens são funcionalmente idênticos:
<?php
$arr = array("um", "dois", "três");
reset ($arr);
while (list(, $value) = each ($arr)) {
echo "Valor: $value<br />\n";
}
foreach ($arr as $value) {
echo "Valor: $value<br />\n";
}
?>
Os seguintes também são funcionalmente idênticos:
<?php
$arr = array("one", "two", "three");
reset($arr);
while (list($key, $value) = each ($arr)) {
echo "Chave: $key; Valor: $value<br />\n";
}
foreach ($arr as $key => $value) {
echo "Chave: $key; Valor: $value<br />\n";
}
?>

Mais alguns exemplos para demonstrar os usos:
<?php
/* exemplo foreach 1: somente valores */
$a = array(1, 2, 3, 17);
foreach ($a as $v) {
echo "Valor atual de \$a: $v.\n";
}
/* exemplo foreach 2: valores (com as chaves impressas para ilustração) */
$a = array(1, 2, 3, 17);
$i = 0; /* para exemplo somente */
foreach ($a as $v) {
echo "\$a[$i] => $v.\n";
$i++;
}
/* exemplo foreach 3: chaves e valores */
$a = array (
"um" => 1,
"dois" => 2,
"três" => 3,
"dezessete" => 17
);
foreach ($a as $k => $v) {
echo "\$a[$k] => $v.\n";
}
/* exemplo foreach 4: arrays multidimensionais */
$a = array();
$a[0][0] = "a";
$a[0][1] = "b";
$a[1][0] = "y";
$a[1][1] = "z";
foreach ($a as $v1) {
foreach ($v1 as $v2) {
echo "$v2\n";
}
}
/* exemplo foreach 5: arrays expressos */
foreach (array(1, 2, 3, 4, 5) as $v) {
echo "$v\n";
}
?>
break
break cancela a execução do comando for, foreach, while, do-while ou switch atual.
break aceita um argumento numérico opcional que diz a ele quantas estruturas aninhadas
englobadas devem ser quebradas.

<?php
$arr = array('um', 'dois', 'três', 'quatro', 'PARE', 'cinco');
while (list (, $val) = each ($arr)) {
if ($val == 'PARE') {
break; /* Você poderia colocar 'break 1;' aqui. */
}
echo "$val<br />\n";
}
/* Utilizando o argumento opcional. */
$i = 0;
while (++$i) {
switch ($i) {
case 5:
echo "No 5<br />\n";
break 1; /* Sai somente do switch. */
case 10:
echo "No 10; saindo<br />\n";
break 2; /* Sai do switch e while. */
default:
break;
}
}
?>
continue
continue é usado dentro de estruturas de loops para saltar o resto da iteração do loop atual e
continuar a execução na avaliação e no início da próxima iteração.
Nota: Note que no PHP a instrução switch é considerada uma estrutura de loop quando relacionada
ao comando continue.
continue aceita um argumento numérico opcional que diz a ele de quantos níveis de loops aninhados
ele deve saltar até o fim.
$arr = array(0,1,2,3,4,5,6,7,8,9);
while (list ($key, $value) = each ($arr)) {
if (!($key % 2)) { // pula itens pares
continue;
}
echo $value;
}
echo "<br/>";
$i = 0;
while ($i++ < 5) {
echo "Fora<br />\n";
while (1) {
echo " Meio<br />\n";
while (1) {
echo " Dentro<br />\n";
continue 3;
}
echo "Isto nunca será exibido.<br />\n";
}
echo "Nem isso.<br />\n";
}
?>

Omitindo o ponto e vírgula depois do continue pode resultar em confusão. Este é um exemplo do que
você NÃO deve fazer.
<?php
for ($i = 0; $i < 5; ++$i) {
if ($i == 2)
continue
print "$i\n";
}
?>
Um resultado esperado poderia ser:
0
1
3
4
mas esse script somente exibirá:
porque o valor de retorno da chamada a print() é int(1), e então ele se parecerá como o argumento
numérico opcional mencionado acima.
switch
A instrução switch é similar a uma série de instruções IFs aninhados. 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 com qual valor ele se encaixar. É exatamente para isso
que a instrução switch faz.
Nota: Note que diferentemente de outras linguagens, a instrução continue se aplica a switch e age
similarmente a um break. Se você tem um switch dentro de um loop e deseja continuar para a
próxima iteração do loop, use continue 2.
Nota: Note que switch/case fazem comparações soltas.
Os exemplos seguintes mostram duas maneiras diferentes de escrever a mesma coisa, uma
utilizando uma série de ifs e elseifs e a outra utlizando a instrução switch:

<?php
if ($i == 0) {
echo "i igual a 0";
} elseif ($i == 1) {
echo "i igual a 1";
} elseif ($i == 2) {
echo "i igual a 2";
}
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;
}
?>
A estrutura switch permite uso de strings
<?php
switch ($i) {
case "apple":
echo "i is apple";
break;
case "bar":
echo "i is bar";
break;
case "cake":
echo "i is cake";
break;
}
?>
É importante entender como a instrução switch funciona para evitar enganos. A instrução switch
executa linha a linha (atualmente, instrução a instrução). No início, nenhum código é executado.
Somente quando uma instrução case é encontrada com um valor que combina com a expressão do
switch faz com que o PHP execute as instruções a partir daí. O PHP continua executando as
instruções até o fim do bloco switch ou na primeira vez que encontrar uma instrução break. Se você
não escrever uma instrução break no fim das instruções case, o PHP continuará executando os cases
seguintes. Exemplo:
<?php
switch ($i) {
case 0:
echo "i igual a 0";
case 1:
echo "i igual a 1";
case 2:
echo "i igual a 2";
}
?>

Aqui, se $i é igual a zero, o PHP executará todas as instruções echo! Se $i é igual a 1, o PHP
executará os últimas duas instruções echo, e somente se $i for igual a 2, você terá o comportamento
'esperado' apenas onde 'i igual a 2' será mostrado. Então é importante não se esquecer das
instruções break (e as vezes não colocá-las para obter esse resultado em certas circunstâncias).
Em uma instrução switch, a condição somente será avaliada e resultado comparado para cada
instrução case. Em uma instrução elseif, a condição é avaliada novamente. Se sua condição é mais
complicada que um simples comparação e/ou e dentro de um loop, um switch é mais rápido.
Um case pode não ter nenhuma instrução dentro, o que simplesmente passa o controle para o
próximo case.
<?php
switch ($i) {
case 0:
case 1:
case 2:
echo "i é menor que 3 mas não negativo";
break;
case 3:
echo "i é 3";
}
?>
Um case especial é o default. Esse case é executado quando nenhum outro case combina. Por
exemplo:
<?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;
default:
echo "i não é igual a 0, 1 ou 2";
}
?>
A expressão avaliada pelo case precisa ser um tipo simples, ou seja, inteiros, números de ponto
flutuante e strings. Arrays ou objetos não podem ser utilizados a não ser que eles impliquem num
tipo simples.
A sintaxe alternativa para estruturas de controle é suportada para os switches. Para maiores
informações, veja Sintaxe alternativa para estruturas de controle.

<?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;
default:
echo "i não é igual a 0, 1 ou 2";
endswitch;
?>
return
Se chamada em uma função, a instrução return() termina imediatamente a execução da função

atual e retorna seu argumento como o valor da função. return() também termina a execução de uma
instrução eval() ou de um script.
Se chamada no escopo global, a execução do script atual será terminada. Se o arquivo do script
atual foi incluído com include() ou require(), então a execução é devolvida para o arquivo chamador.
Especificamente para arquivos de script incluídos com include(), o valor fornecido para return() será
devolvido como o valor da chamada include(). Se return() for chamado do arquivo de script principal,
então o programa pára. Se o arquivo de script atual é o configurado em auto_prepend_file ou
auto_append_file do php.ini, então a execução desses scripts é finalizada.
Nota: Note que return() é um construtor de linguagem e não uma função, e parênteses em volta do
argumento não é requerido. è comum deixa-los, e você atualmente deve faze-lo, já que o PHP tem
menos trabalho para fazer neste caso.
Nota: Você jamais deve usar parênteses em torno da sua variável retornada ao retornar por
referência, já que isto não irá funcionar. Você pode retornar apenas variáveis por referência, não o
resultado de um comando. Se você usar return ($a); então você não esta retornando uma variável,
mas o resultado da expressão ($a) (o qual é, claro, o valor de $a).
require
A instrução require() inclui e avalia um arquivo específico.
require() e include() são idênticos em todas as formas exceto pela manipulação de erros. Ambas
produzem um Warning, mas require() resultará em um Fatal Error. Em outras palavras, não hesite
em utilizar require() se na falta de um arquivo quiser parar o processamento da página. include()
não se comporta da mesma maneira, e o script poderá continuar nessa situação. Em todo caso, vale
a pena confirmar a configuração da diretiva include_path.
Exemplos simples de require()s

<?php
require 'prepend.php';
require $somefile;
require ('somefile.txt');
?>
include

A instrução include() inclui e avalia o arquivo informado.
A documentação a seguir se aplica também a require(). Esses dois construtores são idênticos a
exceção de como eles manipulam erros. Ambas produzem um Warning mas require() resultará em
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. Em todo caso, vale a pena confirmar a configuração da
diretiva include_path. Esteja avisado que um erro de interpretação no arquivo incluído não causa a
parada do processamento em versões do PHP anteriores a PHP 4.3.5. A partir desta versão, causa.
Arquivos a incluir são procurados primeiramente no include_path relativo ao diretório atual de

trabalho, e então no diretório atual do script. Por exemplo, se seu include_path é libraries, o diretório
atual é /www/, se você incluiu include/a.php e há um b.php nesse arquivo, b.php será procurado
primeiro em /www/libraries/ e somente depois em /www/include/.0 Se o nome do arquivo começa
com ./ ou ../, ele é procurado apenas no diretório atual.
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. Entretanto, todas as funções e classes definidas no
arquivo incluído tem um escopo global.
Exemplos de include()s simples
variaveis.php
<?php
$cor = 'verde';
$fruta = 'maçã';
?>
teste.php
<?php
echo "Uma $fruta $cor"; // Uma
include 'vars.php';
echo "Uma $fruta $cor"; // Uma maçã verde
?>
Se o include ocorre dentro de uma função do arquivo principal, então todo o código incluído será
executado como se ele tivesse sido definido dentro daquela função. Da mesma forma, ele seguirá o
escopo de variáveis da função. Uma exceção para esta regra são as constantes mágicas que são
avaliadas pelo parser antes dos includes ocorrerem.
Incluindo dentro de funções

<?php
function foo()
{
global $cor;
include 'variaveis.php';
echo "Uma $fruta $cor";
}
/* variaveis.php está no escopo de foo(), *
.* então $fruta NÃO está disponível fora de *
.* seu escopo. $cor estará porque ela foi *
.* declarada como global */
foo(); // Uma maçã verde
echo "A $fruta $cor"; // Uma maçã
?>
require_once

A instrução require_once() incluí e avalia o arquivo especificado durante a execução do script. Seu
comportamento é similar ao da instrução require(), a não ser que o arquivo informado já tenha sido
incluído, não refazendo a operação novamente. Veja a documentação de require() para maiores
informações sobre como essa instrução funciona.
require_once() pode ser utilizado nos casos em que o mesmo arquivo pode acabar sendo incluído
mais de uma vez durante a execução de um script em particular, quando na verdade ele só pode ser
incluído apenas uma, para evitar problemas com redefinições de funções, alterações nos valores de
variáveis, etc.
include_once
A instrução include_once() inclui e avalia o arquivo especificado durante a execução de um script.

Seu comportamento é similar a instrução include(), a não ser que o arquivo informado já tenha sido
incluído, não refazendo a operação novamente. Como o nome sugere, ele será incluído apenas uma
vez.
include_once() pode ser utilizado nos casos em que o mesmo arquivo pode acabar sendo incluído
mais de uma vez durante a execução de um script em particular, quando na verdade ele só pode ser
incluído apenas uma para evitar problemas com redefinições de funções, alterações nos valores de
variáveis, etc.
2. Arrays
Um array é uma variável cujo objetivo é armazenar um conjunto de valores.
Arrays indexados numericamente
Quando não inicializamos um array usando o par associativo (chave e valor), implícitamente será
adicionado um índice númerico a cada valor adicionado a array.
Arrays indexados não numericamente
Quando inicializamos um array usando o par associativo (chave e valor), essa chave explícitamente
adicionada será o índice do array.
Operadores de array

$a + $b União União de $a e $b.
$a == $b Igualdade TRUE se $a e $b tem os mesmos pares de chave/valor.
$a === $b Identidade TRUE se $a e $b tem os mesmos pares de chave/valor na mesma
ordem e do mesmo tipo.
$a != $b Desigualdade TRUE se $a não é igual a $b.
$a <> $b Desigualdade TRUE se $a não é igual a $b.
$a !== $b Não identidade TRUE se $a não é identico a $b.
Array multidimensionais
Os arrays não têm de ser uma lista simples de chaves e valores – cada localização no array pode
armazenar outro array.

<pre>
<?php
$escopo = range(2, 10, 2);
$mult = array ("cores" => array ( "a" => "amarelo", "b" => "azul", "c" => "verde" ),
"Pares 1 a 10" => $escopo,
"espaços" => array ("primeiro", 5 => "segundo", "terceiro" )
);
var_dump($mult);
?>
</pre>
<?php
print $mult["espaços"][5];
?>
Resultado:
array(3) {
["cores"]=>
array(3) {
["a"]=>
string(7) "amarelo"
["b"]=>
string(4) "azul"
["c"]=>
string(5) "verde"
}
["Pares 1 a 10"]=>
array(5) {
[0]=>
int(2)
[1]=>
int(4)
[2]=>
int(6)
[3]=>
int(8)
[4]=>
int(10)
}
["espaços"]=>
array(3) {
[0]=>
string(8) "primeiro"
[5]=>
string(7) "segundo"
[6]=>
string(8) "terceiro"
}
}
segundo
Classificação de arrays
Classificar um array é poder ordená-lo de acordo com o critério desejado.

sort — Ordena um array
Descrição
bool sort ( array &$array [, int $sort_flags ] )
Essa função ordena um array. Os elementos serão ordenados do menor para o maior ao final da
execução dessa função.
Nota: Esta função define novas chaves para os elementos em array . Ela irá remover qualquer chave
que você tenha definido, ao invés de simplesmente reordenar as chaves.
Retorna TRUE em caso de sucesso ou FALSE em falhas.
Exemplo de sort()
<?php
$frutas = array("limao", "laranja", "banana", "melancia");
sort($frutas);
foreach ($fruits as $key => $val) {
echo "frutas[".$chave."] = ".$valor."\n";
}
?>
fruits[0] = banana
fruits[1] = laranja
fruits[2] = limao
fruits[3] = melancia

asort — Ordena um array mantendo a associação entre índices e valores
Descrição
bool asort ( array &$array [, int $sort_flags ] )
Essa função ordena um array de forma que a correlação entre índices e valores é mantida. É usada
principalmente para ordenar arrays associativos onde a ordem dos elementos é um fator importante.
Exemplo de asort()
<?php
$frutas = array("d" => "limao", "a" => "laranja", "b" => "banana", "c" => "melancia");
asort($frutas);
foreach( $frutas as $chave => $valor ){
echo "$chave = $valor\n";
}
?>
b = banana
a = laranja
d = limao
c = melancia
ksort — Ordena um array pelas chaves
Descrição
int ksort ( array $array [, int $sort_flags ] )
Ordena um array pelas chaves, mantendo a correlação entre as chaves e os valores. Essa função é
bastante útil principalmente para arrays associativos.
Exemplo de ksort()
<?php
$frutas = array("d"=>"limao", "a"=>"laranja", "b" =>"banana", "c"=>"maçã");
ksort($frutas);
reset($frutas);
while (list($chave, $valor) = each($frutas)) {
echo "$chave = $valor\n";
}
?>
O programa acima mostraria:
a = laranja
b = banana
c = maçã
d = limao

usort — Ordena um array pelos valores utilizando uma função de comparação definida pelo usuário
Descrição
bool usort ( array &$array , string $cmp_function )
Essa função irá ordenar um array pelos valores usando uma função de classificação definida pelo
usuário. Se o array precisar ser ordenado utilizando um critério não trivial, você deve usar essa
função.
A função de comparação deve retornar um inteiro menor, igual ou maior que zero se o primeiro
argumento for considerado respectivamente menor, igual, ou maior que o segundo.
Nota: Se dois elementos são considerados iguais, a ordem deles fica indefinida no array resultante.
Até o PHP 4.0.6 as funções definidas pelo usuário manteriam a ordem original desses elementos,
mas com o novo algoritmo de ordenação introduzido no 4.1.0 esse não é o caso, pois não existe
solução para fazer isso de modo eficiente.
Exemplo de usort()
<?php
function cmp($a, $b)
{
if ($a == $b) {
return 0;
}
return ($a < $b) ? -1 : 1;
}
$a = array(3, 2, 5, 6, 1);
usort($a, "cmp");
foreach ($a as $key => $value) {
echo "$chave: $valor\n";
}
?>
0: 1
1: 2
2: 3
3: 5
4: 6
Funções de arrays
shuffle — Mistura os elementos de um array
Descrição
bool shuffle ( array &$array )

Essa função mistura de forma aleatória os elementos de um array.
Exemplo de shuffle()
<?php
$numbers = range(1,20);
srand((float)microtime()*1000000);
shuffle($numbers);
foreach ($numbers as $number) {
echo "$number ";
}
?>
count — Conta o número de elementos de uma variável, ou propriedades de um objeto
Descrição
int count ( mixed $var [, int $mode ] )
Retorna o número de elementos de var , que normalmente é um array (uma vez que qualquer outra
coisa terá apenas um elemento).
Para objetos, se você tem SPL instalada, você pode fazer um gancho na count() implementando a
interface Countable. A interface tem exatamente um método, count(), que retorna o valor retornado
para função count().
Se var não for um array ou um objeto, com a interface Countable implementada, 1 será retornado.
Há uma exceção, se var é NULL, 0 é retornado.
Nota: O parâmetro opcional mode esta disponível apartir do PHP 4.2.0.
Se o parâmetro opcional mode for COUNT_RECURSIVE (ou 1), a função count() irá recursivamente
contar a matriz. Isto é particularmente util para contar elementos em matriz multidimensional. O
valor padrão para mode é 0. count() não detecta infinita recursão.
Cuidado
count() pode retornar 0 para uma variável que não existe, mas também pode retornar 0 para uma
variável que tenha sido inicializada como um array vazio. Use isset() para checar se a variável
existe.
Por favor, veja a sessão Array do manual para uma explicação mais detalhada sobre como os arrays
são implementados e utilizados no PHP.

Exemplo de count()
<?php
$a[0] = 1;
$a[1] = 3;
$a[2] = 5;
$result = count($a);
// $result == 3
$b[0] = 7;
$b[5] = 9;
$b[10] = 11;
$result = count($b);
// $result == 3
$result = count(null);
// $result == 0
$result = count(false);
// $result == 1
?>
3. Manipulação de strings
Formatando strings
trim — Retira espaço no ínicio e final de uma string
Descrição
string trim ( string $str [, string $charlist] )
Esta função retorna uma string com os espaçoes retirados do ínicio e do final de str. Sem o segundo
parâmetro, trim() irá retirar estes caracteres
" " (ASCII 32 (0x20)), um espaço normal.

"\t" (ASCII 9 (0x09)), uma tabulação.
"\n" (ASCII 10 (0x0A)), uma linha nova (line feed).
"\r" (ASCII 13 (0x0D)), um retono de carro.
"\0" (ASCII 0 (0x00)), o byte NULL.
"\x0B" (ASCII 11 (0x0B)), uma tabulação vertical.
Você também pode especificar quais caracteres você quer retirar, através do parâmetro charlist.
Simplesmente liste todos os caracteres que você quer retirar. Com .. você pode especificar um
intervalo de caracteres.
Exemplo de uso de trim()
<?php
$text = "\t\tThese are a few words :) ... ";
$trimmed = trim($text);
// $trimmed = "These are a few words :) ..."
$trimmed = trim($text," \t.");
// $trimmed = "These are a few words :)"
$clean = trim($binary,"\0x00..\0x1F");
// trim the ASCII control characters at the beginning and end of $binary
// (from 0 to 31 inclusive)
?>
ltrim — Retira espaço em branco do início da string

rtrim — Retira espaço em branco do fim da string
nl2br — Insere quebras de linha HTML antes de todas novas linhas em uma string
Descrição
string nl2br ( string $string )
Retorna string com '<br />' inserido antes de todas as novas linhas.
Parâmetros
string
A string de entrada.
Valor Retornado
Retorna a string alterada.
Exemplo
<?php
echo nl2br("foo isn't\n bar");
?>
foo isn't<br />
bar
Unindo e dividindo strings
implode ou join — Junta elementos de uma matriz em uma string
Descrição
string implode ( string $glue, array $pieces )
Retorna uma string contendo os elementos da matriz na mesma ordem com uma ligação entre cada
elemento.
Exemplo
<?php
$array = array('lastname', 'email', 'phone');
$comma_separated = implode(",", $array);
print $comma_separated; // lastname,email,phone
?>
explode — Divide uma string em strings
Valor Retornado
array explode ( string $delimiter, string $string [, int $limit] )
Retorna uma matriz de strings, cada uma como substring de string formada pela divisão dela a partir
do delimiter.
Parâmetros

delimiter
O delimitador.
string
limit
Se limit é definido, o array retornado irá conter o máximo de elementos igual a limit com o último
elemento contendo o resto da string.
Se o parâmetro limit é negativo, todos componentes são retornados exceto os (x) últimos.
Valor Retornado
Se delimiter é uma string vazia (""), explode() irá retornar FALSE. Se delimiter contém um valor que
não contém em string, então explode() irá retornar um array contendo string.
Exemplos
<?php
$pizza = "piece1 piece2 piece3 piece4 piece5 piece6";
$pieces = explode(" ", $pizza);
echo $pieces[0]; // piece1
echo $pieces[1]; // piece2
// Example 2
$data = "foo:*:1023:1000::/home/foo:/bin/sh";
list($user, $pass, $uid, $gid, $gecos, $home, $shell) = explode(":", $data);
echo $user; // foo
echo $pass; // *
?>
Exemplos de parâmetro limit
<?php
$str = 'one|two|three|four';
// positive limit
print_r(explode('|', $str, 2));
// negative limit
print_r(explode('|', $str, -1));
?>
Array
(
[0] => one
[1] => two|three|four
)
Array
(
[0] => one
[1] => two
[2] => three
)

substr — Retorna uma parte de uma string
Descrição
string substr ( string $string, int $start [, int $length] )
substr()retorna a parte de string especificada pelo parâmetro start e length.
Se start não for negativo, a string retornada iniciará na posição start em string, começando em zero.
Por exemplo, na string 'abcdef', o caractere na posição 0 é 'a', o caractere na posição 2 é 'c', e assim
em diante.
Uso basico de substr()
<?php
$rest = substr("abcdef", 1); // retorna "bcdef"
$rest = substr("abcdef", 1, 3); // retorna "bcd"
$rest = substr("abcdef", 0, 4); // retorna "abcd"
$rest = substr("abcdef", 0, 8); // retorna "abcdef"
// Outra opção é acessar atravéz de chaves
$string = 'abcdef';
echo $string{0}; // retorna a
echo $string{3}; // retorna d
?>
Se start for negativo, a string retornada irá começar no caractere start a partir do fim de string.
Usando um inicio negativo
<?php
$rest = substr("abcdef", -1); // retorna "f"
$rest = substr("abcdef", -2); // retorna "ef"
$rest = substr("abcdef", -3, 1); // retorna "d"
?>
Se length for dado e for positivo, a string retornada irá conter length caracteres começando em start
(dependendo do tamanho de string). Se a string é menor do que start, será retornado FALSE.
Se length for dado e for negativo, então esta quantidade caracteres serão omitidos do final de string
(após a posicão de inicio ter sido calculada quando start for negativo). Se start denota uma posição
além da truncagem, uma string vazia será retornada.
Usando um length negativo
<?php
$rest = substr("abcdef", 0, -1); // retorna "abcde"
$rest = substr("abcdef", 2, -1); // retorna "cde"
$rest = substr("abcdef", 4, -4); // retorna ""
$rest = substr("abcdef", -3, -1); // retorna "de"
?>

Comparando strings
strcmp — Comparação de string segura para binário
Descrição
int strcmp ( string $str1, string $str2 )
Retorna < 0 se str1 é menor do que str2; > 0 se str1 é maior do que str2, e 0 se forem iguais.
Note que esta função diferencia maiúsculas e minúsculas.
strcasecmp — Comparação de strings sem diferenciar maiúsculas e minúsculas segura para binário
Descrição
int strcasecmp ( string $str1, string $str2 )
Retorna < 0 se str1 é menor do que str2; > 0 se str1 é maior do que str2, e 0 se forem iguais.
Exemplo strcasecmp()
<?php
$var1 = "Hello";
$var2 = "hello";
if (strcasecmp($var1, $var2) == 0) {
echo '$var1 é igual a $var2 numa comparação sem diferenciar maiúsculas e minúsculas';
}
?>
strnatcmp — Comparação de strings usando o algoritmo "natural order"
Descrição
int strnatcmp ( string $str1, string $str2 )
Esta função implementa um algoritmo de comparação de strings alfanumérico do jeito que um ser
humano faz, isto é descrito como "ordem natural". Um exemplo da diferença entre este algoritmo e
os algoritmos regulares de ordenação (usado em strcmp()) pode ser visto abaixo:
<?php
$arr1 = $arr2 = array("img12.png","img10.png","img2.png","img1.png");
echo "Comparação de string padrão\n";
usort($arr1,"strcmp");
print_r($arr1);
echo "\nComparação usando ordem natural\n";
usort($arr2,"strnatcmp");
print_r($arr2);
?>
O código acima irá gerar a seguinte saída:

Comparação de string padrão

Array
(
[0] => img1.png
[1] => img10.png
[2] => img12.png
[3] => img2.png
)
Comparação usando ordem natural
Array
(
[0] => img1.png
[1] => img2.png
[2] => img10.png
[3] => img12.png
)
strlen — Retorna o tamanho de uma string
Descrição
int strlen ( string $str )
Retorna o tamanho de string.
Exemplo strlen()
<?php
$str = 'abcdef';
echo strlen($str); // 6
$str = ' ab cd ';
echo strlen($str); // 7
?>
Localizando e substituindo substrings com funções de string
strstr — Encontra a primeira ocorrencia de uma string
Descrição
string strstr ( string $haystack, string $needle, bool $before_needle )
Retorna parte da string haystack a partir da primeira ocorrência de needle até o final de haystack.
Nota: Esta função diferencia maiúsculas e minúsculas. Para pesquisas que não diferenciem, use
stristr().
Nota: Se você quer somente determinar se um específica needle existem em haystack, use a função
mais rápida e que usa menos memória ao invés, strpos().
Parâmetros
haystack
needle

Se needle não é uma string, é convertido para um inteiro e aplicado como valor ordinal de um
caractere.
before_needle
Se TRUE (o padrão é FALSE), strstr() retorna a parte de haystack antes da primeira ocorrência de
needle.
Valor Retornado
Retorna a parte da string, ou FALSE se needle não é encontrado.
Exemplo strstr()
<?php
$email = 'name@example.com';
$domain = strstr($email, '@');
echo $domain; // prints @example.com
$user = strstr($email, '@', true);
echo $user; // prints name
?>
strpos — Encontra a posição da primeira ocorrência de uma string
Descrição
int strpos ( string $haystack, string $needle [, int $offset] )
Retorna a posição numérica da primeira ocorrência de needle dentro de haystack. Diferentemente de

strrpos(), esta função pode ter uma string inteira como o parâmetro needle e toda a string será
usada.
Se needle não for encontrado, strpos() irá retornar o boolean FALSE.
Atenção
Esta função pode retornar o booleano FALSE, mas também pode retornar um valor não-booleano que
pode ser avaliado como FALSE, como 0 ou "". Leia a seção em Booleanos para maiores informações.
Utilize o operador === para testar o valor retornado por esta função.
Exemplos strpos()
<?php
$mystring = 'abc';
$findme = 'a';
$pos = strpos($mystring, $findme);
// Note o uso de ===. Simples == não funcionaria como esperado
// por causa da posição de 'a' é 0 (primeiro) caractere.
if ($pos === false) {
echo "A string '$findme' não foi encontrada na string '$mystring'";
} else {
echo "A string '$findme' foi encontrada na string '$mystring'";
echo " e existe na posição $pos";
}
?>

Se o parâmetro needle não é uma string, é convertido para um inteiro e aplicado o valor do
caractere.
O parâmetro opcional offset permite a você definir a partir de qual caractere em haystack iniciar a
busca. A posição retorna ainda é relativa ao inicio de haystack.
strrpos — Encontra a posição da última ocorrência de um caractere em uma string
Descrição
int strrpos ( string $haystack, string $needle [, int $offset] )
Retorna a posição numérica da última ocorrência de needle na string haystack. Note que a needle
neste caso pode apenas ser um simples caractere PHP 4. Se uma string é passada como a needle,
então apenas o primeiro caractere dessa string será usado.
Se needle não é encontrado, retorna FALSE.
É fácil errar a interpretação dos valores de retorno para "character found at position 0" e "character
not found". Aqui segue um exemplo de como detectar a diferença:
<?php
// no PHP 4.0.0 e posterior:
$pos = strrpos($mystring, "b");
if ($pos === false) { // note: três sinais iguais
// não encontrado...
}
// em versões mais antigas do que 4.0.0:
$pos = strrpos($mystring, "b");
if (is_bool($pos) && !$pos) {
// não encontrado...
}
?>
Se needle não é uma string, ela é convertida para um inteiro e aplicada como o valor ordinal de um
caractere.
Nota: No PHP 5.0.0 o offset pode ser especificado para iniciar a busca num número arbitrário de
caracteres dentro da string. Valores negativos irão parar a busca em um ponto arbitrário antes do
final da string.
Nota: A needle pode ser uma string de mais de um caractere no PHP 5.
Parâmetros
haystack
needle
offset
strrchr — Encontra a ultima ocorrência de um caractere em uma string
Descrição
string strrchr ( string $haystack, char $needle )

Esta função retorna a parte de haystack que inicia na última ocorrência de needle e vai até o fim de
haystack.
Retorna FALSE se needle não for encontrado.
Se needle conter mais de um caractere, apenas o primeiro é usado. Isto é diferente da função
strchr().
Se needle não for uma string, é convertido para uma string e é aplicado o valor do caractere.
Exemplo strrchr()
<?php
// get last directory in $PATH
$dir = substr(strrchr($PATH, ":"), 1);
// get everything after last newline
$text = "Line 1\nLine 2\nLine 3";
$last = substr(strrchr($text, 10), 1 );
?>
str_replace — Substitui todas as ocorrências da string de procura com a string de substituição
Descrição
mixed str_replace ( mixed $pesquisa, mixed $substitui, mixed $assunto [, int $&count] )
Esta função retorna uma string ou um array com todas as ocorrências de pesquisa em assunto
substituidas com a o valor dado para substitui.
Exemplo
<?php
// Fornece: <body text='black'>
$bodytag = str_replace("%body%", "black", "<body text='%body%'>");
// Fornece: Hll Wrld f PHP
$vowels = array("a", "e", "i", "o", "u", "A", "E", "I", "O", "U");
$onlyconsonants = str_replace($vowels, "", "Hello World of PHP");
// Fornece: você comeria pizza, cerveja e sorvete todos os dias
$frase = "você comeria frutas, vegetais, e fibra todos os dias.";
$saudavel = array("frutas", "vegetais", "fibra");
$saboroso = array("pizza", "cerveja", "sorvete");
$novafrase = str_replace($saudavel, $saboroso, $frase);
// Uso do parâmetro count está disponível no PHP 5.0.0
$str = str_replace("ll", "", "good golly miss molly!", $count);
echo $count; // 2
?>
substr_replace — Substitui o texto dentro de uma parte de uma string
Descrição
mixed substr_replace ( mixed $string, string $replacement, int $start [, int $length] )
substr_replace() substitui uma cópia de string delimitada pelos parâmetros start e (opcionalmente)
length com a string dada em replacement.
Parâmetros
string

replacement
A string substituta.
start
Se start é positivo, a substituição começará no start-ésimo caractere da string.
Se start é negativo, a substituição começará no start-ésimo caractere do final de string.
length
Se dado e é positivo, ele representa o comprimento da porção de string que é para ser substituída.
Se ele é negativo, ele representa o número de caracteres do final de string para parar de substituir.
Se ele não é dado, então o padrão será até strlen( string ); i.e. o fim da substituição no final de
string. Obviamente, se length é zero então esta função irá ter efeito de inserir replacement em string
na dada posição start.
Valor Retornado
A string de resultado é retornada. Se string é um array, então um array será retornado.
Exemplos
<?php
$var = 'ABCDEFGH:/MNRPQR/';
echo "Original: $var<hr />\n";
/* Estes dois exemplos substituem tudo de $var com 'bob'. */
echo substr_replace($var, 'bob', 0) . "<br />\n";
echo substr_replace($var, 'bob', 0, strlen($var)) . "<br />\n";
/* Insere 'bob' direto no começo de $var. */
echo substr_replace($var, 'bob', 0, 0) . "<br />\n";
/* Estes dois exemplos substituem 'MNRPQR' em $var com 'bob'. */
echo substr_replace($var, 'bob', 10, -1) . "<br />\n";
echo substr_replace($var, 'bob', -7, -1) . "<br />\n";
/* Deleta 'MNRPQR' de $var. */
echo substr_replace($var, '', 10, -1) . "<br />\n";
?>
4. Utilização de funções
Argumentos de funções
Informações podem ser passadas para funções através da lista de argumentos, que é uma lista de
expressões delimitados por vírgulas.
Passando arrays para funções
<?php
function takes_array($input)
{
echo "$input[0] + $input[1] = ", $input[0]+$input[1];
}
?>

Fazendo argumentos serem passados por referência
Por padrão, argumentos de função são passados por valor (de forma que se você mudar o valor do
parâmetro dentro da função, ele não é alterado fora da função). Se você deseja permitir que uma
função modifique seus argumentos, você precisa passá-los por referência.
Se você quer que um argumento para uma função sempre seja passado por referência, você pode
preceder o nome do argumento com um "e comercial" (&) na definição da função:
<?php
function add_some_extra(&$string)
{
$string .= ' e alguma coisa mais.';
}
$str = 'Isto é uma string,';
add_some_extra($str);
echo $str; // imprime 'Isto é uma string, e alguma coisa mais.'
?>
Valores padrão de argumentos
Uma função pode definir valores padrão no estilo C++ para argumentos escalares, como a seguir:
<?php
function cafeteira ($tipo = "cappuccino")
{
return "Fazendo uma xícara de café $tipo.\n";
}
echo cafeteira ();
echo makecoffee(null);
echo cafeteira ("expresso");
?>
A saída do código acima será:
Fazendo uma xícara de café cappucino.

Fazendo uma xícara de .
Fazendo uma xícara de café expresso.
O PHP também permite que você use matrizes e o tipo especial NULL como valor padrão, por
exemplo:
Usando tipos não escalares como valores padrões
<?php
function makecoffee($types = array("cappuccino"), $coffeeMaker = NULL)
{
$device = is_null($coffeeMaker) ? "hands" : $coffeeMaker;
return "Making a cup of ".join(", ", $types)." with $device.\n";
}
echo makecoffee();
echo makecoffee(array("cappuccino", "lavazza"), "teapot");
?>

5. Conceitos e implementação de orientação a objeto
5.1. Classe
Toda definição de classe começa com a palavra-chave class, seguido por um nome da classe, que
pode ser qualquer nome que não seja uma palavra reservada no PHP. seguido por um par de chaves,
que contém a definição dos membros e métodos da classe. Uma pseudo variável, $this, está
disponível quando um método é chamado dentro de um contexto de objeto. $this é uma referência
para o objeto chamador do método (normalmente o objeto ao qual o método pertence, mas pode ser
outro objeto, se o método é chamado statically do contexto de um objeto secundário). Isso é
ilustrado no exemplo a seguir:
Variável $this em linguagens com orientação à objetos
<?php
class A
{
function foo()
{
if (isset($this)) {
echo '$this está definida (';
echo get_class($this);
echo ")\n";
} else {
echo "\$this não está definida.\n";
}
}
}
class B
{
function bar()
{
A::foo();
}
}
$a = new A();
$a->foo();
A::foo();
$b = new B();
$b->bar();
B::bar();
?>
$this está definida (a)

$this não está definida.
$this está definida (b)
$this não está definida.

Definição de SimpleClass
<?php
class SimpleClass
{
// declaração de membro
public $var = 'um valor padrão';
// declaração de método
public function displayVar() {
echo $this->var;
}
}
?>
5.2. Objeto
new
Para criar uma instância de um objeto, um novo objeto deve ser criado e atribuído à uma variável.
Um objeto sempre será atribuído quando for criado um novo objeto, a não ser que o objeto tenha
um construtor definido que dispare uma exceção por um erro. Classes devem ser definidas antes de
serem instanciadas (e em alguns casos isso é um requerimento).
Criando uma instância
<?php
$instance = new SimpleClass();
?>
No contexto da classe, é possível criar um novo objeto por new self and new parent.
Quando atribuír um instância já criada de um objeto à uma variável nova, essa acessarpa a mesma
instância do objeto que foi atribuído. Esse comportamento se mantem quando passando instâncias à
uma função. Uma nova instância de um objeto já criado pode ser feita clonando o mesmo.
Atribuíção de Objetos
<?php
$assigned = $instance;
$reference =& $instance;
$instance->var = '$assigned terá esse valor';
$instance = null; // $instance e $reference tornam-se nulos
var_dump($instance);
var_dump($reference);
var_dump($assigned);
?>
NULL
NULL
object(SimpleClass)#1 (1) {
["var"]=>
string(30) "$assigned terá esse valor"
}

5.3. Herança
Extends
Uma classe pode herdar métodos e membros de outra classe usando a palavra-chave extends na sua
declaração. Não é possível herdar classes múltiplas, uma classe só pode herdar uma classe base.
Os métodos e membros herdados podem ser sobrescritos, a não ser que a classe pai definiu um
método como final, redeclarando eles com o mesmo nome definido na classe pai. É possível acessar
os sobreescritos métodos ou membros estáticos referenciado-os com parent::
Herança Simples
<?php
class ExtendClass extends SimpleClass
{
// Redefine o método pai
function displayVar()
{
echo "Classe Herdeira\n";
parent::displayVar();
}
}
$extended = new ExtendClass();
$extended->displayVar();
?>
Classe Herdeira
um valor padrão
Sobrecarga
Tanto chamada de métodos e acesso a membros podem ser sobrecarregados pelos métodos __call,
__get e __set. Esses métodos só serão disparados quando seu objeto ou o objeto herdado não
contiver o membro ou método que você está tentando acessar. Todos os métodos sobrecarregados
devem ser definidos estáticos. Todos os métodos sobrecarregados devem ser definidos public.
É possível sobrecarregar as funções isset() and unset() através dos métodos __isset e __unset
respectivamente. O método __isset também é chamado com a função empty().
Sobrecarga de membros
void __set ( string $name, mixed $value )

mixed __get ( string $name )
bool __isset ( string $name )
void __unset ( string $name )
Nota: O método __set() não pode obter argumentos por referência.
Exemplo de sobrecarga com __get, __set, __isset e __unset

<?php
class Setter
{
public $n;
private $x = array("a" => 1, "b" => 2, "c" => 3);
public function __get($nm)
{
echo "Getting [$nm]\n";
if (isset($this->x[$nm])) {
$r = $this->x[$nm];
print "Returning: $r\n";
return $r;
} else {
echo "Nothing!\n";
}
}
public function __set($nm, $val)
{
echo "Setting [$nm] to $val\n";
if (isset($this->x[$nm])) {
$this->x[$nm] = $val;
echo "OK!\n";
} else {
echo "Not OK!\n";
}
}
public function __isset($nm)
{
echo "Checking if $nm is set\n";
return isset($this->x[$nm]);
}
public function __unset($nm)
{
echo "Unsetting $nm\n";
unset($this->x[$nm]);
}
}
$foo = new Setter();
$foo->n = 1;
$foo->a = 100;
$foo->a++;
$foo->z++;
var_dump(isset($foo->a)); //true
unset($foo->a);
var_dump(isset($foo->a)); //false
// Isso não passa pelo método __isset()
// porque 'n' é uma proriedade pública
var_dump(isset($foo->n));
var_dump($foo);
?>

Setting [a] to 100

OK!
Getting [a]
Returning: 100
Setting [a] to 101
OK!
Getting [z]
Nothing!
Setting [z] to 1
Not OK!
Checking if a is set
bool(true)
Unsetting a
Checking if a is set
bool(false)
bool(true)
object(Setter)#1 (2) {
["n"]=>
int(1)
["x:private"]=>
array(2) {
["b"]=>
int(2)
["c"]=>
int(3)
}
}
Sobrecarga de método
mixed __call ( string $name, array $arguments )
O método mágico __call() permite captura a invocação de métodos não existentes. Dessa forma,
__call() pode ser usado para implementar tratamento de métodos definidos pelo usuário que
dependem do nome do próprio método ser chamado. Isso é útil para implementações proxy, por
exemplo. Os argumentos que são passados na função serão definidos como um array no parâmetro
$arguments. O valor retornado do método __call() será retornado ao chamador do método.
Exemplo de sobrecarga com __call
<?php
class Caller
{
private $x = array(1, 2, 3);
function __call($m, $a)
{
print "Método $m chamado:\n";
var_dump($a);
return $this->x;
}
}
$foo = new Caller();
$a = $foo->teste(1, "2", 3.4, true);
var_dump($a);
?>

Método teste chamado:

array(4) {
[0]=>
int(1)
[1]=>
string(1) "2"
[2]=>
float(3.4)
[3]=>
bool(true)
}
array(3) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
int(3)
}
5.4. Criação de objetos
Construtores
void __construct ( [mixed $args [, $...]] )
PHP 5 permite que os desenvolvedores declarem métodos construtores para as classes. Classes que
tem um método construtor chamam esse método cada vez que um objeto novo é criado, então é
apropriado para qualquer inicialização que o objeto possa vir a precisar antes de ser usado.
Nota: Construtores pais não são chamados implicitamente se a classe filha define um construtor.
Para executar o construtor da classe pai, uma chamada a parent::__construct() dentro do construtor
da classe filha é necessária.
Usando novos construtores unificados
<?php
class ClasseBase {
function __construct() {
print "No construtor da ClasseBase\n";
}
}
class SubClasse extends ClasseBase {
parent::__construct();
print "No construtor da SubClasse\n";
}
}
$obj = new ClasseBase();
$obj = new SubClasse();
?>

Destrutores
void __destruct ( void )
Exemplo de Destrutor
<?php
class MinhaClasseDestruivel {
print "No construtor\n";
$this->name = "MinhaClasseDestruivel";
}
function __destruct() {
print "Destruindo " . $this->name . "\n";
}
}
$obj = new MinhaClasseDestruivel();
?>
5.5. Controle de acesso
Visibilidade
A visibilidade de uma propriedade ou método pode ser definida prefixando a declaração com as
palavras-chave: 'public','protected' ou 'private'. Itens declarados como public podem ser acessados
por todo mundo. Protected limita o acesso a classes herdadas (e para a classe que define o item).
Private limita a visibilidade para apenas a classe que define o item.
Visibilidade dos membros

Membros de uma classe devem ser definidos com public, private, ou protected.
Declaração de Membros
<?php
/**
* Define MinhaClasse
*/
class MinhaClasse
{
public $publica = 'Public';
protected $protegida = 'Protected';
private $privada = 'Private';
function imprimeAlo()
{
echo $this->publica;
echo $this->protegida;
echo $this->privada;
}
}
$obj = new MinhaClasse();
echo $obj->publica; // Funciona
echo $obj->protegida; // Erro Fatal
echo $obj->privada; // Erro Fatal
$obj->imprimeAlo(); // Mostra Public, Protected e Private

/**
* Define MinhaClasse2
*/
class MinhaClasse2 extends MinhaClasse
{
// Nós podemos redeclarar as propriedades públicas e protegidas mas não as privadas
protected $protegida = 'Protected2';
function imprimeAlo()
{
echo $this->publica;
echo $this->protegida;
echo $this->privada;
}
}
$obj2 = new MinhaClasse2();
echo $obj2->publica; // Works
echo $obj2->privada; // Undefined
echo $obj2->protegida; // Fatal Error
$obj2->imprimeAlo(); // Mostra Public, Protected2, Undefined
?>
Visibilidades de métodos
Métodos de classe devem ser definidos com public, private, ou protected. Métodos sem qualquer
declaração são definidas como public.
Declaração de método
<?php
/**
* Define MinhaClasse
*/
class MinhaClasse
{
// Contrutores devem ser public
public function __construct() { }
// Declara um método public
public function MeuPublico() { }
// Declara um método protected
protected function MeuProtegido() { }
// Declara um método private
private function MeuPrivado() { }
// Esse é public
function Foo()
{
$this->MeuPublico();
$this->MeuProtegido();
$this->MeuPrivado();
}
}
$minhaclasse = new MinhaClasse;

$minhaclasse->MeuPublico(); // Funciona
$minhaclasse->MeuProtegido(); // Erro Fatal
$minhaclasse->MeuPrivado(); // Erro Fatal

$minhaclasse->Foo(); // Public, Protected e Private funcionam

/**
* Define MinhaClasse2
*/
class MinhaClasse2 extends MinhaClasse
{
// Esse é public
function Foo2()
{
$this->MeuPublico();
$this->MeuProtegido();
$this->MeuPrivado(); // Erro Fatal
}
}
$minhaclasse2 = new MinhaClasse2;
$minhaclasse2->MeuPublico(); // Funciona
$minhaclasse2->Foo2(); // Public e Protected funcionam, Private não
class Bar
{
public function test() {
$this->testPrivate();
$this->testPublic();
}
public function testPublic() {
echo "Bar::testPublic\n";
}
private function testPrivate() {
echo "Bar::testPrivate\n";
}
}
class Foo extends Bar
{
public function testPublic() {
echo "Foo::testPublic\n";
}
private function testPrivate() {
echo "Foo::testPrivate\n";
}
}
$myFoo = new foo();
$myFoo->test(); // Bar::testPrivate
// Foo::testPublic
?>

QUESTÕES DE CONHECIMENTO DO CONTEÚDO HTML
1. O que significa a HTML?
Hyper Text Markup Language
Home Tool Markup Language
Hyperlinks and Text Markup
2. Quem é a responsável pelos padrões da WEB?
Netscape
The World Wide Web Consortium
Microsoft
3. Escolha a tag HTML correta que representa o Título.
<h1>
<head>
<heading>
<h6>
4. Qual é a tag correta para inserir uma quebra de linha?
<lb>
<br>
<break>
5. Qual é a correta HTML para adicionar uma cor de fundo?
<background>yellow</background>
<body color="yellow">
<body bgcolor="yellow">
6. Escolha a correta tag HTML que faz o texto negrito
<bld>
<bold>
<b>
<bb>

7. Escolha a correta tag HTML que faz o texto ítalico
<italics>
<i>
<ii>
8. Qual a correta HTML representa um hyperlink?
<a name="http://www.w3schools.com">W3Schools.com</a>
<a href="http://www.w3schools.com">W3Schools</a>
<a url="http://www.w3schools.com">W3Schools.com</a>
<a>http://www.w3schools.com</a>
9. Como você pode fazer um e-mail link?
<a href="xxx@yyy">
<mail>xxx@yyy</mail>
<mail href="xxx@yyy">
<a href="mailto:xxx@yyy">
10. Como você pode abrir um link in uma nova janela do navegdor?
<a href="url" target="_blank">

<a href="url" new>
<a href="url" target="new">
11. Qual dessas são tags de Tabela?
<table><tr><td>
<table><tr><tt>
<thead><body><tr>
<table><head><tfoot>

12. Escolha a correta HTML para alinha a esquerda o conteúdo dentro da célula de uma tabela
<td valign="left">
<td align="left">
<tdleft>
<td leftalign>
13. Como posso fazer uma lista de itens numéricos?
<dl>
<list>
<ul>
<ol>
14. Como posso fazer uma lista de cujos itens sejam marcadores em forma de pontos ou circulos?
<ul>
<ol>
<dl>
<list>
15. Qual é a correta HTML para fazer uma Caixa de Seleção?
<input type="check">
<check>
<input type="checkbox">
<checkbox>
16. Qual é a correta HTML para fazer um campo de entrada do tipo texto?
<input type="text">
<textfield>
<input type="textfield">
<textinput type="text">

17. Qual é a correta HTML para fazer uma lista do tipo drop-down (similar a Combobox no Delphi)?
<input type="list">
<input type="dropdown">
<select>
<list>
18. Qual é a correta HTML para fazer uma área de texto?
<input type="textarea">
<input type="textbox">
<textarea>
19. Qual é a correta HTML para inserir uma imagem?
<img src="image.gif">
<img>image.gif</img>
<image src="image.gif">
<img href="image.gif>
20. Qual é a correta HTML para inserir uma imagem de fundo?
<img src="background.gif" background>

<body background="background.gif">
<background img="background.gif">

Apostila PHP

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Apostila PHP

Enviado por

Direitos autorais:

Formatos disponíveis

“Deus é fiel!

Sem Ele nada somos e nada faríamos”

Prof° Alexandre EUGÊNIO da Silva

Rua da Quitanda 185

1. Estrutura e visão geral da linguagem

1.1. Interação entre PHP e HTML

1.6. Estruturas de controle

5. Conceitos e implementação de orientação a objeto:

5.4. Criação de objetos

5.5. Controle de acesso

Profº Alexandre Eugênio da Silva Página 1

1. Estrutura e visão geral da linguagem

Profº Alexandre Eugênio da Silva Página 2

1.1. Interação entre PHP e HTML

Ex.: Nosso primeiro script PHP: ola.php

Saída no navegador Código-fonte

Olá Mundo <html>

Profº Alexandre Eugênio da Silva Página 3

• Os identificadores podem ser de qualquer comprimento e podem consister em letras,

$this é uma variável especial que não pode ser atribuída.

Profº Alexandre Eugênio da Silva Página 4

Convertendo para booleano

Veja também Manipulação de tipos.

Quando convertendo para booleano, os seguintes valores são considerados FALSE:

• o próprio booleano FALSE

Qualquer outro valor é considerado TRUE (incluindo qualquer recurso).

-1 é considerado TRUE, como qualquer valor não zero (negativos ou positivos)!

Profº Alexandre Eugênio da Silva Página 5

Um inteiro é um número do conjunto Z = {..., -2, -1, 0, 1, 2, ...}.

Números de ponto flutuante

Profº Alexandre Eugênio da Silva Página 6

echo 'Você pode incluir novas linhas em strings,

// Imprime: Arnold disse uma vez: "I\'ll be back"

// Imprime: Você tem certeza em apagar C:\*.*?

// Imprime: Você tem certeza em apagar C:\*.*?

// Imprime: Isto não será substituido: \n uma nova linha

// Imprime: Variaveis $também não $expandem

array( chave => valor )

// chave pode ser tanto string ou um integer

Profº Alexandre Eugênio da Silva Página 7

O valor pode ser qualquer tipo PHP:

Você pode omitir a chave, colocando um par vazio de colchetes ("[]").

Profº Alexandre Eugênio da Silva Página 8

Convertendo para objeto

Profº Alexandre Eugênio da Silva Página 9

Nomes de constantes válidos e inválidos

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

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

Profº Alexandre Eugênio da Silva Página 10

Exemplo Nome Resultado

Além do operador básico de atribuição, há "operadores combinados" para todos os operadores

Profº Alexandre Eugênio da Silva Página 11

Exemplo Nome Resultado

Comparação com vários tipos

Tipo do 1º operando Tipo do 2º operando Resultado

Profº Alexandre Eugênio da Silva Página 12

Outro operador condicional é o operador ?: (ou ternário).

Atribuindo um valor padrão

Nota: É recomendado evitar "stacking" de expressões ternárias. O comportamento do PHP quando

Profº Alexandre Eugênio da Silva Página 13

Comportamento do ternário (não recomendado)

Operadores de controle de erro

// Isto funciona para qualquer expressão, não apenas para funções:

// Imprime: Você tem certeza em apagar C:\.?

// Imprime: Você tem certeza em apagar C:\.?