03 Lua 数据类型
Posted 陈皮的JavaLib
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了03 Lua 数据类型相关的知识，希望对你有一定的参考价值。
文章目录
1 数据类型
- 字符串（string）：双引号或者单引号括起来的字符。
- 数值类型（number）：所有数字，包括十进制，十六进制以及科学计数法等。
- 布尔类型（boolean）：只有真和假两个值，即 true 和 false。
- 函数（function）：可以实现某种功能的代码块。
- 表（table）：lua 语言的核心之一，类似哈希表。
- 自定义类型（userdata）：脚本用户只能使用，不能对其进行定义。
- 线程（thread）：线程类型的值是一个可用于异步计算的协同程序（轻量级有限线程）。
- 空类型（nil）：空的意思，代表什么都没有。
在 Lua 中，可以使用type函数来求出类型。
print(type("chenpi")) -- string
print(type(123)) -- number
print(type(true)) -- boolean
print(type(type)) -- function
print(type()) -- table
2 字符串（string）
双引号和单引号括起来的字符串使用无差别，都可以对转义字符进行转义。
> print('单引号括起来的字符串\\n\\r这是换行后内存！')
单引号括起来的字符串
这是换行后内存！
> print("双引号括起来的字符串\\n\\r这是换行后内存！")
双引号括起来的字符串
这是换行后内存！
>
字符串还可以使用两个成对的中括号包括字符串，这样存储的是字符串原始值，即使它们是跨行的。
str = [[aa
bb cc
dd
ee
ff ff ff
]]
print(str)
-- 输出结果如下
aa
bb cc
dd
ee
ff ff ff
3 数值类型（number）
所有数字，包括十进制，十六进制以及科学计数法等。
i = 10
j = 10.15
k = 0x12
h = 1.20e5
print(i) -- 10
print(j) -- 10.15
print(k) -- 18
print(h) -- 120000.0
4 布尔类型（boolean）
只有真和假两个值，即 true 和 false。
flag = true
if flag then
print("flag is true")
else
print("flag is false")
end
-- 输出 flag is true
5 表（table）
表用来存储一些互相关联的元素，每一个元素都有一个关键字和一个值组成，即键值对。表功能类似哈希表。
表中元素的值可以放任何类型的值，例如字符串，数值，表，函数等等。
-- 创建一个空表
t =
-- 没有显示指定键的值，系统会自动分配键1，2，3...
t = k1 ="v1", "a", "b", "c"
print(t[0]) -- nil
print(t[1]) -- a
print(t[2]) -- b
print(t[3]) -- c
print(t[4]) -- nil
print(t["k1"]) -- v1
对表中元素的引用，除了使用表名[键名]之外，还可以使用表名.键名，但是后面这种不可以引用键是数值的元素。
t = k1 ="a", "b", k2 = "c", "d"
print(t[1]) -- b
print(t[2]) -- d
print(t["k1"]) -- a
print(t.k1) -- a
-- print(t.1) -- 不合法，会报错
t.k1 = "aa"
t[1] = "bb"
print(t[1]) -- bb
print(t.k1) -- aa
如果想要删除表中的元素，只需要将键对应的值设置为 nil 即可。
t = k1 ="a", k2 = "b"
print(t.k1) -- a
t.k1 = nil
print(t.k1) -- nil
遍历表中的元素，如下：
t = k1 ="a", "b", k2 = "c", "d"
for k, v in pairs(t) do
print(k, v)
end
-- 输出结果如下
1 b
2 d
k2 c
k1 a
表中还可以存储函数，以下演示将定义一个函数然后赋值给表中的一个键，最后进行调用。
t =
t.func = function()
print("Hello ChenPi!")
end
function t.func()
print("Hello ChenPi!")
end
--[[
上面和此种方式一样，但是推荐使用上面的方式
function t.func()
print("Hello ChenPi!")
end
--]]
t.func() -- Hello ChenPi!
我们可以借助table库，使用它定义的函数来操作表。
-- 插入元素，删除元素
table.insert(表名, 键, 值)
table.remove(表名, 键)
t = "a", "b", "c"
table.insert(t, 2, "g") -- 在第二个位置插入元素，原来键为2的值依次往后移
table.insert(t, "f") -- 没有指定键，则插入到尾部
-- 输出 agbcf
for i = 1, #t do
print(t[i])
end
table.remove(t, 2) -- 删除键为2的元素
table.remove(t) -- 省略键，则删除最后一个元素
-- 输出 abc
for i = 1, #t do
print(t[i])
end
-- 排序函数
table.sort(表名, 排序规则) -- 排序规则可以省略
t = "d", "a", "e", "c", "h", "g"
table.sort(t) -- 对值进行排序
-- 输出 acdegh
for i = 1, #t do
print(t[i])
end
function mysort(a, b)
return a > b
end
table.sort(t, mysort)
-- 输出 hgedca
for i = 1, #t do
print(t[i])
end
其实 Lua 中各种函数库（例如 table 库，string 库，math 库等等）就是使用表来存储一系列的函数，所以我们也可以自定义自己的函数库。
-- 定义一个空表
chenpifunc =
-- 定义第一个函数
chenpifunc.func1 = function()
print("Hello ChenPi!")
end
-- 定义第二个函数
chenpifunc.func2 = function(a, b)
local r = a + b
return r
end
-- 使用函数库
chenpifunc.func1()
print(chenpifunc.func2(5, 8))
-- 输出结果如下
Hello ChenPi!
13
我们可以借助表来实现数组类型，每一个数组元素底层其实映射着键1，2，3 … 。
arr = 1, 2, "a", "b", 3, true, 10.51
-- 打印的数数组的地址
print(arr)
-- 遍历数组
for k, v in pairs(arr) do
print(k, v)
end
-- 打印数组类型
print(type(arr))
-- 输出结果如下
table: 0x2406730
1 1
2 2
3 a
4 b
5 3
6 true
7 10.51
table
5.1 全局表 _G
我们定义的全局变量都存储在全局表_G中。
name = "陈皮"
age = 18
print(_G["name"]) -- 陈皮
print(_G.age) -- 18
t = name = "Hello Lua"
func = function()
print("Hi func")
end
print(_G["t"]["name"]) -- Hello Lua
_G.func() -- Hi func
5.2 复制表方式实现面向对象
其实可以通过表来实现面向对象编程，我们知道表可以存储键值对，还可以将一个函数赋值给表中的一个键，所以我们可以将表作为一个类使用。
-- 定义一个表，代表一个类模板
Person =
Person.name = "ChenPi"
Person.eat = function(p)
print(p.name.." is eating")
end
print(Person.name) -- ChenPi
Person.eat(Person) -- ChenPi is eating
我们可以定义一个函数，对上面定义的 Person 表进行克隆它的元素，模拟生成新对象（新表）进行使用。
function clone(t)
local inst =
for k, v in pairs(t) do
inst[k] = v
end
return inst
end
-- 定义一个表，代表一个类模板
Person =
Person.name = "ChenPi"
Person.eat = function(p)
print(p.name.." is eating")
end
-- 克隆对象
local p = clone(Person)
print(p.name) -- Hi ChenPi
p.eat(p) -- I am eating
p:eat() -- I am eating 等同于调用eat函数，并把自身作为参数传入函数
其实我们可以在表 Person 中定义一个 new 函数，还可以传入参数，从而可以构造指定参数的对象，如下：
function clone(t)
local inst =
for k, v in pairs(t) do
inst[k] = v
end
return inst
end
-- 定义一个表，代表一个类模板
Person =
Person.name = "ChenPi"
Person.eat = function(p)
print(p.name.." is eating")
end
Person.new = function(name)
local self = clone(Person)
self.name = name
return self
end
-- 克隆对象
local p = Person.new("陈皮")
print(p.name) -- 陈皮
p:eat() -- 皮 is eating
我们还可以模拟类继承关系，如下：
function clone(t)
local inst =
for k, v in pairs(t) do
inst[k] = v
end
return inst
end
-- 定义一个表，代表一个类模板
Person =
Person.name = "ChenPi"
Person.eat = function(p)
print(p.name.." is eating")
end
Person.new = function(name)
local self = clone(Person)
self.name = name
return self
end
-- 子类定义
Student = age = 18
Student.study = function()
print("Student is studying...")
end
Student.new = function(name)
local self = Person.new(name)
-- 将子类的元素放入父类中，重复的键还可以达到重写作用
for k, v in pairs(Student) do
self[k] = v
end
return self
end
-- 创建子类对象
local s = Student.new("陈皮")
print(s.name) -- 陈皮
print(s.age) -- 18
s:eat() -- 陈皮 is eating
s.study() -- Student is studying...
5.3 函数闭包方式实现面向对象
我们可以定义一个函数闭包，来创建对象（表）使用，如下所示：
function Person(name)
local self =
self.name = name
self.eat = function(p)
print(p.name.." is eating")
end
return self
end
local p = Person("陈皮")
p:eat() -- 陈皮 is eating
同样，模拟类继承关系，也是可以使用函数闭包的方式，如下所示：
function Person(name)
local self =
self.name = name
self.eat = function(p)
print(p.name.." is eating")
end
return self
end
local p = Person("陈皮")
p:eat() -- 陈皮 is eating
function Student(name)
local self = Person(name)
self.study = function()
print(self.name.." is studying...")
end
return self
end
local s = Student("狗蛋")
s:eat() -- 狗蛋 is eating
s.study() -- 狗蛋 is studying...
6 函数
函数是 function 类型的对象，函数可以被赋值给一个变量，函数中可以返回一个函数，函数可以比较，函数可以作为 table 表中的值。
-- 函数定义1
function 函数名(参数)
函数内容
...
end
-- 例如
function sum( i, j)
return i + j
end
print(sum(10, 23)) -- 函数调用
-- 函数定义2
函数名 = function(参数)
函数内容
...
end
-- 例如
sum = function(i, j)
return i + j
end
print(sum(10, 23)) -- 函数调用
函数可以不返回值，返回一个值，返回多个值。return 关键字只能在语句块的结尾一句，即 end 之前，else 之前，或者 until 之前。
function chenpi()
print("no return") -- no return
end
chenpi()
function chenpi()
return "one return"
end
print(chenpi()) -- one return
function chenpi(a, b)
local x = a + b
local y = a - b
return x, y
end
i, j = chenpi(10, 5)
print(i) -- 15
print(j) -- 5
如果函数返回值是另一个函数的最后一个参数，或者是多值赋值表达式的最后一个参数，那么函数的所有返回值都能被使用。否则，函数的所有返回值只有第一个返回值才被使用。
function func()
local x, y, z = 1, 2, 3
return x, y, z
end
print("Hello", "ChenPi", func()) -- Hello ChenPi 1 2 3
print("Hello", func(), "ChenPi") -- Hello 1 ChenPi
a, b, c, d = 0, func() -- 0 1 2 3
a, b, c, d = func(), 4 -- 1 4 nil nil
Lua 中，函数还可以定义可变参数。
function 函数名(...) -- 三个点代表参数个数不确定
function 函数名(a, b, ...) -- 2个固定参数，其他参数不确定
function 函数名(a, ...) -- 1个固定参数，其他参数不确定
-- 假设定义如下函数
function chenpi(a, b, ...)
print(a)
print(b)
print(arg[1])
print(arg[2])
print("-------")
end
chenpi() -- a=nil,b=nil,arg=
chenpi(1) -- a=1,b=nil,arg=
chenpi(1, 2) -- a=1,b=2,arg=
chenpi(1, 2, 3) -- a=1,b=2,arg=3
chenpi(1, 2, 3, 4) -- a=1,b=2,arg=3,4
-- 输出结果如下
nil
nil
nil
nil
-------
1
nil
nil
nil
-------
1
2
nil
nil
-------
1
2
3
nil
-------
1
2
3
4
-------
函数尾调用，当函数的最后返回值是调用另一个函数时，称为尾调函数。Lua 在调用尾调函数时，会先弹出当前函数的栈空间，然后再调用尾调函数，这样能降低函数层层调用过程中的栈消耗，适用于函数递归调用。
-- 以下函数调用耗时比较久
function func(i)
while i < 15 do
i = i + 1
print(i)
func(i)
end
return i
end
func(0)
-- 改变顺序，使用尾调函数，执行速度很快（而且1000还比15次数大很多）
function func(i)
if i > 1000 then
return i
end
i = i + 1
print(i)
func(i) -- func(i) + 1 不算尾调函数
end
func(0)
本次分享到此结束啦~~
我是陈皮，一个在互联网 Coding 的 ITer。如果觉得文章对你有帮助，点赞、收藏、关注、评论，您的支持就是我创作最大的动力！
以上是关于03 Lua 数据类型的主要内容，如果未能解决你的问题，请参考以下文章