Prévia do material em texto
O que é o PHP?
O PHP (um acrônimo recursivo para PHP: Hypertext Preprocessor) é uma
linguagem de script open source de uso geral, muito utilizada, e especialmente
adequada para o desenvolvimento web e que pode ser embutida dentro do
HTML.
Ótimo, mas o que isso significa? Por exemplo:
Exemplo #1 Um exemplo introdutório
<!DOCTYPE HTML>
<html>
<head>
<title>Exemplo</title>
</head>
<body>
<?php
echo "Olá, eu sou um script PHP!";
?>
</body>
</html>
Em vez de muitos comandos para mostrar HTML (como acontece com C ou
Perl), as páginas PHP contém HTML em código mesclado que faz "alguma
coisa" (neste caso, mostra "Olá, eu sou um script PHP!"). O código PHP é
delimitado pelas instruções de processamento (tags) de início e
fim <?php e ?> que permitem que você entre e saia do "modo PHP".
O que distingue o PHP de algo como o JavaScript no lado do cliente é que o
código é executado no servidor, gerando o HTML que é então enviado para o
navegador. O navegador recebe os resultados da execução desse script, mas
não sabe qual era o código fonte. Você pode inclusive configurar seu servidor
web para processar todos os seus arquivos HTML com o PHP, e então não há
como os usuários dizerem o que você tem na sua manga.
A melhor coisa em usar o PHP é que ele é extremamente simples para um
iniciante, mas oferece muitos recursos avançados para um programador
profissional. Não tenha medo de ler a longa lista de recursos do PHP. Pode
entrar com tudo, o mais rápido que puder, e começar a escrever scripts simples
em poucas horas.
O que o PHP pode fazer?
Qualquer coisa. O PHP é focado principalmente nos scripts do lado do servidor,
portanto, você pode fazer qualquer coisa que outro programa CGI pode fazer,
como coletar dados de formulários, gerar páginas com conteúdo dinâmico ou
enviar e receber cookies. Mas o PHP pode fazer muito mais.
Existem três áreas principais onde os scripts PHP são usados:
o Scripts no lado do servidor (server-side). Este é o mais tradicional e principal
campo de atuação do PHP. Você precisa de três coisas para isto funcionar: o
interpretador do PHP (CGI ou módulo do servidor), um servidor web e um
navegador web. Você precisa rodar o servidor web conectado a uma instalação
do PHP. Você pode acessar os resultados de seu programa PHP com um
navegador web, visualizando a página PHP através do servidor web. Tudo isso
pode rodar na sua máquina pessoal se você estiver apenas experimentando
programar com o PHP. Veja a seção das instruções de instalação para mais
informações.
o Scripts de linha de comando. Você pode fazer um script PHP para executá-lo
sem um servidor ou navegador. A única coisa necessária é o interpretador
PHP. Esse tipo de uso é ideal para script executados usando o cron (Unix,
Linux) ou o Agendador de Tarefas (no Windows). Esses scripts podem ser
usados também para rotinas de processamento de texto simples. Veja a
seção Utilizando o PHP em linha de comando para mais informações.
o Escrever aplicações desktop. O PHP provavelmente não é a melhor linguagem
para criação de aplicações desktop com interfaces gráficas, mas se você
conhece bem o PHP, e gostaria de usar alguns dos seus recursos avançados
nas suas aplicações do lado do cliente, você pode usar o PHP-GTK para
escrever programas assim. Você também tem a possibilidade de escrever
aplicações multi-plataformas desse jeito. O PHP-GTK é uma extensão do PHP,
não disponibilizada na distribuição oficial. Caso esteja interessado no PHP-
GTK, visite » o site do projeto.
O PHP pode ser utilizado na maioria dos sistemas operacionais, incluindo
Linux, várias variantes do Unix (como HP-UX, Solaris e OpenBSD), Microsoft
Windows, Mac OS X, RISC OS e provavelmente outros. O PHP também tem
suporte à maioria dos servidores web atualmente. Isso inclui o Apache, o IIS e
muitos outros. E isso inclui qualquer servidor web que possa utilizar o binário
FastCGI do PHP, como o lighttpd e o nginx. O PHP trabalha tanto como
módulo quanto como um processador CGI.
Com o PHP, portanto, você tem liberdade de escolha de sistema operacional e
de servidor web. Além disso, você pode escolher entre utilizar programação
estruturada ou programação orientada a objeto (OOP), ou ainda uma mistura
das duas.
Com PHP você não está limitado a gerar somente HTML. As habilidades do
PHP incluem geração de imagens, arquivos PDF e até animações Flash
(utilizando libswf e Ming) criados dinamicamente, on the fly. Você pode
facilmente criar qualquer texto, como XHTML e outros arquivos XML. O PHP
pode gerar esses arquivos e salvá-los no sistema de arquivos, em vez de
mostrá-los em tela, formando um cache no lado do servidor para seu conteúdo
dinâmico.
Uma das características mais fortes e mais significativas do PHP é seu suporte
a uma ampla variedade de banco de dados. Escrever uma página web
consultando um banco de dados é incrivelmente simples usando uma das
extensões específicas de banco de dados (por exemplo, mysql), ou usando
uma camada de abstração como o PDO ou conectar a qualquer banco de
dados que suporte o padrão "Open Database Connection" usando a
extensão ODBC. Outros bancos de dados podem utilizar cURL ou sockets,
como o CouchDB.
O PHP também tem suporte para comunicação com outros serviços utilizando
protocolos como LDAP, IMAP, SNMP, NNTP, POP3, HTTP, COM (no
Windows) e incontáveis outros. Você também pode abrir sockets de rede e
interagir diretamente usando qualquer outro protocolo. O PHP também suporta
o intercâmbio de dados complexos WDDX, utilizado em virtualmente todas as
linguagens de programação para web. Falando de comunicação, o PHP
implementa a instanciação de objetos Java e os utiliza transparentemente
como objetos PHP.
O PHP tem recursos úteis para processamento de texto, incluindo expressões
regulares compatíveis com Perl (PCRE), e muitas outras extensões e
ferramentas para analisar e acessar documentos XML. O PHP padroniza todas
as extensões XML a partir da base sólida da libxml2, além de estender o
conjunto de recursos adicionando suporte
a SimpleXML, XMLReader e XMLWriter.
E existem muitas outras extensões interessantes, que são categorizadas
tanto alfabeticamente quanto por categoria. E existem também as extensões
PECL adicionais que podem, ou não, estar documentadas dentro do próprio
manual do PHP, como a » XDebug.
O que eu preciso? ¶
Neste tutorial nós presumimos que seu servidor tem suporte ao PHP ativado e
que todos os arquivos terminando com a extensão .php são tratados pelo PHP.
Na maioria dos servidores esta é a extensão padrão para os arquivos PHP,
mas pergunte ao administrador do seu servidor para ter certeza. Se o seu
servidor suporta PHP então você não precisa fazer mais nada. Apenas crie
seus arquivos .php, coloque-os no seu diretório web e o servidor irá
automaticamente interpretá-los para você. Não há necessidade de compilar
nada nem você precisa instalar qualquer ferramenta extra. Pense nesses
arquivos PHP como simples arquivos HTML com uma nova família de tags
mágicas que permitem que você faça todo tipo de coisas.
Digamos que você quer salvar sua preciosa conexão e desenvolver tudo
localmente. Neste caso, você precisará instalar um servidor web, como
o » Apache, e claro o » PHP. Você provavelmente também deseja instalar um
banco de dados, como por exemplo o » MySQL.
Sua primeira página PHP ¶
Crie um novo arquivo chamado ola.php e coloque-o no diretório root do seu
servidor web (DOCUMENT_ROOT) com o seguinte conteúdo:
Exemplo #1 Nosso primeiro script PHP: ola.php
<html>
<head>
<title>Teste PHP</title>
</head>
<body>
<?php echo "<p>Olá Mundo</p>"; ?>
</body>
</html>Use o seu navegador para acessar o arquivo com a URL de seu servidor web,
terminando com a referência ao arquivo /ola.php. Quando o desenvolvimento
for local esta URL será algo
como http://localhost/ola.php ou http://127.0.0.1/ola.php mas isso depende da
configuração do seu servidor web. Se tudo foi configurado corretamente, este
arquivo será interpretado pelo PHP e a seguinte mensagem será enviada ao
seu navegador:
<html>
<head>
<title>Teste PHP</title>
</head>
<body>
<p>Olá Mundo</p>
</body>
</html>
Este programa é realmente simples e você não precisa do PHP para criar uma
página assim (fixa). Tudo o que ela faz é mostrar: Hello Worldutilizando a
instrução echo. Note que o arquivo não precisa ser executável ou especial. O
servidor web descobre que este arquivo precisa ser interpretado pelo PHP por
causa da extensão ".php", que o servidor é configurado para repassar ao PHP.
Pense nisso como um arquivo HTML normal que por acaso possui um conjunto
de tags especiais disponíveis para você fazer muitas coisas interessantes.
Se você tentar rodar este exemplo e ele não mostrar nenhuma mensagem de
saída, ou aparecer uma caixa de diálogo pedindo para você salvar o arquivo,
ou você ver todo o conteúdo do arquivo como texto, há uma grande chance do
seu servidor não ter o PHP habilitado ou não estar configurado corretamente.
Peça ao seu administrador para habilitar o PHP para você usando o capítulo
de Instalação do manual. Se você está desenvolvendo localmente, leia também
o capítulo de instalação indicado acima para ter certeza de que configurou tudo
corretamente. Confirme que está acessando o arquivo via HTTP através do
servidor web. Se acessar o arquivo através do sistema de arquivos, então ele
não será interpretado pelo PHP. Caso o problema persista, não hesite em nos
chamar nos vários » canais de suporte do PHP.
O objetivo do exemplo é mostrar o formato especial das tags do PHP. Neste
exemplo nós usamos <?php para indicar que a partir daquele ponto entramos
no modo PHP. Então nós colocamos a instrução do PHP e saímos do modo
PHP adicionando a tag de fechamento, ?>. Você pode entrar e sair do modo
PHP num arquivo HTML desta maneira em qualquer lugar que você queira.
Para mais detalhes, leia a seção do manual que fala da sintaxe básica do PHP.
Tags PHP ¶
Quando o PHP interpreta um arquivo ele procura pelas tags de abertura e
fechamento, <?php e ?>, que dizem ao PHP para iniciar ou parar a
interpretação do código entre elas. A interpretação dessa maneira, permite o
PHP ser incluído em vários tipos de documentos, pois tudo que está fora
dessas tags é ignorado pelo interpretador do PHP.
O PHP também permite a tag curta <? (cujo uso é desencorajado pois essa
opção está disponível somente quando habilitada na diretivashort_open_tag no
arquivo de configuração php.ini, ou quando o PHP tiver sido compilado com a
opção --enable-short-tags ).
Se um arquivo for código PHP puro, é preferível omitir a tag de fechamento no
final do arquivo. Prevenindo a existência de espaços ou linhas em branco após
a tag, que podem causar efeitos indesejáveis, por que o PHP iniciará o buffer
de saída quando não existir intenção do programador de enviar alguma saída
neste ponto do script.
<?php
echo "Hello world";
// ... mais código
echo "última instrução";
// o script termina aqui, sem tag de fechamento PHP
Escapando o HTML ¶
Tudo o que estiver fora das tags PHP é ignorado pelo interpretador, o que
permite arquivos PHP de conteúdo misto. Permite que o PHP seja incluído
dentro de documentos HTML, para, por exemplo, para a criação de templates.
<p>Isto vai ser ignorado pelo PHP em enviado ao navegador.</p>
<?php echo 'Enquanto isto vai ser interpretado.'; ?>
<p>Isto também vai ser ignorado pelo PHP em enviado ao navegador.</p>
Isso funcionará porque quando o interpretador do PHP encontra ?>, a tag de
fechamento, ele simplesmente começa a repassar qualquer coisa que encontre
(exceto um fim de linha imediato, ver a seção sobre separação de instruções), até que
ele encontre outra tag de abertura a não ser que esteja no meio de uma instrução
condicional, onde então o interpretador vai determinar o resultado da condicional e
assim decidir qual caminho tomar. Veja no próximo exemplo.
Utilizando estruturas avançadas
Exemplo #1 Escape avançado usando condições
<?php if ($expression == true): ?>
Isto irá aparecer se a expressão for verdadeira.
<?php else: ?>
Senão isso que aparecerá.
<?php endif; ?>
Nesse exemplo o PHP irá escapar os blocos em que a condição não seja satisfeita,
mesmo que o trecho de código esteja fora das tags de abertura/fechamento do PHP,
pois o interpretador do PHP, irá pular os conteúdos de blocos que não possuem uma
condição que não foi satisfeita.
Para impressão de grandes blocos de texto, sair do modo de interpretação do
PHP é geralmente mais eficiente que enviar todo o texto através das
funções echo ou print.
No PHP 5 existem cinco diferentes pares de tags de abertura e fechamento
disponíveis, dependendo de como o interpretador estiver configurado. Dois
deles, <?php ?> e <script language="php"> </script> estão sempre
disponíveis. Também a tag curta de echo <?= ?>, que está sempre disponível
desde o PHP 5.4.0.
Separação de instruções ¶
Como no C ou Perl, o PHP requer que as instruções sejam terminadas com um
ponto-e-vírgula ao final de cada comando. A tag de fechamento de um bloco de
código PHP automaticamente implica em um ponto-e-vírgula; você não precisa
ter um ponto-e-vírgula terminando a última linha de um bloco PHP. A tag de
fechamento do bloco irá incluir uma nova linha logo após, se estiver presente.
<?php
echo 'Isto é um teste';
?>
<?php echo 'Isto é um teste' ?>
<?php echo 'Nós omitimos a última tag de fechamento';
Nota:
A tag de fechamento de um bloco PHP ao final de um arquivo é opcional, e em
alguns casos omiti-la é útil ao utilizar include ou require, assim espaços em
branco indesejados não irão aparecer ao final dos arquivos, e ainda, será
capaz de adicionar cabeçalhos a resposta. Também é útil se usar o buffer de
saída, e você não quer um espaço em branco ao final adicionado ao final das
partes geradas por arquivos incluídos.
Comentários ¶
O PHP suporta comentários no estilo 'C', 'C++' e do Unix shell (estilo Perl). Por
exemplo:
<?php
echo 'Isto é um teste'; // Estilo de comentário de uma linha em c
++
/* Este é um comentário de múltiplas linhas
ainda outra linha de comentário */
echo 'Isto é ainda outro teste';
echo 'Um teste final'; # Este é um comentário de uma linha no esti
lo shell
?>
Os comentários de estilo "uma linha" apenas comentam até o final da linha ou do
bloco PHP de código corrente, o que chegar primeiro. Isto significa que o código HTML
após // ... ?> ou # ... ?> SERÁ impresso: ?> interrompe o modo PHP e retorna para o
modo HTML, e // ou # não podem influenciar isto. Se a diretiva de
configuração asp_tags estiver habilitada, se comportará da mesma maneira que //
%> e # %>. Entretanto, a tag </script> não interrompe o modo PHP em um comentário
de uma linha.
<h1>Isto é um <?php # echo 'simples';?> exemplo.</h1>
<p>O cabeçalho acima irá dizer 'Isto é um exemplo'.</p>
Comentários no estilo 'C' terminam ao primeiro */ encontrado. Tenha certeza de não
aninhar comentários no estilo 'C'. É fácil fazer este equívoco se estiver tentando
comentar grandes blocos de código.
<?php
/*
echo 'Isto é um teste'; /* Este comentário irá causar um problema
*/
*/
?>
Sintaxe Básica ¶
Introdução ¶
O PHP suporta oito tipos primitivos.
Quatro tipos escalares:o boolean
o integer
o float (número de ponto flutuante, ou também double)
o string
Três tipos compostos:
o array
o object
o callable
E finalmente dois tipos especiais:
o resource
o NULL
Este manual também introduz alguns pseudo-tipos por razões de legibilidade:
o mixed
o number
o callback (também chamado callable)
o array|object
o void
E a pseudo-variável $....
Algumas referências para o tipo "double" podem aparecer no manual. Considere o tipo
double como sendo o float; os dois nomes existem por razões históricas.
O tipo de uma variável geralmente não é definido pelo programador: isto é decidido em
tempo de execução pelo PHP, dependendo do contexto no qual a variável é usada.
Nota: Para checar o tipo e valor de uma expressão, utilize a
função var_dump().
Para ter uma representação legível de um tipo para depuração, use a
função gettype(). Para verificar por um certo tipo, não use gettype(), mas sim as
funções is_tipo. Alguns exemplos:
<?php
$a_bool = TRUE; // um booleano
$a_str = "foo"; // uma string
$a_str2 = 'foo'; // uma string
$an_int = 12; // um inteiro
echo gettype($a_bool); // mostra: boolean
echo gettype($a_str); // mostra: string
// Se ele é um inteiro, incrementa-o com quatro
if (is_int($an_int)) {
$an_int += 4;
}
// Se $bool é uma string, mostre-a
// (não imprime nada)
if (is_string($a_bool)) {
echo "String: $a_bool";
}
?>
Para forçar a conversão de uma variável para um certo tipo, converta a variável ou use
a função settype() nela.
Note que uma variável pode ser avaliada com valores diferentes em certas situações,
dependendo de qual tipo ela é no momento. Para mais informações, veja a
seção Manipulação de tipos. A tabela de conversão de tipos também pode ser útil,
como mostra exemplos de comparações de vários tipos.
Inteiros ¶
Um inteiro é um número do conjunto Z = {..., -2, -1, 0, 1, 2, ...}.
Veja também:
o Inteiros de tamanho arbitrário / GMP
o Números de ponto flutuante
o Precisão arbitrária / BCMath
Sintaxe ¶
Inteiros podem ser especificados em notação decimal (base 10), hexadecimal (base
16), octal (base 8) ou binária (base 2), opcionalmente precedido de sinal (- ou +).
Inteiros binários literais estão disponíveis desde o PHP 5.4.0.
Para usar a notação octal, preceda o número com um 0 (zero). Para utilizar a
notação hexadecimal, preceda o número com 0x. Para utilizar a notação
binária, preceda o número com 0b.
Exemplo #1 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)
$a = 0b11111111; // número binário (equivalente ao 255 decimal)
?>
Formalmente, as estruturas para inteiros literais são:
decimal : [1-9][0-9]*
| 0
hexadecimal : 0[xX][0-9a-fA-F]+
octal : 0[0-7]+
binary : 0b[01]+
integer : [+-]?decimal
| [+-]?hexadecimal
| [+-]?octal
| [+-]?binary
O tamanho de um inteiro depende da plataforma, sendo um número
aproximado a 2 bilhões o valor mais comum (número de 32 bits com sinal).
Plataformas 64-bit possuem comumente o valor máximo de aproximadamente
9E18, exceto no Windows em versões anteriores ao PHP 7, onde são sempre
32-bit. O PHP não suporta inteiros sem sinal. O tamanho do inteiro pode ser
determinado pela constante PHP_INT_SIZE, e seu o valor máximo com a
constante PHP_INT_MAX, desde o PHP 4.4.0 e PHP 5.0.5, e o valor mínimo
utilizando a constante PHP_INT_MIN desde o PHP 7.0.0.
Aviso
Em versões anteriores ao PHP 7, se um dígito inválido é passado
para inteiro octal (por exemplo, 8 ou 9), o resto do número será ignorado.
Desde o PHP 7, um erro de interpretação é emitido.
Overflow de inteiros ¶
Se o PHP encontrar um número além dos limites do tipo inteiro, ele será
interpretado como um ponto flutuante. Assim, uma operação que resulte em um
número além dos limites do tipo inteiro, retornará um ponto flutuante.
Exemplo #2 Overflow de inteiros em sistemas 32-bit
<?php
$large_number = 2147483647;
var_dump($large_number); // int(2147483647)
$large_number = 2147483648;
var_dump($large_number); // float(2147483648)
$million = 1000000;
$large_number = 50000 * $million;
var_dump($large_number); // float(50000000000)
?>
Exemplo #3 Overflow de inteiros em sistemas 64-bit
<?php
$large_number = 9223372036854775807;
var_dump($large_number); // int(922337203685477580
7)
$large_number = 9223372036854775808;
var_dump($large_number); // float(9.2233720368548E
+18)
$million = 1000000;
$large_number = 50000000000000 * $million;
var_dump($large_number); // float(5.0E+19)
?>
Não há um operador de divisão que resulta em um integer no PHP. 1/2 retorna
o ponto flutuante 0.5. O valor pode ser convertido para inteiropara sempre
truncar o número, ou usar a função round() que provê um fino controle sobre o
arredondamento.
<?php
var_dump(25/7); // float(3.5714285714286)
var_dump((int) (25/7)); // int(3)
var_dump(round(25/7)); // float(4)
?>
Convertendo para inteiro ¶
Para converter explicitamente um valor para inteiro, utilize-se um dos
modificadores (int) ou (integer). Entretanto, na maioria dos casos, o modificador não é
necessário, já que o valor será automaticamente convertido se um operador, função
ou estrutura de controle requerer um inteiro como argumento. Um valor também pode
ser convertido para inteiro utilizando a função intval().
Se um recurso for convertido para um inteiro, resultará no número único do recurso,
atribuído ao recurso pelo PHP em tempo de execução.
Veja também Manipulação de tipos.
De booleanos ¶
FALSE será retornado como 0 (zero), e TRUE retornará 1 (um).
De números de ponto flutuante ¶
Conversão de números de ponto flutuante para inteiros, fará o número ser truncado.
Se o número convertido estiver além dos limites de um integer (geralmente +/-
2.15e+9 = 2^31 em plataformas 32 bit e +/- 9.22e+18 = 2^63 em plataformas
64-bit que não sejam Windows), o resultado é indefinido, por que o ponto
flutuante não possui precisão suficiente para fornecer um
resultado inteiro exato. Não se preocupe, pois nenhum aviso será emitido se
isso acontecer!
Nota:
A partir do PHP 7.0.0, em vez de ser um valor indefinido e que varia de acordo
com a plataforma, NaN e Infinity sempre serão zero quando convertido
para integer, a partir do PHP 7.0.0.
Aviso
Nunca modifique uma fração desconhecida para inteiro, porque isto pode, as
vezes, fornecer resultados inesperados.
<?php
echo (int) ( (0.1+0.7) * 10 ); // imprime 7!
?>
Números de ponto flutuante ¶
Números de ponto flutuante (também conhecidos como "floats", "doubles" ou
"números reais"), podem ser especificados utilizando qualquer uma das
seguintes sintaxes:
<?php
$a = 1.234;
$b = 1.2e3;
$c = 7E-10;
?>
Formalmente:
LNUM [0-9]+
DNUM ([0-9]*[\.]{LNUM}) | ({LNUM}[\.][0-9]*)
EXPONENT_DNUM [+-]?(({LNUM} | {DNUM}) [eE][+-]? {LNUM})
O tamanho de um número de ponto flutuante depende da plataforma, sendo o
máximo de ~1.8e308 com precisão de 14 dígitos decimais um valor comum
(número de 64 bits no formato IEEE).
Aviso
Precisão de números de ponto
flutuante
Números de ponto flutuante tem precisão limitada. Embora dependado
sistema, o PHP geralmente utiliza o formato de precisão dupla do IEEE 754,
que trará uma precisão máxima devida a arredondamentos da ordem de 1.11e-
16. Operações matemáticas incomuns poderão ocasionar erros maiores, e,
claro, a propagação de erros deve ser considerada quando várias operações
forem realizadas.
Além disso, números racionais que tem representação exata em números em
base 10, como 0.1 ou 0.7, não possuem representação exata em ponto
flutuante na base 2, o formato utilizado internamente, não importando o
tamanho da mantissa. Portanto não existe conversão para o formato interno
sem uma pequena perda de precisão. Isso pode ocasionar resultados
confusos: por exemplo, floor((0.1+0.7)*10)normalmente retornará 7, em vez do
resultado esperado 8, porque a representação interna final será algo
como 7.9999999999999991118....
Então, nunca confie em resultados com números de ponto flutuante até a
última casa, e nunca compare números de ponto flutuante em igualdades. Se
você realmente precisar de alta precisão, você pode utilizar as funções
matemáticas de precisão arbitrária e as funções gmp estão disponíveis.
Para uma explicação "simples" dessa questão, veja o » guia sobre ponto
flutuante, que também tem o título alternativo de "Porque meus números não
somam direito?".
Convertendo para float ¶
Para informações sobre a conversão de strings para float, veja a
seção Conversão de Strings para números. Para valores de outros tipos, o
valor é primeiro convertido para inteiro e então para float. Veja a
seção Convertendo para inteiros para mais informações. No PHP 5, um aviso é
emitido se você tentar converter um object para um float.
Comparando floats ¶
Como notado acima, testar números de ponto flutuante com igualdade é
problemático, por causa da maneira como são representados internamente.
Entretanto existem maneiras de fazer comparações com números de ponto
flutuante que contornam essas limitações.
Para testar números de ponto flutuante, utilize um "valor de erro máximo" na
comparação utilizada. Esse valor é também chamado de epsilon, ou unidade
de erro, e deve ser a diferença mínima aceitável no resultado dos cálculos.
$a e $b serão consideradas iguais até o 5º dígito de precisão.
<?php
$a = 1.23456789;
$b = 1.23456780;
$epsilon = 0.00001;
if(abs($a-$b) < $epsilon) {
echo "iguais";
}
?>
Strings ¶
Uma string é uma série de caracteres, onde um caractere é o mesmo que um
byte. Isso significa que o PHP possui suporte a um conjunto de apenas 256
caracteres, e, portanto, não possui suporte nativo a Unicode. Veja
mais detalhes do tipo string.
Nota: O tipo string possui o tamanho máximo de 2GB (máximo de 2147483647
bytes)
Sintaxe ¶
Uma string literal pode ser especificada de quatro formas diferentes.
o aspas simples
o aspas duplas
o sintaxe heredoc
o sintaxe nowdoc (desde o PHP 5.3.0)
Aspas simples ¶
A maneira mais simples de se especificar uma string é delimitá-la entre aspas
simples (o caractere ').
Para especificar um apóstrofo, escape-o com uma contrabarra (\). Para
especificar uma contrabarra literal, dobre-a (\\). Todas as outras ocorrências da
contrabarra serão tratadas como uma contrabarra literal: isso significa que
outras sequências de escape que se esteja acostumado a utilizar,
como \r ou \n, serão literalmente impressas em vez de ter qualquer significado
especial.
Nota: Diferentemente das sintaxes com aspas duplas e heredoc, variáveis e
sequências de escape para caracteres especiais não serão expandidas quando
ocorrerem dentro de uma string delimitada por aspas simples.
<?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: Variáveis $também não $expandem
echo 'Variáveis $também não $expandem';
?>
Aspas duplas ¶
Se a string for delimitada entre aspas duplas ("), o PHP interpretará a seguinte
sequência de escape como caracteres especiais:
Sequências de escape
Sequências Significado
\n fim de linha (LF ou 0x0A (10) em ASCII)
\r retorno de carro (CR ou 0x0D (13) em ASCII)
\t TAB horizontal (HT ou 0x09 (9) em ASCII)
\v TAB vertical (VT ou 0x0B (11) em ASCII) (desde o PHP 5.2.5)
\e escape (ESC or 0x1B (27) em ASCII) (desde o PHP 5.4.4)
\f form feed (FF ou 0x0C (12) em ASCII) (desde o PHP 5.2.5)
\\ contrabarra ou barra invertida
\$ sinal de cifrão
\" aspas duplas
\[0-7]{1,3} a sequência de caracteres correspondente a expressão regular é um caractere em notação octal, que silenciosamente é extravasada para caber em um
byte (e.g. "\400" === "\000")
\x[0-9A-Fa-
f]{1,2}
a sequência de caracteres correspondente a expressão regular é um caractere em notação hexadecimal
\u{[0-9A-Fa-f]+} a sequência de caracteres correspondente a expressão regular é um código Unicode, que será impresso como uma string que representa um código UTF-8
(adicionado no PHP 7.0.0)
Como com as strings entre aspas simples, escapar qualquer outro caractere
resultará em uma contrabarra sendo impressa. Em versões anteriores ao PHP
5.1.1, a contrabarra em \{$var} não era impressa.
O recurso mais importante de strings delimitadas por aspas duplas é o fato de
que nomes de variáveis serão expandidos. Veja interpretação de strings para
detalhes.
Heredoc ¶
Uma terceira maneira de delimitar strings é a sintaxe heredoc: <<<. Após este
operador, um identificador é fornecido seguido de uma nova linha. A própria string é
colocada em seguida e a seguir o mesmo identificador novamente para fechar a string.
O identificador de fechamento precisa começar na primeira coluna da linha. Além
disso, o identificador precisa seguir as mesmas regras de nomeação que qualquer
outro rótulo no PHP: deve conter somente caracteres alfanuméricos e sublinhados, e
precisa começar com um caractere não numérico ou sublinhado.
Aviso
É muito importante notar que a linha que contêm o identificador de fechamento não
deve conter nenhum outro caractere, com exceção do ponto-e-vírgula (;). Isso significa
que o identificador não deve ser indentado e não deve ter nenhum espaço ou
tabulações antes ou depois do ponto-e-vírgula. Também é importante perceber que o
primeiro caractere antes do identificador de fechamento deve ser uma nova linha como
definido pelo sistema operacional local. Isso é, \n em sistemas UNIX, incluindo o MAC
OS X. O identificador de fechamento também deve ser seguido por uma nova linha.
Se essa regra for quebrada e o identificador de fechamento não estiver "limpo", ele
não será considerado um identificador de fechamento, e o PHP continuará procurando
por um. Se um identificador de fechamento apropriado não for encontrado antes do
final do arquivo atual, um erro de interpretação será lançado na última linha.
Heredocs não podem ser usados para inicializar propriedades de classes.
Desde o PHP 5.3, esta limitação é válida somente para heredocs que contêm
variáveis.
Exemplo #1 Exemplo inválido
<?php
class foo {
public $bar = <<<EOT
bar
EOT;
}
?>
Textos heredoc se comportam como strings delimitadas por aspas duplas, sem
as aspas duplas. Isso significa que aspas simples em heredocs não precisam
ser escapadas, apesarde que os códigos de escape listados acima podem
continuar sendo utilizados. Variáveis são expandidas, mas o mesmo cuidado
deve ser tomado ao expressar variáveis complexas dentro do heredoc assim
como nas strings.
Exemplo #2 Exemplo de delimitação de strings heredoc
<?php
$str = <<<EOD
Exemplo de uma string
distribuída em várias linhas
utilizando a sintaxe heredoc.
EOD;
/* Exemplo mais complexo, com variáveis */
class foo
{
var $foo;
var $bar;
function foo()
{
$this->foo = 'Foo';
$this->bar = array('Bar1', 'Bar2', 'Bar3');
}
}
$foo = new foo();
$name = 'Meu nome';
echo <<<EOT
Meu nome é "$name". Eu estou imprimindo $foo->foo.
Agora, eu estou imprimindo {$foo->bar[1]}.
Isto deve imprimir um 'A' maiúsculo: \x41
EOT;
?>
O exemplo acima irá imprimir:
My name is "MyName". I am printing some Foo.
Now, I am printing some Bar2.
This should print a capital 'A': A
É possível também utilizar a sintaxe Heredoc para passar dados para
argumentos de funções:
Exemplo #3 Exemplo de Heredoc em argumentos
<?php
var_dump(array(<<<EOD
foobar!
EOD
));
?>
A partir do PHP 5.3.0, é possível inicializar variáveis estáticas e
propriedades/constantes de classe utilizando a sintaxe heredoc:
Exemplo #4 Utilizando o Heredoc na inicialização de valores estáticos
<?php
// Static variables
function foo()
{
static $bar = <<<LABEL
Nothing in here...
LABEL;
}
// Class properties/constants
class foo
{
const BAR = <<<FOOBAR
Constant example
FOOBAR;
public $baz = <<<FOOBAR
Property example
FOOBAR;
}
?>
A partir do PHP 5.3.0, o identificador de abertura do Heredoc pode ser
opcionalmente delimitado por aspas duplas:
Exemplo #5 Usando aspas no Heredoc
<?php
echo <<<"FOOBAR"
Hello World!
FOOBAR;
?>
Nowdoc ¶
Nowdocs estão para aspas simples assim como os heredocs estão para aspas
duplas em strings. Um nowdoc é especificado similarmente a um heredoc,
mas nenhuma interpretação é feita dentro de um nowdoc. A construção é ideal
para colocar códigos PHP ou outros grandes blocos de texto sem a
necessidade de usar escapes. Compartilha algumas características em comum
com a construção SGML <![CDATA[ ]]>, assim é declarado um bloco de texto
onde nada será analisado.
Um nowdoc é identificado com a mesma seqüência <<< usada para heredocs,
mas o identificador precisa ficar entre aspas simples, e.g. <<<'EOT'. Todas as
regras para identificadores heredoc também se aplicam para identificadores
nowdoc, especialmente aquelas referentes a aparência do identificador de
fechamento.
Exemplo #6 Exemplo de string em Nowdoc
<?php
$str = <<<'EOD'
Example of string
spanning multiple lines
using nowdoc syntax.
EOD;
/* Exemplo mais complexo, com variáveis. */
class foo
{
public $foo;
public $bar;
function foo()
{
$this->foo = 'Foo';
$this->bar = array('Bar1', 'Bar2', 'Bar3');
}
}
$foo = new foo();
$name = 'MyName';
echo <<<'EOT'
My name is "$name". I am printing some $foo->foo.
Now, I am printing some {$foo->bar[1]}.
This should not print a capital 'A': \x41
EOT;
?>
O exemplo acima irá imprimir:
My name is "$name". I am printing some $foo->foo.
Now, I am printing some {$foo->bar[1]}.
This should not print a capital 'A': \x41
Exemplo #7 Exemplo de dado estático
<?php
class foo {
public $bar = <<<'EOT'
bar
EOT;
}
?>
Nota:
Suporte a Nowdoc foi adicionado no PHP 5.3.0.
Interpretação de variáveis ¶
Quando uma string é especificada dentro de aspas duplas ou heredoc,
as variáveis são interpretadas dentro delas.
Há dois tipos de sintaxe: uma simples e um complexa. A sintaxe simples é a mais
comum e conveniente. Provê uma maneira de interpretar uma variável, o valor de
um array ou uma propriedade de objeto em uma string com o mínimo de esforço.
A sintaxe complexa pode ser reconhecida pelas chaves envolvendo a expressão.
Sintaxe simples
Se um sinal de cifrão ($) for encontrado, o interpretador tentará obter tantos
identificadores quantos forem possíveis para formar um nome de variável válido.
Envolva o nome da variável com chaves para especificar explicitamente o fim do
nome.
<?php
$juice = "apple";
echo "He drank some $juice juice.".PHP_EOL;
// Invalid. "s" is a valid character for a variable name, but the vari
able is $juice.
echo "He drank some juice made of $juices.";
// Valid. Explicitly specify the end of the variable name by enclosing
it in braces:
echo "He drank some juice made of ${juice}s."
?>
O exemplo acima irá imprimir:
He drank some apple juice.
He drank some juice made of .
He drank some juice made of apples.
Similarmente, um índice de array ou uma propriedade de um objeto podem ser
interpretados. Com índices de arrays, o fechamento de colchetes (]) marca o final do
índice. A mesma regra aplica-se a propriedade de objetos, assim como para variáveis
simples.
Exemplo #8 Simple syntax example
<?php
$juices = array("apple", "orange", "koolaid1" => "purple");
echo "He drank some $juices[0] juice.".PHP_EOL;
echo "He drank some $juices[1] juice.".PHP_EOL;
echo "He drank some $juices[koolaid1] juice.".PHP_EOL;
class people {
public $john = "John Smith";
public $jane = "Jane Smith";
public $robert = "Robert Paulsen";
public $smith = "Smith";
}
$people = new people();
echo "$people->john drank some $juices[0] juice.".PHP_EOL;
echo "$people->john then said hello to $people->jane.".PHP_EOL;
echo "$people->john's wife greeted $people->robert.".PHP_EOL;
echo "$people->robert greeted the two $people->smiths."; // Won't work
?>
O exemplo acima irá imprimir:
He drank some apple juice.
He drank some orange juice.
He drank some purple juice.
John Smith drank some apple juice.
John Smith then said hello to Jane Smith.
John Smith's wife greeted Robert Paulsen.
Robert Paulsen greeted the two .
Para qualquer coisa mais complexa, você deve utilizar a sintaxe complexa.
Sintaxe complexa (chaves)
Isto não é chamado sintaxe complexa porque a sintaxe é complexa, mas sim para
utilização de expressões complexas.
Qualquer variável escalar, elemento de um array ou propriedade de um objeto com
uma representação de uma string pode ser incluída com essa sintaxe. Simplesmente
escreva a expressão da mesma forma como apareceria fora da string e então coloque-
o entre { e }. Já que que {não pode escapado, esta sintaxe será somente reconhecida
quando o $ seguir, imediatamente, o {. Use {\$ para obter um literal {$. Alguns
exemplos para torná-lo claro:
<?php
// Show all errors
error_reporting(E_ALL);
$great = 'fantastic';
// Won't work, outputs: This is { fantastic}
echo "This is { $great}";
// Works, outputs: This is fantastic
echo "This is {$great}";
// Works
echo "This square is {$square->width}00 centimeters broad.";
// Works, quoted keys only work using the curly brace syntax
echo "This works: {$arr['key']}";
// Works
echo "This works: {$arr[4][3]}";
// This is wrong for the same reason as $foo[bar] is wrong outside a
string.
// In other words, it will still work, but only because PHP first look
s for a
// constant named foo; an error of level E_NOTICE (undefined constant)
will be
// thrown.
echo "This is wrong: {$arr[foo][3]}";// Works. When using multi-
dimensional arrays, always use braces around arrays
// when inside of strings
echo "This works: {$arr['foo'][3]}";
// Works.
echo "This works: " . $arr['foo'][3];
echo "This works too: {$obj->values[3]->name}";
echo "This is the value of the var named $name: {${$name}}";
echo "This is the value of the var named by the return value of getNam
e(): {${getName()}}";
echo "This is the value of the var named by the return value of \$obje
ct->getName(): {${$object->getName()}}";
// Won't work, outputs: This is the return value of getName(): {getNam
e()}
echo "This is the return value of getName(): {getName()}";
?>
Também é possível acessar propriedades de classes usando variáveis que
contêm strings utilizando esta sintaxe.
<?php
class foo {
var $bar = 'I am bar.';
}
$foo = new foo();
$bar = 'bar';
$baz = array('foo', 'bar', 'baz', 'quux');
echo "{$foo->$bar}\n";
echo "{$foo->{$baz[1]}}\n";
?>
O exemplo acima irá imprimir:
I am bar.
I am bar.
Nota:
Funções, chamadas a métodos, variáveis estáticas de classe e constantes de
classe dentro de {$} funcionam desde o PHP 5. Entretanto, o valor acessado
deverá ser interpretado como o nome de uma variável no escopo em que a
string está definida. Utilizar somente chaves ({}) não funcionará para acessar
os valores de retorno de funções ou métodos nem os valores de constantes da
classe ou variáveis estáticas da classe.
<?php
// Show all errors.
error_reporting(E_ALL);
class beers {
const softdrink = 'rootbeer';
public static $ale = 'ipa';
}
$rootbeer = 'A & W';
$ipa = 'Alexander Keith\'s';
// This works; outputs: I'd like an A & W
echo "I'd like an {${beers::softdrink}}\n";
// This works too; outputs: I'd like an Alexander Keith's
echo "I'd like an {${beers::$ale}}\n";
?>
Acesso e modificação da string por caractere ¶
É possível acessar e modificar caracteres dentro de strings especificando a
posição, baseada em zero, do caractere desejado na stringusando de
colchetes, parecido com arrays, por exemplo $str[42]. Imagine
uma string como um array de caracteres. As
funções substr() e substr_replace(), podem ser utilizadas quando se deseja
extrair ou substituir mais que 1 caractere.
Nota: Strings também podem ser acessadas usando colchetes, como
em $str{42}, com o mesmo propósito.
Aviso
Escrever em uma posição fora do intervalo preenche a string com espaços. Tipos
diferentes de inteiro são convertidos para inteiro. Tipo ilegal de deslocamento
emite E_NOTICE. Deslocamento negativo emite E_NOTICE na escrita e uma uma string
vazia na leitura. Somente o primeiro caractere de uma string atribuída é usada. Atribuir
uma string vazia atribui o byte NULL.
Aviso
Internamente, as strings do PHP são arrays de bytes. Como resultado, acessar ou
modificar uma string usando colchetes não é seguro com multi-bytes e deve ser feito
somente em strings que utilizem apenas um byte em sua codificação, como a ISO-
8859-1.
Exemplo #9 Alguns exemplos com strings
<?php
// Get the first character of a string
$str = 'This is a test.';
$first = $str[0];
// Get the third character of a string
$third = $str[2];
// Get the last character of a string.
$str = 'This is still a test.';
$last = $str[strlen($str)-1];
// Modify the last character of a string
$str = 'Look at the sea';
$str[strlen($str)-1] = 'e';
?>
A partir do PHP 5.4 o deslocamento de strings devem ser inteiros ou strings
equivalentes a inteiros, caso contrário um erro do tipo warning será disparado.
Anteriormente um deslocamento como "foo" era silenciosamente convertido
em 0.
Exemplo #10 Diferenças entre o PHP 5.3 e PHP 5.4
<?php
$str = 'abc';
var_dump($str['1']);
var_dump(isset($str['1']));
var_dump($str['1.0']);
var_dump(isset($str['1.0']));
var_dump($str['x']);
var_dump(isset($str['x']));
var_dump($str['1x']);
var_dump(isset($str['1x']));
?>
O exemplo acima irá imprimir no PHP 5.3:
string(1) "b"
bool(true)
string(1) "b"
bool(true)
string(1) "a"
bool(true)
string(1) "b"
bool(true)
O exemplo acima irá imprimir no PHP 5.4:
string(1) "b"
bool(true)
Warning: Illegal string offset '1.0' in /tmp/t.php on line 7
string(1) "b"
bool(false)
Warning: Illegal string offset 'x' in /tmp/t.php on line 9
string(1) "a"
bool(false)
string(1) "b"
bool(false)
Variáveis - Básico ¶
As variáveis no PHP são representadas por um cifrão ($) seguido pelo nome da
variável. Os nomes de variável são case-sensitive.
Nomes de variável seguem as mesmas regras como outros rótulos no PHP.
Um nome de variável válido inicia-se com uma letra ou sublinhado, seguido de
qualquer número de letras, números ou sublinhados. Em uma expressão
regular, poderia ser representado assim: '[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*'
Nota: Para nosso propósito, as letras a-z, A-Z e os bytes de 127 a 255 (0x7f-
0xff).
Nota: $this é uma variável especial que não pode ser atribuída.
Dica
Veja também o Guia de nomenclatura em espaço de usuário.
Para informação sobre funções relacionadas a variáveis, veja a Referência de
funções para variáveis.
<?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
?>
Por padrão, as variáveis são sempre atribuídas por valor. Isto significa que ao
atribuir uma expressão a uma variável, o valor da expressão original é copiado
integralmente para a variável de destino. Isto significa também que, após
atribuir o valor de uma variável a outra, a alteração de uma destas variáveis
não afetará a outra. Para maiores informações sobre este tipo de atribuição,
veja o capítulo em Expressões.
O PHP também oferece um outro meio de atribuir valores a
variáveis: atribuição por referência. Isto significa que a nova variável
simplesmente referencia (em outras palavras, "torna-se um apelido para" ou
"aponta para") a variável original. Alterações na nova variável afetam a original,
e vice versa.
Para atribuir por referência, simplesmente adicione um e-comercial (&) na
frente do nome da variável que estiver sendo atribuída (variável de origem) Por
exemplo, o trecho de código abaixo imprime 'My name is Bob' duas vezes:
<?php
$foo = 'Bob'; // Atribui o valor 'Bob' a variável $foo
$bar = &$foo; // Referecia $foo através de $bar.
$bar = "My name is $bar"; // Altera $bar...
echo $bar;
echo $foo; // $foo é alterada também.
?>
Uma observação importante a se fazer, é que somente variáveis nomeadas
podem ser atribuídas por referência.
<?php
$foo = 25;
$bar = &$foo; // Esta atribuição é válida.
$bar = &(24 * 7); // Inválido; referencia uma expressão sem nome.
function test()
{
return 25;
}
$bar = &test(); // Inválido.
?>
Não é necessário inicializar variáveis no PHP, contudo é uma ótima prática.
Variáveis não inicializadas tem um valor padrão de tipo dependendo do
contexto no qual são usadas - padrão de booleanos é FALSE, de inteiros e
ponto-flutuantes é zero, strings (por exemplo, se utilizados em echo), são
definidas como vazia e arrays tornam-se um array vazio.
Exemplo #1 Valores padrões de variáveis não inicializadas
<?php
// Limpa e remove referência (sem uso de contexto)a variável; imprime
NULL
var_dump($unset_var);
// Uso de booleano; imprime 'false' (Veja sobre operadores ternário pa
ra saber mais sobre a sintaxe)
echo ($unset_bool ? "true" : "false"); // false
// Uso de string; imprime 'string(3) "abc"'
$unset_str .= 'abc';
var_dump($unset_str);
// Uso de inteiro; imprime 'int(25)'
$unset_int += 25; // 0 + 25 => 25
var_dump($unset_int);
// Uso de float/double; imprime 'float(1.25)'
$unset_float += 1.25;
var_dump($unset_float);
// Uso de array; imprime array(1) { [3]=> string(3) "def" }
$unset_arr[3] = "def"; // array() + array(3 => "def") => array(3 => "d
ef")
var_dump($unset_arr);
// Uso de objeto; cria novo objeto stdClass (veja http://www.php.net/m
anual/en/reserved.classes.php)
// Imprime: object(stdClass)#1 (1) { ["foo"]=> string(3) "bar" }
$unset_obj->foo = 'bar';
var_dump($unset_obj);
?>
Confiar no valor padrão de uma variável não inicializada é problemático no
caso de incluir um arquivo em outro que usa uma variável de mesmo nome. E
também um dos maiores riscos de segurança com register_globals habilitada.
Erros de nível E_NOTICE serão emitidos no caso de ter variáveis não
inicializadas, contudo não no caso de adicionar elementos a um array não
inicializado. O construtor da linguagem isset() pode ser usado para detectar se
uma variável não foi inicializada.
Escopo de variáveis ¶
O escopo de uma variável é o contexto onde foi definida. A maioria das variáveis do
PHP tem somente escopo local. Este escopo local inclui os arquivos incluídos e
requeridos. Por exemplo:
<?php
$a = 1;
include 'b.inc';
?>
Aqui a variável $a estará disponível no script incluído b.inc. Entretanto, nas funções
definidas pelo usuário, um escopo local é introduzido. Qualquer variável utilizada
dentro de uma função é, por padrão, limitada ao escopo local da função. Por exemplo:
<?php
$a = 1; /* escopo global */
function Teste()
{
echo $a; /* referencia uma variável do escopo local (não definida)
*/
}
Teste();
?>
Este script não produz nenhuma saída porque a instrução echo refere-se a uma
versão local da variável $a, e não possui nenhum valor atribuído neste escopo. Pode-
se perceber que esta é uma pequena diferença em relação a linguagem C, em que
variáveis globais estão automaticamente disponíveis para funções sem sobrescrever
uma definição local. Isto pode causar problemas quando inadvertidamente modificar-
se uma variável global. No PHP, as variáveis globais precisam ser declaradas como
globais dentro de uma função, se for utilizada em uma.
A palavra-chave global ¶
Primeiro, um exemplo de global:
Exemplo #1 Usando global
<?php
$a = 1;
$b = 2;
function Soma()
{
global $a, $b;
$b = $a + $b;
}
Soma();
echo $b;
?>
O script acima imprimirá3. Declarando $a e $b globais na função, fará com que todas
as referências a essas variáveis referenciem a versão global. Não há um limite para o
número de variáveis globais que podem ser manipuladas por uma função.
Uma segunda maneira de acessar variáveis do escopo global é utilizando o array
especial $GLOBALS definido pelo PHP. O exemplo anterior poderia ser reescrito como:
Exemplo #2 Usando $GLOBALS no lugar de global
<?php
$a = 1;
$b = 2;
function Soma()
{
$GLOBALS['b'] = $GLOBALS['a'] + $GLOBALS['b'];
}
Soma();
echo $b;
?>
O array $GLOBALS é um array associativo, sendo o nome da variável global a chave do
array e o seu conteúdo da variável como o valor do elemento do array. Veja
que $GLOBALS existe em qualquer escopo, isto porque $GLOBALS é uma superglobal.
Segue um exemplo demonstrando o poder das superglobais:
Exemplo #3 Exemplo demonstrando superglobals e escopos
<?php
function test_global()
{
// A maioria das variaveis pré-
definidas nao sao 'super' e requerem
// 'global' para serem disponiveis para funcoes em qualquer escopo
.
global $HTTP_POST_VARS;
echo $HTTP_POST_VARS['name'];
// Superglobais são disponiveis em qualquer escopo e
// nao precisam de 'global'. Superglobais existem
// desde o PHP 4.1.0, e HTTP_POST_VARS é agora
// tida como obsoleta.
echo $_POST['name'];
}
?>
Nota:
Utilizar a instrução global fora de uma função não é um erro. Deve ser utilizado
se um arquivo for incluído dentro de uma função.
Utilizando variáveis static ¶
Outro recurso importante do escopo de variáveis é a variável static. Uma variável
estática existe somente no escopo local da função, mas não perde seu valor quando o
nível de execução do programa deixa o escopo. Considere o seguinte exemplo:
Exemplo #4 Exemplo demonstrando a necessidade de variáveis estáticas
<?php
function Teste()
{
$a = 0;
echo $a;
$a++;
}
?>
Essa função é inútil, já que cada vez que é chamada, define $a com o valor 0, e
imprime 0. A instrução $a++ , que aumenta o valor da variável, não tem sentido já que
assim que a função termina a variável $a desaparece. Para fazer um função
contadora, que não perderá a conta atual, a variável $a será declarada como estática:
Exemplo #5 Exemplo de uso de variáveis estáticas
<?php
function Teste()
{
static $a = 0;
echo $a;
$a++;
}
?>
Agora, a variável $a é inicializada apenas na primeira chamada da função e cada vez
que a função test() for chamada, imprimirá o valor de $a e depois o incrementará.
Variáveis estáticas fornecem uma solução para lidar com funções recursivas. Uma
função recursiva é aquela chama a si mesma. Cuidados devem ser tomados quando
escrever funções recursivas porque é possível que ela continue na recursão
indefinidamente. Deve-se assegurar que há uma maneira adequada de terminar a
recursão. A seguinte função recursiva conta até 10, utilizando a variável
estática $count para saber quando parar:
Exemplo #6 Variáveis estáticas em funções recursivas
<?php
function Teste()
{
static $count = 0;
$count++;
echo $count;
if ($count < 10) {
Teste();
}
$count--;
}
?>
Nota:
Variáveis estáticas podem ser declaradas como visto nos exemplos acima. A
partir do PHP 5.6 é possível atribuir valores a essas variáveis, que são
resultados de expressões, porém não é possível usar nenhuma função, o que
causará um erro de interpretação.
Exemplo #7 Declarando variáveis estáticas
<?php
function foo(){
static $int = 0; // correro
static $int = 1+2; // correto (a partir do PHP 5.6)
static $int = sqrt(121); // errado (é uma expressão)
$int++;
echo $int;
}
?>
Nota:
Declarações estáticas são resolvida em tempo de compilação.
Referencias em variáveis global e static ¶
A Zend Engine 1, base do PHP 4, implementa os modificadores static e global para
variáveis, em termo de referências. Por exemplo, uma variável global verdadeira,
importada dentro do escopo de uma função com a instrução global, na verdade, cria
uma referência para a variável global. Isto pode levar a comportamentos imprevisíveis
nos seguintes casos:
<?php
function test_global_ref() {
global $obj;
$obj = &new stdclass;
}
function test_global_noref() {
global $obj;
$obj = new stdclass;
}
test_global_ref();
var_dump($obj);
test_global_noref();
var_dump($obj);
?>
O exemplo acima irá imprimir:
NULL
object(stdClass)(0) {
}
Um comportamento similar seaplica a declaração static. Referências não são
armazenadas estaticamente:
<?php
function &get_instance_ref() {
static $obj;
echo 'Objeto estatico: ';
var_dump($obj);
if (!isset($obj)) {
// Assimila uma referencia a variavel estatica
$obj = &new stdclass;
}
$obj->property++;
return $obj;
}
function &get_instance_noref() {
static $obj;
echo "Objeto estatico: ";
var_dump($obj);
if (!isset($obj)) {
// Assimila o objeto para a veriavel estatica
$obj = new stdclass;
}
$obj->property++;
return $obj;
}
$obj1 = get_instance_ref();
$still_obj1 = get_instance_ref();
echo "\n";
$obj2 = get_instance_noref();
$still_obj2 = get_instance_noref();
?>
O exemplo acima irá imprimir:
Objeto estatico: NULL
Objeto estatico: NULL
Objeto estatico: NULL
Objeto estatico: object(stdClass)(1) {
["property"]=>
int(1)
}
Este exemplo demonstra que, atribuir uma referência a uma variável estática, fará com
que ela não se lembre quando chamou a função&get_instance_ref() uma segunda vez.
CONSTANTES
Sintaxe ¶
Você pode definir uma constante utilizando a função define(), ou a palavra-
chave const fora da definição de uma classe a partir do PHP 5.3.0.
Enquanto define() permite que uma constante seja definida para uma expressão
arbitrária, a palavra-chave const possui restrições conforme descrita no próximo
parágrafo. Uma vez definida, a constante não poderá ser modificada ou anulada.
Ao usar a palavra-chave const, somente dados escalares
(boolean, integer, float e string) podem ser colocados em constantes até o PHP 5.6. A
partir do PHP 5.6, é possível também utilizar qualquer expressão escalar como
constantes e também array constante. É permitido o uso de um resource (recurso)
como valor de constante, mas deve ser evitado, já que pode causar resultados
inesperados.
Pode-se obter o valor de uma constante simplesmente especificando seu nome.
Diferentemente de variáveis, você não prefixará uma constante com um sinal de $.
Também pode-se 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.
Nota: As constantes e variáveis (globais) estão em espaços de nomes
diferentes. Isto implica, por exemplo, que TRUE e $TRUE sejam geralmente
diferentes.
Ao usar-se uma constante indefinida, o PHP assumirá o nome da constante como seu
próprio valor, como se tivesse a chamando como umastring (CONSTANT vs
"CONSTANT"). Um erro de nível E_NOTICE será emitido quando isso acontecer. Veja
também a referência do manual sobre como $foo[bar] é errado (a não ser que
primeiro define() bar como uma constante). Isto não se aplica a constantes totalmente
qualificas, que lançarão um erro fatal se não estiverem definidas. Se você
simplesmente quer checar se uma constante foi definida, utilize a função defined().
Estas são as diferenças entre constantes e variáveis:
o Constantes não possuem um sinal de cifrão ($) antes delas;
o Antes do PHP 5.3 as constantes só podem ser definidas utilizando a
função define(), e não por simples assimilação;
o Constantes podem ser definidas e acessadas de qualquer lugar sem que a
regras de escopo de variáveis seja aplicadas;
o Constantes não podem ser redefinidas ou eliminadas depois de criadas; e
o Constantes só podem ter valores escalares. A partir do PHP 5.6 é possível
definir um array constante com a instrução const e a partir do PHP 7 arrays
constantes também podem ser definidas utilizando a define() Pode-se utilizar
arrays em expressões escalares constantes (por exemplo const FOO =
array(1,2,3)[0];), cujo resultado final deve ser um valor de um tipo permitido.
Exemplo #1 Definindo Constantes
<?php
define("CONSTANT", "Hello world.");
echo CONSTANT; // imprime "Hello world."
echo Constant; // imprime "Constant" e gera um alerta notice.
?>
Exemplo #2 Definindo Constantes usando a palavra-chave const
<?php
// Funciona a partir do PHP 5.3.0
const CONSTANT = 'Hello World';
echo CONSTANT;
// Funciona a partir do PHP 5.6.0
const ANOTHER_CONST = CONSTANT.'; Goodbye World';
echo ANOTHER_CONST;
const ANIMALS = array('dog', 'cat', 'bird');
echo ANIMALS[1]; // imprime "cat"
// A partir do PHP 7
define('ANIMALS', array(
'dog',
'cat',
'bird'
));
echo ANIMALS[1]; // imprime "cat"
?>
Expressões ¶
Expressões são as peças de construção mais importantes do PHP. No PHP, quase
tudo o que você escreve são expressões. A maneira mais simples e ainda mais
precisa de definir uma expressão é "tudo o que tem um valor".
As formas mais básicas de expressões são constantes e variáveis. Quando você digita
"$a = 5", você está atribuindo '5' dentro de $a. '5' obviamente tem o valor 5, ou em
outras palavras '5' é uma expressão com o valor de 5 (nesse caso '5' é uma constante
inteira).
Depois desta atribuição, você pode esperar que o valor de $a seja 5 também, assim
se você escrever $b = $a, você pode esperar que $b se comporte da mesma forma
que se você escrevesse $b = 5. Em outras palavras, $a é uma expressão com valor 5
também. Se tudo funcionou bem isto é exatamente o que acontecerá.
Exemplos ligeiramente mais complexos para expressões são as funções. Por
exemplo, considere a seguinte função:
<?php
function foo ()
{
return 5;
}
?>
Assumindo que você está familiarizado com o conceito de funções (se não estiver, dê
uma olhada no capítulo sobre functions), você pode assumir que digitar $c = foo() é
essencialmente a mesma coisa que escrever $c = 5, e você está certo. Funções são
expressões com o valor igual ao seu valor de retorno. Como foo() retorna 5, o valor da
expressão 'foo()' é 5. Geralmente, as funções não retornam apenas um valor estático,
mas computam algo.
Claro, valores em PHP não tem que ser inteiros, e muito comumente eles não são. o
PHP suporta quatro tipos de valores escalares: valores integer (inteiros), valores de
ponto flutuante (float), valores string (caracteres) e valores boolean (booleano) (valores
escalares são valores que você não pode partir em peças menores, diferentemente de
matrizes, por exemplo). O PHP também suporta dois tipos compostos (não escalar):
matrizes e objetos. Cada um desses valores podem ser definidos em uma variável ou
retornados de uma função.
O PHP leva as expressões muito além, da mesma maneira que muitas outras
linguagens fazem. O PHP é uma linguagem orientada a expressões, no sentido de que
quase tudo são expressões. Considere o exemplo com o qual já lidamos, '$a = 5'. É
fácil ver que há dois valores envolvidos aqui, o valor da constante inteira '5', e o valor
de $a que está sendo atualizado para 5 também. Mas a verdade é que há um valor
adicional envolvido aqui, e que é o próprio valor da atribuição. A própria atribuição é
avaliada com o valor atribuído, neste caso 5. Na prática, significa que '$a = 5',
independente do que faça, é uma expressão com o valor 5. Portanto, escrever algo
como '$b = ($a = 5)' é como escrever '$a = 5; $b = 5;' (um ponto-e-vírgula marca o fim
do comando). Como atribuições são analisadas da direita para a esquerda, você
também pode escrever '$b = $a = 5'.
Outro bom exemplo de orientação de expressão é o pré e o pós-incremento e
decremento. Usuários de PHP 2 e muitas outras linguagens podem estar
familiarizados com a notação de variable++ e variable--. Este são operadores deincremento e decrimento. Em PHP, como em C, há dois tipos de incremento - pré-
incremento e pós-incremento. Tanto o pré-incremento quanto o pós-incremento,
essencialmente, incrementam as variáveis, e o efeito sobre a variável é idêntico. A
diferença é com o valor da expressão de incremento. O pré-incremento, que é escrito
'++$variable', é avaliado como o valor de incremento (o PHP incrementa a variável
antes de ler seu valor, por isso o nome pré-incremento). O pós-incremento, que é
escrito '$variable++' é avaliado como o valor original da variável, antes de ser
incrementada (o PHP incrementa a variável depois de ler seu valor, por isso o nome
'pós-incremento').
Um tipo muito comum de expressões são expressões de comparação. Estas
expressões avaliam para ser FALSE ou TRUE. O PHP suporta > (maior que), >= (maior
ou igual a), == (igual), != (diferente), < (menor que) and <= (menor ou igual a). A
linguagem também suporta um conjunto de operador de equivalencia estrita: ===
(igual a e do mesmo tipo) and !== (diferente de ou não do mesmo tipo). Estas
expressões são mais comumente usada dentro de execução condicional como
comandos if.
O último exemplo de expressões com que nós vamos lidar aqui são as expressões
combinadas operador-atribuição. Você já sabe que se você quer incrementar $a de 1,
você só precisa escrever '$a++' ou '++$a'. Mas e se você quiser somar mais que um a
ele, por exemplo 3? Você poderia escrever '$a++' várias vezes, mas esta obviamente
não é uma forma muito eficiente ou confortável. Uma prática muito mais comum é
escrever '$a = $a + 3'. '$a + 3' é avaliada como o valor de $a mais 3, e é atribuído de
volta a $a, que resulta em incrementar $aem 3. Em PHP, como em várias outras
linguagens como o C você pode escrever isto de uma forma mais curta, que com o
tempo se torna mais limpa e rápida de se entender. Somar 3 ao valor corrente
de $a pode ser escrito '$a +=3'. Isto significa exatamente "pegue o valor de $a, some 3
a ele, e atribua-o de volta a $a." Além de ser mais curto e mais limpo, isto também
resulta em execução mais rápida. O valor de '$a += 3', como o valor de uma atribuição
regular, é o valor atribuído. Note que NÃO é 3, mas o valor combinado de $a mais 3
(este é o valor que é atribuído a $a). Qualquer operador de dois parâmetros pode ser
usado neste modo operador-atribuição, por exemplo '$a -= 5' (subtrai 5 do valor
de $a), '$b *= 7' (multiplica o valor de $b por 7), etc.
Há mais uma expressão que podem parecer estranha se você não a viu em
outras linguagens, o operador condicional ternário:
<?php
$primeira ? $segunda : $terceira
?>
Se o valor da primeira sub-expressão é verdadeiro (TRUE, não-zero), então a
segunda sub-expressão é avaliada, e este é o resultado da expressão
condicional. Caso contrário, a terceira sub-expressão é avaliada e este é o
valor.
O seguinte exemplo deve ajudá-lo a entender um pouco melhor pré e pós-
incremento e expressões em geral:
<?php
function double($i)
{
return $i*2;
}
$b = $a = 5; /* atribui o valor cinco às variáveis $a e $b */
$c = $a++; /* pós-incremento, atribui o valor original de $a
(5) para $c */
$e = $d = ++$b; /* pré-incremento, atribui o valor incrementado de
$b (6) a $d e $e */
/* neste ponto, tanto $d quanto $e são iguais a 6 */
$f = double($d++); /* atribui o dobro do valor de $d antes
do incremento, 2*6 = 12 a $f */
$g = double(++$e); /* atribui o dobro do valor de $e depois
do incremento, 2*7 = 14 a $g */
$h = $g += 10; /* primeiro, $g é incrementado de 10 e termina com
o
valor 24. o valor da atribuição (24) é
então atribuído a $h, e $h termina com o valor
24 também. */
?>
Algumas expressões podem ser consideradas instruções. Neste caso, uma instrução
na forma 'expr ;' ou seja, uma expressão seguida de um ponto e vírgula. Em '$b = $a =
5;', '$a = 5' é uma expressão válida, mas não é um comando por si só. '$b = $a =
5;' porém é um comando válido.
Uma última coisa que vale mencionar é o valor-verdade de expressões. Em muitos
eventos, principalmente em instruções condicionais e loops, você não está interessado
no valor específico da expressão, mas somente se ela significa TRUE ou FALSE (o PHP
não tem um tipo booleano dedicado). As constantes TRUE e FALSE (insensitivas ao
caso) são seus dois valores booleanos possíveis. As vezes uma expressão é
automaticamente convertida para um booleano. Veja a seção sobre type-casting para
detalhes de como isso é feito.
O PHP fornece uma implementação completa e poderosa de expressões, e a
completa documentação dela vai além do escopo deste manual. Os exemplos acima
devem dar a você uma boa idéia sobre o que são as expressões e como você pode
construir expressões úteis. Através do restante do manual nós
escreveremos expr ou expressao para indicar qualquer expressão PHP válida.
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
Exemplo Nome Resultado
$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.
$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.
$a <=>
$b
Spaceship (nave
espacial)
Um integer menor que, igual a ou maior que zero quando $a é, respectivamente, menor que, igual a ou maior que $b.
Disponível a partir do PHP 7.
Se comparar um número com uma string ou com strings numéricas, cada string
é convertido para um número e então a comparação é realizada
numericamente. Essas regras também se aplicam a instrução switch. As
conversões de tipo não são realizadas quando a comparação utilizada é ===
ou !== por esse tipo de comparação envolver valores e tipos.
<?php
var_dump(0 == "a"); // 0 == 0 -> true
var_dump("1" == "01"); // 1 == 1 -> true
var_dump("10" == "1e1"); // 10 == 10 -> true
var_dump(100 == "1e2"); // 100 == 100 -> true
switch ("a") {
case 0:
echo "0";
break;
case "a": // nunca é alcançado porque "a" já foi combinado com 0
echo "a";
break;
}
?>
<?php
// Integers
echo 1 <=> 1; // 0
echo 1 <=> 2; // -1
echo 2 <=> 1; // 1
// Floats
echo 1.5 <=> 1.5; // 0
echo 1.5 <=> 2.5; // -1
echo 2.5 <=> 1.5; // 1
// Strings
echo "a" <=> "a"; // 0
echo "a" <=> "b"; // -1
echo "b" <=> "a"; // 1
echo "a" <=> "aa"; // -1
echo "zz" <=> "aa"; // 1
// Arrays
echo [] <=> []; // 0
echo [1, 2, 3] <=> [1, 2, 3]; // 0
echo [1, 2, 3] <=> []; // 1
echo [1, 2, 3] <=> [1, 2, 1]; // 1
echo [1, 2, 3] <=> [1, 2, 4]; // -1
// Objects
$a = (object) ["a" => "b"];
$b = (object) ["a" => "b"];
echo $a <=> $b; // 0
$a = (object) ["a" => "b"];
$b = (object) ["a" => "c"];
echo $a <=> $b; // -1
$a = (object) ["a" => "c"];
$b = (object) ["a"=> "b"];
echo $a <=> $b; // 1
// only values are compared
$a = (object) ["a" => "b"];
$b = (object) ["b" => "b"];
echo $a <=> $b; // 1
?>
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, mesma
classe - compara propriedades igual faz arrays (PHP 4), PHP 5 tem sua explicação
string, resource ou number string, resource ou number Transforma strings e resources para 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)
object qualquer object é sempre maior
array qualquer array é sempre maior
Exemplo #1 Comparações de boolean e null
<?php
// Bool e null são sempre comparados como booleanos
var_dump(1 == TRUE); // TRUE - same as (bool)1 == TRUE
var_dump(0 == FALSE); // TRUE - same as (bool)0 == FALSE
var_dump(100 < TRUE); // FALSE - same as (bool)100 < TRUE
var_dump(-10 < FALSE);// FALSE - same as (bool)-10 < FALSE
var_dump(min(-100, -
10, NULL, 10, 100)); // NULL - (bool)NULL < (bool)-100 is FALSE < TRUE
?>
Exemplo #2 Transcrição do padrão de comparação de array
<?php
// Arrays são comparados assim quando utilizando-
se os operadores padrão
function standard_array_compare($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; // uncomparable
} elseif ($val < $op2[$key]) {
return -1;
} elseif ($val > $op2[$key]) {
return 1;
}
}
return 0; // $op1 == $op2
}
?>
Operadores de Incremento/Decremento ¶
O PHP suporta operadores de pré e pós-incremento e decremento no estilo C.
Nota: Os operadores incremento/decremento afetam apenas números e
strings. Arrays, objetos e recursos não são afetados. Decrementar NULL não
gera efeitos, mas incrementar resulta em 1.
Operadores de Incremento/Decremento
Exemplo Nome Efeito
++$a Pré-incremento Incrementa $a em um, e então retorna $a.
$a++ Pós-incremento Retorna $a, e então incrementa $a em um.
--$a Pré-decremento Decrementa $a em um, e então retorna $a.
$a-- Pós-decremento Retorna $a, e então decrementa $a em um.
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 "Deve ser 6: " . $a . "<br />\n";
echo "<h3>Pós-decremento</h3>";
$a = 5;
echo "Deve ser 5: " . $a-- . "<br />\n";
echo "Deve ser 4: " . $a . "<br />\n";
echo "<h3>Pré-decremento</h3>";
$a = 5;
echo "Deve ser 4: " . --$a . "<br />\n";
echo "Deve ser 4: " . $a . "<br />\n";
?>
O PHP segue a convenção Perl quando tratando operações aritmétricas em
variavéis caracter em vez da convenção C. Por exemplo, em Perl$a = 'Z';
$a++; transforma $a em 'AA' enquanto que em C a = 'Z';
a++; transforma a em '[' (valor ASCII de 'Z' é 90, valor ASCII '[' é 91). Note que
variáveis caracter podem ser incrementadas mas não decrementadas e
somente caracteres plain ASCII (a-z e A-Z) são suportados. Incrementar ou
decrementar outros caracteres não tem efeitos, a string original não sendo
modificada.
Exemplo #1 Operações aritmétricas em variáveis caractere
<?php
echo '== Alphabets ==' . PHP_EOL;
$s = 'W';
for ($n=0; $n<6; $n++) {
echo ++$s . PHP_EOL;
}
// Digit characters behave differently
echo '== Digits ==' . PHP_EOL;
$d = 'A8';
for ($n=0; $n<6; $n++) {
echo ++$d . PHP_EOL;
}
$d = 'A08';
for ($n=0; $n<6; $n++) {
echo ++$d . PHP_EOL;
}
?>
O exemplo acima irá imprimir:
== Characters ==
X
Y
Z
AA
AB
AC
== Digits ==
A9
B0
B1
B2
B3
B4
A09
A10
A11
A12
A13
A14
Incrementar ou decrementar booleanos não há efeito.
Operadores Lógicos ¶
Operadores Lógicos
Exemplo Nome Resultado
$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.)
Exemplo #1 Ilustrando operadores lógicos
<?php
// --------------------
// foo() nunca será chamada porque toda a expressão sofre curto circui
to
$a = (false && foo());
$b = (true || foo());
$c = (false and foo());
$d = (true or foo());
// --------------------
// "||" tem maior precedência que "or"
// O resultado da expressão (false || true) é atribuido em $e
// Funciona como: ($e = (false || true))
$e = false || true;
// A constante false é atribuída a $f antes que o "or" ocorra
// Funciona como: (($f = false) or true)
$f = false or true;
var_dump($e, $f);
// --------------------
// "&&" tem maior precedência que "and"
// O resultado da expressão (true && false) é atribuído em $g
// Funciona como: ($g = (true && false))
$g = true && false;
// A constante true é atribuída em $h antes que o "and" ocorra
// Funciona como: (($h = true) and false)
$h = true and false;
var_dump($g, $h);
?>
O exemplo acima irá imprimir algo similar à:
bool(true)
bool(false)
bool(false)
bool(true)
Estruturas de Controle
Introdução ¶
Qualquer script PHP é construído por uma série de instruções. Uma instrução pode
ser uma atribuição, uma chamada de função, um 'loop', uma instrução condicional, ou
mesmo uma instrução que não faz nada (um comando vazio). Instruções geralmente
terminam com um ponto e vírgula. Além disso, as instruções podem ser agrupados em
um grupo de comandos através do encapsulamento de um grupo de comandos com
chaves. Um grupo de comandos é uma instrução também. Os vários tipos de
instruções são descritos neste capítulo.
if ¶
(PHP 4, PHP 5, PHP 7)
O construtor if é um dos recursos mais importantes em muitas linguagens,
inclusive no PHP. Permite a execução condicional de fragmentos de código. O
PHP apresenta uma estrutura if semelhante a do C:
if (expr)
statement
Como descrito na seção sobre expressões, expressões são avaliadas por seus valores
Booleanos. Se uma expressão for avaliada como TRUE, o PHP executará a declaração,
e se avaliá-la como FALSE - ignorá-la. Mais informações sobre quais valores são
avaliados como FALSE pode ser encontrada na seção 'Conversão para booleano' .
O exemplo a seguir exibirá a is bigger than b se $a for maior que $b:
<?php
if ($a > $b)
echo "a is bigger than b";
?>
Muitas vezes deseja-se que mais de uma declaração seja condicionalmente
executada. É claro que não énecessário envolver cada declaração em uma
cláusula if. Em vez disso, pode-se agrupar várias declarações em grupos. Por
exemplo, este código exibirá a is bigger than b se $a for maior que $b, e
atribuirá o valor de $a em $b:
<?php
if ($a > $b) {
echo "a is bigger than b";
$b = $a;
}
?>
A declaração If pode ser aninhada indefinidamente dentro de outras declarações if,
fornecendo completa flexibilidade para execução condicional de várias partes do
programa.
else ¶
(PHP 4, PHP 5, PHP 7)
Muitas vezes deseja-se executar uma instrução se uma certa condição for
válida, e uma instrução diferente se a mesma condição não for válida. Para
isso que o else serve. O else estende a instrução if para executar outras caso a
expressão no if retornar FALSE. Por exemplo, o código a seguir exibirá a is
greater than b se $a for maior que $b, e a is NOT greater than b caso contrário:
<?php
if ($a > $b) {
echo "a is greater than b";
} else {
echo "a is NOT greater than b";
}
?>
A instrução else só é executada se a expressão de avaliação do if for avaliada
como FALSE, e se tiver qualquer expressão elseif - somente se também
retornarem FALSE (veja elseif).
elseif/else if ¶
(PHP 4, PHP 5, PHP 7)
elseif, como o nome sugere, é uma combinação do if e else. Como o else,
estende um if para executar instruções diferentes no caso da
expressão if original ser avaliada como FALSE. Entretanto, diferentemente
do else, executará uma expressão alternativa somente se a expressão
condicional do elseif for avaliada como TRUE. Por exemplo, o código a seguir
exibirá a is bigger than b, a equal to b ou a is smaller than b:
<?php
if ($a > $b) {
echo "a is bigger than b";
} elseif ($a == $b) {
echo "a is equal to b";
} else {
echo "a is smaller than b";
}
?>
Pode haver vários elseifs dentro da mesma declaração if. A primeira
expressão elseif (se houver) que retornar TRUE será executada. No PHP, pode-se
escrever 'else if' (em duas palavras), e o comportamento será idêntico ao do 'elseif'
(em uma única palavra). O significado sintático é um pouco diferente (se você está
familiarizado com C, o comportamento é o mesmo), mas, no fundo, ambos terão
exatamente o mesmo comportamento.
O elseif só é executado se o if precedente ou qualquer elseif for avaliado como FALSE,
e o elseif corrente for avaliado como TRUE.
Nota: Note que o elseif e else if só serão considerados exatamente iguais se
usados com chaves como no exemplo abaixo. Ao utilizar os dois pontos (:) para
definir as condições de if/elseif, não deve-se separar else if em duas palavras,
ou o PHP falhará com um erro de interpretação.
<?php
/* Incorrect Method: */
if($a > $b):
echo $a." is greater than ".$b;
else if($a == $b): // Will not compile.
echo "The above line causes a parse error.";
endif;
/* Correct Method: */
if($a > $b):
echo $a." is greater than ".$b;
elseif($a == $b): // Note the combination of the words.
echo $a." equals ".$b;
else:
echo $a." is neither greater than or equal to ".$b;
endif;
?>
while ¶
(PHP 4, PHP 5, PHP 7)
Laços while são os mais simples tipos de laços do PHP. Possui comportamento
semelhante ao C. O formato básico de uma declaração while é:
while (expr)
statement
O propósito da declaração while é simples. Ele dirá ao PHP para executar as
declarações aninhadas repetidamente, enquanto a expressão do while forem
avaliadas como TRUE. O valor da expressão é checado a cada vez que o laço é
iniciado, então, mesmo seu valor mude durante a a execução das declarações
aninhadas, a execução não será interrompida até o final da iteração ( cada vez que o
PHP executa as declarações dentro do laço é uma iteração). Entretanto, se a
expressão do while for avaliada como FALSE desde o início, as declarações aninhadas
não serão executadas nenhuma vez.
Similar a declaração if, pode-se agrupar múltiplas declarações no mesmo
laço while delimitando o grupo de declarações por chaves, ou utilizando a
sintaxe alternativa:
while (expr):
statement
...
endwhile;
Os exemplos a seguir são idênticos, e ambos imprimem os números de 1 a 10.
do-while ¶
(PHP 4, PHP 5, PHP 7)
Os laços do-while é muito similar aos laços while, com exceção que a expressão de
avaliação é verificada ao final de cada iteração em vez de no começo. A maior
diferença para o laço while é que a primeira iteração do laço do-while sempre é
executada (a expressão de avaliação é executada somente no final da iteração),
considerando que no laço while não é necessariamente executada (a expressão de
avaliação é executada no começo de cada iteração, se avaliada como FALSE logo no
começo, a execução do laço será abortada imediatamente).
Só há uma sintaxe para o laço do-while:
<?php
$i = 0;
do {
echo $i;
} while ($i > 0);
?>
O laço acima será executado somente uma vez, pois após a primeira iteração, quando
a expressão de avaliação for executada, resultará emFALSE ($i não é maior que 0) e a
execução do laço será encerrada.
Usuário avançados de C devem estar familiarizados com um uso diferente do
laço do-while, que permite parar a execução no meio do bloco de códigos,
encapsulando-os em um do-while (0), e usando o break . O código a seguir
demonstra isso:
<?php
do {
if ($i < 5) {
echo "i is not big enough";
break;
}
$i *= $factor;
if ($i < $minimum_limit) {
break;
}
echo "i is ok";
/* process i */
} while (0);
?>
for ¶
(PHP 4, PHP 5, PHP 7)
Os laços for são os mais complexo no PHP. Possui comportamento
semelhante ao C. A sintaxe do laço for é:
for (expr1; expr2; expr3)
statement
A primeira expressão (expr1) é avaliada (executada), uma vez, incondicionalmente,
no início do laço.
No começo de cada iteração a expr2 é avaliada. Se a avaliada como TRUE, o laço
continuará e as instruções aninhada serão executadas. Se avaliada como FALSE, a
execução do laço terminará.
No final de cada iteração, a expr3 é avaliada (executada).
Cada uma das expressões podem ser vazias ou conter múltiplas expressões
separadas por vírgulas. Na expr2, todas as expressões separadas por vírgula são
avaliadas mas o resultado é obtido da última parte. Se a expr2 estiver vazia significa
que o laço deve ser executado indefinidamente (O PHP considera implicitamente
como TRUE, igual ao C). Isto não é inútil como se imagina, pois muitas vezes deseja-se
interromper o laço utilizando a instrução break ao invés de usar a expressão verdade
do for.
Analise os seguintes exemplos. Todos exibem números de 1 até 10:
<?php
/* exemplo 1 */
for ($i = 1; $i <= 10; $i++) {
echo $i;
}
/* exemplo 2 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++);
?>
É claro que o primeiro exemplo aparenta ser o mais simpático (ou talvez o quarto),
mas pode-se achar que o uso de expressões vazias no laço for, seja vantajoso em
algumas ocasiões.
O PHP também suporta a sintaxe alternativa "dois pontos" para o laço for.
for (expr1; expr2; expr3):
statement
...
endfor;
É comum, para muitos usuários, iterar em arrays como no exemplo abaixo.
<?php
/** Esta é uma array com alguns dados que devem ser modificadoswant to
modify
* durante a execuçao do loop for.
*/
$people = array(
array('name' => 'Kalle', 'salt' => 856412),
array('name' => 'Pierre', 'salt' => 215863)
);
for($i = 0; $i < count($people); ++$i) {
$people[$i]['salt'] = mt_rand(000000, 999999);
}
?>
O código acima pode se tornar lento, pois o tamanho do array será calculado a cada
iteração. Desde que o tamanho nunca mude, o laço pode ser facilmente otimizado
usando uma variável intermediária para armazenar o tamanho ao invés de executar
repetidamente o count():
<?php
$people = array(
array('name' => 'Kalle', 'salt' => 856412),
array('name' => 'Pierre', 'salt' => 215863)
);
for($i = 0, $size = count($people); $i < $size; ++$i) {
$people[$i]['salt'] = mt_rand(000000, 999999);
}
?>
Tratando Formulários ¶
Uma das características mais fortes do PHP é o jeito como ele trata formulários
HTML. O conceito básico que é importante entender é que qualquer elemento
de formulário irá automaticamente ficar disponível para seus scripts PHP. Por
favor leia a seção Variáveis externas do PHPpara mais informações e
exemplos de como usar formulários com PHP. Aqui vai um exemplo de
formulário HTML:
Exemplo #1 Um simples formulário HTML
<form action="action.php" method="post">
<p>Your name: <input type="text" name="name" /></p>
<p>Your age: <input type="text" name="age" /></p>
<p><input type="submit" /></p>
</form>
Não há nada de especial neste formulário. É um formulário HTML comum sem
nenhuma tag especial de qualquer tipo. Quando o usuário preencher este
formulário e clicar no botão enviar, a página action.php é chamada. Neste
arquivo nós teremos algo como isto:
Exemplo #2 Imprimindo dados de nosso formulário
Hi <?php echo htmlspecialchars($_POST['name']); ?>.
You are <?php echo (int)$_POST['age']; ?> years old.
Um exemplo de saída deste script seria:
Hi Joe. You are 22 years old.
Para além de htmlspecialchars() e (int), deve ser óbvio o que o script
faz. htmlspecialchars() transforma caracteres que sejam especiais no HTML na
sua forma codificada, de forma que não seja possível injetar tags HTML ou
JavaScript em sua página. O campo age (idade), por ser um número, podemos
simplesmente converter para um integer que automaticamente eliminará
qualquer caractere estranho. Você também pode fazer o PHP automaticamente
fazer isso utilizando a extensão filter. As
variáveis $_POST['name'] e $_POST['age'] são criadas automaticamente pelo
PHP. Anteriormente utilizamos a superglobal $_SERVER; acima mostramos que
a superglobal $_POST contem todos os dados POST. Perceba como
o method (método) do formulário é POST. Se fosse utilizado o
método GET então os dados do formulário acabariam na superglobal $_GET.
Você também pode utilizar a superglobal $_REQUEST, se não se importar qual a
origem do dado enviado. Ela conterá os dados mesclados de origens GET,
POST e COOKIE.
Você também pode utilizar XForms no PHP, embora se sinta confortável com
os formulários HTML clássicos por um bom tempo. Embora trabalhar com
XForms não seja para iniciantes, você pode se interessar por eles. Há uma
seção com uma rápida introdução sobre manipular dados recebidos de
XForms no manual.Mais conteúdos dessa disciplina
Função Palíndromo em Python- AOLS Administração da Produção e Operações
- MÉTODOS COMPUTACIONAIS
- Mapa Mental - Computação Móvel
- Gabarito Das Autoatividades
- Algoritmo e Lógica de Programação - Avaliação II
- Algoritmo e Lógica de Programação - Avaliação I
- atividade 4 de compiladores
- Atividade da Unidade 4
- ejercicios_python
- Captura de tela 2026-06-08 132447
- import random def gerar_numeros_mega_sena(): """Gera um conjunto de 6 números aleatórios entre 1 e 60 (inclusive).""" return sorted(random.sample(rang
- Em relação ao funcionamento correto do trem de engrenagens, indique a alternativa INCORRETA: Questão 10Escolha uma opção: a. Um dos motivos da necessi
- As câmaras dedais são uma opção às câmaras de ionização. Nesse modelo de câmara de ionização, submete-se a irradiação de um volume considerável de ...
- Levando em consideração as técnicas de limpeza de peças utilizando o método convencional através de uma máquina de lavar, analise as afirmativas a seg
- A integração de IoT em sistemas de gestão de inventário pode transformar a forma como as empresas operam. Qual dos seguintes benefícios é mais dire...
- Quais estratégias são recomendadas para a implementação efetiva de um currículo escolar que atenda às necessidades de aprendizagem dos estudantes? Que
- Em relação às características e à aplicação de elementos de fixação nas bielas, indique a alternativa INCORRETA: Questão 1Escolha uma opção: A. Não há
- Os silicones são ativos amplamente utilizados em condicionadores devido à sua capacidade de criar uma película protetora sobre o fio, proporcionando b
- Analise a situação a seguir: Qual o valor mais adequado em um memorando de entendimentos? A rede de postos de gasolinas RB Postos de Combustíveis...
- Com relação ao cliclo de inteligência competitiva. Marque a alternativa INCORRETA. O componente de planejamento busca definir metas de coletas de info
- Observe o diagrama abaixo: De acordo com as informações contidas nesse diagrama, conclui-se que a única afirmação correta é: a) Os comentaristas qu...
- Qual característica distingue a capacidade de conexão de internet de um Data Center em comparação com uma residência comum? Questão 8Resposta a. A exi
- Qual dos princípios a seguir é fundamental para a estrutura de conectividade de um Data Center? Questão 6Resposta a. Contratação de links de diferente
- Questoes_de_Operacoes_Basicas_21
- Questoes_de_Operacoes_Basicas_20
