---

函数

函数嵌套

function A()
    print("这里是函数A")
	return function ()
        print("返回函数不要起名")
    end
end
B = A()
B()

输出：
这里是函数A
返回函数不要起名

使用函数嵌套的用法，我们可以将另一个函数作为返回值，但是返回函数作为一个值是要被赋值给其他变量的，所以return时不能起名（赋值）为其他变量名。

---

闭包Closures

推荐阅读深入Lua：函数和闭包

在函数嵌套中，我们需要接触一个叫做闭包的概念

这就是一个闭包，它由一个函数和该函数会访问到的非局部变量（或者说upvalue）组成

function f1(n)
   --函数参数n也是局部变量
   local function f2()
      print(n)   --引用外部函数的局部变量，即upvalue
   end
   return f2
end

a =f1(1) --注意,闭包不传入参数则为nil
a()

当一个函数内嵌套另一个函数的时候，内函数可以访问外部函数的局部变量，这种特征被称为词法域，什么意思呢？

例如上述f1的入参n，它是一个形参，也是f1内的局部变量。现在f1内部定义了另一个函数f2，显然f2需要访问f1内的局部变量 n。但是对于n而言，它的词法域或者说作用域只是在f1内。如果只是简单的函数嵌套的话，用其他语言可以是这样实现的：

void f1(int x){
	f2(x)
}
void f2(int x){
	return x
}

但是问题是上述定义中f1内的x和f2内的x并不是同一个x，而分别是它们作用域内定义的局部变量。

而闭包更相当于一个指针，使得f2直接引用了f1的局部变量

#include <iostream>
using namespace std;
void f2(int *x)
{
	printf("%d", *x);
}
void f1(int x)
{
	f2(&x);
}
int main()
{
	int i = 1;
	f1(i);
	return 0;
}

这就是闭包的概念：内部函数innerFunction能够访问并持有其外部函数outerFunction作用域中的变量，这些被内部函数引用的外部函数的局部变量被称为upvalues。实际上，一般的函数在lua中是一种特殊的闭包。整个函数产生的闭包类似于下列struct ：

// Lua闭包
typedef struct LClosure {
  ClosureHeader;
  struct Proto *p;    // 函数原型
  UpVal *upvals[1];  /* list of upvalues */   // upvalue列表
} LClosure;

function Create(n)
   local function f1()
      print(n)
   end
   local function f2()
      n = n + 10
   end
   return f1,f2
end
a,b = Create(10)
a() -- 10
b()
a() -- 20
b()
a() -- 30

在上述闭包中，两个闭包f1，f2使用的n是同一个局部变量，因此f2使n增加后，f1输出值也变了。它们共享一个upvalues。

现在假设要创建一个对象，对外只提供有限的访问接口，而对象内部的数据不能直接被修改，那么我们可以这样写：

local function new_object()
    local obj = {       -- 这就是要创建的对象
        _data1 = 1,     -- 假设这是内部数据
        _data2 = 2,     -- 这是外部可修改的数据
    }
    return {            -- 这是返回的接口table
        get_data2 = function() return obj._data2 end,
        set_data2 = function(value) obj._data2 = value end,
    }
end

local obj_inteface = new_object()
obj_inteface.set_data2(100)
print(obj_inteface.get_data2())     --> 100

---

可变函数

function f1( x,...)
    arg={...}
    for i=1,#arg do
        print(arg[i])
    end
end

我们用…表示参数是可变参数，它能接收任意长的参数，但是在我们使用的时候，最好使用一个table来接收这个可变参数。此外其他固定的入参一定要放在可变参数的前面，这样函数才能先接受入参，其他的丢给可变参数。

---

函数重载

function A()
	print(123)
end
A()

function A(a)
	print(a)
end
A(1)

输出：
123
1

在Lua中，函数的重载十分简单，只需在函数下方重写这个函数即可。在Unity中Lua能实现热更新，例如修正一些Bug，就是通过重载函数实现的，举个例子：
摘自Lua语言：函数级别的重载

-- hotfix.lua
--- 执行热更新
-- oldmod是旧模块
-- newmod是新模块，这个模块里只会提供要替换的函数，相当于旧模块的一个子集。
function hotfix.run(oldmod, newmod)
    -- 收集旧模块的所有upvalue
    local uvmap = collect_all_upvalue(oldmod)
    for k, v in pairs(newmod) do
        if type(v) == 'function' then
            -- 这里就是先把新函数的upvalue修正，然后直接替换给旧模块
            oldmod[k] = hotfix_func(v, uvmap)
        end
    end
end
return hotfix

---