Precedência de Operadores

    A precedência de um operador especifica quem tem mais prioridade quando há duas delas juntas. Por exemplo, na expressão 1 + 5 * 3, a resposta é 16 e não 18 porque o operador de multiplicação ("*") tem prioridade de precedência que o operador de adição ("+"). Parênteses podem ser utilizados para forçar a precedência, se necessário. Assim, (1 + 5) * 3 é avaliado como 18.

    Quando operadores têm precedência igual a associatividade decide como os operadores são agrupados. Por exemplo "-" é associado à esquerda, de forma que 1 - 2 - 3 é agrupado como (1 - 2) - 3 e resulta em -4. "=" por outro lado associa para a direita, de forma que $a = $b = $c é agrupado como $a = ($b = $c).

    Operadores de igual precedência e associatividade não podem ser utilizados uns próximos aos outros. Por exemplo 1 < 2 > 1 é ilegal no PHP. A expressão 1 <= 1 == 1 por outro lado é válida, porque o operador == tem menor precedência que o operador <=.

    A associatividade somente faz sentido para operadores binários e ternários. Operadores unários são precedentes ou seguintes, de forma que essa outra noção não se aplica. Por exemplo !!$a somente pode ser agrupado como !(!$a).

    O uso de parênteses, embora não estritamente necessário, pode melhorar a leitura do código ao deixar o agrupamento explícito em vez de depender da associatividade e precedências implícitos.

    A tabela seguinte mostra a precedência dos operadores, com a maior precedência no começo. Operadores com a mesma precedência estão na mesma linha, nesses casos a associatividade deles decidirá qual ordem eles serão avaliados.

    Precedência dos operadores
    Associação Operadores Informação Adicional
    (não aplicável) clone new clone e new
    direita ** aritmética
    (não aplicável) + - ++ -- ~ (int) (float) (string) (array) (object) (bool) @ aritméticos (unário + e -), incremento/decremento, bitwise, type cast e controle de erro
    esquerda instanceof tipos
    (não aplicável) ! lógicos
    esquerda * / % aritmética
    esquerda + - . aritmética (binário + e -), array e string (. anteriormente ao PHP 8.0.0)
    esquerda << >> bits
    left . string (desde o PHP 8.0.0)
    não associativo < <= > >= comparação
    não associativo == != === !== <> <=> comparação
    esquerda & bits e referências
    esquerda ^ bits
    esquerda | bits
    esquerda && lógicos
    esquerda || lógicos
    direita ?? null coalescing
    não associativo ? : ternário (esquerda anteriormente ao PHP 8.0.0)
    direita = += -= *= **= /= .= %= &= |= ^= <<= >>= ??= atribuição
    (não aplicável) yield from yield from
    (não aplicável) yield yield
    (não aplicável) print print
    esquerda and lógicos
    esquerda xor lógicos
    esquerda or lógicos

    Exemplo #1 Associação

    <?php
    $a     = 3 * 3 % 5; // (3 * 3) % 5 = 4
    var_dump($a);

    $a = 1;
    $b = 2;
    $a = $b += 3; // $a = ($b += 3) -> $a = 5, $b = 5
    var_dump($a, $b);
    ?>

    O operador ternário requer especificamente o uso de parênteses para remover a ambiguidade de precedência.

    Exemplo #2 Precedência explícita

    <?php
    $a     = true ? 0 : (true ? 1 : 2);
    var_dump($a);

    // isto não é permitido desde o PHP 8
    // $a = true ? 0 : true ? 1 : 2;
    ?>

    A precedência e associatividade apenas determinam como as expressões são agrupadas, mas não especificam a ordem de avaliação. O PHP (geralmente) não especifica em que ordem as expressões são avaliadas, então códigos que assumem ordens específicas de avaliação devem ser evitados porque o comportamento pode ser alterado entre versões do PHP ou dependendo do código em volta.

    Exemplo #3 Ordem de avaliação não definida

    <?php
    $a     = 1;
    echo     $a + $a++; // pode exibir 2 ou 3

    $i = 1;
    $array[$i] = $i++; // pode definir o índice 1 ou 2
    ?>

    Exemplo #4 Precedência de +, - e .

    <?php
    $x     = 4;
    // esta linha pode resultar em uma saída inesperada:
    echo "x menos um é igual a " . $x-1 . ", ou assim eu espero\n";

    // a precedência desejada pode ser aplicada utilizando parênteses:
    echo "x menos um é igual a " . ($x-1) . ", ou assim eu espero\n";

    // isto não é permitido e lança um TypeError:
    echo (("x menos um é igual a " . $x) - 1) . ", ou assim eu espero\n";
    ?>

    O exemplo acima produzirá:

    -1, ou assim eu espero
-1, ou assim eu espero
Fatal error: Uncaught TypeError: Unsupported operand types: string - int

    Exemplo #5 Antes do PHP 8, +, - e . tinham a mesma precedência

    <?php
    $x     = 4;
    // this line might result in unexpected output:
    echo "x menos um é igual a " . $x-1 . ", ou assim eu espero\n";

    // porque é avaliada como esta linha (antes do PHP 8.0.0):
    echo (("x menos um é igual a " . $x) - 1) . ", ou assim eu espero\n";

    // a precedência desejada pode ser aplicada utilizando parênteses:
    echo "x menos um é igual a " . ($x-1) . ", ou assim eu espero\n";
    ?>

    O exemplo acima produzirá:

    -1, ou assim eu espero
-1, ou assim eu espero
x menos um é igual a 3, ou assim eu espero

    Nota:

    Embora o = tenha uma precedência menor que a maioria dos operadores, o PHP ainda permite expressões similares a if (!$a = foo()), onde o valor retornado de foo() é colocado em $a.

    Registro de Alterações

    Versão Descrição
    8.0.0 Concatenação de strings (.) tem uma precedência menor que adição/subtração (+ e -) e shift de bits à esquerda/direita (<< e >>); anteriormente ele tinha a mesma precedência que + e - uma precedência maior que << e >>.
    8.0.0 O operador ternário (? :) agora é não associativo; anteriormente associava a esquerda.
    7.4.0 Depender da precedência da concatenação de strings (.) em relação à adição/subtração (+ ou -) ou shift de bits a esquerda/direta (<< ou >>), ou seja, os usar numa mesma expressão, foi descontinuado.
    7.4.0 Depender da associatividade à esquerda do operador ternário (? :), ou seja, o utilizar em várias expressões sem parênteses, foi descontinuado.

    Melhore Esta Página

    Aprenda Como Melhorar Esta Página • Envie uma Solicitação de Modificação • Reporte um Problema
    ＋adicione uma nota

    Notas Enviadas por Usuários (em inglês) 8 notes

    up
    241
    fabmlk
    9 years ago
    Watch out for the difference of priority between 'and vs &&' or '|| vs or':
    <?php
    $bool     = true && false;
    var_dump($bool); // false, that's expected

    $bool = true and false;
    var_dump($bool); // true, ouch!
    ?>
    Because 'and/or' have lower priority than '=' but '||/&&' have higher.
    up
    48
    aaronw at catalyst dot net dot nz
    7 years ago
    If you've come here looking for a full list of PHP operators, take note that the table here is *not* complete. There are some additional operators (or operator-ish punctuation tokens) that are not included here, such as "->", "::", and "...".

    For a really comprehensive list, take a look at the "List of Parser Tokens" page: http://php.net/manual/en/tokens.php
    up
    8
    rvwoens at gmail dot com
    2 years ago
    Note that ?? has a low priority, so this can lead to unexpected results:

    $a=[];
    $a['aa']??'not set'
    --> not set (as expected)

    but
    "lets see if it is set".$a['aa']??'not set'
    --> notice; undefined index aa
    --> lets see if it is set

    so you need to use parenthesis
    "lets see if it is set".($a['aa']??'not set')
    up
    53
    Carsten Milkau
    12 years ago
    Beware the unusual order of bit-wise operators and comparison operators, this has often lead to bugs in my experience. For instance:

    <?php if ( $flags & MASK == 1) do_something(); ?>

    will not do what you might expect from other languages. Use

    <?php if (($flags & MASK) == 1) do_something(); ?>

    in PHP instead.
    up
    6
    tlili dot mokhtar at gmail dot com
    3 years ago
    An easy trick to get the result of the left shift operation (<<), e.g.

    15 << 2 = 15 * (2*2) = 60

    15 << 3 = 15 * (2*2*2) = 120

    15 << 5 = 15 * (2*2*2*2*2) = 480

    and so on...

    So it's:

    (number on left) multiplied by (number on right) times 2.

    The same goes for the right shift operator (>>), where:

    (number on left) divided by (number on right) times 2 e.g.

    15 >> 2 = (15/2)/2 = 7/2 = 3 (use floor values if result is in decimals).

    35 >> 3 = (((35/2)/2)/2 = (17/2)/2 = 8/2 = 4
    up
    5
    sangala at seznam dot cz
    2 years ago
    Using cast and ternary operator can be unclear,
    (Useful to know with: declare(strict_types = 1) ).
    <?php
    $num_str    ="5";

    $i1 = (int) isset($num_str) ? $num_str : 0;
    $i2 = (int) (isset($num_str) ? $num_str : 0);
    var_dump($i1);
    var_dump($i2);
    ?>
    Output:
    string(1) "5"
    int(5)
    up
    12
    ivan at dilber dot info
    8 years ago
    <?php
    // Another tricky thing here is using && or || with ternary ?:
    $x && $y ? $a : $b; // ($x && $y) ? $a : $b;

    // while:
    $x and $y ? $a : $b; // $x and ($y ? $a : $b);

    ?>
    up
    2
    instatiendaweb at gmail dot com
    4 years ago
    //incorrect
    $a = true ? 0 : true ? 1 : 2; // (true ? 0 : true) ? 1 : 2 = 2
    //Unparenthesized `a ? b : c ? d : e` is not supported. Use either `(a ? b : c) ? d : e` or `a ? b : (c ? d : e)`
    //correct
    $a = (true ? 0 : true) ? 1 : 2; // (true ? 0 : true) ? 1 : 2 = 2

    ==> correction documentation.
    ＋adicione uma nota
    To Top