整型值和浮点型值的类型都是 number ，它们之间可以相互转换。而且，具有相同算术值的整型值和浮点型值在 Lua 语言中都是相同的：

1
2
3
4
5
6
7
8

> type(1)
number
> type(1.00)
number
> 1 == 1.00
true
> 1 == 0.01e2
true

如果的确需要区分整型值和浮点型值时，可以使用函数 math.type ：

1
2
3
4

> math.type(1)
integer
> math.type(1.00)
float

1
2
3
4
5
6

> math.type(1.00)
float
> math.type(1e0)
float
> math.type(1e2)
float

Lua 也支持以 0x 开头的十六进制常量，而且支持十六进制的浮点数，这种十六进制浮点数由小数部分和以 p 或 P 开头的指数部分组成。在函数 string.format 中可以使用 %a 参数进行该格式的格式化输出。 这种格式可以保存所有浮点数的精度。而且比十进制转换速度更快 。

1
2
3
4
5
6
7
8
9
10

> 0xff
255
> 0x1A3
419
> 0x0.2
0.125
> 0x1p-1
0.5
> 0xa.bp2
42.75

对于算术运算符 +、-、*、/、//（整除）、%（取模）、^（幂等） ，如果两个操作数都是整型，那么结果也是整型值，否则就是浮点型值。但是对于除法和幂等运算不遵循上述规则，为了避免两个整型值相除（不一定能整除）和两个浮点型值相除导致不一样的结果，除法运算操作操作的永远是浮点数且产生浮点型结果。

1
2
3
4
5
6
7
8
9
10
11
12
13

> 2 + 4
6
> 2.0 + 4.0
6.0
> 2 + 4 == 2.0 + 4.0
true

> 4 / 2
2.0
> 4.0 / 2.0
2.0
> 4 / 2 == 4.0 / 2.0
true

和除法一样，幂等运算的操作数也永远是浮点型，例如 2^-2 其实就是执行除法运算。

1
2
3
4
5

> 2 ^ -2
0.25

> 4 ^ 0.5
2.0

整除（floor） // 会将得到的商向负无穷取整，从而保证结果是一个整数。因此它就和其他算术运算符遵循同样的规则：如果操作数是整型，那么结果就是整型，否则就是浮点型值（其值是一个整数）。

1
2
3
4
5
6

> 3 // 2
1
> 3.0 // 2.0
1.0
> 3 // 2 == 3.0 // 2.0
true

取模运算的定义为 a % b == a - ((a // b) * b) 。对于整型操作数而言，取模运算结果的符号永远与第二个操作数的符号保持一致。对于实数类型的操作数而言，取模运算则有些不同， x - x % 0.01 恰好是 x 保留两位小数的结果， x - x % 0.001 恰好是 x 保留三位小数的结果。

1
2
3
4
5

> x = 3.1415927
> x % 0.01
0.0015926999999998
> x - x % 0.01
3.14

在二元运算符中，除了幂运算和连接操作符是右结合之外，其他运算符都是左结合的。当不能确定某些表达式的运算符优先级时，应该显式地用括号来指定所希望的运算次序。

Lua 中的字符串是不可变值，只能通过创建一个新的字符串的方式来达到修改目的。Lua 中的字符串也是自动内存管理的对象之一，即 Lua 语言会负责字符串内存的分配和释放。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

> a = "hello"
> print(#a)
5
> "hello".."world"
helloworld
> "3"..2
32
> 3..2
stdin:1: malformed number near '3..2'
> a = "hello"
> a.."world"
helloworld
> a
hello

Lua 字符串支持 C 语言风格的转义字符，例如 \n 等。也可以通过转义序列 \ddd 和 \xhh 来声明字符，其中 ddd 是由最多 3 个十进制数字组成的序列， hh 是由两个且必须是两个的十六进制数字组成的序列。

从 Lua5.3 开始，也支持使用转义序列 \u{h..h} 来声明 UTF-8 字符，花括号中可以支持任意有效的十六进制。

当内容中本身含有双括号时，可以在两个左方括号之间加上任意数量的等号，例如 [===[ ，这样字符串常量只有在遇到了包含相同数量等号的两个右方括号时才会结束（本例中即 ]===] 。Lua 语法扫描器会忽略所含等号数量不相同的方括号。通过选择恰当数量的等号，就可以无需修改原字符串的情况下声明任意的字符串常量。对于注释，这种机制同样有效，例如使用 --[=[ 和 ]=] 来进行长注释，从而降低对内部已经包含注释的代码进行注释的难度。

从 Lua5.2 开始引入了转义序列 \z ，该转义符会跳过其后的所有空白字符，直到遇到第一个非空白字符。

1
2
3
4
5
6

> print(10 .. 20)
1020
> print(10..20)
stdin:1: malformed number near '10..20'
> print(10.."20")
stdin:1: malformed number near '10..'

注意，当数值之后紧接着使用字符串连接时，必须使用空格将它们分开，否则 Lua 语言会将第一个点当成小数点 。

使用 tonumber 可以显式地将一个字符串转换成数值。默认该函数使用十进制，但也可以指定二进制到三十六进制之间的任意进制。使用 tostring 可以将数值转换为字符串。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

> tonumber("   -3")
-3
> tonumber(" 10e4 ")
100000.0
> tonumber("0x1.3p-4")
0.07421875
> tonumber("1010", 2)
10
> tonumber("ff", 16)
255
> tonumber("989", 8)
nil

> tostring(10)
10
> tostring(0x16)
22
> type(tostring(10))
string

注意，比较操作符不会对操作数进行强制类型转换。当比较运算符中混用了字符串和数值时，Lua 会抛出异常。

1
2
3
4
5
6
7

> 2 < "2"
stdin:1: attempt to compare number with string
stack traceback:
        stdin:1: in main chunk
        [C]: in ?
> 2 == "2"
false

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

> string.lower("Hello")
hello
> string.upper("Hello")
HELLO

> string.char(65, 66, 67)
ABC
> string.byte("ABC", 2)
66
> string.byte("ABC", -1)
67

> string.format("%s %d %d", "1", 10, -1)
1 10 -1
> string.format("%x", 31)
1f
> string.format("<%s>%s<%s>", "h1", "hello", "h1")
<h1>hello<h1>

> string.find("hello world", "wor")
7       9
> string.find("hello world", "war")
nil
> string.gsub("hello world", "wor", "xxx")
hello xxxld     1

也可以可以使用冒号操作符像调用字符串的一个方法那样来调用字符串标准库中的所有函数 ：

1
2
3
4
5

> s = "ABC"
> string.sub(s, 1, 2)
AB
> s:sub(1, 2)
AB

从 Lua5.3 开始，Lua 引入了用于操作 UTF-8 编码的 Unicode 字符串的标准库：

1
2
3
4
5
6
7
8
9
10
11
12
13

> utf8.len('中国')
2
> utf8.codepoint('中国', 1, 3)
20013
> utf8.char(20013)
中
> utf8.offset('中国', 2)
4
> for i, c in utf8.codes('中国') do
>>      print(i, c)
>> end
1       20013
4       22269

Lua 并没有提供其他 Unicode 字符相关的特性，因为 Unicode 本身的复杂性，想要支持完整地 Unicode 需要巨大的表，而这与 Lua 精简的大小相矛盾。因此对于这些特殊需求来说，最好就是选择外部库。