环境的概念
45、环境：lua将其所有的全局变量（值、函数、table）保存在一个常规的table中，这个table称为环境，可以认为一个chunk只有一个环境，在lua5.2以后就不允许修改某个函数的环境了。全局变量存在一个叫 _G 的表中。环境的概念是针对全局变量的，对local变量无影响。
利用table访问的元方法可以控制全局变量的访问
--绕过元表，创建全局变量 a ，并赋值为“android”
rawset(_G, "a", "android")
print(a)
--绕过元表判断是否存在全局变量 var
if rawget(_G, var) == nil then
print("not declare")
end
46、非全局的环境（特只自己创建的环境，不是全局环境（_G））
修改函数的环境：setfenv，注意在lua5.3中去除了setfenv，有_ENV属性代替。
a = 1
--改变一个函数的环境，参数1可以为参数本身，也可以是数字，表示当前函数调用栈的层数，参数2表示新的环境table
setfenv(1, {}) --1表示当前函数，2表示调用当前函数的函数，依次类推
print(a) --这样就访问不到 a 了
47、理解非全局环境：定义全局变量，默认被存储在当前环境中的，如果改变了环境，在新环境就没有以前环境下定义的函数变量等。使用全局变量时，不带表前缀（表名.）的，都是默认在当前环境中去找的。
--local x = print --改变环境对local变量无影响
x = print --定义x时的全局环境就是“全局环境”
_ENV = {} --现在改变环境了，之前定义的全局变量都不在了 ，这个就是非全局环境
a = 10 --这里定义的“全局变量 a”，是在当前环境中，也就是 “{}”
x(a) --此时就访问不到 x 了，如果 x 是local的就可以访问
非全局环境可以解决名字污染问题，也是lua封装的重要方法之一
模块
48、加载模块
require函数：用于加载一个模块，如果传入的名字找到一个函数，则直接在加载；如果找到一个Lua文件，则用loadfile加载；如果找到一个C程序库，则用loadlib加载。
--local m = require "mod" --mod是模块的名称
--print(m.add(1, 2))
require "mod"
print(mod.add(1, 2))
require查找的路径：存放在变量package.path中，当Lua启动后，便以环境变量LUA_PATH的值来初始化。
判断name模块是否已加载：package.loaded[name]，已经加载的模块会放在package.loaded中。
49、编写模块的基本方法
local modname = ... --其它地方使用require(name)，...就是传递的name
local M = {}
_G[modname] = M --把M放在全局环境中，让其它地方可以用modname调用该模块
--package.loaded[modname] = M --和末尾的return M 一样的功能
--可定义一系列模块包含的功能
M.add = function(a, b)
return a+b
end
--
--return M
50、在模块中使用环境：上述的模块基本写法中，整个模块内部是在全局环境中的，如果不小心定义了全局变量，那么这个变量在任何加载该文件的地方都可以直接使用，不需要模块前缀，打破了模块的封装性，名字空间污染。
--模块设置
local modname = ... --其它地方使用require(name)，...就是传递的name
local M = {}
_G[modname] = M --把M放在全局环境中，让其它地方可以用modname调用该模块
--package.loaded[modname] = M --和末尾的return M 一样的功能
--导入段
--声明这个模块从外界所需的所有东西
local sqrt = math.sqrt
local io
--改变当前环境，这句话之后就不能访问全局环境中变量了，所以把需要用的外界的在上面先导入进来，注意是local变量存的
_ENV = M
--模块内容
M.add = function(a, b)
return a+b
end
return M
面向对象编程
51、类：在Lua中没有类的概念，每个对象只能自定义行为和形态。但可以用原型来模拟类的概念，因为在会在表的原型中查找它所没有的操作，就可以认为是原型定义了一系列操作，创建一个表并设置原型就近似创建了“对象”。
让 a 的__index属性 等于 b，这样a 就会在 b 中查找所有它没有的操作，a 可以 称为 b的对象。
setmatatable(a, {__index = b})
“:”和“.”的区别：“:”会隐式的传递当前调用者
a = {balance = 0}
function a:f(v) --a:f(v) 等价于 a.f(self, v)
self.balance = self.balance - v
end
b = a
a = nil
b:f(1) --b:f(1) 等价于 b.f(b, 1)
面向对象的写法：
a = {}
function a:new(o)
--“:”定义
o = o or {}
setmetatable(o, self)
self.__index = self
--让o的元表 self的__index属性等于自身，意味着 o 就会在 self 中查找所有它没有的操作
return o
end
function a.f()
print("a.f")
end
x = a:new()
--“:”调用
x.f()
52、继承
a = {} --创建基类a
function a:new(o)
o = o or {}
setmetatable(o, self)
self.__index = self --
return o
end
function a.f()
print("a.f")
end
b = a:new() --派生类b
function b.display()
print("b.display")
end
c = b:new() --创建b类的对象 c
所以啊，lua中类和对象本身没有区别，你可以叫 b、c 是对象，也可以认为它们是派生类。
53、多重继承：如果__index是一个函数，之前学过，当访问一个表中不存在的操作时，就会调用元表中__index元方法返回结果。那么多重继承就是利用在 __index元方法中，查找所有继承的基类，是否存在相应的操作。
local function search(k, plist)
for i=1,#plist do
local v = plist[i][k]
if v then return v end
end
end
function createClass(...)
local c = {}
local parents = {...}
setmetatable(c, {__index = function(t, k)
return search(k, parents)
end})
--c.__index = c
function c:new(o)
o = o or {}
setmetatable(o, c)
c.__index = c
return o
end
return c
end
--创建新类
mult = createClass()
mult.fun = function()
print("mult fun")
end
--创建对象
a = mult:new()
a.fun()
网友评论