Lua的闭包到底是什么？到底有什么用?

-- -- ocos2d.x.version: cocos2d-x-3.15.1 
-- -- 语言: Lua
-- -- 编译: xcode
-- -- 工具: sublimeText
print("test====")
-- lua的闭包是什么，lua的闭包到底有什么用。

-- 要想了解lua的闭包的什么,我们来了解一个场景,假如我们要写一个计数器:
-- -- 方法1  全局变量
--     CC_count = CC_count + 1;
--     CC_count = CC_count + 1;
--     print("CC_count==== ",CC_count);  -- 2
--     -- [LUA-print] test====
--     -- [LUA-print] CC_count====    2
--     -- 但是这里有个问题,如果那个人一不小心写错了
--     CC_count = nil;-- 这样可能使得整个程序有崩溃的危险.

-- -- 方法2 模块
--     local t3 = require "app.TestModule"
--     -- t3.addCount(); [LUA-print] count ===   1
--     -- t3.addCount(); [LUA-print] count ===   2
--     -- 但是我们可能用到地方都要去引用这个模块,或者使用全局变量保存这个模块的对象,好像也不是很理想.

-- 方法3 闭包
    local function getCount(  )
        local _addCount = 0;
        local function addCount(  )
            _addCount = _addCount + 1;
            return _addCount;
        end
        return addCount;
    end

    local addCount = getCount();
    print(addCount());
    print(addCount());
    -- [LUA-print] 1
    -- [LUA-print] 2
    -- 用闭包实现了计数器,函数返回了上层函数的局部变量在调用本函数加1,
    -- 其他人是无法去修改上层函数的_addCount,也不会造成增加全局变量,和增加模块的引用.
    -- 缺点:
    local addCount1 = getCount();
    local addCount2 = getCount();
    local addCount3 = getCount();
    -- 此时内存里面已经有4个变量_addCount常驻在内存中(包括上面的)
    -- 每次调用getCount()都会生成一个新的对象和变量在内存里面没有被销毁.
    -- 清理闭包内存:
    -- 如果不用闭包对象可及时销毁:addCount1 = nil, addCount2 = nil, addCount3 = nil



-- 闭包实现迭代器
--     local function getVal( _table )
--         local sum = 0;
--         return function ( ... )
--             sum = sum + 1;
--             return _table[sum];
--         end
--     end

--     local t = {1,2,3};
--     local iter = getVal(t);
--     while 1 do
--         local val = iter();
--         if not val then
--             break;
--         end
--         print("val ====   ",val)
--     end
-- -- [LUA-print] val ====    1
-- -- [LUA-print] val ====    2
-- -- [LUA-print] val ====    3


-- 闭包:cocos2d常用的函数值传递 (访问上层函数里面的btn 作为值传递到外层函数)
-- local testUI = testUI or {}
-- local testUI:onBtnClick(sender,event)
--     --可获取的参数有:隐藏的self,btn,event
-- end
-- function testUI:initButton()
--      local btn = UIButton:create()
--     --重点来了
--     btn:addListenHandler(function(event)
--            --使用闭包把self,btn都传进去了....
--            self:onBtnClick(btn,event)
--        end
--     )
-- end
-- return testUI


-- 通过上面的案例我们可以得知:闭包就是能够读取上层函数其他函数内部变量的函数。他的作用是变量在内层表现出来,外部不能访问.
-- 优点: 可以避免全局变量的污染,(可以使局部变量内存常驻)    
-- 缺点: 如果过多使用闭包会导致很多变量在内存常驻，可能导致内存泄露，在不用闭包对象的时候我们要及时释放内存,可参考上面(清理闭包内存)；

 这个是路径说明

 这里是路径配置的代码

-- 0 - disable debug info, 1 - less debug info, 2 - verbose debug info -
DEBUG = 2

-- use framework, will disable all deprecated API, false - use legacy API
CC_USE_FRAMEWORK = true

-- show FPS on screen
CC_SHOW_FPS = true

-- disable create unexpected global variable
CC_DISABLE_GLOBAL = true

-- for module display
CC_DESIGN_RESOLUTION = {
    width = 960,
    height = 640,
    autoscale = "FIXED_HEIGHT",
    callback = function(framesize)
        local ratio = framesize.width / framesize.height
        if ratio <= 1.34 then
            -- iPad 768*1024(1536*2048) is 4:3 screen
            return {autoscale = "FIXED_WIDTH"}
        end
    end
}

-- 测试定义的全局变量
CC_count = 0;

总结:

        闭包方便，但是也有内存管理缺陷，且用其管理。

手动码字，真心不易，如有不懂可以联系大嫂，当前有创业或者发财的一定要联系我噢，风里雨里大嫂一直等你，V:1154195328; QQ = V.