Operadores são usados ​​para operar valores. Eles podem ser agrupados em cinco tipos: aritméticos, de atribuição, de comparação, lógicos e operadores bit a bit.

Os operadores aritméticos

Os operadores aritméticos incluem as quatro operações básicas, assim como o operador módulo (%) que é usado para obter o resto da divisão.

<?php
    $x = 4 + 2; // 6  adição
    $x = 4 - 2; // 2  subtração
    $x = 4 * 2; // 8  multiplicação
    $x = 4 / 2; // 2  divisão
    $x = 4 % 2; // 0  modulo (Resto da divisão)
?>

Operadores de atribuição

O segundo grupo é os operadores de atribuição. Mais importante ainda, o operador de atribuição (=) em si, o que atribui um valor a uma variável.

<?php
    $x = 4;
    $variavel = 200;
?>

Operadores de atribuição combinados

Um uso comum dos operadores de atribuição e aritméticos é operar em uma variável e, em seguida, salvar o resultado de volta para essa mesma variável. Estas operações podem ser encurtado com os operadores de atribuição combinados.

<?php
    $x  =     0;
    $x  += 5; // é o mesmo que $x = $x + 5;
    $x  -= 5; // é o mesmo que $x = $x - 5;
    $x  *= 5; // é o mesmo que $x = $x * 5;
    $x  /= 5; // é o mesmo que $x = $x / 5;
    $x  %= 5; // é o mesmo que $x = $x % 5;
?>

Operadores de incremento e decremento

Outra operação comum é para aumentar ou diminuir uma variável em um. Isso pode ser simplificado com o incremento (++) e decremento (--) operadores.

<?php
    $x++ ; // é o mesmo que $x += 1;
    $x-- ; // é o mesmo que $x -= 1;
?>

Ambos os operadores podem ser utilizados antes ou depois de uma variável.

<?php
    $x++; // pós-incremento
    $x−−; // pós-decremento
    ++$x; // pré-incremento
    −−$x; // pré-decremento
?>

O resultado sobre a variável é o mesmo o que é usado. A diferença é que o pós-operador retorna o valor original antes que altera a variável, enquanto que o pré-operador muda a primeira variável e, em seguida, devolve o valor.

<?php
    $x = 5;  $y = $x++; // $x=6,  $y=5
    $x = 5;  $y = ++$x; // $x=6,  $y=6
?>

Os operadores de comparação

Os operadores de comparação comparam dois valores e retornar verdadeiro(true) ou falso(false) como resultado. Eles são usados ​​principalmente para especificar condições, que são expressões que resultam em verdadeiras ou falsas.

<?php
    $x = (2 == 3);   // false // igual
    $x = (2 != 3);  // true // não igual
    $x = (2 <> 3); // true // não igual (alternativo)
    $x = (2 === 3);  // false // Idêntico
    $x = (2 !== 3); // true  // diferente
    $x = (2 > 3);  // false // maior do que
    $x = (2 < 3);     // true  // menor que
    $x = (2 >= 3);   // false // maior e igual a
    $x = (2 <= 3);  // true  // menor e igual a
?>

O operador idêntico (===) é utilizado para comparar o valor e o tipo de dados dos operandos. Ela retorna verdadeiro se ambos os operadores têm o mesmo valor e são do mesmo tipo. Da mesma forma, o operador não idênticos (!==) Retorna true se os operandos não tem o mesmo valor ou não são do mesmo tipo. Dito de outra forma, os operadores de igualdade irá realizar conversões de tipo, enquanto os operadores idênticos não.

<?php
    $x = (1 == "1");   // true (algum valor)
    $x = (1 === "1"); // false (tipos diferentes)
?>

Os operadores lógicos

Os operadores lógicos são muitas vezes utilizados em conjunto com os operadores de comparação. O valor lógico “e” (&&) avalia como verdadeiro se ambos os lados esquerdo e direito são verdadeiras, e lógico “ou” ( || ) avalia como verdadeiro se tanto o lado esquerdo ou direito é verdade. O não operador lógico ( ! ) É usado para inverter um resultado booleano. Note que tanto para o " ‘e’ lógico" e " ‘ou’ lógico" no lado direito do operador não será avaliado se o resultado já é determinado pelo lado esquerdo.

<?php
    $x = (true && false);  // false // E lógico(AND)
    $x = (true || false); // true  // OU Lógico (OR)
    $x = !(true);        // false // negação lógico
?>

Operadores bit a bit

Os operadores bit a bit pode manipular dígitos binários de números. Por exemplo, o operador XOR ( ^ ) liga os bits que são definidos em um lado do operador, mas não em ambos os lados.

<?php
    $x = 5 & 4;      // 101 & 100 = 100 (4) // AND
    $x = 5 | 4;     // 101 | 100 = 101 (5) // OR
    $x = 5 ^ 4;    // 101 ^ 100 = 001 (1) // XOR (OU Exclusivo)
    $x = 4 << 1;  // 100 << 1 =1000 (8)  // Deslocamento a Esquerda
    $x = 4 >> 1; // 100 >> 1 = 10 (2)   // Deslocamento a Direito
    $x = ~4;    // ~00000100 = 11111011 (-5) // Inverter
?>

Estes operadores bit a bit têm operadores de atribuição de taquigrafia, assim como os operadores aritméticos.

<?php
    $x=5; $x &= 4;  // 101 & 100 = 100 (4) // AND
    $x=5; $x |= 4; // 101 | 100 = 101 (5) // OR
    $x=5; $x ^= 4;    // 101 ^ 100 = 001 (1) // XOR
    $x=5; $x <<= 1;  // 101 << 1 =1010 (10) // Descolamento a Esquerda
    $x=5; $x >>= 1; // 101 >> 1 = 10 (2)   // Deslocamento a Direita

?>

 Operador precedência

No PHP, as expressões são normalmente avaliadas da esquerda para a direita. No entanto, quando uma expressão contém vários operadores, a precedência dos operadores determina a ordem em que eles são avaliados.

Por exemplo, lógica e (&&) liga-se no mais fraco dos operadores relacionais, que por sua vez se liga mais fraco dos operadores aritméticos.

<?php
    $x = 2+3 > 1*4   &&   5/5 == 1;   // true
?>

Para tornar as coisas mais claras, parênteses podem ser usados ​​para especificar qual parte da expressão será avaliada primeiro. Parênteses têm a mais alta precedência de todos os operadores.

<?php
    $x = ((2+3) > (1*4))  && ((5/5) == 1);  // true
?>

Operadores lógicos adicionais

Na tabela de precedência, uma observação especial dos últimos três operadores: AND, OR e XOR. Os operadores AND e OR trabalham da mesma forma como os lógicos && e ||. A única diferença é o seu menor nível de precedência.

<?php
    // Mesmo que: $a = (true && false);
    $a = true && false; // $a is false
    
    // Mesmo que: ($a = true) and false;
    $a = true and false; // $a is true
?>

O operador XOR é uma versão booleana do bit a bit, com operador “ ^  “. Ele avalia como verdadeiro se apenas um dos operandos são verdadeiras.

<?php
    $a = (true xor true); // false
?>

Link Importante

Visão geral de operadores : http://php.net/manual/pt_BR/language.operators.php

Dúvidas? Comente!

No tutorial de Operadores no PHP você pode ver que é simples e não há mistério, pra quem faz algum curso acadêmico em Computação terá mais facilidade para entender os Operadores Lógicos, mas se você não conhece, pesquise e estude, pois é importante!