Lua编程

一.lua环境安装

1.SciTE安装包

Github 下载地址:https://github.com/rjpcomputing/luaforwindows/releases

2.LuaDist(官方推荐,但不是很好用)

http://luadist.org/

二.lua中的注释

1.单行注释--

--这里是单行注释

2.多行注释

--[[
这里是多行注释
]]--

小技巧:在多行注释中,--[[添加一个短横线变成---[[就可以取消多行注释

三.标示符命名规则

使用大小写字母或下划线开头,加上0个或若干个大小写字母、数字或下划线。

注意:lua中内部全局变量基本使用下划线加上大写字母命名,因此不推荐这种方式命名标示符,避免冲突。

四.lua中的数据类型

1.数据类型nil

lua中的空值类型,删除变量时将变量设置为nil值即可。没有声明的变量的值都是nil。

b = 1
print(b)
b = nil
print(b)

 

 2.数据类型boolean

布尔值只有两个值true和false,表示真和假。值得注意的是,lua中在作逻辑判断时(如分支结构或循环结构中的真假判断),false和nil都视为假,true和其他值都视为真。

if nil then
    print(' ')
else
    print(false)
end

if 1 then
    print(true)
end

 

 3.数据类型number

lua中的数字都是number类型,可以理解为就是c中的double类型。number有如下写法:

print(2)
print(2.2)
print(2e3)
print(2.34e5)
print(3.1e-2)

 

 4.数据类型string

字符串类型使用单引号或双引号引用都可以,也可以使用两个中括号[[]]来引用字符串。

print('我是字符串')
print("我是字符串")
print([[我是字符串]])

 

 字符串的拼接使用..,不能使用+号。

print('lua中的+号会自动将'..'字符串两边的字符串转化为数字')
print('2'..3)
print('2'+'3')
print(2+3)
print('2'+3)
print('2+3')
print('a'+3)

 

 使用#获得字符串的字节数。

print(#'aaa aa')
print(#'中文一个字符占用两个字节')

 

 5.数据类型table

表的构造和基本使用。当定义table时直接定义值,不定义键时,table和string一样,可以使用#获得table中值的个数(本质上是取得最大索引)。

tab1 = {}  --空表  {}构造表达式
tab2 = {key1='value1',key2='value2'}  --使用键值对的形式构造表(和map或dictionary等类似)
tab3 = {'value1','value2','value3'}  --直接给出表的值,默认索引为1,2,3,4...,和数组或list等的性质类似

print(tab1)  --直接打印表,打印的是表的地址
print(tab1.key)  --表中没有的键对应值为nil

print(tab2.key1)  --获取表中的某个索引对应值的方法一
print(tab2['key1'])  --获取表中某个索引对应值的方法二

print(tab3[2])  --没有给出索引的表默认索引是1,2,3,4...,不能使用方法一获取索引对应的值
print(tab3['1'])  --索引的类型是number,使用字符1进行取值不能取得值

--使用循环遍历表
for k,v in pairs(tab3) do
    print(k..':'..v)
end

 表的添加值

tab = {}
tab.key1 = 'value1'
tab.key2 = 'value2'  --索引是字符串使用.赋值,使用中括号赋值会报错
tab[10] = 100  --索引是number及其他类型使用中括号进行赋值,使用.赋值同样报错。nil不能作为索引。
tab[false] = 10

print(tab.key1)  --同样的,在获取值时也需要注意取值的方式
print(tab[key2])
print(tab[10])
print(tab[false])

 

 6.数据类型function

使用function定义函数,不需要返回值,参数也不需要定义类型。

function fact(n)
    if n==1 then
        return n
    else
        return n*(fact(n-1))
    end
end

print(fact(4))

 

 函数同样可以作为值进行传递。

function fact(n)
    if n==1 then
        return n
    else
        return n*(fact(n-1))
    end
end

print(fact(4))

fact2 = fact

print(fact2(5))

 

 函数也可以作为参数传递,甚至可以定义匿名函数(类似于委托)。

--定义测试函数
function testFun(tab,fun)
    for k,v in pairs(tab) do
        fun(k,v)
    end
end

--定义表和参数中的函数
tab = {key1='value1',key2='value2'}
function f(k,v)
    print(k..':'..v)
end

--调用测试函数
testFun(tab,f)

--定义测试函数
function testFun(tab,fun)
    for k,v in pairs(tab) do
        fun(k,v)
    end
end

--定义
tab = {key1='value1',key2='value2'}

--调用测试函数,以匿名函数的形式传递函数参数
testFun(tab,
    function (k,v)
        print(k..' '..v)
    end
)

 

 7.数据类型thread

thread(线程)本质上是协程。

8.数据类型userdata

userdata是用户自定义的数据类型,通常由C/C++创建。

五.语法

1.全局变量和局部变量

lua中的变量不需要声明类型,默认情况下,变量都是全局变量。可以使用local关键字声明局部变量,局部变量只在当前代码块中起作用。一般情况下, 访问局部变量的速度更快。

function test()
    a = 5
    local b = 6
end

test()

print(a)
print(b)

 2.变量的赋值

变量可以单个赋值,也可以多个同时赋值,赋值的数据类型也可以不同。也可以使用多变量赋值方便地交换变量的值。

--可以单变量赋值,也可以多变量赋值
a = 1
a,b = 1,2
a,b,c = 1,'a',3

print(a,b,c)

--交换两个变量的值
a,b = b,a
print(a,b,c)

--交换三个变量的值
a,b,c = c,a,b
print(a,b,c)

--变量的个数多于值,多出来的变量会被自动忽略;值的个数多于变量,多出来的值会被自动忽略
c,d,e = 1,2
f,g = 4,5,6
print(c,d,e,f,g)

 

 3.循环

while循环。

i = 1
while i<=5 do
    print(i)
    i=i+1
end

 

 for循环。之前也有用到过遍历表的for循环,类似于foreach的使用。

--i从1自增到5,每次自增1
for i=1,5 do
    print(i)
end

--i从1自增到10,每次自增2
for i=1,10,2 do
    print(i)
end

 

 repeat until循环。这个循环相当于do...while,但是和do...while有所不同。do...while是先执行一次do中的代码块,再判断while的逻辑语句,如果满足条件继续执行;repeat until是先执行一次until中的代码块,再判断until中的逻辑语句,如果不满足条件继续执行。

i = 1
repeat
    print(i)
    i=i+2
until i>10

 

 4.分支结构

--if语句
if 0 then
    print(0)
end

--if else语句
i = 1
if i<=0 then
    print(0)
else
    print(1)
end

--if else if ...语句
j = -2
if j <0 then
    print(-1)
elseif j==0 then
    print(0)
else
    print(1)
end

 注:循环结构和分支结构中的,while、for、if等语句后面跟上逻辑语句,这些逻辑语句可以使用括号括起来,也可以使用空格隔开,不使用括号,这里都没有使用括号。

 

 5.函数

在lua中,函数可以作为数据赋值,也可以作为参数传递。

local function max(num1,num2)
    if num1 < num2 then
        return num2
    else
        return num1
    end
end

print(max(3,-5))

--函数作为数据赋值
temp = max
print(temp(1,8))

myprint = function (param)
    print('this is my print function '..param)
end

myprint('ww')

--函数作为参数传递
function add(num1,num2,printFun)
    res = num1+num2
    printFun(res)
end

add(40,50,myprint)

--lua中的函数可以返回多个值
function temp()
    return 10,20,30,40
end

res1,res2,res3,res4 = temp()
print(res1,res2,res3,res4)

--lua中的函数参数个数可变,如print函数
--...代表可变的参数,这些参数会被封装为一个名称为arg的表,使用表的方式访问这些参数,在使用for循环遍历表时arg会多一个值表示参数个数
--可变参数前可以有其他参数,但是可变参数一定在参数列表的最后,封装时只有可变参数部分会被封装到表arg中
function test(a,...)
    for k,v in pairs(arg) do
        print(v)
    end
end

test(1,2,3)

 六.lua中的运算符

1.算数运算符+、-、*、/、%、^(幂运算符在c#语言中不存在,c#中使用函数求幂)

2.关系运算符==、~=(不等于、 <、>、<=、>=

3.逻辑运算符and、or、not

print(3>2 and 4>3)
print(false or false)
print(not true)

 

 七.lua中的常见API

1.string有关的API

常见转义字符:\n 换行、\\ 一个反斜杠、\" 双引号、\' 单引号

a = 'hello\n\world my name is \'Micheal\''
print(a)

 

string.upper 将字符串转换为全部大写 string.lower 将字符串转化为全部小写

str = 'Hello everybody'
str2 = string.upper(str)
print(str,str2)
str3 = string.lower(str)
print(str,str3)

 

 string.gsub 将指定的字符替换为其他指定的字符

str = 'Hello everybody'
--将str中的字符e替换为字符8
str2 = string.gsub(str,'e','8')
print(str,str2)
--将str中的字符e替换为字符123,最多替换1次
str3 = string.gsub(str,'e','123',1)
print(str,str3)

 

 string.find 查找指定字符的第一个索引

str = 'Hello everybody'

--从头查找'every'字符的索引(索引从1开始)
index = string.find(str,'every')
print(index)
--从第6个字符开始茶轴'o'字符的索引
index2 = string.find(str,'o',6)
print(index2)

 

 string.reverse 反转字符串

str = 'Hello everybody'

str2 = string.reverse(str)
print(str2)

 string.format 字符串格式化输出(未知number使用%d代替,未知string使用%s代替,其他代替格式可以自行查阅)

num1 = 5
num2 = 10
str = string.format('加法:%d+%d=%d',num1,num2,num1+num2)
print(str)
date,month,year = 30,1,2021
d = string.format('日期:%02d/%02d/%03d',date,month,year)
print(d)

 

 string.char 将指定的数字转化为对应字符 string.byte 将字符转化为数字(默认转化字符串第一个字符,也可以指定转化第几个字符)

print(string.char(97,98,99,100))
print(string.byte('abcd'))
print(string.byte('abcd',3))

 

 string.len 获得指定字符串的长度(和#的结果相同)

print(string.len('我有一个梦想'))

 

 string.rep 得到指定字符串重复指定次后的字符串

print(string.rep('我有一个梦想',5))

 

 string.gmatch 正则表达式匹配,返回一个迭代器

for word in string.gmatch('Hello lua user','%a+') do
    print(word)
end

 

 2.table有关的API

lua中array本质上是table。因为table是动态的,因此lua中的array也是动态的。值得注意的是,table中的默认索引是从1开始的,因此array中的默认下标也是从1开始的。下面是一个二维数组的例子:

array = {}
for i=1,4 do
    array[i] = {}
    for j=1,3 do
        array[i][j]=i*j
    end
end

for i=1,4 do
    for j=1,3 do
        print(array[i][j])
    end
end

 数组的遍历。

array = {'lua','c#','java'}

--迭代函数一pairs:遍历table中的key和value
for k,v in pairs(array) do
    print(k,v)
end

--迭代函数二ipairs:从索引1开始,递增遍历,遇到nil就停止
for k,v in ipairs(array) do
    print(k,v)
end

array[2] = nil

for k,v in ipairs(array) do
    print(k,v)
end

表可以当作引用类型使用,表赋值给其他表赋值的是地址引用。

table = {'a','b','c'}
newtable = table

print(table[2])
print(newtable[2])

newtable[2] = 'd'

print(table[2])
print(newtable[2])

 

 表的数据拼接。

table1 = {'a','b','c'}

--直接拼接
str = table.concat(table1)
print(str)

--使用,间隔开拼接的数据
str = table.concat(table1,',')
print(str)

--使用,间隔开数据,指定拼接的索引
str = table.concat(table1,',',2,3)
print(str)

 

 表的数据插入和移除。

table1 = {'lua','c#','java','php'}
print(table.concat(table1,','))

--直接插入到末尾
table.insert(table1,'javascript')
print(table.concat(table1,','))

--指定插入到哪一位,后面的数据依次向后移动一位
table.insert(table1,2,'c++')
print(table.concat(table1,','))

--移除表一位数据
table.remove(table1)
print(table.concat(table1,','))

--移除指定位置的数据
table.remove(table1,3)
print(table.concat(table1,','))

 

表的排序。

table1 = {'lua','c#','java','php','c++','javascript'}
print(table.concat(table1,','))

--排序,按照ASCII码表顺序排列
table.sort(table1)
print(table.concat(table1,','))

 

八.面向对象编程及其他特性

1.模块与包

lua中的模块相当于c#的命名空间或java的包。

--定义模块,这个模块保存为文件Module.luavar = 'movin'

func1 = function()
    print('这是一个函数')
end

return module
--引入模块
require 'Module'

--使用模块中的变量
print(var)
func1()

 lua中的包是指使用C包,lua和C很容易结合,lua就是使用C写成的。

2.元表

lua提供了元表允许我们改变table的行为,每种行为关联了对应的元方法。

mytable = {'lua','java','c#','c++'}  --普通表
mymetatable = {}  --元表  拓展了普通表的行为
mytable = setmetatable(mytable,mymetatable)  --关联元表和普通表

1)__index元方法,这是metatable中最常用的键。当通过键访问table的时候,如果这个键没有值,那么lua就会寻找该table的metatable中的__index键。如果__index包含一个表格,lua会在表中查找相应的键,如果__index包含一个函数,lua就会调用那个函数。

mytable = {'lua','java','c#','c++'}

mymetatable = {
__index=function (tab,key)
    return 'javascript'
end
}

mytable = setmetatable(mytable,mymetatable)

print(mytable)
print(mymetatable)  --表和元表关联,但是两个表并不相同,元表是表的拓展
print(mytable[1])  --存在的键值
print(mymetatable[1])
print(mytable[10])  --不存在的键值,调用元表中__index键对应的函数
print(mymetatable[10])

 

 2)__newindex元方法,当对表的新索引进行赋值时会起作用,并且会取消赋值操作。

mytable = {'lua','java','c#','c++'}

mymetatable = {
__newindex = function (tab,key,value)
    print(string.format('我们要修改的key为%s,value为%s',key,value))
end
}

mytable = setmetatable(mytable,mymetatable)

--下面这些操作都不会触发__newindex对应的方法
mytable[1] = 'javascript'
print(table.concat(mytable,'  '))
table.insert(mytable,'lua')
print(table.concat(mytable,'  '))
table.insert(mytable,3,'c')
print(table.concat(mytable,'  '))
table.remove(mytable,1)
print(table.concat(mytable,'  '))
table.remove(mytable)
print(table.concat(mytable,'  '))

mytable[5] = 'lua'  --对新索引进行赋值时会调用__newtable对应的方法,而且不会进行赋值操作
print(table.concat(mytable,'  '))

mytable = {'lua','java','c#','c++'}

mymetatable = {
__newindex = function (tab,key,value)
    rawset(tab,key,value)  --由于调用了__newindex对应的函数后不会进行赋值,若想赋值,可以使用rawset函数(如果直接赋值会产生死循环)
    --mytable[5] = 'lua'  这里采用这种方式赋值会产生死循环
end
}

mytable = setmetatable(mytable,mymetatable)


mytable[5] = 'lua'  
print(table.concat(mytable,'  '))

mytable = {'lua','java','c#','c++'}

newtable = {}
mymetatable = {
__newindex = newtable  --__newindex对应的是一个表
}

mytable = setmetatable(mytable,mymetatable)


mytable[5] = 'javascript'   --设置不存在的索引的值时会设置到__newindex对应的表中

print(mytable[5])
print(newtable[5])  --在__newindex对应的表中,索引值还是5

 

 3)操作符元方法。

mytable = {'lua','java','c#','c++'}

mymetatable = {
__add = function(tab,newtab)  --__add索引的值定义了表的加法操作,这里将第二个相加的表的所有键值对拼接到第一个表的最后
    for k,v in pairs(newtab) do
        table.insert(tab,v)
    end

    return tab
end
}

mytable = setmetatable(mytable,mymetatable)

newtable = {'python','php'}

print(table.concat(mytable+newtable,' '))

 

除了__add外,对应其他运算的元方法有:__sub(减法)__mul(乘法)__div(除法)__mod(求模)__pow(乘方)__unm(取负)__concat(连接)__eq(是否相等)__lt(小于)__le(小于等于)

 4)__call元方法

将表当作函数调用时调用__call对应的函数。

mytable = {'lua','java','c#','c++'}

mymetatable = {
__call = function(tab,arg)
    print(arg)
end
}

mytable = setmetatable(mytable,mymetatable)

mytable('我是大帅比')

 

 5)__tostring元方法

将表当作字符串使用(如print(table))时定义表对应的字符串。

mytable = {'lua','java','c#','c++'}

mymetatable = {
__tostring = function(tab)
    str = ''
    for k,v in pairs(tab) do
        str = str..k..' '..v..','
    end
    return str
end
}

mytable = setmetatable(mytable,mymetatable)

print(mytable)

 

 3.协程

定义和启动协程。

方式一:

--定义协同函数
co = coroutine.create(
    function (a,b)  --必须是匿名函数
        print(a+b)
    end
)

--运行协同函数
coroutine.resume(co,20,40)

 

 方式二:

--定义协同函数
co = coroutine.wrap(
    function (a,b)  --必须是匿名函数
        print(a+b)
    end
)

--运行协同函数
co(20,40)

 

 协程的挂起和继续运行。

--定义协同函数
co = coroutine.create(
    function (a,b)
        print(a+b)
        coroutine.yield()  --挂起协同函数
        print(a-b)
    end
)

--运行协同函数
coroutine.resume(co,20,40)

--这句代码的位置在运行协同函数的代码后,在重启协同函数的代码前,因此挂起协同函数后会运行这段代码
print("I'm here")

--继续运行协同函数
coroutine.resume(co)

 

 协同程序的返回值。

co = coroutine.create(
    function (a,b)
        return a+b,a-b
    end
)

--协同函数默认有一个boolean类型的返回值表示是否启动成功,自己定义的其他返回值作为第二个、第三个......等返回值
res1,res2,res3 = coroutine.resume(co,20,40)

print(res1,res2,res3)

co = coroutine.create(
    function (a,b)
        print('........................')
        coroutine.yield(a+b,a-b)
        print('........................')
        return a*b,a/b
    end
)

--当协同函数中间被暂停时,可以分阶段返回不同的返回值,使当前阶段暂停的yield函数括号中的参数作为当前阶段的返回值
res1,res2,res3 = coroutine.resume(co,20,40)

print(res1,res2,res3)

--最后一个运行阶段的返回值为return返回的内容
res4,res5,res6 = coroutine.resume(co)

print(res4,res5,res6)

 

 协程的状态(3种)。

co = coroutine.create(
    function (a,b)
        print(coroutine.status(co))  --running运行
        print('........................')
        coroutine.yield()
        print('........................')
        print(coroutine.status(co))  --running运行
    end
)

print(coroutine.status(co))  --suspended暂停
coroutine.resume(co,20,40)
print(coroutine.status(co))  --suspended暂停
coroutine.resume(co)
print(coroutine.status(co))  --dead死亡

 

 获取正在运行的协程。

co = coroutine.create(
    function (a,b)
        print(coroutine.running())  --获取正在运行的协程
    end
)

coroutine.resume(co,20,40)

 

 4.文件I/O

文件的简单读取和写入。

f = io.open('iotest.txt','r')  --打开文件
io.input(f)  --创建输入流
print(io.read())  --read函数读取一行
print(io.read())
print(io.read())
print(io.read())
io.close()  --关闭流

 open函数的第一个参数是文件的相对地址和名称,第二个参数是可选参数,对应打开方式。打开方式有:r(只读,文件必须存在)、w(只写,写入的文件原有数据会被清空,文件不存在会自动创建文件)、a(以附加的方式打开只写文件。若文件不存在,则会建立该文件,如果文件存在,写入的数据会被加到文件尾,即文件原先的内容会被保留)、r+(以可读写方式打开文件,该文件必须存在)、w+(打开可读写文件,若文件存在则文件长度清为零,即该文件内容会消失。若文件不存在则建立该文件)、a+(与a类似,但此文件可读可写)、b(二进制模式,如果文件是二进制文件,可以加上b)

f = io.open('iotest.txt','a')  --打开文件,a为追加的形式只写,w为清空后只写
io.output(f)  --创建输出流
print(io.write(''))  --write函数写入内容,返回值代表是否写入成功
io.close()  --关闭流

 

 read函数的参数。参数有:"*n"(读取一个数字并返回)、"*a"(从当前位置读取整个文件)、"*l"(默认参数,读取下一行)、number(返回指定个数的字符串)。

f = io.open('iotest.txt','r')
io.input(f)
print(io.read("*l"))  --读取一行
print(io.read("*n"))  --读取一个数字
print(io.read(10))  --读取10个字符
print(io.read("*a"))  --读取剩下的所有内容
io.close()

 

 完全模式。完全模式下,可以同时处理多个文件。

f = io.open('iotest.txt','r')

--使用f:read代替io.read
print(f:read())

file.close()

 

 5.lua实现面向对象编程

lua中并没有直接实现面向对象编程,但是可以使用表间接实现面向对象。

--定义一个人的对象
person = {name='movin',age=18}

person.eat = function ()
    print(person.name..'在吃饭')
end

person.eat()

 

 优化面向对象的实现。

--定义一个人的对象
person = {name='movin',age=18}

--将对象自身作为变量传递,否则这里对象的名称不能修改
person.eat = function (self)
    print(self.name..'在吃饭')
end

person.eat(person)

--定义一个人的对象
person = {name='movin',age=18}

--使用冒号定义和调用,不用传递self参数,其中self就指代调用者
function person:eat()
    print(self.name..'在吃饭')
end

person:eat()

 

 根据模板创建新对象。

Person = {name='movin',age=18}

function Person:eat()
    print(self.name..'在吃饭')
end

--创建新的对象的new方法
function Person:new()
    local t = {}
    --使用元表的__index元方法指向Person对象
    setmetatable(t,{__index=self})
    return t
end

person1 = Person:new()
person2 = Person:new()

print(person1.name)
person2:eat()

--修改对象中的属性值相当于在对象中设置了新值,再查找这个索引对应的值时就不会在Person中查找,相当于实现了修改属性和重写方法的效果
person1.name = 'ww'

print(person1.name)

 

 __index元方法相当于实现了继承,元表相当于父表。当子表中没有某个属性或方法时,从父表中查找;当子表中重新赋值了某些属性或重写了某些方法时,就直接从子表中调用。

 

posted @ 2021-01-30 12:40  movin2333  阅读(143)  评论(0编辑  收藏  举报