devbox
代码探险家
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Lua 入门详情讲解

作者：代码探险家 | 2024-07-21 01:13:46

赞

踩

lua

一、Lua的介绍

Lua 语音是由巴西里约热内卢天主教大学 ([Pontifical Catholic University of Rio de janeiro ) 里的一个研究小组与 1993年开发的一种轻量小巧的脚本（弱语言）语言，用标准 C 语音编写，其设计目的是为了嵌入应用程序中，从而为应用程序提供灵活的扩展和定制功能。

作为一种扩展语言，Lua 没有“主”程序的概念：它嵌入在宿主客户端中运行，称为嵌入程序或简称为宿主。（通常这个宿主是单机lua程序。） 宿主程序可以调用函数执行一段Lua代码，可以读写Lua变量，可以注册Lua代码调用的C函数。通过使用 C 函数，可以增强 Lua 以应对广泛的不同领域，从而创建共享语法框架的定制编程语言。

Lua适合一些简单的功能，不适合大量功能模块开发，Lua因为本身比较小巧，所以在开发会带来一些缺陷，比如测试的需要基于基于web环境 。

官网：http://www.lua.org/

二、环境配置

Lua 是基于 Lualuaiit的环境运行的，安装方式有很多中，可以直接在系统配置lua的运行时环境，也可以基于 IDE 的方式使用。

2.1 系统环境安装

（1）windwos安装

下载地址 ： https://luabinaries.sourceforge.net/

  • 1.下载 lua-5.4.2_Win64_bin.zip 文件

  • 2. 将文件解压。

  • 3. 将解压后的文件到一个没有中文路径的盘符下，如 ： D:/Lua

  • 4. 配置环境变量 右击此电脑 => 属性 => 高级系统设置=> 环境变量 => 系统变量 or 用户变量 => Path 里面添加上 lua文件

  • 5.测试 cmd => lua 54

（2）linux安装

  1.  
  2. curl -R -O http://www.lua.org/ftp/lua-5.3.0.tar.gz
  3. tar zxf lua-5.3.0.tar.gz
  4. cd lua-5.3.0
  5. make linux test
  6. make install

执行到sudo make linux test报错fatal error: readline/readline.h: No such file or directory

因为这个问题是缺少readline相关的库才导致的，遂安装libreadline-dev

yum install readline-devel

默认装在了 /usr/local/lib下。

2.2 基于idea安装

EmmyLua插件

https://github.com/EmmyLua/IntelliJ-EmmyLua

https://emmylua.github.io/zh_CN/

LDT 基于eclipse

https://www.eclipse.org/ldt/

2.3 内嵌式

比如在使用 Nginx的 openresty时就不需要配置，openresty内嵌了。

三、Lua 基础语法

3.1 交互式编程

Lua 提供了交互式变成模式，我们可以在命令行中输入程序代码并立刻看到效果

Lua 交互式编程模式可以通过命令 lua -i 或 lua 启动

3.2 脚本式编程

我们可以将 Lua 程序代码保存到一个以 lua 结尾的文件，并执行，该模式称为脚本式编程，如我们将如下代码存储在名为 hello.lua 的脚本文件中：

  1.  
  2. print("Hello world !")

我们也可以将代码修改为如下形式来执行脚本（在开头添加：#!/usr/local/bin/lua）：

  1. #!/usr/local/bin/lua
  2.  
  3. print("Hello World！")

3.3 注释

  1. -- 两个减号是行注释
  2.  
  3. --[[
  4.  
  5.  这是块注释
  6.  
  7.  这是块注释.
  8.  
  9.  --]]       

3.4 标识符

Lua 标示符用于定义一个变量，函数获取其他用户定义的项。标示符以一个字母 A 到 Z 或 a 到 z 或下划线 _ 开头后加上 0 个或多个字母，下划线，数字（0 到 9）。

最好不要使用下划线加大写字母的标示符，因为Lua的保留字也是这样的。

Lua 不允许使用特殊字符如 @, $, 和 % 来定义标示符。 Lua 是一个区分大小写的编程语言。因此在 Lua 中 Runoob 与 runoob 是两个不同的标示符。以下列出了一些正确的标示符：

  1. mohd         zara      abc     move_name    a_123
  2. myname50     _temp     j       a23b9        retVal

3.5 关键字

以下列出了 Lua 的保留关键词。保留关键字不能作为常量或变量或其他用户自定义标示符：

and

break

do

else

elseif

end

false

for

function

if

in

local

nil

not

or

repeat

return

then

true

until

while

goto

一般约定，以下划线开头连接一串大写字母的名字（比如 _VERSION）被保留用于 Lua 内部全局变量。

四、Lua的数据类型

Lua 是动态类型语言，变量不要类型定义,只需要为变量赋值。 值可以存储在变量中，作为参数传递或结果返回。

Lua 中有 8 个基本类型分别为：nil、boolean、number、string、userdata、function、thread 和 table。

数据类型

描述

nil

这个最简单，只有值nil属于该类，表示一个无效值（在条件表达式中相当于false）。

boolean

包含两个值：false和true。

number

表示双精度类型的实浮点数

string

字符串由一对双引号或单引号来表示

function

由 C 或 Lua 编写的函数

userdata

表示任意存储在变量中的C数据结构

thread

表示执行的独立线路，用于执行协同程序

table

Lua 中的表（table）其实是一个"关联数组"（associative arrays），数组的索引可以是数字、字符串或表类型。在 Lua 里，table 的创建是通过"构造表达式"来完成，最简单构造表达式是{}，用来创建一个空表。

可以通过 type函数来测试变量或值的类型：

  1. print(type("Hello world"))      --> string
  2. print(type(10.4*3))             --> number
  3. print(type(print))              --> function
  4. print(type(type))               --> function
  5. print(type(true))               --> boolean
  6. print(type(nil))                --> nil
  7. print(type(type(X)))            --> string

4.1 数字类型

Lua的数字只有double型，64bits

你可以以如下的方式表示数字

  1.  
  2. num = 1024
  3.  
  4. num = 3.0
  5.  
  6. num = 3.1416
  7.  
  8. num = 314.16e-2
  9.  
  10. num = 0.31416E1
  11.  
  12. num = 0xff
  13.  
  14. num = 0x56

4.2 字符串

也可以使用转义字符‘\n’ （换行）， ‘\r’ （回车）， ‘\t’ （横向制表）， ‘\v’ （纵向制表）， ‘\’ （反斜杠）， ‘\”‘ （双引号）， 以及 ‘\” （单引号)等等

下面的四种方式定义了完全相同的字符串（其中的两个中括号可以用于定义有换行的字符串）

字符串由一对双引号或单引号来表示。

  1. a = 'alo\n123"'
  2.  
  3. a = "alo\n123\""
  4.  
  5. a = '\97lo\10\04923"'
  6.  
  7. a = [[alo
  9. 123"]]

也可以用 2 个方括号 "[[]]" 来表示"一块"字符串。

  1. html = [[
  2. <html>
  3. <head></head>
  4. <body>
  5.     <a href="www.baidu.com/">baidu</a>
  6. </body>
  7. </html>
  8. ]]
  9. print(html)

在对一个数字字符串上进行算术操作时，Lua 会尝试将这个数字字符串转成一个数字:

  1. > print("2" + 6)
  2. 8.0
  3. > print("2" + "6")
  4. 8.0
  5. > print("2 + 6")
  6. 2 + 6
  7. > print("-2e2" * "6")
  8. -1200.0
  9.  
  10. # 一下报错因为字符串连接 使用 .. 
  11. > print("error" + 1)
  12. stdin:1: attempt to perform arithmetic on a string value
  13. stack traceback:
  14.         stdin:1: in main chunk
  15.         [C]: in ?
  16. >

字符串之间连接

.. 作为连接符 

print("name:" .. "zs")

使用 # 来计算字符串字节的长度（一个中文算两个字节），放在字符串前面，如下实例：

  1. > len = "www.baidu.com"
  2. > print(#len)
  3. 14
  4. > print(#"www.baidu.com")
  5. 14
  6. >

4.3 table(表)

在 Lua 里，table 的创建是通过"构造表达式"来完成，最简单构造表达式是{}，用来创建一个空表。也可以在表里添加一些数据，直接初始化表：

  1. -- 创建一个空的 table
  2. local tbl1 = {}
  3.  
  4. -- 直接初始表
  5. local tbl2 = {"apple", "pear", "orange", "grape"}

Lua 中的表（table）其实是一个"关联数组"（associative arrays），数组的索引可以是数字或者是字符串。

  1. -- table_test.lua 脚本文件
  2. a = {}
  3. a["key"] = "value"
  4. key = 10
  5. a[key] = 22
  6. a[key] = a[key] + 11
  7. for k, v in pairs(a) do
  8.     print(k .. " : " .. v)
  9. end
  10.  
  11. -- 一个table 中是可以以数字和字符串为下标，也可以配合使用但是配置使用的话，又可以把字符串的下标
  12. -- 看做是属性。
  13. a = {"22","233"}
  14. a["key"] = "value"
  15.  
  16. for k, v in pairs(a) do
  17.     print(k .. ":".. v)
  18. end
  19.  
  20. --[[ 
  21. 结果 ：
  22.     1:22
  23.   2:233
  24.   key:value
  25. 1]]

不同于其他语言的数组把 0 作为数组的初始索引，在 Lua 里表的默认初始索引一般以 1 开始。

  1. -- table_test2.lua 脚本文件
  2. local tbl = {"apple", "pear", "orange", "grape"}
  3. for key, val in pairs(tbl) do
  4.     print("Key", key)
  5. end

table 不会固定长度大小，有新数据添加时 table 长度会自动增长，没初始的 table 都是 nil。

  1. -- table_test3.lua 脚本文件
  2. a3 = {}
  3. for i = 1, 10 do
  4.     a3[i] = i
  5. end
  6. a3["key"] = "val"
  7. print(a3["key"])
  8. print(a3["none"])

4.4 function

在 Lua 中，函数是被看作是"第一类值（First-Class Value）"，函数可以存在变量里。

  1. -- function_test.lua 脚本文件
  2. function factorial1(n)
  3.     if n == 0 then
  4.         return 1
  5.     else
  6.         return n * factorial1(n - 1)
  7.     end
  8. end
  9. print(factorial1(5))
  10. -- 将函数 复制给另一个函数 
  11. factorial2 = factorial1
  12.  
  13. print(factorial2(5))
  14.  
  15.  
  16. --[[
  17.     结果 ：
  18.       120
  19.         120
  20. ]]

function 可以以匿名函数（anonymous function）的方式通过参数传递:

  1. -- 参数为function 匿名函数
  2. function doSome(tab,fun)
  3.     for i,v in pairs(tab) do
  4.         -- 调用传递过来的匿名函数
  5.         fun(i,v);
  6.     end
  7. end
  8. array= {1,2,3,4}
  9. doSome(array,function(i,v)
  10.     print("下标: "..i.." : ".."值:"..v)
  11. end)

4.5 nil (空)

nil 作比较时应该加上双引号 "：

  1. > type(X)
  2. nil
  3. > type(X)==nil
  4. false
  5. > type(X)=="nil"
  6. true
  7. >
  8. -- type(X)==nil 结果为 false 的原因是 type(X) 实质是返回的 "nil" 字符串，是一个 string 类型：
  9. type(type(X))==string

nil 类型表示一种没有任何有效值，它只有一个值 -- nil，例如打印一个没有赋值的变量，便会输出一个 nil 值：

print(a)

对于全局变量和 table，nil 还有一个"删除"作用，给全局变量或者 table 表里的变量赋一个 nil 值，等同于把它们删掉，执行下面代码就知：

  1. list = {key1 = "1",key2="2",key3="3"}
  2. for k ,v in pairs(list) do
  3.     print(k ..":" .. v )
  4. end
  5. -- 将key1 删除 
  6. list.key1=nil
  7. for k ,v in pairs(list) do
  8.     print(k ..":" .. v )
  9. end

4.6 boolean

boolean 类型只有两个可选值：true（真） 和 false（假），Lua 把 false 和 nil 看作是 false，其他的都为 true，数字 0 也是 true:

4.7 thread

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

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

4.8 userdata

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

五、变量

变量在使用前，需要在代码中进行声明，即创建该变量。

编译程序执行代码之前编译器需要知道如何给语句变量开辟存储区，用于存储变量的值。

Lua 变量有三种类型：全局变量、局部变量、表中的域。

全局变量是在同一模块内可以互通使用。

Lua 中的变量全是全局变量，哪怕是语句块或是函数里，除非用 local 显式声明为局部变量。

局部变量的作用域为从声明位置开始到所在语句块结束。

变量的默认值均为 nil。

  1.  
  2. a = 5               -- 全局变量
  3. local b = 5         -- 局部变量
  4.  
  5. function joke()
  6.     c = 5           -- 全局变量
  7.     local d = 6     -- 局部变量
  8. end
  9.  
  10. joke()
  11. print(c,d)          --> 5 nil
  12.  
  13. do
  14.     local a = 6     -- 局部变量
  15.     b = 6           -- 对局部变量重新赋值
  16.     print(a,b);     --> 6 6
  17. end
  18.  
  19. print(a,b)      --> 5 6

当变量个数和值的个数不一致时，Lua会一直以变量个数为基础采取以下策略：

  1. a. 变量个数 > 值的个数             按变量个数补足nil
  2. b. 变量个数 < 值的个数             多余的值会被忽略

5.1 索引

对 table 的索引使用方括号 []。Lua 也提供了 . 操作。

  1. t[i]
  2. t.i                 -- 当索引为字符串类型时的一种简化写法
  3. gettable_event(t,i) -- 采用索引访问本质上是一个类似这样的函数调用

六、流程控制

Lua 编程语言流程控制语句通过程序设定一个或多个条件语句来设定。在条件为 true 时执行指定程序代码，在条件为 false 时执行其他指定代码。

以下是典型的流程控制流程图：

控制结构的条件表达式结果可以是任何值，Lua认为false和nil为假，true和非nil为真。

要注意的是Lua中 0 为 true：

  1. --[ 0 为 true ]
  2. if(0)
  3. then
  4.     print("0 为 true")
  5. end
  6.  
  7. -- 结果： 0 为 true

Lua 提供一下控制结构语句功能：

if 语句

if 语句 由一个布尔表达式作为条件判断，其后紧跟其他语句组成。

if...else 语句

if 语句 可以与 else 语句搭配使用, 在 if 条件表达式为 false 时执行 else 语句代码。

if 嵌套语句

你可以在if 或 else if中使用一个或多个 if 或 else if 语句

6.1 if语句

Lua if 语句 由一个布尔表达式作为条件判断，其后紧跟其他语句组成。

  1. if(布尔表达式)
  2. then
  3.    --[ 在布尔表达式为 true 时执行的语句 --]
  4. end
  5.  
  6. --- 实例 ---------
  7.  
  8.  
  9. --[ 定义变量 --]
  10. a = 10;
  11.  
  12. --[ 使用 if 语句 --]
  13. if( a < 20 )
  14. then
  15.    --[ if 条件为 true 时打印以下信息 --]
  16.    print("a 小于 20" );
  17. end
  18. print("a 的值为:", a);

6.2 if..else

Lua if 语句可以与 else 语句搭配使用, 在 if 条件表达式为 false 时执行 else 语句代码块。

Lua if...else 语句语法格式如下：

  1. if(布尔表达式)
  2. then
  3.    --[ 布尔表达式为 true 时执行该语句块 --]
  4. else
  5.    --[ 布尔表达式为 false 时执行该语句块 --]
  6. end
  7.  
  8.  
  9.  
  10. -----------------------实例-------------------------------
  11. --[ 定义变量 --]
  12. a = 100;
  13. --[ 检查条件 --]
  14. if( a < 20 )
  15. then
  16.    --[ if 条件为 true 时执行该语句块 --]
  17.    print("a 小于 20" )
  18. else
  19.    --[ if 条件为 false 时执行该语句块 --]
  20.    print("a 大于 20" )
  21. end
  22. print("a 的值为 :", a)

6.3 if嵌套

Lua if 语句允许嵌套, 这就意味着你可以在一个 if 或 else if 语句中插入其他的 if 或 else if 语句。

  1. if( 布尔表达式 1)
  2. then
  3.    --[ 布尔表达式 1 为 true 时执行该语句块 --]
  4.    if(布尔表达式 2)
  5.    then
  6.       --[ 布尔表达式 2 为 true 时执行该语句块 --]
  7.    end
  8. end
  9.  
  10.  
  11.  
  12. -------------示例-----------------
  13.  
  14. --[ 定义变量 --]
  15. a = 100;
  16. b = 200;
  17.  
  18. --[ 检查条件 --]
  19. if( a == 100 )
  20. then
  21.    --[ if 条件为 true 时执行以下 if 条件判断 --]
  22.    if( b == 200 )
  23.    then
  24.       --[ if 条件为 true 时执行该语句块 --]
  25.       print("a 的值为 100 b 的值为 200" );
  26.    end
  27. end
  28. print("a 的值为 :", a );
  29. print("b 的值为 :", b );
  1. local function main()
  2.  
  3.  
  4. local age = 140
  5.  
  6. local sex = 'Male'
  7.  
  8.  
  9.   if age == 40 and sex =="Male" then
  10.     print(" 男人四十一枝花 ")
  11.   elseif age > 60 and sex ~="Female" then
  12.    
  13.     print("old man!!")
  14.   elseif age < 20 then
  15.     io.write("too young, too simple!\n")
  16.   
  17.   else
  18.   print("Your age is "..age)
  19.   end
  20.  
  21. end
  22.  
  23.  
  24. -- 调用
  25. main()

七、循环

很多情况下我们需要做一些有规律性的重复操作，因此在程序中就需要重复执行某些语句。

一组被重复执行的语句称之为循环体，能否继续重复，决定循环的终止条件。

循环结构是在一定条件下反复执行某段程序的流程结构，被反复执行的程序被称为循环体。

循环语句是由循环体及循环的终止条件两部分组成的。

7.1 控制语句

循环控制语句用于控制程序的流程， 以实现程序的各种结构方式。

Lua 支持以下循环控制语句：

控制语句

描述

break 语句

退出当前循环或语句，并开始脚本执行紧接着的语句。

goto 语句

将程序的控制点转移到一个标签处。

（1）break 语句

Lua 编程语言 break 语句插入在循环体中，用于退出当前循环或语句，并开始脚本执行紧接着的语句。

如果你使用循环嵌套，break语句将停止最内层循环的执行，并开始执行的外层的循环语句。

break

实例

以下实例执行 while 循环，在变量 a 小于 20 时输出 a 的值，并在 a 大于 15 时终止执行循环：

  1. --[ 定义变量 --]
  2. a = 10
  3.  
  4. --[ while 循环 --]
  5. while( a < 20 )
  6. do
  7.    print("a 的值为:", a)
  8.    a=a+1
  9.    if( a > 15)
  10.    then
  11.       --[ 使用 break 语句终止循环 --]
  12.       break
  13.    end
  14. end

（2）goto

Lua 语言中的 goto 语句允许将控制流程无条件地转到被标记的语句处。

这个需要提前打好标记，再能跳转。

语法有问题

语法：

  1. goto Lable 
  2.  
  3.  
  4. -- Lable 的格式 
  5. :: Lable :: 
  6.

7.2 循环

Lua 语言提供了以下几种循环处理方式：

循环类型

描述

while 循环

在条件为 true 时，让程序重复地执行某些语句。执行语句前会先检查条件是否为 true。

for 循环

重复执行指定语句，重复次数可在 for 语句中控制。

repeat...until

重复执行循环，直到 指定的条件为真时为止

循环嵌套

可以在循环内嵌套一个或多个循环语句（while do ... end;for ... do ... end;repeat ... until;）

（1）while循环

  1. while(condition)
  2. do
  3.    statements
  4. end

statements(循环体语句) 可以是一条或多条语句，condition(条件) 可以是任意表达式，在 condition(条件) 为 true 时执行循环体语句。

  1. local i = 0
  2.  
  3. local max = 10
  4.  
  5. while i <= max do
  6.  
  7. print(i)
  8.  
  9. i = i +1
  10.  
  11. end

（2）for循环

Lua 编程语言中 for 循环语句可以重复执行指定语句，重复次数可在 for 语句中控制。

Lua 编程语言中 for语句有两大类：：

  • 数值for循环

  • 泛型for循环

  1. for var=exp1,exp2,exp3 do  
  2.     <执行体>  
  3. end  
  1. for i=1,f(x) do
  2.     print(i)
  3. end
  4.  
  5. for i=10,1,-1 do
  6.     print(i)
  7. end

for的三个表达式在循环开始前一次性求值，以后不再进行求值。比如上面的f(x)只会在循环开始前执行一次，其结果用在后面的循环中。

验证如下:

  1. #!/usr/local/bin/lua  
  2. function f(x)  
  3.     print("function")  
  4.     return x*2  
  5. end  
  6. for i=1,f(5) do print(i)  
  7. end

泛型for循环

泛型 for 循环通过一个迭代器函数来遍历所有值，类似 java 中的 foreach 语句。

Lua 编程语言中泛型 for 循环语法格式:

ipairs ：进行循环的时候要求 下标是数组，否则循环不到

pairs :可以循环任意类型的下标数组。

  1. --打印数组a的所有值  
  2. a = {"one", "two", "three"}
  3. for i, v in ipairs(a) do
  4.     print(i, v)
  5. end

（3）repeat...until 循环

Lua 编程语言中 repeat...until 循环语句不同于 for 和 while循环，for 和 while 循环的条件语句在当前循环执行开始时判断，而 repeat...until 循环的条件语句在当前循环结束后判断。

  1. repeat
  2.    statements
  3. until( condition )
  1. --[ 变量定义 --]
  2. a = 10
  3. --[ 执行循环 --]
  4. repeat
  5.    print("a的值为:", a)
  6.    a = a + 1
  7. until( a > 15 )

八、函数

在Lua中，函数是对语句和表达式进行抽象的主要方法。既可以用来处理一些特殊的工作，也可以用来计算一些值。

Lua 提供了许多的内建函数，你可以很方便的在程序中调用它们，如print()函数可以将传入的参数打印在控制台上。

Lua 函数主要有两种用途：

  • 1.完成指定的任务，这种情况下函数作为调用语句使用；

  • 2.计算并返回值，这种情况下函数作为赋值语句的表达式使用。

8.1 闭包和upvalue

首先 闭包和 upvalue 的是一种概念。

闭包就是能够读取其他函数内部变量的函数。

例如在JavaScript中，只有函数内部的子函数才能读取局部变量，所以闭包可以理解成“定义在一个函数内部的函数”。在本质上，闭包是将函数内部的和函数外部连接的桥梁。

Lua

当一个函数内部签到另一个函数定义时，内部的函数可以访问外部的局部变量，这种特征在lua中我们称作词法定界。

Lua 会将函数的局部变量和其使用到的非局部变量存储在一个称为“upvalue”的结构中。当函数执行时，它可以访问这些非局部变量，即使这些变量在函数执行时已经不再存在。

虽然这种看起来很清楚，事实并非如此，词法定界加上第一类函数在编程语言中是一个强大的概念，很少语言提供这种支持。

  1. -- 一下就是一个闭包函数 
  2. function newCounter()
  3.  
  4.    local i = 0 
  5.    return function()     -- anonymous function
  6.  
  7.         i = i + 1
  8.  
  9.         return i
  10.  
  11.     end
  12. end
  13.  
  14.  
  15.  
  16. c1 = newCounter()
  17.  
  18. print(c1())  --> 1
  19.  
  20. print(c1())  --> 2
  21.  
  22. print(c1())
  23.  
  24.  
  25.  
  26.  
  27.  
  28.  
  29.  
  30.  
  31. ----------
  32. function fun1(x,y) 
  33.     local a = 1 ;  -- 类似于静态变量 upValue
  34.     return function()
  35.         a = a+1 ;
  36.         print(a,x,y)
  37.         return a
  38.     end
  39. end
  40.  
  41. fun= fun1(1,2)
  42. print(fun())
  43. print(fun())
  44. print(fun())

upvalue是让lua来模拟实现，类似c语言中，静态变量机制的一种机制。一个带上upvalue的函数，我们称之为闭包(closure)。一个c函数，带上upvalue的结构，我们称之为c闭包。而一个lua函数，带上upvalue，我们称之为lua闭包。我们可以看一下官方对于upvalue相关内容的阐述。

在 Lua 中，Upvalue（上值）指的是在闭包中使用的外部局部变量。具体来说，当一个函数嵌套在另一个函数中时，它可以访问其父函数的局部变量。在 Lua 中，这些局部变量被称为Upvalue。
当一个函数返回时，它的局部变量通常会被释放，但是如果有内部函数（即闭包）使用了这些变量，那么它们就会被存储在该闭包的Upvalue中，以便在闭包被调用时仍然可以访问它们。 
  1. local upval = 1
  2. local upval2 = 2
  3. function test()
  4.     local locvar = 3
  5.     print(upval)
  6.  
  7.     local function aaa()
  8.         print(upval+upval2+locvar)
  9.     end
  10.     aaa()
  11. end
  12.  
  13.  
  14.  
  15.  
  16. --[[
  17. 上面这个例子中，test函数的外层，一共有两个变量，upval和upval2。
  18. test函数内，有一行打印upval的代码，因为有这个操作，test函数需要引用到外层函数的upval这个变量，
  19. 因此upval是test函数的一个upvavle。而上面这个例子，在test函数内，
  20. 又定义了一个aaa函数，在aaa函数内，因为使用了upval、upval2和locvar几个变量，
  21. 因此aaa函数的upvalue有upval、upval2和locvar。由于aaa是test的内层定义的函数，
  22. test是aaa的外层函数，因此test函数的upvalue也包括了，upval、upval2。现在，
  23. 只是给大家一个直观的概念，其实很多读者对此已经耳熟能详了，在后面的章节内容中，
  24. 我会更细致地论述这个机制的原理。

8.2 函数定义

Lua 编程语言函数定义格式如下：

  1. optional_function_scope function function_name( argument1, argument2, argument3..., argumentn)
  2.     function_body
  3.     return result_params_comma_separated
  4. end

解析：

  • optional_function_scope：

  • 该参数是可选的指定函数是全局函数还是局部函数，未设置该参数则为全局函数，如果需要设置为局部函数则 需要使用 local 关键字 。

  • function_name ：

  • 指定函数，可以是匿名函数

  • argument1, argument2 ....

  • 函数参数，多个参数之间使用 , 割开 ，也可以不带参数

  • function_body ：

  • 函数体，函数中需要执行的代码块语句

  • result_params_comma_separated：

  • 函数返回值，Lua 语言支持多结果返回 ，多值之间使用，割开。 

  1. -------------Lua 中我们可以将函数作为参数传递给函数，如下实例：-------------------
  2. myprint = function(param)
  3.    print("这是打印函数 -   ##",param,"##")
  4. end
  5.  
  6. function add(num1,num2,functionPrint)
  7.    result = num1 + num2
  8.    -- 调用传递的函数参数
  9.    functionPrint(result)
  10. end
  11. myprint(10)
  12. -- myprint 函数作为参数传递
  13. add(2,5,myprint)

8.3 多值返回

Lua函数可以返回多个结果值，比如string.find，其返回匹配串"开始和结束的下标"（如果不存在匹配串返回nil）。

  1.  startIndex, endIndex = string.find("www.runoob.com", "runoob") 
  2. print(startIndex, endIndex)
  3. 5    10

Lua函数中，在return后列出要返回的值的列表即可返回多值，如：

  1. function maximum (a)
  2.     local mi = 1             -- 最大值索引
  3.     local m = a[mi]          -- 最大值
  4.     for i,val in ipairs(a) do
  5.        if val > m then
  6.            mi = i
  7.            m = val
  8.        end
  9.     end
  10.     return m, mi
  11. end
  12.  
  13. print(maximum({8,10,23,12,5}))

8.4 可变参数

Lua 函数可以接收可变数量的参数，和 java 的可变参数很想，在函数裂变中使用三点 ...表示函数有可变的参数 。 

  1. function add(...)  
  2. local s = 0  
  3.   for i, v in ipairs{...} do   --> {...} 表示一个由所有变长参数构成的数组  
  4.     s = s + v  
  5.   end  
  6.   return s  
  7. end  
  8. print(add(3,4,5,6,7))  --->25

我们也可以通过 select("#",...) 来获取可变参数的数量:

  1. function average(...)
  2.    result = 0
  3.    local arg={...}
  4.    for i,v in ipairs(arg) do
  5.       result = result + v
  6.    end
  7.    print("总共传入 " .. select("#",...) .. " 个数")
  8.    return result/select("#",...)
  9. end
  10.  
  11. print("平均值为",average(10,5,3,4,5,6))

有时候我们可能需要几个固定参数加上可变参数，固定参数必须放在变长参数之前:

  1. function fwrite(fmt, ...)  ---> 固定的参数fmt
  2.     return io.write(string.format(fmt, ...))    
  3. end
  4.  
  5. fwrite("runoob\n")       --->fmt = "runoob", 没有变长参数。  
  6. fwrite("%d%d\n", 1, 2)   --->fmt = "%d%d", 变长参数为 1 和 2

常在遍历变长参数的时候只需要使用 {…}，然而变长参数可能会包含一些 nil，那么就可以用 select 函数来访问变长参数了：select('#', …) 或者 select(n, …)

  • select('#', …) 返回可变参数的长度。

  • select(n, …) 用于返回从起点 n 开始到结束位置的所有参数列表。

调用 select 时，必须传入一个固定实参 selector(选择开关) 和一系列变长参数。如果 selector 为数字 n，那么 select 返回参数列表中从索引 n 开始到结束位置的所有参数列表，否则只能为字符串 #，这样 select 返回变长参数的总数。

  1. function f(...)
  2.     a = select(3,...)  -->从第三个位置开始，变量 a 对应右边变量列表的第一个参数
  3.     print (a)
  4.     print (select(3,...)) -->打印所有列表参数
  5. end
  6.  
  7. f(0,1,2,3,4,5)
注意事项：
如果，没有"尾调用消除" 的话，每次用户的移动会创建一个新的 stack ，若干步之后就有可能导致栈移除的风险 。
在Lua 中支持这样一种 函数调用的优化，即" 尾调用消除"。我们可以将这种函数方式是为 goto 语句 ，
如：function f (x) return g(x) end
由于g(x) 函数 是f(x) 的最后一条语句，在函数 g 返回之后，f() 函数将没有任何指令需要被执行，因此在函数g() 返回时，可以直接返回到 f() 函数的调用点。由此可见，Lua 解释器一旦发现 g() 函数的尾调用，那么在调用 g() 是将不会产生音函数调用而引擎的栈开销。这里需要强调的是，尾调用函数一定是其调用函数的最后一条语句，否则 Lua 不会进行优化。然而事实上，我们在很多看似是尾调用的场景中，并不是真正的为尾调用，如：
function f(x) g(x) end -- 没有return语句的明确提示
function f(x) return g(x) +1 -- 在 g() 函数返回之后让扔需要执行一次加一的指令。
function f(x) return x or g(x) -- 如果g() 函数返回多个值，该操作会强制要求 g() 函数只返回一个值。
function f(x) return (g(x)) --原因同上。
在Lua中，只有 "return <func>(<args>) " 形式才是标准的尾调用，至于参数中的(args) 是否包含表达式，由于表达式的执行是在函数调用之前完成的，隐藏不会应函数成为尾掉函数9 数组

数组，就是相同数据类型的元素按一定顺序排列的集合，可以是一维数组和多维数组。

Lua 数组的索引键值可以使用整数表示，数组的大小不是固定的。

九、数组

9.1 一维数组

一维数组是最简单的数组，其逻辑结构是线型表。一维数组可以使用for循环出数组中的元素 。如下实例：

  1. -- 一维数组的声明遍历
  2. oneArr = {"张三",12,33};
  3. print("数组长度".. " : " .. #oneArr)
  4. for i=1,#oneArr,1 do
  5.     print(oneArr[i])
  6. end

9.2 

  1.  
  2. -- 二维数组的声明遍历
  3.  
  4. towArr = {}
  5. -- 初始化二维数组 3*3 的
  6. for i=1,3 do
  7.     towArr[i] = {}
  8.     for j = 1, 3 do
  9.         towArr[i][j] = i* j;
  10.     end
  11. end
  12.  
  13. -- 遍历二维数组
  14. for i =1,#towArr do
  15.     for j = 1,#towArr[i] do
  16.         print(towArr[i][j])
  17.     end
  18. end

本文章用于学习笔记使用。

参考一下文章

https://www.runoob.com/lua/lua-tables.html

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/代码探险家/article/detail/859111
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号