3.3 逻辑运算符

3.3 逻辑运算符

Lua 逻辑运算符详解与实践

在 Lua 编程语言中，逻辑运算符是构建复杂条件表达式和控制程序流程的重要组成部分。它们允许我们基于真值（true 或 false）进行判断和决策，从而实现灵活的程序逻辑。Lua 提供了三个核心的逻辑运算符：and、or 和 not。 它们与其他编程语言中的逻辑运算符概念相似，但在 Lua 中也存在一些独特的行为和特性。

1. and 运算符：逻辑与

and 运算符执行逻辑“与”操作。它接受两个操作数，并返回一个结果，该结果的真值取决于两个操作数的真值。

1.1 功能与运算规则

and 运算符遵循以下规则：

• 当且仅当两个操作数都为真时，and 运算符的结果才为真。

• 如果第一个操作数为假，则 and 运算符会短路，直接返回第一个操作数的值，不再评估第二个操作数。

• 如果第一个操作数为真，则 and 运算符会继续评估第二个操作数，并返回第二个操作数的值。

需要特别注意的是，Lua 中的真值和假值概念与其他一些语言略有不同：

• 假值 (falsey)：false 和 nil 被认为是假值。

• 真值 (truthy)：除了 false 和 nil 之外的所有值都被认为是真值，包括 0、空字符串 "" 和 true 本身。

总结 and 运算符的运算规则如下（假设 a 和 b 是操作数）：

1.2 代码实践与示例

以下代码示例展示了 and 运算符在不同场景下的应用和行为：

示例 1：简单的布尔值运算

local result1 = true and true
print("true and true:", result1)  -- 输出: true and true: true
local result2 = true and false
print("true and false:", result2) -- 输出: true and false: false
local result3 = false and true
print("false and true:", result3) -- 输出: false and true: false
local result4 = false and false
print("false and false:", result4) -- 输出: false and false: false
​

在这个例子中，我们直接对布尔值 true 和 false 进行了 and 运算，结果符合逻辑“与”的预期。

示例 2：真值和假值的混合运算

local result5 = nil and 10
print("nil and 10:", result5)   -- 输出: nil and 10: nil (短路，返回第一个操作数 nil)
local result6 = false and "hello"
print("false and 'hello':", result6) -- 输出: false and 'hello': false (短路，返回第一个操作数 false)
local result7 = 5 and nil
print("5 and nil:", result7)     -- 输出: 5 and nil: nil (第一个操作数为真，返回第二个操作数 nil)
local result8 = "world" and false
print("'world' and false:", result8) -- 输出: 'world' and false: false (第一个操作数为真，返回第二个操作数 false)
local result9 = 1 and "Lua"
print("1 and 'Lua':", result9)    -- 输出: 1 and 'Lua': Lua (两个操作数都为真，返回第二个操作数 'Lua')
local result10 = 0 and ""
print("0 and '':", result10)      -- 输出: 0 and '':  (两个操作数都为真，返回第二个操作数 '')
​

这个例子展示了 and 运算符处理真值和假值混合运算的情况。需要注意以下几点：

• 短路特性： 当第一个操作数为假值 (nil 或 false) 时，and 运算符立即返回第一个操作数的值，不再评估第二个操作数。例如 nil and 10 直接返回 nil，false and "hello" 直接返回 false。

• 返回值不是简单的 true 或 false： 当两个操作数都为真值时，and 运算符返回的是第二个操作数的值。例如 1 and "Lua" 返回的是 "Lua"，而不是简单的 true。 这种行为在 Lua 中非常常见，并被广泛应用于简洁的代码编写。

示例 3：在条件语句中使用 and

local age = 25
local hasLicense = true
if age >= 18 and hasLicense then
  print("可以驾驶汽车")
else
  print("不符合驾驶条件")
end
-- 输出: 可以驾驶汽车
local score = 75
local attendance = 80
if score >= 60 and attendance >= 90 then
  print("优秀学生")
elseif score >= 60 and attendance >= 70 then
  print("合格学生")
else
  print("不合格学生")
end
-- 输出: 合格学生 (因为 attendance 不满足 >= 90)
​

在条件语句中，and 运算符常用于组合多个条件，只有当所有条件都为真时，整个条件表达式才为真，才会执行 if 语句块中的代码。

示例 4：利用 and 的短路特性设置默认值

local username = params.username and params.username  -- 假设 params 是一个表
-- 如果 params.username 存在且为真值，则 username 赋值为 params.username
-- 否则 (params.username 为 nil 或 false)，username 赋值为 params.username (即 nil 或 false)
-- 更常见的设置默认值的方式（虽然不是严格的逻辑与，但利用了短路特性）
local username = params.username and params.username or "guest"
-- 如果 params.username 存在且为真值，则 username 赋值为 params.username
-- 否则 (params.username 为 nil 或 false)，`and` 表达式返回 params.username (假值)，然后执行 `or` 运算
-- 由于 `or` 的第一个操作数为假值，会继续评估第二个操作数 "guest"，并返回 "guest" 作为结果
-- 因此，如果 params.username 不存在或为假值，username 将被赋值为 "guest" (默认值)
local input = getUserInput() -- 假设这是一个获取用户输入的函数，可能返回 nil
local name = input and input or "匿名用户"
print("欢迎您，" .. name)
-- 如果 getUserInput() 返回一个非 nil 的值 (真值)，则 name 为该输入值
-- 如果 getUserInput() 返回 nil (假值)，则 name 为 "匿名用户"
​

这个例子展示了如何利用 and 运算符的短路特性来简洁地设置默认值。虽然这种用法更常见于结合 or 运算符使用，但单独使用 and 的短路特性也可以进行简单的条件赋值。

1.3 注意事项

• 短路行为： 理解 and 的短路行为至关重要。这不仅影响程序的执行效率 (避免不必要的计算)，也影响代码的逻辑。例如，在 a and b() 中，如果 a 为假值，函数 b() 将不会被调用。

• 真值和假值的定义： 务必记住 Lua 中真值和假值的定义 (false 和 nil 为假值，其他都为真值)。这与其他语言的布尔类型概念可能有所不同。

• 返回值： and 运算符返回的是操作数的值，而不是简单的 true 或 false。在某些情况下，这可能会导致意想不到的结果，尤其是在与其他运算符组合使用时。

2. or 运算符：逻辑或

or 运算符执行逻辑“或”操作。它也接受两个操作数，并返回一个结果，结果的真值取决于两个操作数的真值。

2.1 功能与运算规则

or 运算符遵循以下规则：

• 当且仅当两个操作数都为假时，or 运算符的结果才为假。

• 如果第一个操作数为真，则 or 运算符会短路，直接返回第一个操作数的值，不再评估第二个操作数。

• 如果第一个操作数为假，则 or 运算符会继续评估第二个操作数，并返回第二个操作数的值。

总结 or 运算符的运算规则如下（假设 a 和 b 是操作数）：

2.2 代码实践与示例

以下代码示例展示了 or 运算符在不同场景下的应用和行为：

示例 1：简单的布尔值运算

local result1 = true or true
print("true or true:", result1)  -- 输出: true or true: true
local result2 = true or false
print("true or false:", result2) -- 输出: true or false: true
local result3 = false or true
print("false or true:", result3) -- 输出: false or true: true
local result4 = false or false
print("false or false:", result4) -- 输出: false or false: false
​

在这个例子中，我们直接对布尔值 true 和 false 进行了 or 运算，结果符合逻辑“或”的预期。

示例 2：真值和假值的混合运算

local result5 = nil or 10
print("nil or 10:", result5)   -- 输出: nil or 10: 10 (第一个操作数为假，返回第二个操作数 10)
local result6 = false or "hello"
print("false or 'hello':", result6) -- 输出: false or 'hello': hello (第一个操作数为假，返回第二个操作数 'hello')
local result7 = 5 or nil
print("5 or nil:", result7)     -- 输出: 5 or nil: 5 (短路，返回第一个操作数 5)
local result8 = "world" or false
print("'world' or false:", result8) -- 输出: 'world' or false: world (短路，返回第一个操作数 'world')
local result9 = 0 or "Lua"
print("0 or 'Lua':", result9)    -- 输出: 0 or 'Lua': 0 (短路，返回第一个操作数 0)
local result10 = "" or nil
print("'' or nil:", result10)     -- 输出: '' or nil:  (短路，返回第一个操作数 '')
​

这个例子展示了 or 运算符处理真值和假值混合运算的情况。需要注意以下几点：

• 短路特性： 当第一个操作数为真值 (非 nil 和 false) 时，or 运算符立即返回第一个操作数的值，不再评估第二个操作数。例如 5 or nil 直接返回 5，"world" or false 直接返回 "world"。

• 返回值不是简单的 true 或 false： 当第一个操作数为真值时，or 运算符返回的是第一个操作数的值。当第一个操作数为假值时，or 运算符返回的是第二个操作数的值。

示例 3：在条件语句中使用 or

local isWeekend = false
local isHoliday = true
if isWeekend or isHoliday then
  print("可以休息")
else
  print("需要工作")
end
-- 输出: 可以休息 (因为 isHoliday 为 true)
local input = getUserInput() -- 假设这是一个获取用户输入的函数，可能返回 nil
local name = input or "匿名用户"
print("欢迎您，" .. name)
-- 如果 getUserInput() 返回一个非 nil 的值 (真值)，则 name 为该输入值
-- 如果 getUserInput() 返回 nil (假值)，则 name 为 "匿名用户"
​

在条件语句中，or 运算符常用于组合多个条件，只要其中一个条件为真，整个条件表达式就为真，就会执行 if 语句块中的代码。

示例 4：使用 or 设置默认值

local configValue = settings.timeout or 30 -- 假设 settings 是一个表
-- 如果 settings.timeout 存在且为真值，则 configValue 赋值为 settings.timeout
-- 否则 (settings.timeout 为 nil 或 false)，configValue 赋值为 30 (默认值)
local port = options.port or 8080 -- 假设 options 是一个表
-- 如果 options.port 存在且为真值，则 port 赋值为 options.port
-- 否则 (options.port 为 nil 或 false)，port 赋值为 8080 (默认值)
function greet(name)
  name = name or "访客" -- 如果 name 为 nil 或 false，则使用 "访客" 作为默认值
  print("你好，" .. name .. "!")
end
greet("Alice")   -- 输出: 你好，Alice!
greet(nil)      -- 输出: 你好，访客!
greet(false)    -- 输出: 你好，访客!
greet("")       -- 输出: 你好，! (空字符串是真值，所以不会使用默认值，输出 "你好，!" )
​

or 运算符最常见的用法之一就是设置默认值。利用 or 的短路特性，我们可以简洁地为变量赋予默认值，当变量本身为假值 (例如 nil 或 false) 时，就会使用 or 运算符后面的默认值。

2.3 注意事项

• 短路行为： 与 and 类似，理解 or 的短路行为也很重要。在 a or b() 中，如果 a 为真值，函数 b() 将不会被调用。

• 真值和假值的定义： 同样需要记住 Lua 中真值和假值的定义。

• 返回值： or 运算符也返回操作数的值，而不是简单的 true 或 false。这在设置默认值时非常方便，但在其他场景下也需要注意其返回值类型。

• 与 and 的组合： and 和 or 运算符经常组合使用，构建更复杂的条件表达式。理解它们的优先级和短路行为对于正确理解和编写复杂的逻辑至关重要。

3. not 运算符：逻辑非

not 运算符执行逻辑“非”操作，也称为逻辑取反或逻辑反转。它是一个一元运算符，只接受一个操作数。

3.1 功能与运算规则

not 运算符遵循以下规则：

• not 运算符返回的结果总是布尔值：true 或 false。

• 如果操作数为真值，则 not 运算符返回 false。

• 如果操作数为假值，则 not 运算符返回 true。

总结 not 运算符的运算规则如下（假设 a 是操作数）：

3.2 代码实践与示例

以下代码示例展示了 not 运算符在不同场景下的应用和行为：

示例 1：简单的布尔值运算

local result1 = not true
print("not true:", result1)  -- 输出: not true: false
local result2 = not false
print("not false:", result2) -- 输出: not false: true
​

在这个例子中，我们直接对布尔值 true 和 false 进行了 not 运算，结果符合逻辑“非”的预期。

示例 2：真值和假值的混合运算

local result3 = not nil
print("not nil:", result3)   -- 输出: not nil: true
local result4 = not 10
print("not 10:", result4)    -- 输出: not 10: false (10 是真值)
local result5 = not "hello"
print("not 'hello':", result5) -- 输出: not 'hello': false ('hello' 是真值)
local result6 = not 0
print("not 0:", result6)      -- 输出: not 0: false (0 是真值)
local result7 = not ""
print("not '':", result7)      -- 输出: not '': false (空字符串是真值)
​

这个例子展示了 not 运算符处理真值和假值混合运算的情况。可以看到，not 运算符总是返回布尔值 true 或 false，并且它会反转操作数的真值。

示例 3：在条件语句中使用 not

local isLoggedIn = false
if not isLoggedIn then
  print("请先登录")
else
  print("欢迎回来")
end
-- 输出: 请先登录
local isRaining = true
if not isRaining then
  print("今天天气晴朗")
else
  print("今天下雨")
end
-- 输出: 今天下雨
​

在条件语句中，not 运算符常用于反转条件，例如判断某个条件不成立时执行某些操作。

示例 4：结合 and 和 or 使用 not

local hasPermission = false
local isAdmin = true
if isAdmin or not hasPermission then -- 如果是管理员或者没有权限，则... (逻辑错误，应该是管理员且有权限)
  print("允许操作 (逻辑错误示例)")
end
if isAdmin and not hasPermission then -- 如果是管理员但没有权限，则...
  print("管理员权限不足")
end
if not isAdmin and not hasPermission then -- 如果既不是管理员也没有权限，则...
  print("普通用户无权限")
end
if isAdmin and hasPermission then -- 如果是管理员且有权限，则...
  print("管理员权限已授权")
end
-- 输出:
-- 管理员权限不足
-- 普通用户无权限
-- 管理员权限已授权 (根据 hasPermission 的值变化)
​

not 运算符通常与其他逻辑运算符 (and 和 or) 组合使用，构建更复杂的条件表达式。它用于对条件进行否定，从而实现更灵活的逻辑控制。

3.3 注意事项

• 返回值类型： not 运算符总是返回布尔值 true 或 false，与其他两个运算符 (and 和 or) 返回操作数的值不同。

• 优先级： not 运算符的优先级高于 and 和 or 运算符。这意味着在复杂的表达式中，not 运算符会先于 and 和 or 运算。可以使用括号 () 来改变运算的优先级。

• 清晰的代码： 过度使用 not 运算符可能会使代码难以理解。在编写代码时，应尽量保持逻辑清晰，避免不必要的双重否定或复杂的 not 运算。

4. 运算符优先级和结合性

在 Lua 中，逻辑运算符的优先级顺序如下（从高到低）：

1. not

2. and

3. or

这意味着 not 运算符的优先级最高，其次是 and，最后是 or。 当表达式中同时出现多个逻辑运算符时，会按照优先级顺序进行运算。

示例：

local result1 = true or false and false
print("true or false and false:", result1) -- 输出: true or false and false: true
-- 运算顺序：先 `false and false` 得到 `false`，然后 `true or false` 得到 `true`
local result2 = (true or false) and false
print("(true or false) and false:", result2) -- 输出: (true or false) and false: false
-- 运算顺序：先 `(true or false)` 得到 `true`，然后 `true and false` 得到 `false`
local result3 = not false and true or false
print("not false and true or false:", result3) -- 输出: not false and true or false: true
-- 运算顺序：先 `not false` 得到 `true`，然后 `true and true` 得到 `true`，最后 `true or false` 得到 `true`
local result4 = not (false and true) or false
print("not (false and true) or false:", result4) -- 输出: not (false and true) or false: true
-- 运算顺序：先 `(false and true)` 得到 `false`，然后 `not false` 得到 `true`，最后 `true or false` 得到 `true`
local result5 = not (false and (true or false))
print("not (false and (true or false)):", result5) -- 输出: not (false and (true or false)): true
-- 运算顺序：先 `(true or false)` 得到 `true`，然后 `(false and true)` 得到 `false`，最后 `not false` 得到 `true`
​

为了提高代码的可读性和避免歧义，建议在复杂的逻辑表达式中使用括号 () 来明确运算的优先级。 括号可以强制改变运算顺序，使代码逻辑更加清晰易懂。

5. 总结与最佳实践

Lua 的逻辑运算符 and、or 和 not 是程序逻辑控制的重要工具。 理解它们的运算规则、短路特性、真值/假值定义以及运算符优先级对于编写正确、高效的 Lua 代码至关重要。

最佳实践建议：

• 清晰的代码逻辑： 编写逻辑表达式时，应力求逻辑清晰易懂。避免过度复杂的嵌套和难以理解的条件判断。

• 使用括号： 在复杂的逻辑表达式中使用括号 () 来明确运算优先级，提高代码可读性，避免歧义。

• 理解短路特性： 充分利用 and 和 or 运算符的短路特性，可以编写更简洁、高效的代码，例如设置默认值、条件执行函数等。

• 注意真值和假值： 牢记 Lua 中真值和假值的定义 (false 和 nil 为假值，其他都为真值)，避免因真假值判断错误导致的逻辑错误。

• 适度使用 not： not 运算符虽然有用，但过度使用可能会降低代码的可读性。尽量使用肯定形式的条件判断，避免不必要的双重否定。

• 测试与验证： 对于复杂的逻辑表达式，务必进行充分的测试和验证，确保代码逻辑的正确性。

掌握 Lua 的逻辑运算符，并熟练运用到实际编程中，将有助于你编写出更灵活、更强大的 Lua 程序。希望本文的详细讲解和代码示例能够帮助你深入理解 Lua 的逻辑运算符，并在你的 Lua 开发之旅中助你一臂之力。