Lua 语言学习

　　详细讲解见菜鸟教程 Lua。

一、数据类型

 -- 直接输出
 print("hello")

 -- 全局变量
 b =
 print(b)

 -- nil(空）
 print(type(a))
 -- 对于全局变量和table，nil 还有清空的作用

 -- number(数字）
 -- Lua 默认只有一种number类型 -- double(双精度)

 -- string(字符串)
 -- 字符串由一对双引号或单引号来表示
 string1 = "this is string1"
 string2 = 'this is string2'
 -- 在尝试对一个数字字符串进行算术操作时，Lua会尝试将数字字符串转换成数字
 print("" + )
 -- 字符串连接 ..
 print( .. )
 -- 字符串长度 #
 print(#string1)

 -- table(表)
 a = {}
 -- 数组的索引可以为数字或者字符串
 a["key"] = "value"
 key =
 a[key] =
 -- 遍历
 for k,v in pairs(a) do
     print(k .. ":" .. v)
 end
 -- Lua里表的初始索引一般以 1 开始，而不是 0
 -- table 长度不固定，会自动增加

 -- function(函数)
 -- 函数名字f,包含一个参数 n
 -- 主要实现阶乘的计算
 function f(n)
     if n== then
         return
     else
         return n * f(n-)
     end
 end
 -- 调用函数
 print(f())
 -- 函数可以存储在一个变量中
 f1 = f
 print(f1())

 -- 匿名函数参数传递
 -- 函数名 f1，有两个参数，其中第二个参数为一个函数
 function f1(tab, f2)
     for k, v in pairs(tab) do
         -- 输出函数返回的值
         print(f2(k, v))
     end
 end

 -- 新建表
 tab = {"a", "b", "c"}
 -- 调用函数，匿名函数作为参数传入
 -- 注意key是从1开始的
 f1(tab,
     function(key, val) -- 匿名函数
         return key .. " = " .. val
     end
 )

 -- 变量
 a =           -- 全局变量
 local b =  -- 局部变量
 -- Lua可以对多个变量同时赋值
 x,y = ,
 print(x .. "," .. y)
 -- 交换x,y的值
 x,y = y,x
 print(x .. "," .. y)
 -- 多值赋值也可用来接收函数返回的多个变量
 function f()
     return ,
 end
 x,y = f()
 print(x .. "," .. y)

二、循环

 -- while 语句
 a =
 -- 从10输出到20
 while(a < )
 do
     print("a = " .. a)
     a = a +
 end

 -- for 语句
 -- 数值for循环
 -- 从10变化到1，每次步长为-1
 for i=, , - do
     print("i = " .. i)
 end
 -- 泛型for循环
 days = {"Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"}
 -- i为数组索引值，v是对应索引的数组元素值，ipairs为迭代器
 for i,v in ipairs(days) do
     print(v)
 end

 -- repeat...until 语句
 -- 循环直到a>15
 a =
 repeat
     print(a)
     a = a +
 until(a > )

 -- break 语句
 for a = ,,- do
     print(a)
     if(a < )
     then
         break    -- 当a<5，跳出循环
     end
 end

三、流程控制

 -- if...elseif..else 语句
 a =
 if(a == )
 then    -- a=10
     print("a 的值为 10")
 elseif(a == )
 then    -- a=20
     print("a 的值为 20")
 else    -- 没有匹配。注意不需要then
     print("没有匹配的值")
 end

 -- if嵌套语句
 a =
 b =
 if(a == )
 then    -- a=100
     if(b == )
     then    -- a=100且b=200
         print("a = " .. a .. " b = " .. b)
     end
 end

四、函数

 -- 多返回值
 -- 寻找最大值和最大值所在的位置
 function maximum(a)
     local mi =         -- 最大值位置
     local m = a[mi]        -- 最大值
     for k,v in ipairs(a) do
         if(v > m) then    -- 更大
             m = v
             mi = k
         end
     end
     return m, mi        -- 输出最大值及其索引
 end

 -- 输出最大值及其索引
 print(maximum({, , , , , }))

 -- 可变参数
 -- 求不确定参数个数的平均值
 function averge(...)
     result =
     -- 可变参数可以赋值给变量
     local arg = {...}
     for k,v in ipairs(arg) do
         result = result + v
     end
     -- #可以获取...长度
     print("总共传入 " .. #arg .. " 个数")
     -- 返回平均值
     return result/#arg
 end

 -- 输出平均值
 print("平均值为 " .. averge(, , , , , ))

五、运算符

 -- 算术运算符
 -- + - * / 加减乘除
 -- % 取余 ^ 乘幂 - 负号

 -- 关系运算符
 -- == 等于 ~= 不等于
 -- > < >= <= 大于 小于 大于等于 小于等于

 -- 逻辑运算符
 -- and 逻辑与 or 逻辑或 not 非

 -- 其他运算符
 -- .. 连接两个字符串
 -- # 返回字符串或表的长度

六、字符串

 -- 字符串大小写转换
 s = "Lua"
 print(string.upper(s))    -- 大写
 print(string.lower(s))    -- 小写

 -- 字符串查找与反转
 s = "Lua Tutorial"
 -- 查找字符串，若查找成功，返回头和尾，否则返回nil
 print(string.find(s, "Tutorial"))
 -- 字符串反转
 reverses = string.reverse(s)
 print(reverses)

 -- 字符串格式化
 date =
 month =
 year =
 -- 日期格式化
 print(string.format("%02d/%02d/%04d", date, month, year))
 -- 十进制格式化
 print(string.format("%.3f", /))

 -- 字符与ASCII码的转换
 -- 转换第一个字符
 print(string.byte("Lua"))
 -- 转换第三个字符
 print(string.byte("Lua", ))
 -- 转换倒数第一个字符
 print(string.byte("Lua", -))
 -- ASCII转字符
 print(string.char())

 -- 字符串长度
 s = "Lua Tutorial"
 print(string.len(s))

 -- 模式匹配
 -- 搜索 dd/mm/yy 格式的日期
 s = "Deadline is 30/05/1999, firm"
 date = "%d%d/%d%d/%d%d%d%d"
 print(string.sub(s, string.find(s, date)))
 -- 去除空格
 -- gsub 返回的第二个参数为替代字符的个数
 print(string.gsub(s, " ", ""))

七、数组

 -- 一维数组
 array = {}
 -- 初始化数组
 -- 注意数组下标默认从1开始，但是也可以自定义下标
 for i=-,  do
     array[i] = i*
 end
 -- 遍历数组
 for i=-,  do
     print(array[i])
 end

 -- 二维数组
 array = {}
 maxRow =
 maxColumn =
 -- 初始化3行3列数组
 for row=,maxRow do
     array[row] = {}
     for col=,maxColumn do
         array[row][col] = row * col
     end
 end
 -- 遍历数组
 for row=,maxRow do
     for col=,maxColumn do
         print(array[row][col])
     end
 end

八、迭代器

 -- pairs和ipairs区别
 -- pairs 可以遍历集合的所有元素，即可以遍历集合中的所有key
 -- ipairs 按照索引升序遍历，索引中断停止遍历
 tab = {
 [] = "a",
 [] = "b",
 [] = "c"    -- 注意索引值没有3
 }

 -- pairs
 -- 输出 a,b,c
 for k, v in pairs(tab) do
     print(v)
 end

 -- ipairs
 -- 只输出 a,b
 for k, v in ipairs(tab) do
     print(v)
 end

九、表(table)

 -- 初始化表
 mytable = {}
 -- 指定值
 mytable[] = "Lua"
 -- 移除引用
 -- 之后Lua垃圾回收会释放内存
 mytable = nil

 -- table 连接
 fruits = {"banana","orange","apple"}
 -- 直接连接
 print(table.concat(fruits))
 -- 指定连接字符
 print(table.concat(fruits, ","))
 -- 指定要连接的字符串
 print(table.concat(fruits, ", ", , ))

 -- 插入和删除
 fruits = {"banana","orange","apple"}
 -- 在末尾插入
 table.insert(fruits, "watermelon")
 print(table.getn(fruits))
 -- 在指定位置插入
 table.insert(fruits, , "pear")
 print(fruits[])
 print(table.getn(fruits))
 -- 删除指定位置的元素
 print(table.remove(fruits, ))
 print(table.getn(fruits))

 -- 排序
 fruits = {"banana","orange","apple","grapes"}
 print("排序前")
 for k,v in ipairs(fruits) do
     print(k,v)
 end

 -- 排序，默认为升序
 table.sort(fruits)
 print("排序后")
 for k,v in ipairs(fruits) do
     print(k,v)
 end

 -- 注意使用 # 和 table.getn 其都会在索引中断的地方停止计数，
 -- 而导致无法正确取得 table 的长度
 -- 可以用以下的方法
 function table_leng(t)
   local leng=
   for k, v in pairs(t) do
     leng=leng+
   end
   return leng
 end

十、模块

　　模块代码如下：

 -- module.lua
 -- 定义一个名为 module 的模块
 module = {}

 -- 定义一个常量
 module.constant = "这是一个常量"

 -- 定义一个函数
 function module.func1()
     io.write("这是一个公有函数！\n")
 end

 local function func2()
     print("这是一个私有函数！")
 end

 function module.func3()
     func2()
 end

 return module

　　调用模块代码如下：

 -- 加载模块
 -- 返回一个由模块常量和函数组成的table
 local m = require("module")

 print(m.constant)    -- 访问模块常量
 m.func3()            -- 访问模块函数

十一、协同程序

 -- 协同程序
 -- 创建协程，resume时唤醒函数
 co = coroutine.create(
     function(i)
         print(i);
     end
 )

 -- 重启协程，并传入参数
 coroutine.resume(co, )   --
 -- 输出协程状态
 print(coroutine.status(co))  -- dead

 print("----------")

 -- 作用与create一样
 co = coroutine.wrap(
     function(i)
         print(i);
     end
 )

 co()

 print("----------")

 -- create时就是在新线程中注册一个事件
 co2 = coroutine.create(
     function()
         for i=, do
             print(i)
             if i ==  then
                 print(coroutine.status(co2))  --running
                 print(coroutine.running()) --thread:XXXXXX
             end
             -- 遇到yield协程会暂时挂起
             coroutine.yield()
         end
     end
 )

 -- resume会重新激活事件
 coroutine.resume(co2) --
 coroutine.resume(co2) --
 coroutine.resume(co2) --

 print(coroutine.status(co2))   -- suspended
 print(coroutine.running())

 print("----------")

十二、文件 I/O

 -- 文件 I/O
 -- 打开文件
 file = io.open("协同程序.lua", "r")

 -- 输出文件第一行
 print(file:read())

 -- 获取倒数第10个字符位置
 file:seek("end",-)
 -- 读取后10个字符
 print(file:read("*a"))

 -- 关闭文件
 file:close()

 -- 以附加的方式打开只写文件
 file = io.open("协同程序.lua", "a")

 -- 在文件末尾写入字符串
 file:write("-- test io")

十三、面向对象

 -- 面向对象
 -- Shape 类，包含一个属性 area
 Shape = {area = }

 -- 构造方法
 function Shape:new (o, side)
     o = o or {}
     setmetatable(o, self)
     self.__index = self
     side = side or
     self.area = side*side
     return o
 end

 -- 输出形状面积
 function Shape:printArea()
     print("面积为：", self.area)
 end

 -- 创建对象
 myShape = Shape:new(nil, )
 -- 输出面积
 myShape:printArea()        --

 -- 继承
 -- 长方形
 Rectangle = Shape:new()
 -- 派生类构造方法
 function Rectangle : new(o, length, breadth)
     o = o or Shape:new(o)
     setmetatable(o, self)
     self.__index = self
     self.area = length * breadth
     return o
 end

 -- 函数重写
 function Rectangle : printArea()
     print("长方形面积为：", self.area)
 end

 -- 创建一个长方形对象
 myRectangle = Rectangle:new(nil, , )
 -- 输出长方形面积
 myRectangle:printArea()    --