[Lua语言基础]-15、函数进阶_闭包函数

1. --[===[闭包
   
2. 一个函数中嵌套子函数，子函数可以使用父函数中的局部变量，这种行为就是“闭包”。
   
3. 可以简略归纳为：闭包=函数+引用环境]===]
   
4. 
   
5. -- 无参数闭包
   
6. function Fun()
   
7.         local i = 0                                -- i 变量，称为内嵌函数的“upValue”。这里的i 变量即不是全局变量，也不是局部变量。
   
8.         -- 这里的称为“非局部变量”
   
9.         print("-- A步骤 -- i=",i)
   
10.         return function()                -- 内部嵌入的匿名函数，
    
11.                 print("-- B步骤 -- i=",i)
    
12.                 i = i+1
    
13.                 print("-- C步骤 -- i=",i)
    
14.                 return i
    
15.         end
    
16. end
    
17. 
    
18. -- 调用测试
    
19. f1 = Fun()
    
20. print('调用一次',f1())
    
21. print('调用二次',f1())
    
22. print('调用三次',f1())
    
23. --[===[输出结果：
    
24. [2021:08:21-16:35:19:384] [函数进阶-闭包函数.lua 行号:9] -- A步骤 -- i= 0
    
25. [2021:08:21-16:35:19:385] [函数进阶-闭包函数.lua 行号:11] -- B步骤 -- i= 0
    
26. [2021:08:21-16:35:19:386] [函数进阶-闭包函数.lua 行号:13] -- C步骤 -- i= 1
    
27. [2021:08:21-16:35:19:387] [函数进阶-闭包函数.lua 行号:20] 调用一次 1
    
28. [2021:08:21-16:35:19:388] [函数进阶-闭包函数.lua 行号:11] -- B步骤 -- i= 1
    
29. [2021:08:21-16:35:19:389] [函数进阶-闭包函数.lua 行号:13] -- C步骤 -- i= 2
    
30. [2021:08:21-16:35:19:390] [函数进阶-闭包函数.lua 行号:21] 调用二次 2
    
31. [2021:08:21-16:35:19:391] [函数进阶-闭包函数.lua 行号:11] -- B步骤 -- i= 2
    
32. [2021:08:21-16:35:19:392] [函数进阶-闭包函数.lua 行号:13] -- C步骤 -- i= 3
    
33. [2021:08:21-16:35:19:393] [函数进阶-闭包函数.lua 行号:22] 调用三次 3
    
34. ]===]
    
35. 
    
36. --[===[闭包的特点：
    
37. 闭包中内嵌函数可以访问外部函数已经创建的所有局部变量，这些变量称为内嵌函数的“upValue”。
    
38. 闭包与一般函数的区别：
    
39. 闭包只是在形式上和表现上像函数，但是实际上不是函数。函数只有一个实例，定义后逻辑就确定了，不会执行时发生变化。    ]===]
    
40. 
    
41. -- 带参数的闭包
    
42. function FunWithPara(i)
    
43.         print("步骤 1 ,i=",i)
    
44.         return function()                        -- 内嵌匿名函数
    
45.                 print("步骤 2 ,i=",i)
    
46.                 i = i+1
    
47.                 print("步骤 3 ,i=",i)
    
48.                 return i
    
49.         end
    
50. end
    
51. 
    
52. fun2 = FunWithPara(10)
    
53. print(fun2())                                        -- 输出结果：11
    
54. print(fun2())                                        -- 输出结果：12
    
55. print(fun2())                                        -- 输出结果：13
    
56. print(fun2())                                        -- 输出结果：14
    
57. 
    
58. --[===[输出结果：
    
59. [2021:08:21-16:37:19:177] [函数进阶-闭包函数.lua 行号:42] 步骤 1 ,i= 10
    
60. [2021:08:21-16:37:19:180] [函数进阶-闭包函数.lua 行号:44] 步骤 2 ,i= 10
    
61. [2021:08:21-16:37:19:183] [函数进阶-闭包函数.lua 行号:46] 步骤 3 ,i= 11
    
62. [2021:08:21-16:37:19:184] [函数进阶-闭包函数.lua 行号:52] 11
    
63. [2021:08:21-16:37:19:186] [函数进阶-闭包函数.lua 行号:44] 步骤 2 ,i= 11
    
64. [2021:08:21-16:37:19:187] [函数进阶-闭包函数.lua 行号:46] 步骤 3 ,i= 12
    
65. [2021:08:21-16:37:19:189] [函数进阶-闭包函数.lua 行号:53] 12
    
66. [2021:08:21-16:37:19:190] [函数进阶-闭包函数.lua 行号:44] 步骤 2 ,i= 12
    
67. [2021:08:21-16:37:19:193] [函数进阶-闭包函数.lua 行号:46] 步骤 3 ,i= 13
    
68. [2021:08:21-16:37:19:194] [函数进阶-闭包函数.lua 行号:54] 13
    
69. [2021:08:21-16:37:19:197] [函数进阶-闭包函数.lua 行号:44] 步骤 2 ,i= 13
    
70. [2021:08:21-16:37:19:200] [函数进阶-闭包函数.lua 行号:46] 步骤 3 ,i= 14
    
71. [2021:08:21-16:37:19:201] [函数进阶-闭包函数.lua 行号:55] 14
    
72. ]===]
    
73. 
    
74. -- 具备多个内嵌函数的闭包
    
75. -- 本实例中，两个内嵌函数，对upValues 数值进行共享处理。
    
76. function FunMutil()
    
77.         local numUpValue = 10                        -- 这是“up Values”
    
78.         function InnerFun1()                        -- 负责输出结果
    
79.                 print(numUpValue)
    
80.         end
    
81.         function InnerFun2()                        -- 负责逻辑运算
    
82.                 numUpValue = numUpValue + 100
    
83.         end
    
84.         return InnerFun1,InnerFun2
    
85. end
    
86. 
    
87. 
    
88. -- 调用测试
    
89. local res1,res2 = FunMutil()
    
90. res1()                                                                -- 输出结果：10
    
91. res2()                                                                -- 输出结果：
    
92. res1()                                                                -- 输出结果：110
    
93. 
    
94. 
    
95. -- 带参数的内嵌函数
    
96. function Fun4(num)
    
97.         return function(value)                        -- 内嵌函数带有参数
    
98.                 --return num * value                -- 此写法不能保存内部状态
    
99.                 num = num*value
    
100.                 return num
     
101.         end
     
102. end
     
103. 
     
104. -- 调试测试
     
105. fun4 = Fun4(10)
     
106. print(fun4(3))                                                -- 输出结果：30
     
107. print(fun4(3))                                                -- 输出结果：90
     
108. print(fun4(3))                                                -- 输出结果：270
     
109. 
     
110. 
     
111. -- 演示闭包可以具备多个实例。
     
112. function Fun5()
     
113.         local i = 0
     
114.         return function()
     
115.                 i=i+1
     
116.                 return i
     
117.         end
     
118. end
     
119. 
     
120. -- 调用测试
     
121. res5_1 = Fun5()
     
122. print(res5_1())                                                -- 输出结果：1
     
123. print(res5_1())                                            -- 输出结果：2
     
124. print(res5_1())                                      -- 输出结果：3
     
125. 
     
126. res5_2 = Fun5()
     
127. print(res5_2())                                         -- 输出结果：1
     
128. print(res5_2())                                                -- 输出结果：2
     
129. print(res5_2())                                                -- 输出结果：3
     
130. 
     
131. 
     
132. --[===["词法域"概念
     
133. 若将一个函数写在另一个函数内，那么这个位于内部的函数变可以访问，外部函数中的局部变量，
     
134. 这项特征称之为“词法域”。外部函数中的局部变量在匿名函数内既不是全局变量，也不是局部
     
135. 变量，将其称之为“非全局变量”（upValue）。
     
136. 
     
137. 闭包的典型应用：
     
138. “迭代器”的实现可以借助闭合函数实现，闭合函数能保持每次调用之间的一些状态。    ]===]
     
139. 
     
140. 
     
141. -- 使用闭包技术开发自己的“迭代器”
     
142. -- 自定义“迭代器”（闭包）
     
143. function Itrs(tabArray)
     
144.         local i = 0
     
145.        
     
146.         return function()
     
147.                 i = i+1
     
148.                 return tabArray[i]
     
149.         end
     
150. end
     
151. 
     
152. -- 定义一个表
     
153. myTab = {1,2,3,5,4,6,7,10,30,60,88}
     
154. 
     
155. -- 迭代输出
     
156. iterator = Itrs(myTab)
     
157. -- 使用while 输出
     
158. while true do
     
159.         local j = iterator()
     
160.     if j== nil then
     
161.             break
     
162.     end
     
163.     print('while j=',j)
     
164. end
     
165. 
     
166. -- 使用for 输出
     
167. for m in Itrs(myTab)do
     
168. 
     
169. print('for: ',m)
     
170. end
     
171. 
     
172. --[===[
     
173. 闭包的功能与作用总结：
     
174.         1、开发自定义“迭代器”函数。
     
175.     2.扩展了现有函数的功能。
     
176.     3、扩展了命名空间
     
177. ]===]
     
178. 
     

复制代码

看不懂

沙发

fojiao1992 发表于 2021-8-21 18:04
看不懂

对着视频看呗 看不懂才是对的

顶顶,学习了

谢谢分享

回帖水经验！！！

牛逼牛逼~

什么时候用的上

在水一个
在水一个
在水一个
在水一个