Objetivos
        
    
    
    
        
Operadores
    
    
        
            
                Para declararmos expressões em qualquer linguagem de programação precisamos utilizar 
                os operadores. Os conceitos de expressões e operadores já foram vistos em 
                Portugol: Expressões e Operadores e 
                Tutorial C: Operadores. Em caso de dúvida é recomendado a leitura.
            
            
                A linguagem PHP fornece recurso para criarmos expressões dos tipos aritméticas, 
                lógicas e relacionais e bit-a-bit. Nesta seção, vamos discutir sobre os operadores 
                que são utilizados para criar expressões.
            
            
                Os operadores de strings e vetor(array) serão vistos em 
                PHP Básico: String e 
                PHP Básico: Vetor.
            
         
     
    
    
        
            
                Para atribuirmos valores a variáveis e constantes, PHP utiliza a tabela de operadores 
                de atribuição abaixo:
            
            
                Tab. 1: Operadores de atribuição
                
                    
                        | Operador | 
                        Descrição | 
                        Exemplo | 
                    
                
                
                    
                        | = | 
                        Atribuição | 
                        $a=$b | 
                    
                    
                        | += | 
                        Atribuição acumulativa de adição | 
                        $a+=$b | 
                    
                    
                        | -= | 
                        Atribuição acumulativa de subtração | 
                        $a-=$b | 
                    
                    
                        | *= | 
                        Atribuição acumulativa de multiplicação | 
                        $a*=$b | 
                    
                    
                        | %= | 
                        Atribuição acumulativa de Módulo | 
                        $a%=$b | 
                    
                    
                        | /= | 
                        Atribuição acumulativa de divisão | 
                        $a%=$b | 
                    
                    
                        ??= | 
                        - | 
                        $a??=$b | 
                    
                
            
            Sintaxe
            $variavel1|valor operador $variavel2|valor2
$variavel1 operador= $variavel2
            Exemplo 1
            
//main.php
<?php
  $a = 4;
  $b = 2;
  printf("%d\n",$a += $b );
  printf("%d\n",$a -= $b );
  printf("%d\n",$a *= $b );
  printf("%d\n",$a /= $b );
  printf("%d\n",$a += $b );
  printf("%d\n",$a %= $b );
?>
            Saída
            
6
4
8
4
6
0
         
     
    
    
        
            
                Para criação de expressões aritméticas utilizamos os operadores abaixo suportados 
                pela linguagem PHP:
            
         
     
    
        
            
                Tab. 2: Operadores Aritméticos
                
                    
                        | Operador | 
                        Descrição | 
                        Exemplo | 
                    
                
                
                    
                        | + | 
                        Adição | 
                        $a+$b | 
                    
                    
                        | - | 
                        Subtração | 
                        $a-$b | 
                    
                    
                        | * | 
                        Multiplicação | 
                        $a*$b | 
                    
                    
                        | / | 
                        Divisão | 
                        $a/$b | 
                    
                    
                        | % | 
                        Módulo | 
                        $a%$b | 
                    
                    
                        | ++ | 
                        Incremento | 
                        ++$a , $a++ | 
                    
                    
                        | -- | 
                        Decremento | 
                        --$a, $a-- | 
                    
                    
                        | -(Unário) | 
                        Sinal | 
                        -$a | 
                    
                    
                        | +(Unário) | 
                        Sinal | 
                        +$a | 
                    
                    
                        | ** | 
                        Exponencial | 
                        $a**$b | 
                    
                
            
            Sintaxe
            $variavel1|valor operador $variavel2|valor2
operador_incremento$variavel
operador_decremento$variavel
$variaveloperador_incremento
$variaveloperador_decremento
            Exemplo 2
            
<?php
  $a = 4;
  $b = 2;
  printf("%d\n",$a + $b );
  printf("%d\n",$a - $b );
  printf("%d\n",$a * $b );
  printf("%d\n",$a / $b );
  printf("%d\n",$a + $b );
  printf("%d\n",$a % $b );
  printf("%d\n",--$a );
  printf("%d\n",++$b );
?>
            Saída
            
6
2
8
2
6
0
            
                Os operadores -- e ++ utilizados antes ou depois da variável são chamados pré incrementado e pós 
                incrementado. O funcionamento desses operadores foi dicutida quando operadores aritméticos foram estudados 
                em Portugol: Operadores aritméticos e 
                Tutorial C: Operadores aritméticos.
            
         
     
    
    
        
            
                A linguagem PHP fornece os seguintes operadores para que possamos usá-lo para tomada 
                de decisões baseados na comparação de expressões, variáveis ou valores. Esses 
                operadores retornam true(1) e false(0).
            
            
                Tab. 3: Operadores Relacionais
                
                    
                        | Operador | 
                        Descrição | 
                        Exemplo | 
                    
                
                
                    
                        | == | 
                        Igual | 
                        $a == $b | 
                    
                    
                        | >= | 
                        Maior ou igual | 
                        $a >= $b | 
                    
                    
                        | <= | 
                        Menor ou igual | 
                        $a <= $b | 
                    
                    
                        | != | 
                        Diferente | 
                        $a != $b | 
                    
                    
                        | > | 
                        Maior | 
                        $a > $b | 
                    
                    
                        | < | 
                        Menor | 
                        $a < $b | 
                    
                    
                        | === | 
                        $a == $b e tipos iguais | 
                        $a === $b | 
                    
                    
                        | !== | 
                        $a != $b e tipos diferentes | 
                        $a === $b | 
                    
                    
                        <=> | 
                        - | 
                        $a <==> $b | 
                    
                
            
            Sintaxe
            $variavel1|expressao1 operador $variavel2|expressao2
            Exemplo 3
            
//main.php
<?php
  $a = true; //1
  $b = false; //0
  printf("%d\n",$a >  $b );
  printf("%d\n",$a <  $b );
  printf("%d\n",$a >= $b );
  printf("%d\n",$a <= $b );
  printf("%d\n",$a == $b );
  printf("%d\n",$a != $b );
  printf("%d\n",$a === $b );
  printf("%d\n",$a !== $b );
?>
            Saída
            1
0
1
0
0
1
0
1
         
     
    
    
        
            
                Para entendermos sobre a aplicação dos operadores lógicos é importante entender sobre a tabela verdade 
                que foi explicado em 
                Portugol: Operadores Lógicos
                e Tutorial C: Operadores Lógicos.
            
            
                A criação de expressões lógicas é feita utilizando os operadores abaixo suportados
                por PHP:
            
            
                Tab. 4: Operadores lógicos
                
                    
                        | Operador | 
                        Significado | 
                        Exemplo | 
                    
                
                
                    
                        | and | 
                        E lógico | 
                        $a and $b | 
                    
                    
                        | or | 
                        OR lógico | 
                        $a or $b | 
                    
                    
                        | xor | 
                        OR-Excluivo lógico | 
                        $a or $b | 
                    
                    
                        | && | 
                        E lógico | 
                        $a && $b | 
                    
                    
                        | || | 
                        OR lógico | 
                        $a || $b | 
                    
                    
                        | ! | 
                        Não lógico | 
                        !a | 
                    
                
            
            
                Os operadores lógicos retornam um valor booleano true(1) ou false(0). Esse tipo de 
                operador é muito utilizado para tomada de decisão.
            
            Sintaxe
            $variavel1|expressao1 operador $variavel2|expressao2
            Exemplo 4
            
//main.php
<?php
  $a = true;
  $b = false;
  printf("%d\n",$a and $b );
  printf("%d\n",$a or $b );
  printf("%d\n",$a xor $b );
  printf("%d\n",$a && $b );
  printf("%d\n",$a || $b );
  printf("%d\n",!$a);
?>
            Saída
            0
1
1
0
1
0
            
            
         
     
    
        Operadores bit-a-bit/bitwise
        
     
    
        
            
                O uso dos operadores bit-a-bit já foi estudado em  
                Tutorial C: Operadores bit-a-bit . É importante 
                entender sobre as tabelas verdades que foram explicado em 
                Portugol: Operadores Lógicos.
            
            
                Os operadores bit-a-bit são operadores utilizados para trabalhar com manipulação 
                dos bits de variáveis. A linguagem PHP fornece os seguintes operadores:
            
            
                Tab. 5: Operadores bitwise
                
                    
                        | Operador | 
                        Descrição | 
                        Exemplo | 
                    
                
                
                    
                        | & | 
                        E bit-a-bit | 
                        $a & $b | 
                    
                    
                        | | | 
                        OR bit-a-bit | 
                        $a | $b | 
                    
                    
                        | ^ | 
                        Ou Exclusivo | 
                        $a ^ $b | 
                    
                    
                        | ~ | 
                        Não bit-a-bit | 
                        ~a | 
                    
                    
                        | >> | 
                        Desloca N bits à direita | 
                        $a >>$b | 
                    
                    
                        | << | 
                        Desloca N bits à esquerda | 
                        $a << b | 
                    
                
            
            Sintaxe
            $variavel1 operador $variavel1
$variavel|expressao << quantidade_bits
$variavel|expressao >> quantidade_bits
~$variavel|expressao
            Exemplo 5
            
//main.php
<?php
  $a = 2;
  $b = 1;
  printf("%b\n",$a & $b );
  printf("%b\n",$a| $b );
  printf("%b\n",$a ^ $b );
  printf("%b\n",(~$b)&2); //apenas 2 bits
  printf("%d\n",$a >> $b );
  printf("%d\n",$a << $b );
?>
            Saída
            0
11
11
10
1
4
         
     
    
    
        
            
                Todos os outros operadores listados na tabela abaixo estão entre os mais comuns 
                não categorizados e estudados acima. Outros operadores serão adicionados em futuras
                atualizações.
            
            
                Tab. 6: Outros operadores - Em construção
                
                    
                        | Operador | 
                        Descrição | 
                        Exemplo | 
                    
                
                
                    
                        | . | 
                        Concatenação | 
                        - | 
                    
                    
                        | ?: | 
                        if ternário | 
                        - | 
                    
                    
                        | -> | 
                        Acesso a membros | 
                        - | 
                    
                    
                        | ?? | 
                        Operador de nulidade | 
                        - | 
                    
                    
                        | => | 
                        Associação de valor, função | 
                        - | 
                    
                    
                        | yield | 
                        Retorna elemento de iterador | 
                        - | 
                    
                    
                        | yield from | 
                        - | 
                        - | 
                    
                    
                        | instanceof | 
                        - | 
                        - | 
                    
                    
                        | insteadof | 
                        - | 
                        - | 
                    
                    
                        | as | 
                        - | 
                        - | 
                    
                
            
            Exemplo 6
            
//main.php
<?php
$v = 100;
echo "string"."string"; //concatenação de string
echo "\n";
echo 1 > 0 ? "true" : "false"; //if ternário
echo "\n";
$fnc = fn($x) => $x*2; //=> expressão lambda
echo $fnc(2);
class ClassA{} //instanceof
$cls = new ClassA;
echo "\n";
echo $cls instanceof ClassA ? "true" : "false";
?>
            Saída
            stringstring
true
4
true
         
     
    
        Precedência de operadores
        
     
    
        
            
                O validação do uso dos operadores estudados acima seguem uma ordem ou precedência. A tabela abaixo resume essa precedência da mais alta até a mais baixa.
            
            
                Tab. 7: Precedência
                
                    
                        | Operador | 
                        Descrição | 
                    
                
                
                    
                        | clone new | 
                        - | 
                    
                    
                        | ** | 
                        aritmético | 
                    
                    
                        | + - ++ -- ~ (int) (float) (string) (array) (object) (bool) @ | 
                        (unário + e -), incremento/decremento, bitwise, casting  | 
                    
                    
                        | instanceof | 
                        tipo | 
                    
                    
                        | * / % | 
                        aritmético | 
                    
                    
                        | ! | 
                        lógico | 
                    
                    
                        | + - . | 
                        aritmético (binário + e -), vetor e string (< 8.0.0) | 
                    
                    
                        | << >> | 
                        bit-a-bit | 
                    
                    
                        | . | 
                        string ( 8.0.0) | 
                    
                    
                        | < <= > >= | 
                        comparação | 
                    
                    
                        | == != === !== <> <=> | 
                        comparação | 
                    
                    
                        | & | 
                        Deslocamento | 
                    
                    
                        | ^ | 
                        bit-a-bit | 
                    
                    
                        | | | 
                        bit-a-bit | 
                    
                    
                        | && | 
                        lógico | 
                    
                    
                        | || | 
                        lógico | 
                    
                    
                        | ?? | 
                        nulidade | 
                    
                    
                        | ?: | 
                        ternário | 
                    
                    
                        | = += -= *= **= /= .= %= &= |= ^= <<= >>= ??= | 
                        atribuição | 
                    
                    
                        | yield from | 
                        - | 
                    
                    
                        | yield | 
                        - | 
                    
                    
                        | print | 
                        - | 
                    
                    
                        | and | 
                        lógico | 
                    
                    
                        | xor | 
                        lógico | 
                    
                    
                        | or | 
                        lógico | 
                    
                
            
         
     
    
        Histórico de atualizações
        
     
    
        
            
                - 20/08/2025 - revisão 3 - Ajustes: pontuais, sintaxes e target de links internos; Adição: Ex.6
 
                - 21/09/2024 - revisão 2 - Correção em links portugol;ajustes gramaticais e outros
 
                - 05/02/2024 - revisão 1 - correção em navegação e erros gramaticais
 
                - 20/09/2023 - versão inicial
 
            
         
     
    
            
            
                
                    
                    Os cursos oferecidos nesta página são cursos fornecidos por parceiros. Ao comprar um curso clicando
                em seu banner, você está ajudando a manter o projeto TutorialDev vivo. Os sites dos cursos parceiros utilizam cookies.