Aplicativos em PHP/Referências/PHP/PHP1

Origem: Wikilivros, livros abertos por um mundo aberto.
Saltar para a navegação Saltar para a pesquisa

Índice

ALERTA - PHP4 chegando ao fim da linha

Alerta para que quem ainda não migrou para o PHP 5 inicie sua migração:

Depois de 3 anos de PHP5 e com o PHP 6 chegando, a versão 4 será descontinuada a partir do ano que vem. Bugs críticos ainda serão corridos até o final de agosto de 2008.

Enviado por Marcos Alexandre Lemos Rodrigues para o br-linux (marcosalexandre·rodriguesΘgmail·com)

Notícia original em ingles:


PHP 4 end of life announcement [13-Jul-2007]

Today it is exactly three years ago since PHP 5 has been released. In those three years it has seen many improvements over PHP 4. PHP 5 is fast, stable & production-ready and as PHP 6 is on the way, PHP 4 will be discontinued.

The PHP development team hereby announces that support for PHP 4 will continue until the end of this year only. After 2007-12-31 there will be no more releases of PHP 4.4. We will continue to make critical security fixes available on a case-by-case basis until 2008-08-08. Please use the rest of this year to make your application suitable to run on PHP 5.

For documentation on migration for PHP 4 to PHP 5, we would like to point you to our migration guide. There is additional information available in the PHP 5.0 to PHP 5.1 and PHP 5.1 to PHP 5.2 migration guides as well.

Documentos para ajudar na migração:

Migration Guide - http://www.php.net/manual/en/migration5.php Também - http://www.php.net/manual/en/migration51.php e http://www.php.net/manual/en/migration52.php


Este texto teve como principal fonte de informações o manual oficial do PHP em http://www.php.net/manual/pt_BR/

- INTRODUÇÃO

O Que é PHP?

É uma linguagem de script, Open Source, de uso geral, no lado do servidor, embutível no HTML e especialmente voltada para o desenvolvimento Web. Originalmente chamou-se PHP (Personal Home Page) mas depois teve seu nome alterado pela comunidade para PHP: Hypertext Processor, um acrônimo recursivo.

Um pequneno script em PHP

<?php
echo "Script em PHP!";
?>


Popularidade do PHP

O PHP atualmente deve ser a linguagem web mais usada no planeta.

Segundo estatísticas do site:

http://www.drews.cx/2006/03/23/php-usage-stats-go-up-again/

Onde cita as 4 mais populares linguagens: C, C++, Java e PHP. Nesta ordem.

Observação: todas oriundas do C.

Na prática, entre as linguagens Web o PHP fica em segundo lugar. Acontece que Java é não somente uma linguagem mas uma plataforma, contando com recursos para desktop, microedition, etc. Já PHP tem o uso restrito praticamente à Web.

Veja a lista geral:

http://www.tiobe.com/index.htm?tiobe_index

Em março/2006 ele já está presente em mais de 20 milhões de domínios ao redor do planeta (http://www.php.net/usage.php).


Estatísticas sobre o PHP

http://www.nexen.net/chiffres_cles/phpversion/php_statistics_for_april_2006.php


História do PHP

- Criado em 1995 por Rasmus Lerdorf, na forma de scripts Perl para coletar estatísticas online de seu currículo. Com um interpretador em C e comunicação com SGBDs.

- Versão 2 aparece em novembro de 1997, quando recebe seu nome inicial e é enriquecido com um interpretador de formulários (FI) - PHP/FI. Teve seu código fonte disponibilizado para a comunidade. Contava com 50.000 domínios que o utilizavam (em torno de 1% dos existentes na época).

- Versão 3 sai em seguida, logo em julho de 1998. Similar ao PHP atual, esta versão foi totalmente reescrita por Andi Gutmans e Zeev Suraski, programadores israelenses. Inicia o suporte à orientação a objetos e a sua extensibilidade, que atraiu muitos programadores. Rebatizado de PHP: Hypertext Processor. Já estava presente em 10% dos servidores web da Internet.

- Versão 4 sai em maio de 2000. Melhora de performance, suporte a muitos servidores web, a session, entre outros. Já está presente em 20% dos domínios da Internet.

- Versão 5 sai em julho de 2004. Seu foco principal é a orientação a objetos, que corrije deficiências e traz novos e amplos recursos para a orientação a objetos.


Delimitadores do PHP

Para que o interpretador reconheça quando tem que interpretar o script em PHP e quando não, usa-se delimitadores para que quando os encontre ele interprete corretamente. Quando ele encontra o delimitador <?php ele começa a processar como PHP e quando encontra ?> ele pára de processar e tudo o mais envia para o browser como está. Existem outros tipos de delimitadores do PHP mas estes <?php ... ?> são os recomendados, por serem os mais abrangentes e terem suporte inclusive a XML.


Grandes Forças do PHP

- Sua simplicitade é muito importante para o programador que se inicia no PHP.

- Seus recursos atendem ao programador experiente.

- Sua documentação rica em conteúdo e exemplos facilita a solução de problemas, além da busca online.

- O suporte de maneira simples à maioria dos SGBDs do mercado atende às necessidades de sites dinâmicos com acesso a bancos de dados.


O Que é Possível Realizar em PHP?

- Em sendo uma linguagem de uso geral, podemos realizar praticamente qualquer atividade realizada com outra linguagem. Ele roda no lado servidor, como aplicação Web e também roda no lado cliente, com o PHP-GTK.

- Existem edições para os principais sistemas operacionais (Linux, BSDs, Windows, Mac OS X, etc).

- Suportado pela maioria dos servidores Web, especialmente pelo Apache.

- Bom suporte à orientação a objetos, em especial com a chegada da versão 5.

- Comunicação com Java.

- Suporte aos principais SGBDs do mercado (MySQL, PostgreSQL, Oracle, SQL Server, etc), atualmente são mais de vinte os suportados.

- Suporte a LDAP, IMAP, SNMP, NNTP, POP3, HTTP, COM (em Windows somente), a IRC, compressão (gzip, bz2, rar), PDF, GD, Flash, XML, etc..


- TUTORIAL SIMPLES

Para continuar você deve ter um servidor web instalado e com suporte a PHP e, caso queira usar bancos de dados, instale um SGBD.

Os arquivos em PHP somente funcionam corretamente no navegador, se estivem no diretório reconhecido pelo servidor web, que é o DocumentRoot. Considerando que o PHP e Apache tenham sido instalados com o Xampp e que o diretório web seja o default, este fica em:

C:\Arquivos de Programas\Xampp\htdocs

Além disso qualquer script que contenha algo em PHP deve ter a extensão .php para que seja corretamente processado pelo Apache.

Criar um arquivo chamado olamundo.php na pasta C:\Arquivos de Programas\Xampp\htdocs, com o conteúdo:

<?php echo "Olá PHP!"; ?>

Startar o Apache e abrir no browser assim:

http://127.0.0.1/olamundo.php

Visualizar resultado de script PHP no Browser

Após ter executado o olamundo.php no Browser solicite a visualização do código fonte da página exibida.

Veja que nada chega de PHP. O PHP é processado no servidor e envia apenas o resultado em HTML para o browser.

Alerta sobre Editores e Processadores de Texto com PHP Para criar scripts PHP evite o uso de processadores de texto e de editores como o Bloco de Notas, pois deixam sujeira no código e dificultam o salvamento do arquivo.

Preferentemente use uma IDE especializada em PHP, que inclusive tem outros recursos úteis, a exemplo do PHPEclipse ou um editor de texto como o freeware Win32pad.


Informações sobre o PHP

Para obter diversas informações úteis sobre o PHP instalado no seu servidor, execute um script com a função:

<?php
    phpinfo();
?>


Checar navegador em uso

if (strstr($_SERVER["HTTP_USER_AGENT"], "MSIE")) {
     echo "Seu navegador é o Internet Explorer!";
} else {
     echo "Seu navegador não é o IE!";
}

strstr - procura substrings.


Teste com echo e print

<?php
// Teste de echo e print
//print "primeiro, ", "segundo"; // Gera erro de parser
echo "primeiro, ", "segundo, ", "terceiro"; //Funciona
// Ou seja, print pode trabalhar apenas com uma string de cada vez e echo com várias
?>


print retorna valor enquanto que echo não retorna.

<?php
$print = print "";
echo "Retorno do print: " . $print;
?>

Agora teste esse:

<?php
    $echo = echo "";
    echo "Retorno do echo: " . $echo;
?>

Irá receber um erro fatal (do parser).


- CONFIGURAÇÕES

php.ini

register_globals = off (por questões de segurança)

No Xampp o php.ini traz register_globals ativo por default.

GD, pgsql, mysql e outras extensões que queira usar deverá descomentar no php.ini, seção Extensions.


httpd.conf

Para poder alterar o diretório web default deverá mudar dois parâmetros no arquivo httpd.conf do Apache:

DocumentRoot "/opt/lampp/htdocs"

<Directory "/opt/lampp/htdocs">


Os diretórios acima são para a edição for Linux do Xampp. Para o Windows observe que o Apache utiliza, não barras, que são utilizadas neste SO, mas sim contra-barras e as vezes contra-barras duplas.


No caso queremos mudar o diretório default para /home/www, então alteramos o httpd.conf para que fique assim:


DocumentRoot "/home/www"

<Directory "/home/www">

No Windows fica assim:

DocumentRoot "c:/Arquivos de Programas/Xampp/htdocs"

<Directory "<c:/Arquivos de Programas/Xampp/htdocs">

Que devem ficar assim:

DocumentRoot "c:/1www"

<Directory "<c:/1www">


Configuração das extensões suportadas. Altere a linha:

DirectoryIndex index.html index.html.var index.php index.php3 index.php4

Veja que acima configurou-se para perceber inclusive arquivos com as extensões .php3 e .php4.

Caso não fossem incluídas, arquivos com extensão .php3 e .php4 não poderiam ser abertos neste servidor.


- Referência da Linguagem

Separador de Instruções

O ponto e vírgula ; é o separador de instruções em PHP (como em Perl e em C).

Sempre que uma instrução terminar devemos digitar um ponto e vírgula (echo "ola"; ).


Comentários

Em PHP podemos usar 3 tipos de comentários (/* ... */, // e #) mas devemos utilizar somente os dois primeiros e o primeiro é o mais eficiente, que é o /* ... */, que veio do C, já que # está em processo de obsolescência. Ou seja, devemos usar // ou /* ... */, de preferência este último.


- Tipos de Dados

O PHP suporta os oito tipos primitivos:

- boolean, integer, float e string (básicos) - array e object (compostos) - resource e NULL (especiais)

float é sinônimo de double em PHP.


Tipo de Variável

O tipo de uma variável em PHP não é controlado pelo programador, depende do valor da variável e é avaliado em tempo de execução. Não é permitido ao programador declarar o tipo de variáveis.


Funções que Retornal o Tipo

gettype

todas as is_type


Casting

(tipo) variavel;


Boleanos

Pode ser TRUE ou FALSE (case-insensitive)


Exemplos

<?php
echo gettype((bool) "")."<br>";        // bool(false)
echo gettype((bool) 1)."<br>";        // bool(true)
echo gettype((bool) -2)."<br>";        // bool(true)
echo gettype((bool) "foo")."<br>";    // bool(true)
echo gettype((bool) 2.3e5)."<br>";    // bool(true)
echo gettype((bool) array(12))."<br>"; // bool(true)
echo gettype((bool) array())."<br>";  // bool(false)
?>

Convertendo Explicitamente para Boleano

Usa-se o modificador (bool) ou (boolean).


Valores que são considerados FALSE

FALSE, 0, 0.0, "0", "", array vazio, objeto sem membros e NULL (e variáveis indefinidas).


Os demais são TRUE


Inteiros

Em PHP, inteiro é um número do conjunto matemático dos Inteiros (Z), que contem os negativos, o zero e os positivos.

Em PHP os inteiros podem ser decimais, octais ou hexadecimais.


octal - precedido por 0.

hexadecimal - precedido por 0x.


Exemplos

<?php
$a =1234;
echo $a."<br>"; // número decimal
$a =-123;
echo $a."<br>"; // um número negativo
$a =0123;
echo $a."<br>"; // número octal (equivalente a 83 em decimal)
$a =0x1A;
echo $a."<br>"; // número hexadecimal (equivalente a 26 em decimal)
?>

O tamanho dos inteiros depende da plataforma e é de 32 bits com sinal. O PHP não suporta inteiros sem sinal.

Overflow - caso seja especificado um número inteiro além dos limites, será interpretado como flutuante.

Convertendo Explicitamente para Inteiro

Usar o modificador (int) ou (integer).

Ou com a função intval().


De boleanos - FALSE será retornado como 0 e TRUE como 1.

De flutuantes - ao converter para inteiros serão truncados

De strings - A string será avaliada como um ponto flutuante se contiver qualquer um dos caracteres '.', 'e', ou 'E'. Em outros casos, ela será avaliada como um inteiro.

De outros tipos - não têm precisão, exatidão, portanto é melhor evitar.


Alerta

echo (int) ((0.1 + 0.7 ) * 10); // Exibirá 7 ao invés do esperado 8


Ponto Flutuante

É o float, double ou real.


Exemplos

1.234 ou 1.2e3 ou 7E-10

<?php
$a = 1.234;
echo $a."<br>";
$b = 1.2e3;
echo $b."<br>";
$c = 7E-4;
echo $c;
?> 

O tamanho de um float depende também da plataforma e é de 64bits no formato IEEE(*).

Nunca compare números em ponto flutuante em igualdades, sob pena de cometer erros.

  • - (Wikipedia - http://pt.wikipedia.org )O Instituto de Engenheiros Eletricistas e Eletrônicos ou IEEE (pronuncia-se I-3-E ) é uma organização profissional sem fins lucrativos, fundada nos Estados Unidos. É a maior (em número de sócios) organização profissional do mundo. O IEEE foi formado em 1963 pela fusão do Instituto de Engenheiros de Rádio (IRA) com o Instituto Americano de Engenheiros Elétricistas (AIEE). O IEEE tem filiais em muitas partes do mundo, sendo seus sócios engenheiros eletricistas, engenheiros da computação, cientistas da computação, profissionais de telecomunicações etc. Sua meta é promover conhecimento no campo da engenharia elétrica, eletrônica e computação. Um de seus papéis mais importantes é o estabelecimento de padrões para formatos de computadores e dispositivos.


Strings

Em PHP um caractere ocupa um byte. Até a versão 5 o PHP não tem suporte a UNICODE, mas está previsto este suporte para a próxima versão (Fonte: Wikipedia - http://www.wikipedia.org).

Não há limite para o tamanho de uma string em PHP.


Especificando Strings

- apóstrofos (chamados de aspas simples ' )

- aspas (chamadas de aspas duplas " )

- heredoc (<<<)


Exemplos

<?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 once said: "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';

echo '<br>------------<br>';

$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;

?>


Nulos em PHP

NULL

O valor especial NULL representa que a variável não tem valor. NULL é o único valor possível do tipo NULL.

A variável é considerada NULL se:

  • ela foi assimilada com a constante NULL.
  • ela ainda não recebeu nenhum valor ainda.
  • ela foi apagada com unset().

Sintaxe

Há apenas um único valor do tipo NULL, e é a palavra (insensitiva ao caso) NULL.

Exemplos de uso:

Usando: empty() is_null() !isset()

$var = "";

empty($var) is true.
is_null($var) is false.
!isset($var) is false.
?>
<?php

//Outro exemplo

  $var = NULL;

  if (isnull("var")) {
    echo "var===NULL\n";
  } else {
    echo "var!==NULL\n";
  }

  if (isnull("test")) { // give FALSE, test is not set
    echo "test===NULL\n";
  } else {
    echo "test!==NULL\n";
  }

  $array['var'] = NULL;

  if (isnull("var", $array)) {
    echo "array['var']===NULL\n";
  } else {
    echo "array['var']!==NULL\n";
  }

  function isnull($var, $base = FALSE) {
    if ($base===FALSE) {
      $base = &$GLOBALS;
    } elseif (!is_array($base)) {
      return FALSE;
    }
    if ((array_key_exists($var, $base))&&($base[$var]===NULL)) {
      return TRUE;
    } else {
      return FALSE;
    }
  }
?>
:: NULL == NULL is true
:: NULL == FALSE is true
:: NULL == TRUE is false


Agora com SQL:

  • NULL AND TRUE yields NULL
  • NULL OR TRUE yields TRUE
  • NULL AND FALSE yields FALSE
  • NULL OR FALSE yields NULL
  • NULL == TRUE yields FALSE
  • NULL == FALSE yields FALSE

is_null

is_null - Informa se a variável é NULL

Descrição

bool is_null ( mixed $var )

Retorna TRUE se var é null, FALSE senão.

Veja o tipo NULL para saber quando a variável é considerada NULL e quando não.

Veja mais em NULL, is_bool(), is_numeric(), is_float(), is_int(), is_string(), is_object(), is_array(), is_integer() e is_real().

unset

unset - Destrói a variável especificada

Descrição

void unset ( mixed $var [, mixed $var [, $...]] )

unset() destrói a variável especificada. Lembrando que no PHP 3, unset() sempre retornará TRUE (atualmente, o valor inteiro 1). No PHP 4, porém, unset() não é uma função verdadeira: agora é um construtor da linguagem. Como tal, nenhum valor é retornado, se tentar pegar o valor de unset() um erro de sintaxe (parse error) irá acontecer.


Exemplo:

<?php
// destrói uma única variável
unset ($foo);

// destrói um único elemento de uma matriz
unset ($bar['quux']);

// destrói mais de uma variável
unset ($foo1, $foo2, $foo3);
?> 

- VARIÁVEIS

Em PHP as variáveis são iniciadas por um sinal de dólar $.


Variáveis Predefinidas

São as que já vêm definidas no próprio PHP. A função phpinfo() mostra também estas variáveis.

Com o PHP 4.2 o valor default da diretiva register_globals passou a ser off. Com isso as variáveis passaram a ser acessadas de forma diferente e muitos scripts deixaram de funcionar quanto tiveram o PHP atualizado e outros novos scripts não funcionaram devido esperar uma semelhante a anteerior.

On                                                              Off

$DOCUMENT_ROOT                                  $_SERVER['DOCUMENT_ROOT'];
$HOME $_ENV['HOME'];
$GLOBALS
$_SERVER
$_GET
$_POST
$_REQUEST
$_SESSION

Obs.: Agora, como o default do PHP é register_globals = Off, faz-se necessário usar $_POST['nomecampo'], para receber o valor de um campo de form em script PHP.


Escopo de Variáveis

O escopo de uma variável é o contexto onde ela foi definida e geralmente o escopo é local.

$a = 1;
include ("teste.php");

// $a estará disponível, será vista por teste.php, pois foi definida antes. 

include ("teste.php");
$a = 1;

// Aqui, como $a foi definida após a inclusão, não será visto pelo teste.php


Escopo de variáveis em funções

A palavra-chave global pode preceder uma variável para tornar seu escopo global, como também $GLOBALS[].


Exemplos:

<?php
$a = 1; /* escopo global */

function Teste(){
   echo $a; /* referencia uma variável do escopo local (não definida) */
}

Teste();
?>

<?php
$a = 1; /* escopo global */

function Teste(){
    global $a;
    echo $a; /* referencia a variável do escopo global */
}

Teste();
?>


Usando $GLOBALS no lugar de global

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

function Soma(){
   $GLOBALS["b"] = $GLOBALS["a"] + $GLOBALS["b"];
}

Soma();
echo $b;
?>


Utilizando Variáveis Estáticas

Variáveis estáticas guardam o valor de variáveis entre execuções de funções.

Ao fechar o programa, ao fechar ou atualizar o browser, o valor da variável se perde.


Exemplos

<?php
function Teste (){
   $a = 0;
   echo $a;
   $a++;
}

for ($x=1;$x<10;$x++){
    Teste();
}
echo "<br><br>";

function Teste2(){
   static $a = 0;
   echo $a;
   $a++;
}

for ($x=1;$x<10;$x++){
    Teste2();
}

echo "<br><br>";

// Função recursiva
function Teste3()
{
   static $count = 0;

   $count++;
   echo $count;
   if ($count < 10) {
       Teste3 ();
   }
   $count--;
}

for ($x=1;$x<5;$x++){
    Teste3();
    if ($x < 4) echo " - ";

}

echo "<br><br>";
//Declarando variáveis static

function foo(){
   static $int = 0;          // correro
   //static $int = 1+2;        // errado (é uma expressão)
   //static $int = sqrt(121);  // wrong  (é uma expressão também)

   $int++;
   echo $int;
}

foo();
 
?>


Variáveis Variáveis

São variáveis cujos nomes podem ser criados dinamicamente.

Variável comun -> $variavel;

Variável variável -> $$variavelvariavel;


Ela torna o valor de uma variável e o trata como se fosse o nome de uma variável.

Obs.: variáveis variáveis não podem ser utilizadas com os arrays superglobais.


Determiando o Tipo das Variáveis

gettype

is_array, is_float, is_int, is_object, is_string, is_numeric


- Constantes

O valor de uma constante não pode ser alterado durante a execução do script.

Convenciona-se usar o nome de constantes com todas as letras em maiúsculas.

define ("NOME", "valor");


Exemplos

<?php
// Nomes de constantes válidos
define("FOO",    "alguma coisa");
define("FOO2",    "alguma outra coisa");
define("FOO_BAR", "mais alguma outra coisa")

// Nomes de constantes inválidas
define("2FOO",    "alguma coisa");

// Isto é válido, mas deve ser evitado:
// O PHP pode vir a fornercer uma constante mágica
// que danificará seu script
define("__FOO__", "alguma coisa");

?> 


Obs.: Somente dados escalares (bolean, integer, float, e string) podem ser armazanados nos valores de constantes.

A função constant() retorna o valor de uma constante.

A função get_defined_constantes() retorna todas as constantes definidas.

Enquanto que defined() checa se uma constante foi definida.

define (NOME, valor);
define ("PESO", 70);
print "O peso vale " . PESO . " KG";

<?php
switch (PHP_OS){
    case "WIN32":
        echo "Sistema Windows";
        break;
    case "Linux":
        echo "Sistema Linux";
        break;
    case "OS/2":
        echo "Sistema OS/2";
        break;
    default:
        echo "Sistema não é Windows, Linux nem OS/2";
        break;
}
?>

<?php
if (strtoupper(substr(PHP_OS, 0, 3)) === 'WIN') {
    echo 'Este é um servidor usando Windows!';
} else {
    echo 'Este é um servidor que não usa Windows!';
}
?>


Constantes Mágicas

Essas são as cinco constantes "mágicas", que mudam dependendo de onde elas são utilizadas. Por exemplo, o valor de __LINE__ depende do número da linha em que é utilizada em seu script. Essas constantes especiais são insensíveis ao caso:


Algumas constantes "mágicas" do PHP

Nome Descrição

__LINE__ A linha atual do script. __FILE__ O caminho completo e nome do arquivo. Se utilizado dentro de um include, o nome do arquivo incluído será retornado. __FUNCTION__ O nome da função (Acrescentado no PHP 4.3.0). A partir do PHP 5 esta constante retorna o nome da função como ela foi declarada (sensível a maiúsculas e minúsculas). No PHP 4 sempre retorna o nome em minúsculas. __CLASS__ O nome da classe (Acrescentado no PHP 4.3.0). A partir do PHP 5 esta constante retorna o nome da função como ela foi declarada (sensível a maiúsculas e minúsculas). No PHP 4 sempre retorna o nome em minúsculas. __METHOD__ O nome do método de classe. (Acrescentado no PHP 5.0.0). O nome do método é retornado como foi declarado (sensível a maiúsculas e minúsculas).


Veja também get_class(), get_object_vars(), file_exists(), e function_exists().


- EXPRESSÕES

Uma expressão é qualquer coisa que tem um valor, normalmente na forma de constantes ou variáveis.

$a = 5;


Temos acima uma equação formada por duas expressões, a da esquerda composta por uma variável e a da direita composta por uma constante.

Funções são expressões cujo valor é igual ao seu valor de retorno.

O PHP é uma linguagem orientada as expressões.

Atribuições são analisadas da direita para a esquerda.


$b = $a = 5; // $a recebe 5 e então $b recebe 5


Exemplo

<?php
function dobro($i){
   return $i*2;
}
$b = $a = 5;echo $b."<br>";        /* atribui o valor cinco às variáveis $a e $b */
$c = $a++;echo $c."<br>";          /* pós-incremento, atribui o valor original de $a
                       (5) para $c */
$e = $d = ++$b;echo $e."<br>";    /* 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 = dobro($d++);echo $f."<br>";  /* atribui o dobro do valor de $d antes
                       do incremento, 2*6 = 12 a $f */
$g = dobro(++$e);echo $g."<br>";  /* atribui o dobro do valor de $e depois
                       do incremento, 2*7 = 14 a $g */
$h = $g += 10;echo $h."<br>";      /* primeiro, $g é incrementado de 10 e termina com o
                       valor 24. o valor da atribuição (24) é
                       então atribuído a $h, e $h termina com o valor
                       24 também. */
?>


- Operadores

Um operador é algo que alimentado com um ou mais valores devolve outro valor. Assim as funções e outros construtores que retornam valor são operadores.


Tipos de Operadores

- unários - operam apenas em um valor (!, ++, ...)

- binários - operam em dois valores (+, - , ...)

- ternário - selecionar entre 2 valores, dependendo de um terceiro. Emglobá-los entre parênteses facilita o entendimento.


Precedência de Operadores

A precedência de um operador em relação a outro diz que um operador deve ser executado antes do outro.

Exemplo

1 + 5 * 3


Dependendo da precedência dos operadores + ou * teremos resultados diferentes. Se o operador + tiver precedência superior ao * então resolveremos assim:

Somamos 1 + 5 e somente depois multiplicamos por 3 -> (1+5)*3 = 6*3 = 18

Este resultado está incorreto, pois o operador * tem precedência superior ao + e deveria ser assim:

1+(5*3) = 1+15=16


Para facilitar a percepção das precedências usa-se parêntesis

1 + (5 * 3) = Sempre devemos resolver antes o que estiver entre parêntesis.

1 + 15 = 16 (Neste caso fica mais claro).


Veja a tabela contendo a precedência de dos operadores do PHP, da maior precedência para a menor:

  • e / têm precedência sobre + e -.

Obs.: Para uma relação completa das precedências veja o manual oficial no site do PHP.


Operadores Aritméticos

São os operadores correspondentes às quatro operações comuns da matemática adicionados ao operador módulo:

• soma (+) • subtração (-) • multiplicação (*) • divisão (/) • módulo (%)

O módulo é o resto de um número dividido por outro.


Exemplos de operadores aritméticos

$a = 9;
$b = 4;
echo "\$a + \$b = ".($a + $b); // 13
echo "\$a + \$b = ".$a + $b; // Retorna 4, pois após o ponto é considerado strings
echo "\$a - \$b = ".($a - $b); // 5
echo "\$a * \$b = ".$a * $b; // 36
echo "\$a / \$b = ".$a / $b; // 2.25 - Divisão Quociente de $a por $b.
echo "\$a % \$b = ".$a % $b; // 1 - Resto de $a por $b


Operadores de Atribuição

O operador básico de atribuição é o sinal de igualdade =.


Exemplo

$x = $y + 3; // O que representa: 3 será adicionado a $y e o resultado será atribuído a $x
$a = 3;
$a += 5; // Que é semelhante a $a = $a + 5;
$b = "Bom ";
$b .= "Dia!"; // Similar a $b = $b . "Dia!";


Exemplos

<?php
$a = 3;
$a += 5; // $a recebe 5 e soma com seus 3, tipo: $a = $a + 5;
echo "\$a vale " . $a;

$b = "Bom ";
$b .= "Dia!"; // $b fica com "Bom Dia!", como em $b = $b . "Dia!";
echo "\$b vale " . $b;

$c=2;
$a -= $c;    //$a = $a - $c    Subtração
echo "\$a -= \$c vale " . $a;
$a *= $c;    //$a = $a * $c    Multiplicação
echo "\$a *= \$c vale " . $a;
$a /= $c;    //$a = $a / $c    Divisão
echo "\$a /= \$c vale " . $a;
$resto = $a % $c;    //$a = $a % $c    Módulo (resto)
echo "Resto de $a % $c vale: " . $resto;
?>


Operadores de Controle de Erro

Representado pelo símbolo de arroba @. Quando precede uma expressão ele abafa as mensagens de erro.

Observação - Somente funciona em expressões, ou seja, em qualquer construção que retorne algo.

Recomendação - Deixar todas as mensagens de erro originais do PHP livres em ambientes de desenvolvimento (de testes). Somente utilizar @ em ambiente de produção, após executar os testes.


Exemplos

<?php
/* Erro intencional */
$a = 6;
$b = 0;

echo "Camuflando erro de divisão por zero";
$c = @($a / $b);
?>


Operadores de Execução

Existem algumas funções de execução de programas (shell_exec e outras) como também existe um operador, que é formado por dois sinais de crase` `.

Nota: Caso safe_mode esteja desativado no php.ini como também shell_exec() então o operador de execução também fica dasativado.


Exemplo

<?php
// Em PHP a crase ` é um operador de execução de arquivos do SO
// Como em scripts bash

// Exibir todos os arquivos do diretório atual, inclusive os ocultos
if (PHP_OS == "WINNT"){

    $output = `dir/o/p`;
    echo "<pre>$output

";

} elseif (PHP_OS == "Linux){

   $output = `ls -la`;

echo "

$output

";

}else{

   echo "Você está usando um SO diferente de Linux e de Windows!"

} ?>


Operadores de Incremento e de Decremento

Os operadores de pré e pós-incremento/decremento são suportados pelo PHP.

++$a (pré-incremento) - Primeiro incrementa $a de 1, depois retorna $a incrementado
$a++ (pós-incremento) - Primeiro retorna $a, depois incrementa $a de 1
--$a (pré-decremento) - Primeiro decrementa $a de 1, depois retorna $a decrementado
$a-- (pós-decremento) - Primeiro retorna $a, depois decrementa $a de 1


Exemplos:

<?php
echo "<h3>Pós-incremento</h3>";
$a = 5;
echo "\$a = ".$a."<br><br>";
echo "\$a++ deve ser: " . $a++ . "<br />\n";
echo "\$a deve ser: " . $a . "<br />\n";

echo "<h3>Pré-incremento</h3>";
$a = 5;
echo "++\$a deve ser: " . ++$a . "<br />\n";
echo "\$a deve ser: " . $a . "<br />\n";

echo "<h3>Pós-decremento</h3>";
$a = 5;
echo "\$a-- deve ser: " . $a-- . "<br />\n";
echo "\$a deve ser: " . $a . "<br />\n";

echo "<h3>Pré-decremento</h3>";
$a = 5;
echo "--\$a deve ser: " . --$a . "<br />\n";
echo "\$a deve ser: " . $a . "<br />\n";
?>


Operadores Lógicos

Utilizados para comparar duas expressões e o resultado será TRUE ou FALSE.


Exemplos:

<?php
$a = true; $b = FALSE; // true e false são insensitivos

echo ($a and $b)? "T<br>":"F<br>";    //E    Verdadeiro (TRUE) se tanto $a quanto $b são verdadeiros.
echo ($a or $b)? "T<br>":"F<br>";    //OU    Verdadeiro se $a ou $b são verdadeiros.
echo ($a xor $b)? "T<br>":"F<br>";    //XOR    Verdadeiro se $a ou $b são verdadeiros, mas não ambos.
echo (! $a)? "T<br>":"F<br>";        //NÃO    Verdadeiro se $a não é verdadeiro.
echo ($a && $b)? "T<br>":"F<br>";    //E    Verdadeiro se tanto $a quanto $b são verdadeiros.
echo ($a || $b)? "T<br>":"F<br>";    //OU    Verdadeiro se $a ou $b são verdadeiros.
?>


Operadores de String

Strings em PHP são concatenadas com o operador ponto final ".".


Exemplos:

<?php
$a = "Olá ";
$b = $a . "mundo do PHP!";
echo $b;

$a = "Olá ";
$a .= "meu mundo!";

echo "<br>" . $a;
?>


Convertendo strings em números

<?php
$foo = 1 + "10.5";echo $foo."<br>";             // $foo é float (11.5)
$foo = 1 + "-1.3e3";echo $foo."<br>";              // $foo é float (-1299)
$foo = 1 + "bob-1.3e3";echo $foo."<br>";          // $foo é integer (1)
$foo = 1 + "bob3";echo $foo."<br>";                // $foo é integer (1)
$foo = 1 + "10 Small Pigs";echo $foo."<br>";      // $foo é integer (11)
$foo = 4 + "10.2 Little Piggies";echo $foo."<br>"; // $foo é float (14.2)
$foo = "10.0 pigs " + 1;echo $foo."<br>";          // $foo é float (11)
$foo = "10.0 pigs " + 1.0;echo $foo."<br>";        // $foo é float (11)
?>


Operações com Strings

<?php
// Pega o primeiro caracter da string
$str = 'Isto é um teste.';
$first = $str{0};
echo $first."<br>";
// Pega o terceiro caracter da string
$third = $str{2};
echo $third."<br>";
// Pega o último caracter da string
$str = 'Isto ainda é um teste.';
$last = $str{strlen($str)-1};
echo $last."<br>";
// Modifica o ultimo caracter da string
$str = 'Olhe o mal';
echo $str{strlen($str)-1} = 'r';
?>


Operadores com Arrays

Exemplo Nome Resultado

$a + $b União União de $a e $b.

$a == $b Igualdade TRUE se $a e $b tem os mesmos elementos.

$a === $b Identidade TRUE se $a e $b tem os mesmos elementos na mesma ordem.

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


O operador + acrescenta o array da direita no array da esquerda, contudo, chaves duplicadas NÃO são sobrescritas.


Exemplos:

<?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);
?>

Observar que na união de $a+$b o valor de "b" é banana em $a, ele não foi sobrescrito por framboesa de $b.

Assim como framboesa "b" em $b não foi substituído por banana de $a na união de $b+$a.