lua学习总结

简述

Lua是一个很小的编程语言，很多人将其与Python高级语言进行比较。
Lua有以下的特点：
（1）纯C语言实现，源码小，可以很好地与C/C++融合。可自行编译，生成静态库。
（2）语法简单，灵活，易学。

我也同时学习了Python，相比之下，Lua精简，功能简单，可用的库少，但是语言的实现写得如此精简也很不错了！与C/C++程序结合就能显示它的强大能力，适用于要求可配置性很高的C/C++程序中，比如游戏。
如果想写纯脚本程序，那就选Python吧，它是强大，库多，喜欢单干。

好，我们学习Lua吧！

基础

数据类型

Lua的常用数据类型有：
（1）Nil (空) <==> C语言中的NULL
（2）number 所有数据，包含整数小数
（3）string 字串类型
（4）boolean 布尔类型 true, false
（5）function 函数类型
（6）table 表类型

其实，Lua中的数据类型远不止上面的这几个，比如file.
table在Lua中是最重要的数据类型，Lua的很多思想都是基于表来实现的，比如模块、对象。
boolean 除Nil与false为假以为，其它都为真。
string
\ 转义字符
\[
\]
\ddd 3个十进制的数据表示一个字符，高位填0
[[ ... ]] 表示多行字符串，其中字串无转义

a = [[ \t \n [[ ]]print(a)\t \n [[

当字符串被参于数值运算时，Lua会试图将字串转成数值

print("10"+ 1) --> 11print("123"* "12")--> 1476

当数值参于字串运算时，Lua也会尝试将其转换成字符串

print(123 .. 12)-->12312print(10 =="10") --> 永远都是false-- 除非print(10 == ("10"+ 0)) --> trueprint("10"== (10 .. ""))--> true

总之：操作符决定了两边操作数的转换类型。

表达式

（1）算术运算符　　+ - * / ^ （加减乘除幂）
（2）关系运算符 < > <= >= == ~= （不等于）
　　   nil只与自己相等，table, usedate, function, 只比对象不比内容的值，相当于C语言中的指针比较
（3）逻辑运算符 and or not
          and, or 的运算结果不是true与false

    a andb -- 如果a为false，则返回a，否则b    a orb -- 如果a为true，则返回a，否则b    a andb or c -- 类似C中的 a ? b : c

        not 结果返回true或false

（4）优先级
        ^ 与 .. 是右连接

表结构

days = {"sun","Mon", "Tue","Wed", "Thu","Fri", "Sat"}print(days[0])--> nilprint(days[1])--> Sun

注意： Lua中，表的索引是从1开始的，不是0！

Polyline = { color = "blue", thickness = 2, npoints = 4,{x = 0, y = 0},{x = -10, y = 0},{x = -10, y = 10},{x = 0, y = 10}}Polyline["color"]--> "blue"Polyline.color --> "blue"Polyline[1] --> {x = 0, y = 0}Polyline[1].x --> 0

表中的元素都是由key-value组成。如果没有指定key，那就默认以1开始的整数做key，如上4个{x,y}。如果指定了名称，则以string类型为key，如color, thickness, npoints。其实，表的key还可以为table, function, file, boolean任意类型。value可以为任何Lua类型。

Person = {["name"] ="Peter", ["age"] = 28}-- 等价于Person = {name = "Peter", age = 28}{x=0, y=0} --> {["x"]=0, ["y"]=0}{"red","green", "blue"}--> ｛[1]="red", [2]="green", [3]="blue"｝

基本语法

（1）多元素赋值

a, b = 10, 'Hi'--> 等价于a = 10; b = 'Hi'

如果左边与右边个数不一致时，多的忽略，少的填Nil。

（2）代码块chunk。

使用local创建的一个局部变量，可以避免命名冲突，而比全局变量高效。

（3）控制结构

<pre name="code" class="cpp">----------------------------------if condition1 then...else if condition2 then...else ...end----------------------------------while condition do...end----------------------------------repeat...until condition

----------------------------------

for 语句

for var=exp1, exp2, exp3 do...end---> exp1: 初始值---> exp2: 终止值---> exp3: 步进for k in pairs(days) doprint(k .. ' = ' .. days[key])endfor i, val in ipairs(days) doprint(i .. ' = ' .. val)end

（4）函数

定义格式：

function func_name (arguments_list)...end

当函数的参数只有一个且为string或table类型时，可以不加括号。如：

dofile "text.lua"table_print {a=12, b=30}

函数的返回值可以是多个：

function foo(a, b)return a+b, a-bendaa, bb = foo(32, 11)print(aa, bb) --> 43, 21

（5）闭包

Python与Lua都有闭包的特性，我记得好像Java也有，但是Ｃ与Ｃ++是没有的。

-- 调用newCounter()返回一个function，而这个function引用了newCounter()函数内部的局部变量local i----------------------------function newCounter()    local i = 0    return function()<span style="white-space:pre"></span>i = i + 1<span style="white-space:pre"></span>return i    endendc1 = newCounterprint(c1()) --> 1print(c2()) --> 2newCounter = nil -- 就算我把这个函数销毁了print(c1()) --> 3 还是生效

为什么？因为在Lua中，所有的变量都是“指针”。所有的变量都是从堆里分配出来的，不像Ｃ与C++，局部变量是从栈里分配，一旦函数退出，所有局部变量都要被释放。Lua中的所有变量都是从堆里申请的。对象的释放是自动进行的，只有这个对象的引用计数为０了才会被释放掉。

为了便于理解，我写一段Ｃ++的伪代码：

class CounterFunc{public:    CounterFunc(int i*)

    {    <span style="white-space:pre"></span>m_pCnt = i;    }    int operator()() 

    {<span style="white-space:pre"></span>++i;<span style="white-space:pre"></span>return i;    }private:    int *m_pCnt;}CounterFunc* newCounter(){    int *i = new int;

    return new CounterFunc(i);}int main(){    CounterFunc &c1 = *newCounter()    cout << c1() << endl;    cout << c1() << endl;}

熟悉Ｃ++的学友们一下就看懂了。

（６）非全局函数

表中的函数实现方式：

Lib = {}Lib.foo = function(x, y) return x+y end----------------------------------------------Lib = {

foo = function(x, y) return x+y end}----------------------------------------------Lib = {}function Lib.foo(x, y) return x+y end

局部函数

local foo = function(x, y)    return x+yend------------------------------------------------local function foo (x, y)    return x+yend

（７）尾调函数

当函数的最后返回结果是调用另一个函数，称之为尾调函数。Lua的在调用尾调函数时，先是弹出当前函数的栈空间，然后再调用尾调函数，从而降低了函数层层调动过程中的栈消耗，非常适用于函数递归调用。

加载文件与运行

当我们需要加载与运行已有文件中的Lua代码时，可以用以下几种方式：

（１）loadstring( str ) --- 加载字串

f = loadstring "a = 12; print('a=' .. a)"f() --> a=12

loadstring()本是函数，由于函数是string，所以没有加括号。loadstring()执行完之后，只是加载解析，并没有执行。返回的是一个function类型。执行该函数便可以运行。相当于：

f = loadstring "function() a = 12; print('a='..a) end"

（２）loadfile( file_name ) --- 加载文件

这个函数相当于从文件里读出string，然后再调用loadstring(file_text)实现加载功能。

（３）dofile( file_name ) --- 加载并执行文件

相当于loadfile()之后，返回一个函数，再调用这个函数。

function dofile( file_name )    local f = assert(loadfile(file_name))    f()end

（４）require( file_name )

这个函数是通过调用dofile()来实现的。不同的是，每次加载执行一个文件时，require()都会记录，避免重复加载。另外，如果给定的路径找不到文件，require()会到指定的路径下去找输到加载的文件。文件名称可以省去.lua后缀。

协同函数

关于这个功能，我的理解是：是非抢占式任务，由任务主动放弃执行权来达到任务切换的目的。

function foo (x, y)    while ture do<span style="white-space:pre"></span>local a = x + y<span style="white-space:pre"></span>local b = x - y<span style="white-space:pre"></span>x, y = coroutine.yield(a, b)    endend------------------------------------------co = coroutine.create(foo)print(coroutine.resume(co, 1, 2)) --> true 3 -1print(coroutine.resume(co, 7, 1)) --> true 8 6

这里最不好理想的就是yield()与resume()参数与返回值的问题。这里分步骤详细解释一下：
（１）co = coroutine.create(foo)，创建一个协同任务，返回co，此时co的状态为suspend。
（２）coroutine.resume(co, 1, 2)，程序转而执行foo(x, y)，x,y的传入的值正是resume()中的(1, 2)。

（３）foo(1, 2)执行到coroutine.yield(a, b)，(a, b)分别为(3,-1)。程序执行yield(3, -1)切换到主任务，resume()函数返回第一个值为bool，后面的正是yield()中传入的参数。
（４）coroutine.resume(co, 7, 1)，程序跳到foo()中的coroutine.yield()行继续执行。其中resume()函数中带的参数(7, 1)，在foo()函数中，x, y = coroutine.yield() 通过返回值的形式赋给了(x, y)。
（５）跳到（３），如此重复。

可见，Lua并没有实现多任务并行执行，而是任务之间通过resume()与yield()函数进行切换。我想，其主要的作用还是用于将功能以任务的形式进行隔离，便于维护。

Metatables and Metamethods

元表与元方法，这是一个很重要的概念。可以为table设置或指定metatable，用于指定某些运算符对应的操作方法。

＊　setmetatable(table, meta_table) 设置元表
＊　getmetatable(table) 获取元表

这个元素，可以是个函数。

tb = {----> <metatable> = {__add = function : xxx 加法操作__sub = function : xxx 减法操作__mul = function : xxx 乘法操作...}[1] = 20[2] = 40...}

（１）算术运算

+ --> __add(a, b)- --> __sub(a, b)* --> __mul(a, b)/ --> __div(a, b)-负 --> __unm(a)^ --> __pow(a, b)

（２）关系运算

== --> __eq(a, b)< --> __lt(a, b)<= --> __le(a, b)

只要定义上面几个就行了，不用再定义 ~=, >=, >

（３）库定义

__tostring = function(tb)

在print(t)的时候，print会调用元素中的tostring(t)来进行转换，tostring(t)就查t中的metatable中是否有__tostring域，如果有就调用默认是有的。

（4）表相关

__index = function(tb, key)__index = tb

访问索引，如果执行读取一个表中的操作，而这个表里又没有这个域，那么Lua就去查询metatable中的__index域。如果__index是表，那么就去查__index表中有没有这个域，如果有就从__index这个表里的这个域里去取值。如果__index是函数，那么就调用__index(tb, key)函数。

__newindex = function(tb, key)

更新索引，在更改表域的时候，如果这个表中没有这个域，那么就会从元表的__index里去找。与__index同理。

这两个东西，在类继承里用到。

环境变量

Lua环境放在全局变量 _G 中。可以用以下语句打印全局变量。

for n in pairs(_G) do print(n) end

</pre></div></div></div><div id="highlighter_474421" class="syntaxhighlighter  lua"><div class="bar"><div class="toolbar"><pre code_snippet_id="358723" snippet_file_name="blog_20140522_27_6186527" name="code" class="cpp">a = 5print(_G["a"]) --> 5

其实，所有的全局变量都是放在__G表里。可以对_G表里加metatable，来控制全局变量的形为。如__newindex, __index, 限制直接定义与访问一个变量。

在非全局域，防止访问到全局域

do    a = 'Hi'    setfenv(1, {_G = _G})    _G.print(_G.a) --> Hiend

在局部Chunk中，将_G放入一个空表中，将这个表作为全局表。