3.2 关系运算符

3.2 关系运算符

Lua 关系运算符详解与实践

1. Lua 中的关系运算符概览

Lua 提供了以下六种关系运算符，用于比较两个值 a 和 b 之间的关系：

2. 等于运算符 == 和 不等于运算符 ~=

等于运算符 == 和 不等于运算符 ~= 是最基本且常用的关系运算符。它们用于判断两个值是否相等。

2.1 等于运算符 == 的详解与实践

语法: a == b

描述: == 运算符比较两个值 a 和 b 是否相等。相等意味着它们在值上是相同的。需要注意的是，Lua 中的相等性比较遵循以下规则：

• 数值类型 (number): 数值类型的比较基于数学上的值。例如，10 == 10.0 的结果为 true，因为它们在数值上是相等的。

• 字符串类型 (string): 字符串类型的比较基于字符序列。只有当两个字符串包含完全相同的字符序列时，它们才被认为是相等的。例如，"hello" == "hello" 为 true，而 "hello" == "Hello" 为 false (大小写敏感)。

• 布尔类型 (boolean): 布尔类型只有两个值：true 和 false。 只有当两个值都是 true 或都是 false 时，它们才相等。 例如， true == true 为 true， true == false 为 false。

• nil 类型: nil 类型只有一个值 nil。 只有当两个值都是 nil 时，它们才相等。 例如， nil == nil 为 true。

• 表类型 (table) 和 用户数据类型 (userdata): 表和用户数据类型在 Lua 中是引用类型。== 运算符比较的是它们的引用是否相同，而不是它们的内容是否相同。 换句话说，只有当两个表或用户数据指向内存中的同一个对象时，它们才被认为是相等的。

代码实践:

-- 数值类型比较
local num1 = 10
local num2 = 10.0
local num3 = 20
print(num1 == num2)  --> true  (数值相等)
print(num1 == num3)  --> false (数值不相等)
-- 字符串类型比较
local str1 = "lua"
local str2 = "lua"
local str3 = "Lua"
print(str1 == str2)  --> true  (字符串内容相同)
print(str1 == str3)  --> false (字符串内容不同，大小写敏感)
-- 布尔类型比较
local bool1 = true
local bool2 = true
local bool3 = false
print(bool1 == bool2)  --> true  (布尔值相同)
print(bool1 == bool3)  --> false (布尔值不同)
-- nil 类型比较
local nil1 = nil
local nil2 = nil
local nil3
print(nil1 == nil2)  --> true  (都是 nil)
print(nil1 == nil3)  --> true  (nil3 未赋值，默认值为 nil)
-- 表类型比较 (引用比较)
local table1 = {1, 2, 3}
local table2 = {1, 2, 3}
local table3 = table1 -- table3 和 table1 指向同一个表
print(table1 == table2)  --> false (table1 和 table2 内容相同，但不是同一个表对象)
print(table1 == table3)  --> true  (table1 和 table3 指向同一个表对象)
-- 用户数据类型比较 (引用比较，假设已经创建了 userdata)
-- (由于 userdata 通常涉及 C 代码，这里只做概念演示)
-- local userdata1 = ... -- 创建 userdata1
-- local userdata2 = ... -- 创建 userdata2 (内容可能与 userdata1 相同)
-- local userdata3 = userdata1 -- userdata3 和 userdata1 指向同一个 userdata
-- print(userdata1 == userdata2) --> false (userdata1 和 userdata2 内容可能相同，但不是同一个 userdata 对象)
-- print(userdata1 == userdata3) --> true  (userdata1 和 userdata3 指向同一个 userdata 对象)
​

2.2 不等于运算符 ~= 的详解与实践

语法: a ~= b

描述: ~= 运算符与 == 运算符相反。它比较两个值 a 和 b 是否不相等。如果不相等，则返回 true，否则返回 false。 不等于的判断规则与等于运算符 == 的规则相对应。

代码实践:

-- 数值类型比较
local num1 = 10
local num2 = 10.0
local num3 = 20
print(num1 ~= num2)  --> false (数值相等)
print(num1 ~= num3)  --> true  (数值不相等)
-- 字符串类型比较
local str1 = "lua"
local str2 = "lua"
local str3 = "Lua"
print(str1 ~= str2)  --> false (字符串内容相同)
print(str1 ~= str3)  --> true  (字符串内容不同，大小写敏感)
-- 布尔类型比较
local bool1 = true
local bool2 = true
local bool3 = false
print(bool1 ~= bool2)  --> false (布尔值相同)
print(bool1 ~= bool3)  --> true  (布尔值不同)
-- nil 类型比较
local nil1 = nil
local nil2 = nil
local nil3
print(nil1 ~= nil2)  --> false (都是 nil)
print(nil1 ~= nil3)  --> false (nil3 未赋值，默认值为 nil)
-- 表类型比较 (引用比较)
local table1 = {1, 2, 3}
local table2 = {1, 2, 3}
local table3 = table1
print(table1 ~= table2)  --> true  (table1 和 table2 不是同一个表对象)
print(table1 ~= table3)  --> false (table1 和 table3 是同一个表对象)
​

2.3 == 和 ~= 的应用场景

== 和 ~= 运算符在 Lua 编程中应用非常广泛，主要用于：

• 条件判断: 在 if 语句、 while 循环、 repeat...until 循环等控制结构中，根据比较结果决定程序的执行流程。

• 数据过滤和查找: 在处理数据集合时，可以使用 == 或 ~= 运算符来筛选符合特定条件的数据。

• 错误检测: 判断函数返回值是否为预期值，例如检查返回值是否为 nil 表示操作失败。

• 状态判断: 在游戏开发或状态机中，判断当前状态是否满足特定条件。

示例：条件判断

local age = 25
if age == 18 then
  print("刚刚成年")
elseif age > 18 and age < 60 then
  print("正值壮年")
else
  print("老年")
end
​

示例：数据过滤

local names = {"Alice", "Bob", "Charlie", "Alice", "David"}
local target_name = "Alice"
local alice_count = 0
for _, name in ipairs(names) do
  if name == target_name then
    alice_count = alice_count + 1
  end
end
print("名字为 Alice 的人数:", alice_count) --> 名字为 Alice 的人数: 2
​

3. 大小比较运算符 <、 >、 <=、 >=

大小比较运算符 < (小于)、 > (大于)、 <= (小于等于)、 >= (大于等于) 用于比较两个值的大小关系。

3.1 小于运算符 < 的详解与实践

语法: a < b

描述: < 运算符判断值 a 是否小于值 b。 如果是，则返回 true，否则返回 false。

比较规则:

• 数值类型 (number): 数值类型的比较基于数学上的大小关系。

• 字符串类型 (string): 字符串类型的比较基于字典序 (lexicographical order)。 按照字符在 ASCII 码表中的顺序进行比较。 例如， "apple" < "banana" 为 true， "Apple" < "apple" 为 true (大写字母的 ASCII 码小于小写字母)。

• 其他类型: 尝试比较其他类型 (例如布尔值、 nil、 表、 用户数据) 的大小关系通常会导致错误。 Lua 的默认行为是只允许数值和字符串类型进行大小比较。 如果尝试比较其他类型，Lua 会抛出一个错误，提示 "attempt to compare ..."。

代码实践:

-- 数值类型比较
local num1 = 10
local num2 = 20
local num3 = 10
print(num1 < num2)  --> true  (10 小于 20)
print(num2 < num1)  --> false (20 不小于 10)
print(num1 < num3)  --> false (10 不小于 10)
-- 字符串类型比较 (字典序)
local str1 = "apple"
local str2 = "banana"
local str3 = "Apple"
print(str1 < str2)  --> true  ("apple" 在字典序中排在 "banana" 前面)
print(str2 < str1)  --> false ("banana" 不在字典序中排在 "apple" 前面)
print(str3 < str1)  --> true  ("Apple" 在字典序中排在 "apple" 前面，因为 'A' 的 ASCII 码小于 'a' 的 ASCII 码)
-- 错误示例：尝试比较布尔类型 (会报错)
-- local bool1 = true
-- local bool2 = false
-- print(bool1 < bool2) --> 运行时错误：attempt to compare boolean with boolean
​

3.2 大于运算符 > 的详解与实践

语法: a > b

描述: > 运算符判断值 a 是否大于值 b。 如果是，则返回 true，否则返回 false。

比较规则: 与 < 运算符相同，适用于数值类型和字符串类型，并遵循相同的比较规则。

代码实践:

-- 数值类型比较
local num1 = 10
local num2 = 20
local num3 = 10
print(num1 > num2)  --> false (10 不大于 20)
print(num2 > num1)  --> true  (20 大于 10)
print(num2 > num3)  --> true  (20 大于 10)
-- 字符串类型比较 (字典序)
local str1 = "apple"
local str2 = "banana"
local str3 = "Apple"
print(str1 > str2)  --> false ("apple" 不在字典序中排在 "banana" 后面)
print(str2 > str1)  --> true  ("banana" 在字典序中排在 "apple" 后面)
print(str1 > str3)  --> false ("apple" 不在字典序中排在 "Apple" 后面)
​

3.3 小于等于运算符 <= 的详解与实践

语法: a <= b

描述: <= 运算符判断值 a 是否小于或等于值 b。 如果是，则返回 true，否则返回 false。

比较规则: 与 < 和 > 运算符相同，适用于数值类型和字符串类型，并遵循相同的比较规则。

代码实践:

-- 数值类型比较
local num1 = 10
local num2 = 20
local num3 = 10
print(num1 <= num2)  --> true  (10 小于 20)
print(num1 <= num3)  --> true  (10 等于 10)
print(num2 <= num1)  --> false (20 既不小于也不等于 10)
-- 字符串类型比较 (字典序)
local str1 = "apple"
local str2 = "banana"
local str3 = "apple"
print(str1 <= str2)  --> true  ("apple" 在字典序中排在 "banana" 前面)
print(str1 <= str3)  --> true  ("apple" 和 "apple" 字典序相同)
print(str2 <= str1)  --> false ("banana" 不在字典序中排在 "apple" 前面或相同)
​

3.4 大于等于运算符 >= 的详解与实践

语法: a >= b

描述: >= 运算符判断值 a 是否大于或等于值 b。 如果是，则返回 true，否则返回 false。

比较规则: 与 <、 > 和 <= 运算符相同，适用于数值类型和字符串类型，并遵循相同的比较规则。

代码实践:

-- 数值类型比较
local num1 = 10
local num2 = 20
local num3 = 10
print(num1 >= num2)  --> false (10 既不大于也不等于 20)
print(num2 >= num1)  --> true  (20 大于 10)
print(num3 >= num1)  --> true  (10 等于 10)
print(num3 >= num3)  --> true  (10 等于 10)
-- 字符串类型比较 (字典序)
local str1 = "apple"
local str2 = "banana"
local str3 = "apple"
print(str1 >= str2)  --> false ("apple" 不在字典序中排在 "banana" 后面或相同)
print(str2 >= str1)  --> true  ("banana" 在字典序中排在 "apple" 后面)
print(str3 >= str1)  --> true  ("apple" 和 "apple" 字典序相同)
​

3.5 大小比较运算符的应用场景

大小比较运算符 <、 >、 <=、 >= 主要用于：

• 排序: 在排序算法中，需要比较元素的大小来决定它们的顺序。

• 范围判断: 检查一个数值是否在一个指定的范围内。

• 循环控制: 在 for 循环或 while 循环中，根据大小比较结果控制循环的执行次数或终止条件。

• 数据验证: 验证用户输入的数据是否符合预期的范围或规则。

示例：排序

local numbers = {5, 2, 8, 1, 9}
table.sort(numbers, function(a, b)
  return a < b -- 升序排序
end)
for _, num in ipairs(numbers) do
  print(num) --> 1 2 5 8 9 (升序排列)
end
​

示例：范围判断

local score = 75
if score >= 60 and score <= 100 then
  print("及格")
else
  print("不及格")
end
​

4. 注意事项和最佳实践

• 类型一致性: 尽量确保关系运算符两侧的操作数类型一致。虽然 Lua 不会强制类型一致性，但在进行大小比较时，最好只比较数值类型或字符串类型。 混合比较不同类型可能会导致意想不到的结果或运行时错误。

• 表和用户数据的比较: 记住表和用户数据类型的 == 和 ~= 运算符比较的是引用，而不是内容。 如果需要比较表的内容是否相同，需要自定义比较函数，逐个比较表中的元素。

• 字符串大小写敏感性: 字符串的比较是大小写敏感的。如果需要进行大小写不敏感的字符串比较，需要先将字符串转换为统一的大小写形式 (例如，都转换为小写或大写) 再进行比较。可以使用 string.lower() 或 string.upper() 函数进行转换。

• 避免比较非数值和非字符串类型的大小: 除非明确知道自己在做什么，否则应避免使用 <、 >、 <=、 >= 运算符比较布尔值、 nil、 表、 用户数据等类型，因为这通常会导致运行时错误。

• 代码可读性: 合理使用括号来提高复杂条件表达式的可读性。 例如， if (age > 18 and age < 60) or is_student then ... end 比 if age > 18 and age < 60 or is_student then ... end 更易于理解。

5. 总结

关系运算符是 Lua 编程中不可或缺的一部分。 熟练掌握 ==、 ~=、 <、 >、 <=、 >= 这六种关系运算符的用法和比较规则，能够帮助你编写出更加灵活、强大的 Lua 程序。 理解不同数据类型的比较特性，并遵循最佳实践，可以避免常见的错误，提高代码的质量和可维护性。 通过本文的学习和实践，相信你已经对 Lua 的关系运算符有了更深入的理解，并能在实际开发中灵活运用它们。