# lua-study **Repository Path**: ti132520/lua-study ## Basic Information - **Project Name**: lua-study - **Description**: 学习lua的记录 - **Primary Language**: Lua - **License**: MulanPSL-2.0 - **Default Branch**: master - **Homepage**: None - **GVP Project**: No ## Statistics - **Stars**: 0 - **Forks**: 1 - **Created**: 2021-10-27 - **Last Updated**: 2022-10-20 ## Categories & Tags **Categories**: Uncategorized **Tags**: None ## README --- title: lua学习 date: 2021-10-26 13:26:14 tags: - lua summary: lua学习 categories: lua学习sh --- ## 基本语法 ```lua # 交互式编程：即使用 lua 或者 lua -i 打开的命令行编写代码 # 脚本式编程：即编辑 .lua 后缀文件后使用命令 lua xx.lua 执行（也可以在头部加入 #!/usr/local/bin/lua 即lua环境位置，直接使用 ./xx.lua 执行） -- 单行注释 --[[ 多行注释 ]] ``` ## 关键词 以下列出了 Lua 的保留关键词。保留关键字不能作为常量或变量或其他用户自定义标示符： | and | break | do | else | | -------- | ----- | ----- | ------ | | elseif | end | false | for | | function | if | in | local | | nil | not | or | repeat | | return | then | true | until | | while | goto | | | ## 全局变量 在默认情况下，变量总是认为是全局的。 全局变量不需要声明，给一个变量赋值后即创建了这个全局变量，访问一个没有初始化的全局变量也不会出错，只不过得到的结果是：nil。 要删除变量，只需要将其赋值为nil。 ## 数据类型 | 数据类型 | 描述 | | :------- | :----------------------------------------------------------- | | nil | 这个最简单，只有值nil属于该类，表示一个无效值（在条件表达式中相当于false）。 | | boolean | 包含两个值：false和true。 | | number | 表示双精度类型的实浮点数 | | string | 字符串由一对双引号或单引号来表示 | | function | 由 C 或 Lua 编写的函数 | | userdata | 表示任意存储在变量中的C数据结构 | | thread | 表示执行的独立线路，用于执行协同程序 | | table | Lua 中的表（table）其实是一个"关联数组"（associative arrays），数组的索引可以是数字、字符串或表类型。在 Lua 里，table 的创建是通过"构造表达式"来完成，最简单构造表达式是{}，用来创建一个空表。 | * 变量和 nil 作比较时 nil 要加“” ：即 a == “nil” * boolean 类型只有两个可选值：true（真） 和 false（假），Lua 把 false 和 nil 看作是 false，其他的都为 true，数字 0 也是 true: * Lua 默认只有一种 number 类型 -- double（双精度）类型（默认类型可以修改 luaconf.h 里的定义） * 在 Lua 里，table 的创建是通过"构造表达式"来完成，最简 单构造表达式是{}，用来创建一个空表。也可以在表里添加一些数据，直接初始化表。 * table 不会固定长度大小，有新数据添加时 table 长度会自动增长，没初始的 table 都是 nil。 * 在 Lua 里，最主要的线程是协同程序（coroutine）。它跟线程（thread）差不多，拥有自己独立的栈、局部变量和指令指针，可以跟其他协同程序共享全局变量和其他大部分东西。线程跟协程的区别：线程可以同时多个运行，而协程任意时刻只能运行一个，并且处于运行状态的协程只有被挂起（suspend）时才会暂停。 * userdata 是一种用户自定义数据，用于表示一种由应用程序或 C/C++ 语言库所创建的类型，可以将任意 C/C++ 的任意数据类型的数据（通常是 struct 和 指针）存储到 Lua 变量中调用。 * 遍历表使用下方法： ```lua local tbl = {"apple", "pear", "orange", "grape"} for key, val in pairs(tbl) do print("Key", key) end -- pairs: 可遍历所有表 -- ipairs: 只可遍历 key 为 1 开头的表，没有1开头就没有输出（或者自己指定了key 非数字） ``` ## 变量 * 变量在使用前需要进行声明 * Lua 变量有三种类型：全局变量、局部变量、表中的域。 * 变量不做显式声明，默认为全局变量 * 使用 local 声明的变量为局部变量 * 局部变量的作用域为从声明位置开始到所在语句块结束。 * 字符串相加使用 “..”连接，数字相加使用 “+” * 应该尽可能的使用局部变量，有两个好处： - 避免命名冲突。 - 访问局部变量的速度比全局变量更快。 * 对于 table 的索引使用 [] 或者 . 访问 ## 循环 | 循环类型 | 描述 | | :------------- | :----------------------------------------------------------- | | while 循环 | 在条件为 true 时，让程序重复地执行某些语句。执行语句前会先检查条件是否为 true。 | | for 循环 | 重复执行指定语句，重复次数可在 for 语句中控制。 | | repeat...until | 重复执行循环，直到 指定的条件为真时为止 | | 循环嵌套 | 可以在循环内嵌套一个或多个循环语句（while do ... end;for ... do ... end;repeat ... until;） | ```lua while(condition) do statements end for var=exp1,exp2,exp3 do <执行体> end -- var 从 exp1 变化到 exp2，每次变化以 exp3 为步长递增 var，并执行一次 "执行体"。exp3 是可选的，如果不指定，默认为1。 repeat statements until( condition ) --[ 变量定义 --] a = 10 --[ 执行循环 --] repeat print("a的值为:", a) a = a + 1 until( a > 15 ) ``` ## 循环控制语句 循环控制语句用于控制程序的流程， 以实现程序的各种结构方式。 Lua 支持以下循环控制语句： | 控制语句 | 描述 | | :----------------------------------------------------------- | :----------------------------------------------- | | [break 语句](https://www.runoob.com/lua/lua-break-statement.html) | 退出当前循环或语句，并开始脚本执行紧接着的语句。 | | [goto 语句](https://www.runoob.com/lua/lua-goto.html) | 将程序的控制点转移到一个标签处。 | ## 流程控制语句 Lua 提供了以下控制结构语句： | 语句 | 描述 | | :----------------------------------------------------------- | :----------------------------------------------------------- | | [if 语句](https://www.runoob.com/lua/if-statement-in-lua.html) | **if 语句** 由一个布尔表达式作为条件判断，其后紧跟其他语句组成。 | | [if...else 语句](https://www.runoob.com/lua/if-else-statement-in-lua.html) | **if 语句** 可以与 **else 语句**搭配使用, 在 if 条件表达式为 false 时执行 else 语句代码。 | | [if 嵌套语句](https://www.runoob.com/lua/nested-if-statements-in-lua.html) | 你可以在**if** 或 **else if**中使用一个或多个 **if** 或 **else if** 语句 。 | ## 函数 ```lua optional_function_scope function function_name( argument1, argument2, argument3..., argumentn) function_body return result_params_comma_separated end ``` - **optional_function_scope:** 该参数是可选的制定函数是全局函数还是局部函数，未设置该参数默认为全局函数，如果你需要设置函数为局部函数需要使用关键字 **local**。 - **function_name:** 指定函数名称。 - **argument1, argument2, argument3..., argumentn:** 函数参数，多个参数以逗号隔开，函数也可以不带参数。 - **function_body:** 函数体，函数中需要执行的代码语句块。 - **result_params_comma_separated:** 函数返回值，Lua语言函数可以返回多个值，每个值以逗号隔开。 - ```lua -- Lua 中我们可以将函数作为参数传递给函数，如下实例： -- 实例 myprint = function(param) print("这是打印函数 - ##",param,"##") end function add(num1,num2,functionPrint) result = num1 + num2 -- 调用传递的函数参数 functionPrint(result) end myprint(10) -- myprint 函数作为参数传递 add(2,5,myprint) ``` ## 可变参数 - Lua 函数可以接受可变数目的参数，和 C 语言类似，在函数参数列表中使用三点 **...** 表示函数有可变的参数。 ```lua function add(...) local s = 0 for i, v in ipairs{...} do --> {...} 表示一个由所有变长参数构成的数组 s = s + v end return s end print(add(3,4,5,6,7)) --->25 ``` - 我们可以将可变参数赋值给一个变量。 - 我们也可以通过 select("#",...) 来获取可变参数的数量: - 固定参数必须放到可变参数前 实例 ```lua function average(...) result = 0 local arg={...} for i,v in ipairs(arg) do result = result + v end print("总共传入 " .. select("#",...) .. " 个数") return result/select("#",...) end print("平均值为",average(10,5,3,4,5,6)) ``` ## Lua 运算符 运算符是一个特殊的符号，用于告诉解释器执行特定的数学或逻辑运算。Lua提供了以下几种运算符类型： - 算术运算符 - 关系运算符 - 逻辑运算符 - 其他运算符 ### 算术运算符 A = 10, B = 20 | 操作符 | 描述 | 实例 | | :----- | :--- | :---- | | + | 加法 | A + B | | - | 减法 | A - B | | * | 乘法 | A * B | | / | 除法 | B / A | | % | 取余 | B % A | | ^ | 乘幂 | A^2 | | - | 负号 | -A | ### 关系运算符 下表列出了 Lua 语言中的常用关系运算符，设定 A 的值为10，B 的值为 20： | 操作符 | 描述 | 实例 | | :----- | :----------------------------------------------------------- | :-------------------- | | == | 等于，检测两个值是否相等，相等返回 true，否则返回 false | (A == B) 为 false。 | | ~= | 不等于，检测两个值是否相等，不相等返回 true，否则返回 false | (A ~= B) 为 true。 | | > | 大于，如果左边的值大于右边的值，返回 true，否则返回 false | (A > B) 为 false。 | | < | 小于，如果左边的值大于右边的值，返回 false，否则返回 true | (A < B) 为 true。 | | >= | 大于等于，如果左边的值大于等于右边的值，返回 true，否则返回 false | (A >= B) 返回 false。 | | <= | 小于等于， 如果左边的值小于等于右边的值，返回 true，否则返回 false | (A <= B) 返回 true。 | ### 逻辑运算符 下表列出了 Lua 语言中的常用逻辑运算符，设定 A 的值为 true，B 的值为 false： | 操作符 | 描述 | 实例 | | :----- | :----------------------------------------------------------- | :--------------------- | | and | 逻辑与操作符。 若 A 为 false，则返回 A，否则返回 B。 | (A and B) 为 false。 | | or | 逻辑或操作符。 若 A 为 true，则返回 A，否则返回 B。 | (A or B) 为 true。 | | not | 逻辑非操作符。与逻辑运算结果相反，如果条件为 true，逻辑非为 false。 | not(A and B) 为 true。 | ### 其他运算符 下表列出了 Lua 语言中的连接运算符与计算表或字符串长度的运算符： | 操作符 | 描述 | 实例 | | :----- | :--------------------------------- | :----------------------------------------------------------- | | .. | 连接两个字符串 | a..b ，其中 a 为 "Hello " ， b 为 "World", 输出结果为 "Hello World"。 | | # | 一元运算符，返回字符串或表的长度。 | #"Hello" 返回 5 | ### 运算符优先级 从高到低的顺序： ```lua ^ not - (unary) * / % + - .. < > <= >= ~= == and or ``` 除了 **^** 和 **..** 外所有的二元运算符都是左连接的。 ```lua a+i < b/2+1 <--> (a+i) < ((b/2)+1) 5+x^2*8 <--> 5+((x^2)*8) a < y and y <= z <--> (a < y) and (y <= z) -x^2 <--> -(x^2) x^y^z <--> x^(y^z) ``` ## Lua 字符串 字符串或串(String)是由数字、字母、下划线组成的一串字符。 Lua 语言中字符串可以使用以下三种方式来表示： - 单引号间的一串字符。 - 双引号间的一串字符。 - **[[** 与 **]]** 间的一串字符。 转义字符用于表示不能直接显示的字符，比如后退键，回车键，等。如在字符串转换双引号可以使用 "\""。 所有的转义字符和所对应的意义： | 转义字符 | 意义 | ASCII码值（十进制） | | -------- | ----------------------------------- | ------------------- | | \a | 响铃(BEL) | 007 | | \b | 退格(BS) ，将当前位置移到前一列 | 008 | | \f | 换页(FF)，将当前位置移到下页开头 | 012 | | \n | 换行(LF) ，将当前位置移到下一行开头 | 010 | | \r | 回车(CR) ，将当前位置移到本行开头 | 013 | | \t | 水平制表(HT) （跳到下一个TAB位置） | 009 | | \v | 垂直制表(VT) | 011 | | \\ | 代表一个反斜线字符''\' | 092 | | \' | 代表一个单引号（撇号）字符 | 039 | | \" | 代表一个双引号字符 | 034 | | \0 | 空字符(NULL) | 000 | | \ddd | 1到3位八进制数所代表的任意字符 | 三位八进制 | | \xhh | 1到2位十六进制所代表的任意字符 | 二位十六进制 | ### 字符串操作 Lua 提供了很多的方法来支持字符串的操作： | 序号 | 方法 & 用途 | | :--- | :----------------------------------------------------------- | | 1 | **string.upper(argument):** 字符串全部转为大写字母。 | | 2 | **string.lower(argument):** 字符串全部转为小写字母。 | | 3 | **string.gsub(mainString,findString,replaceString,num)**在字符串中替换。mainString 为要操作的字符串， findString 为被替换的字符，replaceString 要替换的字符，num 替换次数（可以忽略，则全部替换），如：`> string.gsub("aaaa","a","z",3); zzza 3` | | 4 | **string.find (str, substr, [init, [end]])** 在一个指定的目标字符串中搜索指定的内容(第三个参数为索引),返回其具体位置。不存在则返回 nil。`> string.find("Hello Lua user", "Lua", 1) 7 9` | | 5 | **string.reverse(arg)** 字符串反转`> string.reverse("Lua") auL` | | 6 | **string.format(...)** 返回一个类似printf的格式化字符串`> string.format("the value is:%d",4) the value is:4` | | 7 | **string.char(arg) 和 string.byte(arg[,int])** char 将整型数字转成字符并连接， byte 转换字符为整数值(可以指定某个字符，默认第一个字符)。`> string.char(97,98,99,100) abcd > string.byte("ABCD",4) 68 > string.byte("ABCD") 65 >` | | 8 | **string.len(arg)** 计算字符串长度。`string.len("abc") 3` | | 9 | **string.rep(string, n)** 返回字符串string的n个拷贝`> string.rep("abcd",2) abcdabcd` | | 10 | **..** 链接两个字符串`> print("www.runoob.".."com") www.runoob.com` | | 11 | **string.gmatch(str, pattern)** 回一个迭代器函数，每一次调用这个函数，返回一个在字符串 str 找到的下一个符合 pattern 描述的子串。如果参数 pattern 描述的字符串没有找到，迭代函数返回nil。`> for word in string.gmatch("Hello Lua user", "%a+") do print(word) end Hello Lua user` | | 12 | **string.match(str, pattern, init)** string.match()只寻找源字串str中的第一个配对. 参数init可选, 指定搜寻过程的起点, 默认为1。 在成功配对时, 函数将返回配对表达式中的所有捕获结果; 如果没有设置捕获标记, 则返回整个配对字符串. 当没有成功的配对时, 返回nil。`> = string.match("I have 2 questions for you.", "%d+ %a+") 2 questions > = string.format("%d, %q", string.match("I have 2 questions for you.", "(%d+) (%a+)")) 2, "questions"` | ### 字符串截取 字符串截取使用 sub() 方法。 string.sub() 用于截取字符串，原型为： ```lua string.sub(s, i [, j]) ``` 参数说明： - s：要截取的字符串。 - i：截取开始位置。 - j：截取结束位置，默认为 -1，最后一个字符。 ### 字符串格式化 Lua 提供了 **string.format()** 函数来生成具有特定格式的字符串, 函数的第一个参数是格式 , 之后是对应格式中每个代号的各种数据。 由于格式字符串的存在, 使得产生的长字符串可读性大大提高了。这个函数的格式很像 C 语言中的 printf()。 以下实例演示了如何对字符串进行格式化操作： 格式字符串可能包含以下的转义码: - %c - 接受一个数字, 并将其转化为ASCII码表中对应的字符 - %d, %i - 接受一个数字并将其转化为有符号的整数格式 - %o - 接受一个数字并将其转化为八进制数格式 - %u - 接受一个数字并将其转化为无符号整数格式 - %x - 接受一个数字并将其转化为十六进制数格式, 使用小写字母 - %X - 接受一个数字并将其转化为十六进制数格式, 使用大写字母 - %e - 接受一个数字并将其转化为科学记数法格式, 使用小写字母e - %E - 接受一个数字并将其转化为科学记数法格式, 使用大写字母E - %f - 接受一个数字并将其转化为浮点数格式 - %g(%G) - 接受一个数字并将其转化为%e(%E, 对应%G)及%f中较短的一种格式 - %q - 接受一个字符串并将其转化为可安全被Lua编译器读入的格式 - %s - 接受一个字符串并按照给定的参数格式化该字符串 为进一步细化格式, 可以在%号后添加参数. 参数将以如下的顺序读入: - (1) 符号: 一个+号表示其后的数字转义符将让正数显示正号. 默认情况下只有负数显示符号. - (2) 占位符: 一个0, 在后面指定了字串宽度时占位用. 不填时的默认占位符是空格. - (3) 对齐标识: 在指定了字串宽度时, 默认为右对齐, 增加-号可以改为左对齐. - (4) 宽度数值 - (5) 小数位数/字串裁切: 在宽度数值后增加的小数部分n, 若后接f(浮点数转义符, 如%6.3f)则设定该浮点数的小数只保留n位, 若后接s(字符串转义符, 如%5.3s)则设定该字符串只显示前n位. ### 匹配模式 Lua 中的匹配模式直接用常规的字符串来描述。 它用于模式匹配函数 **string.find, string.gmatch, string.gsub, string.match**。 你还可以在模式串中使用字符类。 字符类指可以匹配一个特定字符集合内任何字符的模式项。比如，字符类 **%d** 匹配任意数字。所以你可以使用模式串 **%d%d/%d%d/%d%d%d%d** 搜索 **dd/mm/yyyy** 格式的日期： ## 实例 s = "Deadline is 30/05/1999, firm" date = "%d%d/%d%d/%d%d%d%d" print(string.sub(s, string.find(s, date))) *--> 30/05/1999* 下面的表列出了Lua支持的所有字符类： 单个字符(除 **^$()%.[]\*+-?** 外): 与该字符自身配对 - .(点): 与任何字符配对 - %a: 与任何字母配对 - %c: 与任何控制符配对(例如\n) - %d: 与任何数字配对 - %l: 与任何小写字母配对 - %p: 与任何标点(punctuation)配对 - %s: 与空白字符配对 - %u: 与任何大写字母配对 - %w: 与任何字母/数字配对 - %x: 与任何十六进制数配对 - %z: 与任何代表0的字符配对 - %x(此处x是非字母非数字字符): 与字符x配对. 主要用来处理表达式中有功能的字符(^$()%.[]*+-?)的配对问题, 例如%%与%配对 - [数个字符类]: 与任何[]中包含的字符类配对. 例如[%w_]与任何字母/数字, 或下划线符号(_)配对 - [^数个字符类]: 与任何不包含在[]中的字符类配对. 例如[^%s]与任何非空白字符配对 当上述的字符类用大写书写时, 表示与非此字符类的任何字符配对. 例如, %S表示与任何非空白字符配对.例如，'%A'非字母的字符: ``` > print(string.gsub("hello, up-down!", "%A", ".")) hello..up.down. 4 ``` 数字4不是字符串结果的一部分，他是gsub返回的第二个结果，代表发生替换的次数。 在模式匹配中有一些特殊字符，他们有特殊的意义，Lua中的特殊字符如下： ``` ( ) . % + - * ? [ ^ $ ``` '%' 用作特殊字符的转义字符，因此 '%.' 匹配点；'%%' 匹配字符 '%'。转义字符 '%'不仅可以用来转义特殊字符，还可以用于所有的非字母的字符。 **模式条目可以是：** - 单个字符类匹配该类别中任意单个字符； - 单个字符类跟一个 '`*`'， 将匹配零或多个该类的字符。 这个条目总是匹配尽可能长的串； - 单个字符类跟一个 '`+`'， 将匹配一或更多个该类的字符。 这个条目总是匹配尽可能长的串； - 单个字符类跟一个 '`-`'， 将匹配零或更多个该类的字符。 和 '`*`' 不同， 这个条目总是匹配尽可能短的串； - 单个字符类跟一个 '`?`'， 将匹配零或一个该类的字符。 只要有可能，它会匹配一个； - `%*n*`， 这里的 *n* 可以从 1 到 9； 这个条目匹配一个等于 *n* 号捕获物（后面有描述）的子串。 - `%b*xy*`， 这里的 *x* 和 *y* 是两个明确的字符； 这个条目匹配以 *x* 开始 *y* 结束， 且其中 *x* 和 *y* 保持 *平衡* 的字符串。 意思是，如果从左到右读这个字符串，对每次读到一个 *x* 就 *+1* ，读到一个 *y* 就 *-1*， 最终结束处的那个 *y* 是第一个记数到 0 的 *y*。 举个例子，条目 `%b()` 可以匹配到括号平衡的表达式。 - `%f[*set*]`， 指 *边境模式*； 这个条目会匹配到一个位于 *set* 内某个字符之前的一个空串， 且这个位置的前一个字符不属于 *set* 。 集合 *set* 的含义如前面所述。 匹配出的那个空串之开始和结束点的计算就看成该处有个字符 '`\0`' 一样。 **模式：** *模式* 指一个模式条目的序列。 在模式最前面加上符号 '`^`' 将锚定从字符串的开始处做匹配。 在模式最后面加上符号 '`$`' 将使匹配过程锚定到字符串的结尾。 如果 '`^`' 和 '`$`' 出现在其它位置，它们均没有特殊含义，只表示自身。 **捕获：** 模式可以在内部用小括号括起一个子模式； 这些子模式被称为 *捕获物*。 当匹配成功时，由 *捕获物* 匹配到的字符串中的子串被保存起来用于未来的用途。 捕获物以它们左括号的次序来编号。 例如，对于模式 `"(a*(.)%w(%s*))"` ， 字符串中匹配到 `"a*(.)%w(%s*)"` 的部分保存在第一个捕获物中 （因此是编号 1 ）； 由 "`.`" 匹配到的字符是 2 号捕获物， 匹配到 "`%s*`" 的那部分是 3 号。 作为一个特例，空的捕获 `()` 将捕获到当前字符串的位置（它是一个数字）。 例如，如果将模式 `"()aa()"` 作用到字符串 `"flaaap"` 上，将产生两个捕获物： 3 和 5 。 ## Lua 数组 数组，就是相同数据类型的元素按一定顺序排列的集合，可以是一维数组和多维数组。 Lua 数组的索引键值可以使用整数表示，数组的大小不是固定的。 ### 一维数组 一维数组是最简单的数组，其逻辑结构是线性表。一维数组可以用for循环出数组中的元素 ### 多维数组 多维数组即数组中包含数组或一维数组的索引键对应一个数组。 ## Lua 迭代器 迭代器（iterator）是一种对象，它能够用来遍历标准模板库容器中的部分或全部元素，每个迭代器对象代表容器中的确定的地址。 在 Lua 中迭代器是一种支持指针类型的结构，它可以遍历集合的每一个元素。 ### 泛型 for 迭代器 泛型 for 在自己内部保存迭代函数，实际上它保存三个值：迭代函数、状态常量、控制变量。 泛型 for 迭代器提供了集合的 key/value 对，语法格式如下： ```lua for k, v in pairs(t) do print(k, v) end ``` 上面代码中，k, v为变量列表；pairs(t)为表达式列表。 泛型 for 的执行过程： - 首先，初始化，计算 in 后面表达式的值，表达式应该返回泛型 for 需要的三个值：迭代函数、状态常量、控制变量；与多值赋值一样，如果表达式返回的结果个数不足三个会自动用 nil 补足，多出部分会被忽略。 - 第二，将状态常量和控制变量作为参数调用迭代函数（注意：对于 for 结构来说，状态常量没有用处，仅仅在初始化时获取他的值并传递给迭代函数）。 - 第三，将迭代函数返回的值赋给变量列表。 - 第四，如果返回的第一个值为nil循环结束，否则执行循环体。 - 第五，回到第二步再次调用迭代函数 在Lua中我们常常使用函数来描述迭代器，每次调用该函数就返回集合的下一个元素。Lua 的迭代器包含以下两种类型： - 无状态的迭代器 - 多状态的迭代器 ### 无状态的迭代器 无状态的迭代器是指不保留任何状态的迭代器，因此在循环中我们可以利用无状态迭代器避免创建闭包花费额外的代价。 每一次迭代，迭代函数都是用两个变量（状态常量和控制变量）的值作为参数被调用，一个无状态的迭代器只利用这两个值可以获取下一个元素。 这种无状态迭代器的典型的简单的例子是 ipairs，它遍历数组的每一个元素，元素的索引需要是数值。 以下实例我们使用了一个简单的函数来实现迭代器，实现 数字 n 的平方： ```lua function square(iteratorMaxCount,currentNumber) if currentNumber other = { foo = 3 } > t = setmetatable({}, { __index = other }) > t.foo 3 > t.bar nil ``` 如果*__index*包含一个函数的话，Lua就会调用那个函数，table和键会作为参数传递给函数。 *__index* 元方法查看表中元素是否存在，如果不存在，返回结果为 nil；如果存在则由 *__index* 返回结果。 ```lua mytable = setmetatable({key1 = "value1"}, { __index = function(mytable, key) if key == "key2" then return "metatablevalue" else return nil end end }) print(mytable.key1,mytable.key2) ``` 实例解析： - mytable 表赋值为 **{key1 = "value1"}**。 - mytable 设置了元表，元方法为 *__index*。 - 在mytable表中查找 key1，如果找到，返回该元素，找不到则继续。 - 在mytable表中查找 key2，如果找到，返回 metatablevalue，找不到则继续。 - 判断元表有没有*__index*方法，如果*__index*方法是一个函数，则调用该函数。 - 元方法中查看是否传入 "key2" 键的参数（mytable.key2已设置），如果传入 "key2" 参数返回 "metatablevalue"，否则返回 mytable 对应的键值。 #### 总结 Lua 查找一个表元素时的规则，其实就是如下 3 个步骤: - 1.在表中查找，如果找到，返回该元素，找不到则继续 - 2.判断该表是否有元表，如果没有元表，返回 nil，有元表则继续。 - 3.判断元表有没有 *__index* 方法，如果 *__index* 方法为 nil，则返回 nil；如果 *__index* 方法是一个表，则重复 1、2、3；如果 *__index* 方法是一个函数，则返回该函数的返回值。 该部分内容来自作者寰子：https://blog.csdn.net/xocoder/article/details/9028347 ### *__newindex* 元方法 *__newindex* 元方法用来对表更新，*__index*则用来对表访问 。 当你给表的一个缺少的索引赋值，解释器就会查找*__newindex* 元方法：如果存在则调用这个函数而不进行赋值操作。 以下实例演示了 __newindex 元方法的应用： ```lua mymetatable = {} mytable = setmetatable({key1 = "value1"}, { __newindex = mymetatable }) print(mytable.key1) mytable.newkey = "新值2" print(mytable.newkey,mymetatable.newkey) mytable.key1 = "新值1" print(mytable.key1,mymetatable.key1) ``` ### 为表添加操作符 ```lua -- 计算表中最大值，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,5,6} mytable = mytable + secondtable for k,v in ipairs(mytable) do print(k,v) end ``` *__add* 键包含在元表中，并进行相加操作。 表中对应的操作列表如下：(**注意：****__**是两个下划线) | 模式 | 描述 | | :------- | :----------------- | | __add | 对应的运算符 '+'. | | __sub | 对应的运算符 '-'. | | __mul | 对应的运算符 '*'. | | __div | 对应的运算符 '/'. | | __mod | 对应的运算符 '%'. | | __unm | 对应的运算符 '-'. | | __concat | 对应的运算符 '..'. | | __eq | 对应的运算符 '=='. | | __lt | 对应的运算符 '<'. | | __le | 对应的运算符 '<='. | ### *__call* 元方法 ```lua -- __call 元方法在 Lua 调用一个值时调用。以下实例演示了计算表中元素的和： -- 计算表中最大值，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 -- 定义元方法__call mytable = setmetatable({10}, { __call = function(mytable, newtable) sum = 0 for i = 1, table_maxn(mytable) do sum = sum + mytable[i] end for i = 1, table_maxn(newtable) do sum = sum + newtable[i] end return sum end }) newtable = {10,20,30} print(mytable(newtable)) ``` ### *__tostring* 元方法 ```lua -- __tostring 元方法用于修改表的输出行为。以下实例我们自定义了表的输出内容： mytable = setmetatable({ 10, 20, 30 }, { __tostring = function(mytable) sum = 0 for k, v in pairs(mytable) do sum = sum + v end return "表所有元素的和为 " .. sum end }) print(mytable) ``` ## Lua 协同程序(coroutine) ### 什么是协同(coroutine)？ Lua 协同程序(coroutine)与线程比较类似：拥有独立的堆栈，独立的局部变量，独立的指令指针，同时又与其它协同程序共享全局变量和其它大部分东西。 协同是非常强大的功能，但是用起来也很复杂。 ### 线程和协同程序区别 线程与协同程序的主要区别在于，一个具有多个线程的程序可以同时运行几个线程，而协同程序却需要彼此协作的运行。 在任一指定时刻只有一个协同程序在运行，并且这个正在运行的协同程序只有在明确的被要求挂起的时候才会被挂起。 协同程序有点类似同步的多线程，在等待同一个线程锁的几个线程有点类似协同。 ### 基本语法 | 方法 | 描述 | | :------------------ | :----------------------------------------------------------- | | coroutine.create() | 创建 coroutine，返回 coroutine， 参数是一个函数，当和 resume 配合使用的时候就唤醒函数调用 | | coroutine.resume() | 重启 coroutine，和 create 配合使用 | | coroutine.yield() | 挂起 coroutine，将 coroutine 设置为挂起状态，这个和 resume 配合使用能有很多有用的效果 | | coroutine.status() | 查看 coroutine 的状态 注：coroutine 的状态有三种：dead，suspended，running，具体什么时候有这样的状态请参考下面的程序 | | coroutine.wrap（） | 创建 coroutine，返回一个函数，一旦你调用这个函数，就进入 coroutine，和 create 功能重复 | | coroutine.running() | 返回正在跑的 coroutine，一个 coroutine 就是一个线程，当使用running的时候，就是返回一个 corouting 的线程号 | ## lua文件 I/O Lua I/O 库用于读取和处理文件。分为简单模式（和C一样）、完全模式。 - 简单模式（simple model）拥有一个当前输入文件和一个当前输出文件，并且提供针对这些文件相关的操作。 - 完全模式（complete model） 使用外部的文件句柄来实现。它以一种面对对象的形式，将所有的文件操作定义为文件句柄的方法 简单模式在做一些简单的文件操作时较为合适。但是在进行一些高级的文件操作的时候，简单模式就显得力不从心。例如同时读取多个文件这样的操作，使用完全模式则较为合适。 打开文件操作语句如下： ```lua file = io.open (filename [, mode]) ``` mode 的值有： | 模式 | 描述 | | :--- | :----------------------------------------------------------- | | r | 以只读方式打开文件，该文件必须存在。 | | w | 打开只写文件，若文件存在则文件长度清为0，即该文件内容会消失。若文件不存在则建立该文件。 | | a | 以附加的方式打开只写文件。若文件不存在，则会建立该文件，如果文件存在，写入的数据会被加到文件尾，即文件原先的内容会被保留。（EOF符保留） | | r+ | 以可读写方式打开文件，该文件必须存在。 | | w+ | 打开可读写文件，若文件存在则文件长度清为零，即该文件内容会消失。若文件不存在则建立该文件。 | | a+ | 与a类似，但此文件可读可写 | | b | 二进制模式，如果文件是二进制文件，可以加上b | | + | 号表示对文件既可以读也可以写 | ### io.read() 中 read() 的参数 | 模式 | 描述 | | :----------- | :----------------------------------------------------------- | | "*n" | 读取一个数字并返回它。例：file.read("*n") | | "*a" | 从当前位置读取整个文件。例：file.read("*a") | | "*l"（默认） | 读取下一行，在文件尾 (EOF) 处返回 nil。例：file.read("*l") | | number | 返回一个指定字符个数的字符串，或在 EOF 时返回 nil。例：file.read(5) | 其他的 io 方法有： - **io.tmpfile():**返回一个临时文件句柄，该文件以更新模式打开，程序结束时自动删除 - **io.type(file):** 检测obj是否一个可用的文件句柄 - **io.flush():** 向文件写入缓冲中的所有数据 - **io.lines(optional file name):** 返回一个迭代函数,每次调用将获得文件中的一行内容,当到文件尾时，将返回nil,但不关闭文件 ### 完全模式 通常我们需要在同一时间处理多个文件。我们需要使用 file:function_name 来代替 io.function_name 方法。 ```lua -- 以只读方式打开文件 file = io.open("test.lua", "r") -- 输出文件第一行 print(file:read()) -- 关闭打开的文件 file:close() -- 以附加的方式打开只写文件 file = io.open("test.lua", "a") -- 在文件最后一行添加 Lua 注释 file:write("--test") -- 关闭打开的文件 file:close() ``` * read 的参数与简单模式一致。 * 其他方法: - **file:seek(optional whence, optional offset):** 设置和获取当前文件位置,成功则返回最终的文件位置(按字节),失败则返回nil加错误信息。参数 whence 值可以是: - "set": 从文件头开始 - "cur": 从当前位置开始[默认] - "end": 从文件尾开始 - offset:默认为0 不带参数file:seek()则返回当前位置,file:seek("set")则定位到文件头,file:seek("end")则定位到文件尾并返回文件大小 - **file:flush():** 向文件写入缓冲中的所有数据 - **io.lines(optional file name):** 打开指定的文件filename为读模式并返回一个迭代函数,每次调用将获得文件中的一行内容,当到文件尾时，将返回nil,并自动关闭文件。 若不带参数时io.lines() <=> io.input():lines(); 读取默认输入设备的内容，但结束时不关闭文件,如： ```lua for line in io.lines("main.lua") do 　　print(line) end ``` 以下实例使用了 seek 方法，定位到文件倒数第 25 个位置并使用 read 方法的 *a 参数，即从当期位置(倒数第 25 个位置)读取整个文件。 ```lua -- 以只读方式打开文件 file = io.open("test.lua", "r") file:seek("end",-25) print(file:read("*a")) -- 关闭打开的文件 file:close() ``` ## lua 中 方法调用时 . 与 ： 区别 首先在lua中使用“:”定义的函数会自动传入一个名为self的变量，这个变量是隐含的，self同c++中的this一样，表示当前对象的指针：而“.”定义的函数中没有self。 见： https://blog.csdn.net/baidu_35080512/article/details/85857739 ```lua row = cur:fetch({},"a") row = cur.fetch(cur, {},"a") -- 两种方法相同 ```