【Lua基础】基本语法

た入场券 2023-10-16 23:22 2阅读 0赞

## 注释 ##

Lua使用的注释如下：

-- 单行注释使用
    --[[
        多行注释使用
        多行注释使用
    ]]

跟其它语言使用的注释稍有不同，它以"--"为注释的标记。

## 类型 ##

Lua是动态类型语言，即变量的类型可以变。

通过type可以测试给定变量的类型，下面是例子：

print(type("helloworld"))           --> string
    print(type(1))                      --> number
    print(type(nil))                    --> nil
    print(type(true))                   --> boolean
    print(type(type))                   --> function
    print(type({x = 0, y = 1}))         --> table
    co = coroutine.create(function()
        print("helloworld")
    end)
    print(type(co))                     --> thread

上面展示了Lua的7个基本类型：

string/number/nil/boolean/function/table/thread。

另外还有一个类型是userdata，还不知道如何展示......

几点说明：

1.  nil类型只有nil这么一个值。
2.  boolean有两个值true和false。另外Lua中的所有值都可以用在条件语句中，且**除了false和nil表示假，其它都表示真**。比如0，它表示真。
3.  数值类型只有number，没有int、float等类型。
4.  string可以用双引号，也可以用单引号指定。还可以用**\[\[**里面是字符串**\]\]**，\[\[\]\]的特点是可以包含多行，可以嵌套，且不解释转移字符。
5.  function和其他上述的类型一样，属于第一类值，就是说也可以存在普通的变量里面。
6.  table、userdata和thread后面还会讲。

## 变量 ##

变量不需要声明。

给一个变量赋值后就生成了一个全局变量。

print(a)    --> nil
    a = 0
    print(a)    --> 0
    a = "hello world"
    print(a)    --> hello world
    a = nil     --> 相当于删除a这个变量

没有初始化的全局变量也可以访问，得到的是nil。实际的意思是，如果一个变量不是nil，就表示变量存在。所以如果给一个变量赋值为nil，就表示删除这个变量。

使用**local**关键字可以创建局部变量。

do
        local b = 0
        print(b)    --> 0
    end
    print(b)        --> 打印nil，因为a的生命周期已经结束

局部变量只在被声明的那个代码块内有效。代码块可以是一个控制结构，一个函数体，或者一个chunk（变量被声明的那个文件或者字符串）。

Lua中可以使用多变量赋值：

a,b,c = 1,"helloworld"
    print(a)    --> 1
    print(b)    --> helloworld
    print(c)    --> nil

多变量赋值也不是很讲究，=右边如果比左边少，则相应的变量为nil，比如这里的c；=右边如果比左边少，则多出来的赋值会被忽略。

多变量赋值在函数返回时也很有用，因为Lua中的函数是可以返回多个值的。

## 表达式 ##

一些特别的点：

1.  ~=相当于c语言里面的!=，不等于。
2.  table、userdata和function是引用比较，只有两个变量指向同一个对象才是相等。
3.  逻辑运算符是"and or not"，但是这里的and和or意思跟c语言有不同：
    
    1.  a and b：如果a为false，则返回a，否则返回b；
    2.  a or b ：如果a为true，则返回a，否则返回b。
4.  “..”两个点，表示字符连接符；如果操作数是number，则转换为字符串：

print(1 .. 2)   --> 12，注意..前后需要有空格，否则会报错

注意这里1 ..之间有一个空格，不然会报错。

但是如果是字符串就不需要：

print("hello".."world")	--> helloworld

## 表的构造 ##

下面是基本例子：

table1 = {}                             --> 空表
    names = {"jack", "john", "jimmy"}       --> 列表形式初始化
    print(names[1])                         --> jack,下标从1开始
    names[4] = "jason"                      --> 动态添加
    print(names[4])                         --> jason
    print(names[5])                         --> nil,因为不存在
    a = {x = 0, y = 1}                      --> record形式初始化
    print(a.x)                              --> 0
    print(a["x"])                           --> 0,另一种表示方式
    b = {"helloworld", x = 1, "goodbye"}    -->混合形式
    print(b[1])                             --> helloworld
    print(b.x)                              --> 1
    print(b[2])                             --> goodbye
    -- print(b.1)                           --> 没有这种

表中分隔可以使用逗号，也可以使用分号。

还有一种更一般的形式：

a = {["+"] = "add", ["-"] = "sub", ["*"] = "mul", ["/"] = "div", }  --> 后面可以有逗号
    print(a["+"])   --> add
    b = {[1] = "one", [2] = "two", [3] = "three"}
    print(b[1])     --> one

## 控制语句 ##

### **IF语句** ###

if xxx then xxx end
    if xxx then xxx else xxx end
    if xxx then xxx elseif xxx then xxx else xxx end

elseif可以有很多个，注意else和if中间没有空格！！

### **WHILE语句** ###

while xxx do xxx end

### **REPEAT-UNTIL语句** ###

repeat xxx until xxx

### **FOR语句** ###

for var=exp1,exp2,exp3 do xxx end

这里for里面的语句意思是var以exp3为step，从exp1到exp2。

需要注意几点：

*  几个exp只会运行一次，且在for循环之前；
 *  var是局部变量；
 *  循环过程中不要改变var。

for x,y,z in xxx do xxx end

### **BREAK和RETURN语句** ###

break退出当前循环；return退出函数并返回结果。

注意break和return只能用在一个block的结尾。如果有时候确实想要在另外的地方使用，可以用这样的方式：

do break/return end

## 函数 ##

函数的定义：

function funcName (args)
        states
    end

关于函数调用时，如果没有参数，需要使用()；

如果参数是字符串或者表构造时，可以不用()。

Lua函数中实参和形参的匹配也比较不讲究，实参多于形参，多余部分会忽略；实参少于形参，少的形参会是nil。这个与多变量赋值方式一致。

函数可以返回多个值：

function func (void)
        return 1,2
    end
    
    a,b = func()
    print(a)    --> 1
    print(b)    --> 2

通过()可以是函数强制返回一个值：

function func (void)
        return 1,2
    end
    
    print(func())       --> 1 2
    print((func()))     --> 1

Lua可以有可变参数。使用...三个点表示，在函数中用一个叫arg的table表示参数，arg中还有一个域n表示参数的个数。

下面是一个例子：

function func_1(...)
        print("The number of args: " .. #{...})
        for i,v in ipairs({...}) do
            print(i,v)
        end
    end
    func_1(0, 1, 2, 3)

打印的结果是：

The number of args: 4
    1       0
    2       1
    3       2
    4       3

函数参数传递时可以使用表的形式，这样就不需要记太多的参数，如下面的例子：

--> 不需要特别创建函数func(new, old)
    function func_2 (args)
        print(args.new,args.old)
    end
    var = {new = 1, old = 2}
    func_2(var)

函数实际上也是变量，因此可以有另外一种表达方式，比如下面两种方式：

function foo(x) return 2 * x end
    foo = function (x) return 2 * x end

它们其实是一样的。第二个foo被称为第一类值函数，将它应用在表中是Lua面向对象和包机制的关键。

函数中还可以包含函数，这个内部的函数可以访问包含它的那个函数中的变量（包括参数），下面是一个例子：

--> 定义了一个返回函数的函数
    function NewCounter()
        local i = 0
        return function()
            i = i + 1
            return i
        end
    end
    c1 = NewCounter()   --> c1是被返回的函数，需要注意的是它捕获了NewCounter()中的i变量
    print(c1())         --> 1
    print(c1())         --> 2
    c2 = NewCounter()
    print(c2())         --> 1，c2是一个新的返回函数，它捕获的还是原来的i，所以打印的是1

这里的内部函数以及它能够访问到的（捕获的）变量，共同构成了称为"闭包(closure)"的概念。

典型的闭包包含两个部分，一个是闭包自己，另一个是工厂（创建闭包的函数）。

Lua中的函数是变量，因此它可以是全局变量或者局部变量。作为局部变量的例子，比如说表中的域（像io.read这种，read就是一个局部函数）：

Lib = {}    --> 定义一个表
    Lib.add = function(x, y) return x + y end   --> 创建两个局部变量
    Lib.sub = function(x, y) return x - y end
    
    print(Lib.add(1,1)) --> 2
    print(Lib.sub(1,1)) --> 0

表中的局部函数还有两种形式可以表示：

第一种：

Lib1 = {
        add = function(x, y) return x + y end,  --> 分隔符别忘了
        sub = function(x, y) return x - y end
    }   --> 定义一个表
    print(Lib1.add(1,1)) --> 2
    print(Lib1.sub(1,1)) --> 0

第二种：

Lib2 = {}
    function Lib2.add(x, y) return x + y end
    function Lib2.sub(x, y) return x - y end
    
    print(Lib2.add(1,1)) --> 2
    print(Lib2.sub(1,1)) --> 0

另外，在函数前面声明local就得到局部函数：

do
        local foo = function(x)
            print(x)
        end
        local function goo(x)
            print(x)
        end
    
        foo(1)
        goo(2)
    end
    -- foo(1)   --> 报错，访问不到了
    -- goo(2)   --> 报错，访问不到了

声明局部函数的时候需要注意递归的情况，下面是一个错误的声明：

local func_3 = function (x)
        if x == 0 then
            return 1
        else
            return x * func_3(x - 1)
        end
    end
    
    print(func_3(3))

如果只在func\_3的全面声明，函数内部的func\_3(x - 1)位置就会识别不出来它是局部的，所以去找全局的了，结果没有找到就会报错，所以这里要做前向声明：

local func_3
    
    func_3 = function (x)
        if x == 0 then
            return 1
        else
            return x * func_3(x - 1)
        end
    end
    
    print(func_3(3))

另外Lua中的函数还支持“正确的尾调用”，它像下面的样子：

function f(x)
      return g(x)
    end

在这里g的调用就是尾调用，这种情况下，实际上g返回时不需要返回到调用者f中，所以不需要在栈中保留调用者f的任何信息。而正确的尾调用就是指Lua能够使尾调用时不使用额外的信息，这相当于一个goto到了另外的函数。

正确的尾调用使得递归可以无限进行而不会导致栈的溢出，当然也不只是在递归中，其它多个函数之间的调用也不需要担心栈溢出。

但是需要注意尾调用的形式，像**下面这些就不是尾调用**：

function f()
      g()
      return
    end
    return g(x) + 1
    return x or g(x)
    return (g(x))

## 迭代器和泛型for ##

Lua中的迭代器常用函数来描述迭代器，每次调用该函数就返回集合的下一个元素。

下面是一个例子：

function IterFactory(t)     -->创建迭代器的工厂
        local i = 0
        local n = #t            -->获取表的长度，只对列表形式的有效
        return function()       -->这个是迭代器
            i = i + 1
            if i <= n then
                return t[i]
            end
        end
    end
    
    aTable = {"one", "two", "three"}
    f = IterFactory(aTable)
    print(f())  --> one
    print(f())  --> two
    print(f())  --> three
    print(f())  --> 不打印

上面的例子其实跟《函数》一章中的闭包例子没有多大的差别。这个主要要讲的是下面这种和泛型for一起使用的情况：

aTable = {"one", "two", "three"}
    for element in IterFactory(aTable) do
        print(element)
    end

泛型for的格式是下面这样的：

for <var-list> in <exp-list> do
      <body>
    end

其中，var-list的第一个变量称为控制变量，如果它是nil，循环终止；exp-list通常是一个迭代工厂的调用，就像前面的IterFactory(aTable)。

泛型for循环的执行过程如下：

1.  计算in后面表达式的值，这个表达式返回三个值，分别是迭代函数，状态常量和控制变量，如果返回的不够，就用nil来补充；
2.  将状态常量和控制变量作为参数调用迭代函数。(对于for循环，状态常量没有用，仅仅在初始化时获取它的值并传递给迭代函数)；
3.  将迭代函数返回的值赋值给变量列表；
4.  如果返回的第一个值是nil，循环结束，否则执行循环体；
5.  回到第二步再次调用迭代函数。

所以说，上面的泛型for可以解释称下面的伪代码：

do
        local _f, _s, _var = exp-list
        while true do
            local var_1, ..., var_n = _f(_s, _var)
            _var = var_1
            if _var == nil then
                break
            end
            <block>
        end
    end

## 编译/运行/调试 ##

首先介绍chunk的概念：

chunk是一系列的代码。Lua执行的每一个块代码，比如一个文件或者交互模式下（命令行下运行Lua不加参数，就会进入交互模式）的每一行都是一个chunk。

chunk可以是一个语句（比如：交互模式下的一行，do end内部只有一行的话也算），可以是一系列的语句（比如do end内部，或者for循环内部），还可以是函数。

下面介绍几个函数：

**dofile()**：用来连接外部的chunk，它加载文件并执行它。下面是一个例子：

dofile("test_helloworld.lua")

这里的"test\_helloworld.lua"是放置之前例子的文件，通过dofile()就可以运行它的代码。

dofile是Lua运行代码的一种原始操作，它只是辅助作用，真正完成功能的是loadfile()函数。

**loadfile()**：它编译代码成中间码并且返回编译后的chunk作为函数，但不执行代码。

注意Lua语言也有编译这个动作，虽然它被称为脚本语言，但是Lua的编译器是语言运行时的一部分，所以执行编译并生成中间码的动作非常快。

另外，loadfile()不会抛出错误信息而是返回错误码，当发生错误时，loadfile()返回nil和错误信息。

与loadfile()很相似的有一个loadstring()。

**loadstring()：**从一个字符串中读入代码并编译成函数。

f = loadstring("i = 1; print(i)")
    f() --> 这里才是执行，前面只是生成了函数

或者简写成：

loadstring("i = 2; print(i)")() --> 注意后面的括号

loadstring()和loadfile()一样，不会抛出错误，但是会返回nil和错误信息，下面是一个例子：

print(loadstring("i i"))

它打印如下的错误信息：

nil     [string "i i"]:1: syntax error near 'i'

需要注意的一点，loadstring()总是在全局环境下编译字符串，所以它只认全局的变量而看不到局部变量：

local la = 0
    loadstring("print(la)")()    --> nil

还有一个跟dofile()类似的函数是require()：

require()：它用来加载运行库。与dofile的主要区别是以下几点：

1.  require()会搜索目录加载文件。
2.  require()会判断是否文件已经加载以避免重复加载同一文件。

关于第一个区别：require()搜索的路径采用模式列表的形式，比如如下的形式：

?;?.lua;/usr/local/lua/?/?.lua

在实际的操作中，比如require("helloworld")，则参数代替模式中的?，并搜寻代替后的文件：

helloworld;helloworld.lua;/usr/local/lua/helloworld/helloworld.lua

下面是一个例子：

require("test_helloworld")

实际上它运行了helloworld.lua文件。

需要注意这里的路径保存在LUA\_PATH这个全局变量中，但是它也不一定存在，如果不存在，就用默认的"?;?.lua"。

关于第二个区别：Lua中有一个表记录所有已经加载了的文件，但是需要注意表中保存的是文件的虚名，即参数名字。因此如果使用require("helloworld")和require("helloworld.lua")，那么实际上还是会加载两次helloworld.lua文件，而不是一次。

**error()：**结束程序并返回错误信息。下面是一个例子：

error("Error happened!")

**assert()：**接受两个参数，第一个参数如果不为真，就调用error(第二个参数表示的信息)。

**pcall()：**封装可能的错误代码（错误代码被放在函数中，或者包装成一个匿名函数），用来进行错误处理。如果没有错误，返回true和调用函数的返回值，否则返回false加错误信息。由于error()函数会直接返回，所以使用pcall()的话，至少可以保证让代码继续运行下去。

下面是一个例子：

--> 可能出错的代码封装在函数内
    function func()
        error() -->抛出错误
    end
    --> pcall调用函数
    if pcall(func) then
        print("no error")
    else
        print("error")
    end

上述的代码打印error。

不仅是错误信息，当发生错误的时候，所有传递给error()的参数都会被pcall()返回：

--> 可能出错的代码封装在函数内
    function func()
        error({code = 404}) -->抛出错误
    end
    --> pcall调用函数
    local status, err = pcall(func)
    if status == false then
        print(err.code)
    end

打印结果：404。

## 协程coroutine ##

协程跟线程类似，不同的是同一时间可以跑多个线程，但是协程只能有一个在运行。

协程通过协作来完成，Lua里面就是resume()和yeild()。

协程需要运行的代码被封装在函数中，通过将函数名传递给create()函数作为参数来创建一个协程，当然也可以直接传递匿名函数当作参数。

下面是一个例子：

co = coroutine.create(
            function ()
                print("helloworld")
            end
        )
    
    print(co)   --> thread: 0xxxxx(某个16位地址)

协程有三个状态：挂起态，运行态，停止态。

协程被创建后处于挂起态。也就是说协程并不会自动运行。

通过协程的status()来查看状态：

co = coroutine.create(
            function ()
                print("helloworld")
            end
        )
    
    print(co)                   -->thread: 0xxxxx(某个16位地址)
    print(coroutine.status(co)) -->suspended

通过resume()可以使协程进入运行态，之后代码结束就进入了停止态：

co = coroutine.create(
            function ()
                print("helloworld")
            end
        )
    
    print(co)                   -->thread: 0xxxxx(某个16位地址)
    coroutine.resume(co)        -->running，打印helloworld
    print(coroutine.status(co)) -->dead

通过yield()可以将协程挂起：

co = coroutine.create(
        function ()
            for i=1,10 do
                print("co", i)
                coroutine.yield()
            end
        end
        )
    
    coroutine.resume(co)
    print(coroutine.status(co)) -->suspended

运行结果如下：

co      1
    suspended

如果之后再运行resume()：

co = coroutine.create(
        function ()
            for i=1,10 do
                print("co", i)
                coroutine.yield()
            end
        end
        )
    
    coroutine.resume(co)
    print(coroutine.status(co)) -->suspended
    coroutine.resume(co)
    coroutine.resume(co)
    coroutine.resume(co)
    coroutine.resume(co)

运行结果如下：

co      1
    suspended
    co      2
    co      3
    co      4
    co      5

当调用次数超过10次之后：

print(coroutine.resume(co))

运行结果如下：

false   cannot resume dead coroutine

resume()和yield()之间可以传递参数，见下面的示例：

示例一，resume()的参数传递给了协程：

co = coroutine.create(
        function (a, b, c)
            print("co", a, b, c)
        end
        )
    
    coroutine.resume(co, 1, 2, 3)   --> resume的参数传递到了协程中

运行结果如下：

co      1       2       3

示例二，yield()的参数也将传递给resume()：

co = coroutine.create(
        function(a, b)
            coroutine.yield(a + b, a - b)
        end
        )
    
    print(coroutine.resume(co, 20, 10))

运行结果如下：

true    30      10

运行结果中，true表示resume()运行成功，后面的30和10是yield的参数。

示例三，协程代码返回值也会传递给resume()：

co = coroutine.create(
        function(a, b)
            return a + b, a - b
        end
        )
    
    print(coroutine.resume(co, 20, 10))

运行结果跟之前那个一样。

协程是非抢占式的，因此如果一个线程阻塞了，整个程序也就停止了。(当然这个也是有办法解决的，不过在基础部分不讲)