Lua

原创于 2024-08-06 21:38:44 发布 · 376 阅读

CC 4.0 BY-SA版权

文章标签：

官网：https://www.lua.org
菜鸟教程：https://www.runoob.com/lua/lua-tutorial.html
Github：https://github.com/rjpcomputing/luaforwindows/releases
Lua 是一种轻量小巧的脚本语言，用标准C语言编写并以源代码形式开放，其设计目的是为了嵌入应用程序中，从而为应用程序提供灵活的扩展和定制功能。

环境变量：如果是安装二进制文件，在系统变量 Path 中添加安装目录，cmd 中使用 lua54 命令运行脚本。（lua54是版本5.4.x）

command

# 查看版本
lua54
# 执行
lua a.lua
# 编译
luac a.lua

注释

--单行注释
--[[
多行注释
]]

打印

print("hello",false,nil)-- hello	false	nil
print("换行\n","制表\t")
print("不转义输出",[[\n\t]])
print(#"长度")
io.write("不换行")
io.write("输出")

基本类型（ Lua 是弱类型语言）

nil	boolean	number	string	function	userdata	thread	table

--number
print(type(1))
--string
name="lisi"
name='lisi'
print(type(name))
--nil
name=nil
name=null
name=NULL
print(type(name))
--boolean，只有nil和false表示假
print(type(true))
--多重赋值，不同类型变量可以直接赋值
age,name=10,"lisi"
age,name=name,age

function

--可以有多个返回值，可以用多个变量接收返回值（按顺序赋值）
--如果接收的变量数量大于返回值数量，则补充nil
--如果接收的变量数量小于返回值数量，则不返回多余返回值
a,b=function func(name)
    return "1",2,name
end
--上面的变量接收的是函数返回值
--这里的变量接收的是一个函数
a=function(val)
    return val;
end
print(a,a("name"))--function: 0000000000cf08s0	name

table

--table 类似于map，除了nil，都可以作为 key 值
--{}就是一个table
print({})--table: 0000000001061f30
--属性，在循环中，有 key 值的属性都是无序遍历
t={id=1,name="aa"}
print(t.id,t["name"])--1	aa
--使用索引作为 key，从 1 开始
t={age=1,"name",false,nil,false}
--ipairs循环，会跳过所有有 key 值的属性，遇到 nil 会结束循环
for i, v in ipairs(t) do
    print(i,"=",v)
end
--[[
	1	=	name
	2	=	false
]]
--pairs循环，遇到 nil 不会结束，会跳过并且会增加索引
--循环结束会无序遍历被跳过的有 key 值的属性
for i, v in pairs(t) do
    print(i,"=",v)
end
--[[
	1	=	name
	2	=	false
	4	=	false
	age	=	1
]]
--新增
t.desc="直接添加没有的属性"
table.insert(t,"在末尾添加")
table.insert(t,1,"指定索引位置插入")
--修改，覆盖即可
t.id=2
--删除
t.id=nil--赋值为 nil
table.remove(t)--删除最后一个元素
table.remove(t,1)--删除指定索引位置的元素
--拼接
t={"a","b"}
print(table.concat(t))--ab
print("拼接时添加分隔符','",table.concat(t,","))--a,b
--排序
table.sort({"b","a","c"})--abc
--复杂结构
t={
    {id=1},
    func=function()
        return "1"
    end
}
print("通过下标访问t的属性中的table的属性",t[1].id)
print("调用t的属性中的方法",t.func())

变量

--全局变量
a=1
--局部变量，在代码块内使用 local 修饰
do
    age=10--全局
    local name="name"
end
print(name)--nil

运算符：+ - * / % ^

print(8/3)--2.6666666666667
print(2^3)--8.0

关系运算符：==，~=，>，<，>=，<=

--只能相同类型间运算
print(1=='1')--false
t1={}
t2={}
print(t1==t2)--false
t3=t1
print(t1==t3)--true

逻辑运算符：and，or，not

--a为真则返回b，a为假则返回a
a,b=1,2
print(a and b)--2
a,b=nil,2
print(a and b)--nil
--a为真则返回a，a为假则返回b
a,b=1,2
print(a or b)--1
a,b=nil,2
print(a or b)--2
--not运算符会将结果转为boolean
a,b=nil,2
print(not a)--true
print(not b)--false

流程控制：if，while，repeat

--if
if a < 10 then
elseif a < 20 then
else
end
--while
while i < 4 do
    if i > 2 then
        break
    end
    i = i + 1
end
--repeat（ do while ）
repeat
    i = i + 1
until i >= 4
--for
for i = 1, 3 do
    print(i)--1，2，3
end
--第三个参数是步进值，可以是负数，步进值默认是1
for i = 1, 3, 2 do
    print(i)--1，3
end

string

--转大写
string.upper(str)
--转小写
string.lower(str)
--长度
string.len(str)
print(#str)
--反转
string.reverse("hello")--olleh
--拼接
print("a".."b")--ab
--查找，找得到返回（起始索引，结束索引），找不到返回 nil
--init 指定了搜索的起始位置，默认为 1，可以一个负数，表示从后往前数的字符个数。
--plain 表示是否使用简单模式，true 只做简单的查找子串的操作，false(默认) 表示使用正则模式匹配。
string.find (str, substr, [init, [plain]])
--正则匹配
str="12345"
string.find(str,"%d") --1	1
string.find(str,"%d+")--1	5
--ascii码转换
string.char(65)--A

select

--参数表"..."代表可变参
--select(n,...)获取从第n个位置开始的部分
--select("#",...)获取长度
function func(...)
    print(select(1,...))--1	2
    print(select(2,...))--2
    print(select("#",...))--2
end
func(1,2)

（）

--()返回可变参或返回值列表的第一个参数
function func(...)
    print((...))--1
    return ...
end
print((func(1,2,3)))--1

pack

--打包成table，属性 n 代表参数个数
function func(...)
    local t = table.pack(...)
    print(t.n)--3
end
func(1,2,3)

unpack

--解包
t={1,2,3}
a,b,c = table.unpack(t)--1	2	3
--参数2，3 代表起始索引和结束索引
a=table.unpack(t,1,1)--1
b,c=table.unpack(t,2,3)--2	3

元表

--一套自定义的计算规则 用于表与表之间的运算 又称元方法 起到其他语言中运算符重载的作用
t1={1,2}
t2={3,4}
print(t1+t2)--不能直接相加
--定义元表
metaTable={}
setmetatable(t1,metaTable)--把 metaTable 设为 t1 的元表
setmetatable(t2,metaTable)--把 metaTable 设为 t2 的元表
metaTable.__add = function(tb1,tb2)
    local res={}
    for i = 1, #tb1 do
        res[i] = tb1[i] + tb2[i]
    end
    return res
end
t3 = t1 + t2--{4,6}
--返回对象的元表
getmetatable(t)

面向对象

--self
t1 = { id = 1, name = "name" }
function t1:getName()
    return self.name
end
print(t1:getName())
--自索引实现继承
t1 = { id = 1, name = "name" }
meta = { age = 10 }
meta.__index = meta--自己索引自己，继承者才可以访问父类（元表）的属性
setmetatable(t1, meta)
print(t1.age)--10
--多重继承
t1 = {id = 1}
function t1:new()
    obj = {}
    setmetatable(obj, self)
    self.__index = self
    return obj
end
t2 = t1:new()
t3 = t2:new()
print(t3.id)--1

协程

编程语言Lua从5.0版开始支持协程的概念，极大的扩展了Lua的能力。Lua的协程通过扩展库croutine来实现。
Lua的协程是一种类似于线程的概念，它可以实现多个任务的并发执行，但又不同于操作系统的线程。
Lua的协程有以下特点：

Lua的协程是协作式的，它们需要彼此之间主动让出控制权，才能切换执行。
Lua的协程是轻量级的，它们不需要太多的系统资源，可以创建很多个协程。每个协程只有自己的栈、局部变量和指令指针，而共享全局变量和其他大部分东西。
Lua的协程是单线程的，在任何时刻只有一个协程在运行，其他的协程都处于挂起状态。Lua使用一个全局变量来记录当前运行的协程，所以协程之间不会发生并发冲突。

coroutine.close (co)-----------关闭协程，返回boolean
coroutine.create (f)-----------创建协程，传入一个function，返回一个协程句柄（类型为thread的值）
coroutine.isyieldable ([co])-----------判断协程是否是yield 状态
coroutine.resume (co [, val1, ·.]) -----------将挂起态的协程重新激活
coroutine. running ()-----------获取正在运行的协程
coroutine.status----------- (co)获取co句柄对应的协程的状态[suspended(挂起)，running(执行中) , dead(结束)]
coroutine.wrap (f)-----------用function创建一个新的协程
coroutine.yield (.. ) -----------挂起当前协程

handle = coroutine.create(func)--thread: 000000000100e8d8
--挂起协程
--参数会传递给 coroutine.resume
coroutine.yield("你好")
--唤醒协程
--参数一是协程变量，后面是传递给协程函数的参数
--返回值一是一个布尔值，表示协同程序是否成功恢复执行。
--返回值二是 coroutine.yield 传递的第一个值
--如果没有调用 yield 并且到达了函数的结尾，那么就是协同程序函数的返回值。
isOk,msg = coroutine.resume(handle,1,2)

文件操作

io.open (filename [, mode])
r只读方式打开，文件必须存在。
w只写方式打开，文件存在则删除原有内容，文件不存在则创建。
a追加方式打开，文件存在，则写入的数据会往最后追加，文件不存在则创建。读写方式打开，文件必须存在。
w+读写方式打开，文件存在则删除原有内容，文件不存在则创建。
a+与a类似，但文件可读写。
b二进制模式，如果文件是二进制文件，可以加上b
+修饰符，表示对文件既可以读也可以写

io.read()
*n读取一个数字
*a读取所有内容
*l默认值，读取下一行
123从当前位置开始，读取123个字符长度

f1 = io.open("a.txt", "r")--只读方式打开
if (f1 == nil) then
    print("文件不存在")
    os.exit()
end
print(f1)--file (00007fffaa16fj90)
--把f1文件句柄输入到io
io.input(f1)
print(io.read())--读取一行
print(io.read("*a"))--读取剩下的所有内容
--关闭资源
f1:close()
f2 = io.open("a.txt", "r+")
io.output(f2)
--移动光标到末尾
f2:seek("end")
io.write("追加写入")
--刷新当前的输出文件 确保数据写入
io.flush()
f2:close()

包管理

--t.lua
t = {}
return t
--其他位置调用
local t = require("t")