字符串或串(String)是由数字、字母、下划线组成的一串字符。
Lua 语言中字符串可以使用以下三种方式来表示:
以上三种方式的字符串实例如下:
string1 = "Hello"
print("\"字符串 1 是\"", string1)
string2 = 'lua'
print("字符串 2 是", string2)
string3 = [["Lua 教程"]]
print("字符串 3 是", string3)
以上代码执行输出结果为:
"字符串 1 是" Hello
字符串 2 是 lua
字符串 3 是 "Lua 教程"
转义字符用于表示不能直接显示的字符,比如后退键,回车键,等。如在字符串转换双引号可以使用 “"“。
所有的转义字符和所对应的意义:
转义字符 | 意义 | ASCII 码值(十进制) |
---|---|---|
\a | 响铃(BEL) | 007 |
\b | 退格(BS) ,将当前位置移到前一列 | 008 |
\f | 换页(FF),将当前位置移到下页开头 | 012 |
\n | 换行(LF) ,将当前位置移到下一行开头 | 010 |
\r | 回车(CR) ,将当前位置移到本行开头 | 013 |
\t | 水平制表(HT) (跳到下一个 TAB 位置) | 009 |
\v | 垂直制表(VT) | 011 |
\ | 代表一个反斜线字符’’' | 092 |
' | 代表一个单引号(撇号)字符 | 039 |
" | 代表一个双引号字符 | 034 |
空字符(NULL) | 000 | |
\ddd | 1 到 3 位八进制数所代表的任意字符 | 三位八进制 |
\xhh | 1 到 2 位十六进制所代表的任意字符 | 二位十六进制 |
Lua 提供了很多的方法来支持字符串的操作:
字符串大小写转换
以下实例演示了如何对字符串大小写进行转换:
string1 = "Lua";
print(string.upper(string1))
print(string.lower(string1))
以上代码执行结果为:
LUA
lua
字符串查找与反转
以下实例演示了如何对字符串进行查找与反转操作:
string = "Lua Tutorial"
-- 查找字符串
print(string.find(string,"Tutorial"))
reversedString = string.reverse(string)
print("新字符串为",reversedString)
以上代码执行结果为:
5 12
新字符串为 lairotuT auL
字符串格式化
以下实例演示了如何对字符串进行格式化操作:
string1 = "Lua"
string2 = "Tutorial"
number1 = 10
number2 = 20
-- 基本字符串格式化
print(string.format("基本格式化 %s %s",string1,string2))
-- 日期格式化
date = 2; month = 1; year = 2014
print(string.format("日期格式化 %02d/%02d/%03d", date, month, year))
-- 十进制格式化
print(string.format("%.4f",1/3))
以上代码执行结果为:
基本格式化 Lua Tutorial
日期格式化 02/01/2014
0.3333
字符与整数相互转换
以下实例演示了字符与整数相互转换:
-- 字符转换
-- 转换第一个字符
print(string.byte("Lua"))
-- 转换第三个字符
print(string.byte("Lua",3))
-- 转换末尾第一个字符
print(string.byte("Lua",-1))
-- 第二个字符
print(string.byte("Lua",2))
-- 转换末尾第二个字符
print(string.byte("Lua",-2))
-- 整数 ASCII 码转换为字符
print(string.char(97))
以上代码执行结果为:
76
97
97
117
117
a
其他常用函数
以下实例演示了其他字符串操作,如计算字符串长度,字符串连接,字符串复制等:
string1 = "wsdjeg."
string2 = "spacevim"
string3 = ".org"
-- 使用 .. 进行字符串连接
print("连接字符串",string1..string2..string3)
-- 字符串长度
print("字符串长度 ",string.len(string2))
-- 字符串复制 2 次
repeatedString = string.rep(string2,2)
print(repeatedString)
以上代码执行结果为:
连接字符串 wsdjeg.spacevim.org
字符串长度 8
spacevimspacevim
Lua 提供了很多的方法来支持字符串的操作:
字符串全部转为大写字母。
string.upper(argument)
示例:
str1 = "wsdjeg"
print(string.upper(str1))
输出:
WSDJEG
运算符是一个特殊的符号,用于告诉解释器执行特定的数学或逻辑运算。Lua 提供了以下几种运算符类型:
下表列出了 Lua 语言中的常用算术运算符,设定 A 的值为 10,B 的值为 20:
操作符 | 描述 | 实例 |
---|---|---|
+ |
加法 | A + B 输出结果 30 |
- |
减法 | A - B 输出结果 -10 |
* |
乘法 | A * B 输出结果 200 |
/ |
除法 | B / A 输出结果 2 |
% |
取余 | B % A 输出结果 0 |
^ |
乘幂 | A ^ 2 输出结果 100 |
- |
负号 | -A 输出结果 -10 |
实例
我们可以通过以下实例来更加透彻的理解算术运算符的应用:
a = 21
b = 10
c = a + b
print("Line 1 - c 的值为 ", c )
c = a - b
print("Line 2 - c 的值为 ", c )
c = a * b
print("Line 3 - c 的值为 ", c )
c = a / b
print("Line 4 - c 的值为 ", c )
c = a % b
print("Line 5 - c 的值为 ", c )
c = a^2
print("Line 6 - c 的值为 ", c )
c = -a
print("Line 7 - c 的值为 ", c )
以上程序执行结果为:
Line 1 - c 的值为 31
Line 2 - c 的值为 11
Line 3 - c 的值为 210
Line 4 - c 的值为 2.1
Line 5 - c 的值为 1
Line 6 - c 的值为 441
Line 7 - c 的值为 -21
下表列出了 Lua 语言中的常用关系运算符,设定 A 的值为 10,B 的值为 20:
操作符 | 描述 | 实例 |
---|---|---|
== | 等于,检测两个值是否相等,相等返回 true,否则返回 false | (A == B) 为 false。 |
~= | 不等于,检测两个值是否相等,相等返回 false,否则返回 true | (A ~= B) 为 true。 |
> | 大于,如果左边的值大于右边的值,返回 true,否则返回 false | (A > B) 为 false。 |
< | 小于,如果左边的值大于右边的值,返回 false,否则返回 true | (A < B) 为 true。 |
>= | 大于等于,如果左边的值大于等于右边的值,返回 true,否则返回 false | (A >= B) is not true. |
<= | 小于等于, 如果左边的值小于等于右边的值,返回 true,否则返回 false | (A <= B) is true. |
实例
我们可以通过以下实例来更加透彻的理解关系运算符的应用:
a = 21
b = 10
if( a == b )
then
print("Line 1 - a 等于 b" )
else
print("Line 1 - a 不等于 b" )
end
if( a ~= b )
then
print("Line 2 - a 不等于 b" )
else
print("Line 2 - a 等于 b" )
end
if ( a < b )
then
print("Line 3 - a 小于 b" )
else
print("Line 3 - a 大于等于 b" )
end
if ( a > b )
then
print("Line 4 - a 大于 b" )
else
print("Line 5 - a 小于等于 b" )
end
-- 修改 a 和 b 的值
a = 5
b = 20
if ( a <= b )
then
print("Line 5 - a 小于等于 b" )
end
if ( b >= a )
then
print("Line 6 - b 大于等于 a" )
end
以上程序执行结果为:
Line 1 - a 不等于 b
Line 2 - a 不等于 b
Line 3 - a 大于等于 b
Line 4 - a 大于 b
Line 5 - a 小于等于 b
Line 6 - b 大于等于 a
在 Lua 中,函数是对语句和表达式进行抽象的主要方法。既可以用来处理一些特殊的工作,也可以用来计算一些值。
Lua 提供了许多的内建函数,你可以很方便的在程序中调用它们,如 print()函数可以将传入的参数打印在控制台上。
Lua 函数主要有两种用途:
函数定义
Lua 编程语言函数定义格式如下:
optional_function_scope function function_name( argument1, argument2, argument3..., argumentn)
function_body
return result_params_comma_separated
end
解析:
optional_function_scope
: 该参数是可选的制定函数是全局函数还是局部函数,未设置该参数末尾为全局函数,如果你需要设置函数为局部函数需要使用关键字 local。function_name
: 指定函数名称。argument1, argument2, argument3..., argumentn
: 函数参数,多个参数以逗号隔开,函数也可以不带参数。function_body
: 函数体,函数中需要执行的代码语句块。result_params_comma_separated
: 函数返回值,Lua 语言函数可以返回多个值,每个值以逗号隔开。实例
以下实例定义了函数 max(),参数为 num1, num2,用于比较两值的大小,并返回最大值:
--[[ 函数返回两个值的最大值 --]]
function max(num1, num2)
if (num1 > num2) then
result = num1;
else
result = num2;
end
return result;
end
-- 调用函数
print("两值比较最大值为 ",max(10,4))
print("两值比较最大值为 ",max(5,6))
以上代码执行结果为:
Lua 中我们可以将函数作为参数传递给函数,如下实例:
myprint = function(param)
print("这是打印函数 - ##",param,"##")
end
function add(num1,num2,functionPrint)
result = num1 + num2
-- 调用传递的函数参数
functionPrint(result)
end
myprint(10)
-- myprint 函数作为参数传递
add(2,5,myprint)
以上代码执行结果为:
Lua 函数可以返回多个结果值,比如 string.find,其返回匹配串”开始和结束的下标”(如果不存在匹配串返回 nil)。
> s, e = string.find("www.w3cschool.cn", "w3cschool")
> print(s, e)
5 13
Lua 函数中,在 return 后列出要返回的值得列表即可返回多值,如:
function maximum (a)
local mi = 1 -- 最大值索引
local m = a[mi] -- 最大值
for i,val in ipairs(a) do
if val > m then
mi = i
m = val
end
end
return m, mi
end
print(maximum({8,10,23,12,5}))
以上代码执行结果为:
Lua 函数可以接受可变数目的参数,和 C 语言类似在函数参数列表中使用三点(…) 表示函数有可变的参数。
Lua 将函数的参数放在一个叫 arg 的表中,#arg 表示传入参数的个数。
例如,我们计算几个数的平均值:
function average(...)
result = 0
local arg={...}
for i,v in ipairs(arg) do
result = result + v
end
print("总共传入 " .. #arg .. " 个数")
return result/#arg
end
print("平均值为",average(10,5,3,4,5,6))
以上代码执行结果为:
Lua 编程语言流程控制语句通过程序设定一个或多个条件语句来设定。在条件为 true 时执行指定程序代码,在条件为 false 时执行其他指定代码。
控制结构的条件表达式结果可以是任何值,Lua 认为 false 和 nil 为假,true 和非 nil 为真。
要注意的是 Lua 中 0 为 true:
--[ 0 为true ]
if(0)
then
print("0 为真")
end
以上代码输出结果为:
0 为真
Lua 提供了以下控制结构语句:
语句 | 描述 |
---|---|
if 语句 | if 语句 由一个布尔表达式作为条件判断,其后紧跟其他语句组成。 |
if…else 语句 | if 语句 可以与 else 语句搭配使用, 在 if 条件表达式为 false 时执行 else 语句代码。 |
if 嵌套语句 | 你可以在 if 或 else if 中使用一个或多个 if 或 else if 语句 。 |
Lua if 语句 由一个布尔表达式作为条件判断,其后紧跟其他语句组成。
Lua if 语句语法格式如下:
if(布尔表达式)
then
--[ 在布尔表达式为 true 时执行的语句 --]
end
在布尔表达式为 true 时会 if 中的代码块会被执行,在布尔表达式为 false 时,紧跟在 if 语句 end 之后的代码会被执行。
Lua 认为 false 和 nil 为假,true 和非 nil 为真。要注意的是 Lua 中 0 为 true。
实例
以下实例用于判断变量 a 的值是否小于 20:
--[ 定义变量 --]
a = 10
--[ 使用 if 语句 --]
if( a < 20 )
then
--[ if 条件为 true 时打印以下信息 --]
print("a 小于 20" )
end
print("a 的值为:", a)
以上代码执行结果如下:
Lua if 语句可以与 else 语句搭配使用, 在 if 条件表达式为 false 时执行 else 语句代码块。
Lua if…else 语句语法格式如下:
if(布尔表达式)
then
--[ 布尔表达式为 true 时执行该语句块 --]
else
--[ 布尔表达式为 false 时执行该语句块 --]
end
在布尔表达式为 true 时会 if 中的代码块会被执行,在布尔表达式为 false 时,else 的代码块会被执行。
Lua 认为 false 和 nil 为假,true 和非 nil 为真。要注意的是 Lua 中 0 为 true。
实例
以下实例用于判断变量 a 的值:
--[ 定义变量 --]
a = 100;
--[ 检查条件 --]
if( a < 20 )
then
--[ if 条件为 true 时执行该语句块 --]
print("a 小于 20" )
else
--[ if 条件为 false 时执行该语句块 --]
print("a 大于 20" )
end
print("a 的值为 :", a)
以上代码执行结果如下:
Lua if 语句可以与 else if…else 语句搭配使用, 在 if 条件表达式为 false 时执行 else if…else 语句代码块,用于检测多个条件语句。
Lua if…else if…else 语句语法格式如下:
if( 布尔表达式 1)
then
--[ 在布尔表达式 1 为 true 时执行该语句块 --]
else if( 布尔表达式 2)
--[ 在布尔表达式 2 为 true 时执行该语句块 --]
else if( 布尔表达式 3)
--[ 在布尔表达式 3 为 true 时执行该语句块 --]
else
--[ 如果以上布尔表达式都不为 true 则执行该语句块 --]
end
示例代码,以下示例代码对变量 a 值进行判断:
--[ 定义变量 --]
a = 100
--[ 检查布尔条件 --]
if( a == 10 )
then
--[ 如果条件为 true 打印以下信息 --]
print("a 的值为 10" )
elseif( a == 20 )
then
--[ if else if 条件为 true 时打印以下信息 --]
print("a 的值为 20" )
elseif( a == 30 )
then
--[ if else if condition 条件为 true 时打印以下信息 --]
print("a 的值为 30" )
else
--[ 以上条件语句没有一个为 true 时打印以下信息 --]
print("没有匹配 a 的值" )
end
print("a 的真实值为: ", a )
运行结果如下:
Lua if 语句允许嵌套, 这就意味着你可以在一个 if 或 else if 语句中插入其他的 if 或 else if 语句。 Lua if 嵌套语句语法格式如下:
if( 布尔表达式 1)
then
--[ 布尔表达式 1 为 true 时执行该语句块 --]
if(布尔表达式 2)
then
--[ 布尔表达式 2 为 true 时执行该语句块 --]
end
end
你可以用同样的方式嵌套 else if…else 语句。
实例
以下实例用于判断变量 a 和 b 的值:
--[ 定义变量 --]
a = 100;
b = 200;
--[ 检查条件 --]
if( a == 100 )
then
--[ if 条件为 true 时执行以下 if 条件判断 --]
if( b == 200 )
then
--[ if 条件为 true 时执行该语句块 --]
print("a 的值为 100 b 的值为 200" );
end
end
print("a 的值为 :", a );
print("b 的值为 :", b );
以上代码执行结果如下:
很多情况下我们需要做一些有规律性的重复操作,因此在程序中就需要重复执行某些语句。
一组被重复执行的语句称之为循环体,能否继续重复,决定循环的终止条件。
循环结构是在一定条件下反复执行某段程序的流程结构,被反复执行的程序被称为循环体。
循环语句是由循环体及循环的终止条件两部分组成的。
Lua 语言提供了以下几种循环处理方式:
循环类型 | 描述 |
---|---|
while 循环 | 在条件为 true 时,让程序重复地执行某些语句。执行语句前会先检查条件是否为 true。 |
for 循环 | 重复执行指定语句,重复次数可在 for 语句中控制。 |
Lua repeat…until | 重复执行循环,直到 指定的条件为真时为止 |
循环嵌套 | 可以在循环内嵌套一个或多个循环语句(while、for、do..while) |
while(condition)
do
statements
end
statements(循环体语句) 可以是一条或多条语句,condition(条件) 可以是任意表达式,在 condition(条件) 为 true 时执行循环体语句。
示例:
a = 15
while ( a < 20 )
do
print("a 的值为:", a)
a = a + 1
end
Lua 编程语言中 for 循环语句可以重复执行指定语句,重复次数可在 for 语句中控制。
Lua 编程语言中 for 语句有两大类::
基本语法:
for var=exp1,exp2,exp3 do
<执行体>
end
var 从 exp1 变化到 exp2,每次变化以 exp3 为步长递增 var,并执行一次”执行体”。exp3 是可选的,如果不指定,默认为 1。
实例:
for i=1,f(x) do
print(i)
end
for i=10,1,-1 do
print(i)
end
for 的三个表达式在循环开始前一次性求值,以后不再进行求值。比如上面的 f(x)只会在循环开始前执行一次,其结果用在后面的循环中。
验证如下:
function f(x)
print("方法被执行")
return x*2
end
for i=1,f(5) do print(i)
end
泛型 for 循环通过一个迭代器函数来遍历所有值,类似 java 中的 foreach 语句。
Lua 编程语言中泛型 for 循环语法格式:
--打印数组a的所有值
for i,v in ipairs(a)
do print(v)
end
示例:
days = {"Suanday","Monday","Tuesday"}
for i,v in ipairs(days) do print(v) end
Lua 编程语言中 repeat…until 循环语句不同于 for 和 while 循环,for 和 while 循环的 条件语句在当前循环执行开始时判断,而 repeat…until 循环的条件语句在当前循环结束后判断。
基本语法格式:
repeat
statements
until( condition )
我们注意到循环条件判断语句(condition)在循环体末尾部分,所以在条件进行判断前循环体都会执行一次。 如果条件判断语句(condition)为 false,循环会重新开始执行,直到条件判断语句(condition)为 true 才会停止执行。
示例代码:
--[ 变量定义 --]
a = 10
--[ 执行循环 --]
repeat
print("a的值为:", a)
a = a + 1
until( a > 13 )
允许结果如下:
Lua 编程语言中允许循环中嵌入循环。以下实例演示了 Lua 循环嵌套的应用。 语法
Lua 编程语言中 for 循环嵌套语法格式:
for init,max/min value, increment
do
for init,max/min value, increment
do
statements
end
statements
end
Lua 编程语言中 while 循环嵌套语法格式:
while(condition)
do
while(condition)
do
statements
end
statements
end
Lua 编程语言中 repeat…until 循环嵌套语法格式:
repeat
statements
repeat
statements
until( condition )
until( condition )
除了以上同类型循环嵌套外,我们还可以使用不同的循环类型来嵌套,如 for 循环体中嵌套 while 循环。 实例
以下实例使用了 for 循环嵌套:
j =2
for i=2,10 do
for j=2,(i/j) , 2 do
if(not(i%j))
then
break
end
if(j > (i/j))then
print("i 的值为:",i)
end
end
end
运行结果如下:
lua 支持 break 语句,退出当前循环或语句,并开始脚本执行紧接着的语句:
--[ 定义变量 --]
a = 10
--[ while 循环 --]
while ( a < 20 )
do
print("a 的值为:", a)
a = a + 1
if ( a > 13)
then
--[ 使用 break 语句终止循环 --]
break
end
end
Lua 是动态类型语言,变量不要类型定义,只需要为变量赋值。 值可以存储在变量中,作为参数传递或结果返回。
Lua 中有 8 个基本类型分别为:nil、boolean、number、string、userdata、function、thread 和 table。
数据类型 | 描述 |
---|---|
nil | 这个最简单,只有值 nil 属于该类,表示一个无效值(在条件表达式中相当于 false)。 |
boolean | 包含两个值:false 和 true。 |
number | 表示双精度类型的实浮点数 |
string | 字符串由一对双引号或单引号来表示 |
function | 由 C 或 Lua 编写的函数 |
userdata | 表示任意存储在变量中的 C 数据结构 |
thread | 表示执行的独立线路,用于执行协同程序 |
table | Lua 中的表(table)其实是一个”关联数组”(associative arrays),数组的索引可以是数字或者是字符串。在 Lua 里,table 的创建是通过”构造表达式”来完成,最简单构造表达式是{},用来创建一个空表。 |
我们可以使用 type 函数测试给定变量或者值的类型
print(type("Hello world")) --> string
print(type(10.4*3)) --> number
print(type(print)) --> function
print(type(type)) --> function
print(type(true)) --> boolean
print(type(nil)) --> nil
print(type(type(X))) --> string
nil 类型表示一种没有任何有效值,它只有一个值 – nil,例如打印一个没有赋值的变量,便会输出一个 nil 值:
> print(type(a))
nil
>
对于全局变量和 table,nil 还有一个”删除”作用,给全局变量或者 table 表里的变量赋一个 nil 值,等同于把它们删掉,执行下面代码就知:
tab1 = { key1 = "val1", key2 = "val2", "val3" }
for k, v in pairs(tab1) do
print(k .. " - " .. v)
end
tab1.key1 = nil
for k, v in pairs(tab1) do
print(k .. " - " .. v)
end
boolean 类型只有两个可选值:true(真) 和 false(假),Lua 把 false 和 nil 看作是”假”,其他的都为”真”:
print(type(true))
print(type(false))
print(type(nil))
if type(false) or type(nil) then
print("false and nil are false!")
else
print("other is true!")
end
Lua 默认只有一种 number 类型 – double(双精度)类型(默认类型可以修改 luaconf.h 里的定义),以下几种写法都被看作是 number 类型:
print(type(2))
print(type(2.2))
print(type(0.2))
print(type(2e+1))
print(type(0.2e-1))
print(type(7.8263692594256e-06))
字符串由一对双引号或单引号来表示。
string1 = "this is string1"
string2 = 'this is string2'
也可以用 2 个方括号 “[[]]” 来表示”一块”字符串。
html = [[
<html>
<head></head>
<body>
<a href="//www.w3cschool.cn/">w3cschoolW3Cschool教程</a>
</body>
</html>
]]
print(html)
在对一个数字字符串上进行算术操作时,Lua 会尝试将这个数字字符串转成一个数字:
> print("2" + 6)
8.0
> print("2" + "6")
8.0
> print("2 + 6")
2 + 6
> print("-2e2" * "6")
-1200.0
> print("error" + 1)
stdin:1: attempt to perform arithmetic on a string value
stack traceback:
stdin:1: in main chunk
[C]: in ?
>
以上代码中”error” + 1 执行报错了,字符串连接使用的是 .. ,如:
> print("a" .. 'b')
ab
> print(157 .. 428)
157428
>
使用 # 来计算字符串的长度,放在字符串前面,如下实例:
> len = "www.w3cschool.cn"
> print(#len)
16
> print(#"www.w3cschool.cn")
16
>
在 Lua 里,table 的创建是通过”构造表达式”来完成,最简单构造表达式是{},用来创建一个空表。也可以在表里添加一些数据,直接初始化表:
-- 创建一个空的 table
local tbl1 = {}
-- 直接初始表
local tbl2 = {"apple", "pear", "orange", "grape"}
Lua 中的表(table)其实是一个”关联数组”(associative arrays),数组的索引可以是数字或者是字符串。
-- table_test.lua 脚本文件
a = {}
a["key"] = "value"
key = 10
a[key] = 22
a[key] = a[key] + 11
for k, v in pairs(a) do
print(k .. " : " .. v)
end
脚本执行结果为:
不同于其他语言的数组把 0 作为数组的初始索引,在 Lua 里表的默认初始索引一般以 1 开始。
-- table_test2.lua 脚本文件
local tbl = {"apple", "pear", "orange", "grape"}
for key, val in pairs(tbl) do
print("Key", key)
end
脚本执行结果为:
table 不会固定长度大小,有新数据添加时 table 长度会自动增长,没初始的 table 都是 nil。
-- table_test3.lua 脚本文件
a3 = {}
for i = 1, 10 do
a3[i] = i
end
a3["key"] = "val"
print(a3["key"])
print(a3["none"])
脚本执行结果为:
在 Lua 中,函数是被看作是”第一类值(First-Class Value)”,函数可以存在变量里:
-- function_test.lua 脚本文件
function factorial1(n)
if n == 0 then
return 1
else
return n * factorial1(n - 1)
end
end
print(factorial1(5))
factorial2 = factorial1
print(factorial2(5))
脚本执行结果为:
function 可以以匿名函数(anonymous function)的方式通过参数传递:
-- function_test2.lua 脚本文件
function anonymous(tab, fun)
for k, v in pairs(tab) do
print(fun(k, v))
end
end
tab = { key1 = "val1", key2 = "val2" }
anonymous(tab, function(key, val)
return key .. " = " .. val
end)
脚本执行结果为:
在 Lua 里,最主要的线程是协同程序(coroutine)。它跟线程(thread)差不多,拥有自己独立的栈、局部变量和指令指针,可以跟其他协同程序共享全局变量和其他大部分东西。
线程跟协程的区别:线程可以同时多个运行,而协程任意时刻只能运行一个,并且处于运行状态的协程只有被挂起(suspend)时才会暂停。
userdata 是一种用户自定义数据,用于表示一种由应用程序或 C/C++ 语言库所创建的类型,可以将任意 C/C++ 的任意数据类型的数据(通常是 struct 和 指针)存储到 Lua 变量中调用。