经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置:技术经验 » 程序设计 » Lua » 查看文章
lua变量、数据类型、if判断条件和数据结构table以及【lua 函数】
来源:cnblogs  作者:一乐乐  时间:2023/4/19 9:02:03  对本文有异议

一、lua变量【 全局变量和局部变量和表中的域】

Lua 变量有三种类型:全局变量局部变量表中的域

? 全局变量:默认情况下,Lua中所有的变量都是全局变量。

? 局部变量:使用local 显式声明在函数内的变量,以及函数的参数,都是局部变量。在函数外即使用local去声明,它的作用域也是当前的整个文件,这相当于一个全局变量。

? 表中的域:变量的默认值均为 nil

? Lua语言不区分未初始化变量和被赋值为nil的变量,因此全局变量无须声明即可使用。


1、全局变量

全局变量,不需要声明,只需要将一个值赋予一个全局变量即可创建了

  1. b=10 -- 这个b就是一个全局变量了
  2. print(b)
  • 通常没必要删除一个全局变量,如果一个变量生存周期较为短,使用局部变量即可。不过,如果真的想删除全局变量的话,只需将它赋值为nil。
  1. b=nil -- 这个全局变量b就被删除了
  2. print(b)

2、局部变量-使用local 声明

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

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

建议:在Lua中,应尽可能使用局部变量,好处:

  1. 避免命名冲突
  2. 访问局部变量的速度比全局变量更快

3、lua表中的域

  1. a = {}
  2. a[10] = 1
  3. for i=1,15,1 do
  4. print(a[i])
  5. end
  • 结果:


二、lua数据类型、if判断条件

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

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

数据类型 描述
nil 空值,只有值nil属于该类,表示一个无效值在条件表达式中相当于false)。
boolean 布尔类型
number 数值类型,相当于C语言的double
string 字符串类型,由一对双引号或单引号来表示
function 函数类型,由 C 或 Lua 编写的函数
table Lua 中的表(table)其实是一个"关联数组"(associative arrays),数组的索引可以是数字、字符串或表类型。在 Lua 里,table 的字面量是用{} 表示。 {},表示创建一个空表。
thread 线程类型,表示执行的独立线路,用于执行协同程序
userdata 表示任意存储在变量中的C数据结构

2、type(变量名)

  • 作用:获取该变量的类型

3、lua 的if 判断条件是理解为是否有效

?什么时候会【无效】错误失败---为nil和false的时候

  • nil 表示空值、无效值

?其他情况为数字、字符串、true、表(甚至是空表也是正确的),判断条件都是【有效】正确成功的!



三、lua数据结构-table

0、table的字面量:{},创建的空表,内部的域默认值是nil。

  • 表用大括号{}来构造,可以是多维的 {{}}。

1、lua中的表,其实是一个"关联数组",关联数组是一种具有特殊索引的数组,数组的索引可以是数组、字符串、表等[除了nil]。

  • 表中的元素是键值对形式。key 也就是数组的索引。表的key是唯一的。表是可以自定义键名。

2、table 是没有固定大小的,可以添加任意数量的元素到数组中。

3、table 是lua中最主要的数据结构机制,也是唯一的数据结构。用它可以实现数组,哈希表、集合、字典等等。还可以通过table 表示对象、包、模块。

其实lua 中的table 概念,相当于java中的对象的概念。万物皆是对象。

4、表中元素的删除,有两种方式:直接设置为nil或调用remove方法删除

  • 两种删除方式的区别:直接把元素赋值为nil,会留下空位,不影响其他元素。而用remove函数去删除,会把后面的元素往前移,补位。

5、表中元素有多少个,可以使用#获取

6、表中的索引是从1开始的

  1. tb={'干饭', '吃饭', '恰饭'}
  • 实际上,tb如下:
  1. -- tb的情况如下:
  2. -- 地址table(c917ad2)
  3. {
  4. [1] = '干饭',
  5. [2] = '吃饭',
  6. [3] = '恰饭',
  7. }

7、表有自定义键的时候:

  1. -- 表中只写了值value作为元素
  2. tb={'干饭', '吃饭', '恰饭', s='溜达'}
  • 实际上,表是有默认分配键key的,默认分配的键是从数字1开始的,tb表中的分配如下:
  1. -- tb的情况如下:
  2. -- 地址table(c917ad3)
  3. {
  4. [1] = '干饭',
  5. [2] = '吃饭',
  6. [3] = '恰饭',
  7. ['s'] = '溜达',--细节:s会被带上引号
  8. }

细节:要通过自定义的s键获取到值,s是要加上引号的。


对于自定义的键有一个语法糖,中括号可以使用点代替


表中默认分配的键和自定义键的执行顺序是:默认的先执行,然后再是自定义的键

  1. -- 表中只写了值value作为元素
  2. tb={'干饭',a='溜达',b='哈哈哈', _='饿了么','吃饭', '恰饭'}
  • 实际上,tb表中的分配如下:程序分配键的时候,会先跳过自定义键,再接着分配。
  1. -- tb的情况如下:
  2. -- 地址table(c917ad3)
  3. {
  4. [1] = '干饭',
  5. [2] = '吃饭',
  6. [3] = '恰饭',
  7. ['a'] = '溜达',
  8. ['b'] = '哈哈哈',
  9. ['_'] = '饿了么',
  10. }
  • 结果:

8、table 提供的增删元素的方法 table.insert 和 table.remove

  • table.insert(表名,要增加的键位,要增加的值) 直接再最后的位置增加元素:table.insert(表名,要增加的值)

  • table.remove(表名,要删除的键位)



四、lua 函数(形参-实参数数量不匹配、多重返回值、不定长参数、方法的冒号和点-self隐式参数)

0、lua 程序是严格从上到下的顺序执行代码的, 函数的声明必须在写函数调用前面。


在lua中,函数是作为第一类型,函数是可以存在在变量中,也可以通过参数传递给其他函数,还可以作为其他函数的返回值,还可以作为table表中的键

1、函数定义的方式

  1. -- 方式1
  2. function 函数名(参数列表)
  3. 函数内容
  4. end
  5. -- 方式2
  6. 函数名=function(参数列表)
  7. 函数内容
  8. end

2、lua 函数

① 函数是可以存在在变量中【匿名函数

  1. a = function(x, y)
  2. return x * y
  3. end
  4. b = a
  5. print(b(2,3))
  • 结果:

    6

? 在table中也可以存在function函数

  1. tab = {
  2. test=function()
  3. print("Hello World!")
  4. end
  5. }
  6. tab.test()
  • 结果:

Hello World!

3、形参-实参数数量不匹配

  • 传入的实参数量 > 定义的形参数量:多传入的参数,直接被忽略了
  • 传入的实参数量 < 定义的形参数量:缺少的参数,使用nil替补

4、多重返回值

  • 举例1:


  • 举例2:

  • 小细节:多个具有多重返回值的函数连续调用[使用,间隔],只有最后一个函数被展开,即最后一个函数才有资格返回多个值,其他函数都默认返回第一个值


5、不定长参数

  • 和java 一样,不定长参数使用...表示,并且作为函数的最后一个参数。
  • select 函数来访问变长参数了
    • select('#', …) 返回可变参数的长度。
    • select(n, …) 用于返回从起点 n 开始到结束位置的所有参数列表。


6、方法的冒号和点-self隐式参数

? Lua 定义或调用方法时的语法糖-冒号,表示参数self

这个语法糖是用冒号,表示self,相当于java中的this

■ 举例1:

  1. --定义
  2. Account = { balance = 0 }
  3. --withdraw 方法有两个参数,一个self【相当于java中的this】是指向当前tableAccount
  4. function Account.withdraw(self, v)
  5. self.balance = self.balance - v
  6. end
  7. --等价写法:
  8. function Account:withdraw(v) --通过冒号,表示定义了第一个参数是self
  9. self.balance = self.balance - v
  10. end
  11. --调用
  12. Account.withdraw(self, 100)
  13. --等价写法
  14. Account:withdraw(100)

■ 举例2:

  1. -- table的键值对的value---是function的时候,方法的参数是self,并且还将self 参数传递给function方法体的另外一个方法
  2. -- {} lua中表示table
  3. tbWnd.tbOnClick = {
  4. btnOk = function(self)
  5. self:onClickOK() -- 相当于onClickOK(self)
  6. end,
  7. }

7、函数嵌套调用,并且作为参数的那个函数,它是需要有参数传入

① 通过将参数存储到table中,table又绑定上的函数,该函数就可以通过self.key 拿到参数

② 然后外层的函数(func,table)

  1. local tbTable = {}
  2. tbTable.key1 = 1
  3. function tbTable:func1()--这样写,隐式参数是self
  4. print(self.key1)
  5. end
  6. -- 函数嵌套调用
  7. function func2(func,tbSelf)
  8. func(tbself)
  9. end
  10. -- 执行
  11. func(tbTable.func1)



? 五、lua 函数常见写法

1、直接构建

  1. function func(...)
  2. print(...)
  3. end
  4. -- 调用函数
  5. func(123)

2、表构建,key存储函数(1)

  1. local tbTable = {}
  2. function tbTable.func1(...)
  3. print(...)
  4. end
  5. function tbTable.func2(...)
  6. print(...)
  7. end
  8. -- 调用函数
  9. tbTable.func1(123)
  10. tbTable.func1(4,5,6)

3、表构建,key存储函数(2)

  1. local tbTable = {}
  2. tbTable.func1 = function(...)
  3. print(...)
  4. end
  5. tbTable.func2 = function(...)
  6. print(...)
  7. end
  8. -- 调用函数
  9. tbTable.func1(123)
  10. tbTable.func1(4,5,6)

4、表构建,key存储函数(3)

  1. local tbTable = {
  2. func1 = function(...)
  3. print(...)
  4. end,
  5. func2 = function(...)
  6. print(...)
  7. end
  8. }
  9. -- 调用函数
  10. tbTable.func1(123)
  11. tbTable.func1(4,5,6)



六、函数嵌套|闭包

1、local 特点:

局部变量:使用local 显式声明在函数内的变量,以及函数的参数,都是局部变量。

在函数外即使用local去声明,它的作用域也是当前的整个文件,这相当于一个全局变量。


2、函数嵌套|闭包

(1) 特点:函数的调用是用() 表示,有多少层,函数真正调用就需要多少个()

(2) 举例子:

  • 举例子1:
  1. local f = function(n)
  2. return function(x)
  3. return x+n
  4. end
  5. end
  6. print(f(1)(2)) -- 函数嵌套,每一层都相当于()
  7. a = f(1)
  8. print(a(10))
  • 结果:

    3
    11


  • 举例子2:local 在函数外相当于java的全局变量【独立的作用域强调的就是这个在函数外面的local 变量】
  1. local p = 1
  2. local f = function()
  3. local v = 0 -- local 在[下面的]函数外面相当于java的全局变量
  4. return function()
  5. v = v + p
  6. print(v)
  7. end
  8. end
  9. a,b = f(), f()
  10. a(); b();
  11. p = 2
  12. a(); b();
  • 结果:

    1

    1

    3

    3

  • local 在函数外相当于java的全局变量【独立的作用域

  1. class A{
  2. private int v; -- 全局变量
  3. public void add(){}
  4. }

  • 举例子3:
  1. local f = function()
  2. return {
  3. add = function(a,b)
  4. return a + b
  5. end,
  6. sub = function(a,b)
  7. return a - b
  8. end,
  9. }
  10. end
  11. v = f()
  12. print(v.add(1,2))
  13. print(v.sub(2,1))
  • 结果:

    3
    1




如果本文对你有帮助的话记得给一乐点个赞哦,感谢!

原文链接:https://www.cnblogs.com/shan333/p/17331661.html

 友情链接:直通硅谷  点职佳  北美留学生论坛

本站QQ群:前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

W3xue 的所有内容仅供测试,对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接(目前9元/月)请联系QQ:27243702 沸活量
皖ICP备17017327号-2 皖公网安备34020702000426号