高效开发：lua语言交互式编程和脚本式编程

Posted 2021-09-09 爱奇志

文章目录

• • • lua -i 进入交互式编程
    • lua脚本式编程

lua -i 进入交互式编程

交互式编程
Lua 提供了交互式编程模式。我们可以在命令行中输入程序并立即查看效果。
Lua 交互式编程模式可以通过命令 lua -i 或 lua 来启用：

$ lua 
$ Lua 5.3.0  Copyright (C) 1994-2015 Lua.org, PUC-Rio
> 

在命令行中，输入以下

print(“Hello World！”)

Hello World！

如上为 lua 进入交互式编程，向cmd命令行 或者 java 的控制台console一样。

lua 所有类型

lua语言和java一样，大括号表示对象，中括号表示数组，小括号表示函数，nil 对应 java中null

小坑：字符串一定要用双引号

字符串一定要使用双引号，上面对象属性赋值为字符串的时候，没有使用双引号，就会把 wangwu 识别为数字，但是却无法转换为数字，所以取出的时候，就是 nil

定义方法并调用

>> 表示在函数的定义里面

lua脚本式编程

新建一个course.lua文件

定义对象和定义对象里面的方法

新建另一个student.lua文件

student.lua 引入 course.lua

执行 输出java

交互式学习lua入门体验
1.运行lua文件的方法：

$ lua HelloWorld.lua

-------------------------------------------------------基础语法  --------------------------------------------------------
-- 注释
-- 这就是单行注释

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


--删除变量
n = 10
print(n)
n = bil --删除变量
print(n)

--------------------------------------------------------数据类型--------------------------------------------------------------
--Lua是动态类型语言，变量不需要类型定义，只需要为变量赋值即可。
print("数据类型: nil")
print(type(nil))

print("\\n")

print("数据类型: boolean")
print(type(true))
print(type(false))

print("\\n")

print("数据类型: number")
-- Lua 默认只有一种 number 类型 -- double（双精度）类型
print(type(2.3))

print("\\n")

print("数据类型: string")
--字符串由一对双引号或单引号来表示。
print(type("hello world in lua"))
--也可以用 2 个方括号 "[[]]" 来表示"一块"字符串
str = [[ 
hello
in 
world !
]]
print(str)

--计算字符串长度
print("the length of str is "..#str) --使用# 来计算长度



print("\\n")

print("数据类型: table")  --important
-- 不同于其他语言的数组把 0 作为数组的初始索引，在 Lua 里表的默认初始索引一般以 1 开始。
tab = {key1 ="value1",key2="value2"}

for k,v in pairs(tab) do
    print(k .. "-".. v)  -- 连接符 ..
end


print("\\n")
tabt = {} --空表
tabt["key3"] = "value3"

key4 = "key4"
tabt[key4] = "vlaue4"

for k,v in pairs(tabt) do
    print(k.." = "..v)
end

-- 索引
--对 table 的索引使用方括号 []。Lua 也提供了 . 操作。
print("索引 "..tabt[key4])

print("索引 "..tabt.key3)

print("\\n")

print("数据类型: function")
print(type(print))


function demo()
    return "hello"
end

print(demo())


--匿名函数

function anonymous(tab,fn)
    for k,v in pairs(tab) do
        print(fn(k,v))
    end
end

anonymous(tabt,function(k,v)
    return k .."==".. v
end)


--数组
print("\\n")
arr = {1,2,3,"h"}
for i = 1,4 do
    print("数组 "..i.." =="..arr[i])
end

print("\\n多维数组")
arrm = {}
arrm[1] = {1,2,3}
arrm[2] = {4,5,6}

for i= 1,2 do
    for j = 1,3 do
        print("多维数组 "..arrm[i][j]) --notice
    end
end
--------------------------------------------------------Lua 变量--------------------------------------------------------------
print("\\n")
print("Lua 变量")

--[[
Lua 变量有三种类型：全局变量、局部变量、表中的域。
Lua 中的变量全是全局变量，那怕是语句块或是函数里，除非用 local 显示声明为局部变量。
局部变量的作用域为从声明位置开始到所在语句块结束。
变量的默认值均为 nil。


应该尽可能的使用局部变量，有两个好处：
1. 避免命名冲突。
2. 访问局部变量的速度比全局变量更快。

--]]

a = 12
local b = 1

function area()
    b = 3
    local a = 3
    local c = 26
end

print("a is "..a)  --12
print("b is "..b)  -- 1  notice: here b is 1
print("c is "..type(c)) --nil

-- 多个变量同时赋值
-- 注意：如果要对多个变量赋值必须依次对每个变量赋值。
a,b = "hello","world"
print(a..b)



--------------------------------------------------------Lua 循环--------------------------------------------------------------
print("\\n")
print("while循环")
i = 10
while(i > 0)
do
    i = i - 1
    print(i)
end

print("\\n")

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

print("\\n")
print("for循环")
--[[
Lua 编程语言中 for语句有两大类：：
数值for循环
泛型for循环
--------------
Lua 编程语言中数值for循环语法格式:
for的三个表达式在循环开始前一次性求值，以后不再进行求值。
for var=exp1,exp2,exp3 do  
    <执行体>  
end  
var从exp1变化到exp2，每次变化以exp3为步长递增var，并执行一次"执行体"。
exp3是可选的，如果不指定，默认为1。
--]]

for i=0,10 do
    print(i)
end


function f(x)
    return x*5
end

for i=1,f(5),2 do
    print(i)
end

-- 泛型for循环
print("泛型for循环")
--泛型for循环通过一个迭代器函数来遍历所有值，类似java中的foreach语句。
--i是数组索引值，v是对应索引的数组元素值。ipairs是Lua提供的一个迭代器函数，用来迭代数组。
arr = {1,23,4,55,1,3234,4}
for i,v in ipairs(arr) do
    print("泛型for循环:"..i..' '..v)

end


print("\\n")
print("repeat until")

i = 10
repeat
    print(i)
    i = i -1
until(i < 0)


--------------------------------------------------------Lua 流程控制 --------------------------------------------------------
print("\\n")
if(true) then   -- 注意这里是then
    print("if contro")
end

a = 100

-- if else
if(a >100) then
    print(a+100)
else
    print(a)
end

-- if elseif else

if(a<200) then
    print("a<200")
elseif(a <100) then
    print("a<100")
else 
    print(a)
end

--------------------------------------------------------Lua 函数---------------------------------------------------------------------

--Lua函数可以返回多个结果值
-- return a,b

--可变参数
--[[
Lua函数可以接受可变数目的参数，和C语言类似在函数参数列表中使用三点（...) 表示函数有可变的参数。
Lua将函数的参数放在一个叫arg的表中，#arg 表示传入参数的个数。
--]]


function cot(...)
    return "参数个数是 "..#arg
end 
print(cot(1,2,3,4,5))



--------------------------------------------------------Lua 运算符---------------------------------------------------------------------

-- http://www.runoob.com/lua/lua-miscellaneous-operator.html


a = 21
b = 10
c = a + b
print("Line 1 - c 的值为 ", c )
c = a - b
print("Line 2 - c 的值为 ", c )
c = a * b
print("Line 3 - c 的值为 ", c )
c = a / b
print("Line 4 - c 的值为 ", c )
c = a % b
print("Line 5 - c 的值为 ", c )
c = a^2
print("Line 6 - c 的值为 ", c )
c = -a
print("Line 7 - c 的值为 ", c )


a = true
b = false
if(a or b) then
    print(a or b)
end



--------------------------------------------------------Lua 字符串---------------------------------------------------------------------


str = "hello in world! Lua loved!"
print(string.upper(str))
print(string.lower(str))
print(string.reverse(str))


--------------------------------------------------------Lua table---------------------------------------------------------------------
--[[
table 是 Lua 的一种数据结构用来帮助我们创建不同的数据类型，如：数字、字典等。
Lua table 使用关联型数组，你可以用任意类型的值来作数组的索引，但这个值不能是 nil。
Lua table 是不固定大小的，你可以根据自己需要进行扩容。
Lua也是通过table来解决模块（module）、包（package）和对象（Object）的。 例如string.format表示使用"format"来索引table string。

--]]
print("\\n")
print("Table 连接")
fruits = {1,2,3,4}
print("连接后",table.concat(fruits,'-'))


print("\\n")
print("Table insert and remove")
table.insert(fruits,"hh")
print(fruits[5])

table.remove(fruits)  --返回table数组部分位于pos位置的元素. 其后的元素会被前移. pos参数可选, 默认为table长度, 即从最后一个元素删起


print("Table 排序")
table.sort(fruits)
for k,v in pairs(fruits) do
    print(k.."--"..v)
end



--------------------------------------------------------Lua 协同程序---------------------------------------------------------------------
-- Notice::协同程序在在线ide上，使用coroutine.resume()不能打印出具体值来，所以建议在本地练习！！


print("\\n------------协调程序-----------------\\n")
--[[
Lua 协同程序(coroutine)与线程比较类似：拥有独立的堆栈，独立的局部变量，独立的指令指针，同时又与其它协同程序共享全局变量和其它大部分东西。
协同是非常强大的功能，但是用起来也很复杂。
线程和协同程序区别
线程与协同程序的主要区别在于，一个具有多个线程的程序可以同时运行几个线程，而协同程序却需要彼此协作的运行。
在任一指定时刻只有一个协同程序在运行，并且这个正在运行的协同程序只有在明确的被要求挂起的时候才会被挂起。
协同程序有点类似同步的多线程，在等待同一个线程锁的几个线程有点类似协同。


coroutine.create()  创建coroutine，返回coroutine， 参数是一个函数，当和resume配合使用的时候就唤醒函数调用

coroutine.resume()  重启coroutine，和create配合使用

coroutine.yield()   挂起coroutine，将coroutine设置为挂起状态，这个和resume配合使用能有很多有用的效果

coroutine.status()  查看coroutine的状态
注：coroutine的状态有三种：dead，suspend，running，具体什么时候有这样的状态请参考下面的程序

coroutine.wrap（）    创建coroutine，返回一个函数，一旦你调用这个函数，就进入coroutine，和create功能重复

coroutine.running() 返回正在跑的coroutine，一个coroutine就是一个线程，当使用running的时候，就是返回一个corouting的线程号

--]]


--[[
协同有三个状态：挂起态（suspended）、运行态（running）、停止态（dead）。当我们创建协同程序成功时，其为挂起态，即此时协同程序并未运行。我们可用status函数检查协同的状态：
--]]

co = coroutine.create(
    function()
        print("Hello coroutine!")
end)

print(coroutine.status(co)) -- suspended

print("\\n----------\\n")
co = coroutine.create(function (a,b,c)
    print("co", a,b,c)
end)
print(coroutine.resume(co, 1, 2, 3))




-- 函数coroutine.resume使协同程序由挂起状态变为运行态：
coroutine.resume(co)

--本例中，协同程序打印出"hi"后，任务完成，便进入终止态：
print(coroutine.status(co))     --> dead

print("\\n----------\\n")
--协同真正的强大之处在于yield,可以将正在运行的代码挂起
co = coroutine.create(function ()
    for i=1,10 do
       print("co", i)
       coroutine.yield()
    end
end)

coroutine.resume(co)
print(coroutine.status(co))
coroutine.resume(co)

--------------------------------------------------------Lua 模块---------------------------------------------------------------------
--[[
模块类似于一个封装库
可以把一些公用的代码放在一个文件里，以 API 接口的形式在其他地方调用，有利于代码的重用和降低代码耦合度。

Lua 的模块是由变量、函数等已知元素组成的 table，因此创建一个模块很简单，就是创建一个 table，然后把需要导出的常量、函数放入其中，最后返回这个 table 就行。
--]]



module = {}

module.constant = "Define constant"

function module.fn1()
    print("定义一个公有函数！")
end

local function fn2()
    print("私有函数")
end

return module

---加载模块
--[[

Lua提供了一个名为require的函数用来加载模块。要加载一个模块，只需要简单地调用就可以了。例如：
require("<模块名>")
或者
require "<模块名>"
-- ]]