Lua学习之--函数，变长参数，closure（闭包）及select的一些特性

1. Lua函数支持多返回值，但并不是每次调用函数返回的全部值都会被使用。

有一条规则是只有当函数调用是表达式最后一个元素时，才会使用它的全部返回值。看代码：

--string.find函数返回两个值,:被查找子串的开始索引和结束索引
s,e = string.find("Lua program language","Lua")
print(s,e)  --> 1	3

--如果找不到,则输出nil和nil
s,e = string.find("Lua program language","Lub")
print(s,e)  -->nil	nil


--找出数组中最大的元素和其索引
function maximum(a)
	local mi = 1   --最大元素索引,开始假设第一个元素就是最大元素
	local m = a[mi]
	for i,val in ipairs(a) do
		if m < val then
			mi,m = i,val
		end
	end
	return mi,m
end

print(maximum{1,2,10,4,5,7}) --> 3	10

--返回多个值的函数只有作为表达式最有一个元素时才能使用它返回的多个值
--否则只取第一个值


--定义一个返回两个值的函数
function foo() return "a","b" end

--foo()在表达式最后，使用了他返回的两个值
a,b = foo()  -->a	b
print(a,b)

--foo()出现在表达式中间, 只使用了她返回的第一个值
a,b,c = foo(),"c"
print(a,b,c)   -->a	c	nil

--使用了函数返回的两个结果
print(foo())  -->a	b

--把函数调用放在括号中间， 迫使函数只返回的一个结果
print((foo()))  --> a

2. 函数支持变长参数：... 

如果变长参数中没有nil，那么可以使用ipairs(...)来遍历得到所有的参数.

如果参数中有nil,那么就只能使用select()函数了. 因为ipairs只能遍历到nil处.

--变长参数


--使用变长参数完成对nunmber列表求和
function add(...)
	local sum = 0
	for i,v in ipairs(...) do
		sum = sum + v
	end
	return sum
end

print(add{1.1,2.2,3.3,4.4,nil,6,8}) -->11   说明nil后面的6,8都没有遍历到


--如果变长参数中故意传入nil
--那么就要使用select函数来访问变长参数列表了.
--select得以参数如果传入的是整数n, 返回的是第i个元素开始到最后一个元素结束的列表
--如果传入的是"#",则返回参数列表的总长度

function add2(...)
	local sum = 0
	local arg
	for i=1,select('#',...) do

		--从输出结果可见,select(i,...)  返回的是第i个元素开始到最后一个元素结束的列表
		print(select(i,...))  	-->2	4	6	nil	5	8
								-->4	6	nil	5	8
								-->6	nil	5	8
								-->nil	5	8
								-->5	8
								-->8

		--只取列表的第一个值
		arg = select(i,...)
		if arg then
			sum = sum + arg
		end

	end
	return sum
end
print(add2(2,4,6,nil,5,8)) -->25   说明nil后边的值都遍历到了

3.closure(闭包)

我的理解是:使得内部函数能够调用外部函数的局部变量,而且在外部函数调用结束后仍然能使用外部函数的局部变量.而每次调用外部函数的会重新创建一个closure,而且以前的不会消失.这里不禁产生一个疑问:closure在什么时候释放?

-- closure的特性

function newCounter()
	local i = 0
	return function()
		i = i + 1
		return i
	end
end

c1 = newCounter()  --注意此处不是把newCounter函数赋给c1,而是把newCounter的返回值赋给c1,即 里面的c1是里面的匿名函数

--此处newCounter只调用了一次, 所以创建了一个closure，所以i也只有一个，不管调用多少次c1，他们都访问的是同一个i；

print(c1())  -->1
print(c1())  -->2

c2 = newCounter()  -- 再次调用newCounter,将产生一个新的closure

print(c2())  -->1
--此处c1的closure依然存在，
--疑问：每次调用函数都产生新的closure，那么closure什么时候释放？
print(c1())  -->3  
print(c2())  -->2