1. 数据类型

数据类型 描述
nil 只有值为 nil 属于该类，表示一个无效值（在条件表达式中相当于 false）
boolean false or true
number 双精度类型的实浮点数
string 双引号或单引号表示
function 由 C 或 Lua 编写的函数
userdata 表示任意存储在变量中的 C 数据结构
thread 表示执行的独立线路，用于执行协同程序
table Lua 中的表其实是一个”关联数据”, 数组的索引可以是数字或字符串
  • nil
  • boolena
  • number
  • string
    • 可以使用两个方括号”[[]]” 来表示一块字符串
    • 字符串链接使用两个点好 ..
    • 计算字符串的长度使用 #
html = [[
    <html>
    <head></head>
    <body>
        <a href="http://domob.cn">Domob</a>
    </body>
    </html>
]]
print(html)

len = "pemako.cn"

print(#len)

  • function
-- function_test.lua
function factoriall(n)
    if n == 0 then
        return 1
    else
        return n * factoriall(n - 1)
    end
end

print(factoriall(5)) – 120

  • table
    • 不同于其他语言的数组把 0 作为数组的初始索引，在 Lua 里表的默认初始索引一般以 1 开始
local tb1 = {"apple", "pear", "orange"}

for k, v in pairs(tb1) do

print(k … " : " … v)

end

– 1 : apple

– 2 : pear

– 3 : orange

  • userdata

    <p>userdata 是一种用户自定义数据，用于表示一种由应用程序或 C/C++ 语言库所创建的类型，可以将任意 C/C++ 的任意数据类型的数据（通常是 struct 和 指针）存储到 Lua 变量中调用</p>

  • thread

    <p>在 Lua 里，最主要的线程是协同程序（coroutine）。它跟线程（thread）差不多，拥有自己独立的栈、局部变量和指令指针，可以跟其他协同程序共享全局变量和其他大部分东西。

    线程跟协程的区别：线程可以同时多个运行，而协程任意时刻只能运行一个，并且处于运行状态的协程只有被挂起（suspend）时才会暂停

2. Lua 变量

  • 全局变量

    <p>Lua 中的变量全是全局变量，哪怕是语句块或是函数里，除非用 local 显示声明为局部变量</p>

  • 局部变量

    <p>局部变量的作用于为从生命位置开始到所在语句块结束</p>

<p>变量的默认值均为 <code class="highlighter-rouge">nil</code></p>

  • 表中的域

  • 赋值语句

    <ul>
  <li>Lua 可以对多个变量同时赋值，变量列表和值列表的各个元素使用逗号分开，复制语句右边的值会依次赋值给左边的变量</li>
  <li><code class="highlighter-rouge">x, y = y, x</code> – 交换 x y 的值</li>
  <li>当变量的个数和值的个数不一致时，Lua会一直以变量个数为基础采取以下策略</li>
</ul>

<div class="highlighter-rouge"><div class="highlight"><pre class="highlight"><code>  a. 变量的个数 &gt; 值的个数    按变量个数补足 nil

    b. 变量的格式 < 值的格式 多余的值会被忽略

<ul>
  <li>多值赋值经常用来交换变量，或将函数调用返回给变量</li>
</ul>

  • 索引

    <ul>
  <li><code class="highlighter-rouge">t[i]</code></li>
  <li><code class="highlighter-rouge">t.i</code> 当索引为字符串类型时的一种简化写法</li>
</ul>

    • 3. Lua 循环

    • while
    • for
    • repeat...until 重复执行循环，知道指定的条件为真时为止
    • 循环嵌套 可以在循环内嵌套一个或多个循环语句(while for do..while)

    4. Lua 流程控制

    if 表达式
then
    -- 在表达式为 true 时执行的语句
end

    5. Lua 函数

    optional_function_scope function function_name( argument1, argument2..., argumentn)
    function_body
    return result_params_comma_separated
end
-- optional_function_scope 默认不写为全局函数 加上 local 为局部函数
-- Lua 可以返回多个返回值，每个值已逗号隔开
    • 可变参数

    可变参数使用三个点(…) 便是函数有可变参数。Lua 将函数的参数放在一个叫 arg 的表中，#arg 便是传入参数的个数

    function average(...)
    result = 0
    local arg = {...}
    for i,v in ipairs(arg) do
        result = result + v
    end

    <span class="nb">print</span><span class="p">(</span><span class="s2">&#34;总共传入&#34;</span><span class="o">..</span> <span class="o">#</span><span class="n">arg</span> <span class="o">..</span> <span class="s2">&#34;个数&#34;</span><span class="p">)</span>
<span class="k">return</span> <span class="n">result</span><span class="o">/#</span><span class="n">arg</span>

    

    end
    

    print("平均值为:", average(1,2,3,4))
    
– 总共传入4个数
    
– 平均值为: 2.5

    6. Lua 运算符

    • 算术运算符： + - * / % ^
    • 关系运算符：== ~=(不等于) > < >= <=
    • 逻辑运算符：and or not
    • 其它运算符：..(链接两个字符串) #(返回字符串或表的程度)

    7. Lua 字符串

    • 单引号字符串
    • 双引号字符串
    • [[和]]间的字符串
    • 字符串操作
      • string.upper(argument)
      • string.lower(argument)
      • string.gsub(mainString, findString, replaceString, num)
      • string.strfind(str, substr,[init,[end]])
      • string.reverse(arg)
      • string.format(…)
      • string.len(arg)
      • string.rep(string, n)
      • string.char(arg) 和 string.byte(arg[,int])
    string.gsub("aaaaa", "a", "z", 3) -- 把字符串aaaaa 中的 a 替换为z 天幻3次
string.gsub("aaaaa", "a", "z") -- 把字符串aaaaa 中的 a 替换为z 全部替换

    – 在一个指定的目标字符串中搜索指定的内容(第三个参数为索引)
    
string.find("Hello Lua user", "Lua", 1) – 7  9 (分别为开始位置和结束位置的索引)
    

    string.format("the value is:%d", 4) – the value is:4
    

    string.rep("abcd", 2) – abcdabcd
    

    – char 将整数数字转换成字符并连接，byte 转换字符为整数值(可以指定某一个字符，默认第一个字符)
    
string.char(97,98,99,100)   – abcd
    
string.byte("ABCD", 4)      – 68
    
string.byte("ABCD")         – 65

    8. Lua 数组

    Lua数组可以为一维数组或多维数组，数组的索引值可以使用整数表示，数组的大小不固定。

    -- 一维数组
array = {"Lua", "Tutorial"}

    for i=1, #array do
    
print(array[i])
    
end
    

    –Lua
    
–Tutorial
    

    – 多维数组
    
array = {}
    
– 初始化数组
    
for i = 1, 3 do
    
array[i] = {}
    
for j = 1, 3 do
    
array[i][j] = i*j
    
end
    
end
    
– 遍历数组
    
for i=1, 3 do
    
for j = 1, 3 do
    
print(array[i][j])
    
end
    
end
    

    – 1 2 3 2 4 6 3 6 9

    9. Lua 迭代器

    • 无状态的迭代器

      <p>无状态迭代器的典型的简单的例子是 <code class="highlighter-rouge">ipairs</code>, 他遍历数组的每一个元素</p>

    t = {"Lua","Python", "PHP", "Java"}
for k, v in pairs(t) do
    print(k, v)
end
    • 多状态的迭代器
    array = {"Lua", "Tutorial"}

    function elementIterator (collection)
    
local index = 0
    
local count = #collection
    
– 闭包函数
    
return function ()
    
index = index + 1
    
if index <= count
    
then
    
–  返回迭代器的当前元素
    
return collection[index]
    
end
    
end
    
end
    

    for element in elementIterator(array)
    
do
    
print(element)
    
end
    

    – Lua
    
– Tutorial

    10. Lua table

    table 是 Lua 的一种数据结构用来帮助我们创建不同的数据类型，如：数字、字典等。

    Lua table 使用关联型数组，你可以用任意类型的值来作数组的索引，但这个值不能是 nil。

    Lua table 是不固定大小的，你可以根据自己需要进行扩容。

    Lua也是通过table来解决模块（module）、包（package）和对象（Object）的。 例如string.format表示使用”format”来索引table string。

    • Table 操作

      <ul>
  <li>table.concat(table[,sep[,start[,end]]])</li>
</ul>

    -- concat 链接两个 table 和 PHP 中的 implode 函数很类似
-- table.concat() 函数列出参数中指定 table 的数组部分从 start 位置到 end 位置的所有元素，元素间已指定的分隔符(sep)隔开
> language = {"Lua", "Python", "PHP", "Java"}
> print(table.concat(language))
LuaPythonPHPJava
> print(table.concat(language, ','))
Lua,Python,PHP,Java
> print(table.concat(language, ',', 1, 2))
Lua,Python
    • table.insert(table[,[pos,]value])
    
-- 在 table 数组部分指定位置(pos)插入值为 value 的元素，默认从末尾插入
> language = {"Lua", "Python", "PHP", "Java"}
> table.insert(language, "Golang")
> print(language[5])
Golang
> table.remove(language)
> print(language[5])
nil
> print(language[1])
Lua
> table.remove(language,1)
> print(language[1])
Python

    - table.remove(table[,pos])
- table.sort(table[,comp])

    11. Lua 模块与包

    Lua 的模块是由变量、函数等已知元素组成的 table，因此创建一个模块很简单，就是创建一个 table，然后把需要导出的常量、函数放入其中，最后返回这个 table 就行。以下为创建自定义模块 module.lua，文件代码格式如下：

    • 定义模块
    -- 文件名 utils.lua
-- 定义一个名为 utils 的模块

    utils = {}
    

    – 定义一个常量
    
utils.constant = "这是一个常量"
    

    – 定义一个函数
    
function utils.func1()
    
io.write("这是一个共有函数!n")
    
end
    

    local function func2()
    
print("这是一个私有函数！")
    
end
    

    function utils.fun3()
    
func2()
    
end
    

    return utils

    • 加载模块 require
    
require("utils") -- 或者使用 require "utils"
                 -- 别名导入 local u = require("utils")
print(utils.constant)
                -- print(u.constant)  使用别名
utils.fun3()

    12. Lua 元表(Metatable)

    Lua table 无法对两个 table 进行操作，因此 Lua 提供了元表(Metatable),允许我们改变 table 的行为，每个行为关联了对应的元方法。

    对指定的表设置元表

    • setmetatable(table, metatable): 对指定的 table 设置元表(metatable),如果元表中存在__metatable值，setmetatable会失败

    • getmetatable(table): 返回对象的元表(metatable)

    • __index元方法

    当你通过健来访问 table 的时候，如果这个健没有值，那么 Lua 就会寻找该 table 的 metatable(假定有 metatable)中的__index 健。如果__index包含一个表格，Lua 会在表格中查找相应的健。

    Lua 5.3.4  Copyright (C) 1994-2017 Lua.org, PUC-Rio
> other = { foo = 3}
> t = setmetatable({}, {__index = other})
> t.foo
3
> t.bar
nil

    如果 __index包含一个函数的话，Lua 就会调用那个函数，table 和健会作为参数传递给函数。__index元房费查看表中元素是否存在，如果不存在，返回结果为 nil, 如果存在则由__index返回结果。

    mytable = setmetatable({key1 = "value1"}, {
    __index = function(mytable, key)
        if key == "key2" then
            return "metablevalue"
        else
            return nil
        end
    end
})

    print(mytable.key1, mytable.key2)
    
– value1	metablevalue
    

    – 上面的代码可以简写为
    
mytable = setmetatable({key1="value1", {__index = {key2 = "metatablevalue"}} })

    Lua 查找一个元素时的规则

    1. 在表中查找，如果找到，返回该元素，找不到则继续
    2. 判断该表是否有元表，如果没有元表，返回 nil, 有元表则继续
    3. 判断元表有没有 __index 方法,如果__index 方法为 nil,则返回 nil; 如果 __index 方法是一个表，则重复i, ii, iii; 如果 __index 方法是一个函数，则返回该函数的返回值
    • __newindex 元方法

    __newindex元方法用来对表更新，__index则用来对表访问。当你给表的一个缺少的索引赋值，解释器就会查找__newindex元方法；如果存在则调用这个函数而不进行赋值操作。

    mymetatable = {}
mytable = setmetatable({key1 = "vlaue1"}, { __newindex = mymetatable })

print(mytable.key1)                         -- value1

mytable.newkey = "新值2"
print(mytable.newkey, mymetatable.newkey)   -- nil 新值2

mytable.key1 = "新值1"
print(mytable.key1, mymetatable.key1)       -- 新值1 nil

    以上实例中表设置了元方法 __newindex,在对新索引(newkey)赋值时(mytable.newkey = “新值2”),会调用元方法，而不进行赋值。而如果对已存在的索引健(key1),则会进行赋值，而不调用元方法 __newindex。

    • __add方法

    进行两个表相加操作。

    -- 计算表中最大值，table.maxn 在 Lua5.2以上版本中已无法使用
-- 自定义计算表中最大值函数 table_maxn

    function table_maxn(t)
    
local mn = 0
    
for k, v in pairs(t) do
    
if mn < k then
    
mn = k
    
end
    
end
    
return mn
    
end
    

    – 两表相加操作
    
mytable = setmetatable({1, 2, 3}, {
    
__add = function(mytable, newtable)
    
for i = 1, table_maxn(newtable) do
    
table.insert(mytable, table_maxn(mytable) + 1, newtable[i])
    
end
    
return mytable
    
end
    
})
    

    secondtable = {4<span class