Lua—快速入门教程

在开始学习之前,先介绍一些最基本的概念,在Lua中具有一个代码块的概念,每个函数或者for循环等都是一个代码块。在Lua中,用 “- – ”来标记该行的注释,使用“- – [ [” 和   “ – – ] ] ”之间括起来的部分进行块注释。如下所示:

    -- 行注释,仅仅注释当前行  
    for idx = 1, 10 do  --在代码之后进行行注释  
         print("idx=",idx);    
    end  
    --[[  
    块注释,上边的for循环结构跟end结合起来就是一个Lua中常见的代码块结构。  
    --]]  

另外,Lua中支持的算术运算符有:+、-、*、/,即加、减、乘、除;支持的关系运算符有:==、~=(不等于)、<、>、<=、>=;支持的逻辑运算符有:and、or、not。需要注意的是,在Lua中,and逻辑运算符如果第一个参数是false,则返回false,不会执行第二个参数的代码(即使第二个参数是一个错误的表达式,也能顺利运行);如果第一个参数是true,返回第二个参数的值。 同理,or逻辑运算符如果第一个参数不是false,则返回第一个参数的值(不会执行第二个参数的代码);否则返回第二个参数的值。这就是所谓的逻辑运算符短路求值。

    result = true  
    if result and an_donot_defined_method() then  
      print("no erro occured!")  
    end  
    --[[  
    上述代码输出的错误如下:  
    stdin:1: attempt to call global 'an_donot_defined_method' (a nil value)  
    stack traceback:  
        stdin:1: in main chunk  
        [C]: ?  
    --]]  
    result =false   
    if (result and an_donot_defined_method())==false  then  
      print("no erro occured!")  
    end  
    --上述代码顺利通过编译,即使有一个没定义的方法,打印结果:no erro occured!  

基本数据类型

       Lua中具有5种基本的数据类型,nil、Boolean、string、Number和table。在Lua中使用变量不需要提前声明,变量的类型决定于用户赋值的类型。可以使用 type()函数判断变量的类型。其中,nil、Boolean、Number都是用法比较简单的类型,string、table类型用法稍微复杂点。给一个变量赋值为nil,表示释放该变量。Boolean跟其他语言一样,只有true和false两种值。Number是双精度浮点数,Lua中没有整数类型。table类型可以当作数组使用。

       在Lua中,变量默认是全局的,这通常导致一些调试困难,最好尽量显式的在变量名之前加上 local 关键字声明该变量为局部变量。

    gNumber = 10  --这是一个默认全局的变量  
    print(type(gNumber))  
    --输出结果为number  
    gNumber = nil --之前的number类型gNumber = 10变量被释放  
    print(type(gNumber))  
    --输出结果为nil  
      
    function LocalVarFunction ()  
      local pTable = {} --用local关键字声明一个局部变量,这个变量将在执行LocalVarFunction方法后销毁  
         for idx = 1, 5 do   
               local result = true  --这个result将在每个for循环执行之后销毁  
               if result then   
                  local pString = "这个字符串将在if代码块之后销毁"  
                  pTable[idx] = pString  
                  print(pTable[idx])  
               end  
         end  
    end  
下面详细介绍string以及table两种类型的详细用法。其它数据类型的介绍请参考《Lua—数据类型》
 

string类型的用法

       Lua中的字符串操作非常出色。下表是一些特殊意义的字符:
特殊的Lua字符串
 字符 意义 字符 意义
     a 响铃     v  垂直制表符 
    b 退格     反斜杠
    f 换页符     “ 双引号
    n 换行符     ' 单引号
    r 换行符    [ 左方括号
   t 制表符    ] 右方括号

类型转换

     Lua会根据上下文在合理合法的情况下隐式进行数字和字符之间的转换。另外,也可以使用tonumber()函数和tostring()函数显式地进行字符与数字的转换。 见代码实例:
    --字符与数字的隐式转换  
    print("10" + 7)  
    --输出结果为:17,将字符10隐私转化为Number类型计算  
    print("hello" + 7)  
    --无法进行运算,即不能隐式将"hello"字符转化为Number计算  
    --[[  
       系统错误如下:  
    stdin:1: attempt to perform arithmetic on a string value    
    stack traceback:    
        stdin:1: in main chunk    
        [C]: ?    
    --]]  
      
      
      
    --字符与数字的显式转换  
    print(tonumber("100")+11)  
    --输出结果为:111  
    print(type(tostring(100)))  
    --输出结果为:string  

常用的字符处理函数介绍

       string.char()函数根据传入的ASCII编码返回该编码对应的字符。如:string.char(10),表示字符换行符,10是换行符的ASCII编码。    
       string.len()函数求字符串的长度。如:
    print(string.len("hello"))  
    --输出结果为:5  

       string.sub(aString, start, end) 函数返回指定字符串的子串。如:

    gString = "hello Lua"  
    print(string.sub(gString, 7,9))  
    --输出结果为:Lua  

       string.format()函数格式化输出指定字符串。%s表示字符串,%d表示所有数字,%D表示非数字,%a表示字母,%c表示控制字符,%l小写字母,%p标点符号,%s空格符号,%u大写字母,%w字母数字,%x十六进制数,%z用0表示的字符。加%前缀可以让特殊符号也能用在格式化中(如:().%+_*?[ ^ $ ]),如%%代表百分比符号。%.4f表示小数点后有4位的浮点数,%02d.表示至少有两个数字的整数,如果不足两个数字则用0补足。如:

    aString = "哈哈,你是"  
    bString = "一头猪"  
    print(string.format("%s%s", aString, bString))  
    --输出结果为:哈哈,你是一头猪  
      sting.find(sourceString, targetString) 函数在sourceString字符串中查找第一个符合targetString字符串的位置,如果找到则返回开始和结束的位置,没找到则返回nil。
      string.gsub(sourceString, pattern, replacementString) 函数返回一个字符串,sourceString字符中满足pattern格式的字符都会被替换成replacementString参数的值。
      string.gfind(sourceString, pattern) 函数遍历一个字符串,一旦查找到符合指定格式的字符串就返回该子串。

table类型的用法

      一般table可以当做数组使用,可以通过table[n]的索引形式访问任意数组中的某个成员。在Lua中,table还能被当做字典dictionary数据使用,并且数组跟字典的用法还能混合使用(实质上还是数组,只不过索引从数字变成其他属性值)。
      使用其他值作为table的索引以及多维table
      table还可以使用其他的值作为索引值,并且能用数字跟其他值同时作为同一个table的索引。如:
    gTable = {}  
    gTable.name = "eric"  
    gTable.gender = "man"  
    gTable.phonenumber = "0000000000"  
    gTable[1] = "公司"  
    gTable[2] = "部门"  
    for index, value in pairs(gTable) do   
      print(index, value)  
    end  
    --[[  
    输出结果如下:  
    1   公司  
    2   部门  
    phonenumber 0000000000  
    gender  man  
    name    eric  
    --]]  
       注意,上述循环中的pairs()函数可以遍历table中的每一对值(索引以及索引对应的value,有点类似字典,不是吗?)
       事实上,table的索引还可以是table本身,这样就组成了一个多维table或多维字典。跟其他语言的多维数组或字典比起来,使用真是超级方便,非常非常的灵活。如:
    gTable = {}  
    gTable.name = "eric"  
    gTable.gender = "man"  
    gTable.phonenumber = "0000000000"  
    gTable[1] = "公司"  
    gTable[2] = "部门"  
    gTable.hobby = {"跑步", "读书", "游戏", "动漫"}  -- 多维table,可以通过gTable.hobby[1]的方式访问.即gTable.hobby本身也是一个table  
    gTable.secTable = {}  
    gTable.secTable.job = "程序员"  
    gTable.secTable.label = "写代码的"  
    gTable.secTable.description = "职责是实现产品的逻辑"  
      
    for index, value in pairs(gTable) do   
      print(index, value)  
      if ("table" == type(value)) then  
         for idx, var in pairs(value) do   
             print("二维table:", idx, var)  
         end  
       end  
    end  
    --[[  
    输出结果如下:  
    1   公司  
    2   部门  
    hobby   table: 0x7fdceac14bc0  
    二维table:    1   跑步  
    二维table:    2   读书  
    二维table:    3   游戏  
    二维table:    4   动漫  
    phonenumber 0000000000  
    gender  man  
    secTable    table: 0x7fdceac15100  
    二维table:    label   写代码的  
    二维table:    description 职责是实现产品的逻辑  
    二维table:    job 程序员  
    name    eric  
    --]]  

table 的常用函数

       table.getn()函数,返回table中元素的个数。如:
gStringTable = {"a", "b","c","d","e"}  
for i = 1, table.getn(gStringTable) do  
     print(gStringTable[i])  
end 

       table.sort()函数,将table中的元素从小到大排列。如:

    gNumberTable = {10, 5, 7, 2,3, 2}  
    table.sort(gNumberTable)  
    for i = 1, table.getn(gNumberTable) do   
       print(gNumberTable[i])  
    end  
    --输出结果如下:  
    2  
    2  
    3  
    5  
    7  
    10  
       table.insert(pTable, position, value) 函数在table中插入一个新值,位置参数如果没指定,则默认将新值插入到table的末尾。
       table.remove(pTable, position) 函数从指定table中删除指定位置的元素并返回该元素,如果没有指定删除的位置,则默认删除table的最后一个元素。
    
   介绍到这里, Lua中基本的数据类型诸位应该都能掌握,休息一下,下面接着开始简单介绍Lua的基本语句以及函数。

Lua中的常用语句结构

Lua中的常用语句结构介绍,首先介绍分支语句,也即Lua的条件判断语句,具体如下:

    --if 语句结构,如下实例:  
    gTable = {"hello", 10}  
    if nil ~= gTable[1] and "hello" == gTable[1] then  
      print("gTable[1] is" , gStringTable[1])  
    elseif  10 == gTable[2] then  
      print("gTable[2] is", gTable[2])  
    else   
      print("unkown gTable element")  
    end  

循环语句在各种编程语言中都存在,Lua的循环语句如下所示:

    --while 和repeat循环语句结构,while先判断条件,如果true才执行代码块(有可能跳过该代码块);repeat则是在最后判断条件,保证代码块至少执行一次。  
    gTable = {1,2,3,4,5,6,7,8,9,10}  
    index = 1  
    while gTable[index] < 10 do   
       print("while gTable[",index,"] is ",gTable[index])  
       index = index + 1 -- 注意,Lua不支持index++或者index += 1形式的运算符。  
    end  
    --[[  
    while循环输出结果如下:  
    while gTable[   1   ] is    1  
    while gTable[   2   ] is    2  
    while gTable[   3   ] is    3  
    while gTable[   4   ] is    4  
    while gTable[   5   ] is    5  
    while gTable[   6   ] is    6  
    while gTable[   7   ] is    7  
    while gTable[   8   ] is    8  
    while gTable[   9   ] is    9  
    --]]  
      
    --上一个循环结束后,index = 10  
    repeat  
        print("repeat gTable[",index,"] is ",gTable[index])  
       index = index - 2  
    until index < 1  
    --[[  
    输出结果如下:  
    repeat gTable[  10  ] is    10  
    repeat gTable[  8   ] is    8  
    repeat gTable[  6   ] is    6  
    repeat gTable[  4   ] is    4  
    repeat gTable[  2   ] is    2  
    --]]  

Lua的另外一种循环语句:

--for循环结构,for循环结构具有三个参数,初始值,结束值,每个循环增加值。  
for index = 1, 5 do --不设置第三个参数的话,默认缺省第三个参数是1,即每个循环 index 增加1  
   print("for cycle index =",index)  
end  
--[[  
输出结果为:  
for cycle index =   1  
for cycle index =   2  
for cycle index =   3  
for cycle index =   4  
for cycle index =   5  
--]]  
  
for index = 20 , 0, -5 do --设定第三个参数为-5  
 print("for cycle index:",index)  
end  
--[[  
输出结果:  
for cycle index:    20  
for cycle index:    15  
for cycle index:    10  
for cycle index:    5  
for cycle index:    0  
--]] 

有时候我们并不期望走完所有循环,而是在循环的某个点退出循环。这时就会用到break语句。

    --break关键字可以使循环强制退出,Lua中没有continue关键字,需要通过其他方式实现continue关键字,比如if-else语句。或者通过网络下载Lua的continue关键字补丁安装来解决该问题  
      
    for index = 1, 100, 5 do   
      if index > 10 and index < 25 then  --用if-else语句实现continue关键字的功能  
         print("continue!!!!! index=",index)  
      else   
        if index > 15 and index < 35 then   
           print("break~~~~~index=",index)  
           break  
        end  
        print("At end index=",index)  
      end  
    end  
      
    --[[  
    输出结果如下:  
    At end index=   1  
    At end index=   6  
    continue!!!!! index=    11  
    continue!!!!! index=    16  
    continue!!!!! index=    21  
    break~~~~~index=    26  
    --]]  

Lua中没有switch语句,但是可以用如下方式代替该语句。

    --最后还要提的一点是,Lua中switch语句的缺失,用if-elseif-else语句代替的话,显得非常臃肿,还有其他的一些实现方案。笔者在网上麦子加菲童鞋的博客中找到一种Lua中代替switch语句非常优雅的方案。下面贴出麦子加菲原代码:  
    --Switch语句的替代语法(所有替代方案中觉得最好,最简洁,最高效,最能体现Lua特点的一种方案)  
    action = {    
      [1] = function (x) print(x) end,    
      [2] = function (x) print( 2 * x ) end,    
      ["nop"] = function (x) print(math.random()) end,    
      ["my name"] = function (x) print("fred") end,    
    }    
       
    while true do    
        key = getChar()    
        x = math.ramdon()    
        action[key](x)    
    end   

Lua中的函数

     在Lua脚本中,函数是以function关键字开始,然后是函数名称,参数列表,最后以end关键字表示函数结束。需要注意的是,函数中的参数是局部变量,如果参数列表中存在(…)时,Lua内部将创建一个类型为table的局部变量arg,用来保存所有调用时传递的参数以及参数的个数(arg.n)
    function PrintTable (pTable)  
      for index = 1, table.getn(pTable) do   
          print("pTable[",index,"] =",pTable[index])  
      end  
    end  
      
    gStringTable = {"hello","how","are","you"}  
    PrintTable(gStringTable)  
    --[[  
    输出结果为:  
    pTable[ 1   ] = hello  
    pTable[ 2   ] = how  
    pTable[ 3   ] = are  
    pTable[ 4   ] = you  
    --]]  
      
    function PrintFriendInfo (name, gender, ...)   
      local friendInfoString = string.format("name:%s  gender:%d",name,gender)  
      if 0 < arg.n then  
         for index = 1, arg.n do   
            friendInfoString = string.format("%s otherInfo:%s",friendInfoString, arg[index])  
         end  
       end  
       print(friendInfoString)  
    end  
      
      
    PrintFriendInfo ("eric", 1, "程序员","2b", 50)  
      
     --输出结果为:  
    -- name:eric  gender:1 otherInfo:程序员 otherInfo:2b otherInfo:50  

  Lua函数的返回值跟其他语言比较的话,特殊的是能够返回多个返回值。return之后,该Lua函数从Lua的堆栈里被清理

    function GetUserInfo ()  
        local name = "eric"  
        local gender = 1  
        local hobby = "动漫"  
      return name, gender, hobby  
    end  
      
    print(GetUserInfo())  
      
    --输出结果:eric 1   动漫  

Lua中的库函数

          在本文的最后,介绍一些Lua中常用的库函数。
          1. 数学库
          math库的常用函数:三角函数math.sin、math.cos、取整函数math.floor、math.ceil、math.max、math.min、随机函数math.random、math.randomseed(os.time())、变量pi和huge。
          2. I/O库
         进行I/O操作前,必须先用io.open()函数打开一个文件。io.open()函数存在两个参数,一个是要打开的文件名,另一个是模式字符,类似"r"表示读取、“w”表示写入并同时删除文件原来内容,“a”表示追加,“b”表示打开二进制文件。该函数会返回一个表示文件的返回值,如果打开出错则返回nil,写入之前需要判断是否出错,比如:local file = assert(io.open(filename, “w”))..使用完毕后,调用io.close(file).或file:close()。
       几个常用I/O函数:io.input ()、io.output ()、 io.read()、 io.write()
    local file = assert(io.open(filename, “w”))  
    if file ~= nil then  
      file:write("hello lua!!!!")  --注意,等同于io.write("hello lua!!!!")  
      file:close()  --等同于io.close(file)  
    end  

         3. 调试库

         debug.getinfo()函数,他的第一个参数 可以是一个函数或一个栈层。返回结果是一个table,其中包含了函数的定义位置、行号、函数类型、函数名称等信息。

         debug.getlocal()函数检查函数任意局部变量,有两个参数,第一个是希望查询的函数栈层,另一个是变量的索引。

         assert(trunk)() 函数,执行参数中代码块并在出错时提供报错功能

    a = "hello world"  
    b = "print(a)"  
    assert(loadstring(b))()  
    --输出结果:  
    hello world  

       4. 几个处理Lua码块的函数

        loadstring(pString)()函数可以直接执行pString字符串组成的Lua码,但不提供报错功能

loadstring("for index = 1, 4 do print("for cycle index =",index) end")()  
--[[  
输出结果  
for cycle index =   1  
for cycle index =   2  
for cycle index =   3  
for cycle index =   4  
--]] 

dofile(filename)函数的功能是载入并立刻执行Lua脚本文件。可以用来载入定义函数的文件或者数据文件、或立即执行的Lua码。dofile函数会将程序的执行目录作为当前目录。如果要载入程序执行目录的子目录里的文件,需要加上子目录的路径。

dofile("/Users/ericli/WorkSpace/Lua语言/hellolua.lua")  
--输出结果:Hello Lua! 

完整示例

下面本文给出一个完整的示例,通过该实例可以简单的了解Lua的语法和程序结构,具体细节还需参考本教程其它章节内容。

-- 单行注释
--[[
    [多行注释]
--]]
 
----------
- 1. 变量 & 控制流
----------
num = 23 -- 数字都是双精度
str = 'aspythonstring' -- 像 Python 一样不可变
str = "aspythonuse" -- 可以双引号
str = [[
        像 Python 的多行注释可用于
        表示多行字符串一样
        方便
    ]]
 
bol = nil -- 未定义;支持垃圾回收
 
-- 缩进只为易读性,像 Matlab 一样以 end 结尾
while num < 50 do
    num = num + 1 -- 没有 ++ 或 += 自增操作符号
end
 
-- IF 条件开关
if num > 40 then
    print('> 40')
elseif s ~= 'aspython' then -- ~= 表示 !=
    io.write('s is not aspython') -- 风骚的标准输出
else
    thisIsGlobal = 5 -- 驼峰式命名
    -- 显示声明局部变量(像 Javascript 一样)
    local line = io.read()
 
    -- .. 作为字符串连接符
    print('凛冬将至' .. line)
end
 
-- 引用未定义变量将返回 nil ,这不是错误
foo = anUnknownVariable  -- 等价于 foo = nil
 
aBoolValue = false
-- 只有 nil 与 false 为逻辑假; 数字 0 与空字串 '' 为真!
if not aBoolValue then print('false') end
 
-- 像 Python 一样运用 'or' 和 'and'
-- 得到 C 语言中 a ? b : c 的效果;需注意 b = false 或 nil 的情况
ans = aBoolValue and 'yes' or 'no'
 
karlSum = 0
for i = 1, 100 do -- 像 Matlab 一样的递增语法,包括两端,如同数学中[1, 100]
    karlSum = karlSum + i
end
 
-- Step 为 2 递减的方式 '100, 1, -2'
for j = 100, 1, -2 then print(j) end
 
-- 综上,范围可表示为 "begin, end [, step]"
 
-- 另一个循环控制
num = 23
repeat
    print('凡人必有一死')
    num = num - 1
until num == 0
 
 
----------
- 2. 函数
----------
function fib(n)
    if n < 2 then return 1 end
    return fib(n - 2) + fib(n - 1)
end
 
-- Javascript 一样的匿名函数与闭包
function adder(x)
    -- 返回一个函数
    -- 闭包内封存 x 值
    return function (y) return x + y end
end
a1 = adder(9)
a2 = adder(36)
print(a1(16))  --> 25
print(a2(64))  --> 100
 
-- 遇到不匹配的列表长度时
-- 过长的变量将被赋予 nil
-- 过长的值将被忽略
 
x, y, z = 1, 2, 3, 4 -- 4 将被忽略
function bar(a, b, c)
    print(a, b, c)
    return 4, 8, 15, 16, 23, 42
end
x, y = bar('zaphod')  --> "zaphod  nil nil"
-- x = 4, y = 8, 其余值被忽略
 
-- 函数与其他类型一样为一等公民
-- 同样有 local/global 之分
-- 像 Javascript 一样定义
function f(x) return x * x end
f = function (x) return x * x end
 
print 'Hello World!' -- 只有一个`字符串`参数时可省略括号
 
----------
- 3. 表(Table) 
----------
-- 表是 Lua 中唯一的复合类型
-- 像 PHP 中的数组或 Javascript 中的 Object 一样
-- 可用作 list/dict/map
 
-- 默认以字符串作为 key
t = {key1 = 'value1', key2 = false}
-- 像 Javascript 一样以 . 取值
print(t.key1) --> "value1"
t.key3 = {} -- 加入新的键值对
t.key2 = nil -- 销毁一组键值对
 
-- 理论上任何非 nil 的变量都可以作为 key
u = {['@!#'] = 'qbert', [{}] = 1729, [6.28] = 'tau'}
print(u[6.28])  --> "tau"
a = u['@!#'] -- a = 'qbert'
b = u[{}] -- b = nil;像 Javascript 一样 {} 会创建新的对象
          -- 因此不要用蛋疼的 key 值,老老实实用字串或数字
 
-- 同字符串一样,只有一个表作为函数的参数时可以省略括号
-- 为了一个括号增加阅读难度,得不偿失
function h(x) print(x.key1) end
h{key1 = 'Sonmi~451'}  --> "Sonmi~451"
 
for key, val in pairs(u) do  -- 像 Python  一样的键值迭代
    print(key, val)
end
 
-- 像 Javascript 一样的全局作用域 _G
print(_G['_G'] == _G) --> true
 
-- 省略 key 之后即可变身为 list
-- 实际上是以递增自然数为 key
v = {'value1', 'value2', 1.21, 'gigawatts'}
for i = 1, #v do  -- 像 Bash 一样,#v 表示列表长度
    print(v[i])  -- 像 Matlab 一样,列表索引从 1 开始
end
 
----------
- 3.1 Metatables & metamethods
----------
-- 元表(metatable)就是表的表,像 Javascript 的原型(prototype)一样
-- 为表重载一些元方法(metamethods)
 
f1 = {a = 1, b = 2}
f2 = {a = 2, b = 3}
-- s = f1 + f2 为错
 
mm = {}
function mm.__add(x, y)
  sum = {}
  sum.a = x.a + y.a
  sum.b = x.b + y.b
  return sum
end
 
setmetatable(f1, mm)
setmetatable(f2, mm)
 
-- 实际调用 f1 的 metatable 中的 __add(f1, f2)
-- 只为 f1 设置元表也可以
s = f1 + f2 -- s = {a = 3, b = 5}
 
-- s2 = s + s 为错,s 未定义元表
 
-- __index 元方法重载表中 key 的提取符号 `.`
defaultFavs = {animal = 'gru', food = 'donuts'}
myFavs = {food = 'pizza'}
setmetatable(myFavs, {__index = defaultFavs})
food = myFavs.food
 
-- Lua 中的值都具有元方法,只有 Table 可以重载
-- 所有元方法如下
 
-- __add(a, b)                     for a + b
-- __sub(a, b)                     for a - b
-- __mul(a, b)                     for a * b
-- __div(a, b)                     for a / b
-- __mod(a, b)                     for a % b
-- __pow(a, b)                     for a ^ b
-- __unm(a)                        for -a
-- __concat(a, b)                  for a .. b
-- __len(a)                        for #a
-- __eq(a, b)                      for a == b
-- __lt(a, b)                      for a < b
-- __le(a, b)                      for a <= b
-- __index(a, b)  <fn or a table>  for a.b
-- __newindex(a, b, c)             for a.b = c
-- __call(a, ...)                  for a(...)
 
----------
- 3.2 类风格的 Table 与继承
----------
 
-- 像 Javascript 一样并没有内置 Class
-- 但可以通过 Table `{}` 实现
 
Dog = {}                                -- 1.
function Dog:new()                      -- 2.
    newObj = {sound = 'woof'}           -- 3.
    self.__index = self                 -- 4.
    return setmetatable(newObj, self)   -- 5.
end
function Dog:makeSound()                -- 6.
    print('I say ' .. self.sound)
end
 
mrDog = Dog:new()                       -- 7.
mrDog:makeSound() --> "I say woof"
 
-- 1. Dog 像类但实际是 Table
-- 2. Dog:new(...) := Dog.new(self, ...)
-- 3. newObj 作 Dog 的实例
-- 4. self 是 Lua 中默认的参数,在这里 self = Dog
--    继承的时候可以改变
--    self.__index 与 self 的元方法 __index 不是一回事
--    self = {__index = self, metatable = {__index = ...}}
-- 5. setmetatable(newObj, self) 相当于 setmetatable(newObj, {__index = self})
--    赋予实例所有类方法
-- 6. 同 2.
-- 7. mrDog = Dog.new(Dog)
 
-- 继承
LoudDog = Dog:new()
function LoudDog:makeSound()
    s = self.sound .. ' '
    print(s .. s .. s)
end
seymour = LoudDog:new()
seymour:makeSound() --> "woof woof woof"
 
----------
- 4. 模块
----------
 
-- 以下来自文件 mod.lua
local M = {}
 
local function sayMyName()
    print('Hrunkner')
end
 
function M.sayHello()
    print('Why hello there')
    sayMyName()
end
return M
-- 以上
-- 回到主文件
local mod = require('mod') -- 运行 mod.lua 中的代码
-- 操作同下
local mod = (function()
    -- 像 Javascript 一样
    --[[
        mod.lua 中的代码
    ]]--
end)()
 
mod.sayHello() --> "Why hello there"
mod.sayMyName() --> 错!sayMyName() 是 mod.lua 中的局部变量
 
-- require 返回的值将被缓存
-- 即使多次调用 require 被调用文件也只运行一次
 
-- mod2.lua 包含 print("mod2")
local a = require("mod2") --> "mod2"
local b = require("mod2") -- 不输出, 实际为 b = a
 
-- dofile 是不缓存的版本的 require
dofile("mod2") --> "mod2"
dofile("mod2") --> "mod2"
 
-- loadfile 读取文件但不执行
-- 勘误:f = loadfile('mod2'),需加后缀名,否则找不到文件
f = loadfile('mod2.lua')
f() --> "mod2"
 
-- loadstring 读取代码字符串
f = loadstring("print('Lua is cool!')")
f() --> "Lua is cool!"
 
----------
- 5. 参考,略
----------

通过本教程可以对Lua有个简单的认识,如果想更深入的学习Lua语言的开发,请参考《Lua入门教程》

如果引用本站的原创文章,请注明原文链接:,本站保留追究责任的权利!

发表评论