糖果实验室杂货铺

Candy Lab

关于Lua的LazyTable的实现

6 months ago 0

作者:糖果

LazyTable源码

None
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
local ngx_req = {
      headers = function()
          return "testcase"
      end,
      method = function()
          return "GET"
      end,
}


local lazy_tbl
lazy_tbl = function(tbl, index)
  return setmetatable(tbl, {
    __index = function(self, key)
      for k,v in pairs(index) do
          print(k, v)
      end
      --print(key)
      for k,v in pairs(self) do
          print(k, v)
      end
      local fn = index[key]
      if fn then
        do
          --此处fn(self)和fn(),传入self形参与否的效果是一样,table中的匿名函数
          --定义是没有参数的,这个形参是moonscript翻译后加上去的。
          local res = fn(self)
          --local res = fn(self)        
          local res = fn()
          self[key] = res
          --实际把return res去掉也不会影响这个程序的运行结果, 在此函数中
          --从了这个return语句再也没有return调用了,而设定工作在self[key] = res这句就已经完成。
          return res
        end
      end
    end
  })
end


local build_request
build_request = function(unlazy)
  if unlazy == nil then
    unlazy = false
    --unlazy = true
  end
  do
    local t = lazy_tbl({ }, ngx_req)
    if unlazy then
      for k in pairs(ngx_req) do
        --这里遍历的ngx_req,但是调用的函数是t的。
        local _ = t[k]
      end
    end
    return t
  end
end


req = build_request("unlazy")


for k,v in pairs(req) do
    print(k, v)
end

重置setmetatable

在一个匿名函数中,return setmetatable,通过对函数形参传入的table的变量的index属 性进行统一修改,而新设定的index对应函数的形参self和key,分别对应新table的本身, 和table对应的key。

None
1
2
__index = function(self, key)
  lazy_tbl({ }, ngx_req)

self:是ngxreq的引用。 key:是ngxreq的key。

如果发现,ngx_req的元素类型是function就执行下,然后,把返回结果(字符串) 替换原value值。

核心原理

lazy table实现的核心部分是,是在return setmetatable做table复制时,并统一的设定 新table的index属性, 然后在遍历我们要批量设定的table时,得用table的index对 应函数中的设置,修改要修改table的成员变量值,把table中,对应key的值是function 的元素,改成key的值等于,这个key对应匿名函数的返回值。

修改table元素的是由setmetatable指定的__index方法来完成。而遍历循环执行table中的 所有匿名函数,由一次外层的循环来完成。

moonscript的lua翻译特征

do end 结构是为了让local型的局部变量,在 do end 结构外不可见。

lua do local tmp = 1 end print(tmp)

结果是:nil

lua do tmp = 1 end print(tmp)

结果是:1

下面的代码有明显的moonscript翻译成lua的特征:

None
1
2
3
4
5
6
7
8
9
10
11
local test 
test = function()
    do  
        local tmp = "do end"
        return tmp 
    end 
    return "ret"
end

ret = test()
print(ret)

简化后的LazyTable代码

None
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
local ngx = { 
    url = function() 
        return "url"
    end,
    method = function()
        return "method"
    end,
}

local lazy

lazy = function(tbl, index)
    return setmetatable (tbl, {
        __index = function(self, key)
            print(key)
        end 
    })  
end


local build_request
build_request = function(unlazy)
        ret = lazy({}, ngx)
        for k in pairs(ngx) do
             local _ = ret[k]
        end
end

build_request("")

lazy的核心是通过lazy函数,重新设置table的__index对应函数 ,在函数中调用元素值是function类型的函数,用函数返回结果修 改当前元素的value值。

通过LazyTable可把Table表的声明和元素值的动态设定在一个 封装调用周期内完成。

应用场景

LazyTable在应用在Lapis的获取nginx变量的一个功能,我们把这个功能 移到HiLua演示框架里,看LazyTable如何在实际应用场景应用的。

None
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
local ngx_request = {
  headers = function()
    return ngx.req.get_headers()
  end,
  cmd_meth = function()
    return ngx.var.request_method
  end,
  cmd_url = function()
    return ngx.var.request_uri
  end,
}

local lazy_tbl
lazy_tbl = function(tbl, index)
  return setmetatable(tbl, {
    __index = function(self, key)
      local fn = index[key]
      if fn then
        do  
          local res = fn(self)
          self[key] = res 
          return res 
        end 
      end 
    end 
  })  
end

return ngx_request

Moonscript是有OO的类的组织结构,但是用Moonscript写的Lapis框架,有的一些文件并没有 按类的形式组织,比如上面这个截取的代码,最后返回的就是一个ngx_request的table,通过 引用table中的函数类型元素进行调用,即可返回你想要的数据,这个类似之前lapis ES的写法 一个孙数的调用过程,可以整个组织成一个table声明的过程,在其过程中就完成了各种行为的 调用,看起来很整洁,调用时序隐含在声明里,而不是传统的若干个函数过程顺序调用的方式。

在一个数据结构中定义若干函数的调用,要是和路由器比较的话,路由器需要正则匹配判断 而这个是顺序执行。

在HiLua中的调用形式如下:

None
1
2
3
4
5
local req = require "nginx"

app:get("/hilua", function(request,id)
    ngx.say(type(req.cmd_meth))
end

nginx中ngx_request取得HTTP请求阶段的各种变量,这个数据结构在HiLua进行路由匹配处理 从这个数据结构中,取得相关变量。

None
1
2
3
4
5
local req = require "nginx"
function Route:run(router)
        local url = req.cmd_url()
        local method = req.cmd_meth()
end

LazyTable本身是一种设计实现的思路,可以用Moonscript实现,也可以用Lua实现,也可以 C/CPP实现。


糖果实验室

Openresty中文编程网
IKBC经典机械键盘
机械键盘领券优惠购买

Write a Comment