3.8 运算符优先级

3.8 运算符优先级

Lua 运算符优先级详解：代码实践与深度解析

虽然通常我们说 Lua 运算符有大约八个优先级级别，但更精确地理解其分组和相对优先级关系能让你更清晰地掌握 Lua 的运算规则。本文将围绕这些优先级分组，通过丰富的代码示例和详细解释，让你彻底掌握 Lua 运算符的优先级。

文章结构：

1. 引言：运算符优先级的重要性

2. Lua 运算符优先级概述

3. 优先级级别详解与代码实践

   • 级别 1 (最高): 函数调用、表构造、索引访问、幂运算

   • 级别 2: 一元运算符 (not, #, -, ~)

   • 级别 3: 乘法、除法、取模

   • 级别 4: 加法、减法

   • 级别 5: 连接运算符 (..)

   • 级别 6: 关系运算符 (<, >, <=, >=, ==, ~=)

   • 级别 7: 逻辑与 (and)

   • 级别 8 (最低): 逻辑或 (or)

4. 括号的力量：显式控制运算顺序

5. 运算符结合性：相同优先级运算符的计算方向

6. 最佳实践：编写清晰易懂的表达式

7. 总结

1. 引言：运算符优先级的重要性

在任何编程语言中，表达式都由运算符和操作数组成。当一个表达式包含多个运算符时，运算符优先级就决定了哪些运算先执行，哪些运算后执行。如果对运算符优先级理解不足，就可能导致代码执行结果与预期不符，甚至产生难以调试的错误。

例如，考虑以下简单的数学表达式：

result = 2 + 3 * 4
​

如果不了解运算符优先级，你可能会从左到右计算，先算 2 + 3 得到 5，再算 5 * 4 得到 20。然而，根据数学和编程语言的通用规则，乘法运算符 * 的优先级高于加法运算符 +。因此，Lua 会先计算 3 * 4 得到 12，再计算 2 + 12 得到 14。所以 result 的正确值是 14。

Lua 运算符优先级规则确保了表达式计算的确定性和一致性。理解并掌握这些规则，能够帮助你：

• 编写正确无误的代码： 避免因运算顺序错误导致的逻辑错误。

• 提高代码可读性： 理解复杂的表达式，减少误读。

• 优化代码性能： 在某些情况下，运算符优先级可以影响代码的执行效率（虽然在 Lua 中影响较小，但良好的理解有助于编写更优的代码）。

2. Lua 运算符优先级概述

Lua 的运算符优先级可以大致归纳为以下几个级别（从高到低）：

注意：

• 最高优先级： 函数调用、表构造、索引访问等操作实际上拥有最高的优先级，它们先于上述表格中的所有运算符执行。

• 最低优先级： or 运算符的优先级最低。

• 结合性： 指的是当同一优先级的运算符连续出现时，运算的执行方向。左结合性从左到右计算，右结合性从右到左计算。

接下来，我们将逐级深入，结合代码示例，详细解释每个优先级级别的运算符，并进行实践。

3. 优先级级别详解与代码实践

级别 1 (最高): 函数调用、表构造、索引访问、幂运算

这一级别包含了 Lua 中优先级最高的几个操作：函数调用、表构造、索引访问以及幂运算。

函数调用 ()

函数调用拥有最高的优先级，这意味着在表达式中，函数调用会首先被执行。

function add(a, b)
  return a + b
end
result = add(2, 3) * 4  -- 先执行 add(2, 3)，结果为 5，再乘以 4
print(result)  --> 输出 20
​

在这个例子中，add(2, 3) 函数调用先被执行，返回结果 5，然后才将 5 与 4 相乘。

表构造 {}

表构造也具有高优先级，这意味着在表达式中，表会先被创建。

function get_table()
  return {1, 2, 3}
end
length = #{1, 2, 3} + 5  -- 先构造表 {1, 2, 3}，然后取长度 3，再加 5
print(length)  --> 输出 8
length2 = #get_table() + 5 -- 先执行 get_table() 返回表，再取长度，再加 5
print(length2) --> 输出 8
​

表构造 {1, 2, 3} 先被执行，创建了一个包含三个元素的表，然后 # 运算符计算表的长度，最后加 5。

索引访问 [] 和 .

索引访问（使用 [] 或 .）用于访问表中的元素，也具有高优先级。

local my_table = {name = "Lua", version = 5.4}
message = "Language: " .. my_table.name .. ", Version: " .. my_table["version"] -- 先访问表元素，再进行字符串连接
print(message) --> 输出 Language: Lua, Version: 5.4
function get_table_index(tbl, index)
  return tbl[index]
end
value = get_table_index(my_table, "name") .. " is fun!" -- 先函数调用，返回表，再索引访问，再字符串连接
print(value) --> 输出 Lua is fun!
​

在这个例子中，my_table.name 和 my_table["version"] 先被执行，获取表中的值，然后再进行字符串连接。

幂运算 ^

幂运算 ^ 用于计算一个数的指数幂，其优先级也较高，但低于函数调用、表构造和索引访问。 幂运算是右结合性的。

result1 = 2 ^ 3 * 4   -- 先计算 2^3 = 8，再乘以 4
print(result1) --> 输出 32
result2 = 2 ^ (3 * 4) -- 括号改变优先级，先计算 3*4=12, 再计算 2^12
print(result2) --> 输出 4096
result3 = 2 ^ 3 ^ 2  -- 幂运算是右结合性，等价于 2 ^ (3 ^ 2) = 2 ^ 9
print(result3) --> 输出 512
​

在 result1 中，幂运算 2 ^ 3 先执行，然后结果再乘以 4。result3 展示了幂运算的右结合性，2 ^ 3 ^ 2 等价于 2 ^ (3 ^ 2) 而不是 (2 ^ 3) ^ 2。

级别 2: 一元运算符 (not, #, -, ~)

一元运算符作用于单个操作数，包括逻辑非 not、长度运算符 #、负号 - 和位反运算符 ~。这些运算符的优先级低于上一级别，但高于后续级别的二元运算符。一元运算符是右结合性的。

逻辑非 not

not 运算符用于取反一个布尔值。

is_true = true
is_false = not is_true  -- 先执行 not is_true，结果为 false
print(is_false) --> 输出 false
result = not 10 > 5  -- 先计算 10 > 5 为 true，再执行 not true
print(result) --> 输出 false
​

not is_true 先执行，将 is_true 的值取反。在 result 的例子中，关系运算 10 > 5 先执行，得到 true，然后 not 运算符作用于 true。

长度运算符 #

# 运算符用于获取字符串或表的长度。

str_len = #"Hello" + 3  -- 先计算 #"Hello" = 5，再加 3
print(str_len) --> 输出 8
table_len = #{10, 20, 30} * 2 -- 先计算 #{10, 20, 30} = 3，再乘以 2
print(table_len) --> 输出 6
​

#"Hello" 和 #{10, 20, 30} 先被计算，得到字符串和表的长度，然后再进行加法和乘法运算。

负号 -

负号 - 用于取反一个数值。

negative_num = -5 + 10  -- 先计算 -5，再加 10
print(negative_num) --> 输出 5
result = -(2 + 3) * 4  -- 括号改变优先级，先计算 (2+3) = 5，再取负数 -5，最后乘以 4
print(result) --> 输出 -20
​

-5 先被计算，表示数值 -5。在 result 的例子中，括号改变了优先级，2 + 3 先被计算，然后负号运算符作用于结果 5。

位反运算符 ~

位反运算符 ~ 对整数进行按位取反操作。

bitwise_not = ~10 + 5  -- 先计算 ~10，再加 5
print(bitwise_not) --> 输出 -6  --  ~10 在二进制中是按位取反，结果是 -11，-11 + 5 = -6
result = ~(5 & 3) | 8  -- 位运算优先级高于位反， 先 5 & 3 = 1, 然后 ~1 = -2, 最后 -2 | 8 = 8
print(result) --> 输出 8
​

~10 先被计算，对整数 10 进行位反操作。在 result 的例子中，位与运算符 & 的优先级低于位反运算符，但因为有括号，所以 5 & 3 先被计算。

级别 3: 乘法、除法、取模 (*, /, %)

乘法 *、除法 / 和取模 % 运算符属于同一优先级级别。它们都低于一元运算符，但高于加减法和连接运算符。 它们是左结合性的。

乘法 *

product = 5 * 2 + 3  -- 先计算 5 * 2 = 10，再加 3
print(product) --> 输出 13
​

除法 /

quotient = 10 / 2 - 1  -- 先计算 10 / 2 = 5，再减 1
print(quotient) --> 输出 4
​

取模 %

remainder = 17 % 5 + 2 -- 先计算 17 % 5 = 2，再加 2
print(remainder) --> 输出 4
​

左结合性示例

result = 10 / 2 * 3  -- 左结合性，先计算 10 / 2 = 5，再计算 5 * 3
print(result) --> 输出 15
result2 = 10 * 2 / 5 -- 左结合性，先计算 10 * 2 = 20，再计算 20 / 5
print(result2) --> 输出 4
​

由于乘法和除法是左结合性的，10 / 2 * 3 从左到右计算，先除后乘。

级别 4: 加法、减法 (+, -)

加法 + 和减法 - 运算符优先级相同，低于乘除法和取模，但高于连接运算符和关系运算符。 它们是左结合性的。

加法 +

sum = 10 + 5 - 2  -- 先计算 10 + 5 = 15，再减 2
print(sum) --> 输出 13
​

减法 -

difference = 20 - 8 + 3 -- 先计算 20 - 8 = 12，再加 3
print(difference) --> 输出 15
​

与乘除法优先级比较

result = 2 + 3 * 4  -- 先乘法 3 * 4 = 12，再加法 2 + 12
print(result) --> 输出 14
result2 = (2 + 3) * 4 -- 括号改变优先级，先加法 2 + 3 = 5，再乘法 5 * 4
print(result2) --> 输出 20
​

可以看到，乘法优先级高于加法，因此在没有括号的情况下，乘法先执行。

级别 5: 连接运算符 (..)

连接运算符 .. 用于连接两个字符串。它的优先级低于加减法，但高于关系运算符和逻辑运算符。 它是左结合性的。

greeting = "Hello, " .. "World!" -- 连接两个字符串
print(greeting) --> 输出 Hello, World!
message = "The sum is: " .. 10 + 5 -- 先加法 10 + 5 = 15，再连接字符串
print(message) --> 输出 The sum is: 15
message2 = "The sum is: " .. (10 + 5) -- 括号改变优先级，仍然先加法，但更清晰
print(message2) --> 输出 The sum is: 15
message3 = "Number: " .. 10 .. 20 -- 左结合性，先连接 "Number: " 和 10, 再连接结果和 20
print(message3) --> 输出 Number: 1020
​

连接运算符 .. 将字符串连接起来。在 message 和 message2 的例子中，加法运算符 + 的优先级高于连接运算符，所以先执行加法运算，然后将数字结果转换为字符串并连接。

级别 6: 关系运算符 (<, >, <=, >=, ==, ~=)

关系运算符用于比较两个值，返回布尔值 true 或 false。它们包括：小于 <、大于 >、小于等于 <=、大于等于 >=、等于 == 和不等于 ~=。 关系运算符的优先级低于连接运算符，但高于逻辑运算符。 它们是左结合性的，但实际上关系运算符通常不会连续使用，所以结合性在实际应用中不太重要。

is_greater = 10 > 5  -- 比较 10 是否大于 5
print(is_greater) --> 输出 true
is_equal = "hello" == "hello" -- 比较字符串是否相等
print(is_equal) --> 输出 true
result = 5 + 3 > 10 - 2 -- 先加减法，再比较大小
print(result) --> 输出 false -- (8 > 8) 为 false
result2 = "abc" .. "def" == "abcdef" -- 先连接字符串，再比较相等
print(result2) --> 输出 true
​

关系运算符用于比较数值或字符串的大小或相等性。在 result 的例子中，先执行加减法，然后比较结果的大小。在 result2 的例子中，先连接字符串，然后比较连接后的字符串是否等于 "abcdef"。

级别 7: 逻辑与 (and)

逻辑与运算符 and 用于连接两个布尔表达式。只有当两个表达式都为 true 时，结果才为 true。 and 运算符的优先级低于关系运算符，但高于逻辑或运算符 or。 它是左结合性的。

condition1 = true
condition2 = false
result_and1 = condition1 and condition2  -- 逻辑与运算
print(result_and1) --> 输出 false
result_and2 = condition1 and true  -- 逻辑与运算
print(result_and2) --> 输出 true
result_compare_and = 10 > 5 and 3 < 7 -- 先关系运算，再逻辑与
print(result_compare_and) --> 输出 true -- (true and true) 为 true
​

and 运算符只有在左右两边的操作数都为真时才返回真。在 result_compare_and 的例子中，关系运算符的优先级高于 and，所以先进行比较运算，然后进行逻辑与运算。

级别 8 (最低): 逻辑或 (or)

逻辑或运算符 or 用于连接两个布尔表达式。只要两个表达式中至少有一个为 true，结果就为 true。 or 运算符的优先级最低，低于所有其他二元运算符。 它是左结合性的。

condition1 = true
condition2 = false
result_or1 = condition1 or condition2  -- 逻辑或运算
print(result_or1) --> 输出 true
result_or2 = false or false  -- 逻辑或运算
print(result_or2) --> 输出 false
result_and_or = false and true or true -- 先逻辑与，再逻辑或
print(result_and_or) --> 输出 true -- (false and true) 为 false, (false or true) 为 true
​

or 运算符只要左右两边的操作数有一个为真就返回真。在 result_and_or 的例子中，and 运算符的优先级高于 or，所以先计算 false and true 得到 false，然后再计算 false or true 得到 true。

4. 括号的力量：显式控制运算顺序

括号 () 是改变运算符优先级的利器。使用括号可以强制 Lua 优先计算括号内的表达式，无论括号内的运算符优先级多低。

result1 = (2 + 3) * 4  -- 括号强制先计算加法
print(result1) --> 输出 20
result2 = 2 + (3 * 4)  -- 括号虽然存在，但乘法优先级本来就高，所以结果与不加括号相同
print(result2) --> 输出 14
result3 = not (10 > 5 and 3 < 7) -- 括号强制先计算逻辑与
print(result3) --> 输出 false -- 先 (true and true) 为 true，再 not true 为 false
result4 = (not 10 > 5) and (3 < 7) -- 括号分别控制 not 和 关系运算的优先级，但最终结果与不加括号的 not 10 > 5 and 3 < 7 相同，因为 not 优先级高于 and
print(result4) --> 输出 false
​

括号可以清晰地表达复杂的运算顺序，提高代码的可读性。在编写复杂表达式时，即使运算符优先级符合预期，为了代码清晰易懂，也建议适当使用括号。

5. 运算符结合性：相同优先级运算符的计算方向

运算符结合性决定了当同一优先级的运算符连续出现时，运算的执行方向。Lua 的运算符结合性主要分为两种：

• 左结合性 (Left-associativity): 从左到右计算。例如：a op1 b op2 c 等价于 (a op1 b) op2 c

• 右结合性 (Right-associativity): 从右到左计算。例如：a op1 b op2 c 等价于 a op1 (b op2 c)

Lua 运算符结合性总结：

• 右结合性: 幂运算 ^，一元运算符 ( not, #, -, ~ )

• 左结合性: 其他所有二元运算符 ( *, /, %, +, -, .., <, >, <=, >=, ==, ~=, and, or )

左结合性示例 (加法和减法):

result = 10 - 5 + 2  -- 左结合性，等价于 (10 - 5) + 2
print(result) --> 输出 7
​

右结合性示例 (幂运算):

result = 2 ^ 3 ^ 2  -- 右结合性，等价于 2 ^ (3 ^ 2)
print(result) --> 输出 512
​

对于大多数运算符，尤其是算术运算符和逻辑运算符，左结合性是更符合直觉的计算方式。右结合性在幂运算和一元运算符中比较常见。理解结合性有助于理解连续相同优先级运算符的运算顺序。

6. 最佳实践：编写清晰易懂的表达式

掌握运算符优先级是编写正确代码的基础，但编写清晰易懂的代码同样重要。以下是一些最佳实践建议：

• 适度使用括号： 即使你很清楚运算符优先级，为了代码的可读性，也应该在复杂表达式中适度使用括号，明确运算顺序。这尤其在团队协作开发时非常重要，可以减少他人理解代码的成本。

• 避免过度复杂的表达式： 将复杂的表达式拆分成多个简单的语句，使用临时变量存储中间结果。这可以提高代码的可读性和可维护性。

• 注释说明： 对于一些不容易一眼看懂的表达式，添加注释说明运算逻辑，特别是当表达式的运算顺序依赖于不太常见的优先级规则时。

• 测试验证： 编写单元测试来验证表达式的计算结果是否符合预期。这可以帮助及早发现因运算符优先级理解错误而导致的问题。

示例：改进复杂表达式的可读性

-- 原始复杂表达式 (可读性较差)
result = not (a > b and c < d or e == f) and g ~= h
-- 使用括号和临时变量改进 (可读性更好)
local condition1 = a > b
local condition2 = c < d
local condition3 = e == f
local condition4 = g ~= h
local intermediate_result = condition1 and condition2 or condition3
result = not intermediate_result and condition4
​

改进后的代码通过使用括号和临时变量，将复杂的逻辑拆分成多个步骤，使代码逻辑更加清晰易懂，即使不熟悉 Lua 运算符优先级的人也能更容易理解代码的意图。

7. 总结

Lua 运算符优先级是 Lua 语言基础的重要组成部分。理解和掌握运算符优先级，能够帮助你编写出正确、高效、易于理解和维护的 Lua 代码。

本文详细介绍了 Lua 运算符的优先级级别，并通过丰富的代码示例，深入解析了每个优先级级别运算符的使用和运算规则。同时，我们强调了括号在控制运算顺序中的作用，以及运算符结合性的概念。最后，我们给出了编写清晰易懂 Lua 表达式的最佳实践建议。

希望通过本文的学习，你能够彻底掌握 Lua 运算符优先级，并在实际的 Lua 开发中灵活运用，编写出高质量的 Lua 代码。 掌握这些知识，你将能更自信地应对各种复杂的 Lua 表达式，并写出更健壮、更易读的代码。