Referência - O que esse símbolo significa em PHP?

4479

O que é isso?

Esta é uma coleção de perguntas que surgem de vez em quando sobre sintaxe no PHP. Este também é um Wiki da comunidade, portanto todos são convidados a participar da manutenção desta lista.

Por que é isso?

Costumava ser difícil encontrar perguntas sobre operadores e outros tokens de sintaxe.¹
A idéia principal é ter links para perguntas existentes no Stack Overflow, para que seja mais fácil referenciá-las, não copiar sobre o conteúdo do Manual do PHP.

Nota: Desde janeiro de 2013, o Stack Overflow suporta caracteres especiais . Apenas coloque os termos da pesquisa entre aspas, por exemplo[php] "==" vs "==="

O que devo fazer aqui?

Se você foi indicado aqui por alguém por ter feito essa pergunta, encontre a sintaxe específica abaixo. As páginas vinculadas ao manual do PHP, juntamente com as perguntas vinculadas, provavelmente responderão à sua pergunta. Em caso afirmativo, você é incentivado a votar novamente na resposta. Esta lista não pretende substituir a ajuda fornecida por outras pessoas.

A lista

Se o seu token específico não estiver listado abaixo, você poderá encontrá-lo na Lista de Tokens do Analisador .

& Operadores ou referências bit a bit

=& Referências

&= Operadores bit a bit

&& Operadores lógicos

% Operadores aritméticos

!! Operadores lógicos

@ Operadores de controle de erros

?: Operador ternário

?? Operador de coalescência nula (desde PHP 7)

?string ?int ?array ?bool ?float Declaração de tipo de retorno anulável (desde PHP 7.1)

: Sintaxe alternativa para estruturas de controle , Operador Ternário

:: Operador de resolução de escopo

\ Namespaces

-> Classes e Objetos

=> Matrizes

^ Operadores bit a bit

>> Operadores bit a bit

<< Operadores bit a bit

<<< Heredoc ou Nowdoc

= Operadores de atribuição

== Operadores de comparação

=== Operadores de comparação

!== Operadores de comparação

!= Operadores de comparação

<> Operadores de comparação

<=> Operadores de comparação (desde PHP 7.0)

| Operadores bit a bit

|| Operadores lógicos

~ Operadores bit a bit

+ Operadores aritméticos , operadores de matriz

+=e -= operadores de atribuição

++e -- Incrementando / Decrementando Operadores

.= Operadores de atribuição

. Operadores de string

, Argumentos de Função

, Declarações variáveis

$$ Variáveis ​​Variáveis

` Operador de execução

<?= Tags abertas curtas

[] Matrizes (sintaxe curta desde o PHP 5.4)

<? Tags de abertura e fechamento

... Desempacotamento de argumento (desde PHP 5.6)

** Exponenciação (desde PHP 5.6)

# Comentário de uma linha no estilo de shell

:? Tipos de retorno anuláveis

?-> Chamadas do operador NullSafe

php  arguments  operators  symbols 
— Gordon
fonte
36
Eu sei que isso não é estritamente PHP, mas que tal incluir um link para phpdoc.org para a sintaxe de comentário do phpDocumentor, que é comumente usada e também é impossível procurar /**?
— Mike
8
Posso sugerir colchete e colchete?
— precisa
124
Também me deparei com esse problema (não consegui pesquisar caracteres especiais), e foi por isso que criei o SymbolHound , um mecanismo de pesquisa que não ignora caracteres especiais. Também publiquei no StackApps .
— dncrane
1
Bem, do cabeçalho Por que isso? , Eu acho que é porque "A idéia principal é ter links para perguntas existentes no Stack Overflow, para que seja mais fácil referenciá-las".
— Herbert
3
Uma pergunta foi feita hoje (20/15 de novembro) stackoverflow.com/questions/33833259/what-is-rscat-in-php perguntando "O que é $ rsCat em php" (essa pergunta ainda deve ser tornada visível e não excluída) . Estranhamente, não há uma referência sobre $variável, mas apenas sobre $$variáveis ​​variáveis. Eu acredito que isso deve ser alterado em algum lugar.
— Funk Quarenta Niner

Respostas:

1172

Operadores de incremento / decrescimento

++ operador de incremento

-- operador de decremento

Example    Name              Effect
---------------------------------------------------------------------
++$a       Pre-increment     Increments $a by one, then returns $a.
$a++       Post-increment    Returns $a, then increments $a by one.
--$a       Pre-decrement     Decrements $a by one, then returns $a.
$a--       Post-decrement    Returns $a, then decrements $a by one.

Estes podem ir antes ou depois da variável.

Se colocada antes da variável, a operação de incremento / decremento é feita primeiro para a variável e, em seguida, o resultado é retornado. Se colocada após a variável, a variável será retornada primeiro , e a operação de incremento / decremento será concluída.

Por exemplo:

$apples = 10;
for ($i = 0; $i < 10; ++$i) {
    echo 'I have ' . $apples-- . " apples. I just ate one.\n";
}

Exemplo ao vivo

No caso acima ++$ié usado, pois é mais rápido. $i++teria os mesmos resultados.

O pré-incremento é um pouco mais rápido, porque realmente incrementa a variável e depois 'retorna' o resultado. O pós-incremento cria uma variável especial, copia lá o valor da primeira variável e somente depois que a primeira variável é usada, substitui seu valor por segundos.

No entanto, você deve usar $apples--, pois, primeiro, você deseja exibir o número atual de maçãs e, em seguida, deseja subtrair um número.

Você também pode incrementar letras no PHP:

$i = "a";
while ($i < "c") {
    echo $i++;
}

Uma vez zatingido aaé o próximo, e assim por diante.

Observe que as variáveis ​​de caracteres podem ser incrementadas, mas não decrementadas, e mesmo assim apenas os caracteres ASCII simples (az e AZ) são suportados.

Posts de estouro de pilha:

— Peter Ajtai
fonte
9
+1 para a observação de que os decrementadores não funcionam em caracteres, apenas em números
— Mark Baker
163
Para o bem de todos, remova as informações em negrito de que o pré-incremento é infinitesimalmente mais rápido. Este é o pior exemplo absoluto de otimização prematura e esse tipo de informação não deve estar na cabeça das pessoas se elas estão apenas começando a aprender PHP.
— Lotus Notes
14
@Lotus - considero um fato divertido. Se você é iniciante em PHP, C ++, etc., parece muito estranho que ++ ie i ++ sejam diferentes o suficiente para funcionar em velocidades diferentes. Achei fascinante.
— quer
12
@ Peter Ajtai Sim, é interessante, mas pela maneira como você estruturou sua publicação, parece que ela é um dos principais fatos do PHP que é absolutamente vital para o uso da linguagem.
— Lotus Notes
4
Não tenho certeza se sou apenas eu ou não, mas o exemplo da maçã parece um pouco enganador. 'Eu tenho 10 maçãs. Acabei de comer uma 'me faz acreditar que você tinha 11 maçãs, mas agora você tem 10 porque acabou de comer uma em vez de comer uma depois de dizer que tem 10, fazendo com que você tenha 9 - que é o que o código está implicando.
— precisa
440

Operador bit a bit

O que é um pouco? Um bit é uma representação de 1 ou 0. Basicamente OFF (0) e ON (1)

O que é um byte? Um byte é composto de 8 bits e o valor mais alto de um byte é 255, o que significaria que cada bit está definido. Veremos por que o valor máximo de um byte é 255.

-------------------------------------------
|      1 Byte ( 8 bits )                  |
-------------------------------------------
|Place Value | 128| 64| 32| 16| 8| 4| 2| 1|     
-------------------------------------------

Esta representação de 1 Byte

1 + 2 + 4 + 8 + 16 + 32 + 64 + 128 = 255 (1 Byte)

Alguns exemplos para uma melhor compreensão

O operador "AND": &

$a =  9;
$b = 10;
echo $a & $b;

Isso produziria o número 8. Por que? Bem, vamos ver usando o nosso exemplo de tabela.

-------------------------------------------
|      1 Byte ( 8 bits )                  |
-------------------------------------------
|Place Value | 128| 64| 32| 16| 8| 4| 2| 1|     
-------------------------------------------
|      $a    |   0|  0|  0|  0| 1| 0| 0| 1|    
-------------------------------------------
|      $b    |   0|  0|  0|  0| 1| 0| 1| 0|
------------------------------------------- 
|      &     |   0|  0|  0|  0| 1| 0| 0| 0|
-------------------------------------------

Então você pode ver na tabela o único bit que eles compartilham é o 8 bits.

Segundo exemplo

$a =  36;
$b = 103;
echo $a & $b; // This would output the number 36.
$a = 00100100
$b = 01100111

Os dois bits compartilhados são 32 e 4, que quando somados retornam 36.

O operador "Or": |

$a =  9;
$b = 10;
echo $a | $b;

Isso produziria o número 11. Por que?

-------------------------------------------
|      1 Byte ( 8 bits )                  |
-------------------------------------------
|Place Value | 128| 64| 32| 16| 8| 4| 2| 1|     
-------------------------------------------
|      $a    |   0|  0|  0|  0| 1| 0| 0| 1|    
-------------------------------------------
|      $b    |   0|  0|  0|  0| 1| 0| 1| 0|
------------------------------------------- 
|      |     |   0|  0|  0|  0| 1| 0| 1| 1|
-------------------------------------------

Você notará que temos 3 bits definidos nas colunas 8, 2 e 1. Adicione-os: 8 + 2 + 1 = 11.

— Ankur Saxena
fonte
6
E se $ a assumir um valor maior que 255?
— Aycan Yaşıt
@ AycanYaşıt A maior parte do sistema operacional usa sistemas de 32 e 64 bits, o que significa que o limite é muito superior a 255 (8 bits).
— AlbertSamuel
@ AycanYaşıt Na verdade, a representação aqui com comprimento de um byte nem sequer está correta, pois mesmo o menor número inteiro ainda tem 64 bits (8 bytes) de memória em uma plataforma moderna de 64 bits.
— Kaii
Por que and &é 0 0 0 0 1 0 0 0 e or |é 0 0 0 0 1 0 1 1?
— Vir
285

<=> Operador da nave espacial

Adicionado no PHP 7

O operador nave espacial <=> é a mais recente operador de comparação adicionado em PHP 7. É um não associativo operador binário com o mesmo precedência como operadores de igualdade ( ==, !=, ===, !==). Esse operador permite uma comparação de três vias mais simples entre os operandos do lado esquerdo e do lado direito.

O operador resulta em uma expressão inteira de:

  • 0 quando ambos os operandos são iguais
  • Menor do que 0quando o operando do lado esquerdo é menor que o operando do lado direito
  • Maior do que 0quando o operando do lado esquerdo é maior que o operando do lado direito

por exemplo

1 <=> 1; // 0
1 <=> 2; // -1
2 <=> 1; // 1

Uma boa aplicação prática do uso desse operador seria nos retornos de chamada do tipo de comparação que devem retornar um número inteiro zero, negativo ou positivo com base em uma comparação de três vias entre dois valores. A função de comparação passada para usorté um exemplo.

Antes do PHP 7, você escrevia ...

$arr = [4,2,1,3];

usort($arr, function ($a, $b) {
    if ($a < $b) {
        return -1;
    } elseif ($a > $b) {
        return 1;
    } else {
        return 0;
    }
});

Desde o PHP 7 você pode escrever ...

$arr = [4,2,1,3];

usort($arr, function ($a, $b) {
    return $a <=> $b;
});
— Sherif
fonte
21
Não sei como $a <=> $bé diferente$a - $b
— rev
38
O @AcidShout $a - $bfunciona para números, mas não para cadeias, objetos ou matrizes.
— Mcrumley 25/09/2015
44
@crumley Não, é pior do que isso. Em geral $a - $b, nem sequer funciona para números; funciona apenas para números inteiros . Ele não funciona para números não inteiros, porque usortlança os valores de retorno da função comparadora para int, o que significa que 0,5 é convertido em 0, o que significa que dois números com uma diferença menor que 1, como 4 e 4,6, podem (dependendo no qual um é passado como o primeiro argumento para sua função comparadora), incorretamente, compare como igual.
— Mark Amery
5
@MarkAmery, o guia de migração não é o comportamento documentado do operador. Para isso, você deve consultar a seção de operadores de idioma do manual para comparar o comportamento real por trás disso em php.net/language.operators.com, que depende de várias funções de comparação da API, como quando você está fazendo strcmp para strings, em que você não pode garantir o valor de retorno real em todos os casos. Claro, quase sempre é 1, 0 ou -1, mas nos casos em que você não pode garantir isso, como empacotar o strcmp da libc, você oferece o mesmo comportamento definido que a especificação subjacente para segurança
— Sherif
9
@ MarkAmery O objetivo aqui não é permitir que as pessoas confiem em comportamentos indefinidos. No caso em que alguém obtém um valor que não é exatamente 1, 0 ou -1, você obtém alguém que envia um relatório de erro pensando que há algo errado no idioma. É por isso que documentamos que tudo o que podemos garantir é que o valor será menor que , maior que ou igual a 0, e não necessariamente 1, 0 e -1.
— Sherif
273 
Syntax    Name             Description

x == y    Equality         True if x and y have the same key/value pairs
x != y    Inequality       True if x is not equal to y
x === y   Identity         True if x and y have the same key/value pairs
                            in the same order and of the same types
x !== y   Non-identity     True if x is not identical to y
++ x      Pre-increment    Increments x by one, then returns x
x ++      Post-increment   Returns x, then increments x by one
-- x      Pre-decrement    Decrements x by one, then returns x
x --      Post-decrement   Returns x, then decrements x by one
x and y   And              True if both x and y are true x=6 y=3
                           (x < 10 and y > 1) returns true 
x && y    And              True if both x and y are true x=6 y=3
                           (x < 10 && y > 1) returns true
x or y     Or              True if any of x or y are true x=6 y=3
                           (x < 10 or y > 10) returns true 
x || y     Or              True if any of x or y are true x=6 y=3
                           (x < 3 || y > 1) returns true
a . b     Concatenation    Concatenate two strings: "Hi" . "Ha"
— Ankur Saxena
fonte
239

Constantes mágicas : Embora estes não sejam apenas símbolos, são parte importante dessa família de símbolos. Existem oito constantes mágicas que mudam dependendo de onde são usadas.

__LINE__: O número da linha atual do arquivo.

__FILE__: O caminho completo e o nome do arquivo. Se usado dentro de uma inclusão, o nome do arquivo incluído é retornado. Desde o PHP 4.0.2, __FILE__sempre contém um caminho absoluto com links simbólicos resolvidos, enquanto nas versões mais antigas ele continha um caminho relativo em algumas circunstâncias.

__DIR__: O diretório do arquivo. Se usado dentro de uma inclusão, o diretório do arquivo incluído é retornado. Isso é equivalente a dirname(__FILE__). Esse nome de diretório não possui uma barra final, a menos que seja o diretório raiz. (Adicionado no PHP 5.3.0.)

__FUNCTION__: O nome da função. (Adicionado no PHP 4.3.0) A partir do PHP 5, essa constante retorna o nome da função como foi declarada (diferencia maiúsculas de minúsculas). No PHP 4, seu valor é sempre em minúsculas.

__CLASS__: O nome da classe. (Adicionado no PHP 4.3.0) A partir do PHP 5, essa constante retorna o nome da classe como foi declarado (diferencia maiúsculas de minúsculas). No PHP 4, seu valor é sempre em minúsculas. O nome da classe inclui o espaço para nome em que foi declarado (por exemplo Foo\Bar). Note que a partir do PHP 5.4 __CLASS__também funciona em características. Quando usado em um método de característica, __CLASS__é o nome da classe na qual a característica é usada.

__TRAIT__: O nome da característica. (Adicionado no PHP 5.4.0) A partir do PHP 5.4, essa constante retorna a característica como foi declarada (diferencia maiúsculas de minúsculas). O nome da característica inclui o espaço para nome em que foi declarado (por exemplo Foo\Bar).

__METHOD__: O nome do método da classe. (Adicionado no PHP 5.0.0) O nome do método é retornado como foi declarado (diferencia maiúsculas de minúsculas).

__NAMESPACE__: O nome do espaço para nome atual (diferencia maiúsculas de minúsculas). Esta constante é definida em tempo de compilação (adicionada no PHP 5.3.0).

Fonte

— n.1
fonte
150

Operadores de tipo

instanceof é usado para determinar se uma variável PHP é um objeto instanciado de uma determinada classe.

<?php
class mclass { }
class sclass { }
$a = new mclass;
var_dump($a instanceof mclass);
var_dump($a instanceof sclass);

O exemplo acima exibirá:

bool(true)
bool(false)

Razão: O exemplo acima $aé um objeto do mclassportanto, use apenas mclassdados que não sejam uma instância dosclass

Exemplo com herança

<?php 
class pclass { } 
class childclass extends pclass { } 
$a = new childclass; 
var_dump($a instanceof childclass); 
var_dump($a instanceof pclass);

O exemplo acima exibirá:

bool(true)
bool(true)

Exemplo com Clone

<?php 
class cloneable { } 
$a = new cloneable;
$b = clone $a; 
var_dump($a instanceof cloneable); 
var_dump($b instanceof cloneable);

O exemplo acima exibirá:

bool(true)
bool(true)
— Maulik patel
fonte
7
O exemplo acima também funciona com 'interfaces'. Isso é útil para verificar se uma interface específica está disponível.
— Ryan Vincent
133

Uma visão geral dos operadores em PHP :

Operadores lógicos:

  • $ a && $ b: TRUE se $ a e $ b forem TRUE.
  • $ a || $ b: TRUE se $ a ou $ b for TRUE.
  • $ a xor $ b: TRUE se $ a ou $ b for TRUE, mas não ambos.
  • ! $ a: TRUE se $ a não for TRUE.
  • $ a e $ b: TRUE se ambos $ a e $ b forem VERDADEIROS.
  • $ a ou $ b: TRUE se $ a ou $ b for TRUE.

Operadores de comparação:

  • $ a == $ b: TRUE se $ a for igual a $ b após o tipo de malabarismo.
  • $ a === $ b: TRUE se $ a é igual a $ b e eles são do mesmo tipo.
  • $ a! = $ b: TRUE se $ a não for igual a $ b após o malabarismo do tipo.
  • $ a <> $ b: TRUE se $ a não for igual a $ b após o malabarismo do tipo.
  • $ a! == $ b: TRUE se $ a não for igual a $ b ou eles não forem do mesmo tipo.
  • $ a <$ b : TRUE se $ a for estritamente menor que $ b.
  • $ a> $ b : TRUE se $ a for estritamente maior que $ b.
  • $ a <= $ b : TRUE se $ a for menor ou igual a $ b.
  • $ a> = $ b : TRUE se $ a for maior ou igual a $ b.
  • $ a <=> $ b : um número inteiro menor que, igual a ou maior que zero quando $ a é respectivamente menor que, igual a ou maior que $ b. Disponível a partir do PHP 7.
  • $ a? $ b: $ c : se $ a retornar $ b, senão retornar $ c ( operador ternário )
  • $ a ?? $ c : o mesmo que $ a? $ a: $ c ( operador coalescente nulo - requer PHP> = 7)

Operadores aritméticos:

  • - $ a : oposto de $ a.
  • $ a + $ b : soma de $ a e $ b.
  • $ a - $ b : Diferença de $ a e $ b.
  • $ a * $ b : produto de $ a e $ b.
  • $ a / $ b : quociente de $ a e $ b.
  • $ a% $ b : restante de $ a dividido por $ b.
  • $ a ** $ b : resultado do aumento de $ a para o poder de $ b'th (introduzido no PHP 5.6)

Operadores de incremento / decrescimento:

  • ++ $ a : Incrementa $ a por um e depois retorna $ a.
  • $ a ++ : retorna $ a e depois incrementa $ a por um.
  • - $ a : Decrementa $ a por um e depois retorna $ a.
  • $ a-- : Retorna $ a e depois diminui $ a por um.

Operadores bit a bit:

  • $ a & $ b : são definidos os bits definidos em $ a e $ b.
  • $ a | $ b : os bits definidos em $ a ou $ b são definidos.
  • $ a ^ $ b : os bits definidos em $ a ou $ b, mas não os dois, estão definidos.
  • ~ $ a : Os bits definidos em $ a não são definidos e vice-versa.
  • $ a << $ b : desloque os bits das etapas de $ a $ b para a esquerda (cada etapa significa "multiplicar por dois")
  • $ a >> $ b : mova os bits das etapas de $ a $ b para a direita (cada etapa significa "dividir por dois")

Operadores de seqüência de caracteres:

  • $ a. $ b : concatenação de $ a e $ b.

Operadores de matriz:

  • $ a + $ b : união de $ a e $ b.
  • $ a == $ b : TRUE se $ a e $ b tiverem os mesmos pares de chave / valor.
  • $ a === $ b : TRUE se $ a e $ b tiverem os mesmos pares de chave / valor na mesma ordem e dos mesmos tipos.
  • $ a! = $ b : TRUE se $ a não for igual a $ b.
  • $ a <> $ b : TRUE se $ a não for igual a $ b.
  • $ a! == $ b : TRUE se $ a não for idêntico a $ b.

Operadores de atribuição:

  • $ a = $ b : o valor de $ b é atribuído a $ a
  • $ a + = $ b : o mesmo que $ a = $ a + $ b
  • $ a - = $ b : o mesmo que $ a = $ a - $ b
  • $ a * = $ b : o mesmo que $ a = $ a * $ b
  • $ a / = $ b : o mesmo que $ a = $ a / $ b
  • $ a% = $ b : o mesmo que $ a = $ a% $ b
  • $ a ** = $ b : o mesmo que $ a = $ a ** $ b
  • $ a. = $ b : o mesmo que $ a = $ a. $ b
  • $ a & = $ b : o mesmo que $ a = $ a & $ b
  • $ a | = $ b : O mesmo que $ a = $ a | $ b
  • $ a ^ = $ b : o mesmo que $ a = $ a ^ $ b
  • $ a << = $ b : o mesmo que $ a = $ a << $ b
  • $ a >> = $ b : o mesmo que $ a = $ a >> $ b

Nota

andoperador e oroperador têm menor precedência que o operador de atribuição =.

Isso significa que $a = true and false;é equivalente a ($a = true) and false.

Na maioria dos casos, você provavelmente desejará usar &&e ||, que se comportam de uma maneira conhecida em linguagens como C, Java ou JavaScript.

— John Slegers
fonte
1
Existe um erro $a ?? $c, diz que é o mesmo que $a ? $a : $c, mas o operador ternário verifica se o valor é verdadeiro; por outro lado, a coalescência nula verifica valores nulos; portanto, se $ a for 0, você receberá 0 (porque 0 é não nulo), por exemplo, se você tiver: $a=0; $c=5;então $a?$a:$cretorna 5 e $a??$cretorna 0. #
— stramin
104

Operador de nave espacial<=> (adicionado no PHP 7)

Exemplos para <=>operador de nave espacial (PHP 7, Fonte: Manual do PHP):

Inteiros, flutuadores, seqüências de caracteres, matrizes e objetos para comparação de variáveis ​​de três vias.

// Integers
echo 10 <=> 10; // 0
echo 10 <=> 20; // -1
echo 20 <=> 10; // 1

// Floats
echo 1.5 <=> 1.5; // 0
echo 1.5 <=> 2.5; // -1
echo 2.5 <=> 1.5; // 1

// Strings
echo "a" <=> "a"; // 0
echo "a" <=> "b"; // -1
echo "b" <=> "a"; // 1
// Comparison is case-sensitive
echo "B" <=> "a"; // -1

echo "a" <=> "aa"; // -1
echo "zz" <=> "aa"; // 1

// Arrays
echo [] <=> []; // 0
echo [1, 2, 3] <=> [1, 2, 3]; // 0
echo [1, 2, 3] <=> []; // 1
echo [1, 2, 3] <=> [1, 2, 1]; // 1
echo [1, 2, 3] <=> [1, 2, 4]; // -1

// Objects
$a = (object) ["a" => "b"]; 
$b = (object) ["a" => "b"]; 
echo $a <=> $b; // 0

$a = (object) ["a" => "b"]; 
$b = (object) ["a" => "c"]; 
echo $a <=> $b; // -1

$a = (object) ["a" => "c"]; 
$b = (object) ["a" => "b"]; 
echo $a <=> $b; // 1

// only values are compared
$a = (object) ["a" => "b"]; 
$b = (object) ["b" => "b"]; 
echo $a <=> $b; // 1
— rajangupta
fonte
1
Verifique php.net/manual/en/language.operators.comparison.php para obter a referência
— rajangupta
74

{} Suspensórios

E algumas palavras sobre o último post

$x[4] = 'd'; // it works
$x{4} = 'd'; // it works

$echo $x[4]; // it works
$echo $x{4}; // it works

$x[] = 'e'; // it works
$x{} = 'e'; // does not work

$x = [1, 2]; // it works
$x = {1, 2}; // does not work

echo "${x[4]}"; // it works
echo "${x{4}}"; // does not work

echo "{$x[4]}"; // it works
echo "{$x{4}}"; // it works
— mnv
fonte
4
notação {''} para nomes de propriedades. echo $ movies-> movie -> {'great-lines'} -> line; pode ser usado para acessar dados no SimpleXMLElement. Talvez também possa ser usado em outros casos. php.net/manual/en/simplexml.examples-basic.php
— Andrei
68

Operador coalescente nulo (??)

Esse operador foi adicionado no PHP 7.0 para o caso comum de precisar usar um operador ternário em conjunto com isset() . Retorna seu primeiro operando se ele existe e não é NULL; caso contrário, ele retornará seu segundo operando.

<?php
// Fetches the value of $_GET['user'] and returns 'nobody'
// if it does not exist.
$username = $_GET['user'] ?? 'nobody';
// This is equivalent to:
$username = isset($_GET['user']) ? $_GET['user'] : 'nobody';

// Coalescing can be chained: this will return the first
// defined value out of $_GET['user'], $_POST['user'], and
// 'nobody'.
$username = $_GET['user'] ?? $_POST['user'] ?? 'nobody';
?>
— VIPIN A ROY
fonte
64

Strings PHP: As Strings PHP podem ser especificadas de quatro maneiras e não apenas de duas maneiras:

1) Cordas de aspas simples: 

$string = 'This is my string'; // print This is my string

2) Cordas de aspas duplas: 

$str = 'string';

$string = "This is my $str"; // print This is my string

3) Heredoc: 

$string = <<<EOD
This is my string
EOD; // print This is my string

4) Nowdoc (desde PHP 5.3.0): 

$string = <<<'END_OF_STRING'
    This is my string 
END_OF_STRING; // print This is my string
— devpro
fonte
@ Rizier123: O que significa "Heredocs não pode ser usado para inicializar propriedades de classe. Desde o PHP 5.3, essa limitação é válida apenas para heredocs que contêm variáveis."?
— PHPFan
48

QUESTÃO:

O que =>significa isso ?

RESPONDA:

=>É o símbolo que nós humanos decidimos usar para separar "Key" => "Value"pares em matrizes associativas.

ELABORAÇÃO:

Para entender isso, precisamos saber o que são matrizes associativas. A primeira coisa que surge quando um programador convencional pensa em uma matriz ( em PHP ) seria algo semelhante a:

$myArray1 = array(2016, "hello", 33);//option 1

$myArray2 = [2016, "hello", 33];//option 2

$myArray3 = [];//option 3
$myArray3[] = 2016; 
$myArray3[] = "hello"; 
$myArray3[] = 33;

Onde, se quiséssemos chamar a matriz em alguma parte posterior do código, poderíamos fazer:

echo $myArray1[1];// output: hello
echo $myArray2[1];// output: hello
echo $myArray3[1];// output: hello

Por enquanto, tudo bem. No entanto, como seres humanos, podemos achar difícil lembrar que o índice [0]da matriz é o valor do ano de 2016, o índice [1]da matriz é uma saudação e o índice [2]da matriz é um valor inteiro simples . A alternativa que teríamos então seria usar o que é chamado de Matriz Associativa . Uma matriz associativa possui algumas diferenças em relação a uma matriz seqüencial ( que é o caso anterior, pois incrementa o índice usado em uma sequência predeterminada, incrementando em 1 para cada valor a seguir ).

Diferenças ( entre uma matriz seqüencial e associativa ):

  • Durante a declaração de uma matriz associativa, você não inclui apenas o valueque deseja colocar na matriz, mas também coloca o valor do índice (chamado de key) que deseja usar ao chamar a matriz em partes posteriores do código. A sintaxe a seguir é usada durante a sua declaração: "key" => "value".

  • Ao usar a Matriz associativa, o keyvalor será colocado dentro do índice da matriz para recuperar o desejado value.

Por exemplo:

    $myArray1 = array( 
        "Year" => 2016, 
        "Greetings" => "hello", 
        "Integer_value" => 33);//option 1

    $myArray2 = [ 
        "Year" =>  2016, 
        "Greetings" => "hello", 
        "Integer_value" => 33];//option 2

    $myArray3 = [];//option 3
    $myArray3["Year"] = 2016; 
    $myArray3["Greetings"] = "hello"; 
    $myArray3["Integer_value"] = 33;

E agora, para receber a mesma saída de antes, o keyvalor seria usado no índice de matrizes:

echo $myArray1["Greetings"];// output: hello
echo $myArray2["Greetings"];// output: hello
echo $myArray3["Greetings"];// output: hello

PONTO FINAL:

Portanto, a partir do exemplo acima, é muito fácil ver que o =>símbolo é usado para expressar o relacionamento de uma Matriz associativa entre cada um dos pares keye valueem uma matriz DURANTE a iniciação dos valores dentro da matriz.

— Webeng
fonte
36

Pergunta :

O que "&" significa aqui em PHP?

Operador PHP "&"

Facilita a vida assim que nos acostumamos. (Veja o exemplo abaixo com atenção)

& normalmente verifica os bits definidos em $ a e $ b.

você já reparou como essas chamadas funcionam?

   error_reporting(E_ERROR | E_WARNING | E_PARSE);
    error_reporting(E_ERROR | E_WARNING | E_PARSE | E_NOTICE);
    error_reporting(E_ALL & ~E_NOTICE);
    error_reporting(E_ALL);

Então, por trás de tudo, há um jogo de operador e bits bit a bit.

Um caso útil disso são as configurações fáceis, como abaixo, para que um único campo inteiro possa armazenar milhares de combinações para você.

A maioria das pessoas já leu os documentos, mas não liberou o caso de uso do mundo real desses operadores bit a bit.

Exemplo que você vai adorar

<?php

class Config {

    // our constants must be 1,2,4,8,16,32,64 ....so on
    const TYPE_CAT=1;
    const TYPE_DOG=2;
    const TYPE_LION=4;
    const TYPE_RAT=8;
    const TYPE_BIRD=16;
    const TYPE_ALL=31;

    private $config;

    public function __construct($config){
        $this->config=$config;

        if($this->is(Config::TYPE_CAT)){
            echo 'cat ';
        }
        if($this->is(Config::TYPE_DOG)){
            echo 'dog ';
        }
        if($this->is(Config::TYPE_RAT)){
            echo 'rat ';
        }
        if($this->is(Config::TYPE_LION)){
            echo 'lion ';
        }
        if($this->is(Config::TYPE_BIRD)){
            echo 'bird ';
        }
        echo "\n";
    }

    private function is($value){
        return $this->config & $value;
    }
}

new Config(Config::TYPE_ALL);
// cat dog rat lion bird
new Config(Config::TYPE_BIRD);
//bird
new Config(Config::TYPE_BIRD | Config::TYPE_DOG);
//dog bird
new Config(Config::TYPE_ALL & ~Config::TYPE_DOG & ~Config::TYPE_CAT);
//rat lion bird
— dev.mraj
fonte
30

== é usado para verificar a igualdade sem considerar o tipo de dados variável

===é usado para a igualdade cheque de tanto a variável de valor e do tipo de dados

Exemplo

$a = 5

  1. if ($a == 5) - avaliará como verdadeiro

  2. if ($a == '5') - será avaliado como true, porque, ao comparar esse valor, o PHP converte internamente esse valor da string em número inteiro e, em seguida, compara os dois valores

  3. if ($a === 5) - avaliará como verdadeiro

  4. if ($a === '5') - será avaliado como falso, porque o valor é 5, mas esse valor 5 não é um número inteiro.

— Parth Nayak
fonte
27

Operador de coalescência nula "??" (Adicionado no PHP 7)

Não é o nome mais atraente para um operador, mas o PHP 7 traz a coalescência nula bastante útil, então pensei em compartilhar um exemplo.

No PHP 5, já temos um operador ternário, que testa um valor e, em seguida, retorna o segundo elemento se retornar true e o terceiro se não retornar:

echo $count ? $count : 10; // outputs 10

Também existe uma abreviação para isso, que permite pular o segundo elemento se for o mesmo que o primeiro: echo $ count?: 10; // também gera 10

No PHP 7, obtemos adicionalmente o ?? Um operador que, em vez de indicar confusão extrema, é assim que eu usaria dois pontos de interrogação juntos, permite-nos encadear uma cadeia de valores. Lendo da esquerda para a direita, o primeiro valor que existe e não é nulo é o valor que será retornado.

// $a is not set
$b = 16;

echo $a ?? 2; // outputs 2
echo $a ?? $b ?? 7; // outputs 16

Essa construção é útil para dar prioridade a um ou mais valores provenientes talvez da entrada do usuário ou da configuração existente e retornar com segurança a um determinado padrão se essa configuração estiver ausente. É um recurso pequeno, mas sei que usarei assim que meus aplicativos forem atualizados para o PHP 7.

— Yogi Ghorecha
fonte
12

Declaração de tipo de retorno anulável

O PHP 7 adiciona suporte para declarações de tipo de retorno. Da mesma forma que as declarações de tipo de argumento, as declarações de tipo de retorno especificam o tipo de valor que será retornado de uma função. Os mesmos tipos estão disponíveis para declarações de tipo de retorno e estão disponíveis para declarações de tipo de argumento.

A digitação estrita também afeta as declarações de tipo de retorno. No modo fraco padrão, os valores retornados serão coagidos para o tipo correto se ainda não forem desse tipo. No modo forte, o valor retornado deve ser do tipo correto, caso contrário, um TypeError será lançado.

A partir do PHP 7.1.0, os valores retornados podem ser marcados como nulos, prefixando o nome do tipo com um ponto de interrogação (?). Isso significa que a função retorna o tipo especificado ou NULL.

<?php
function get_item(): ?string {
    if (isset($_GET['item'])) {
        return $_GET['item'];
    } else {
        return null;
    }
}
?>

Fonte

— John Conde
fonte
7

Três DOTS como Operador Splat (...) (desde PHP 5.6)

O PHP possui um operador "..." (Três pontos), chamado Operador Splat. É usado para passar um número arbitrário de parâmetros em uma função e esse tipo de função é chamado de Funções Variadic. Vamos dar exemplos para usar "..." (Três pontos).

Exemplo 1:

<?php
function calculateNumbers(...$params){
    $total = 0;
    foreach($params as $v){
        $total = $total + $v;
    }
    return $total;
}

echo calculateNumbers(10, 20, 30, 40, 50);

//Output 150
?>

Cada argumento da função generateNumbers () passa por $ params como uma matriz quando usa "...".

Existem muitas maneiras diferentes de usar o operador "...". Abaixo alguns exemplos:

Exemplo 2:

<?php
function calculateNumbers($no1, $no2, $no3, $no4, $no5){
    $total = $no1 + $no2 + $no3 + $no4 + $no5;
    return $total;
}

$numbers = array(10, 20, 30, 40, 50);
echo calculateNumbers(...$numbers);

//Output 150
?>

Exemplo 3:

<?php
function calculateNumbers(...$params){
    $total = 0;
    foreach($params as $v){
        $total = $total + $v;
    }
    return $total;
}
$no1 = 70;
$numbers = array(10, 20, 30, 40, 50);
echo calculateNumbers($no1, ...$numbers);

//Output 220
?>

Exemplo 4:

<?php
function calculateNumbers(...$params){
    $total = 0;
    foreach($params as $v){
        $total = $total + $v;
    }
    return $total;
}

$numbers1 = array(10, 20, 30, 40, 50);
$numbers2 = array(100, 200, 300, 400, 500);
echo calculateNumbers(...$numbers1, ...$numbers2);

//Output 1650

?>
— Yogi Ghorecha
fonte
0

? -> Operador NullSafe

No momento, é apenas uma proposta, você pode encontrá-la aqui . É o NullSafe Operator, retorna nullcaso você tente invocar funções ou obter valores de null... Exemplo

$objDrive = null;
$drive = $objDrive?->func?->getDriver()?->value; //return null
$drive = $objDrive->func->getDriver()->value; // Error: Trying to get property 'func' of non-object
— John Conde
fonte
Adicionar isso parece prematuro, ninguém verá esse operador em nenhum código ativo e talvez nem seja adicionado. Seria melhor esperar até que os detalhes sejam finalizados e documentá-lo corretamente.
— IMSoP
Já estamos recebendo perguntas sobre isso. : / Se a proposta falhar, podemos decidir se vale a pena mantê-lo.
— John Conde
@JohnConde see? era isso que eu estava dizendo ...
— Berto99
@JohnConde Eu ficaria tentado a fechá-los como fora de tópico, porque eles estão perguntando sobre uma linguagem de programação imaginária; ou talvez "esta pergunta pertença a uma parte diferente da linha do tempo, verifique as configurações na sua máquina do tempo";)
— IMSoP
lol O pensamento passou pela minha cabeça. Perguntei-me se isso ofereceria valor aos futuros visitantes e, por enquanto, a resposta é "sim". Mas isso pode mudar ...
— John Conde
0

Operador NullSafe "? ->" (possivelmente) desde o php8

No momento, é apenas uma proposta, você pode encontrá-la aqui . ?->é o NullSafe Operatorretorno null, caso você tente invocar funções ou obter valores de null...

Exemplos:

<?php
$obj = null;
$obj = $obj?->attr; //return null
$obj = ?->funct(); // return null
$obj = $objDrive->attr; // Error: Trying to get property 'attr' of non-object
?>
— Berto99
fonte
Adicionar isso parece prematuro, ninguém verá esse operador em nenhum código ativo e talvez nem seja adicionado. Seria melhor esperar até que os detalhes sejam finalizados e documentá-lo corretamente.
— IMSoP
@IMSoP Estou com você, no entanto, fui convidado a fazê-lo aqui stackoverflow.com/questions/62178354/… ...
— Berto99
Parece que agora temos duas respostas sobre isso. Pessoalmente, eu teria votado para encerrar a outra pergunta em vez de tentar responder, porque no momento não existe esse operador.
— IMSoP
@IMSoP existem muitas perguntas aqui no StackOverflow sobre a proposta de C ++, e elas não foram fechadas: apesar disso, estou com você sobre não postar aqui este operador no momento
— Berto99
Eu não sei muito sobre o processo C ++ e quando é razoável discutir propostas, e para ser justo, esse parece ser bem provável que seja bem-sucedido na modificação de exercícios, mas, em geral, existem muitos recursos propostos para o PHP que nunca chegam ao idioma e seria bastante confuso para os usuários encontrarem todos eles em listas de referência. Dito isto, em parte estou apenas sendo um velho rabugento aqui: P
— IMSoP
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.