Lua变量输出完全指南 掌握print函数与格式化输出技巧 解决开发调试难题提升代码效率 实例详解常见问题与最佳实践

威震华夏关云长

引言

Lua作为一种轻量级、高效的脚本语言，广泛应用于游戏开发、嵌入式系统和各种应用程序中。在Lua开发过程中，变量输出是一项基础而重要的技能，它不仅是调试代码的关键手段，也是程序与用户交互的重要方式。本文将全面介绍Lua中的变量输出技术，从基础的print函数到高级的格式化输出技巧，帮助开发者解决调试难题，提升代码效率。

Lua基础输出：print函数详解

基本用法

Lua中最基本的输出函数是print，它可以将一个或多个值输出到标准输出（通常是控制台）。

2. -- 输出字符串
3. print("Hello, World!")
5. -- 输出数字
6. print(42)
8. -- 输出布尔值
9. print(true)
10. print(false)
12. -- 输出nil
13. print(nil)

复制代码

print函数会自动在每个参数之间添加制表符（tab），并在末尾添加换行符。

2. -- 输出多个值
3. print("The answer is", 42, "and the status is", true)
4. -- 输出: The answer is    42    and the status is    true

复制代码

多变量输出

当需要输出多个变量时，可以使用print函数，并利用字符串连接操作符..来格式化输出：

2. local name = "Alice"
3. local age = 25
4. local city = "New York"
6. -- 使用字符串连接
7. print("Name: " .. name .. ", Age: " .. age .. ", City: " .. city)
8. -- 输出: Name: Alice, Age: 25, City: New York

复制代码

另一种方法是使用多个参数传递给print函数：

2. print("Name:", name, "Age:", age, "City:", city)
3. -- 输出: Name:    Alice    Age:    25    City:    New York

复制代码

输出重定向

默认情况下，print函数将输出发送到标准输出。但在某些情况下，我们可能需要将输出重定向到文件或其他地方。这可以通过重新定义print函数来实现：

2. -- 保存原始的print函数
3. local original_print = print
5. -- 重定向print到文件
6. local file = io.open("output.txt", "w")
7. function print(...)
8.     -- 将参数转换为字符串
9.     local args = {...}
10.     for i, v in ipairs(args) do
11.         args[i] = tostring(v)
12.     end
13.    
14.     -- 写入文件
15.     file:write(table.concat(args, "\t") .. "\n")
16.    
17.     -- 也可以同时输出到控制台
18.     original_print(...)
19. end
21. -- 现在print会同时输出到控制台和文件
22. print("This message goes to both console and file")
24. -- 完成后关闭文件
25. file:close()

复制代码

格式化输出技巧

string.format函数

虽然print函数简单易用，但在需要精确控制输出格式时，string.format函数提供了更强大的功能。它使用格式化字符串和参数来生成格式化的输出。

2. local name = "Bob"
3. local age = 30
4. local height = 1.75
6. -- 使用string.format格式化字符串
7. local formatted = string.format("Name: %s, Age: %d, Height: %.2f", name, age, height)
8. print(formatted)
9. -- 输出: Name: Bob, Age: 30, Height: 1.75

复制代码

格式化选项详解

string.format支持多种格式化选项，以下是一些常用的格式说明符：

• %s: 字符串
• %d: 十进制整数
• %f: 浮点数
• %.nf: 指定精度的浮点数（n为小数位数）
• %x: 十六进制整数（小写）
• %X: 十六进制整数（大写）
• %o: 八进制整数
• %e: 科学计数法（小写）
• %E: 科学计数法（大写）
• %%: 百分号

2. -- 各种格式化示例
3. local pi = 3.14159265359
4. local num = 255
6. print(string.format("Pi: %.2f", pi))           -- 输出: Pi: 3.14
7. print(string.format("Pi: %.4f", pi))          -- 输出: Pi: 3.1416
8. print(string.format("Decimal: %d", num))      -- 输出: Decimal: 255
9. print(string.format("Hex: %x", num))          -- 输出: Hex: ff
10. print(string.format("Hex: %X", num))          -- 输出: Hex: FF
11. print(string.format("Octal: %o", num))        -- 输出: Octal: 377
12. print(string.format("Scientific: %e", pi))    -- 输出: Scientific: 3.141593e+00
13. print(string.format("Percentage: %d%%", 85))  -- 输出: Percentage: 85%

复制代码

格式说明符还可以包含宽度、对齐和填充选项：

2. local name = "Alice"
3. local value = 42.5
5. -- 宽度和对齐
6. print(string.format("'%10s'", name))    -- 输出: '    Alice' (右对齐，宽度10)
7. print(string.format("'%-10s'", name))   -- 输出: 'Alice    ' (左对齐，宽度10)
8. print(string.format("'%10.1f'", value)) -- 输出: '      42.5' (右对齐，宽度10，1位小数)
9. print(string.format("'%010d'", 42))     -- 输出: '0000000042' (右对齐，宽度10，用0填充)

复制代码

复杂数据结构的格式化

对于表和其他复杂数据结构，直接使用print或string.format可能无法得到理想的输出。我们需要编写辅助函数来格式化这些数据结构：

2. -- 格式化表的函数
3. function format_table(t, indent)
4.     indent = indent or 0
5.     local spaces = string.rep("  ", indent)
6.     local result = "{\n"
7.    
8.     for k, v in pairs(t) do
9.         local key = type(k) == "string" and string.format("%q", k) or tostring(k)
10.         local value
11.         
12.         if type(v) == "table" then
13.             value = format_table(v, indent + 1)
14.         elseif type(v) == "string" then
15.             value = string.format("%q", v)
16.         else
17.             value = tostring(v)
18.         end
19.         
20.         result = result .. spaces .. "  " .. key .. " = " .. value .. ",\n"
21.     end
22.    
23.     result = result .. spaces .. "}"
24.     return result
25. end
27. -- 使用示例
28. local person = {
29.     name = "Alice",
30.     age = 25,
31.     address = {
32.         street = "123 Main St",
33.         city = "New York",
34.         zip = "10001"
35.     },
36.     hobbies = {"reading", "swimming", "coding"}
37. }
39. print(format_table(person))

复制代码

输出结果：

2. {
3.   "name" = "Alice",
4.   "age" = 25,
5.   "address" = {
6.     "street" = "123 Main St",
7.     "city" = "New York",
8.     "zip" = "10001",
9.   },
10.   "hobbies" = {
11.     1 = "reading",
12.     2 = "swimming",
13.     3 = "coding",
14.   },
15. }

复制代码

高级输出技巧

表的输出

Lua中的表是一种复杂的数据结构，可以包含各种类型的值。为了更好地输出表的内容，我们可以创建专门的表打印函数：

2. -- 简单表打印函数
3. function print_table(t)
4.     for k, v in pairs(t) do
5.         print(k, v)
6.     end
7. end
9. local scores = {math = 95, english = 88, science = 92}
10. print_table(scores)
11. -- 输出:
12. -- math    95
13. -- english 88
14. -- science 92
16. -- 更高级的表打印函数，支持嵌套表
17. function print_table_recursive(t, indent)
18.     indent = indent or 0
19.     local spaces = string.rep("  ", indent)
20.    
21.     for k, v in pairs(t) do
22.         if type(v) == "table" then
23.             print(spaces .. tostring(k) .. ":")
24.             print_table_recursive(v, indent + 1)
25.         else
26.             print(spaces .. tostring(k) .. ": " .. tostring(v))
27.         end
28.     end
29. end
31. local data = {
32.     player = {
33.         name = "Alice",
34.         level = 10,
35.         inventory = {
36.             {id = 1, name = "Sword", count = 1},
37.             {id = 2, name = "Potion", count = 5}
38.         }
39.     }
40. }
42. print_table_recursive(data)

复制代码

输出结果：

2. player:
3.   name: Alice
4.   level: 10
5.   inventory:
6.     1: table: 0x55a8b5c0c780
7.     2: table: 0x55a8b5c0c9e0

复制代码

上面的输出还不够理想，因为我们看到了表的内存地址而不是内容。让我们改进这个函数：

2. -- 改进的表打印函数，显示数组内容
3. function print_table_enhanced(t, indent)
4.     indent = indent or 0
5.     local spaces = string.rep("  ", indent)
6.    
7.     if type(t) ~= "table" then
8.         print(spaces .. tostring(t))
9.         return
10.     end
11.    
12.     -- 检查是否是数组（连续的数字键）
13.     local is_array = true
14.     for k, _ in pairs(t) do
15.         if type(k) ~= "number" or k <= 0 or math.floor(k) ~= k then
16.             is_array = false
17.             break
18.         end
19.     end
20.    
21.     if is_array then
22.         -- 按数字键排序输出
23.         local keys = {}
24.         for k, _ in pairs(t) do
25.             table.insert(keys, k)
26.         end
27.         table.sort(keys)
28.         
29.         for _, k in ipairs(keys) do
30.             local v = t[k]
31.             if type(v) == "table" then
32.                 print(spaces .. tostring(k) .. ":")
33.                 print_table_enhanced(v, indent + 1)
34.             else
35.                 print(spaces .. tostring(k) .. ": " .. tostring(v))
36.             end
37.         end
38.     else
39.         -- 普通表输出
40.         for k, v in pairs(t) do
41.             if type(v) == "table" then
42.                 print(spaces .. tostring(k) .. ":")
43.                 print_table_enhanced(v, indent + 1)
44.             else
45.                 print(spaces .. tostring(k) .. ": " .. tostring(v))
46.             end
47.         end
48.     end
49. end
51. print_table_enhanced(data)

复制代码

输出结果：

2. player:
3.   name: Alice
4.   level: 10
5.   inventory:
6.     1:
7.       1: 1
8.       2: Sword
9.       3: 1
10.     2:
11.       1: 2
12.       2: Potion
13.       3: 5

复制代码

函数的输出

在Lua中，函数也是一等公民，可以作为值传递和输出。直接输出函数会显示其内存地址：

2. local function add(a, b)
3.     return a + b
4. end
6. print(add)  -- 输出类似: function: 0x55a8b5c0d6e0

复制代码

如果我们想查看函数的内容，可以使用debug库：

2. -- 使用debug.getinfo获取函数信息
3. local info = debug.getinfo(add)
4. print("Function name:", info.name)
5. print("Defined at line:", info.linedefined)
6. print("Source file:", info.short_src)
8. -- 获取函数的源代码（如果可用）
9. if info.source and info.source:sub(1,1) == "@" then
10.     local file = io.open(info.source:sub(2), "r")
11.     if file then
12.         local lines = {}
13.         for line in file:lines() do
14.             table.insert(lines, line)
15.         end
16.         file:close()
17.         
18.         print("Function source:")
19.         for i = info.linedefined, info.lastlinedefined do
20.             print(lines[i])
21.         end
22.     end
23. end

复制代码

自定义输出函数

为了满足特定需求，我们可以创建自定义的输出函数。例如，创建一个带有时间戳的日志函数：

2. -- 带时间戳的日志函数
3. function log(message, level)
4.     level = level or "INFO"
5.     local timestamp = os.date("%Y-%m-%d %H:%M:%S")
6.     print(string.format("[%s] [%s] %s", timestamp, level, message))
7. end
9. -- 使用示例
10. log("Application started")
11. log("User logged in", "INFO")
12. log("Failed to connect to database", "ERROR")
14. -- 更高级的日志函数，支持多参数和格式化
15. function logf(level, format, ...)
16.     level = level or "INFO"
17.     local timestamp = os.date("%Y-%m-%d %H:%M:%S")
18.     local message = string.format(format, ...)
19.     print(string.format("[%s] [%s] %s", timestamp, level, message))
20. end
22. -- 使用示例
23. logf("INFO", "User %s logged in from %s", "Alice", "192.168.1.1")
24. logf("ERROR", "Database connection failed: %s", "timeout")

复制代码

另一个例子是创建一个颜色输出函数，用于终端中的彩色输出：

2. -- ANSI颜色代码
3. local colors = {
4.     reset = "\27[0m",
5.     black = "\27[30m",
6.     red = "\27[31m",
7.     green = "\27[32m",
8.     yellow = "\27[33m",
9.     blue = "\27[34m",
10.     magenta = "\27[35m",
11.     cyan = "\27[36m",
12.     white = "\27[37m",
13.     bg_black = "\27[40m",
14.     bg_red = "\27[41m",
15.     bg_green = "\27[42m",
16.     bg_yellow = "\27[43m",
17.     bg_blue = "\27[44m",
18.     bg_magenta = "\27[45m",
19.     bg_cyan = "\27[46m",
20.     bg_white = "\27[47m",
21.     bright = "\27[1m",
22.     dim = "\27[2m",
23.     underscore = "\27[4m",
24.     blink = "\27[5m",
25.     reverse = "\27[7m",
26.     hidden = "\27[8m"
27. }
29. -- 带颜色的打印函数
30. function print_color(color, ...)
31.     local args = {...}
32.     for i, v in ipairs(args) do
33.         args[i] = tostring(v)
34.     end
35.    
36.     local color_code = colors[color] or ""
37.     local reset_code = colors.reset or ""
38.    
39.     print(color_code .. table.concat(args, "\t") .. reset_code)
40. end
42. -- 使用示例
43. print_color("red", "This is an error message")
44. print_color("green", "This is a success message")
45. print_color("yellow", "This is a warning")
46. print_color("blue", "This is an info message")
47. print_color("bright", "This is bright text")
48. print_color("bg_red", "White text on red background")

复制代码

调试中的应用

日志记录

日志记录是调试和监控应用程序运行状态的重要手段。我们可以创建一个简单的日志系统：

2. -- 日志级别
3. local LOG_LEVELS = {
4.     DEBUG = 1,
5.     INFO = 2,
6.     WARN = 3,
7.     ERROR = 4,
8.     FATAL = 5
9. }
11. -- 当前日志级别
12. local CURRENT_LOG_LEVEL = LOG_LEVELS.DEBUG
14. -- 日志函数
15. function log(level, message)
16.     local level_value = LOG_LEVELS[level]
17.     if not level_value then
18.         error("Invalid log level: " .. tostring(level))
19.     end
20.    
21.     if level_value < CURRENT_LOG_LEVEL then
22.         return  -- 低于当前级别的日志不输出
23.     end
24.    
25.     local timestamp = os.date("%Y-%m-%d %H:%M:%S")
26.     local color = {
27.         [LOG_LEVELS.DEBUG] = "cyan",
28.         [LOG_LEVELS.INFO] = "green",
29.         [LOG_LEVELS.WARN] = "yellow",
30.         [LOG_LEVELS.ERROR] = "red",
31.         [LOG_LEVELS.FATAL] = "bright red"
32.     }[level_value] or "white"
33.    
34.     print_color(color, string.format("[%s] [%s] %s", timestamp, level, message))
35. end
37. -- 便捷函数
38. function log_debug(message) log("DEBUG", message) end
39. function log_info(message) log("INFO", message) end
40. function log_warn(message) log("WARN", message) end
41. function log_error(message) log("ERROR", message) end
42. function log_fatal(message) log("FATAL", message) end
44. -- 使用示例
45. log_debug("Debugging information")
46. log_info("Application started successfully")
47. log_warn("Configuration file not found, using defaults")
48. log_error("Failed to connect to database")
49. log_fatal("System out of memory")
51. -- 设置日志级别
52. CURRENT_LOG_LEVEL = LOG_LEVELS.INFO
53. log_debug("This debug message won't be shown")
54. log_info("This info message will be shown")

复制代码

错误追踪

在调试过程中，了解错误发生的位置和调用栈是非常重要的。Lua提供了debug库来获取这些信息：

2. -- 错误处理和追踪函数
3. function trace_error(err)
4.     print_color("red", "ERROR: " .. tostring(err))
5.    
6.     -- 获取调用栈
7.     local stack = {}
8.     local level = 2  -- 从调用trace_error的函数开始
9.    
10.     while true do
11.         local info = debug.getinfo(level, "Sln")
12.         if not info then break end
13.         
14.         table.insert(stack, string.format(
15.             "  File: %s:%d, Function: %s",
16.             info.short_src,
17.             info.currentline,
18.             info.name or "?"
19.         ))
20.         
21.         level = level + 1
22.     end
23.    
24.     print_color("yellow", "Call stack:")
25.     for _, frame in ipairs(stack) do
26.         print(frame)
27.     end
28. end
30. -- 示例函数
31. function function_a()
32.     function_b()
33. end
35. function function_b()
36.     function_c()
37. end
39. function function_c()
40.     -- 模拟错误
41.     local success, err = pcall(function()
42.         error("Something went wrong!")
43.     end)
44.    
45.     if not success then
46.         trace_error(err)
47.     end
48. end
50. -- 调用示例
51. function_a()

复制代码

输出结果：

2. ERROR: Something went wrong!
3. Call stack:
4.   File: test.lua:25, Function: function_c
5.   File: test.lua:20, Function: function_b
6.   File: test.lua:16, Function: function_a
7.   File: test.lua:32, Function: ?

复制代码

性能分析

输出变量和状态信息也可以用于性能分析。我们可以创建一个简单的性能分析工具：

2. -- 性能分析工具
3. local profiler = {}
5. -- 记录函数执行时间
6. function profiler.time(name, func, ...)
7.     local start_time = os.clock()
8.     local results = {func(...)}
9.     local end_time = os.clock()
10.     local elapsed = end_time - start_time
11.    
12.     print(string.format("[PROFILER] Function '%s' executed in %.6f seconds", name, elapsed))
13.     return unpack(results)
14. end
16. -- 使用示例
17. local function slow_function()
18.     local sum = 0
19.     for i = 1, 1000000 do
20.         sum = sum + i
21.     end
22.     return sum
23. end
25. local result = profiler.time("slow_function", slow_function)
26. print("Result:", result)
28. -- 更高级的性能分析器
29. local advanced_profiler = {
30.     data = {}
31. }
33. function advanced_profiler.start(name)
34.     advanced_profiler.data[name] = {
35.         start_time = os.clock(),
36.         calls = 0,
37.         total_time = 0
38.     }
39. end
41. function advanced_profiler.stop(name)
42.     local entry = advanced_profiler.data[name]
43.     if entry then
44.         entry.total_time = os.clock() - entry.start_time
45.         entry.calls = entry.calls + 1
46.     end
47. end
49. function advanced_profiler.report()
50.     print("\nPerformance Report:")
51.     print("-----------------")
52.     print(string.format("%-20s %-10s %-15s %-15s", "Function", "Calls", "Total Time", "Avg Time"))
53.    
54.     for name, entry in pairs(advanced_profiler.data) do
55.         local avg_time = entry.total_time / entry.calls
56.         print(string.format("%-20s %-10d %-15.6f %-15.6f",
57.             name, entry.calls, entry.total_time, avg_time))
58.     end
59. end
61. -- 使用示例
62. advanced_profiler.start("test_loop")
63. for i = 1, 1000000 do
64.     -- 一些操作
65. end
66. advanced_profiler.stop("test_loop")
68. advanced_profiler.start("string_concat")
69. local result = ""
70. for i = 1, 10000 do
71.     result = result .. "x"
72. end
73. advanced_profiler.stop("string_concat")
75. advanced_profiler.report()

复制代码

常见问题与解决方案

问题1：输出表时只显示表地址

问题描述：当直接使用print输出表时，只显示表的内存地址，而不是表的内容。

2. local t = {name = "Alice", age = 25}
3. print(t)  -- 输出类似: table: 0x55a8b5c0d6e0

复制代码

解决方案：创建一个函数来递归输出表的内容：

2. function dump_table(t, indent)
3.     indent = indent or 0
4.     local spaces = string.rep("  ", indent)
5.    
6.     if type(t) ~= "table" then
7.         print(spaces .. tostring(t))
8.         return
9.     end
10.    
11.     print(spaces .. "{")
12.     for k, v in pairs(t) do
13.         if type(v) == "table" then
14.             print(spaces .. "  " .. tostring(k) .. ":")
15.             dump_table(v, indent + 2)
16.         else
17.             print(spaces .. "  " .. tostring(k) .. ": " .. tostring(v))
18.         end
19.     end
20.     print(spaces .. "}")
21. end
23. local t = {name = "Alice", age = 25, address = {city = "New York", zip = "10001"}}
24. dump_table(t)

复制代码

问题2：循环引用导致的无限递归

问题描述：当表中存在循环引用时，尝试递归输出表的内容会导致无限递归和栈溢出。

2. local a = {}
3. local b = {parent = a}
4. a.child = b
6. -- 尝试输出会导致无限递归
7. dump_table(a)  -- 栈溢出错误

复制代码

解决方案：在递归函数中跟踪已访问的表，避免重复处理：

2. function dump_table_safe(t, indent, visited)
3.     indent = indent or 0
4.     visited = visited or {}
5.     local spaces = string.rep("  ", indent)
6.    
7.     if type(t) ~= "table" then
8.         print(spaces .. tostring(t))
9.         return
10.     end
11.    
12.     -- 检查是否已经访问过这个表
13.     if visited[t] then
14.         print(spaces .. "{...}")  -- 表示循环引用
15.         return
16.     end
17.    
18.     -- 标记为已访问
19.     visited[t] = true
20.    
21.     print(spaces .. "{")
22.     for k, v in pairs(t) do
23.         if type(v) == "table" then
24.             print(spaces .. "  " .. tostring(k) .. ":")
25.             dump_table_safe(v, indent + 2, visited)
26.         else
27.             print(spaces .. "  " .. tostring(k) .. ": " .. tostring(v))
28.         end
29.     end
30.     print(spaces .. "}")
31. end
33. local a = {}
34. local b = {parent = a}
35. a.child = b
37. dump_table_safe(a)  -- 正确处理循环引用

复制代码

问题3：输出中文或其他非ASCII字符时的乱码

问题描述：在某些环境中，输出中文或其他非ASCII字符时可能出现乱码。

2. print("你好，世界")  -- 可能显示为乱码

复制代码

解决方案：确保终端或控制台支持UTF-8编码，并在必要时设置正确的编码：

2. -- 在Lua 5.3及以上版本中，可以使用utf8库
3. if utf8 then
4.     -- 确保字符串是有效的UTF-8
5.     local str = "你好，世界"
6.     if utf8.len(str) then
7.         print(str)
8.     else
9.         print("Invalid UTF-8 string")
10.     end
11. else
12.     -- 对于旧版Lua，可能需要依赖外部库或系统设置
13.     print("你好，世界")  -- 假设环境已正确配置
14. end

复制代码

问题4：格式化输出时的精度问题

问题描述：使用string.format格式化浮点数时，可能会遇到精度问题。

2. local num = 1.23456789012345
3. print(string.format("%.10f", num))  -- 可能不是预期的精度

复制代码

解决方案：了解浮点数的精度限制，并根据需要调整格式化选项：

2. local num = 1.23456789012345
4. -- 使用适当的精度
5. print(string.format("%.5f", num))   -- 输出: 1.23457
6. print(string.format("%.10f", num))  -- 输出: 1.2345678901
7. print(string.format("%.15f", num))  -- 可能不是完全精确的
9. -- 对于高精度需求，考虑使用字符串或专门的库
10. local high_precision = require("decimal")  -- 假设有这样的库
11. if high_precision then
12.     local d = high_precision.new("1.23456789012345")
13.     print(d:tostring(15))  -- 输出更高精度的结果
14. end

复制代码

问题5：输出大量数据时的性能问题

问题描述：当需要输出大量数据时，可能会遇到性能问题，尤其是在循环中频繁调用输出函数。

2. -- 性能较差的方式
3. for i = 1, 100000 do
4.     print("Processing item " .. i)
5. end

复制代码

解决方案：减少输出频率，或使用缓冲区批量输出：

2. -- 减少输出频率
3. local counter = 0
4. for i = 1, 100000 do
5.     -- 处理数据
6.    
7.     counter = counter + 1
8.     if counter % 1000 == 0 then
9.         print("Processed " .. counter .. " items")
10.     end
11. end
13. -- 使用缓冲区批量输出
14. local buffer = {}
15. for i = 1, 100000 do
16.     -- 处理数据
17.    
18.     if i % 1000 == 0 then
19.         table.insert(buffer, "Processed " .. i .. " items")
20.     end
21. end
23. -- 一次性输出所有缓冲内容
24. print(table.concat(buffer, "\n"))

复制代码

最佳实践

1. 选择合适的输出函数

根据不同的场景选择合适的输出函数：

• 使用print进行简单的调试输出
• 使用string.format进行格式化输出
• 使用自定义函数处理复杂数据结构

2. -- 简单输出
3. print("Debug message")
5. -- 格式化输出
6. local name = "Alice"
7. local score = 95
8. print(string.format("Player: %s, Score: %d", name, score))
10. -- 复杂数据结构
11. local data = {players = {name = "Alice", score = 95}, level = 5}
12. dump_table_safe(data)

复制代码

2. 使用日志级别

实现日志级别系统，以便在不同环境下控制输出详细程度：

2. -- 定义日志级别
3. local LOG_LEVEL = {
4.     DEBUG = 1,
5.     INFO = 2,
6.     WARN = 3,
7.     ERROR = 4
8. }
10. -- 设置当前日志级别
11. local CURRENT_LEVEL = LOG_LEVEL.INFO
13. -- 日志函数
14. function log(level, message)
15.     if LOG_LEVEL[level] >= CURRENT_LEVEL then
16.         print(os.date("%Y-%m-%d %H:%M:%S") .. " [" .. level .. "] " .. message)
17.     end
18. end
20. -- 使用示例
21. log("DEBUG", "Detailed debug information")  -- 在INFO级别下不会显示
22. log("INFO", "Application started")
23. log("ERROR", "Failed to connect to database")

复制代码

3. 结构化输出

对于复杂的数据结构，使用结构化的输出格式，如JSON或自定义格式：

2. -- 简单的JSON格式化函数
3. function to_json(value, indent)
4.     indent = indent or 0
5.     local spaces = string.rep("  ", indent)
6.    
7.     if type(value) == "table" then
8.         local is_array = true
9.         local max_index = 0
10.         
11.         -- 检查是否是数组
12.         for k, _ in pairs(value) do
13.             if type(k) ~= "number" or k <= 0 or math.floor(k) ~= k then
14.                 is_array = false
15.                 break
16.             end
17.             max_index = math.max(max_index, k)
18.         end
19.         
20.         -- 检查数组是否连续
21.         if is_array then
22.             for i = 1, max_index do
23.                 if value[i] == nil then
24.                     is_array = false
25.                     break
26.                 end
27.             end
28.         end
29.         
30.         if is_array then
31.             -- 输出数组
32.             local result = "[\n"
33.             for i = 1, max_index do
34.                 result = result .. spaces .. "  " .. to_json(value[i], indent + 1) .. ",\n"
35.             end
36.             result = result .. spaces .. "]"
37.             return result
38.         else
39.             -- 输出对象
40.             local result = "{\n"
41.             for k, v in pairs(value) do
42.                 local key = type(k) == "string" and string.format("%q", k) or tostring(k)
43.                 result = result .. spaces .. "  " .. key .. ": " .. to_json(v, indent + 1) .. ",\n"
44.             end
45.             result = result .. spaces .. "}"
46.             return result
47.         end
48.     elseif type(value) == "string" then
49.         return string.format("%q", value)
50.     else
51.         return tostring(value)
52.     end
53. end
55. -- 使用示例
56. local data = {
57.     name = "Alice",
58.     age = 25,
59.     hobbies = {"reading", "swimming", "coding"},
60.     address = {
61.         street = "123 Main St",
62.         city = "New York"
63.     }
64. }
66. print(to_json(data))

复制代码

4. 输出重定向和日志文件

实现输出重定向，将日志写入文件以便后续分析：

2. -- 日志系统
3. local logger = {
4.     file = nil,
5.     console_output = true,
6.     file_output = false,
7.     level = "INFO"
8. }
10. -- 初始化日志系统
11. function logger.init(filename, level)
12.     logger.file = io.open(filename, "a")
13.     logger.file_output = (logger.file ~= nil)
14.     logger.level = level or "INFO"
15. end
17. -- 日志级别
18. local LOG_LEVELS = {
19.     DEBUG = 1,
20.     INFO = 2,
21.     WARN = 3,
22.     ERROR = 4
23. }
25. -- 写入日志
26. function logger.log(level, message)
27.     local level_value = LOG_LEVELS[level]
28.     if not level_value or level_value < LOG_LEVELS[logger.level] then
29.         return
30.     end
31.    
32.     local timestamp = os.date("%Y-%m-%d %H:%M:%S")
33.     local log_entry = string.format("[%s] [%s] %s", timestamp, level, message)
34.    
35.     -- 输出到控制台
36.     if logger.console_output then
37.         print(log_entry)
38.     end
39.    
40.     -- 输出到文件
41.     if logger.file_output and logger.file then
42.         logger.file:write(log_entry .. "\n")
43.         logger.file:flush()
44.     end
45. end
47. -- 关闭日志系统
48. function logger.close()
49.     if logger.file then
50.         logger.file:close()
51.         logger.file = nil
52.         logger.file_output = false
53.     end
54. end
56. -- 便捷函数
57. function logger.debug(message) logger.log("DEBUG", message) end
58. function logger.info(message) logger.log("INFO", message) end
59. function logger.warn(message) logger.log("WARN", message) end
60. function logger.error(message) logger.log("ERROR", message) end
62. -- 使用示例
63. logger.init("app.log", "DEBUG")
64. logger.debug("Debug information")
65. logger.info("Application started")
66. logger.warn("Configuration warning")
67. logger.error("An error occurred")
68. logger.close()

复制代码

5. 条件输出和调试标志

使用调试标志控制输出，便于在生产环境中关闭调试输出：

2. -- 调试标志
3. local DEBUG = true  -- 在生产环境中设置为false
5. -- 调试输出函数
6. function debug_print(...)
7.     if DEBUG then
8.         print(...)
9.     end
10. end
12. -- 使用示例
13. debug_print("This will only be printed if DEBUG is true")
15. -- 更高级的调试系统
16. local debug_flags = {
17.     network = false,
18.     database = false,
19.     ui = true
20. }
22. function debug_print(category, ...)
23.     if debug_flags[category] then
24.         print("[DEBUG:" .. category .. "]", ...)
25.     end
26. end
28. -- 使用示例
29. debug_print("network", "Connecting to server...")
30. debug_print("ui", "Button clicked")
31. debug_print("database", "Query executed")

复制代码

总结

Lua变量输出是开发过程中不可或缺的技能，它不仅帮助我们调试代码，还能提供程序运行状态的重要信息。本文从基础的print函数到高级的格式化输出技巧，全面介绍了Lua中的变量输出技术。

我们学习了如何使用print函数进行简单输出，如何使用string.format进行格式化输出，以及如何处理复杂数据结构的输出。我们还探讨了输出技术在调试中的应用，包括日志记录、错误追踪和性能分析。

通过解决常见问题和遵循最佳实践，我们可以更有效地使用输出技术来提升开发效率和代码质量。无论是简单的调试输出还是复杂的日志系统，掌握这些技巧都将使我们的Lua开发工作更加高效和愉快。

希望这篇指南能帮助你在Lua开发中更好地掌握变量输出技术，解决调试难题，提升代码效率。