Lua格式化输出详解从基础到高级技巧帮助开发者掌握stringformat函数解决实际编程中的数据格式化挑战优化输出效果

威震华夏关云长

引言

在Lua编程中，格式化输出是一项基本但极其重要的技能。无论是日志记录、数据展示还是用户界面生成，良好的格式化输出都能使信息更加清晰易读。Lua提供了强大的string.format函数，它允许开发者按照特定格式输出数据，类似于C语言中的printf函数。本文将深入探讨string.format函数的各个方面，从基础用法到高级技巧，帮助开发者全面掌握Lua中的格式化输出技术，解决实际编程中的数据格式化挑战，优化输出效果。

基础部分：string.format函数的基本语法和用法

string.format函数是Lua标准库中用于格式化字符串的核心函数。它的基本语法如下：

2. formatted_string = string.format(formatstring, ...)

复制代码

其中，formatstring是一个包含普通文本和格式说明符的字符串，而…是要格式化的参数列表。

最简单的例子：

2. local name = "Alice"
3. local age = 25
4. local message = string.format("Name: %s, Age: %d", name, age)
5. print(message)  -- 输出: Name: Alice, Age: 25

复制代码

在这个例子中，%s和%d是格式说明符，分别表示字符串和十进制整数。string.format会用后面的参数替换这些说明符，生成最终的格式化字符串。

格式化选项详解

Lua中的string.format支持多种格式说明符，每种都有特定的用途。下面详细介绍各种格式说明符：

基本格式说明符

1.

2. %s - 字符串local str = "Hello"
3. print(string.format("String: %s", str))  -- 输出: String: Hello

复制代码

2.

2. %d - 十进制整数local num = 42
3. print(string.format("Number: %d", num))  -- 输出: Number: 42

复制代码

3.

2. %i - 同%d，十进制整数local num = 42
3. print(string.format("Number: %i", num))  -- 输出: Number: 42

复制代码

4.

2. %f - 浮点数local pi = 3.14159
3. print(string.format("Pi: %f", pi))  -- 输出: Pi: 3.141590

复制代码

5.

2. %c - 字符（将数字转换为对应的ASCII字符）local ascii_code = 65
3. print(string.format("Character: %c", ascii_code))  -- 输出: Character: A

复制代码

6.

2. %o - 八进制数local num = 16
3. print(string.format("Octal: %o", num))  -- 输出: Octal: 20

复制代码

7.

2. %u - 无符号十进制整数local num = 42
3. print(string.format("Unsigned: %u", num))  -- 输出: Unsigned: 42

复制代码

8.

2. %x - 小写十六进制数local num = 255
3. print(string.format("Hex: %x", num))  -- 输出: Hex: ff

复制代码

9.

2. %X - 大写十六进制数local num = 255
3. print(string.format("Hex: %X", num))  -- 输出: Hex: FF

复制代码

10.

2. %e - 科学计数法（小写e）local num = 12345.67
3. print(string.format("Scientific: %e", num))  -- 输出: Scientific: 1.234567e+04

复制代码

11.

2. %E - 科学计数法（大写E）local num = 12345.67
3. print(string.format("Scientific: %E", num))  -- 输出: Scientific: 1.234567E+04

复制代码

12.

2. %g - 根据值的大小自动选择%f或%e格式（紧凑形式）local num1 = 123.456
3. local num2 = 123456789.123
4. print(string.format("Compact1: %g", num1))  -- 输出: Compact1: 123.456
5. print(string.format("Compact2: %g", num2))  -- 输出: Compact2: 1.23457e+08

复制代码

13.

2. %G - 同%g，但使用大写字母local num = 123456789.123
3. print(string.format("Compact: %G", num))  -- 输出: Compact: 1.23457E+08

复制代码

14.

2. %% - 百分号本身local percentage = 50
3. print(string.format("Progress: %d%%", percentage))  -- 输出: Progress: 50%

复制代码

%s - 字符串

2. local str = "Hello"
3. print(string.format("String: %s", str))  -- 输出: String: Hello

复制代码

%d - 十进制整数

2. local num = 42
3. print(string.format("Number: %d", num))  -- 输出: Number: 42

复制代码

%i - 同%d，十进制整数

2. local num = 42
3. print(string.format("Number: %i", num))  -- 输出: Number: 42

复制代码

%f - 浮点数

2. local pi = 3.14159
3. print(string.format("Pi: %f", pi))  -- 输出: Pi: 3.141590

复制代码

%c - 字符（将数字转换为对应的ASCII字符）

2. local ascii_code = 65
3. print(string.format("Character: %c", ascii_code))  -- 输出: Character: A

复制代码

%o - 八进制数

2. local num = 16
3. print(string.format("Octal: %o", num))  -- 输出: Octal: 20

复制代码

%u - 无符号十进制整数

2. local num = 42
3. print(string.format("Unsigned: %u", num))  -- 输出: Unsigned: 42

复制代码

%x - 小写十六进制数

2. local num = 255
3. print(string.format("Hex: %x", num))  -- 输出: Hex: ff

复制代码

%X - 大写十六进制数

2. local num = 255
3. print(string.format("Hex: %X", num))  -- 输出: Hex: FF

复制代码

%e - 科学计数法（小写e）

2. local num = 12345.67
3. print(string.format("Scientific: %e", num))  -- 输出: Scientific: 1.234567e+04

复制代码

%E - 科学计数法（大写E）

2. local num = 12345.67
3. print(string.format("Scientific: %E", num))  -- 输出: Scientific: 1.234567E+04

复制代码

%g - 根据值的大小自动选择%f或%e格式（紧凑形式）

2. local num1 = 123.456
3. local num2 = 123456789.123
4. print(string.format("Compact1: %g", num1))  -- 输出: Compact1: 123.456
5. print(string.format("Compact2: %g", num2))  -- 输出: Compact2: 1.23457e+08

复制代码

%G - 同%g，但使用大写字母

2. local num = 123456789.123
3. print(string.format("Compact: %G", num))  -- 输出: Compact: 1.23457E+08

复制代码

%% - 百分号本身

2. local percentage = 50
3. print(string.format("Progress: %d%%", percentage))  -- 输出: Progress: 50%

复制代码

格式修饰符

除了基本的格式说明符外，Lua还支持多种修饰符来控制输出的格式：

1.

2. 宽度修饰符local num = 42
3. print(string.format("Number: %5d", num))  -- 输出: Number:    42 (总宽度为5，右对齐)
4. print(string.format("Number: %-5d", num)) -- 输出: Number: 42   (总宽度为5，左对齐)

复制代码

2.

2. 精度修饰符local pi = 3.14159265359
3. print(string.format("Pi: %.2f", pi))  -- 输出: Pi: 3.14 (保留2位小数)
4. print(string.format("Pi: %.5f", pi))  -- 输出: Pi: 3.14159 (保留5位小数)

复制代码

3.

2. 标志修饰符+：显示数字的正负号local num1 = 42
3. local num2 = -42
4. print(string.format("Num1: %+d", num1))  -- 输出: Num1: +42
5. print(string.format("Num2: %+d", num2))  -- 输出: Num2: -420：用0填充而不是空格local num = 42
6. print(string.format("Num: %05d", num))  -- 输出: Num: 00042#：对于%o，添加前缀0；对于%x/%X，添加前缀0x/0Xlocal num = 255
7. print(string.format("Octal: %#o", num))    -- 输出: Octal: 0377
8. print(string.format("Hex: %#x", num))      -- 输出: Hex: 0xff
9. print(string.format("Hex: %#X", num))      -- 输出: Hex: 0XFF（空格）：对于正数，在前面添加一个空格local num1 = 42
10. local num2 = -42
11. print(string.format("Num1: % d", num1))  -- 输出: Num1:  42 (注意前面的空格)
12. print(string.format("Num2: % d", num2))  -- 输出: Num2: -42

复制代码

4.

2. +：显示数字的正负号local num1 = 42
3. local num2 = -42
4. print(string.format("Num1: %+d", num1))  -- 输出: Num1: +42
5. print(string.format("Num2: %+d", num2))  -- 输出: Num2: -42

复制代码

5.

2. 0：用0填充而不是空格local num = 42
3. print(string.format("Num: %05d", num))  -- 输出: Num: 00042

复制代码

6.

2. #：对于%o，添加前缀0；对于%x/%X，添加前缀0x/0Xlocal num = 255
3. print(string.format("Octal: %#o", num))    -- 输出: Octal: 0377
4. print(string.format("Hex: %#x", num))      -- 输出: Hex: 0xff
5. print(string.format("Hex: %#X", num))      -- 输出: Hex: 0XFF

复制代码

7.

2. （空格）：对于正数，在前面添加一个空格local num1 = 42
3. local num2 = -42
4. print(string.format("Num1: % d", num1))  -- 输出: Num1:  42 (注意前面的空格)
5. print(string.format("Num2: % d", num2))  -- 输出: Num2: -42

复制代码

宽度修饰符

2. local num = 42
3. print(string.format("Number: %5d", num))  -- 输出: Number:    42 (总宽度为5，右对齐)
4. print(string.format("Number: %-5d", num)) -- 输出: Number: 42   (总宽度为5，左对齐)

复制代码

精度修饰符

2. local pi = 3.14159265359
3. print(string.format("Pi: %.2f", pi))  -- 输出: Pi: 3.14 (保留2位小数)
4. print(string.format("Pi: %.5f", pi))  -- 输出: Pi: 3.14159 (保留5位小数)

复制代码

标志修饰符

•

2. +：显示数字的正负号local num1 = 42
3. local num2 = -42
4. print(string.format("Num1: %+d", num1))  -- 输出: Num1: +42
5. print(string.format("Num2: %+d", num2))  -- 输出: Num2: -42

复制代码

•

2. 0：用0填充而不是空格local num = 42
3. print(string.format("Num: %05d", num))  -- 输出: Num: 00042

复制代码

•

2. #：对于%o，添加前缀0；对于%x/%X，添加前缀0x/0Xlocal num = 255
3. print(string.format("Octal: %#o", num))    -- 输出: Octal: 0377
4. print(string.format("Hex: %#x", num))      -- 输出: Hex: 0xff
5. print(string.format("Hex: %#X", num))      -- 输出: Hex: 0XFF

复制代码

•

2. （空格）：对于正数，在前面添加一个空格local num1 = 42
3. local num2 = -42
4. print(string.format("Num1: % d", num1))  -- 输出: Num1:  42 (注意前面的空格)
5. print(string.format("Num2: % d", num2))  -- 输出: Num2: -42

复制代码

+：显示数字的正负号

2. local num1 = 42
3. local num2 = -42
4. print(string.format("Num1: %+d", num1))  -- 输出: Num1: +42
5. print(string.format("Num2: %+d", num2))  -- 输出: Num2: -42

复制代码

0：用0填充而不是空格

2. local num = 42
3. print(string.format("Num: %05d", num))  -- 输出: Num: 00042

复制代码

#：对于%o，添加前缀0；对于%x/%X，添加前缀0x/0X

2. local num = 255
3. print(string.format("Octal: %#o", num))    -- 输出: Octal: 0377
4. print(string.format("Hex: %#x", num))      -- 输出: Hex: 0xff
5. print(string.format("Hex: %#X", num))      -- 输出: Hex: 0XFF

复制代码

（空格）：对于正数，在前面添加一个空格

2. local num1 = 42
3. local num2 = -42
4. print(string.format("Num1: % d", num1))  -- 输出: Num1:  42 (注意前面的空格)
5. print(string.format("Num2: % d", num2))  -- 输出: Num2: -42

复制代码

组合使用修饰符

可以组合使用多个修饰符来达到更复杂的格式化效果：

2. local pi = 3.14159
3. local num = 42
5. -- 宽度、精度和对齐的组合
6. print(string.format("Pi: %10.2f", pi))  -- 输出: Pi:       3.14 (总宽度10，保留2位小数，右对齐)
7. print(string.format("Pi: %-10.2f", pi)) -- 输出: Pi: 3.14      (总宽度10，保留2位小数，左对齐)
9. -- 标志、宽度和精度的组合
10. print(string.format("Num: %+05d", num))  -- 输出: Num: +0042 (显示符号，用0填充，总宽度5)
11. print(string.format("Num: %#06X", num))  -- 输出: Num: 0X002A (添加前缀，用0填充，总宽度6)

复制代码

实际应用案例

1. 表格对齐输出

在需要输出对齐的表格数据时，string.format非常有用：

2. local users = {
3.     {name = "Alice", age = 25, score = 95.5},
4.     {name = "Bob", age = 30, score = 87.2},
5.     {name = "Charlie", age = 35, score = 92.8}
6. }
8. -- 打印表头
9. print(string.format("%-10s | %3s | %5s", "Name", "Age", "Score"))
10. print(string.format("%-10s | %3s | %5s", "----------", "---", "-----"))
12. -- 打印数据行
13. for _, user in ipairs(users) do
14.     print(string.format("%-10s | %3d | %5.1f", user.name, user.age, user.score))
15. end

复制代码

输出结果：

2. Name       | Age | Score
3. ---------- | --- | -----
4. Alice      |  25 |  95.5
5. Bob        |  30 |  87.2
6. Charlie    |  35 |  92.8

复制代码

2. 货币格式化

格式化货币金额，添加千位分隔符和固定小数位数：

2. function formatCurrency(amount)
3.     -- 分离整数部分和小数部分
4.     local integer_part = math.floor(amount)
5.     local decimal_part = math.floor((amount - integer_part) * 100 + 0.5)
6.    
7.     -- 添加千位分隔符
8.     local formatted_integer = tostring(integer_part)
9.     local formatted_with_commas = ""
10.     local count = 0
11.    
12.     -- 从右到左遍历字符串，每3位添加一个逗号
13.     for i = #formatted_integer, 1, -1 do
14.         formatted_with_commas = formatted_integer:sub(i, i) .. formatted_with_commas
15.         count = count + 1
16.         if count % 3 == 0 and i > 1 then
17.             formatted_with_commas = "," .. formatted_with_commas
18.         end
19.     end
20.    
21.     -- 组合整数部分和小数部分
22.     return string.format("$%s.%02d", formatted_with_commas, decimal_part)
23. end
25. local price1 = 1234567.8912
26. local price2 = 42.5
27. local price3 = 1000
29. print(formatCurrency(price1))  -- 输出: $1,234,567.89
30. print(formatCurrency(price2))  -- 输出: $42.50
31. print(formatCurrency(price3))  -- 输出: $1,000.00

复制代码

3. 时间和日期格式化

虽然Lua没有内置的日期格式化函数，但可以使用os.date和string.format结合来创建自定义的日期时间格式：

2. -- 获取当前时间
3. local current_time = os.time()
5. -- 使用os.date获取时间组件
6. local year = os.date("%Y", current_time)
7. local month = os.date("%m", current_time)
8. local day = os.date("%d", current_time)
9. local hour = os.date("%H", current_time)
10. local min = os.date("%M", current_time)
11. local sec = os.date("%S", current_time)
13. -- 自定义格式
14. local formatted_date = string.format("%s-%s-%s %s:%s:%s", year, month, day, hour, min, sec)
15. print("Standard format:", formatted_date)  -- 输出类似: Standard format: 2023-05-15 14:30:45
17. -- 更友好的格式
18. local friendly_date = string.format("%s年%s月%s日 %s时%s分%s秒", year, month, day, hour, min, sec)
19. print("Friendly format:", friendly_date)  -- 输出类似: Friendly format: 2023年05月15日 14时30分45秒

复制代码

4. 进制转换

使用string.format进行不同进制之间的转换：

2. function convertBase(num, fromBase, toBase)
3.     -- 将原进制数转换为十进制
4.     local decimal = 0
5.     local power = 1
6.     local digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
7.    
8.     num = num:upper()
9.     for i = #num, 1, -1 do
10.         local digit = num:sub(i, i)
11.         local value = digits:find(digit) - 1
12.         if value >= fromBase then
13.             return nil, "Invalid digit for base " .. fromBase
14.         end
15.         decimal = decimal + value * power
16.         power = power * fromBase
17.     end
18.    
19.     -- 将十进制数转换为目标进制
20.     if toBase == 10 then
21.         return tostring(decimal)
22.     end
23.    
24.     local result = ""
25.     while decimal > 0 do
26.         local remainder = decimal % toBase
27.         result = digits:sub(remainder + 1, remainder + 1) .. result
28.         decimal = math.floor(decimal / toBase)
29.     end
30.    
31.     return result == "" and "0" or result
32. end
34. -- 示例：二进制转十进制
35. local bin_num = "1010"
36. local dec_num = convertBase(bin_num, 2, 10)
37. print(string.format("Binary %s to Decimal: %s", bin_num, dec_num))  -- 输出: Binary 1010 to Decimal: 10
39. -- 示例：十进制转十六进制
40. local dec_num2 = "255"
41. local hex_num = convertBase(dec_num2, 10, 16)
42. print(string.format("Decimal %s to Hexadecimal: %s", dec_num2, hex_num))  -- 输出: Decimal 255 to Hexadecimal: FF
44. -- 使用string.format直接进行十进制到其他进制的转换
45. local num = 255
46. print(string.format("Decimal %d to Octal: %o", num, num))      -- 输出: Decimal 255 to Octal: 377
47. print(string.format("Decimal %d to Hexadecimal: %X", num, num)) -- 输出: Decimal 255 to Hexadecimal: FF

复制代码

5. 数据可视化中的格式化

在简单的控制台数据可视化中，格式化输出非常有用：

2. -- 简单的水平条形图
3. function drawBarChart(data, labels, max_label_length)
4.     max_label_length = max_label_length or 10
5.     local max_value = 0
6.    
7.     -- 找出最大值
8.     for _, value in ipairs(data) do
9.         if value > max_value then
10.             max_value = value
11.         end
12.     end
13.    
14.     -- 计算比例因子
15.     local scale = 50 / max_value  -- 50是条形的最大长度
16.    
17.     -- 打印图表
18.     for i, value in ipairs(data) do
19.         local label = labels[i] or "Item " .. i
20.         local bar_length = math.floor(value * scale + 0.5)
21.         local bar = string.rep("=", bar_length)
22.         
23.         -- 格式化输出
24.         print(string.format("%-" .. max_label_length .. "s | %-50s | %6.2f",
25.               label, bar, value))
26.     end
27. end
29. -- 示例数据
30. local sales_data = {120, 85, 160, 95, 140}
31. local months = {"January", "February", "March", "April", "May"}
33. -- 绘制图表
34. print("Monthly Sales Chart:")
35. drawBarChart(sales_data, months, 9)

复制代码

输出结果：

2. Monthly Sales Chart:
3. January   | ================================================== | 120.00
4. February  | ==================================               |  85.00
5. March     | =============================================================== | 160.00
6. April     | =======================================         |  95.00
7. May       | =========================================================       | 140.00

复制代码

高级技巧

1. 动态格式化字符串

有时需要根据运行时条件动态构建格式化字符串：

2. function dynamicFormat(value, options)
3.     local format_str = "%"
4.    
5.     -- 添加标志
6.     if options.showSign then
7.         format_str = format_str .. "+"
8.     end
9.    
10.     -- 添加填充字符
11.     if options.padZero then
12.         format_str = format_str .. "0"
13.     end
14.    
15.     -- 添加宽度
16.     if options.width then
17.         format_str = format_str .. options.width
18.     end
19.    
20.     -- 添加精度
21.     if options.precision then
22.         format_str = format_str .. "." .. options.precision
23.     end
24.    
25.     -- 添加类型
26.     format_str = format_str .. (options.type or "f")
27.    
28.     return string.format(format_str, value)
29. end
31. -- 示例使用
32. local num = 123.456789
34. local options1 = {
35.     width = 10,
36.     precision = 2,
37.     type = "f"
38. }
39. print(dynamicFormat(num, options1))  -- 输出: "  123.46"
41. local options2 = {
42.     showSign = true,
43.     padZero = true,
44.     width = 10,
45.     precision = 3,
46.     type = "f"
47. }
48. print(dynamicFormat(num, options2))  -- 输出: "+0123.457"
50. local options3 = {
51.     width = 8,
52.     type = "X"
53. }
54. print(dynamicFormat(255, options3))  -- 输出: "      FF"

复制代码

2. 格式化复杂的数据结构

对于表等复杂数据结构，可以编写递归函数来格式化输出：

2. function formatTable(tbl, indent)
3.     indent = indent or 0
4.     local result = ""
5.     local indent_str = string.rep("  ", indent)
6.    
7.     result = result .. "{\n"
8.    
9.     for k, v in pairs(tbl) do
10.         result = result .. indent_str .. "  "
11.         
12.         -- 格式化键
13.         if type(k) == "string" then
14.             result = result .. string.format("%s = ", k)
15.         else
16.             result = result .. string.format("[%s] = ", tostring(k))
17.         end
18.         
19.         -- 格式化值
20.         if type(v) == "table" then
21.             result = result .. formatTable(v, indent + 1)
22.         elseif type(v) == "string" then
23.             result = result .. string.format("%q", v) .. ",\n"
24.         elseif type(v) == "number" then
25.             result = result .. string.format("%f", v) .. ",\n"
26.         elseif type(v) == "boolean" then
27.             result = result .. tostring(v) .. ",\n"
28.         else
29.             result = result .. tostring(v) .. ",\n"
30.         end
31.     end
32.    
33.     result = result .. indent_str .. "}"
34.     if indent > 0 then
35.         result = result .. ",\n"
36.     end
37.    
38.     return result
39. end
41. -- 示例使用
42. local data = {
43.     name = "John Doe",
44.     age = 30,
45.     scores = {math = 95, english = 88, science = 92},
46.     active = true,
47.     address = {
48.         street = "123 Main St",
49.         city = "Anytown",
50.         zip = 12345
51.     }
52. }
54. print(formatTable(data))

复制代码

输出结果：

2. {
3.   active = true,
4.   address = {
5.     city = "Anytown",
6.     street = "123 Main St",
7.     zip = 12345.000000,
8.   },
9.   age = 30.000000,
10.   name = "John Doe",
11.   scores = {
12.     english = 88.000000,
13.     math = 95.000000,
14.     science = 92.000000,
15.   },
16. }

复制代码

3. 本地化格式化

对于需要考虑本地化的应用程序，可以创建本地化格式化函数：

2. -- 本地化设置
3. local locales = {
4.     en_US = {
5.         decimal_point = ".",
6.         thousands_sep = ",",
7.         currency_symbol = "$",
8.         currency_format = "%s%s",  -- 符号在前
9.         date_format = "%m/%d/%Y",
10.         time_format = "%I:%M:%S %p"
11.     },
12.     de_DE = {
13.         decimal_point = ",",
14.         thousands_sep = ".",
15.         currency_symbol = "€",
16.         currency_format = "%s %s",  -- 符号在后
17.         date_format = "%d.%m.%Y",
18.         time_format = "%H:%M:%S"
19.     },
20.     ja_JP = {
21.         decimal_point = ".",
22.         thousands_sep = ",",
23.         currency_symbol = "¥",
24.         currency_format = "%s%s",  -- 符号在前
25.         date_format = "%Y/%m/%d",
26.         time_format = "%H:%M:%S"
27.     }
28. }
30. -- 当前本地化设置
31. local current_locale = "en_US"
33. function setLocale(locale)
34.     if locales[locale] then
35.         current_locale = locale
36.         return true
37.     end
38.     return false
39. end
41. function formatLocalizedNumber(num)
42.     local locale = locales[current_locale]
43.     local formatted = tostring(num)
44.    
45.     -- 处理小数部分
46.     local integer_part, decimal_part = formatted:match("^(%d+)%.?(%d*)$")
47.    
48.     -- 添加千位分隔符
49.     local formatted_integer = ""
50.     local count = 0
51.     for i = #integer_part, 1, -1 do
52.         formatted_integer = integer_part:sub(i, i) .. formatted_integer
53.         count = count + 1
54.         if count % 3 == 0 and i > 1 then
55.             formatted_integer = locale.thousands_sep .. formatted_integer
56.         end
57.     end
58.    
59.     -- 组合整数和小数部分
60.     if decimal_part and decimal_part ~= "" then
61.         formatted = formatted_integer .. locale.decimal_point .. decimal_part
62.     else
63.         formatted = formatted_integer
64.     end
65.    
66.     return formatted
67. end
69. function formatLocalizedCurrency(amount)
70.     local locale = locales[current_locale]
71.     local formatted_num = formatLocalizedNumber(amount)
72.    
73.     -- 根据本地化设置格式化货币
74.     if locale.currency_format == "%s%s" then
75.         return string.format(locale.currency_format, locale.currency_symbol, formatted_num)
76.     else
77.         return string.format(locale.currency_format, formatted_num, locale.currency_symbol)
78.     end
79. end
81. -- 示例使用
82. local amount = 1234567.89
84. setLocale("en_US")
85. print("US format: " .. formatLocalizedCurrency(amount))  -- 输出: US format: $1,234,567.89
87. setLocale("de_DE")
88. print("German format: " .. formatLocalizedCurrency(amount))  -- 输出: German format: 1.234.567,89 €
90. setLocale("ja_JP")
91. print("Japanese format: " .. formatLocalizedCurrency(amount))  -- 输出: Japanese format: ¥1,234,567.89

复制代码

4. 安全格式化

当处理用户提供的格式化字符串时，需要防止格式化字符串注入攻击：

2. function safeFormat(template, ...)
3.     -- 转义所有格式说明符
4.     local escaped = template:gsub("%%", "%%%%")
5.    
6.     -- 使用转义后的模板进行格式化
7.     return string.format(escaped, ...)
8. end
10. -- 示例使用
11. local user_input = "Hello %s, your balance is %d"
12. local name = "Alice"
13. local balance = 1000
15. -- 不安全的格式化（可能被攻击）
16. -- print(string.format(user_input, name, balance))  -- 这会出错，因为模板中有未处理的格式说明符
18. -- 安全的格式化
19. print(safeFormat(user_input, name, balance))  -- 输出: Hello %s, your balance is %d

复制代码

5. 条件格式化

根据条件应用不同的格式：

2. function conditionalFormat(value, conditions)
3.     for _, condition in ipairs(conditions) do
4.         if condition.test(value) then
5.             return condition.format(value)
6.         end
7.     end
8.    
9.     -- 默认格式
10.     return tostring(value)
11. end
13. -- 示例使用
14. local number = 12345.6789
16. local conditions = {
17.     {
18.         test = function(v) return v >= 10000 end,
19.         format = function(v) return string.format("Large: %.2e", v) end
20.     },
21.     {
22.         test = function(v) return v >= 1000 end,
23.         format = function(v) return string.format("Medium: %.2f", v) end
24.     },
25.     {
26.         test = function(v) return v >= 0 end,
27.         format = function(v) return string.format("Small: %.2f", v) end
28.     },
29.     {
30.         test = function(v) return v < 0 end,
31.         format = function(v) return string.format("Negative: %.2f", v) end
32.     }
33. }
35. print(conditionalFormat(number, conditions))  -- 输出: Large: 1.23e+04
37. print(conditionalFormat(500, conditions))    -- 输出: Medium: 500.00
38. print(conditionalFormat(50, conditions))     -- 输出: Small: 50.00
39. print(conditionalFormat(-50, conditions))    -- 输出: Negative: -50.00

复制代码

性能考虑和最佳实践

1. 避免频繁的字符串连接

在需要构建复杂字符串时，频繁使用字符串连接（..）可能会导致性能问题。可以使用table.concat和string.format结合来提高性能：

2. -- 低效方式
3. local result = ""
4. for i = 1, 1000 do
5.     result = result .. string.format("Item %d: %s\n", i, tostring(i))
6. end
8. -- 高效方式
9. local parts = {}
10. for i = 1, 1000 do
11.     parts[#parts + 1] = string.format("Item %d: %s", i, tostring(i))
12. end
13. local result = table.concat(parts, "\n")

复制代码

2. 预编译格式化字符串

在循环中重复使用相同的格式化字符串时，可以预编译格式化字符串以提高性能：

2. -- 低效方式
3. for i = 1, 1000 do
4.     local message = string.format("Processing item %d of %d (%.1f%%)", i, 1000, i/10)
5.     -- 使用message...
6. end
8. -- 高效方式
9. local format_str = "Processing item %d of %d (%.1f%%)"
10. for i = 1, 1000 do
11.     local message = string.format(format_str, i, 1000, i/10)
12.     -- 使用message...
13. end

复制代码

3. 缓存格式化结果

如果相同的值需要多次格式化，可以考虑缓存格式化结果：

2. local format_cache = {}
4. function cachedFormat(fmt, ...)
5.     local key = fmt .. table.concat({...}, "|")
6.    
7.     if not format_cache[key] then
8.         format_cache[key] = string.format(fmt, ...)
9.     end
10.    
11.     return format_cache[key]
12. end
14. -- 示例使用
15. local name = "Alice"
16. local age = 25
18. -- 第一次调用会计算并缓存
19. local message1 = cachedFormat("Name: %s, Age: %d", name, age)
21. -- 第二次调用直接从缓存获取
22. local message2 = cachedFormat("Name: %s, Age: %d", name, age)
24. print(message1)  -- 输出: Name: Alice, Age: 25
25. print(message2)  -- 输出: Name: Alice, Age: 25

复制代码

4. 限制缓存大小

为了避免缓存过大，可以实现一个带有大小限制的缓存：

2. local LimitedCache = {}
3. LimitedCache.__index = LimitedCache
5. function LimitedCache.new(max_size)
6.     return setmetatable({
7.         items = {},
8.         max_size = max_size or 100,
9.         order = {}
10.     }, LimitedCache)
11. end
13. function LimitedCache:get(key)
14.     return self.items[key]
15. end
17. function LimitedCache:set(key, value)
18.     -- 如果键已存在，更新值
19.     if self.items[key] then
20.         self.items[key] = value
21.         return
22.     end
23.    
24.     -- 如果缓存已满，删除最旧的项
25.     if #self.order >= self.max_size then
26.         local oldest_key = table.remove(self.order, 1)
27.         self.items[oldest_key] = nil
28.     end
29.    
30.     -- 添加新项
31.     self.items[key] = value
32.     table.insert(self.order, key)
33. end
35. local format_cache = LimitedCache.new(100)
37. function cachedFormatWithLimit(fmt, ...)
38.     local key = fmt .. table.concat({...}, "|")
39.    
40.     local cached = format_cache:get(key)
41.     if not cached then
42.         cached = string.format(fmt, ...)
43.         format_cache:set(key, cached)
44.     end
45.    
46.     return cached
47. end

复制代码

常见问题和解决方案

1. 格式化字符串中的百分号问题

当需要在格式化字符串中包含百分号时，必须使用双百分号（%%）来转义：

2. local percentage = 50
3. -- 错误方式
4. -- print(string.format("Progress: %d%", percentage))  -- 这会出错
6. -- 正确方式
7. print(string.format("Progress: %d%%", percentage))  -- 输出: Progress: 50%

复制代码

2. 格式化nil值

尝试格式化nil值会导致错误：

2. -- 错误方式
3. -- print(string.format("Value: %s", nil))  -- 这会出错
5. -- 解决方案1：使用默认值
6. local value = nil
7. print(string.format("Value: %s", value or "N/A"))  -- 输出: Value: N/A
9. -- 解决方案2：创建安全的格式化函数
10. function safeFormat(fmt, ...)
11.     local args = {...}
12.     for i, arg in ipairs(args) do
13.         if arg == nil then
14.             args[i] = "nil"
15.         end
16.     end
17.     return string.format(fmt, unpack(args))
18. end
20. print(safeFormat("Value: %s", nil))  -- 输出: Value: nil

复制代码

3. 格式化表类型

string.format不能直接格式化表类型：

2. -- 错误方式
3. -- local data = {name = "Alice", age = 25}
4. -- print(string.format("Data: %s", data))  -- 这会出错
6. -- 解决方案：自定义表格式化函数
7. function formatTableSimple(tbl)
8.     if type(tbl) ~= "table" then
9.         return tostring(tbl)
10.     end
11.    
12.     local result = "{"
13.     local first = true
14.    
15.     for k, v in pairs(tbl) do
16.         if not first then
17.             result = result .. ", "
18.         end
19.         first = false
20.         
21.         if type(k) == "string" then
22.             result = result .. k .. "="
23.         else
24.             result = result .. "[" .. tostring(k) .. "]="
25.         end
26.         
27.         if type(v) == "string" then
28.             result = result .. '"' .. v .. '"'
29.         elseif type(v) == "table" then
30.             result = result .. formatTableSimple(v)
31.         else
32.             result = result .. tostring(v)
33.         end
34.     end
35.    
36.     return result .. "}"
37. end
39. local data = {name = "Alice", age = 25, scores = {math = 95, english = 88}}
40. print(string.format("Data: %s", formatTableSimple(data)))
41. -- 输出: Data: {name="Alice", age=25, scores={math=95, english=88}}

复制代码

4. 处理宽字符和Unicode

Lua的string.format对宽字符和Unicode的支持有限，特别是在长度计算方面：

2. -- 示例：中文字符
3. local chinese = "中文"
4. print(string.format("Length of '%s': %d", chinese, #chinese))  -- 输出: Length of '中文': 4 (而不是2)
6. -- 解决方案：使用UTF-8长度计算函数
7. function utf8len(str)
8.     local len = 0
9.     local i = 1
10.     while i <= #str do
11.         local byte = str:byte(i)
12.         if byte >= 240 then
13.             len = len + 1
14.             i = i + 4
15.         elseif byte >= 224 then
16.             len = len + 1
17.             i = i + 3
18.         elseif byte >= 192 then
19.             len = len + 1
20.             i = i + 2
21.         else
22.             len = len + 1
23.             i = i + 1
24.         end
25.     end
26.     return len
27. end
29. print(string.format("UTF-8 length of '%s': %d", chinese, utf8len(chinese)))  -- 输出: UTF-8 length of '中文': 2

复制代码

5. 格式化精度问题

浮点数格式化时可能会遇到精度问题：

2. local num = 0.1 + 0.2
3. print(string.format("0.1 + 0.2 = %.17f", num))  -- 输出: 0.1 + 0.2 = 0.30000000000000004
5. -- 解决方案：使用四舍五入函数
6. function round(num, decimal_places)
7.     local mult = 10 ^ (decimal_places or 0)
8.     return math.floor(num * mult + 0.5) / mult
9. end
11. print(string.format("Rounded: %.2f", round(num, 2)))  -- 输出: Rounded: 0.30

复制代码

总结

Lua的string.format函数是一个强大而灵活的工具，可以帮助开发者以各种方式格式化输出数据。从基本的数字和字符串格式化，到复杂的表格对齐、数据可视化和本地化输出，string.format都能胜任。

通过掌握各种格式说明符和修饰符，开发者可以精确控制输出的格式，满足各种应用场景的需求。同时，了解高级技巧如动态格式化、条件格式化和安全格式化，可以帮助开发者编写更健壮、更灵活的代码。

在实际应用中，还需要考虑性能因素，避免不必要的字符串操作，合理使用缓存和预编译技术。同时，处理常见问题如nil值格式化、Unicode字符和浮点数精度等，也是编写高质量代码的重要方面。

通过本文的介绍和示例，希望开发者能够全面掌握Lua中的格式化输出技术，在实际编程中更加得心应手，创造出更加优雅、高效的代码。