lua学习笔记(三)

--变长参数
function printelement(...)
for k,v in pairs({...}) do
if v%2==0 then
print(v)
end
end
end

printelement(3,4,5,6,7,8)

printelement(1,2,3,4)

--变长参数中有固定参数
function printoddelement(str,...)
for k,v in pairs{str,...} do
if k%2~=0 then
print(v)
end
end
end

printoddelement("asd",1,2,3,4,5)

--select('#',...) 和select(n,...)的使用

function printnumber(...)
for k=1,select('#',...)do
  local ele = select(k,...)--select(#,...)返回的它的可变参数总数
   print(ele)        --select(n,...)返回它的前n个参数,可以利用多重赋值来只获取第一个值
end
end

printnumber(9,8,7,6,5)
--具名实参 就是利用表达到类似C++中的缺省参数的目的
function rename(arg)
return os.rename(arg.old,arg.new)
end

print(rename({old="C:\\Users\\Administrator\\Desktop\\layer.txt",new="C:\\Users\\Administrator\\Desktop\\layer2.txt"}))

--函数进阶2  我注释掉的这段代码因为不方便后边测试，这段代码是很正确的代码
--函数是第一类值，和一般的变量是一样的
--[[a={p=print}
a.p("Hello")
print = math.sin
a.p(print(1))
math.sin = a.p
math.sin(3.14)]]
--函数function foo(x) return 2*x end 就是 foo = function(x) return 2*x end，foo只是一个变量而已
--函数类型的变量可以作为函数的参数传递，也可以作为返回值
--奇葩的地方......竟然有二维的函数
--词法域，一个函数位于另一个函数内部，里面的函数就能访问外面函数的局部变量
function f(x)
return x*x
end

function derivative(f,delta)
delta = delta or 1e-4
return function(x)
      return (f(x+delta)-f(x))/delta
      end
end

print(derivative(f)(0))

--table.sort()的使用
network = {{name = "asd",IP=12345},{name = "sdf",IP=23456},{name = "dfg",IP=34567}}
table.sort(network,function(a,b) return(a.name>b.name) end)
for k,v in pairs(network) do
print(v.name,v.IP)
end

--接下来是更奇葩的东西
--closure(闭合函数)  个人理解:函数作为函数的返回值时，非局部的变量在嵌套的(里面的)函数中被一个变量所持有时不会消失的现象
function returnname()
local name = 0
print(name)
 return function()
  name=name+1
  return name
 end
end
definename = returnname()
print(definename())
print(definename())
print(definename())

definename2=returnname()
print(definename2())

--非全局的函数和尾调用
--table中的函数为非全局函数
lib = {}
lib.foo = function(x,y) return x+y end
lib.goo = function(x,y) return x-y end

lib={foo = function(x,y) return x+y end ,
     goo = function(x,y) return x-y end}

lib = {}
function lib.foo(x,y) return x+y end
function lib.goo(x,y) return x-y end
--还可以将函数直接设置为局部的，直接设置或赋值给局部变量
local function f(i)  --这样是可以递归调用自己的,但递归相互调用是不可以的
if(i==0) then
return 1
end
return 2*f(i-1)
end

print(f(2));

local f
f= function() return 1 end --这样是可以递归调用自己的，也可以相互递归调用

local f = function() return 1 end --注意，这样写，是不能递归调用自己的，更不能相互递归调用

--尾调用消除，当尾调用结束时不需要再对和尾调用有关的表达式做任何操作，直接返回调用函数的地方
--避免了栈溢出,但是如果对尾调用这句话还需要有其它作用时，尾调用消除不能进行

--尾调用消除能进行的情况
function foo (n)
if(n>0) then return foo(n-1) end
end

function foo(x)
return goo(x)
end

--尾调用消除不能进行的情况
--需要调整这个尾调用表达式的返回值
function foo(x)
return goo(x)+1
end

function foo(x)
return x or goo(x)
end

function foo(x)
return (goo(x))
end