Pseudo-tipos e variáveis utilizadas nesta documentação

Pseudo-tipos são palavras-chave usadas na documentação do PHP para especificar os tipos ou valores que um parâmetro pode ter. Observe que eles não são primitivos da linguagem PHP. Portanto, você não pode usar pseudo-tipos como dicas de tipo em suas próprias funções personalizadas.

mixed

mixed indica que um parâmetro pode aceitar vários (mas não necessariamente todos) os tipos.

, por exemplo, aceita todos os tipos do PHP, enquanto que a função aceita somente strings e arrays.

number

number indica que um parâmetro pode ser tanto um integer ou float.

callback

O pseudo-tipo callback era utilizado nesta documentação antes da introdução da declaração de tipo pelo PHP 5.4. Isso significa exatamente o mesmo.

array|object

array|object indica que o parâmetro pode ser tanto array quanto object.

void

void no tipo de retorno indica que não há valor a ser retornado. void na lista de parâmetros indica que a função não aceita parâmetros.

...

$... no protótipo de uma função significa e assim por diante. Este nome de variável é utilizado quando a função suporta um número infinito de argumentos.

Manipulação de tipos

O PHP não obriga (ou suporta) a definição de tipo explícita na declaração de variáveis: o tipo de uma variável é determinado pelo contexto em que a variável é utilizada. Isto significa que, atribuir um valor string a variável $var, fará $var se tornar uma string. Se um valor integer for atribuído a $var, ela se torna um integer.

Um exemplo de conversão automática do PHP é o operador de multiplicação '*'. Se qualquer um dos operandos for float, todos os operadores serão avaliados como float, e o resultado será um float. De outra forma, se os operadores forem interpretados como integers, o resultado será um integer. Note que isso não muda os tipos dos operadores: apenas muda como esses operadores são avaliados e qual o tipo da expressão.

<?php
$foo = "1";  // $foo é string (ASCII 49)
$foo *= 2;   // $foo é agora um inteiro (2)
$foo = $foo * 1.3;  // $foo é agora um float (2.6)
$foo = 5 * "10 pequenos porcos"; // $foo é  um inteiro (50)
$foo = 5 * "10 minúsculos porcos";     // $foo é um inteiro (50)
?>

Se os últimos dois exemplos lhe parecerem estranhos, veja a .

Para forçar uma variável ser avaliada como um certo tipo, veja a seção . Se desejar mudar o tipo de uma variável, veja a função .

Para testar qualquer um dos exemplo desta seção, você pode usar a função .

Nota:

O comportamento de uma conversão automática para array é atualmente indefinida.

O PHP também suporta indexação em strings via índice usando a mesma sintaxe de array, o seguinte exemplo é válido para todas versões do PHP:

<?php
$a    = 'car'; // $a é uma string
$a[0] = 'b';   // $a é ainda uma string
echo $a;       // bar
?>

Veja a seção intitulada para mais informações.

Conversão de Tipos

A conversão de tipos no PHP funciona como no C: o nome de um tipo desejado é escrito entre parênteses antes da variável que se deseja converter.

<?php
$foo = 10;             // $foo é um inteiro
$bar = (boolean) $foo; // $bar é um booleano
?>

As conversões permitidas são:

  • (int), (integer) - molde para inteiro
  • (bool), (boolean) - converte para booleano
  • (float), (double), (real) - converte para número de ponto flutuante
  • (string) - converte para string
  • (array) - converte para array
  • (object) - converte para objeto
  • (unset) - converte para NULL

(binary) e o prefixo b foram adicionados no PHP 5.2.1. Note que (binary) é essencialmente o mesmo que (string), mas não deve ser invocado

Conversão (unset) está depreciada a partir do PHP 7.2.0. Note que (unset) é o mesmo que atribuir NULL a variável ou chamada. Conversão (unset) será removida a partir do PHP 8.0.0.

Note que tabulações e espaços são permitidos dentro dos parênteses, então o seguinte são funcionalmente equivalentes:

<?php
$foo = (int) $bar;
$foo = ( int ) $bar;
?>

Convertendo strings literais e variáveis para strings binárias:

<?php
$binary = (binary)$string;
$binary = b"binary string";
?>

Nota:

Em vez de converter uma variável para string, pode-se também englobar a variável entre aspas duplas.

<?php
$foo = 10;            // $foo é um interio
$str = "$foo";        // $str é uma string
$fst = (string) $foo; // $fst tambem é uma string

// Isto imprimirah "eles são o mesmo"
if ($fst === $str) {
    echo "eles são o mesmo";
}
?>

Pode não ser tão óbvio o que ocorre exatamente quando se converte entre certos tipos. Para mais informações, veja essas seções:

Variáveis

Índice

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 .

Para informação sobre funções relacionadas a variáveis, veja a .

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

O PHP também oferece um outro meio de atribuir valores a variáveis: . 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 ), 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 para 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 => "def")
var_dump($unset_arr);

// Uso de objeto; cria novo objeto stdClass (veja http://www.php.net/manual/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 com habilitada. Erros de nível 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 pode ser usado para detectar se uma variável não foi inicializada.

Variáveis Pré-definidas

O PHP oferece um grande número de variáveis pré-definidas para qualquer script que execute. Muitas destas variáveis, entretanto, não podem ser completamente documentadas pois dependem do servidor que está sendo executado, a versão e configuração deste servidor e outros fatores. Algumas destas variáveis não estarão disponíveis quando o PHP for executado em . Para uma lista destas variáveis, por favor, veja a seção .

Aviso

No PHP 4.2.0 e versões posteriores, o valor padrão da diretiva é off. Esta é a maior modificação no PHP. Ter register_globals off afeta o conjunto de variáveis pré-definidas disponíveis no escopo global. Por exemplo, para obter a variável DOCUMENT_ROOT você usará em vez de $DOCUMENT_ROOT, ou da URL http://www.example.com/test.php?id=3 em vez de $id, ou em vez de $HOME.

Para informações relacionadas a esta modificação, leia o registro da configuração , no capítulo de segurança em , assim como os anúncios de lançamento das versões e .

Utilizar as Variáveis Reservadas Pré-definidas do PHP, como os , é preferível.

Desde a versão 4.1.0, o PHP fornece um conjunto adicional de arrays predefinidos contendo as variáveis do servidor web (se aplicável), variáveis de ambiente e as entradas do usuário. Esses novos arrays são especiais por serem automaticamente globais--significando que estão disponíveis automaticamente em qualquer escopo. Por esta razão, também são conhecidos como "superglobais". (Não há um mecanismo no PHP para superglobais definidas pelo usuário) As superglobais são listadas abaixo; entretanto, para a listagem de seu conteúdo e detalhes sobre as variáveis pré-definidas do PHP e sua natureza, veja a seção . Note também, que todas as outras variáveis pré-definidas antigas ($HTTP_*_VARS) ainda existem. A partir do PHP 5.0.0, os grandes podem ser desativadas através da diretiva .

Nota: Variáveis variáveis

Superglobais não podem ser utilizadas como dentro de funções ou métodos de classe.

Nota:

Mesmo que ambas variáveis, suprglobais e HTTP_*_VARS existam ao mesmo tempo; não serão idênticas, então modificar uma não alterará a outra.

Se determinadas variáveis não estiverem definidas na diretiva , seus arrays predefinidos também estarão vazios.

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 definido pelo PHP. O exemplo anterior poderia ser reescrito como:

Exemplo #2 Usando no lugar de global

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

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

Soma();
echo $b;
?>

O array é 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 existe em qualquer escopo, isto porque $GLOBALS é uma . 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 e para variáveis, em termo de . 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 se aplica 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.

Variáveis variáveis

As vezes, é conveniente possuir variáveis com nomes variáveis. Isto é, o nome de uma variável que pode ser definido e utilizado dinamicamente. Uma variável normal é definida com uma instrução como:

<?php
$a = 'hello';
?>

Uma variável variável obtém o valor de uma variável e a trata como o nome de uma variável. No exemplo acima, hello pode ser utilizada como o nome de uma variável utilizando dois sinais de cifrão:

<?php
$$a = "world";
?>

Neste ponto, duas variáveis foram definidas e armazenadas na árvore de símbolos do PHP: $a que contém "hello" e $hello que contém "world". Assim, esta instrução:

<?php
echo "$a ${$a}";
?>

produz a mesma saída que:

<?php
echo "$a $hello";
?>

assim sendo, as duas produzem: hello world.

Para poder utilizar variáveis variáveis com arrays, você precisa resolver um problema de ambiguidade. Isso é, se você escrever $$a[1] o interpretador precisa saber que se deseja utilizar $a[1] como uma variável ou que se deseja usar $$a como uma variável e [1] como o índice dessa variável. A sintaxe para resolver essa ambiguidade é ${$a[1]} para o primeiro caso e ${$a}[1], para o segundo.

Propriedades de classes também podem ser acessadas utilizando-se nomes de propriedades variáveis. O nome de propriedade variável será resolvido dentro do escopo em que a chamada foi feita. Por exemplo, se houver uma expressão como $foo->$bar, o escopo local será examinado procurando por $bar e seu valor será utilizado como o nome da propriedade $foo. Isso também funciona se $bar for um array.

Cuidado

Referenciamento sequencial de propriedades que estão em um array, possuem semânticas diferentes entre PHP 5 e PHP 7. O inclui mais detalhes em como os tipos e expressões foram alterados, e como utilizar colchetes para evitar ambiguidades.

Colchetes também podem ser utilizados para delimitar claramente os nomes de propriedade. São muito úteis ao acessar valores de uma propriedade que contenham um array, quando o nome da propriedade tem várias partes, ou quando o nome da propriedade contém caracteres que não são válidos (por exemplo, em saídas da função ou ).

Exemplo #1 Exemplo de propriedade variável

<?php
class foo {
    var $bar = 'I am bar.';
    var $arr = array('I am A.', 'I am B.', 'I am C.');
    var $r   = 'I am r.';
}

$foo = new foo();
$bar = 'bar';
$baz = array('foo', 'bar', 'baz', 'quux');
echo $foo->$bar . "\n";
echo $foo->{$baz[1]} . "\n";

$start = 'b';
$end   = 'ar';
echo $foo->{$start . $end} . "\n";

$arr = 'arr';
echo $foo->{$arr[1]} . "\n";

?>

O exemplo acima irá imprimir:


I am bar.
I am bar.
I am bar.
I am r.
Aviso

Note que variáveis variáveis não podem ser utilizadas nos dentro de funções ou métodos de classe. A variável $this também é uma variável especial que não pode ser referenciada dinamicamente.

Variáveis de fontes externas

Formulários HTML (GET e POST)

Quando um formulário é submetido para um script PHP, a informação deste formulário estará automaticamente disponível ao script. Há algumas maneiras de acessar estas informações, por exemplo:

Exemplo #1 Um formulário HTML simples 

<form action="foo.php" method="post">
    Nome:  <input type="text" name="username" /><br />
    Email: <input type="text" name="email" /><br />
    <input type="submit" name="submit" value="Me aperte!" />
</form>

A partir do PHP 5.4.0, existem apenas duas formas de acessas dados de formulários PHP. Os métodos disponíveis atualmente são listadas a seguir:

Exemplo #2 Acessando dados de um formulário HTML via POST

<?php
echo $_POST['username'];
echo $_REQUEST['username'];
?>

Há outras formas de acessar dados enviados pelo usuário nas antigas versões do PHP. Elas estão listadas abaixo. Veja a lista de modificações no final da página para mais detalhes.

Exemplo #3 Meios antigos de acessar dados enviados pelo usuário

<?php
// CUIDADO: esses métodos NÃO são mais suportados.
// Os válido estão descritos acima

// Utilizando import_request_variables() - esta função foi removida no PHP 5.4.0
   import_request_variables('p', 'p_');
   echo $p_username;

// Essas variáveis pré-definidas foram removidas no PHP 5.4.0
   echo $HTTP_POST_VARS['username'];

// Utilizando register_globals. Este recurso foi removido no in PHP 5.4.0
   echo $username;
?>

Utilizar um formulário GET é similar, exceto que você usará a variável GET pré-definida. GET também se aplica a superglobal QUERY_STRING (a informação depois do '?' numa URL). Então, por exemplo, http://www.example.com/test.php?id=3 contém os dados GET que estarão acessíveis com . Veja também .

Nota:

Pontos e espaços em nomes de variáveis são convertidos para sublinhados. Por exemplo <input name="a.b" /> se tornará $_REQUEST["a_b"].

O PHP também entende arrays no contexto de variáveis de formulário (veja essa ). Pode-se, por exemplo, agrupar variáveis relacionadas, ou utilizar este recurso para obter valores de um input select múltiplo. Por exemplo, iremos enviar o formulário abaixo para si mesmo, e depois de submetido, mostra os dados:

Exemplo #4 Variáveis de formulários mais complexos

<?php
if ($_POST) {
    echo '<pre>';
    echo htmlspecialchars(print_r($_POST, true));
    echo '</pre>';
}
?>
<form action="" method="post">
    Nome:  <input type="text" name="personal[name]" /><br />
    Email: <input type="text" name="personal[email]" /><br />
    Cerveja: <br />
    <select multiple name="beer[]">
        <option value="antartica">Antartica</option>
        <option value="brahma">Brahma</option>
        <option value="skol">Skol</option>
    </select><br />
    <input type="submit" value="Enviar dados!" />
</form>

Nomes de variáveis SUBMIT IMAGE

Ao submeter um formulário, é possível de utilizar imagens em vez do botão de submit padrão com uma tag do tipo: 

<input type="image" src="image.gif" name="sub" />

Quando o usuário clicar em algum lugar da imagem, o formulário será transmitido para o servidor com duas variáveis adicionais, sub_x and sub_y. Elas contém as coordenadas do clique do usuário na imagem. Os mais experientes percebem que os atuais nomes dessas variáveis enviadas ao navegador contém um ponto ao invés de um sublinhado, mas o PHP converte o ponto para um sublinhado automaticamente.

Cookies HTTP

O PHP suporta transparentemente cookies HTTP como os definidos pela . Cookies são um mecanismo o armazenamento de dados no navegador, rastreando ou identificando o retorno de usuários. Você pode definir cookies com a função . Cookies são parte do cabeçalho HTTP, então a função SetCookie precisa ser chamada antes de qualquer saída ser enviada ao navegador. Esta é a mesma restrição da função . Dados de cookies estão disponíveis nos arrays de dados de cookies apropriados, como e também em . Veja o manual de para mais detalhes e exemplos.

Se você deseja atribuir vários valores para uma única variável do cookie, você pode fazer dele um array:

<?php
  setcookie("MeuCookie[foo]", 'Testando 1', time()+3600);
  setcookie("MeuCookie[bar]", 'Testando 2', time()+3600);
?>

Isso irá criar dois cookies separados enquanto que MeuCookie será um único array em seu script. Se quiser definir apenas um cookie com vários valores, considere utilizar ou nos valores primeiro.

Note que um cookie substituirá um anterior com o mesmo nome em seu navegador, a menos que o nome ou o caminho seja diferente. Então, para uma aplicação de carrinho de compras em que se quer ter um contador e repassá-lo:

Exemplo #5 Exemplo

<?php
if (isset($_COOKIE['count'])) {
    $count = $_COOKIE['count'] + 1;
} else {
    $count = 1;
}
setcookie('count', $count, time()+3600);
setcookie("Cart[$count]", $item, time()+3600);
?>

Pontos em nomes de variáveis postadas

Normalmente o PHP não altera o nome de variáveis quando elas são passadas para o script. Entretanto, é necessário notar que o ponto (ponto final) não é um caractere válido no nomes de variáveis do PHP. Para ilustrar, veja o seguinte exemplo:

<?php
$varname.ext;  /* nome de variável inválido */
?>
Dessa forma, o interpretador entende isso como uma variável nomeada $varname, seguida do operador de concatenação de strings, seguida de uma string crua (uma string não delimitada que não bate com nenhuma palavra-chave ou reservada) 'ext'. Obviamente, isso não tem os resultados pretendidos.

Nessa situação, é importante notar que o PHP substituirá automaticamente qualquer ponto nos nomes de variáveis recebidas por sublinhados.

Determinando o tipo das variáveis

Como o PHP determina os tipos de variáveis e faz conversões (geralmente) quando necessárias, nem sempre é óbvio o tipo de uma variável em todos os momentos. O PHP incluí várias funções que permitem determinar qual o tipo de uma variável, por exemplo: , , , , , e . Veja também o capítulo .

Changelog

Versão Descrição
5.4.0 , e foram removidos
5.3.0 , e estão obsoletos
4.2.0 A diretiva foi padronizada para off.
4.1.0 Os , e estão disponíveis.

Constantes

Índice

Uma constante é um identificador (nome) para um valor único. Como o nome sugere, esse valor não pode mudar durante a execução do script (exceto as , que não são constantes de verdade). As constantes são case-sensitive por padrão. Por convenção, identificadores de constantes são sempre em maiúsculas.

O nome de uma constante tem as mesmas regras de qualquer rótulo do PHP. Um nome válido de constante começa com uma letra ou sublinhado, seguido por qualquer número de letras, números ou sublinhados. Como uma expressão regular, pode ser representada por: ^[a-zA-Z_\x80-\xff][a-zA-Z0-9_\x80-\xff]*$

É permitido utilizar em constantes com, nomes reservados ou mesmo inválidos, cujo valor pode (apenas) ser recuperado com . No entanto, isso não é recomendado.

Dica

Veja também o .

Exemplo #1 Nomes de constantes válidos e inválidos

<?php

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

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

// 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");

?>

Nota: Para nossos exemplos, uma letra é a-z, A-Z e os caracteres ASCII do 128 ao 255 (0x80-0xff).

Como as , o escopo de uma constante é global. Você pode acessar constantes de qualquer lugar em seu script sem se preocupar com o escopo. Para mais informações sobre o escopo no PHP, leia a seção do manual .

Sintaxe

Você pode definir uma constante utilizando a função , ou a palavra-chave const fora da definição de uma classe a partir do PHP 5.3.0. Enquanto 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 para ler o valor de uma constante, se você precisar obter seu valor dinamicamente. Utilize 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 chamando-a como uma string (CONSTANT vs "CONSTANT"). Este comportamento é depreciado a partir do PHP 7.2.0, e um erro de nível E_WARNING é emitido quando isso acontece (antes, um erro de nível era emitido Veja também a referência do manual sobre o porquê é errado (a não ser que bar primeiro seja definida como uma constante). Isto não se aplica a , 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 .

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

  • Constantes não possuem um sinal de cifrão ($) antes delas;
  • Antes do PHP 5.3 as constantes só poderiam ser definidas utilizando a função , e não por simples assimilação;
  • Constantes podem ser definidas e acessadas de qualquer lugar sem que a regras de escopo de variáveis sejam aplicadas;
  • Constantes não podem ser redefinidas ou eliminadas depois de criadas; e
  • 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 função 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"
?>

Nota:

Ao contrário das funções definidas através de , as constantes definidas usando a palavra-chave const devem ser declarados no escopo de maior nível, pois são definidas no tempo de compilação. Isso significa que não podem ser definidas dentro de funções, laços ou instruções ifs ou blocos try/catch.

Nota:

Constantes definidas usando a palavra-chave const sempre serão case-sensitive, enquanto as constantes usando podem ser case-insensitive.

Veja também .

Constantes Mágicas

O PHP fornece um grande número de para qualquer script que execute. A maioria dessas constantes, entretanto, são criadas por várias extensões, e estarão presentes somente quando essas extensões estiverem disponíveis, tanto por carregamento dinâmico quanto por compilação direta.

Há nove constantes mágicas, que mudam dependendo de onde são utilizadas. Por exemplo, o valor de __LINE__ depende da linha em que é utilizada em seu script. Todas essas constantes "mágicas" são resolvidas em tempo de compilação, ao contrário das constantes regulares que são resolvidas em tempo de execução. Essas constantes especiais são case-insentitive e estão descritas a seguir:

Algumas constantes "mágicas" do PHP
Nome Descrição
__LINE__ O número da linha corrente do arquivo.
__FILE__ O caminho completo e nome do arquivo com links simbólicos resolvidos. Se utilizado dentro de um include, o nome do arquivo incluído será retornado.
__DIR__ O diretório do arquivo. Se usado dentro de um include, o diretório do arquivo incluído é retornado. É equivalente a dirname(__FILE__). O nome do diretório não possui barra no final, a não ser que seja o diretório raiz.
__FUNCTION__ O nome da função, or {closure} para funções anônimas.
__CLASS__ O nome da classe. O nome da classe inclui o namespace em que foi declarado (por exemplo, Foo\Bar). Note que a partir do PHP 5.4, __CLASS__ também funcionará em traits. Quando utilizada em um método trait, __CLASS__ é o nome da classe que está utilizando a trait.
__TRAIT__ O nome do trait. O nome do trait inclui o namespace em que foi declarado (por exemplo, Foo\Bar).
__METHOD__ O nome do método da classe.
__NAMESPACE__ O nome do namespace corrente.
NomeDaClasse::class O nome completo da classe. Veja também .

Veja também , , e .

Changelog

Versão Descrição
5.5.0 Adicionada a constante mágica ::class
5.4.0 Adicionada a constante __TRAIT__
5.3.0 Adicionadas as constantes __DIR__ e __NAMESPACE__

Expressões

Expressões são os blocos 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 ele 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 ), 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 . 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 . 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 $a em 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 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

Índice

Um operador é algo que recebe um ou mais valores (ou expressões, no jargão de programação) e que devolve outro valor (e por isso os próprios construtores se tormam expressões).

Operadores podem ser agrupados segundo o número de valores que aceitam. Operadores unários recebem um único valor, por exemplo ! (o ) ou ++ (o ). Operadores binários aceitam dois valores, como os + (soma) e - (subtração), além da maioria dos operadores PHP dessa categoria. Finalmente há um único , ? :, que aceita três valores; normalmente conhecido simplesmente como "o operador ternário" (embora um nome melhor fosse operador condicional).

A lista completa dos operadores no PHP está na seção sobre . Essa seção também explica precedência e combinações, que governam exatamente como expressões contendo vários operadores são avaliados.