PHP的運算符優(yōu)先級和結(jié)合性決定了表達(dá)式的求值順序，正確理解可避免隱蔽bug；1. 優(yōu)先級高的運算符先執(zhí)行，如算術(shù)運算中乘除高於加減；2. 相同優(yōu)先級時按結(jié)合性左或右結(jié)合，如減法左結(jié)合、賦值右結(jié)合；3. 括號()優(yōu)先級最高，應(yīng)多用以明確意圖；4. 字符串連接. 優(yōu)先於比較，需括號避免誤判；5. 邏輯運算&& || 優(yōu)先級高於and or，混用易出錯；6. 自PHP 7.4起三元運算?:改為右結(jié)合，更符合直覺；7. 建議優(yōu)先使用&&和||，複雜表達(dá)式拆分並用工具檢查，括號提升可讀性與安全性。

PHP's operator precedence and associativity rules are like the grammar of a language—they dictate how expressions are interpreted when parentheses aren't present. While they may seem like a minor detail, misunderstanding them can lead to subtle bugs and unexpected behavior. Let's break down how PHP handles operator precedence and associativity in a practical, developer-friendly way.

What Are Operator Precedence and Associativity?

Operator precedence determines which operations are performed first in an expression with multiple operators. For example, in 2 3 * 4 , multiplication has higher precedence than addition, so it's evaluated as 2 (3 * 4) = 14 , not (2 3) * 4 = 20 .

Associativity comes into play when operators of the same precedence appear in sequence. It defines whether evaluation happens left-to-right or right-to-left. For instance, subtraction is left-associative: 10 - 5 - 2 is (10 - 5) - 2 = 3 , not 10 - (5 - 2) = 7 .

PHP has a well-defined hierarchy of 18 levels of precedence and specific associativity rules for each operator group.

Key Precedence Levels You Should Know

While PHP's full precedence table is extensive, here are the most commonly encountered operators, ordered from highest to lowest precedence:

• Parentheses () – Always highest; use them to override default rules.
• Unary operators – ! , , -- , (as in $a ), - (as in -$a )
• Arithmetic – * , / , % (higher), then , - (lower)
• String concatenation – The . operator (often surprises developers!)
• Comparison operators – , <code>> , , <code>>= , == , != , === , !==
• Logical operators – && , || , but also the lower-precedence and , or
• Ternary operator – ?: (left-associative in older PHP versions, right-associative as of PHP 7.4 )
• Assignment operators – = , = , .= , etc. (right-associative)

One common pitfall: many assume and and && have the same precedence, but they don't.

 // This may not work as expected:
$bool = true && false;
$result = $bool or true; // Equivalent to: ($result = $bool) or true;

Here, = has higher precedence than or , so $result gets assigned true && false → false , and then the or is evaluated but doesn't affect $result . To fix:

 $result = ($bool or true); // Use parentheses
// Or better yet, stick with && and ||

Watch Out for String Concatenation and Comparison

The . operator has higher precedence than most comparison operators, which can trip you up:

 echo "Hello " . $user == "Admin" ? "Welcome!" : "Guest";

This doesn't do what it looks like. It parses as:

 echo (("Hello " . $user) == "Admin") ? "Welcome!" : "Guest";

So you're comparing the concatenated string "Hello John" to "Admin" —which will always be false unless the user is literally named "Admin" and the string is exactly "Hello Admin" .

Instead, use parentheses:

 echo "Hello " . ($user == "Admin" ? "Welcome!" : "Guest");

Logical Operator Precedence Gotchas

PHP has two sets of logical operators with different precedence:

• && and || – higher precedence
• and and or – lower precedence

This leads to confusing results:

 $a = true and false;
var_dump($a); // true — because it's parsed as ($a = true) and false

The assignment happens first due to precedence, so $a becomes true , and the and false doesn't reassign it.

Use && and || for logical operations unless you're intentionally relying on low precedence for control flow (rare).

Ternary Operator Changes in PHP 7.4

Before PHP 7.4, nested ternary expressions were left-associative, leading to confusing outcomes:

 echo $a ? $a : $b ? $b : $c;

In PHP < 7.4: this was (($a ? $a : $b) ? $b : $c)
In PHP >= 7.4: it's $a ? $a : ($b ? $b : $c) — much more intuitive.

Best practice? Use parentheses for clarity:

 echo $a ? $a : ($b ? $b : $c);

Practical Tips for Avoiding Precedence Bugs

• Use parentheses liberally — they make intent clear and override precedence safely.
• Prefer && and || over and and or — unless you're doing control flow like:

   do_this() or die('Failed');

• Break complex expressions into smaller ones — improves readability and reduces bugs.
• Use static analysis tools — PHPStan or Psalm can flag ambiguous expressions.

---

Basically, PHP's operator rules are predictable once you know them, but they're full of traps for the unwary. When in doubt, parenthesize. It's not laziness—it's clarity.

以上是導(dǎo)航PHP操作員優(yōu)先級和關(guān)聯(lián)的迷宮的詳細(xì)內(nèi)容。更多資訊請關(guān)注PHP中文網(wǎng)其他相關(guān)文章！