Operador Bitwise

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

_ 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).

Origem

<=> 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;
    }
});

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

Resposta:

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

Elaboração:

$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

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

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

Pergunta:

Operador de PHP"&"

& 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

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

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

2. if ($a == '5') - irá avaliar para true, porque ao comparar este valor php internamente converter esse valor string em inteiro e, em seguida, comparar ambos valores

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

4. if ($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

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