init_by_lua和access_by_lua的用法

wujiankaka

在用lua编写nginx模块的时候，模块的什么部分应该写在init_by_lua里呢？是不是把模块需要用到的全局变量和函数都写在init_by_lua里？

我在编写自己的模块时，就是刚才那样做的，不知道有没有问题。在init_by_lua_file init.lua中，我把所有的函数都写在init.lua中并且都申明为local，有一个入口函数为handle()。

在access_by_lua中，调用handle这个入口函数时，我发现local的handle性能比全局的handle差，这是为什么呢？另外什么部分应该写在set_by_lua里呢？

init_by_lua '

local set()

...

end

...

local handle(...) ->这个handle是入口函数，其申明为local时的性能不如申明为全局的

...

end()

access_by_lua'

handle(...); ->在access中是这样调用的

不知道我这样编写lua模块的结构合不合理，一般编写lua模块的时候，函数申明是放在哪里呢？如果不放在init中，应该放在什么地方呢？

agentzh

Hello!

2014-03-10 4:32 GMT-07:00 Jian Wu:
> 在用lua编写nginx模块的时候，模块的什么部分应该写在init_by_lua里呢？

推荐把耗时耗空间的初始化和预计算工作放在 init_by_lua 中。

> 是不是把模块需要用到的全局变量和函数都写在init_by_lua里？

不推荐在 init_by_lua 里创建全局变量，事实上，我们不推荐任何自己定义全局变量的做法，因为 Lua
全局变量会污染全局作用域的名字空间，容易导致难于调试的副作用和性能损耗。

见 https://github.com/chaoslawful/lua-nginx-module#lua-variable-scope

> 在init_by_lua_file
> init.lua中，我把所有的函数都写在init.lua中并且都申明为local，有一个入口函数为handle()。

用 local 声明的函数（和变量）的作用域都限制在当前的 Lua 代码块中（在这里，就是 init_by_lua 后面的这个 Lua
代码块）。考虑下面这个例子：

    init_by_lua '
        local function handle()
            ngx.say("hello")
        end
    ';

    server {
        ...
        location = /t {
            content_by_lua '
                handle()
            ';
        }
    }

此时访问 /t 时会返回 500 错误页，同时 nginx 错误日志文件中会有下面这条错误消息：

    attempt to call global 'handle' (a nil value)

只有当在 init_by_lua 中去掉 handle 函数的 local 修饰符才能正确工作。当然，让 handle
成为全局变量并不是推荐的做法（正如刚才提到的）。正确的做法是使用自定义的 Lua module，比如下面这个名为 myinit 的 Lua
模块文件：

    -- myinit.lua
    local _M = {}
    local say = ngx.say

    function _M.handle()
        say("hello")
    end

    return _M

然后，在 access_by_lua 里面直接 require 之：

    access_by_lua 'require("myinit").handle()';

> 在access_by_lua中，调用handle这个入口函数时，我发现local的handle性能比全局的handle差，这是为什么呢？

你这里的压测结果中，之所以 local 时的性能差，应该是 nginx 忙着刷你的 nginx 错误日志文件了，于是文件 IO
成为瓶颈（见上面我给出的那个 local 的例子）。

> 另外什么部分应该写在set_by_lua里呢？
>

> 不知道我这样编写lua模块的结构合不合理，一般编写
> lua模块的时候，函数申明是放在哪里呢？
> 如果不放在init中，应该放在什么地方呢？

函数定义应该放在 Lua module 文件中。这样也不至于每次请求都为该函数创建一个 closure，因为 Lua module
的计算结果是被全局缓存的（require 只会加载同一个模块一次）。

Regards,
-agentzh

wujiankaka

那应该把什么定义在init_by_lua中呢？init_by_lua中的东西应该是access_by_lua和content_by_lua中能访问的，也就是与全局变量性质一样的东西，有什么变通的方法申明与全局变量作用相同的东西呢？

在 2014年3月11日星期二UTC+8上午12时45分44秒，agentzh写道：

Hello!

2014-03-10 4:32 GMT-07:00 Jian Wu:
> 在用lua编写nginx模块的时候，模块的什么部分应该写在init_by_lua里呢？

推荐把耗时耗空间的初始化和预计算工作放在 init_by_lua 中。

> 是不是把模块需要用到的全局变量和函数都写在init_by_lua里？

不推荐在 init_by_lua 里创建全局变量，事实上，我们不推荐任何自己定义全局变量的做法，因为 Lua
全局变量会污染全局作用域的名字空间，容易导致难于调试的副作用和性能损耗。

见 https://github.com/chaoslawful/lua-nginx-module#lua-variable-scope

> 在init_by_lua_file
> init.lua中，我把所有的函数都写在init.lua中并且都申明为local，有一个入口函数为handle()。

用 local 声明的函数（和变量）的作用域都限制在当前的 Lua 代码块中（在这里，就是 init_by_lua 后面的这个 Lua
代码块）。考虑下面这个例子：

init_by_lua '
local function handle()
ngx.say("hello")
end
';

server {
...
location = /t {
content_by_lua '
handle()
';
}
}

此时访问 /t 时会返回 500 错误页，同时 nginx 错误日志文件中会有下面这条错误消息：

attempt to call global 'handle' (a nil value)

只有当在 init_by_lua 中去掉 handle 函数的 local 修饰符才能正确工作。当然，让 handle
成为全局变量并不是推荐的做法（正如刚才提到的）。正确的做法是使用自定义的 Lua module，比如下面这个名为 myinit 的 Lua
模块文件：

-- myinit.lua
local _M = {}
local say = ngx.say

function _M.handle()
say("hello")
end

return _M

然后，在 access_by_lua 里面直接 require 之：

access_by_lua 'require("myinit").handle()';

> 在access_by_lua中，调用handle这个入口函数时，我发现local的handle性能比全局的handle差，这是为什么呢？

你这里的压测结果中，之所以 local 时的性能差，应该是 nginx 忙着刷你的 nginx 错误日志文件了，于是文件 IO
成为瓶颈（见上面我给出的那个 local 的例子）。

> 另外什么部分应该写在set_by_lua里呢？
>

> 不知道我这样编写lua模块的结构合不合理，一般编写
> lua模块的时候，函数申明是放在哪里呢？
> 如果不放在init中，应该放在什么地方呢？

函数定义应该放在 Lua module 文件中。这样也不至于每次请求都为该函数创建一个 closure，因为 Lua module
的计算结果是被全局缓存的（require 只会加载同一个模块一次）。

Regards,
-agentzh

wujiankaka

另外，为什么放在init_by_lua中的全局函数在access_by_lua中调用时，每个请求调用handle时都要为handle创建闭包呢？

难道是因为函数虽然是如下定义的

function handle()

...

end

但实际上是handle=funtion()...end

在每次请求中调用handle时，都会先进行一次handle=function()..end的过程？如果是这样的话，那为什么是这样呢？

以上仅仅是我的猜测，求解

谢谢

在 2014年3月11日星期二UTC+8上午12时45分44秒，agentzh写道：

Hello!

2014-03-10 4:32 GMT-07:00 Jian Wu:
> 在用lua编写nginx模块的时候，模块的什么部分应该写在init_by_lua里呢？

推荐把耗时耗空间的初始化和预计算工作放在 init_by_lua 中。

> 是不是把模块需要用到的全局变量和函数都写在init_by_lua里？

不推荐在 init_by_lua 里创建全局变量，事实上，我们不推荐任何自己定义全局变量的做法，因为 Lua
全局变量会污染全局作用域的名字空间，容易导致难于调试的副作用和性能损耗。

见 https://github.com/chaoslawful/lua-nginx-module#lua-variable-scope

> 在init_by_lua_file
> init.lua中，我把所有的函数都写在init.lua中并且都申明为local，有一个入口函数为handle()。

用 local 声明的函数（和变量）的作用域都限制在当前的 Lua 代码块中（在这里，就是 init_by_lua 后面的这个 Lua
代码块）。考虑下面这个例子：

init_by_lua '
local function handle()
ngx.say("hello")
end
';

server {
...
location = /t {
content_by_lua '
handle()
';
}
}

此时访问 /t 时会返回 500 错误页，同时 nginx 错误日志文件中会有下面这条错误消息：

attempt to call global 'handle' (a nil value)

只有当在 init_by_lua 中去掉 handle 函数的 local 修饰符才能正确工作。当然，让 handle
成为全局变量并不是推荐的做法（正如刚才提到的）。正确的做法是使用自定义的 Lua module，比如下面这个名为 myinit 的 Lua
模块文件：

-- myinit.lua
local _M = {}
local say = ngx.say

function _M.handle()
say("hello")
end

return _M

然后，在 access_by_lua 里面直接 require 之：

access_by_lua 'require("myinit").handle()';

> 在access_by_lua中，调用handle这个入口函数时，我发现local的handle性能比全局的handle差，这是为什么呢？

你这里的压测结果中，之所以 local 时的性能差，应该是 nginx 忙着刷你的 nginx 错误日志文件了，于是文件 IO
成为瓶颈（见上面我给出的那个 local 的例子）。

> 另外什么部分应该写在set_by_lua里呢？
>

> 不知道我这样编写lua模块的结构合不合理，一般编写
> lua模块的时候，函数申明是放在哪里呢？
> 如果不放在init中，应该放在什么地方呢？

函数定义应该放在 Lua module 文件中。这样也不至于每次请求都为该函数创建一个 closure，因为 Lua module
的计算结果是被全局缓存的（require 只会加载同一个模块一次）。

Regards,
-agentzh

agentzh

Hello!

2014-03-10 19:33 GMT-07:00 Jian Wu:
> 那应该把什么定义在init_by_lua中呢？

我已经说了，定义应该尽量放在 Lua module 里面。init_by_lua 里面可以通过 require 预加载需要的 Lua
module（一个常识是对于同一个 Lua 模块名，require 会自动缓存已经加载过的模块）. 但无论何时都不应污染全局名字空间。

> init_by_lua中的东西应该是access_by_lua和
> content_by_lua中能访问的，也就是与全局变量性质一
> 样的东西，有什么变通的方法申明与全局变量作用相
> 同的东西呢？

我已经给你演示过了，即通过 require() 在 access_by_lua 和 content_by_lua 等上下文中引入你自己的 Lua module.

> 另外，为什么放在init_by_lua中的全局函数在
> access_by_lua中调用时，每个请求调用handle时都要
> 为handle创建闭包呢？

在 Lua 中，下面这种形式的函数定义

    local function foo(...)
        ...
    end

等价于

    local foo = function (...)
        ...
    end

你明白会为什么在执行这一段代码时总是会创建一个闭包了吧？

init_by_lua 里的代码块只会在 nginx 加载配置时执行一次。

类似地，Lua module 顶层的代码块在第一次 require() 时被执行，也仅在此时被执行一次。随后的 require()
都会直接返回 module 本身的数据结构（一般是 table，但也可以是其他）。

而 access_by_lua 的代码块总是会在每次请求的 access 阶段执行一次。这不是很自然的吗？

Regards,
-agentzh

wujiankaka

既然这样，那为什么不在init里面把所有需要的lua module加载进来呢？什么时候需要在access_by_lua和content_by_lua中加载模块呢？

在 2014年3月11日星期二UTC+8上午11时59分46秒，agentzh写道：

Hello!

2014-03-10 19:33 GMT-07:00 Jian Wu:
> 那应该把什么定义在init_by_lua中呢？

我已经说了，定义应该尽量放在 Lua module 里面。init_by_lua 里面可以通过 require 预加载需要的 Lua
module（一个常识是对于同一个 Lua 模块名，require 会自动缓存已经加载过的模块）. 但无论何时都不应污染全局名字空间。

> init_by_lua中的东西应该是access_by_lua和
> content_by_lua中能访问的，也就是与全局变量性质一
> 样的东西，有什么变通的方法申明与全局变量作用相
> 同的东西呢？

我已经给你演示过了，即通过 require() 在 access_by_lua 和 content_by_lua 等上下文中引入你自己的 Lua module.

> 另外，为什么放在init_by_lua中的全局函数在
> access_by_lua中调用时，每个请求调用handle时都要
> 为handle创建闭包呢？

在 Lua 中，下面这种形式的函数定义

local function foo(...)
...
end

等价于

local foo = function (...)
...
end

你明白会为什么在执行这一段代码时总是会创建一个闭包了吧？

init_by_lua 里的代码块只会在 nginx 加载配置时执行一次。

类似地，Lua module 顶层的代码块在第一次 require() 时被执行，也仅在此时被执行一次。随后的 require()
都会直接返回 module 本身的数据结构（一般是 table，但也可以是其他）。

而 access_by_lua 的代码块总是会在每次请求的 access 阶段执行一次。这不是很自然的吗？

Regards,
-agentzh

agentzh

Hello!

2014-03-10 21:53 GMT-07:00 Jian Wu:
> 既然这样，那为什么不在init里面把所有需要的lua
> module加载进来呢？什么时候需要在access_by_lua和content_by_lua中加载模块呢？
>

请仔细重读我前面的邮件。我觉得我已经解释过不止一遍了，实在不想再重复了。

如果你还有疑问，请仔细阅读 Lua 5.1 语言的官方手册：

    http://www.lua.org/manual/5.1/manual.html

Regards,
-agentzh

wujiankaka

我的意思是假如有自定义的一个模块init，我是否应该总是在init中先require一次？即如下：

init_by_lua '

require("init")

access_by_lua'

local M = require("init")

M.xxx()

在 2014年3月11日星期二UTC+8下午12时58分09秒，agentzh写道：

Hello!

2014-03-10 21:53 GMT-07:00 Jian Wu:
> 既然这样，那为什么不在init里面把所有需要的lua
> module加载进来呢？什么时候需要在access_by_lua和content_by_lua中加载模块呢？
>

请仔细重读我前面的邮件。我觉得我已经解释过不止一遍了，实在不想再重复了。

如果你还有疑问，请仔细阅读 Lua 5.1 语言的官方手册：

http://www.lua.org/manual/5.1/manual.html

Regards,
-agentzh

wujiankaka

在 Lua 中，下面这种形式的函数定义
local function foo(...)
...
end
等价于
local foo = function (...)
...
end
你明白会为什么在执行这一段代码时总是会创建一个闭包了吧？

这一块我还是有个疑问：其实我的意思是把这个foo函数的定义放在了init_by_lua中并申明为全局的，然后在access_by_lua中调用，这样还是处理每个请求的时候给foo函数创建闭包吗？

在 2014年3月11日星期二UTC+8上午11时59分46秒，agentzh写道：

Hello!

2014-03-10 19:33 GMT-07:00 Jian Wu:
> 那应该把什么定义在init_by_lua中呢？

我已经说了，定义应该尽量放在 Lua module 里面。init_by_lua 里面可以通过 require 预加载需要的 Lua
module（一个常识是对于同一个 Lua 模块名，require 会自动缓存已经加载过的模块）. 但无论何时都不应污染全局名字空间。

> init_by_lua中的东西应该是access_by_lua和
> content_by_lua中能访问的，也就是与全局变量性质一
> 样的东西，有什么变通的方法申明与全局变量作用相
> 同的东西呢？

我已经给你演示过了，即通过 require() 在 access_by_lua 和 content_by_lua 等上下文中引入你自己的 Lua module.

> 另外，为什么放在init_by_lua中的全局函数在
> access_by_lua中调用时，每个请求调用handle时都要
> 为handle创建闭包呢？

在 Lua 中，下面这种形式的函数定义

local function foo(...)
...
end

等价于

local foo = function (...)
...
end

你明白会为什么在执行这一段代码时总是会创建一个闭包了吧？

init_by_lua 里的代码块只会在 nginx 加载配置时执行一次。

类似地，Lua module 顶层的代码块在第一次 require() 时被执行，也仅在此时被执行一次。随后的 require()
都会直接返回 module 本身的数据结构（一般是 table，但也可以是其他）。

而 access_by_lua 的代码块总是会在每次请求的 access 阶段执行一次。这不是很自然的吗？

Regards,
-agentzh

agentzh

Hello!

2014-03-10 22:32 GMT-07:00 Jian Wu:
> 我的意思是假如有自定义的一个模块init，我是否应该总是在init中先require一次？即如下：

如果你在 init_by_lua 里面 require 一次，那么该 Lua 模块便是在 nginx 加载配置时加载（并缓存）。如果你只在
access_by_lua 里面 require（或者类似的请求处理程序的上下文），则该 Lua 模块在每个 nginx worker
进程服务第一个请求的时候加载（并缓存）。

只有当 Lua module 很大或者有较复杂的初始化计算时才值得在 init_by_lua 里预加载。

> 这一块我还是有个疑问：其实我的意思是把这个foo函
> 数的定义放在了init_by_lua中并申明为全局的，然后在
> access_by_lua中调用，这样还是处理每个请求的时候
> 给foo函数创建闭包吗？
>

不是。

貌似你不太熟悉动态语言里面闭包创建的行为，这和 Perl 等其他动态语言都是类似的行为。你把 Lua 的 function 关键字看作是类似
C++ 里面的 new 运算符就好了。换句话说，function 这个关键字是一个动作，而不是一个声明。

每次 LuaJIT VM 运行到 function 这个关键字时（对应 FNEW 这个字节码），它就会在 C 级别上创建一个 GCfunc
类型的底层对象（代码 Lua closure 对象）。你都已经把 function 这个动作的结果保存到一个 Lua
全局变量中，随后你直接引用这个全局变量值，你说 function 这个动作还会再执行吗？

Regards,
-agentzh