Lua 快速入门 · 教程笔记

发布时间:2024年01月19日

前言

笔记的内容出自 Bilibili 上的这两个视频:

Lua语言快速入门精通(第 1 ~ 6 集)

【无废话30分钟】Lua快速入门教程 - 4K超清

前者组成了笔记的主要结构,后者作为前者的补充。笔记主要用于供笔者个人或读者回顾知识点,如有纰漏,烦请指出 : )

1. Lua 语言介绍

一般是使用 C/C++ 来实现功能,用 Lua 来实现逻辑。因为 Lua 作为一种动态的脚本语言,它可以在调用时进行解释或编译,不用像静态语言那样编译完毕才能运行。

2. Lua 语言基础之基本语法

声明变量

在 Lua 里,直接声明一个变量的话,它是作为全局变量存在的,它在另一个文件里也可以用。

如果想让它只对本地有作用则需要在前面加个 local。

num1 = 100			-- 作用于全局
local num2 = 200	-- 作用于本地
  • 在 Lua 里,nil 代表空值。
  • 在其他语言里 “不等于” 是 !=,但在 Lua 里是 ~=(波浪号和等于号)
  • 在 Lua 里,nilfalse 才代表 false;其他所有数都代表 true,包括 0

声明方法

最基础的方法声明与调用,如下所示:

-- 声明方法
function sayHello()
	print("Hello Lua")
end

sayHello()	-- 调用,输出 Hello Lua

使用 if - else

声明带参数的方法与调用,如下所示:

function max(a, b)
	-- if 语句的运用
	if a > b then
		return a
	else
		return b
	end
end

print(max(2, 3))	-- 输出 3
  • 如果中间想继续判断就用 elseif {表达式} then

使用 for

使用 for 循环:

-- 输出 1 到 100
for var = 1, 100 do
	print(var)
end
  • break 可以用于终止 for 和 while 的循环。

使用 while

使用 for 循环:

-- 输出 1 到 100
local var = 1
while var < 101 do
    print(var)
    var = var + 1 	-- 注意,Lua 不支持自减(-=)和自增(+=)
end

3. Lua 语言基础之表

表相当于一个装载键值对的容器,但是它里面什么都可以存放,示例如下:

Config = {}		-- 声明一个空表

-- 声明两个键值对
Config.words = "Hello"	-- 键是 words,值是 "Hello"
Config.num = 100		-- 键是 num,值是 100

-- 用中括号 [] 来声明键值对
Config["name"] = "ZhangSan"		-- 此处可看出键实际上是字符串

-- 通过表和键输出值
print(Config.words)		-- 输出 Hello
print(Config["num"])	-- 输出 100,如果不添加双引号则为 nil(为空)

由上我们可以得出一个规律:

  1. . 和键获取表内元素的时候 不需要 " "
  2. [ ] 和键获取表内元素的时候 配套使用 " "

我们也可以在声明表的同时声明内部元素,并且用 for 来遍历内部元素

-- 在声明表的同时声明内部元素
Config1 = {hello = "Hello lua", world = "World"}

-- 用 for 遍历表内元素
for key, var in pairs(Config1) do
	print(key, var)	
end

-- 输出如下(乱序输出)
--hello		Hello lua
--world		World

4. Lua 语言基础之数组

数组跟表一样也是用 { } 来代表,不过声明内部元素的时候不需要提供键,它会自动从 1 开始递增式为元素配置键。

arr = {1, 2, "Hello"}

-- 用 for 遍历数组内键值对
for key, var in pairs(arr) do
	print(key, var)
end

-- 输出如下
--1		1
--2		2
--3		Hello

插入元素

我们可以通过 for 为表添加元素,这时候要用到 Lua 提供的一个 API:table.insert()

arr1 = {}

for var = 1, 3 do
	table.insert(arr1, 1, var)	-- 3个形参按顺序分别是:表,插入位置,值
end

for key, var in pairs(arr1) do
	print(key, var)
end

-- 输出如下
--1		3
--2		2
--3		1

我们可以从上面的输出结果看出来,固定往位置 1 分别插入 1、2、3,原来处于位置 1 的值就会被往后推,最后就呈一个倒序的样子。

Lua 官网的 Document 里可以找到其 API 文档(此处为 5.4 版本),方便我们查阅 Lua 提供的方法的作用。其 API 基本就是对 C 语言 API 的一个映射。

下图截取自官方的 API 解析:
在这里插入图片描述

移除元素

我们可以通过 table.remove() 来移除表内的元素,并且这个方法会返回被移除的元素的值。

arr2 = {1, 2, 3, 4}

local rm = table.remove(arr2, 2)	-- 移除第 2 个元素

for key, var in pairs(arr2) do
	print(key, var)
end

print(rm)

-- 输出如下
--1		1
--2		3
--3		4
--2

获取表的长度

在 lua 5.2 及之前的版本,我们还可以通过 table.maxn() 来获取表的长度。如果是 lua 5.3 及以上的版本,我们可以用 # 来获取表的长度。

print(table.maxn(arr1))		-- 输出 3(仅适用于 lua 5.2 及以下版本)

print(#arr1)	-- 输出 3(仅适用于 lua 5.3 及以上版本)

全局表

在 Lua 里,所有的全局变量都被放在一个名为 _G 的全局表里。

a = 1
print(_G["a"])		-- 输出 1	

并且实际上 table.insert() 里的 table 也是一个全局变量,其类型是一个表;insert 就是它的一个键,其值是一个方法。

5. Lua 语言面向对象之复制表的方式面向对象

在表里面声明方法的写法如下:

People = {}

-- 声明方法的方式一
People.sayHi = function()
	print("People say hi")
end

-- 声明方法的方式二
function People.sayHello()
	print("People say hello")
end

此时我们可以发现表也可以当作是一个类,因为它既可以存储变量,又可以存储方法,所以表在 Lua 里是一个比较万金油的角色。

通过复制 People 类来创建它的实例:

-- 复制表内元素,返回这个复制表
function clone(tab)
	local ins = {}
	for key, var in pairs(tab) do
		ins[key] = var
	end
	return ins
end

-- 相当于创建实例
local p = clone(People)
p.sayHi()	-- 输出 People say Hi

我们还可以为类添加一个构造方法:

-- 修改一下 sayHi()
People.sayHi = function(self)
	print("People say hi:"..self.name)	-- ".." 是字符串连接符号
end

-- People 的构造方法
People.new = function(name)
	local self = clone(People)
	self.name = name

	return self
end

local p = People.new("ZhangSan")
p.sayHi(p)	-- 输出 People say hi:ZhangSan
-- 另一种调用方式
p:sayHi()	-- 使用 ":" 调用,输出同上

通过 : 调用方法,其实就是隐式地把表自己当作第一个实参传递,即 tab:func(param) 相当于 tab.func(tab, param)

那么反过来,通过 : 来定义方法,实际上隐藏了一个形参的声明,这个形参会截获调用函数时的第一个实参并把它赋值给self。

此处结论截取自其他博主的文章:《Lua函数的调用(:和.的调用区别)》

实现继承和重写父类方法

我们还可以通过复制表的内容来实现类的继承,并且可以重写父类方法。

-- 复制表的内容
function copy(dist, tab)
	for key, var in pairs(tab) do
		dist[key] = var
	end
end

-- Man 继承 People
Man = {}
Man.new = function(name)
	local self = People.new(name)
	copy(self, Man)		-- 将 Man 原本的内容也复制到 self 内
	return self
end

-- 重写父类 People 的 sayHello() 方法
Man.sayHello = function()
	print("Man say hello")
end

local m = Man.new("Lisi")
m:sayHello()	-- 输出 Man say hello
m:sayHi()		-- 输出 People say hi:Lisi

6. Lua语言面向对象之函数闭包的方式面向对象

我们可以专门声明一个返回表的方法,其中通过本地声明一个表,然后对其进行初始化操作以及方法定义的操作,这样我们就可以通过这个方法来获得一个类的实例。

function People(name)
	local self = {}

	local function init()
		self.name = name
	end

	self.sayHi = function()
		print("Hi "..self.name)
	end

	init()
	return self
end

local p = People("ZhangSan")
p:sayHi()	-- 输出 Hi ZhangSan

实现继承和重写父类方法

操作比较好理解,示例如下:

function Man(name)
	local self = People(name)

	self.sayHello = function()
		print("Hello "..self.name)
	end

	return self
end

local m = Man("Lisi")
m:sayHi()	-- 输出 Hi Lisi

额外补充

字符串补充

Lua 提供的 string.char() 可以将 Ascii 码值转换成字符串;string.byte() 可以直接将字符串里的指定位字符转换为十进制数值。

s = string.char(0x30, 0x31, 0x32, 0x33)
print(s)		-- 输出 0123
n = string.byte(s, 2)
print(n)		-- 输出 49(Ascii 表里,十进制 49 对应的是字符 '1')

在 C 语言里,字符串的 ‘0’ 代表着结束;但是在 Lua 里字符 ‘0’ 也可以被存储。这个特性可以用于安全地存储二进制流之类的数据。

文章来源:https://blog.csdn.net/q446013924/article/details/135474188
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。