w3cschool-Lua 教程

https://www.w3cschool.cn/lua/

Lua 学习笔记之一(初阶话题)

1.八种基本类型: 如下表

基本类型	描述	备注
数值(number)	内部以double表示
字符串(string)	总是以零结尾,但可以包含任意字符(包括零),因此并不等价于C字符串, 而是其超集
布尔(boolean)	只有“true”或者“false”两个值。
函数(function)	Lua的关键概念之一。不简单等同于C的函数或函数指针。
表(table)	异构的Hash表。Lua的关键概念之一。
userdata	用户(非脚本用户)定义的C数据结构。脚本用户只能使用它,不能定义。
线程(thread)	Lua协作线程(coroutine),与一般操作系统的抢占式线程不一样。
nil	代表什么也没有,可以与C的NULL作类比,但它不是空指针。

2.函数

2.1 实例代码

function foo(a,b,c,...)

local sum = a+b

return sum,c  --函数可以返回多个值

end

r1,r2 = foo(1,"123","hello")--平行赋值

print(r1,r2);

输出结果:

124 hello

2.2 函数基本使用方法

• 函数定义:

用关键字function定义函数,以关键字end结束

• 局部变量:

用关键字local定义。如果没有用local定义,即使在函数内部定义的变量也是全局变量!

• 函数可以返回多个值:

return a, b, c, ...

• 平行赋值:

a, b = c, d

• 全局变量:

前面的代码定义了三个全局变量:foo、r1和r2

3.表

3.1 实现代码

local a = {}

local b = {x = 1,["hello,"] = "world!"}

a["astring"] = "ni,hao!"

a[1] = 100

a["a table"] = b

for k,v in  pairs(a) do

print(k,"=>",v);

end

输出结果:

1=>100

astring=>ni,hao!

a table=>table: 0xfd59570

3.2 表使用方法

• 定义表(Table)的方式

a = {}, b = {...}

• 访问表的成员

通过“.”或者“[]”运算符来访问表的成员。

注意:表达式a.b等价于a[“b”],但不等价于a[b]

• 表项的键和值

  任何类型的变量,除了nil,都可以做为表项的键。从简单的数值、字符串到复杂的函数、表等等都可以;同样,任何类型的变量,除了nil,都可以作为表项的值。给一个表项的值赋nil意味着从表中删除这一项,比如令a.b= nil,则把表a中键为“b”的项删除。如果访问一个不存在的表项,其值也是nil,比如有c = a.b,但表a中没有键为“b”的项,则c等于nil。

4.一种简单的对象实现方式

4.1 实现代码

function create(name,id)

local obj = {name = name,id = id}

function obj:SetName(name)

self.name = name

end

function obj:GetName()

return self.name

end

function obj:SetId(id)

self.id = id

end

function obj:GetId()

return self.id

end

return obj

end

local myCreate = create("sam",001)

for k,v in pairs(myCreate) do

print(k,"=>",v)

end

print("myCreate's name:",myCreate:GetName(),"myCreate's id:",myCreate.GetId(myCreate))

myCreate:SetId(100)

myCreate:SetName("Hello Kity")

print("myCreate's name:",myCreate:GetName(),"myCreate's id:",myCreate:GetId())

SetName=>function: 0x85efc50

GetId=>function: 0x85efc10

id=>1

SetId=>function: 0x85efd00

GetName=>function: 0x85efce0

name=>sam

myCreate's name:sammyCreate's id:1

myCreate's name:Hello KitymyCreate's id:100

4.2对象实现描述

• 对象工厂模式

如前面代码的create函数

• 用表来表示对象

把对象的数据和方法都放在一张表内,虽然没有隐藏私有成员,但对于简单脚本来说完全可以接受。

• 成员方法的定义

  function obj:method(a1, a2, ...) ... end 等价于function obj.method(self, a1, a2, ...) ... end 等价于obj.method = function (self, a1, a2, ...) ... end

• 成员方法的调用

obj:method(a1, a2, ...) 等价于obj.method(obj, a1, a2, ...)

Lua 学习笔记之二(进阶话题)

1.函数闭包

1.1 实例代码

    function createCountdownTimer(second)
        local ms = second * 1000  --ms为countDown的Upvalue
        local function countDown()
            ms = ms -1
            return ms
        end

        return countDown
    end

    local timer1 = createCountdownTimer(1) 

    for i = 1, 3 do
        print(timer1())
    end

输出结果:

999

998

997

1.2 关于函数闭包描述

• Upvalue

  一个函数所使用的定义在它的函数体之外的局部变量(external local variable)称为这个函数的upvalue。 在前面的代码中,函数countDown使用的定义在函数createCountdownTimer 中的局部变量ms就是countDown的upvalue,但ms对createCountdownTimer而 言只是一个局部变量,不是upvalue。 Upvalue是Lua不同于C/C++的特有属性,需要结合代码仔细体会。

• 函数闭包

一个函数和它所使用的所有upvalue构成了一个函数闭包。

• Lua函数闭包与C函数的比较

Lua函数闭包使函数具有保持它自己的状态的能力,从这个意义上说,可以 与带静态局部变量的C函数相类比。但二者有显著的不同:对Lua来说,函数 是一种基本数据类型——代表一种(可执行)对象,可以有自己的状态;但 是对带静态局部变量的C函数来说,它并不是C的一种数据类型,更不会产生 什么对象实例,它只是一个静态地址的符号名称。

2. 基于对象的实现方式

2.2  实例代码

    local function create(name ,id )
        local data = {name = name ,id = id}  --data为obj.SetName,obj.GetName,obj.SetId,obj.GetId的Upvalue
        local obj = {}  --把需要隐藏的成员放在一张表里,把该表作为成员函数的upvalue。

        function obj.SetName(name)
            data.name = name
        end

        function obj.GetName()
            return data.name
        end

        function obj.SetId(id)
            data.id = id
        end

        function obj.GetId()
            return data.id
        end

        return obj
    end

输出结果:

mycreate's id:1mycreate's name:Sam

mycreate's id:1mycreate's name:Lucy

2.2  有关对象实现的描述

实现方式:  把需要隐藏的成员放在一张表里,把该表作为成员函数的upvalue。

局限性:  基于对象的实现不涉及继承及多态。但另一方面,脚本编程是否需要继承和多态要视情况而定。

3.元表

3.1  实例代码(1):

    local t = {}
    local m = {a = "and",b = "Li Lei", c = "Han Meimei"}

    setmetatable(t,{__index = m})  --表{ __index=m }作为表t的元表

    for k,v in pairs(t) do  --穷举表t
        print("有值吗？")
        print(k,"=>",v)
    end

    print("-------------")
    print(t.b, t.a, t.c)

输出结果:

---

Li LeiandHan Meimei

3.2  实例代码(2):

    local function add(t1,t2)
        --‘#’运算符取表长度
        assert(#t1 == #t2)
        local length = #t1
        for i = 1,length do
            t1[i] = t1[i] + t2[i]
        end
        return t1
    end

    --setmetatable返回被设置的表
    t1 = setmetatable({1,2,3},{__add = add})
    t2 = setmetatable({10,20,30},{__add = add})

    for k,v in  pairs(t1) do
        print(k,"=>",v)
    end

    for k,v in  pairs(t2) do
        print(k,"=>",v)
    end

    print("---------两元表相加--------------")
    t1 = t1 + t2
    for i = 1 ,#t1 do
        print(t1[i])
    end

输出结果:

1=>1

2=>2

3=>3

1=>10

2=>20

3=>30

---------两元表相加--------------

11

22

33

3.3  有关元表的描述:

定义 :

元表本身只是一个普通的表,通过特定的方法(比如setmetatable)设置到某个对象上,进而影响这个对象的行为;一个对象有哪些行为受到元表影响以及这些行为按照何种方式受到影响是受Lua语言约束的。比如在前面的代码里,两个表对象的加法运算,如果没有元表的干预,就是一种错误;但是Lua规定了元表可以“重载”对象的加法运算符,因此若把定义了加法运算的元表设置到那两个表上,它们就可以做加法了。元表是Lua最关键的概念之一,内容也很丰富,请参考Lua文档了解详情。

Lua 学习笔记之三(高阶话题)

1.迭代

1.1  实例代码:

    --迭代
    local function enum(array)
        local index = 1
        return function()
            local ret = array[index]
            index = index + 1
            return ret
        end
    end

    local function foreach(array,action)
        for element in enum(array)do
            action(element)
        end
    end

    foreach({1,2,3},print)

输出结果:

1

2

3

1.2  有关迭代的描述:

• 定义

迭代是for语句的一种特殊形式,可以通过for语句驱动迭代函数对一个给定集合进行遍历。正式、完备的语法说明较复杂,请参考Lua手册。

• 实现

如前面代码所示:enum函数返回一个匿名的迭代函数,for语句每次调用该迭代函数都得到一个值(通过element变量引用),若该值为nil,则for循环结束。

2.协作线程

2.1  实例代码

    --线程
    local function producer()
        return coroutine.create(
        function(salt)
            local t = {1,2,3}
            for i = 1,#t do
                salt = coroutine.yield(t[i] + salt)
            end
        end
        )
    end

    function consumer(prod)
        local salt = 10
        while true do
            local running ,product = coroutine.resume(prod, salt)
            salt = salt*salt
            if running then
                print(product or "END!")
            else
                break
            end
        end
    end

    consumer(producer())

输出结果:

11

102

10003

END!

2.2  有关协作线程的描述:

• 创建协作线程

通过coroutine.create可以创建一个协作线程,该函数接收一个函数类型的参数作为线程的执行体,返回一个线程对象。

• 启动线程

通过coroutine.resume可以启动一个线程或者继续一个挂起的线程。该函数接收一个线程对象以及其他需要传递给该线程的参数。线程可以通过线程函数的参数或者coroutine.yield调用的返回值来获取这些参数。当线程初次执行时,resume传递的参数通过线程函数的参数传递给线程,线程从线程函数开始执行;当线程由挂起转为执行时,resume传递的参数以yield调用返回值的形式传递给线程,线程从yield调用后继续执行

• 线程放弃调度

  线程调用coroutine.yield暂停自己的执行,并把执行权返回给启动/继续它的线程;线程还可利用yield返回一些值给后者,这些值以resume调用的返回值的形式返回。

Lua 学习笔记之四(Lua中的基本函数库)

Lua中的基本函数库

表1

基本函数库	功能	参数	备注
assert(v[,mess age])	相当于C的断言	v：当表达式v为nil或false将触发错误, message：发生错误时返回的信息，默认为"assertion failed!"
collectgarbage (opt [, arg])	是垃圾收集器的通用接口，用于操作垃圾收集器	opt：操作方法标志 "Stop": 停止垃圾收集器 "Restart": 重启垃圾收集器 "Collect": 执行一次全垃圾收集循环 "Count": 返回当前Lua中使用的内存量(以KB为单位) "Step": 单步执行一个垃圾收集. 步长 "Size" 由参数arg指定　(大型的值需要多步才能完成)，如果要准确指定步长，需要多次实验以达最优效果。如果步长完成一次收集循环，将返回True "Setpause": 设置 arg/100 的值作为暂定收集的时长 "Setstepmul": 设置 arg/100 的值，作为步长的增幅(即新步长＝旧步长*arg/100)
dofile (filename)	打开并且执行一个lua块,当忽略参数filename时，将执行标准输入设备(stdin)的内容。返回所有块的返回值。当发生错误时，dofile将错误反射给调用者	注：dofile不能在保护模式下运行
error (message [, level])	终止正在执行的函数，并返回message的内容作为错误信息(error函数永远都不会返回)	通常情况下，error会附加一些错误位置的信息到message头部. Level参数指示获得错误的位置, Level=1[默认]：为调用error位置(文件+行号) Level=2：指出哪个调用error的函数的函数 Level=0:不添加错误位置信息
_G全局环境表(全局变量)	记录全局环境的变量值的表 _G._G = _G
getfenv(f)	返回函数f的当前环境表	f可以为函数或调用栈的级别，级别1[默认]为当前的函数,级别0或其它值将返回全局环境_G
getmetatable(object)	返回指定对象的元表(若object的元表.__metatable项有值，则返回object的元表.__metatable的值)，当object没有元表时将返回nil
ipairs (t)	返回三个值 迭代函数、表、0 多用于穷举表的键名和键值对 如：for i,v in ipairs(t) do   end 每次循环将索引赋级i，键值赋给v	注：本函数只能用于以数字索引访问的表如：t={"1","cash"}
load (func [, chunkname])	装载一个块中的函数，每次调用func将返回一个连接前一结的字串，在块结尾处将返回nil 当没有发生错误时，将返回一个编译完成的块作为函数,否则返回nil加上错误信息，此函数的环境为全局环境 chunkname用于错误和调试信息
loadfile ([filename])	与load类似，但装载的是文件或当没有指定filename时装载标准输入(stdin)的内容
loadstring (string [, chunkname])	与load类似，但装载的内容是一个字串 如：assert(loadstring(s))()
next (table [, index])	允许程序遍历表中的每一个字段，返回下一索引和该索引的值。	table：要遍历的表 index：要返回的索引的前一索中的号，当index为nil[]时，将返回第一个索引的值，当索引号为最后一个索引或表为空时将返回nil 注：可以用next(t)来检测表是否为空(此函数只能用于以数字索引的表与ipairs相类似)
ipairs (t)	返回三个值 next函数、表、0 多用于穷举表的键名和键值对 如：for n,v in pairs(t) do end	每次循环将索引赋级i，键值赋给v 注：本函数只能用于以键名索引访问的表如：t={id="1",name="cash"}
pcall (f, arg1, ···)	在保护模式下调用函数(即发生的错误将不会反射给调用者) 当调用函数成功能返回true,失败时将返回false加错误信息
print (···)	简单的以tostring方式格式化输出参数的内容
rawequal (v1, v2)	检测v1是否等于v2，此函数不会调用任何元表的方法
rawget (table, index)	获取表中指定索引的值，此函数不会调用任何元表的方法，成功返回相应的值，当索引不存在时返回nil	注：本函数只能用于以数字索引访问的表如：t={"1","cash"}
rawset (table, index, value)	设置表中指定索引的值，此函数不会调用任何元表的方法，此函数将返回table
select (index, ···)	当index为数字将返回所有index大于index的参数:如：select(2,"a","b") 返回 "b" 当index为"#"，则返回参数的总个数(不包括index)
setfenv (f, table)	设置函数f的环境表为table	f可以为函数或调用栈的级别，级别1[默认]为当前的函数,级别0将设置当前线程的环境表
setmetatable (table, metatable)	指定的table设置元表metatable，如果metatable为nil则取消table的元表，当metatable有__metatable字段时，将触发错误	注：只能为LUA_TTABLE表类型指定元表
tonumber (e [, base])	尝试将参数e转换为数字，当不能转换时返回nil	base(2~36)指出参数e当前使用的进制，默认为10进制，如tonumber(11,2)=3
tostirng(e)	将参数e转换为字符串，此函数将会触发元表的__tostring事件
type(v)	返回参数的类型名("nil"，"number", "string", "boolean", "table", "function", "thread", "userdata")
unpack (list [, i [, j]])	返回指定表的索引的值,i为起始索引，j为结束索引	注：本函数只能用于以数字索引访问的表,否则只会返回nil如：t={"1","cash"}
_VERSION	返回当前Lua的版本号"Lua 5.1".
xpcall (f, err)	与pcall类似，在保护模式下调用函数(即发生的错误将不会反射给调用者) 但可指定一个新的错误处理函数句柄 当调用函数成功能返回true,失败时将返回false加err返回的结果

Lua 学习笔记之五(Lua中的数学库)

Lua中的数学库

Lua5.1中数学库的所有函数如下表：

math.pi 为圆周率常量 = 3.14159265358979323846

表1

数学库	说明	例子	方法
abs	取绝对值	math.abs(-15)	15
acos	反余弦函数	math.acos(0.5)	1.04719755
asin	反正弦函数	math.asin(0.5)	0.52359877
atan2	x / y的反正切值	math.atan2(90.0, 45.0)	1.10714871
atan	反正切函数	math.atan(0.5)	0.463647609
ceil	不小于x的最大整数	math.ceil(5.8)	6
cosh	双曲线余弦函数	math.cosh(0.5)	1.276259652
cos	余弦函数	math.cos(0.5)	0.87758256
deg	弧度转角度	math.deg(math.pi)	180
exp	计算以e为底x次方值	math.exp(2)	2.718281828
floor	不大于x的最大整数	math.floor(5.6)	5
fmod （mod）	取模运算	math.mod(14, 5)	4
frexp	把双精度数val分解为数字部分（尾数）和以2为底的指数n，即val=x*2n	math.frexp(10.0)	0.625    4
ldexp	计算value * 2的n次方	math.ldexp(10.0, 3)	80 = 10 * (2 ^3)
log10	计算以10为基数的对数	math.log10(100)	2
log	计算一个数字的自然对数	math.log(2.71)	0.9969
max	取得参数中最大值	math.max(2.71, 100, -98, 23)	100
min	取得参数中最小值	math.min(2.71, 100, -98, 23)	-98
modf	把数分为整数和小数	math.modf(15.98)	15    98
pow	得到x的y次方	math.pow(2, 5)	32
rad	角度转弧度	math.rad(180)	3.14159265358
random	获取随机数	math.random(1, 100) math.random(100)	获取1-100的随机数
randomseed	设置随机数种子	math.randomseed(os.time())	在使用math.random函数之前必须使用此函数设置随机数种子
sinh	双曲线正弦函数	math.sinh(0.5)	0.5210953
sin	正弦函数	math.sin(math.rad(30))	0.5
sqrt	开平方函数	math.sqrt(16)	4
tanh	双曲线正切函数	math.tanh(0.5)	0.46211715
tan	正切函数	math.tan(0.5)	0.5463024

Lua中的table函数库

2018-11-16 17:15 更新

Lua中的table函数库

table库由一些操作table的辅助函数组成。他的主要作用之一是对Lua中array的大小给出一个合理的解释。另外还提供了一些从list中插入删除元素的函数，以及对array元素排序函数。

table.concat(table, sep,  start, end)

concat是concatenate(连锁, 连接)的缩写. table.concat()函数列出参数中指定table的数组部分从start位置到end位置的所有元素, 元素间以指定的分隔符(sep)隔开。除了table外, 其他的参数都不是必须的, 分隔符的默认值是空字符, start的默认值是1, end的默认值是数组部分的总长.

sep, start, end这三个参数是顺序读入的, 所以虽然它们都不是必须参数, 但如果要指定靠后的参数, 必须同时指定前面的参数.

test = {"Tom", "Mary", "Jam","Hey"}

print(table.concat(test, ":"))
print("*************")
print(table.concat(test, nil, 1, 2))
print("*************")
print(table.concat(test, "\n", 2, 3))

print(table.maxn(test))

Lua string库

一、String库的常用函数：

--返回字符串s的长度
local s = "HelloWorld"
print(string.len(s))  -->10

--重复n次字符串s的串
print(string.rep(s,2))  -->HelloWorldHelloWorld

--大写字母转换成小写
print(string.lower(s))  -->helloworld

--小写转换成大写
print(string.upper(s))  -->HELLOWORLD

--截取字符串
local s = "[in brackets]"
print(string.sub(s,2,-1))  -->in brackets]

--将每一个数字转换成字符
print(string.char(97))  -->a

--将每一个字符转换成数字
print(string.byte("abc"))
print(string.byte("abc", 2)) --> 98
print(string.byte("abc", -1)) --> 99

--注：使用负数索引访问字符串的最后一个字符

--对字符串进行格式化输出
PI = 3.14165120
print(string.format("pi = %.4f", PI))  -->pi = 3.1417
--注释：使用和C语言的printf函数几乎一模一样，你完全可以照C语言的printf来使用这个函数.

注：

string库中所有的字符索引从前往后是1,2,...;从后往前是-1,-2,...

string库中所有的function都不会直接操作字符串，而是返回一个结果。

二、String库的模式匹配函数

在string库中功能最强大的函数是：string.find（字符串查找），string.gsub（全局字符串替换），and string.gfind（全局字符串查找）。这些函数都是基于模式匹配的。

1.string.find  

说明：用来在目标串（subject string）内搜索匹配指定的模式的串。函数如果找到匹配的串返回他的位置，否则返回nil.最简单的模式就是一个单词，仅仅匹配单词本身。比如，模式'hello'仅仅匹配目标串中的"hello"。当查找到模式的时候，函数返回两个值：匹配串开始索引和结束索引。

local s = "hello world"
i,j = string.find(s,"hello")
print(i,"   ",j)  -->1      5

print(string.find(s, "kity"))  -->nil

string.find函数第三个参数是可选的：标示目标串中搜索的起始位置。当我们想查找目标串中所有匹配的子串的时候，这个选项非常有用。

local s = "\nare you ok!\n OK\n"
local t = {}
local i = 0
while true do
    i = string.find(s,"\n",i+1)
    if i == nil then break end
    table.insert(t,i)
end

for k,v in pairs(t) do
    print(k,"->",v)
end

Lua 中的模块与 module 函数

这篇文章主要介绍了 Lua 中的模块 (module) 和包 (package) 详解,本文讲解了 require 函数、写一个模块、package.loaded、module 函数等内容.

从 Lua5.1 版本开始，就对模块和包添加了新的支持，可是使用 require 和 module 来定义和使用模块和包。require 用于使用模块，module 用于创建模块。简单的说，一个模块就是一个程序库，可以通过 require 来加载。然后便得到了一个全局变量，表示一个 table。这个 table 就像是一个命名空间，其内容就是模块中导出的所有东西，比如函数和常量，一个符合规范的模块还应使 require 返回这个 table。现在就来具体的总结一下 require 和 module 这两个函数。如：

require "mod"
mod.foo()
local m2 = require "mod2"
local f = mod2.foo
f()

1. require 函数：

require 函数的调用形式为 require "模块名"。该调用会返回一个由模块函数组成的 table，并且还会定义一个包含该 table 的全局变量。在使用 Lua 中的标准库时可以不用显示的调用 require，因为 Lua 已经预先加载了他们。

require 函数在搜素加载模块时，有一套自定义的模式，如：
?;?.lua;c:/windows/?;/usr/local/lua/?/?.lua
在上面的模式中，只有问号 (?) 和分号 (;) 是模式字符，分别表示 require 函数的参数(模块名)和模式间的分隔符。如：调用 require "sql"，将会打开以下的文件：
sql
sql.lua
c:/windows/sql
/usr/local/lua/sql/sql.lua
Lua 将 require 搜索的模式字符串放在变量 package.path 中。当 Lua 启动后，便以环境变量 LUA_PATH 的值来初始化这个变量。如果没有找到该环境变量，则使用一个编译时定义的默认路径来初始化。如果 require 无法找到与模块名相符的 Lua 文件，就会找 C 程序库。C 程序库的搜索模式存放在变量 package.cpath 中。而这个变量则是通过环境变量 LUA_CPATH 来初始化的。

2. 编写模块的基本方法：

新建一个文件，命名为 game.lua，代码如下：

local M = {};
local modelName = ...;
_G[modelName] = M;
function M.play()
    print("那么，开始吧");
end
function M.quit()
    print("你走吧，我保证你不会出事的，呵，呵呵");
end
return M;

加载 game.lua，代码如下：

game = require "test"

game.play()

运行：

lua -e "io.stdout:setvbuf 'no'" "HelloWorld.lua" 
那么，开始吧
Exit code: 0

3. 使用环境：

仔细阅读上例中的代码，我们可以发现一些细节上问题。比如模块内函数之间的调用仍然要保留模块名的限定符，如果是私有变量还需要加 local 关键字，同时不能加模块名限定符。如果需要将私有改为公有，或者反之，都需要一定的修改。那又该如何规避这些问题呢？我们可以通过Lua的函数“全局环境”来有效的解决这些问题。

我们把 game.lua 这个模块里的全局环境设置为 M，于是，我们直接定义函数的时候，不需要再带 M 前缀。
因为此时的全局环境就是 M，不带前缀去定义变量，就是全局变量，这时的全局变量是保存在 M 里。
所以，实际上，play 和 quit 函数仍然是在 M 这个 table 里。

local M = {};
local modelName = ...;
_G[modelName] = M;
package.loaded[modname] = M
setfenv(1, M);
function play()
    print("那么，开始吧");
end
function quit()
    print("你走吧，我保证你不会出事的，呵，呵呵");
end
return M;

4. module 函数：

在 Lua 5.1中，我们可以用 module(...) 函数来代替以下代码，如：

local modname = ...
local M = {}
_G[modname] = M
package.loaded[modname] = M
     --[[
     和普通Lua程序块一样声明外部函数。
     --]]
setfenv(1,M)

即是：

module(..., package.seeall);

function play()
    print("那么，开始吧")
end

function quit()
    print("你走吧，我保证你不会出事的，呵，呵呵");
end

由于在默认情况下，module 不提供外部访问，必须在调用它之前，为需要访问的外部函数或模块声明适当的局部变量。然后 Lua 提供了一种更为方便的实现方式，即在调用 module 函数时，多传入一个 package.seeall 的参数，相当于 setmetatable(M, {__index = _G}) .

如：

module(...,package.seeall)

Lua IO库

2018-11-16 19:58 更新

I/O库为文件操作提供两种模式。简单模式（simple model）拥有一个当前输入文件和一个当前输出文件，并且提供针对这些文件相关的操作。完全模式（complete model）使用外部的文件句柄来实现。

简单模式

I/O库将当前输入文件作为标准输入（stdin），将当前输出文件作为标准输出（stdout）。这样当我们执行io.read，就是在标准输入中读取一行。
写操作较读操作简单，我们先从写操作入手。

下面这个例子里函数io.write获取任意数目的字符串参数，接着将它们写到当前的输出文件。

local t = io.write("sin (3) = ", math.sin(3), "\n")
--> sin (3) = 0.1411200080598672
print("hello", "Lua"); print("Hi")
-->hello    Lua
-->Hi

注：Write函数与print函数不同在于，write不附加任何额外的字符到输出中去，例如制表符，换行符等等。还有write函数是使用当前输出文件，而print始终使用标准输出。另外print函数会自动调用参数的tostring方法，所以可以显示出表（tables）函数（functions）和nil。

read函数:从当前输入文件读取串，由它的参数控制读取的内容：

例子：

--io.read 从标准输入流中获得，默认设置下，就是你的屏幕输入
t = io.read("*all")
t = string.gsub(t, ...) -- do the job
io.write(t) -- write the

提示：若使用luaEditor编辑器,估计无法在屏幕输入。

完全模式

完全模式的核心在于文件句柄（file handle）。该结构类似于C语言中的文件流（FILE*），其呈现了一个打开的文件以及当前存取位置。打开一个文件的函数是io.open。它模仿C语言中的fopen函数，同样需要打开文件的文件名参数，打开模式的字符串参数：

例子：

--读操作
file = io.open("testRead.txt", "r")
for line in file:lines() do
    print(line)
end
file:close()

--写操作
file = io.open("testRead.txt","a+")
file:write("\nhello")
file:close()

素材：

内容：

运行结果：

文件内容：

Lua 常用数据结构

一、数组

在lua中通过整数下标访问表中的元素即可简单的实现数组。并且数组不必事先指定大小，大小可以随需要动态的增长。

a = {}
for i = 1,100 do
    a[i] = 0
end
print("The length of array 'a' is " .. #a)

squares = {1, 4, 9, 16, 25}
print("The length of array 'a' is " .. #squares)

在Lua中习惯上数组的下表从1开始，Lua的标准库与此习惯保持一致，因此如果你的数组下标也是从1开始你就可以直接使用标准库的函数，否则就无法直接使用。

二、二维数组

Lua中主要有两种表示矩阵的方法，第一种是用数组的数组表示。也就是说一个表的元素是另一个表。

local N = 3
local M = 3
mt = {}
for i = 1,N do
    mt[i] = {}
    for j = 1,M do
        mt[i][j] = i * j
    end
end

mt = {}
for i = 1, N do
    for j = 1, M do
        mt[(i - 1) * M + j] = i * j
    end
end

三、链表

Lua中用tables很容易实现链表，每一个节点是一个table，指针是这个表的一个域，并且指向另一个节点(table)。例如，要实现一个只有两个域：值和指针的基本链表，代码如下：

list = nil
for i = 1, 10 do
    list = { next = list ,value = i}
end

local l = list
while l do
    --print(l.value)
    l = l.next
end

四、队列与双向队列

虽然可以使用Lua的table库提供的insert和remove操作来实现队列，但这种方式实现的队列针对大数据量时效率太低，有效的方式是使用两个索引下标，一个表示第一个元素，另一个表示最后一个元素。

List = {}

--创建
function List.new()
    return {first = 0,last = -1}
end

--队列头插入
function List.pushFront(list,value)
    local first = list.first - 1
    list.first = first
    list[first] = value
end

--队列尾插入
function List.popFront(list)
    local first = list.first
    if first > list.last then
        error("List is empty")
    end

    local value = list[first]
    list[first] = nil
    list.first = first + 1
    return value
end

function List.popBack(list)
    local last = list.last
    if list.first > last then
        error("List is empty")
    end
    local value = list[last]
    list[last] = nil
    list.last = last - 1
    return value
end

--测试代码
local testList = {first = 0,last = -1}
local tableTest = 12

List.pushFront(testList,tableTest)
print( List.popFront(testList))

五、栈

简单实现堆栈功能，代码如下：

local stackMng = {}
stackMng.__index = stackMng

function stackMng:new()
    local temp = {}
    setmetatable(temp,stackMng)
    return temp
end

function stackMng:init()
    self.stackList = {}
end

function stackMng:reset()
    self:init()
end

function stackMng:clear()
    self.stackList = {}
end

function stackMng:pop()
    if #self.stackList == 0 then
        return
    end
    if self.stackList[1] then
        print(self.stackList[1])
    end

    return table.remove(self.stackList,1)
end

function stackMng:push(t)
    table.insert(self.stackList,t)
end

function stackMng:Count()
    return #self.stackList
end

--测试代码
object = stackMng:new()
object:init()
object:push(1)
object:pop()

六、集合

在Lua中用table实现集合是非常简单的，见如下代码：

reserved = {
["while"] = true, ["end"] = true,
["function"] = true, ["local"] = true,
}

for k,v in pairs(reserved) do
    print(k,"->",v)
end