Php todas as variáveis. Variáveis ​​em PHP

Variáveis ​​Phpé um tipo de recipiente de informações que pode conter vários tipos de dados (texto, números, matrizes e assim por diante). Em geral, as variáveis ​​permitem que você crie, armazene, modifique e, no futuro, acesse rapidamente as informações nelas especificadas.

Como criar uma variável em PHP

Inicialmente, as variáveis ​​contêm o sinal $ (dólar) - designação do uso de uma variável, depois letras Alfabeto latino(de a a z e pequeno e grande), no final pode conter números... Além disso, o nome pode usar um sublinhado (não no final).

Como as variáveis ​​podem ser nomeadas:

$ var
$ variável
$ year1945
$ _variable
Como as variáveis ​​não podem ser chamadas:

$ 1 - consiste apenas em um dígito
$ 1var - você não pode iniciar um nome de variável com um dígito
$ / var - apenas sublinhados são permitidos com caracteres adicionais _
$ variable - Cirílico permitido pela documentação php, mas não recomendado
$ var iable - espaços não podem ser usados

Cada variável recebe um valor. Para atribuir um valor, use o sinal = (é igual a). Durante o processamento do script, o valor da variável pode mudar repetidamente dependendo de diferentes condições.

$ city = "Moscou"; // a variável $ city foi atribuída a um valor de string (entre aspas) Moscou
$ ano = 1147; // e a variável $ year recebeu o valor numérico 1147
?>

$ name = "Alexander";
$ Name = "Alexey";
echo "$ name, $ Name"; // exibe "Alexander, Alexey"
?>

Saída de Variável PHP

Separadamente, você deve considerar como exibir variáveis ​​usando operadores de saída, cujo trabalho discutimos na última lição, Criando uma página PHP. Operadores de saída. ... Abaixo estão alguns exemplos ilustrativos com comentários.

// É assim que atribuímos valores às variáveis
$ name1 = "Alexey";
$ name2 = "Alexander";

// Exibir variáveis
echo $ name2; // Resultado: Alexander
echo "nome1 é $ nome1"; // name1 é Alexey

// Ao usar aspas simples, a saída é
// nome da variável, não valor
echo "nome1 é $ nome1"; // imprime: nome1 é $ nome1

// você pode apenas exibir os valores das variáveis
echo $ name1; // Alexey
echo $ name1, $ name2; // Alexey Alexander
echo $ name1. "". $ name2; // Alexey Alexander
echo "$ name1, $ name2"; // Alexey, Alexander

Eco<<Isso usa a sintaxe "here document" para a saída
múltiplas linhas com substituição de $ variável.
FIM;

Operações de Variável PHP

Operações aritméticas em PHP
No caso de valores numéricos, você pode realizar operações aritméticas: adição, subtração, multiplicação e assim por diante.

- $ a(negação) Mude o sinal de $ a.
$ a + $ b(adição) A soma de $ a e $ b.
$ a - $ b(subtração) Diferença entre $ a e $ b.
$ a * $ b(multiplicação) O produto de $ a e $ b.
$ a / $ b(divisão) O quociente de $ a dividido por $ b.
$ a% $ b(divisão do módulo) O resto inteiro de $ a dividido por $ b.
Vejamos exemplos

$ a = 2; // observe, no caso de números, as aspas não são usadas
$ b = 3; // observe, no caso de números, as aspas não são usadas

$ resultado = $ a + $ b; // adicionar variáveis
echo $ result; // imprimirá 5

$ resultado = $ b - $ a; // adicionar variáveis
echo $ result; // produzirá 1

Operações de incremento e decremento em PHP
Essas operações serão úteis principalmente na construção de loops, sobre os quais falaremos um pouco mais tarde.
Prefixo- operadores escritos ANTES da variável ( - $ a; ++ $ a) Retorna o valor da variável antes da alteração.
Postfix- operadores escritos após a variável ( $ a--; $ a--) Retorna o valor modificado da variável.
Incremento- aumentando o valor.
Decrementar- diminuindo o valor.

++ $ a Incremento do prefixo. Incrementa $ a em um e retorna $ a.
$ a ++ Incremento Postfix. Retorna o valor de $ a e, a seguir, incrementa $ a em um.
- $ a Diminuição do prefixo. Diminui $ a em um e retorna o valor de $ a.
$ a-- Diminuição do Postfix. Retorna o valor de $ a e, a seguir, diminui $ a em um.
echo "

Incremento Postfix

";
$ a = 5;
echo "Deve ser 5:". $ a ++. "\ n";

Eco "

Incremento de prefixo

";
$ a = 5;
echo "Deve ser 6:". ++ $ a. "\ n";
echo "Deve ser 6:". $ a. "\ n";

Eco "

Diminuição do Postfix

";
$ a = 5;
echo "Deve ser 5:". $ a--. "\ n";

Eco "

Diminuição do prefixo

";
$ a = 5;
echo "Deve ser 4:". - $ a. "\ n";
echo "Deve ser 4:". $ a. "\ n";
?>

Operações de atribuição de PHP
Operador básico parece = ... À primeira vista, pode parecer que esse operador é igual. Na verdade, não é esse o caso. Na verdade, o operador de atribuição significa que o operando esquerdo é definido com o valor da expressão direita, (ou seja, definido pelo valor resultante). Operadores combinados- são operadores que permitem usar os valores anteriores das variáveis ​​para operações subsequentes (anexar a uma variável de string (com texto) ou adicionar valores numéricos).

$ a = ($ b = 2) + 4; // resultado: $ a é definido como 6, $ b é definido como 2.

$ a = 2;
$ a + = 3; // define $ a para 5, semelhante à escrita: $ a = $ a + 3;
$ b = "Olá";
$ b. = "Paz!"; // define $ b como "Hello World!", assim como $ b = $ b. "Lá!";

Há também operações de comparação e quebra-cabeças, mas falaremos sobre eles nas próximas lições. Vou tentar não assustá-lo com uma grande quantidade de informações imediatamente!)

Esta lição explora o escopo das variáveis ​​PHP. Explica a diferença entre escopos locais e globais, mostra como acessar variáveis ​​globais dentro de uma função, como trabalhar com superglobais e como criar variáveis ​​estáticas.

Quando você começa a aprender PHP e a trabalhar com funções e objetos, o escopo das variáveis ​​é um pouco confuso. Felizmente, as regras do PHP a esse respeito são muito fáceis de entender (em comparação com outras linguagens de programação).

Qual é o escopo?

O escopo da variável é o contexto dentro do qual uma variável foi definida e onde ela pode ser acessada. PHP tem dois escopos de variáveis:

  • O global- as variáveis ​​podem ser acessadas em qualquer lugar no script
  • Local- as variáveis ​​só podem ser acessadas dentro da função em que foram definidas

O escopo da variável, e especialmente o escopo local, torna muito mais fácil gerenciar seu código. Se todas as variáveis ​​fossem globais, elas poderiam ser alteradas em qualquer lugar no script. Isso levaria ao caos e a grandes scripts, já que muitas vezes diferentes partes do script usam variáveis ​​com o mesmo nome. Ao definir o escopo do contexto local, você define os limites do código que podem acessar a variável, tornando o código mais robusto, modular e mais fácil de depurar.

As variáveis ​​com escopo global são chamadas de globais e as variáveis ​​com escopo local são chamadas de locais.

Aqui está um exemplo de como as variáveis ​​globais e locais funcionam.

";) sayHello (); echo" Valor \ $ globalName: "$ globalName"
"; echo" Valor \ $ localName: "$ localName"
"; ?>

Olá Harry! Valor de $ GlobalName: "Zoe" Valor de $ localName: ""

Neste script, criamos duas variáveis:

  • $ globalName- isto é um global variável
  • $ localName- isto é local uma variável que é criada dentro da função sayHello ().

Depois de criar a variável e a função, o script chama sayHello (), que retorna "Hello Harry!" ... O script então tenta ecoar os valores das duas variáveis. Aqui está o que está acontecendo:

  • Porque $ globalName foi criado fora da função, está disponível em qualquer lugar no script, portanto, "Zoya" é exibido.
  • $ localName só estará disponível dentro da função sayHello (). Como a expressão echo está fora da função, o PHP não permite acesso à variável local. Em vez disso, o PHP assume que o código criará uma nova variável chamada $ localName, que receberá um valor padrão de uma string vazia. é por isso que a segunda chamada para echo imprime o valor "" para a variável $ localName.

Acessando variáveis ​​globais dentro de uma função

Para acessar uma variável global fora de função apenas escreva o nome dela. Mas para acessar a variável global função interna, você deve primeiro declarar a variável como global na função usando a palavra-chave global:

Função myFunction () (global $ globalVariable; // Acesso à variável global $ globalVariable)

Caso contrário, o PHP assume que você está criando ou usando uma variável local.

Aqui está um script de exemplo que usa uma variável global dentro de uma função:

"; global $ globalName; echo" Olá $ globalName!
";) diga olá ();?>

Quando executado, o script produzirá:

Olá Harry! Oi Zoya!

A função sayHello () usa a palavra-chave global para declarar a variável $ globalName como global. Em seguida, ela pode acessar a variável e exibir seu valor ("Zoya").

O que são superglobais?

O PHP possui um conjunto especial de matrizes globais predefinidas que contêm várias informações. Essas matrizes são chamadas superglobais, uma vez que eles podem ser acessados ​​de qualquer lugar no script, incluindo o espaço interno da função, e não precisam ser definidos com a palavra-chave global.

Aqui está uma lista de superglobais disponíveis no PHP 5.3:

  • $ GLOBALS - lista de todas as variáveis ​​globais no script (excluindo superglobais)
  • $ _GET - contém uma lista de todos os campos do formulário enviados pelo navegador usando uma solicitação GET
  • $ _POST - contém uma lista de todos os campos do formulário enviados pelo navegador usando uma solicitação POST
  • $ _COOKIE - contém uma lista de todos os cookies enviados pelo navegador
  • $ _REQUEST - contém todas as combinações de chave / valor contidas nas matrizes $ _GET, $ _POST, $ _COOKIE
  • $ _FILES - contém uma lista de todos os arquivos carregados pelo navegador
  • $ _SESSION - permite que você armazene e use variáveis ​​de sessão para o navegador atual
  • $ _SERVER - contém informações sobre o servidor, como o nome do arquivo do script que está sendo executado e o endereço IP do navegador.
  • $ _ENV - Contém uma lista de variáveis ​​de ambiente passadas para o PHP, por exemplo, variáveis ​​CGI.
Por exemplo, você pode usar $ _GET para obter os valores das variáveis ​​incluídas na string de URL da solicitação de script e exibi-los na página:

Se você executar o script acima com a string de URL http://www.example.com/script.php?yourName=Fred, a saída será:

Oi Fred!

Um aviso! Em um script real, você nunca deve usar essa transferência de dados devido à falta de segurança. Você deve sempre verificar ou filtrar seus dados.

A superglobal $ GLOBALS é muito conveniente de usar porque permite organizar o acesso a variáveis ​​globais em uma função sem a necessidade de usar a palavra-chave global. Por exemplo:

";) sayHello (); // Imprime" Olá, Zoe! "?>

Variáveis ​​estáticas: elas estão em algum lugar próximo

Quando você cria uma variável local dentro de uma função, ela só existe enquanto a função está em execução. Quando a função termina, a variável local desaparece. Quando a função é chamada novamente, uma nova variável local é criada.

Isso funciona muito bem na maioria dos casos. Desta forma, as funções são independentes e funcionam sempre da mesma forma todas as vezes que são chamadas.

No entanto, existem situações em que seria conveniente criar uma variável local que "lembra" seu valor entre as chamadas de função. Essa variável é chamada de estática.

Para criar uma variável estática em uma função, você deve usar a palavra-chave static na frente do nome da variável e certificar-se de dar a ela um valor inicial. Por exemplo:

Função myFunction () (static $ myVariable = 0;)

Vamos considerar uma situação em que é conveniente usar uma variável estática. Digamos que você crie uma função que, quando chamada, cria um widget e exibe o número de widgets já criados. Você pode tentar escrever um código como este usando uma variável local:


"; echo createWidget ()." já criamos.
"; echo createWidget ()." já criamos.>
"; ?>

Mas, como a variável $ numWidgets é criada toda vez que a função é chamada, obteremos o seguinte resultado:

Criamos alguns widgets ... 1 já criamos. 1 já criamos. 1 já criamos.

Mas, usando uma variável estática, podemos armazenar o valor de uma chamada de função para a próxima:

"; echo createWidget ()." já criamos.
"; echo createWidget ()." já criamos.
"; echo createWidget ()."> já criamos.
"; ?>

Agora, o script produzirá a saída esperada:

Criamos alguns widgets ... 1 já criamos. 2 já criamos. 3 já criamos.

Embora uma variável estática retenha seu valor entre as chamadas de função, ela só é válida no momento em que o script é executado. Assim que o script termina sua execução, todas as variáveis ​​estáticas são destruídas, assim como as variáveis ​​locais e globais.

Isso é tudo! Verifique a documentação do PHP com freqüência.

As variáveis ​​de ambiente (ambiente) no Windows contêm várias informações sobre as configurações do sistema e o ambiente do usuário. Distinguir entre variáveis ​​de ambiente de usuário, sistema e processo.

A maneira mais fácil de visualizar o conteúdo das variáveis ​​de ambiente no Windows é abrir as propriedades do sistema ( sysdm.cpl) -> Avançado -> Variáveis ​​de ambiente. Como você pode ver, na seção aberta existem duas seções: a superior contém as variáveis ​​de ambiente do usuário, a inferior contém as do sistema.

Além disso, as variáveis ​​de ambiente são armazenadas no registro do sistema. Variáveis ​​personalizadas são armazenadas na seção. Sistema - em HKLM \ SYSTEM \ CurrentControlSet \ Control \ Session Manager \ Environment.

Você pode exibir os valores de todas as variáveis ​​de ambiente na linha de comando do Windows. O comando é simples:

O comando listará as variáveis ​​de ambiente e seus valores.

No PowerShell, você pode usar o comando para exibir todas as variáveis ​​de ambiente:

Se você deseja exibir o valor de apenas uma variável, você precisa usar o comando echo, e o nome da variável deve ser colocado entre sinais de porcentagem. Por exemplo,

Echo% systemroot%

set> c: \ tmp \ env_var.txt

Variáveis ​​de ambiente de um processo específico podem ser obtidas usando um Utilitários do Process Explorer(de Sysinternals). Basta abrir as propriedades do processo e acessar a aba Ambiente.

13 anos atrás

Uma pequena pegadinha a observar:

Se você desativar RegisterGlobals e related e usar get_defined_vars (), poderá ver algo como o seguinte:

Variedade
[GLOBALS] => Matriz
[GLOBALS] => Matriz
* RECURSÃO *
[_POST] => Matriz ()
[_GET] => Matriz ()
[_COOKIE] => Matriz ()
[_FILES] => Matriz ()
)

[_POST] => Matriz ()
[_GET] => Matriz ()
[_COOKIE] => Matriz ()
[_FILES] => Matriz ()

)
?>

Observe que $ _SERVER não está lá. Parece que o php só carrega o $ _SERVER superglobal se ele for usado em algum lugar. Você pode fazer isso:

imprimir " 

". htmlspecialchars (print_r (get_defined_vars (), true))."
" ;
imprimir " 
". htmlspecialchars (print_r ($ _SERVER, true))."
" ;
?>

E então $ _SERVER aparecerá em ambas as listas. Eu acho que não é realmente um pegadinho, porque nada de ruim vai acontecer de qualquer maneira, mas é uma curiosidade interessante, no entanto.

6 anos atrás

Uma vez que get_defined_vars () só obtém as variáveis ​​no ponto em que você chama a função, há uma maneira simples de obter as variáveis ​​definidas no escopo atual.

// O topo do seu script php
$ vars = get_defined_vars ();

// Agora faça suas coisas
$ foo = "foo";
$ bar = "bar";

// Pega todas as variáveis ​​definidas no escopo atual
$ vars = array_diff (get_defined_vars (), $ vars);

echo " 

"
;
print_r ($ vars); 
echo "
" ;
?>

15 anos atrás

Aqui está uma função que gera um relatório de depuração para exibição ou e-mail
usando get_defined_vars. Ótimo para obter um instantâneo detalhado sem
contando com a entrada do usuário.

function generateDebugReport ($ method, $ defined_vars, $ email = "undefined") (
// Função para criar um relatório de depuração para exibir ou enviar por e-mail.
// Uso: generateDebugReport (método, get_defined_vars (), email);
// Onde o método é "navegador" ou "e-mail".

// Cria uma lista de ignorados para as chaves retornadas por "get_defined_vars".
// Por exemplo, HTTP_POST_VARS, HTTP_GET_VARS e outros são
// redundante (igual a _POST, _GET)
// Também inclui vars que você deseja ignorar por motivos de segurança - ou seja, PHPSESSID.
$ ignorelist = array ("HTTP_POST_VARS", "HTTP_GET_VARS",
"HTTP_COOKIE_VARS", "HTTP_SERVER_VARS",
"HTTP_ENV_VARS", "HTTP_SESSION_VARS",
"_ENV", "PHPSESSID", "SESS_DBUSER",
"SESS_DBPASS", "HTTP_COOKIE");

$ timestamp = date ("m / d / y h: m: s");
$ message = "Relatório de depuração criado $ timestamp \ n";

// Obtenha o último erro de SQL para uma boa medida, onde $ link é o identificador de recurso
// para mysql_connect. Comente ou modifique seu banco de dados ou configuração de abstração.
global $ link;
$ sql_error = mysql_error ($ link);
if ($ sql_error) (
$ message. = "\ nMensagens do Myql: \ n". mysql_error ($ link);
}
// Fim do MySQL

// Pode usar uma função recursiva aqui. Você entendeu a ideia ;-)
foreach ($ defined_vars as $ key => $ val) (
if (is_array ($ val) &&! in_array ($ key, $ ignorelist) && count ($ val)> 0) (
$ mensagem. = "\ n $ matriz de chave (chave = valor): \ n";
foreach ($ val as $ subkey => $ subval) (
if (! in_array ($ subkey, $ ignorelist) &&! is_array ($ subval)) (
$ mensagem. = $ subchave. "=". $ subval. "\ n";
}
elseif (! in_array ($ subkey, $ ignorelist) && is_array ($ subval)) (
foreach ($ subval as $ subsubkey => $ subsubval) (
if (! in_array ($ subsubkey, $ ignorelist)) (
$ message. = $ subsubkey. "=". $ subsubval. "\ n" ;
}
}
}
}
}
elseif (! is_array ($ val) &&! in_array ($ key, $ ignorelist) && $ val) (
$ message. = "\ nVariable". $ chave. "=". $ val. "\ n";
}
}

If ($ method == "browser") (
echo nl2br ($ mensagem);
}
elseif ($ method == "email") (
if ($ email == "undefined") (
$ email = $ _SERVER ["SERVER_ADMIN"];
}

$ mresult = mail ($ email, "Relatório de depuração para". $ _ENV ["HOSTNAME"]. "", $ message);
if ($ mresult == 1) (
eco "Relatório de depuração enviado com sucesso. \ N";
}
outro (
eco "Falha ao enviar relatório de depuração. \ N";
}
}
}
?>

17 anos atrás

Rotina simples para converter um objeto get_defined_vars em XML.

function obj2xml ($ v, $ indent = "") (
while (list ($ key, $ val) = each ($ v)) (
if ($ key == "__attr") continue;
// Verifique se há __attr
if (is_object ($ val -> __attr)) (
while (list ($ key2, $ val2) = each ($ val -> __attr)) (
$ attr. = "$ key2 = \" $ val2 \ "";
}
}
else $ attr = "";
if (is_array ($ val) || is_object ($ val)) (
print ("$ indent< $key$attr >\ n ");
obj2xml ($ val, $ indent. "");
print ("$ indent\ n ");
}
else print ("$ indent< $key$attr >$ val\ n ");
}
}

// Objeto de exemplo
$ x -> nome -> primeiro = "John";
$ x -> nome -> último = "Smith";
$ x -> arr ["Fruta"] = "Banana";
$ x -> arr ["Veg"] = "Cenoura";
$ y -> cliente = $ x;
$ y -> cliente -> __attr -> id = "176C4";

$ z = get_defined_vars ();
obj2xml ($ z ["y"]);
?>
irá produzir:


João
Smith


Bannana
Cenoura

11 anos atrás

Como uma observação, get_defined_vars () não retorna um conjunto de referências de variáveis ​​(como eu esperava). Por exemplo:

// define uma variável
$ my_var = "foo";

// obtenha nossa lista de variáveis ​​definidas
$ defined_vars = get_defined_vars ();

// agora tente mudar o valor através do array retornado
$ defined_vars ["my_var"] = "bar";

echo $ my_var, "\ n";

?>

irá imprimir "foo" (o valor original). Seria bom se get_defined_vars () tivesse um argumento opcional para torná-los referências, mas imagino que seja uma solicitação bastante especializada. Você pode fazer isso sozinho (de forma menos conveniente) com algo como:

$ defined_vars = array ();
$ var_names = array_keys (get_defined_vars ());

foreach ($ var_names as $ var_name)
{
$ defined_vars [$ var_name] = & $ $ var_name;
}

?>

1 ano atrás

Eu postei aqui antes sobre "isso" estar em get_defined_vars.

Acontece que nem sempre está lá, mas em certos casos aparecerá inexplicavelmente.

Php -r "
classe Teste (
função pública a () (var_dump (array_keys (get_defined_vars ())); $ a = 123;)
função pública b () (var_dump (array_keys (get_defined_vars ())); $ this;)
}
$ t = novo Teste ();
$ t-> a ();
$ t-> b ();
"

Variedade ()
array ("este")

Isso não acontece no PHP 7.2, mas acontecerá no PHP 5.6.

1 ano atrás

Alguns comentários aqui apontam que esta função não retornará referências. No entanto, os nomes de retorno e os nomes são "referências".

Eu não recomendaria as sugestões aqui que o convertem em referências.

Função pública x ($ a, $ b, $ c) (
foreach (array_keys (get_defined_vars ()) as $ key)
if ($ key! == "this")
$ this-> y ($ ($ key));
}

Função pública y (& $ input) (
$ input ++;
}

Em vez de $ (), você também pode usar $$.

Eu fiz algumas coisas malucas no meu tempo para criar um código extremamente genérico, mas nunca tive que fazer nada como o acima. Pode até não funcionar (mas deveria, já que não é diferente de $ a [$ key]).

Você também poderia fazer $$ key ++, mas eu nunca vi um código como aquele que não fosse terrivelmente ruim (usar dinâmico onde dinâmico não é benéfico).

Se você estiver fazendo algo assim, faça um exame mais minucioso.

ARTIGOS SEMELHANTES