7.3 字符串与数值的转换

7.3 字符串与数值的转换

Lua字符串与数值的转换详解

在Lua编程中，字符串 (String) 和数值 (Number) 是两种最基本且常用的数据类型。由于Lua的动态类型特性，变量的类型并非固定不变，因此在实际开发中，字符串和数值之间的转换操作非常频繁且重要。理解和掌握Lua中字符串与数值之间的转换方法，对于编写健壮、高效的Lua代码至关重要。

本文将深入探讨Lua中字符串与数值的转换，包括：

1. 字符串转换为数值 (String to Number)：

   • 使用 tonumber() 函数进行转换。

   • 详解 tonumber() 函数的工作原理、参数和返回值。

   • 探讨不同进制字符串的转换 (十进制、十六进制、八进制、二进制)。

   • 处理转换失败的情况以及错误处理。

   • 实际代码示例和应用场景。

2. 数值转换为字符串 (Number to String)：

   • 使用 tostring() 函数进行简单转换。

   • 使用 string.format() 函数进行格式化转换。

   • 详解 string.format() 函数的格式化控制符，包括数值类型的格式化。

   • 实现各种数值格式化需求，例如：

     • 指定小数位数。

     • 使用科学计数法。

     • 填充和对齐。

     • 不同进制的字符串表示 (十六进制、八进制)。

   • 实际代码示例和应用场景。

3. 最佳实践和注意事项：

   • 性能考量。

   • 代码可读性和维护性。

   • 错误处理和健壮性。

1. 字符串转换为数值 (String to Number)

在Lua中，将字符串转换为数值最常用的方法是使用内置函数 tonumber()。

1.1 tonumber() 函数详解

tonumber() 函数的语法格式如下：

tonumber (e [, base])
​

• 参数 e: 要转换为数值的字符串表达式。它可以是任何Lua表达式，但通常是一个字符串变量或字符串字面量。

• 参数 base (可选): 指定数值的进制。这是一个可选的整数参数，取值范围为 2 到 36 (包含 2 和 36)。

  • 如果省略 base 参数或为 nil，tonumber() 默认将字符串 e 视为 十进制数 进行转换。

  • 如果指定了 base 参数，tonumber() 将根据指定的进制来解析字符串 e。例如，base 为 16 表示十六进制，base 为 8 表示八进制，base 为 2 表示二进制。

返回值:

• 如果字符串 e 可以成功转换为数值，tonumber() 函数将返回转换后的数值。

• 如果字符串 e 不能 转换为数值 (例如，字符串不是一个有效的数字表示形式)，tonumber() 函数将返回 nil。

1.2 十进制字符串转换

当 tonumber() 函数不指定 base 参数或 base 为 nil 时，它会将字符串视为十进制数进行转换。

代码示例:

local str_decimal = "123"
local num_decimal = tonumber(str_decimal)
print(type(num_decimal))  -- 输出: number
print(num_decimal)       -- 输出: 123
local str_float = "3.14159"
local num_float = tonumber(str_float)
print(type(num_float))  -- 输出: number
print(num_float)       -- 输出: 3.14159
local str_negative = "-42"
local num_negative = tonumber(str_negative)
print(type(num_negative))  -- 输出: number
print(num_negative)       -- 输出: -42
local str_zero = "0"
local num_zero = tonumber(str_zero)
print(type(num_zero))  -- 输出: number
print(num_zero)       -- 输出: 0
local str_invalid = "abc"
local num_invalid = tonumber(str_invalid)
print(type(num_invalid))  -- 输出: nil
print(num_invalid)       -- 输出: nil
local str_empty = ""
local num_empty = tonumber(str_empty)
print(type(num_empty))  -- 输出: nil
print(num_empty)       -- 输出: nil
local str_whitespace = "  123  "
local num_whitespace = tonumber(str_whitespace)
print(type(num_whitespace)) -- 输出: nil
print(num_whitespace)      -- 输出: nil  (注意：tonumber 不会自动去除首尾空格)
local str_whitespace_inside = "12 3"
local num_whitespace_inside = tonumber(str_whitespace_inside)
print(type(num_whitespace_inside)) -- 输出: nil
print(num_whitespace_inside)      -- 输出: nil  (字符串中间有空格也无法转换)
​

详解:

• tonumber() 可以正确转换表示整数、浮点数和负数的十进制字符串。

• 字符串 "0" 会被转换为数值 0。

• 当字符串不是有效的十进制数字表示形式时 (例如 "abc", "", " 123 ", "12 3")，tonumber() 返回 nil。

• 重要: tonumber() 不会自动去除字符串首尾的空格，也不允许字符串中间包含空格。如果字符串包含这些无效字符，转换会失败并返回 nil。

1.3 不同进制字符串转换

tonumber() 函数的第二个可选参数 base 允许我们指定字符串所表示的数值的进制。常用的进制包括：

• 十六进制 (base = 16): 使用数字 0-9 和字母 a-f (或 A-F) 表示。

• 八进制 (base = 8): 使用数字 0-7 表示。

• 二进制 (base = 2): 使用数字 0 和 1 表示。

代码示例:

-- 十六进制字符串转换
local str_hex = "FF"
local num_hex = tonumber(str_hex, 16)
print(type(num_hex))  -- 输出: number
print(num_hex)       -- 输出: 255
local str_hex_lower = "ff"
local num_hex_lower = tonumber(str_hex_lower, 16)
print(num_hex_lower)   -- 输出: 255 (大小写不敏感)
local str_hex_prefix = "0xFF" -- 某些语言中十六进制会加前缀 0x，Lua tonumber 不需要
local num_hex_prefix = tonumber(str_hex_prefix, 16) -- 仍然可以正常转换
print(num_hex_prefix)   -- 输出: 255
-- 八进制字符串转换
local str_octal = "377"
local num_octal = tonumber(str_octal, 8)
print(type(num_octal))  -- 输出: number
print(num_octal)       -- 输出: 255
local str_octal_prefix = "0377" -- 某些语言中八进制会加前缀 0，Lua tonumber 不需要
local num_octal_prefix = tonumber(str_octal_prefix, 8) -- 仍然可以正常转换
print(num_octal_prefix)   -- 输出: 255
-- 二进制字符串转换
local str_binary = "11111111"
local num_binary = tonumber(str_binary, 2)
print(type(num_binary))  -- 输出: number
print(num_binary)       -- 输出: 255
local str_binary_invalid = "101012" -- 二进制字符串包含无效字符 '2'
local num_binary_invalid = tonumber(str_binary_invalid, 2)
print(type(num_binary_invalid)) -- 输出: nil
print(num_binary_invalid)      -- 输出: nil
​

详解:

• 通过指定 base 参数，tonumber() 可以正确解析十六进制、八进制和二进制字符串。

• 十六进制字符串可以使用大写或小写字母 (a-f 或 A-F)。

• 对于十六进制和八进制，即使字符串带有某些语言中常用的前缀 ("0x" 或 "0")，tonumber() 也能正常转换，但这并非必须，Lua 的 tonumber 函数本身并不需要这些前缀。

• 如果字符串中包含对于指定进制无效的字符 (例如，二进制字符串包含 '2' )，tonumber() 会返回 nil。

1.4 处理转换失败和错误处理

当 tonumber() 转换失败时，它会返回 nil。在实际编程中，我们需要检查 tonumber() 的返回值是否为 nil，以判断转换是否成功，并进行相应的错误处理。

代码示例:

local input_str = io.read() -- 从用户读取输入
local num = tonumber(input_str)
if num == nil then
  print("输入无效，无法转换为数值！")
else
  print("成功转换为数值:", num)
  -- 在这里可以对数值进行后续操作
end
​

应用场景:

• 用户输入验证: 当需要从用户获取数值输入时，可以使用 tonumber() 验证输入是否为有效的数字格式。

• 配置文件解析: 配置文件中可能以字符串形式存储数值数据，需要使用 tonumber() 将其转换为数值类型进行处理。

• 数据类型转换: 在进行数值计算或数据处理时，有时需要将从其他数据源 (如数据库、文件) 读取的字符串数据转换为数值类型。

2. 数值转换为字符串 (Number to String)

Lua提供了两种主要的方法将数值转换为字符串：

• tostring() 函数: 用于简单的数值到字符串的转换，通常采用默认的格式。

• string.format() 函数: 提供更强大的格式化控制，可以自定义数值字符串的输出格式。

2.1 tostring() 函数详解

tostring() 函数的语法格式非常简单：

tostring (v)
​

• 参数 v: 要转换为字符串的值。可以是任何Lua值，包括数值。

返回值:

• tostring() 函数返回参数 v 的字符串表示形式。对于数值类型，它会返回一个表示该数值的字符串。

代码示例:

local num_int = 123
local str_int = tostring(num_int)
print(type(str_int))  -- 输出: string
print(str_int)       -- 输出: "123"
local num_float = 3.14159
local str_float = tostring(num_float)
print(type(str_float))  -- 输出: string
print(str_float)       -- 输出: "3.14159"
local num_negative = -42
local str_negative = tostring(num_negative)
print(type(str_negative)) -- 输出: string
print(str_negative)      -- 输出: "-42"
local num_zero = 0
local str_zero = tostring(num_zero)
print(type(str_zero))  -- 输出: string
print(str_zero)       -- 输出: "0"
​

详解:

• tostring() 函数可以将整数、浮点数和负数转换为对应的字符串表示。

• 对于浮点数，tostring() 通常会保留一定的小数位数，但具体的位数可能取决于Lua的实现和数值的精度。

• tostring() 的转换结果是默认的字符串表示形式，无法进行更精细的格式控制。

2.2 string.format() 函数详解

string.format() 函数提供了强大的字符串格式化功能，可以灵活地控制数值转换为字符串的格式。它的语法格式如下：

string.format (formatstring, ...)
​

• 参数 formatstring: 格式化字符串，用于指定输出字符串的格式。它包含普通文本和格式化控制符。

• 参数 ...: 要格式化的值，可以有多个值，与格式化控制符一一对应。

格式化控制符:

格式化控制符以百分号 % 开头，后面跟随一个或多个字符，用于指定如何格式化对应位置的参数。 对于数值类型，常用的格式化控制符包括：

• %d 或 %i: 格式化为 十进制整数。

• %f: 格式化为 浮点数 (默认保留6位小数)。

• %e 或 %E: 格式化为 科学计数法。%e 使用小写 'e'，%E 使用大写 'E'。

• %x 或 %X: 格式化为 十六进制整数。%x 使用小写字母 (a-f)，%X 使用大写字母 (A-F)。

• %o: 格式化为 八进制整数。

• %b: 格式化为 二进制整数 (Lua 5.3+ 版本支持)。

修饰符:

可以在格式化控制符的百分号 % 和类型字符之间添加修饰符，以进一步控制格式化输出。常用的修饰符包括：

• 宽度修饰符: 一个数字，指定输出字段的最小宽度。如果输出字符串的长度小于宽度，则会进行填充 (默认用空格填充)。

  • 例如: %5d 表示输出十进制整数，字段宽度至少为 5。

• 精度修饰符: 一个小数点 . 后跟一个数字，用于指定浮点数的小数位数或字符串的最大长度。

  • 例如: %.2f 表示输出浮点数，保留两位小数。

  • 例如: %.5s 表示输出字符串，最多显示 5 个字符。

• 对齐修饰符: - 标志，表示左对齐。默认情况下是右对齐 (对于数值和字符串)。

  • 例如: %-5d 表示输出左对齐的十进制整数，字段宽度至少为 5。

• 填充字符: 0 标志，当使用宽度修饰符且输出字符串长度小于宽度时，用 '0' 而不是空格进行填充 (通常用于数值类型)。

  • 例如: %05d 表示输出十进制整数，字段宽度至少为 5，用 '0' 填充。

2.3 数值格式化示例

代码示例:

local num = 123.456
-- 格式化为整数
local str_int_format = string.format("%d", num)
print(str_int_format)       -- 输出: 123 (浮点数会被截断为整数)
-- 格式化为浮点数，保留两位小数
local str_float_2decimal = string.format("%.2f", num)
print(str_float_2decimal)   -- 输出: 123.46 (注意四舍五入)
-- 格式化为浮点数，保留零位小数 (相当于四舍五入到整数)
local str_float_0decimal = string.format("%.0f", num)
print(str_float_0decimal)   -- 输出: 123
-- 格式化为科学计数法
local str_scientific_e = string.format("%e", num)
print(str_scientific_e)     -- 输出: 1.234560e+02
local str_scientific_E = string.format("%E", num)
print(str_scientific_E)     -- 输出: 1.234560E+02
-- 格式化为十六进制整数
local str_hex_format = string.format("%x", 255)
print(str_hex_format)       -- 输出: ff
local str_hex_format_upper = string.format("%X", 255)
print(str_hex_format_upper) -- 输出: FF
-- 格式化为八进制整数
local str_octal_format = string.format("%o", 255)
print(str_octal_format)     -- 输出: 377
-- 格式化为二进制整数 (Lua 5.3+)
local str_binary_format = string.format("%b", 255)
print(str_binary_format)     -- 输出: 11111111
-- 使用宽度修饰符和填充字符
local str_padded = string.format("%05d", 12)
print(str_padded)           -- 输出: 00012 (右对齐，用 '0' 填充)
local str_left_aligned = string.format("%-5d", 12)
print(str_left_aligned .. "|") -- 输出: 12   | (左对齐，用空格填充，为了显示对齐效果加了 '|')
-- 格式化多个数值
local x = 10
local y = 20
local formatted_str = string.format("x = %d, y = %d", x, y)
print(formatted_str)        -- 输出: x = 10, y = 20
​

详解:

• string.format() 提供了丰富的格式化控制符和修饰符，可以满足各种数值格式化需求。

• 可以使用精度修饰符来控制浮点数的小数位数，并注意四舍五入的行为。

• 可以使用宽度修饰符和填充字符来控制输出字段的宽度和填充方式，实现对齐效果。

• 可以使用不同的格式化控制符将数值转换为不同进制的字符串表示 (十六进制、八进制、二进制)。

• string.format() 可以同时格式化多个数值，通过在格式化字符串中使用多个格式化控制符，并按顺序提供要格式化的数值参数。

应用场景:

• 用户界面显示: 将数值格式化为易于阅读的字符串，例如显示金额、百分比、温度等。

• 日志输出: 将数值数据格式化到日志文件中，方便分析和调试。

• 数据导出和报告生成: 将数值数据格式化为特定格式的字符串，用于导出到文件或生成报告。

• 字符串拼接: 在字符串中嵌入数值变量时，可以使用 string.format() 进行格式化，比简单的字符串连接 .. 更清晰和灵活。

3. 最佳实践和注意事项

3.1 性能考量

• tonumber() 和 tostring() 的性能: 这两个内置函数通常都非常高效，对于一般的转换操作，性能影响可以忽略不计。

• string.format() 的性能: string.format() 的性能略低于 tostring()，因为格式化过程涉及到字符串解析和处理。但是，对于大多数应用场景，string.format() 的性能仍然足够好。

• 避免不必要的转换: 在代码中，尽量避免不必要的字符串和数值之间的频繁转换，特别是在循环或性能敏感的代码段中。如果可能，尽量保持数据类型的一致性，减少类型转换的开销。

3.2 代码可读性和维护性

• 选择合适的转换方法: 根据实际需求选择合适的转换方法。对于简单的转换，可以使用 tostring() 和 tonumber()。对于需要精细格式控制的场景，应该使用 string.format()。

• 使用清晰的代码: 在代码中明确地进行类型转换，并添加必要的注释，提高代码的可读性和可维护性。

• 避免隐式类型转换: Lua允许某些隐式类型转换，例如在算术运算中，字符串 "10" 可以隐式转换为数值 10。但是，为了代码的清晰性和避免潜在的错误，建议显式地进行类型转换。

3.3 错误处理和健壮性

• 检查 tonumber() 的返回值: 务必检查 tonumber() 的返回值是否为 nil，以处理字符串转换失败的情况。

• 处理用户输入错误: 当从用户获取输入并尝试转换为数值时，要充分考虑用户可能输入无效的字符串，并进行适当的错误提示和处理。

• 考虑异常情况: 在进行字符串和数值转换时，要考虑到各种可能的异常情况，例如空字符串、包含无效字符的字符串、超出数值范围的字符串等，并编写健壮的代码来处理这些情况。

总结

Lua 提供了简单而强大的机制来处理字符串和数值之间的转换。tonumber() 函数用于将字符串转换为数值，而 tostring() 和 string.format() 函数用于将数值转换为字符串，后者提供了更丰富的格式化选项。理解和熟练掌握这些转换方法，并结合最佳实践和注意事项，可以帮助我们编写更高效、健壮、易于维护的Lua代码。在实际开发中，根据具体需求选择合适的转换方法，并进行充分的错误处理，是保证程序稳定性和用户体验的关键。