lua中常量的实现及表的深拷贝实现

废话：很久没在这里写博客了。。。主要缘由是我买了个域名hanxi.info并在github上搭建了我的博客。。。

 

　　lua中默认是没有c中的const常量的，在csdn上找到了一个使用setmetatable。参考http://blog.csdn.net/xiaodan007/article/details/6668015。主要原理就是重载__index方法（至关于get方法）和__newindex方法（至关于set方法）。可是他实现的是不支持表中有表的状况的。

下面是我修改后的代码：

 1 function newConst( const_table )    --生成常量表功能
 2     function Const( const_table )
 3         local mt =
 4         {
 5             __index = function (t,k)
 6                 if type(const_table[k])=="table" then
 7                     const_table[k] = newConst(const_table[k])
 8                 end
 9                 return const_table[k]
10             end,
11             __newindex = function (t,k,v)
12                 print("*can't update " .. tostring(const_table) .."[" .. tostring(k) .."] = " .. tostring(v))
13             end
14         }
15         return mt
16     end
17 
18     local t = {}
19     setmetatable(t, Const(const_table))
20     return t
21 end
22 
23 quan = {a = {[1]={2}}}
24 quan.b = quan
25 t = newConst(quan)
26 --t.b = 4
27 print(type(t))
28 print(quan.b)
29 
30 
31 for k,v in pairs(quan) do
32 print(k,v)
33 end

　　我也就是添加了6,7,8三行代码（刚开始想了半天觉得递归了，结果思索了下，不是递归，只是函数的实现形式，调用newConst的次数就是读取表的深度，有环的表也不会出现问题的）。__index函数（看参数能够知道取元素t[k]）拿到表的元素,若是元素是表则先将表常量化。__newindex函数（看参数能够知道写元素t[k]=v）是给元素赋值，这里不让它实现赋值操做，直接打印错误提示。

　　为何要实现这个常量功能，由于如今的手游项目中使用了lua表存放数值策划表，每每程序写代码时会直接去读取静态数据表，万一不当心把表元素赋值了，那就是把静态数据改了，会致使游戏数据错误的。实现了这个lua常量就不会出现静态数据表被修改了。

　　可是若是须要复制一份静态数据，而后做为临时数据在游戏逻辑中处理（一个同事就这么用过。。。），把静态数据通过了常量处理就不再能被修改了，不常量化也不行，中途被修改了就再也还原不了静态数据了。所以就须要实现lua表的深拷贝功能了（默然的表与表之间赋值只是简单的别名而已）。先说下思路吧，实现的效果是：

local B = deepcopy(A,n)

　　把A拷贝给B，n为拷贝深度。若是n为nil时那就是说要拷贝到底了，这又出现了中有环的问题了，不考虑环的问题能够很简单的递归实现，递归结束标识就是判断n的值。代码就先不写了，晚了洗洗睡吧。下次有时间会贴代码的。。。

　　网上关于深拷贝表的资料不多。总共在下面几个网站上找到了答案。

http://blog.sina.com.cn/s/blog_49bdd36d0100fdc1.html（集合了带环的table和不带环的table的解决方案）

http://www.coronafaqs.com/how-do-i-copy-a-complex-table-in-lua/（就是上面那个带坏的table的解决方案）

http://lua-users.org/wiki/CopyTable（不带环的table的解决方案，还有一个浅拷贝实现）

https://gist.github.com/Deco/3985043 （牛逼的解决方案，非递归实现，可以处理带环的table）

　　先给上递归式的代码吧。

 1 function table.deepcopy(object)
 2     local lookup_table = {}
 3     local function _copy(object)
 4         if type(object) ~= "table" then
 5             return object
 6         elseif lookup_table[object] then
 7             return lookup_table[object]
 8         end
 9         local new_table = {}
10         lookup_table[object] = new_table
11         for index, value in pairs(object) do
12             new_table[_copy(index)] = _copy(value)
13         end
14         return setmetatable(new_table, getmetatable(object))
15     end
16     return _copy(object)
17 end

为啥带环的table用这个函数不会无限递归呢？关键之处在于lookup_table，它记录了全部遍历过的table的副本（新的深拷贝的table），若是出现遍历过的直接返回那个副本。第12行为什么有两个_copy，这里用的很巧妙，举个例子吧。

t = {

    a = 1,

    b = 2,

    c = {

        x = 1,

        y = 2,

        z = 3,

    }

}

t[t.c] = t

t2 = table.deepcopy(t)

print(t2[t2.c])

若是index没有通过_copy处理，则打印出来的则是nil。为什么通过_copy处理必定会是t2.c==t2呢？这也就是第6行判断的效果了，它返回的index就是t2.c(由于t2.c要么就是从第7行返回的，要没是新生成的副本，下次拷贝时仍是取得同一个副本)。

接下来看第14行，这行不是我想要的，个人目的是拷贝出一份临时表，这分临时表要去除常量的特性，因此我修改以下

return setmetatable(new_table)

这样也就不保留常量特性了。

lua中使用局部函数的好处是不少的。look_up就用到了这个好处，若是lua不支持局部函数，那就只能将look_up表当作参数传递进去了。我以前实现了不支持环的版本，以下：

 

 1 function table.deepcopy(t, n)
 2     local newT = {}
 3     if n == nil then    -- 默认为浅拷贝。。。
 4         n = 1
 5     end
 6     for i,v in pairs(t) do
 7         if n>0 and type(v) == "table" then
 8             local T = table.deepcopy(v, n-1)
 9             newT[i] = T
10         else
11             local x = v
12             newT[i] = x
13         end
14     end
15     return newT
16 end

非递归版本太牛逼了，不作介绍了本身想看源码的去看吧