一、在线虚拟机环境
二、变量
1. 变量声明
- 全局变量
不加任何修饰符的默认情况下声明的变量即为全局变量.
-- 以下是全局变量
a = 1
b = 2
- 局部变量
使用 local 修饰符将变量声明为局部变量.
local a = 1
local b = 2
- 空
所有没有被声明的变量默认为空.
print(a)
-- 输出为 nil
- 声明多个变量并赋值
Lua中可以用以下语法同时声明多个变量并且赋值:
a, b = 1, 2
print(1, 2)
2. 变量的数据类型
数字(number)类型
最基本的数字即为number类型, 且其拥有多种表示方法:
-- 十进制数字
a = 1
b = 2
-- 以十六进制表示的数字类型
c = 0x11 -- 等于 17
-- 科学计数法
d = 2e10 -- 等于 20000000000.0
字符串(string)类型
与其他语言相似, 在Lua中可以用双引号或单引号来表示一个字符串：
str1 = "hello world"
str2 = 'foo bar'
print(str1) -- 输出 hello world
print(str2) -- 输出 foo bar
Lua中可以使用双中括号来声明一个文本块:
str = [[
114514
1919
810
]]
print(str)
Lua中可以使用字符串连接符号来进行字符串的连接:
a = 'foo'
b = 'bar'
c = a..b
print(c) -- 输出 foobar
使用tostring()函数可以将其他类型的变量转换为字符串:
a = 123
b = tostring(a)
print(type(b)) -- 输出 string
同时, 也可以使用tonumber()函数来将字符串变量转换为Number类型:
a = "10"
b = tonumber(a)
print(type(b)) -- 输出 number
-- 注意, 如果tonumber()转换失败, 则输出结果将为nil
c = "abc"
d = tonumber(c)
print(d) -- 输出 nil
使用#号获取字符串的长度:
a = "114514 1919 810"
print(#a) -- 输出 15
字符串(string)内建函数
string.char()
在Lua中的字符串类似其他语言, 本质上是一个字符(char)类型的数组. 对于 string.char(...)函数, 它可以接收一组ascii码值, 然后返回一个由这些字符组成的字符串.
s = string.char(0x30, 0x31, 0x32, 0x34)
print(s) -- 输出 0124
string.byte()
函数string.byte(x, y)接收两个变量, x为任意字符串, y则是该字符串中任意字符的下标, 该函数返回对应下标的字符的ascii码值
str = "hello"
n = string.byte(str, 2)
print(n) -- 输出 101, 即e
print(string.char(n)) -- 输出 e
布尔(boolean)类型
与其他语言类似, Lua拥有布尔类型, 其值只有 true 和 false 两种
a = true
b = false
布尔值可以用比较符号得出, Lua支持的比较符号有以下几种
-- 小于
print(1 < 2)
-- 大于
print(1 > 2)
-- 小于等于
print(1 <= 2)
-- 大于等于
print(1 >= 2)
-- 等于
print(1 == 2)
-- 不等于
print(1 ~= 2)
同时, Lua使用 and、or 和 not 等关键字来作为逻辑连接词
a = true
b = false
-- a且b
print(a and b) -- 输出 false
-- a或b
print(a or b) -- 输出 true
-- 非a
print(not a) -- 输出 false
在Lua中, 只有nil和false为成假赋值, 其他所有值均为成真赋值
a = nil -- 假
b = 0 -- 真
-- 由于无法进行类型转换, 因此直接使用两次求反运算来转换为布尔值
print(not not a) -- 输出 false
print(not not b) -- 输出 true
当使用逻辑连接词对非布尔值进行运算时, 将不一定会返回布尔值,
例如, 当多个变量以and相连时, 会返回第一个为成假赋值(false/nil)的变量:
a = "hello"
b = 0
c = false
print(a and b and c) -- 输出 false
a = nil
b = 0
c = 123
print(a and b and c) -- 输出 nil
当相连的变量中不含有成假赋值的变量时, 返回最后一个变量(右值)
a = "hello"
b = 0
c = 123
print(a and b and c) -- 输出 123
类似的, 对于or语句相连的变量, 会返回第一个成真赋值, 而当不存在成真赋值时, 返回最后一个变量(右值)
a = 'hello'
b = a
c = nil
print(a or b or c) -- 输出 hello
a = false
b = false
c = nil
print(a or b or c) -- 输出 nil
利用上述特性, 可以用逻辑连接词来构建一个三元表达式
a = 1
print(1 > 0 and "yes" or "no") -- 输出 yes
表(table)类型
表是一种类似数组的数据结构, 可以用一对大括号进行声明
-- 声明一个表
a = {}
print(type(a)) -- 输出 table
表中可以存放任意类型的元素, 除了数字型和字符串型外还可以存储函数, 甚至可以在表中嵌套表
a = {
"hello",
114514,
function() end,
{}
}
注意 表使用一对中括号+下标来存取元素, 而下标的起始数为1
a = {"hello", 123}
print(a[0]) -- 输出为 nil
print(a[1]) -- 输出为 hello
-- 使用等号可以直接为任意下标的元素赋值
a[5] = "foo"
print(a[5]) -- 输出为 foo
使用#符号也可以获取到表的长度
a = {123, 456}
print(#a) -- 输出为 2
表(table)的内建函数
- 插入元素
使用table.insert(x, y)语句来为一个表插入元素, x为表名, y为任意变量
a = {}
table.insert(a, "hello")
print(a[1]) -- 输出 hello
还可以使用table.insert(x, y, z)语句来在某个表的指定位置插入元素, x为表名, y为对应位置的下标, z为任意变量
a = {"hello", 123}
table.insert(a, 1, "foo") -- 在下标为1的位置插入元素, 即首位
print(a[1]) -- 输出为 foo
- 删除元素
使用table.remove(x, y)来删除表中任意位置的元素, 其中x为表名, y为对于位置的下标
a = {"hello", 123}
table.remove(a, 1) -- 删除a表中下标为1的元素, 即"hello"
-- 删除元素后所有剩余元素向前移动一位
print(a[1]) -- 输出为 123
table.remove(x, y) 将返回其删除掉的元素
a = {"hello", 123}
local b = table.remove(a, 1)
print(b) -- 输出为 hello
表(table)的字符串(string)下标
Lua中的表还拥有类似Map的属性, 即可以使用字符串作为下标, 实现类似于key的效果.
a = {
el1 = 1, --使用 "el1"作为下标
el2 = 10
}
-- 注意 使用字符串下标时, 存取元素需要带有双引号来表示其下标, 否则会被认定为是一个变量
print(a["el1"]) -- 输出 1
当下标的命名符合变量的命名规范时, 还可以直接用 表名.下标名 来存取元素
a = {
el1 = 1,
el2 = 10
}
print(a.el2) -- 输出 10
全局表
在Lua中有一个特殊的表, 被称为全局表, 变量名为_G, 它存储了当前上下文中的所有全局变量
a = 114514
print(_G["a"]) -- 输出 114514
注意 _G 表存储了所有的全局变量, 包括之前用到的 table 实际上便是Lua中内建的一个表, 该表存储了与表有关的操作函数
print(_G["table"]) -- 输出 table: 0x10
print(_G["table"]["insert"]) -- 输出 function: 0x155
三、运算符
除了最基本的加减乘除运算, Lua还支持一些其他的符号.
- 乘幂符号
乘幂符号用于计算x的y次方, 具体语法如下:
a = 10^5 -- 等于10的5次方
print(a) -- 输出为100000.0
- 左移、右移
基本的二进制移位运算:
a = 1 << 3 -- 将1左移3位 即 001 → 010 → 100 = 8
print(a) -- 输出 8
四、 函数
- 函数声明
一个最基础的函数声明如下:
function hello()
-- 函数体
end
在Lua中, 函数本质上也是一种变量类型, 可以将函数名在左侧声明, 然后用等号连接:
hello = function()
-- 函数体
end
- 形式参数
函数的形式参数声明类似变量:
-- 此处声明了三个形式参数a, b, c
function f(a, b, c)
-- 函数体
end
类似变量, 当形式参数被声明而没有传入值时, 未传值的形式参数值为nil
function f(a, b, c)
print(a, b, c)
end
f(114514, 1919810) -- 输出 114514 1919810 nil
- 返回值
默认情况下, 函数返回值为nil
function f()
-- 函数体
end
result = f()
print(result) -- 输出 nil
可以使用return语句来返回值
function f(a, b)
return a
end
result = f(1, 2)
print(result) -- 输出 1
return语句也可以返回多个值
function f(a, b)
return a, b
end
print(f(1, 2)) -- 输出 1 2
-- 可以配合多重赋值语句使用
local i, j = f(1, 2)
print(i) -- 输出 1
print(j) -- 输出 2
五、分支判断语句
在Lua中的分支判断语句由if关键字开始判断语句, 在than关键字处结束判断语句, 并开始一段代码块, 用else关键字开始另一分支代码块, 最后用end关键字结束整个语句, 具体如下:
a = 1
b = 2
if a==b then
print("foo")
else
print("no")
end
-- 输出 no
使用elseif <布尔表达式> then语句来开始另一个条件分支代码块
a = 1
b = 2
if a==b then
print("foo")
elseif b > a then
print("bar")
else
print("no")
end
-- 输出 bar
注意 在elseif语句中, else和if不可分开写, 否则将会视为一个新的if语句而导致编译报错
六、循环语句
在Lua中拥有三种循环语句, 分别使用 for、while 和 repeat 关键字
for循环
for循环使用for关键字作为起始, 然后接受一个循环范围表达式, 类似i = 1, 10 表示从1到10, 然后在 do 关键字之后开始循环代码块, 最后用end关键字结束代码块
-- 这是一个最简单的循环
for i=1,10 do
print(i) -- 输出0 1 2 3 4 5 6 7 8 9 10
end
-- 此处的i为局部变量, 离开for代码块后将没有定义
print(i) -- 输出nil
循环范围表达式可以加入第三个值来代表i所增加的步长
for i=1,10,2 do
print(i) -- 输出 1 3 5 7 9
end
步长值可以是负数, 此时每次循环使得i减少对应步长值, 此时对应的i值应大于结束值, 否则代码块不会被执行
for i=10,1,-1 do
print(i) -- 输出 10 9 8 7 6 5 4 3 2 1
end
循环过程中, i的值不能被更改, 若在循环代码块中对i值进行修改, 则得到的是一个新的i
for i=10,1,-1 do
print(i) -- 输出 10 9 8 7 6 5 4 3 2 1
i = 1
end
循环过程中, 使用break关键字提前退出循环
for i=10,1,-1 do
print(i) -- 输出 10 9 8
if i == 8 then break end
end
while循环
while循环类似for循环表达式, 但是将循环范围的表达式换成了布尔表达式, 当布尔表达式成真时, 执行循环代码块中的语句.
local x = 10
while x > 0 do
print(x) -- 输出 10 9 8 7 6 5 4 3 2 1
x = x - 1
end