Lua数据类型

概述

Lua是一种动态类型语言，变量不需要声明类型，类型信息与值相关联。Lua有8种基本数据类型。

1. nil（空值）

nil表示一个无效值，在条件表达式中相当于false。

local var = nil
print(var)          -- 输出: nil
print(type(var))    -- 输出: nil

-- nil用于删除变量
local x = 10
x = nil  -- 删除变量x

特点

• 全局变量默认值为nil
• 给全局变量赋nil等同于删除它
• nil是false类型，但false不是nil

2. boolean（布尔值）

包含两个值：true和false。

local is_true = true
local is_false = false

print(type(is_true))   -- 输出: boolean
print(type(is_false))  -- 输出: boolean

-- 在条件判断中，只有nil和false为假，其他都为真
if 0 then
    print("0是真值")    -- 会执行
end

if "" then
    print("空字符串是真值")  -- 会执行
end

逻辑运算

local a = true
local b = false

print(a and b)    -- false
print(a or b)     -- true
print(not a)      -- false
print(not b)      -- true

3. number（数字）

表示双精度类型的实浮点数。Lua 5.3开始支持整数类型。

-- 整数
local int_num = 42
local hex_num = 0xFF        -- 十六进制
local oct_num = 0o77        -- 八进制（Lua 5.2+）

-- 浮点数
local float_num = 3.14
local exp_num = 1.23e-4     -- 科学计数法

print(type(int_num))        -- number
print(type(float_num))      -- number

-- 数学运算
print(10 + 3)    -- 13
print(10 - 3)    -- 7
print(10 * 3)    -- 30
print(10 / 3)    -- 3.3333333333333
print(10 // 3)   -- 3 (整数除法，Lua 5.3+)
print(10 % 3)    -- 1 (取模)
print(10 ^ 3)    -- 1000 (幂运算)

数字类型判断

-- Lua 5.3+
local x = 42
local y = 3.14

print(math.type(x))  -- integer
print(math.type(y))  -- float

4. string（字符串）

字符串由一对双引号或单引号来表示，也可以用双方括号表示长字符串。

-- 基本字符串
local str1 = "Hello"
local str2 = 'World'
local str3 = [[
    多行字符串
    可以包含换行
]]

print(str1)  -- Hello
print(str2)  -- World
print(str3)  -- 多行字符串...

-- 字符串长度
print(#str1)        -- 5
print(string.len(str1))  -- 5

转义字符

local escaped = "Hello\nWorld\t!"
print(escaped)
-- 输出:
-- Hello
-- World	!

-- 常用转义字符
-- \n  换行
-- \t  制表符
-- \\  反斜杠
-- \"  双引号
-- \'  单引号
-- \r  回车
-- \a  响铃
-- \b  退格

字符串操作

local str = "Lua Programming"

-- 字符串连接
local result = "Hello " .. "World"
print(result)  -- Hello World

-- 字符串方法
print(string.upper(str))     -- LUA PROGRAMMING
print(string.lower(str))     -- lua programming
print(string.len(str))       -- 15
print(string.reverse(str))   -- gnimmargorP auL

-- 字符串查找
local pos = string.find(str, "Pro")
print(pos)  -- 5

-- 字符串替换
local new_str = string.gsub(str, "Lua", "Python")
print(new_str)  -- Python Programming

-- 字符串截取
local sub_str = string.sub(str, 1, 3)
print(sub_str)  -- Lua

-- 字符串格式化
local formatted = string.format("Hello %s, you are %d years old", "Alice", 25)
print(formatted)  -- Hello Alice, you are 25 years old

5. function（函数）

由C或Lua编写的函数。

-- 函数定义
function greet(name)
    return "Hello, " .. name
end

-- 匿名函数
local add = function(a, b)
    return a + b
end

-- 函数作为参数
local function apply_operation(a, b, operation)
    return operation(a, b)
end

print(greet("Lua"))                    -- Hello, Lua
print(add(5, 3))                      -- 8
print(apply_operation(10, 5, add))    -- 15

-- 多返回值
local function get_name_age()
    return "Alice", 25
end

local name, age = get_name_age()
print(name, age)  -- Alice	25

函数特性

-- 函数是第一类值
local func_var = print
func_var("Hello")  -- Hello

-- 闭包
local function create_counter()
    local count = 0
    return function()
        count = count + 1
        return count
    end
end

local counter = create_counter()
print(counter())  -- 1
print(counter())  -- 2

6. userdata（用户数据）

表示任意存储在变量中的C数据结构。

-- userdata通常由C扩展创建
-- 例如文件句柄
local file = io.open("test.txt", "w")
print(type(file))  -- userdata

if file then
    file:write("Hello, World!")
    file:close()
end

7. thread（线程）

表示执行的独立线路，用于执行协程。

-- 创建协程
local co = coroutine.create(function()
    print("协程开始")
    coroutine.yield()
    print("协程结束")
end)

print(type(co))  -- thread

-- 协程状态
print(coroutine.status(co))  -- suspended

-- 执行协程
coroutine.resume(co)  -- 协程开始
coroutine.resume(co)  -- 协程结束

8. table（表）

Lua中的表是一个"关联数组"，数组的索引可以是数字、字符串或表类型。

-- 创建空表
local empty_table = {}

-- 数组形式
local array = {1, 2, 3, 4, 5}
print(array[1])  -- 1 (注意：Lua数组索引从1开始)

-- 字典形式
local dict = {
    name = "Lua",
    version = 5.4,
    year = 2020
}
print(dict.name)     -- Lua
print(dict["name"])  -- Lua

-- 混合形式
local mixed = {
    "first",           -- [1] = "first"
    "second",          -- [2] = "second"
    name = "mixed",    -- ["name"] = "mixed"
    [10] = "tenth"     -- [10] = "tenth"
}

print(mixed[1])      -- first
print(mixed.name)    -- mixed
print(mixed[10])     -- tenth

表操作

local t = {}

-- 添加元素
t.name = "Lua"
t["age"] = 29
t[1] = "first"

-- 删除元素
t.name = nil

-- 表长度（只对数组部分有效）
local arr = {1, 2, 3, 4, 5}
print(#arr)  -- 5

-- 遍历表
local person = {name = "Alice", age = 30, city = "Beijing"}

-- pairs遍历所有键值对
for key, value in pairs(person) do
    print(key, value)
end

-- ipairs遍历数组部分
local numbers = {10, 20, 30, 40}
for index, value in ipairs(numbers) do
    print(index, value)
end

类型检查和转换

type()函数

print(type(nil))        -- nil
print(type(true))       -- boolean
print(type(42))         -- number
print(type("hello"))    -- string
print(type(print))      -- function
print(type({}))         -- table

类型转换

-- 数字转字符串
local num = 42
local str = tostring(num)
print(type(str))  -- string

-- 字符串转数字
local str_num = "123"
local num = tonumber(str_num)
print(type(num))  -- number

-- 转换失败返回nil
local invalid = tonumber("abc")
print(invalid)  -- nil

变量作用域

全局变量

-- 全局变量（不推荐）
global_var = "I'm global"

function test()
    print(global_var)  -- 可以访问
end

局部变量

-- 局部变量（推荐）
local local_var = "I'm local"

function test()
    local inner_var = "I'm inner"
    print(local_var)   -- 可以访问外部局部变量
end

-- print(inner_var)  -- 错误：无法访问

块作用域

do
    local block_var = "I'm in a block"
    print(block_var)  -- 可以访问
end
-- print(block_var)  -- 错误：超出作用域

最佳实践

1. 优先使用局部变量

   -- 好的做法
   local name = "Alice"
   
   -- 避免的做法
   name = "Alice"

2. 明确的类型检查

   local function safe_add(a, b)
       if type(a) ~= "number" or type(b) ~= "number" then
           error("参数必须是数字")
       end
       return a + b
   end

3. 合理使用表

   -- 配置表
   local config = {
       debug = true,
       max_users = 1000,
       database = {
           host = "localhost",
           port = 3306
       }
   }

4. 字符串操作优化

   -- 大量字符串连接时使用table.concat
   local parts = {}
   for i = 1, 1000 do
       parts[i] = "string" .. i
   end
   local result = table.concat(parts, ", ")

总结

Lua的数据类型系统简洁而强大：

• 8种基本类型涵盖了大部分编程需求
• 动态类型提供了灵活性
• 表类型是最重要和最强大的数据结构
• 函数是第一类值，支持函数式编程
• 协程提供了轻量级的并发支持

理解这些数据类型是掌握Lua编程的基础。