Lua常用API库整理_lua api

math

-- math.abs
local x = -5
local abs_x = math.abs(x) -- 计算 x 的绝对值
print(abs_x) -- 输出 5

-- math.acos
local x = 0.5
local acos_x = math.acos(x) -- 计算 x 的反余弦值
print(acos_x) -- 输出 1.0471975511966 (弧度)

-- math.asin
local x = 0.5
local asin_x = math.asin(x) -- 计算 x 的反正弦值
print(asin_x) -- 输出 0.5235987755983 (弧度)

-- math.atan
local x = 1
local atan_x = math.atan(x) -- 计算 x 的反正切值
print(atan_x) -- 输出 0.78539816339745 (弧度)

-- math.atan2
local y, x = 2, 2
local atan2_yx = math.atan2(y, x) -- 计算 y/x 的反正切值
print(atan2_yx) -- 输出 0.78539816339745 (弧度)

-- math.ceil
local x = 5.3
local ceil_x = math.ceil(x) -- 对 x 向上取整
print(ceil_x) -- 输出 6

-- math.cos
local angle = math.pi / 3
local cos_angle = math.cos(angle) -- 计算角度的余弦值
print(cos_angle) -- 输出 0.5

-- math.cosh
local x = 1
local cosh_x = math.cosh(x) -- 计算 x 的双曲余弦值
print(cosh_x) -- 输出 1.5430806348152

-- math.deg
local rad = math.pi / 3
local deg = math.deg(rad) -- 将弧度转换为角度
print(deg) -- 输出 60

-- math.exp
local x = 1
local exp_x = math.exp(x) -- 计算 e 的 x 次幂
print(exp_x) -- 输出 2.718281828459

-- math.floor
local x = 5.7
local floor_x = math.floor(x) -- 对 x 向下取整
print(floor_x) -- 输出 5

-- math.fmod
local x, y = 7, 3
local remainder = math.fmod(x, y) -- 计算 x 除以 y 的余数
print(remainder) -- 输出 1

-- math.frexp
local x = 8
local m, e = math.frexp(x) -- 将 x 分解为尾数 m 和指数 e
print(m, e) -- 输出 0.5, 4

-- math.huge
local huge_num = math.huge -- 表示正无穷大
print(huge_num) -- 输出 inf

-- math.ldexp
local m, e = 0.5, 4
local x = math.ldexp(m, e) -- 根据尾数 m 和指数 e 计算结果
print(x) -- 输出 8

-- math.log
local x = 8
local log_x = math.log(x) -- 计算 x 的自然对数
print(log_x) -- 输出 2.0794415416798

-- math.max
local max_val = math.max(5, 8, 1, 3, 7) -- 计算参数中的最大值
print(max_val) -- 输出 8

-- math.maxinteger
local max_int = math.maxinteger -- 表示整数的最大值
print(max_int) -- 输出 9223372036854775807

-- math.min
local min_val = math.min(5, 8, 1, 3, 7) -- 计算参数中的最小值
print(min_val) -- 输出 1

-- math.mininteger
local min_int = math.mininteger -- 表示整数的最小值
print(min_int) -- 输出 -9223372036854775808

-- math.modf
local x = 5.7
local integral, fractional = math.modf(x) -- 将 x 分解为整数部分和小数部分
print(integral, fractional) -- 输出 5, 0.7

-- math.pi
local pi_val = math.pi -- 圆周率的近似值
print(pi_val) -- 输出 3.1415926535898

-- math.rad
local deg = 60
local rad = math.rad(deg) -- 将角度转换为弧度
print(rad) -- 输出 1.0471975511966

-- math.random
local random_num = math.random(1, 10) -- 生成一个 [1, 10] 区间内的随机整数
print(random_num)

-- math.randomseed
math.randomseed(os.time()) -- 使用当前时间作为随机数种子

-- math.sin
local angle = math.pi / 3
local sin_angle = math.sin(angle) -- 计算角度的正弦值
print(sin_angle) -- 输出 0.86602540378444

-- math.sinh
local x = 1
local sinh_x = math.sinh(x) -- 计算 x 的双曲正弦值
print(sinh_x) -- 输出 1.1752011936438

-- math.sqrt
local x = 9
local sqrt_x = math.sqrt(x) -- 计算 x 的平方根
print(sqrt_x) -- 输出 3

-- math.tan
local angle = math.pi / 4
local tan_angle = math.tan(angle) -- 计算角度的正切值
print(tan_angle) -- 输出 0.99999999999999

-- math.tanh
local x = 1
local tanh_x = math.tanh(x) -- 计算 x 的双曲正切值
print(tanh_x) -- 输出 0.76159415595576

-- math.tointeger
local x = 5.7
local int_x = math.tointeger(x) -- 将 x 转换为整数（如果 x 是整数，则返回 x，否则返回 nil）
print(int_x) -- 输出 nil

-- math.type
local x = 5.7
local y = 3
local type_x = math.type(x) -- 检查 x 的类型（"float" 或 "integer"）
local type_y = math.type(y) -- 检查 y 的类型（"float" 或 "integer"）
print(type_x) -- 输出 "float"
print(type_y) -- 输出 "integer"

-- math.ult
local x, y = 3, 5
local result = math.ult(x, y) -- 检查 x 是否严格小于 y（无符号整数比较）
print(result) -- 输出 true
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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

string

-- string.byte
local str = "hello"
local byte_val = string.byte(str, 1) -- 获取第 1 个字符的 ASCII 码
print(byte_val) -- 输出 104，即 "h" 的 ASCII 码

-- string.char
local char_val = string.char(104) -- 根据 ASCII 码获取字符
print(char_val) -- 输出 "h"

-- string.dump
local function example() print("Hello, World!") end
local binary_str = string.dump(example) -- 获取函数的二进制表示
print(binary_str)

-- string.find
local s = "hello, world"
local start_pos, end_pos = string.find(s, "world") -- 在字符串中查找子串 "world"
print(start_pos, end_pos) -- 输出 8 12

-- string.format
local formatted_str = string.format("Hello, %s! You are %d years old.", "John", 25) -- 格式化字符串
print(formatted_str) -- 输出 "Hello, John! You are 25 years old."

-- string.gmatch
local s = "I am learning Lua"
for word in string.gmatch(s, "%a+") do -- 使用迭代器函数逐个提取单词
    print(word)
end

-- string.gsub
local s = "The quick brown dog jumps over the lazy dog"
local new_s = string.gsub(s, "dog", "fox") -- 将所有 "dog" 替换为 "fox"
print(new_s) -- 输出 "The quick brown fox jumps over the lazy fox"

-- string.len
local s = "hello"
local length = string.len(s) -- 获取字符串长度
print(length) -- 输出 5

-- string.lower
local s = "HELLO"
local lower_s = string.lower(s) -- 将字符串转换为小写
print(lower_s) -- 输出 "hello"

-- string.match
local s = "My phone number is 123-456-7890"
local phone_number = string.match(s, "%d%d%d%-%d%d%d%-%d%d%d%d") -- 提取电话号码
print(phone_number) -- 输出 "123-456-7890"

-- string.pack
local packed_data = string.pack(">i4", 42) -- 以大端序整数格式打包数据
print(packed_data)

-- string.packsize
local size = string.packsize(">i4") -- 获取大端序整数格式的数据大小
print(size) -- 输出 4

-- string.rep
local s = "hello"
local repeated_s = string.rep(s, 3, " ") -- 重复字符串 3 次，每次之间用空格分隔
print(repeated_s) -- 输出 "hello hello hello"

-- string.reverse
local s = "hello"
local reversed_s = string.reverse(s) -- 反转字符串
print(reversed_s) -- 输出 "olleh"

-- string.sub
local s = "hello, world"
local sub_s = string.sub(s, 1, 5) -- 截取子串，从第 1 个字符到第 5 个字符
print(sub_s) -- 输出 "hello"

-- string.unpack
local packed_data = string.pack(">i4", 42)
local unpacked_data = string.unpack(">i4", packed_data) -- 从打包数据中解包整数
print(unpacked_data) -- 输出 "42"

-- string.upper
local s = "hello"
local upper_s = string.upper(s) -- 将字符串转换为大写
print(upper_s) -- 输出 "HELLO"
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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

table

-- table.concat
local t = {"apple", "banana", "cherry"}
local joined_str = table.concat(t, ", ") -- 将表中的元素连接成一个字符串，以 ", " 分隔
print(joined_str) -- 输出 "apple, banana, cherry"

-- table.insert
local t = {10, 20, 30}
table.insert(t, 2, 15) -- 在表的第 2 个位置插入元素 15
for _, v in ipairs(t) do print(v) end -- 输出 10, 15, 20, 30

-- table.move
local t1 = {1, 2, 3, 4, 5}
local t2 = {6, 7, 8, 9, 10}
table.move(t1, 1, 5, 6, t2) -- 将 t1 的前 5 个元素移动到 t2 的第 6 个位置开始
for _, v in ipairs(t2) do print(v) end -- 输出 6, 7, 8, 9, 10, 1, 2, 3, 4, 5

-- table.pack
local t = table.pack("apple", "banana", "cherry") -- 将多个值打包成一个表
for _, v in ipairs(t) do print(v) end -- 输出 "apple", "banana", "cherry"

-- table.remove
local t = {"apple", "banana", "cherry"}
table.remove(t, 2) -- 移除表中第 2 个元素
for _, v in ipairs(t) do print(v) end -- 输出 "apple", "cherry"

-- table.sort
local t = {5, 8, 1, 3, 7}
table.sort(t) -- 将表中的元素进行升序排序
for _, v in ipairs(t) do print(v) end -- 输出 1, 3, 5, 7, 8

-- table.unpack
local t = {"apple", "banana", "cherry"}
local a, b, c = table.unpack(t) -- 解包表中的元素，将它们赋值给变量
print(a, b, c) -- 输出 "apple", "banana", "cherry"
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
26
27
28
29
30
31
32
33
34

metamethods

__add：定义加法操作符的行为。

local mt = {
    __add = function(a, b)
        return {value = a.value + b.value}
    end
}
local a = {value = 10}
local b = {value = 20}
setmetatable(a, mt)
setmetatable(b, mt)
local result = a + b
print(result.value) -- 输出 30

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

__band：定义按位与操作符的行为。

local mt = {
    __band = function(a, b)
        return {value = a.value & b.value}
    end
}
local a = {value = 0x0F}
local b = {value = 0x33}
setmetatable(a, mt)
setmetatable(b, mt)
local result = a & b
print(result.value) -- 输出 3

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

__bnot：定义按位非操作符的行为。

local mt = {
    __bnot = function(a)
        return {value = ~a.value}
    end
}
local a = {value = 0x0F}
setmetatable(a, mt)
local result = ~a
print(result.value) -- 输出 -16

1
2
3
4
5
6
7
8
9
10

__bor：定义按位或操作符的行为。

local mt = {
    __bor = function(a, b)
        return {value = a.value | b.value}
    end
}
local a = {value = 0x0F}
local b = {value = 0x33}
setmetatable(a, mt)
setmetatable(b, mt)
local result = a | b
print(result.value) -- 输出 63

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

__bxor：定义按位异或操作符的行为。

local mt = {
    __bxor = function(a, b)
        return {value = a.value ~ b.value}
    end
}
local a = {value = 0x0F}
local b = {value = 0x33}
setmetatable(a, mt)
setmetatable(b, mt)
local result = a ~ b
print(result.value) -- 输出 60

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

__call：定义调用表作为函数时的行为。

local mt = {
    __call = function(t, arg)
        return t.value * arg
    end
}
local a = {value = 10}
setmetatable(a, mt)
local result = a(5) -- 调用 a 作为函数
print(result) -- 输出 50

1
2
3
4
5
6
7
8
9
10

__close：在 Lua 5.4 中引入，定义在执行器（finalizer）中调用的函数。

local mt = {
    __close = function(t)
        print("Closing", t.value)
    end
}
local function newResource(value)
    return setmetatable({value = value}, mt)
end
local function test()
    local r = newResource("Resource 1")
    return r
end
local resource = test() -- 在离开 test 函数作用域时调用 __close 方法

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

__concat：定义字符串连接操作符的行为。

local mt = {
    __concat = function(a, b)
        return a.value .. b.value
    end
}
local a = {value = "Hello "}
local b = {value = "World!"}
setmetatable(a, mt)
setmetatable(b, mt)
local result = a .. b
print(result) -- 输出 "Hello World!"

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

__div：定义除法操作符的行为。

local mt = {
    __div = function(a, b)
        return {value = a.value / b.value}
    end
}
local a = {value = 10}
local b = {value = 2}
setmetatable(a, mt)
setmetatable(b, mt)
local result = a / b
print(result.value) -- 输出 5

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

__eq：定义相等操作符的行为。

local mt = {
    __eq = function(a, b)
        return a.value == b.value
    end
}
local a = {value = 10}
local b = {value = 10}
setmetatable(a, mt)
setmetatable(b, mt)
local result = a == b
print(result) -- 输出 true

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

__gc：定义垃圾回收器操作的行为，当对象被垃圾回收器回收时调用。

local mt = {
    __gc = function(t)
        print("Object with value", t.value, "is being collected.")
    end
}
local function createObject(value)
    local obj = {value = value}
    setmetatable(obj, mt)
end
createObject(42) -- 在垃圾回收时调用 __gc 方法
collectgarbage() -- 强制进行垃圾回收

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

__idiv：定义整数除法操作符的行为。

local mt = {
    __idiv = function(a, b)
        return {value = a.value // b.value}
    end
}
local a = {value = 10}
local b = {value = 3}
setmetatable(a, mt)
setmetatable(b, mt)
local result = a // b
print(result.value) -- 输出 3

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

__index：定义访问表中不存在的键时的行为。

local mt = {
    __index = function(t, key)
        return "default"
    end
}
local a = {}
setmetatable(a, mt)
print(a.some_key) -- 输出 "default"

1
2
3
4
5
6
7
8
9

__le：定义小于等于操作符的行为。

local mt = {
    __le = function(a, b)
        return a.value <= b.value
    end
}
local a = {value = 10}
local b = {value = 20}
setmetatable(a, mt)
setmetatable(b, mt)
local result = a <= b
print(result) -- 输出 true

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

__len：定义求表长度操作符的行为。

local mt = {
    __len = function(t)
        return t.value
    end
}
local a = {value = 5}
setmetatable(a, mt)
local length = #a
print(length) -- 输出 5

1
2
3
4
5
6
7
8
9
10

__lt：定义小于操作符的行为。

local mt = {
    __lt = function(a, b)
        return a.value < b.value
    end
}
local a = {value = 10}
local b = {value = 20}
setmetatable(a, mt)
setmetatable(b, mt)
local result = a < b
print(result) -- 输出 true

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

__metatable：定义获取元表的行为，以防止用户访问或修改实际的元表。

local mt = {
    __metatable = "This metatable is locked."
}
local a = {}
setmetatable(a, mt)
local a_mt = getmetatable(a)
print(a_mt) -- 输出 "This metatable is locked."

1
2
3
4
5
6
7
8

__mod：定义取模操作符的行为。

local mt = {
    __mod = function(a, b)
        return {value = a.value % b.value}
    end
}
local a = {value = 10}
local b = {value = 3}
setmetatable(a, mt)
setmetatable(b, mt)
local result = a % b
print(result.value) -- 输出 1

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

__mode：定义弱表的行为，可以设置为 “k”、“v” 或 “kv”，表示表中的键、值或键值都是弱引用。

local mt = {__mode = "v"}
local cache = setmetatable({}, mt)
local function getFromCache(key)
    local value = cache[key]
    if not value then
        value = key .. " cached"
        cache[key] = value
    end
    return value
end
getFromCache("test") -- 在垃圾回收时，值将被释放
collectgarbage()

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

__mul：定义乘法操作符的行为。

local mt = {
    __mul = function(a, b)
        return {value = a.value * b.value}
    end
}
local a = {value = 10}
local b = {value = 2}
setmetatable(a, mt)
setmetatable(b, mt)
local result = a * b
print(result.value) -- 输出 20

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

__name：在 Lua 5.3 中引入，用于定义类型名。

local mt = {
    __name = "MyType"
}
local a = setmetatable({}, mt)
local typeName = tostring(a)
print(typeName) -- 输出 "MyType: <address>"

1
2
3
4
5
6
7

__newindex：定义设置表中不存在的键时的行为。

local mt = {
    __newindex = function(t, key, value)
        print("Setting", key, "to", value)
    end
}
local a = {}
setmetatable(a, mt)
a.some_key = "value" -- 输出 "Setting some_key to value"

1
2
3
4
5
6
7
8
9

__pairs：定义使用 pairs() 函数遍历表时的行为。

local mt = {
    __pairs = function(t)
        local function iter(t, key)
            local nextKey, nextValue = next(t, key)
            if nextKey then
                return nextKey, nextValue
            end
        end
        return iter, t, nil
    end
}
local a = {a = 1, b = 2, c = 3}
setmetatable(a, mt)
for k, v in pairs(a) do
    print(k, v)
end

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

__pow：定义幂运算操作符的行为。

local mt = {
    __pow = function(a, b)
        return {value = a.value ^ b.value}
    end
}
local a = {value = 2}
local b = {value = 3}
setmetatable(a, mt)
setmetatable(b, mt)
local result = a ^ b
print(result.value) -- 输出 8

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

__shl：定义按位左移操作符的行为。

local mt = {
    __shl = function(a, b)
        return {value = a.value << b.value}
    end
}
local a = {value = 0x0F}
local b = {value = 1}
setmetatable(a, mt)
setmetatable(b, mt)
local result = a << b
print(result.value) -- 输出 30

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

__shr：定义按位右移操作符的行为。

local mt = {
    __shr = function(a, b)
        return {value = a.value >> b.value}
    end
}
local a = {value = 0x0F}
local b = {value = 1}
setmetatable(a, mt)
setmetatable(b, mt)
local result = a >> b
print(result.value) -- 输出 7

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

__sub：定义减法操作符的行为。

local mt = {
    __sub = function(a, b)
        return {value = a.value - b.value}
    end
}
local a = {value = 10}
local b = {value = 2}
setmetatable(a, mt)
setmetatable(b, mt)
local result = a - b
print(result.value) -- 输出 8

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

__tostring：定义将表转换为字符串时的行为。

local mt = {
    __tostring = function(t)
        return "Object with value: " .. t.value
    end
}
local a = {value = 10}
setmetatable(a, mt)
local str = tostring(a)
print(str) -- 输出 "Object with value: 10"

1
2
3
4
5
6
7
8
9
10

__unm：定义一元负操作符的行为。

local mt = {
    __unm = function(a)
        return {value = -a.value}
    end
}
local a = {value = 10}
setmetatable(a, mt)
local result = -a
print(result.value) -- 输出 -10

1
2
3
4
5
6
7
8
9
10