Lua 语言学习

　　详细讲解见菜鸟教程 Lua。

一、数据类型

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


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



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


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


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


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

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

-- 匿名函数参数传递
-- 函数名 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 = 5          -- 全局变量
local b = 10 -- 局部变量
-- Lua可以对多个变量同时赋值
x,y = 11,12
print(x .. "," .. y)
-- 交换x,y的值
x,y = y,x
print(x .. "," .. y)
-- 多值赋值也可用来接收函数返回的多个变量
function f()
    return 11, 12
end
x,y = f()
print(x .. "," .. y)

二、循环

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


-- for 语句
-- 数值for循环
-- 从10变化到1，每次步长为-1
for i=10, 1, -1 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 = 10
repeat
    print(a)
    a = a + 1
until(a > 15)


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

三、流程控制

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


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

四、函数

-- 多返回值
-- 寻找最大值和最大值所在的位置
function maximum(a)
    local mi = 1        -- 最大值位置
    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({8, 10, 13, 6, 15, 9}))

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

-- 输出平均值
print("平均值为 " .. averge(10, 5, 3, 4, 5, 6))

五、运算符

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


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


-- 逻辑运算符
-- 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 = 2
month = 1
year = 2014
-- 日期格式化
print(string.format("%02d/%02d/%04d", date, month, year))
-- 十进制格式化
print(string.format("%.3f", 1/3))


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


-- 字符串长度
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=-2, 2 do
    array[i] = i*2
end
-- 遍历数组
for i=-2, 2 do
    print(array[i])
end

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

八、迭代器

-- pairs和ipairs区别
-- pairs 可以遍历集合的所有元素，即可以遍历集合中的所有key
-- ipairs 按照索引升序遍历，索引中断停止遍历
tab = {
[1] = "a",
[2] = "b",
[4] = "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[1] = "Lua"
-- 移除引用
-- 之后Lua垃圾回收会释放内存
mytable = nil


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


-- 插入和删除
fruits = {"banana","orange","apple"}
-- 在末尾插入
table.insert(fruits, "watermelon")
print(table.getn(fruits))
-- 在指定位置插入
table.insert(fruits, 2, "pear")
print(fruits[2])
print(table.getn(fruits))
-- 删除指定位置的元素
print(table.remove(fruits, 4))
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=0
  for k, v in pairs(t) do
    leng=leng+1
  end
  return leng
end

十、模块

　　模块代码如下：

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

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

-- 定义一个函数
function module.func1()
    io.write("这是一个公有函数！
")
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, 1)   -- 1
-- 输出协程状态
print(coroutine.status(co))  -- dead

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

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

co(1)

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

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

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

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)
-- 读取后10个字符
print(file:read("*a"))

-- 关闭文件
file:close()

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

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

十三、面向对象

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

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

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

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


-- 继承
-- 长方形
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, 10, 20)
-- 输出长方形面积
myRectangle:printArea()    -- 200