Operadores PHP

Um operador recebe um ou mais valores (chamados de operandos) e produz um novo valor a partir deles. Os operadores são os blocos fundamentais de toda expressão escrita em PHP — eles permitem realizar operações aritméticas, comparar valores, combinar condições booleanas, atribuir resultados a variáveis e concatenar strings.

Este capítulo aborda todas as categorias de operadores PHP com exemplos executáveis: aritméticos, de atribuição, de comparação, lógicos, de incremento/decremento, de string, de array, o operador nave espacial, o operador null-coalescing e como a precedência dos operadores determina a ordem de avaliação.

Operadores Aritméticos

Os operadores aritméticos realizam as operações matemáticas habituais em números.

<?php
$x = 10;
$y = 3;

echo $x + $y;   // 13
echo $x - $y;   // 7
echo $x * $y;   // 30
echo $x / $y;   // 3.3333333333333
echo $x % $y;   // 1   (remainder of 10 / 3)
echo $x ** $y;  // 1000 (10 to the power of 3)

Nota: Ao contrário de muitas linguagens, o / do PHP não trunca. 10 / 4 é 2.5, não 2. Use intdiv() para divisão inteira. O operador % funciona com inteiros; para restos com ponto flutuante, use fmod().

Operadores de Atribuição

O operador de atribuição básico é = — ele armazena o valor à direita na variável à esquerda. Cada operador aritmético também possui uma forma combinada (composta) que atualiza uma variável no lugar.

<?php
$total = 100;
$total += 20;  // 120
$total -= 50;  // 70
$total *= 2;   // 140
echo $total;   // 140

Operadores de Comparação

Os operadores de comparação comparam dois valores e retornam um boolean (true ou false). Observe a distinção importante entre comparação fraca (==) e estrita (===).

<?php
var_dump(10 == "10");   // bool(true)  — values match after juggling
var_dump(10 === "10");  // bool(false) — int vs string, types differ
var_dump(5 != 8);       // bool(true)
var_dump(5 >= 5);       // bool(true)

Atenção: Prefira === quando se importa com os tipos. 0 == "abc" é false no PHP moderno (8.0+), mas a comparação fraca ainda tem casos inesperados — a comparação estrita os evita.

O operador nave espacial <=>

O operador nave espacial compara dois valores e retorna -1, 0 ou 1. É mais útil como valor de retorno de um callback de ordenação.

<?php
echo 1 <=> 2;   // -1  (left is smaller)
echo 2 <=> 2;   //  0  (equal)
echo 3 <=> 2;   //  1  (left is larger)

Operadores Lógicos

Os operadores lógicos combinam expressões booleanas, normalmente dentro de condições if.

<?php
$age = 25;
$hasLicense = true;

var_dump($age >= 18 && $hasLicense);  // bool(true)
var_dump($age < 18 || $hasLicense);   // bool(true)
var_dump(!$hasLicense);               // bool(false)

&& e and se comportam da mesma forma em condições, mas têm precedências diferentes — and/or ligam mais frouxamente do que =, o que pode surpreender. Prefira && e ||.

O PHP também realiza curto-circuito: em $a && expensive(), se $a for false, o lado direito nunca é avaliado.

Operadores de Incremento e Decremento

Esses operadores adicionam ou subtraem 1 de uma variável. Sua posição (pré ou pós) muda o que a expressão avalia.

<?php
$x = 5;
echo $x++;  // 5  (prints old value, then $x becomes 6)
echo $x;    // 6
echo ++$x;  // 7  (increments first, then prints)

Operadores de String

O PHP tem dois operadores dedicados a strings:

• . — o operador de concatenação, une duas strings.
• .= — o operador de atribuição por concatenação, acrescenta à variável.

<?php
$greeting = "Hello";
$greeting .= ", World!";   // append
echo $greeting;            // Hello, World!
echo "PHP" . " " . "rocks"; // PHP rocks

Operadores de Array

Os operadores de array funcionam em arrays inteiros.

<?php
$a = ["a" => 1, "b" => 2];
$b = ["b" => 99, "c" => 3];

print_r($a + $b);
// Array ( [a] => 1 [b] => 2 [c] => 3 )
// "b" keeps the LEFT value (2), "c" is added

Operador Null-Coalescing ??

O operador ?? retorna o operando esquerdo se ele existir e não for null, caso contrário retorna o operando direito. É o substituto elegante para verificações com isset().

<?php
$data = ["name" => "Ann"];

$name = $data["name"] ?? "Guest";  // "Ann"
$role = $data["role"] ?? "Member"; // "Member" — key missing, no warning
echo "$name / $role";              // Ann / Member

A atribuição null-coalescing ??= atribui apenas quando a variável é atualmente null ou não está definida: $config["theme"] ??= "dark";.

Precedência dos Operadores

Quando uma expressão mistura operadores, a precedência decide qual é executado primeiro, assim como na matemática (* antes de +). Use parênteses para tornar a intenção explícita e sobrescrever os padrões.

<?php
echo 2 + 3 * 4;     // 14  — * binds tighter than +
echo (2 + 3) * 4;   // 20  — parentheses force addition first

Do maior para o menor, alguns níveis-chave: **, depois !, depois * / %, depois + -, depois comparação (< > == ===), depois &&, depois ||, e finalmente =. Na dúvida, adicione parênteses — eles não custam nada e previnem bugs.

Resumo

• Aritméticos (+ - * / % **) operam sobre números; / retorna um float, % retorna o resto.
• Atribuição (= += .= …) armazena e atualiza valores; as formas compostas são abreviações.
• Comparação (== === != <=>) retorna booleanos — prefira === estrito para evitar surpresas de conversão de tipos.
• Lógicos (&& || !) combinam condições e realizam curto-circuito.
• Incremento/decremento (++ --) diferem pela posição pré/pós.
• String (. .=) une textos; array (+ == ===) compara e mescla arrays.
• ?? fornece valores padrão para valores ausentes; precedência e parênteses controlam a ordem de avaliação.

Em seguida, coloque esses operadores em prática dentro de instruções condicionais e loops.

Prática