Referência - o que significa este símbolo em PHP?
esta é uma coleção de perguntas que surgem de vez em quando sobre sintaxe em PHP. Esta é também uma Wiki comunitária, por isso todos são convidados a participar na manutenção desta lista.
Porquê? costumava ser difícil encontrar perguntas sobre operadores e outros tokens de sintaxe.¹
A ideia principal é ter links para as questões existentes no fluxo de pilha, por isso é mais fácil para nós referi-las, não para copiar sobre o conteúdo do Stack Manual do PHP.
1 Nota: Desde janeiro de 2013, o Stack Overflow suporta caracteres especiais. Basta rodear os Termos de pesquisa por aspas, e.g. [php] "==" vs "==="
Se você foi apontado aqui por alguém porque você fez tal pergunta, por favor, Encontre a sintaxe particular abaixo. As páginas ligadas ao manual PHP juntamente com as perguntas ligadas provavelmente responderão à sua pergunta então. Se assim for, você é encorajado a vote a resposta. Esta lista não se destina a substituir a ajuda fornecida pelos outros.
A Lista
se a sua ficha não estiver listada abaixo, poderá encontrá-la na lista de fichas Analisadoras.
&
operadores Bitwise ou referências
- O que significa iniciar uma função PHP com um ampersand?
- compreender o PHP & (ampersand, bitwise e) operador
- operador de PHP"&"
- diferença entre & e & em PHP
- o que significa " & " aqui em PHP?
- o que significa " e " neste caso?
- O que significa o sinal " & " em PHP?
- O que significa esta assinatura (&) em PHP?
- como funciona o operador " & " numa função PHP?
- O que significa & em & 2 em PHP?
- Quando devo usar um operador bitwise?
- Há alguma necessidade de usar ampersand na frente de um objecto? (&$)
=&
Referências
- operador de atribuição de referência em PHP, =&
- o que significam os operadores "= & " e "& = " em PHP?
- o que fazem os operadores '& = 'e'=&'?
- o que significa = & em PHP?
- 'E" vs "& & " como operador
- diferença entre & e & em PHP
- existe alguma diferença entre operadores" e " e " & " em PHP?
- PHP-e / ou palavras-chave
- o que significa o sinal percentual em PHP?
- O que é o PHP operador % e como eu usá-lo em exemplos do mundo real?
@
Controlo De Erros Operadores
- Qual é o uso do símbolo @ em PHP?
- 'no símbolo' antes do nome da variável em PHP: @$_POST
- funções PHP e @functions
- devo usar @ no meu código PHP?
- o que são os operadores PHP "?"e": "chamou e o que eles fazem?
- ?: operador (o "Elvis operator") em PHP
- Onde posso ler sobre condicionalismos feitos"?"and": "(colon)?
- usar o PHP 5.3 ?: operador
??
operador de carvão nulo (desde PHP 7)
:
sintaxe Alternativa para estruturas de controle, Operador Ternário
::
Operador De Resolução De Âmbito
- o que significam dois colões em PHP?
- Qual é o significado do símbolo PHP t_paamayim_nekudotayim?
- Qual é a diferença entre:: (dois pontos) e - > (seta) no PHP?
- o que exatamente são ligações estáticas tardias em PHP?
- static:: staticFunctionName()
- T_paamayim_nekudotayim inesperado, esperando T_NS_Separator
- o que é o operador de PHP "- > " chamado e como você diz quando lês o código em voz alta?
- onde usamos o operador do objeto "- > " em PHP?
- Qual é a diferença entre:: (dois pontos) e - > (seta) no PHP?
- o que significa a sintaxe do PHP $var1->$var2?
- o que significa "- > " /se refere em PHP?
=>
Arrays
- o que significa "= > " em PHP?
- utilização de => em PHP
- o que significa $k = > $v em foreach ($ex como $k=>$v)?
- o que significa <<< < END em PHP?
- expressão de PHP << < < EOB
- em PHP, o que representa"<<<"?
- utilizar < < < CON em PHP
- que sintaxe é esta no PHP?
- como os operadores de comparação PHP equality (== double equals) e identity (=== triple equals) diferem?
- PHP != e = = operadores
- os 3 diferentes é igual
- Tipo-malabarismo e (estrito) maior/menor-que comparações em PHP
- o que significa"=="?
- como os operadores de comparação PHP equality (== double equals) e identity (=== triple equals) diferem?
- os 3 diferentes é igual
- tipo-malabarismo e (estrito) maior/menor-que comparações em PHP
- PHP != e = = operadores
- há alguma diferença entre != = and !- em PHP?
- comparando != = versus !=
- Qual é a diferença entre < > e !=
- operador de PHP<>
- operador do PHP
- Qual é a diferença entre < > e !=
- tipo-malabarismo e (estrito) maior/menor-que comparações em PHP
<=>
operadores de comparação (desde PHP 7.0)
- Qual é a diferença entre os | e || operadores?
- O Que Faz Usar Um Único Tubo '|' Em Um Argumento De Função?
- Qual é a diferença entre os | e || operadores?
- PHP-e / ou palavras-chave
- o que exatamente faz || mau?
- o comportamento do operador ou em PHP
+
Operadores Aritméticos, Operadores De Listas
+=
e -=
Operadores de Atribuição
++
e --
operadores que aumentam/diminuem
- diferença entre o período e a vírgula quando se concatenam com echo versus retorno?
- o que faz um . (dot) do in PHP?
[]
Arrays (sintaxe curta desde PHP 5.4)
- PHP arrays... Qual é / são o Significado de um suporte vazio?
- Qual é o significado de []
- Php array_ push () vs myArray[]
- o que significa [] ao ler a partir de um array PHP?
- abreviatura para arrays: literal
$var = []
matriz vazia
...
argumento desempacotar (desde PHP 5.6)
**
exponenciação (desde PHP 5.6)
#
comentário ao estilo da linha de comandos
18 answers
Operadores Que Aumentam / Diminuem
++
operador do incremento
--
operador decretado
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 colocado antes da variável, a operação de incremento/decremento é feita à variável primeiro, Então o resultado é devolvido. Se colocar depois da variável, a variável é primeiramente devolvida, então a operação de incremento/decremento é feita.
Para exemplo:
$apples = 10;
for ($i = 0; $i < 10; ++$i) {
echo 'I have ' . $apples-- . " apples. I just ate one.\n";
}
No caso acima ++$i
é usado, uma vez que é mais rápido. $i++
teria os mesmos resultados.
O pré-incremento é um pouco mais rápido, porque realmente aumenta a variável e depois disso 'retorna' o resultado. O pós-incremento cria uma variável especial, copia lá o valor da primeira variável e só depois da primeira variável ser usada, substitui o seu valor pelo do segundo.
No entanto, deve utilizar $apples--
, desde que primeiro você quer mostrar o número atual de maçãs, e Então Você quer subtrair uma delas.
Também pode aumentar as letras em PHP:
$i = "a";
while ($i < "c") {
echo $i++;
}
Uma vez que z
é alcançado aa
é próximo, e assim por diante.
Note que as variáveis de caracteres podem ser incrementadas mas não decremidas e mesmo assim apenas os caracteres ASCII simples (A-z e a-Z) são suportados.
Estouro Da Pilha Publicações:
Operador Bitwise
O que é um pouco? Um bit é uma representação de 1 ou 0. Basicamente desligado (0) e LIGADO(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 é definido. Veremos porque é 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"e" operador: &
$a = 9;
$b = 10;
echo $a & $b;
Isto daria o número 8. Por quê? Vamos ver usando nosso exemplo de mesa.
-------------------------------------------
| 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 a partir da mesa o único pedaço que eles compartilham juntos é 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 partilhados são 32 e 4, que, quando adicionados, devolvem 36.
O " ou " operador: |
$a = 9;
$b = 10;
echo $a | $b;
Isto daria o número 11. Por quê?
-------------------------------------------
| 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|
-------------------------------------------
Vais reparar que temos 3 bits. set, nas 8, 2 e 1 colunas. Somem esses: 8+2+1 = 11.
_
Nome alternativo para gettext()
O carácter sublinhado '_' como em {[1] } é um nome falso para o gettext()
função.
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
a . b Concatenation Concatenate two strings: "Hi" . "Ha"
Constantes mágicas : embora não sejam apenas símbolos, mas uma parte importante desta família Simbólica. Há oito constantes mágicas que mudam dependendo de onde são usadas.
__LINE__
: o número de linha actual do ficheiro.
__FILE__
: a localização completa e o nome do ficheiro. Se usado dentro de uma inclusão, o nome do arquivo incluído é devolvido. Desde o PHP 4.0.2, __FILE__
sempre contém um caminho absoluto com ligações simbólicas resolvidas, enquanto que nas versões mais antigas ele o caminho relativo contido em algumas circunstâncias.
__DIR__
: o diretório do arquivo. Se usado dentro de uma inclusão, o diretório do arquivo incluído é devolvido. Isto é equivalente a dirname(__FILE__)
. Este nome de directório não tem uma barra final a menos que seja a pasta raiz. (Adicionado em PHP 5.3.0.)
__FUNCTION__
: o nome da função. (Adicionado em PHP 4. 3. 0) a partir de PHP 5 esta constante devolve o nome da função tal como foi declarado (sensível à capitalização). Em PHP 4 o seu valor é sempre minúsculas.
__CLASS__
: o nome da turma. (Adicionado em PHP 4. 3. 0) a partir de PHP 5 esta constante devolve o nome da classe como foi declarado (sensível à capitalização). No PHP 4 o seu valor é sempre baixo. O nome da classe inclui o espaço de nomes em que foi declarado (por exemplo Foo\Bar
). Note que a partir de PHP 5.4 __CLASS__
também funciona em traços. Quando usado em um método de traço, __CLASS__
é o nome da classe em que o traço é usado.
__TRAIT__
: o nome do traço. (Adicionado em PHP 5, 4, 0) a partir de PHP 5, 4 esta constante devolve a característica tal como foi declarada (caso sensível). O nome do traço inclui o espaço de nomes em que foi declarado (por exemplo Foo\Bar
).
__METHOD__
: o nome do método da classe. (Added in PHP 5.0.0) The method name is returned as it was declared (case-sensitive).
__NAMESPACE__
: o nome do espaço de nomes actual (sensível à capitalização). Esta constante é definida em tempo de compilação (adicionado em PHP 5.3.0).
<=>
Operador Da Nave Espacial
Adicionado ao PHP 7
O operador da nave espacial <=>
é o último operador de comparação adicionado em PHP 7. It is a non-associative binary operator with the same precedency as equality operators (==
, !=
, ===
, !==
). Este operador permite uma comparação tridimensional mais simples entre operandos da esquerda e da direita.
O operador resulta numa expressão inteira de:
-
0
quando ambos os operandos são iguais - inferior a
0
Quando o comando da esquerda for inferior ao comando da direita - maior que
0
Quando o comando esquerdo é maior que o comando direito
Por exemplo
1 <=> 1; // 0
1 <=> 2; // -1
2 <=> 1; // 1
Uma boa aplicação prática de usar este operador seria, em comparação, callbacks tipo que são esperados para retornar um zero, negativo, ou positivo inteiro baseado em uma comparação de três vias entre dois valores. A função de comparação passou para usort
é um desses exemplos.
$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 podes escrever...
$arr = [4,2,1,3];
usort($arr, function ($a, $b) {
return $a <=> $b;
});
Operadores Do 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 irá aparecer:
bool(true)
bool(false)
Razão: acima do exemplo $a
é um objecto do mclass
por isso use apenas um mclass
dados não instância de com o sclass
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 irá aparecer:
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 saída do will:
bool(true)
bool(true)
Uma visão geral da operadores de PHP:
Operadores Lógicos:
- $a & $b: verdadeiro se tanto $a como $b são verdadeiros.
- $a || $b: TRUE if either $a or $b is TRUE.
- $a xor $b: TRUE if either $a or $b is TRUE, but not both.
- ! $ a : é verdade se $a não é verdade.
- É verdade, se tanto o a como o b são verdadeiros.
- $A ou $ b : verdadeiro se $a ou $b for verdadeiro.
Operadores de comparação:
- $a = = $b: TRUE if $a is equal to $b after type juggling.
- $a === $b : TRUE if $a is equal to $b, and they are of the same type.
- $ A != $ b : TRUE if $a is not equal to $b after type juggling.
- $a $ b: TRUE if $a is not equal to $b after type juggling.
- $ A !== $B : TRUE if $a is not equal to $b, or they are not of the same type.
- $a : verdadeiro se $a for estritamente inferior a $B.
- $a > $b : verdadeiro se $a for estritamente maior que $b.
- $a : verdadeiro se $a for inferior ou igual a $B.
- $a > = $b : verdadeiro se $a for maior ou igual a $B.
- $a $b : Um inteiro inferior a, igual ou superior a zero quando $a é, respectivamente, inferior do que, igual ou superior a $B. disponível a partir de PHP 7.
- $ A ? $b: $ c : se $a return $B else return $c (operador ternário)
- $ A ?? igual a $ a ? $A: $c (operador de carvão nulo - necessita de 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 de aumentar $a para o poder $B ' ésimo (introduzido em PHP 5.6)
Operadores Que Aumentam/Diminuem:
- ++ $ a : incrementos $a por um, depois devolve $ A.
- $a++: Devolve $a, aumentando depois $a por um.
- --$a : Decretos $a por um, e depois devolve $a.
- $a--: Devolve $a, depois decreta $a por um.
Operadores Bitwise:
- $a & $b : Os Bits que estão definidos em $A E $b estão definidos.
- $a / $b : Os Bits que estão definidos em $A ou $b estão definidos.
- $a ^ $b : Bits que estão definidos em $A ou $b, mas não estão ambos definidos.
- ~ $a : Bits que estão definidos em $a não estão definidos, e vice-versa.
- $a : muda os bits de $A $B passos para a esquerda (cada passo significa "multiplicar por dois")
- $a >> $b : Deslocar os bits de $a $b passos para a direita (cada passo significa "dividir por dois")
Operadores De Texto:
- $ A. $ b : concatenação de $A e $ B.
Operadores De Listas:
- $a + $b : União de $a e $b.
- $a = = $b : verdadeiro se $a e $b tiverem os mesmos pares de chaves / valores.
- $a = = = $b : verdadeiro se $a e $b tiverem os mesmos pares de chaves/valores na mesma ordem e dos mesmos tipos.
- $ A != $b : verdadeiro se $a não for igual a $B.
- $a $b : verdadeiro se $a não for igual a $B.
- $ A !== $b : verdadeiro 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 : igual a $A = $A + $b
- $a - = $b : igual a $A = $A - $b
- $a * = $b : igual a $A = $A * $b
- $a / = $b : igual a $A = $A / $b
- $a %= $b : igual a $a = $a % $b
- $a * * = $b : igual a $a = $a * * $b
- $ A.= $b : igual a $a = $A. $b
- $a & = $b : igual a $A = $A & $b
- $a / = $b : igual a $A = $A / $b
- $a ^ = $b : igual a $A = $A ^ $b
-
$a : igual a $A = $A
- $a > > = $b : igual a $a = $a > > $b
Nota
and
operador e or
operador têm precedência inferior à atribuição Operador =
.
Isto significa que {[3] } é equivalente a ($a = true) and false
.
Na maioria dos casos você provavelmente vai querer usar &&
e ||
, que se comportam de uma maneira conhecida de linguagens como C, Java ou JavaScript.
Operador da nave espacial<=>
(Adicionado em PHP 7)
Exemplos de <=>
Operador de nave espacial (PHP 7, Fonte: manual PHP):
Inteiros, flutuantes, Strings, Arrays & objects para comparação de três vias de variáveis.
// 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
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
{}
Chavetas encaracoladas
- blocos-aparelho encaracolado / sem aparelho encaracolado?
- Chavetas enroladas no texto em PHP
- chavetas de PHP em notação de Lista
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
Cadeias de PHP: As cadeias de PHP podem ser especificadas de quatro formas e não apenas de duas formas:
1) Textos De Citação Simples:
$string = 'This is my string'; // print This is my string
2) Textos 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
Operador de carvão nulo (??)
Este operador foi adicionado em PHP 7.0 para o caso comum de necessitar de utilizar um operador ternário em conjunto com isset()
. Devolve o seu primeiro operando se existir e não for NULL
; caso contrário devolve o 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';
?>
Pergunta:
O que significa isso?Resposta:
=>
é o símbolo que nós humanos decidimos usar para separar os pares "Key" => "Value"
em matrizes associativas.
Elaboração:
Para compreender isto, temos de saber que matrizes associativas são. 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, como se queríamos ligar para o array numa parte posterior do Código, podíamos fazer: [[23]}
echo $myArray1[1];// output: hello
echo $myArray2[1];// output: hello
echo $myArray3[1];// output: hello
Até agora tudo bem. No entanto, como humanos, podemos achar difícil lembrar que o índice [0]
do array é o valor do ano } de 2016, o índice [1]
do array é um saudações , e o índice [2]
do array é um simples valor inteiro . A alternativa que teríamos então seria usar o que é chamado de matriz associativa . Uma matriz associativa tem algumas diferenças de a matriz Sequencial
( que é o que eram os casos anteriores desde que aumentaram o índice utilizado numa sequência pré-determinada, aumentando em 1 para cada valor seguinte ).
Diferenças ( entre uma matriz sequencial e associativa):
Durring the declaration of an Associative Array, you don't only include the
value
of what you want to put in the array, but you also put the index value( called thekey
) which you want to use ao chamar o array em partes posteriores do Código. A seguinte sintaxe é usada durante a sua declaração:"key" => "value"
.Ao usar a matriz associativa, o valor
key
seria então colocado dentro do índice da matriz para obter o desejadovalue
.
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 que antes, o valor key
seria usado no índice de matrizes:
echo $myArray1["Greetings"];// output: hello
echo $myArray2["Greetings"];// output: hello
echo $myArray3["Greetings"];// output: hello
PONTO FINAL:
Então ... a partir do exemplo acima, é muito fácil de ver que o=>
símbolo é usado para expressar a relação de uma Matriz Associativa entre cada um dos key
e value
pares em uma matriz DURANTE a a iniciação dos valores dentro da matriz.
Pergunta:
O que significa" e " aqui em PHP?Operador de PHP"&"
Torna a vida mais fácil quando nos habituamos..& normalmente verifica os bits que são definidos em $A e $b são definidos.
Já reparaste como estas 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);
Por trás de tudo acima está o jogo do operador bitwise e bits.
Um caso útil destes é configurações fáceis. como dar abaixo, para que um único campo inteiro possa armazenar milhares de combos para você.
A maioria das pessoas já leu os documentos, mas não reliase o caso de Uso do mundo real destes operadores bitwise.
Exemplo de que você vai amar {[[12]}
<?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
<?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
Null Coalesce Operator php
O operador de coalescing nulo (??) foi adicionado ao PHP7 para o caso comum de necessidade de usar um ternário em conjunto com isset(). Devolve o seu primeiro operando se existir e não for nulo caso contrário devolve o seu segundo operando, como por exemplo:
$username = $_GET['user'] ?? 'nobody';
// This is equivalent to:
$username = isset($_GET['user']) ? $_GET['user'] : 'nobody';
==
é utilizado para verificar a igualdade sem considerando a variável tipo de dados
===
é utilizado para verificar a igualdade para ambos a variável valor* e **tipo de dados
Exemplo
$a = 5
if ($a == 5)
- irá avaliar para verdadeiroif ($a == '5')
- irá avaliar para true, porque ao comparar este valor php internamente converter esse valor string em inteiro e, em seguida, comparar ambos valoresif ($a === 5)
- irá avaliar para verdadeiroif ($a === '5')
- irá avaliar para falso, porque o valor é 5, mas este valor 5 não é um inteiro.
Operador de carvão nulo"??"(Adicionado em PHP 7)
Não é o nome mais pegajoso para um operador, mas PHP 7 traz o bastante útil coalesce null então eu pensei que eu iria compartilhar um exemplo.
Em PHP 5, já temos um operador ternário, que testa um valor, e depois retorna o segundo elemento se ele retorna verdadeiro e o terceiro se não:
echo $count ? $count : 10; // outputs 10
Há também uma abreviatura para o que permite saltar o segundo elemento se for o mesmo que o primeiro: echo. $ count ?: 10; // também produz 10
No PHP 7 nós adicionalmente temos o ?? operador que, em vez de indicar confusão extrema, que é como eu usaria normalmente dois pontos de interrogação juntos, em vez disso permite-nos acorrentar juntos uma cadeia de valores. Leitura da esquerda para a direita, o primeiro valor que existe e não é nulo é o valor que será devolvido.
// $a is not set
$b = 16;
echo $a ?? 2; // outputs 2
echo $a ?? $b ?? 7; // outputs 16
Esta construção é útil para dar prioridade a um ou mais valores provenientes talvez da entrada do utilizador ou existentes configuração, e cair de forma segura em um determinado padrão, se essa configuração estiver faltando. É uma espécie de pequeno recurso, mas é um que eu sei que vou estar usando assim que meus aplicativos Atualizar para PHP 7.
Aqui estão os nomes de todos os operadores de PHP (TOKEN).
Referência http://php.net/manual/en/tokens.php