查看“模块:Arguments/doc”的源代码

{{NoteTA
|G1 = IT
|G2 = MediaWiki
}}
{{Documentation subpage}}
{{High-risk|2818915|all-pages=yes}}
{{缺乏中文說明}}
{{Translating|[[:en:Module:Arguments/doc]]|75|time=2019-09-13T13:37:42+00:00}}

此模块提供了对通过<code><nowiki>{{#invoke:}}</nowiki></code>（以下简称#invoke）传递参数的简单处理。它是一个元模块，只能被其他模块所使用，而不应被#invoke直接调用。其特性如下：
* 对参数的简易修整，移除空白参数。
* 参数可以在当前框架或父框架中同时传递。（具体见下）
* 参数可以直接通过其他Lua模块或调试控制台传递。
* 参数按需获取，这样可以避免一些{{tag|ref}}标签的问题。
* 可自定义更多特性。

== 基本用法 ==

首先，您需要通过require函数加载这个模块。这个模块包含了一个名为<code>getArgs</code>的函数。

<source lang="lua">
local getArgs = require('Module:Arguments').getArgs
</source>

最简单的方法是在使用getArgs函数。变量<code>args</code>是包含#invoke参数的表（table）。（详情见下文）
<source lang="lua">
local getArgs = require('Module:Arguments').getArgs
local p = {}

function p.main(frame)
	local args = getArgs(frame)
	-- 主模块放这儿。
end

return p
</source>

但实践中，最好先用专门的函数（指变量{{code|p}}的一个域值，如下文中的p._main）来处理一个特定的参数表（lua的表，与#invoke无关），然后用另一个函数（如下文中的p.main）调用这个函数，并将调用#invoke时传用的参数（即下文中的getArgs(frame)）作为调用这个函数时的参数。这样，其他Lua模块直接调用该模块时，就无需再调用frame对象，从而提升性能，减小开销。

<source lang="lua">
local getArgs = require('Module:Arguments').getArgs
local p = {}

function p.main(frame)
	local args = getArgs(frame) -- 从#invoke中获得的参数
	return p._main(args)
end

function p._main(args)
	-- 主模块放这儿，这里的args是一个纯粹的表
end

return p
</source>

如果你需要多个函数使用这些参数，而且你希望这些函数可用于#invoke，你可以使用包装函数（wrapper function）。

<source lang="lua">
local getArgs = require('Module:Arguments').getArgs

local function makeInvokeFunc(funcName)
	return function (frame)
		local args = getArgs(frame)
		return p[funcName](args)
	end
end

local p = {}

p.func1 = makeInvokeFunc('_func1')

function p._func1(args)
	-- 第一个函数的代码。
end

p.func2 = makeInvokeFunc('_func2')

function p._func2(args)
	-- 第二个函数的代码。
end

return p
</source>

=== 选项 ===

你可以使用如下面这段代码所示的选项。这些选项会在下文中介绍。

<source lang="lua">
local args = getArgs(frame, {
	trim = false,
	removeBlanks = false,
	valueFunc = function (key, value)
		-- 用于处理一个参数的函数的代码。
	end,
	frameOnly = true,
	parentOnly = true,
	parentFirst = true,
	wrappers = {
		'Template:A wrapper template',
		'Template:Another wrapper template'
	},
	readOnly = true,
	noOverwrite = true
})
</source>

=== 移除参数空格和移除空白的参数 ===

Blank arguments often trip up coders new to converting MediaWiki templates to Lua. 在模板中，空白字符串和仅包含空白字符（whitespace，空格、换行等）的字符串被视为假值（false）。然而，在Lua，空白字符串和只包含空白字符的字符串则会被视为真值（true）。这就是说，如果你在写Lua模块时，不注意这些参数，你可能会把本想视为假值的东西视为真值。为了避免这种情况，这个模块默认会移除所有的空白参数。

与之类似，空白字符在处理位置参数（positional arguments）时会发生问题。虽然来自#invoke的命了名的参数的空白字符会被剔除（trim），但是对一些位置参数仍然保留。<!-- Although whitespace is trimmed for named arguments coming from #invoke, it is preserved for positional arguments. -->大多数时候，多余的空白字符是不需要的，所以这个模块默认剔除这些空白字符。

然而，有时输入时又需要使用这些空白字符，或者空白参数。This can be necessary to convert some templates exactly as they were written. 如果你需要不剔除空白字符或移除空白参数，你可以（在调用getArgs函数时）将<code>trim</code>和<code>removeBlanks</code>参数设为<code>false</code>。

<source lang="lua">
local args = getArgs(frame, {
	trim = false,
	removeBlanks = false
})
</source>

=== 对参数进行自定义格式化 ===

有时，你需要移除某些空白参数，但是还有些空白参数又不想移除，或者，你需要将所有位置参数转化为小写字母。你可以使用<code>valueFunc</code>选项。这个参数的值必须是一个接收两个参数<code>key</code>和<code>value</code>并且只返回一个值的函数，这个值是你在{{code|args}}表中索引名为{{code|key}}的域时得到的值。

例1：这个函数不会动第一个参数的空白字符，但是其他参数的空白字符会剔除并移除其他所有空白参数。
<source lang="lua">
local args = getArgs(frame, {
	valueFunc = function (key, value)
		if key == 1 then
			return value
		elseif value then
			value = mw.text.trim(value)
			if value ~= '' then
				return value
			end
		end
		return nil
	end
})
</source>

例2：这个函数移除空白参数并将所有参数转化为小写字母，但是不会剔除位置参数的空白字符。
<source lang="lua">
local args = getArgs(frame, {
	valueFunc = function (key, value)
		if not value then
			return nil
		end
		value = mw.ustring.lower(value)
		if mw.ustring.find(value, '%S') then
			return value
		end
		return nil
	end
})
</source>

注：如果传入了既不是字符串又不是空值（nil）的值，上面这个函数会失败。当你在你的模块的主函数使用<code>getArgs</code>函数，而且那个函数被另一个Lua模块调用时，就可能出现此情况。这种情况下，你需要检查你输入的内容的类型（type）。如果你使用一个专门用于来自#invoke的参数的函数时，不会有这个问题，你如你有<code>p.main</code>和<code>p._main</code>函数，或者类似。

{{cot|带有数据类型检查功能的例1和例2}}
例1：
<source lang="lua">
local args = getArgs(frame, {
	valueFunc = function (key, value)
		if key == 1 then
			return value
		elseif type(value) == 'string' then
			value = mw.text.trim(value)
			if value ~= '' then
				return value
			else
				return nil
			end
		else
			return value
		end
	end
})
</source>

例2：
<source lang="lua">
local args = getArgs(frame, {
	valueFunc = function (key, value)
		if type(value) == 'string' then
			value = mw.ustring.lower(value)
			if mw.ustring.find(value, '%S') then
				return value
			else
				return nil
			end
		else
			return value
		end
	end
})
</source>
{{cob}}

而且，请注意，每次有一个参数被{{code|args}}表请求时，<code>valueFunc</code>函数都会迟早调用。So if you care about performance you should make sure you aren't doing anything inefficient with your code.

=== 框架与父框架 ===

<code>args</code>表中的参数可以从当前框架或父框架同时传递。这句话有点难懂，可以看下面的例子。假设我们有个称为<code>模块:ExampleArgs</code>的模块，这个模块输出（print）前两个传入的位置参数。

{{cot|模块:ExampleArgs的代码}}
<source lang="lua">
local getArgs = require('Module:Arguments').getArgs
local p = {}

function p.main(frame)
	local args = getArgs(frame)
	return p._main(args)
end

function p._main(args)
	local first = args[1] or ''
	local second = args[2] or ''
	return first .. ' ' .. second
end

return p
</source>
{{cob}}

然后，<code>模块:ExampleArgs</code>被<code>模板:ExampleArgs</code>调用，<code>模板:ExampleArgs</code>内容如下：<code><nowiki>{{#invoke:ExampleArgs|main|firstInvokeArg}}</nowiki></code>。它会输出内容firstInvokeArg。

现在，如果我们调用<code>模板:ExampleArgs</code>，其结果如下表所示：

{| class="wikitable" style="width: 50em; max-width: 100%;"
|-
! style="width: 60%;" | 代码
! style="width: 40%;" | 结果
|-
| <code><nowiki>{{ExampleArgs}}</nowiki></code>
| firstInvokeArg
|-
| <code><nowiki>{{ExampleArgs|firstTemplateArg}}</nowiki></code>
| firstInvokeArg
|-
| <code><nowiki>{{ExampleArgs|firstTemplateArg|secondTemplateArg}}</nowiki></code>
| firstInvokeArg secondTemplateArg
|}

有三个选项可以用来改变行为：<code>frameOnly</code>、<code>parentOnly</code>和<code>parentFirst</code>。如果设置<code>frameOnly</code>，那么只有从当前框架传入的参数可以被接受；如果设置 <code>parentOnly</code>，那么只有从父框架传入的参数会被接受；如果你设置<code>parentFirst</code>，那么当前框架和父框架的参数都会接受，但是父框架优先于当前框架。以下是对于<code>模板:ExampleArgs</code>的结果：

; 设为frameOnly时
{| class="wikitable" style="width: 50em; max-width: 100%;"
|-
! style="width: 60%;" | 代码
! style="width: 40%;" | 结果
|-
| <code><nowiki>{{ExampleArgs}}</nowiki></code>
| firstInvokeArg
|-
| <code><nowiki>{{ExampleArgs|firstTemplateArg}}</nowiki></code>
| firstInvokeArg
|-
| <code><nowiki>{{ExampleArgs|firstTemplateArg|secondTemplateArg}}</nowiki></code>
| firstInvokeArg
|}

; 设为parentOnly时
{| class="wikitable" style="width: 50em; max-width: 100%;"
|-
! style="width: 60%;" | 代码
! style="width: 40%;" | 结果
|-
| <code><nowiki>{{ExampleArgs}}</nowiki></code>
| 
|-
| <code><nowiki>{{ExampleArgs|firstTemplateArg}}</nowiki></code>
| firstTemplateArg
|-
| <code><nowiki>{{ExampleArgs|firstTemplateArg|secondTemplateArg}}</nowiki></code>
| firstTemplateArg secondTemplateArg
|}

; 设为parentFirst时
{| class="wikitable" style="width: 50em; max-width: 100%;"
|-
! style="width: 60%;" | 代码
! style="width: 40%;" | 结果
|-
| <code><nowiki>{{ExampleArgs}}</nowiki></code>
| firstInvokeArg
|-
| <code><nowiki>{{ExampleArgs|firstTemplateArg}}</nowiki></code>
| firstTemplateArg
|-
| <code><nowiki>{{ExampleArgs|firstTemplateArg|secondTemplateArg}}</nowiki></code>
| firstTemplateArg secondTemplateArg
|}

注意：
# 如果你同时设置了<code>frameOnly</code>和<code>parentOnly</code>两个选项，模块将不会从#invoke获取任何参数。这显然不是你需要的。
# 有时，父框架可能无效，比如getArgs是从父框架传入的，而不是当前框架。这种情况下，只有框架参数会被使用（除非设置了parentOnly，那种情况下不会使用任何参数），而且<code>parentFirst</code>和<code>frameOnly</code>选项都会没有效果。

=== Wrappers ===

The ''wrappers'' option is used to specify a limited number of templates as ''wrapper templates'', that is, templates whose only purpose is to call a module. If the module detects that it is being called from a wrapper template, it will only check for arguments in the parent frame; otherwise it will only check for arguments in the frame passed to getArgs. This allows modules to be called by either #invoke or through a wrapper template without the loss of performance associated with having to check both the frame and the parent frame for each argument lookup.

For example, the only content of [[Template:Side box]] (excluding content in {{tag|noinclude}} tags) is <code><nowiki>{{#invoke:Side box|main}}</nowiki></code>. There is no point in checking the arguments passed directly to the #invoke statement for this template, as no arguments will ever be specified there. We can avoid checking arguments passed to #invoke by using the ''parentOnly'' option, but if we do this then #invoke will not work from other pages either. If this were the case, the {{para|text|Some text}} in the code <code><nowiki>{{#invoke:Side box|main|text=Some text}}</nowiki></code> would be ignored completely, no matter what page it was used from. By using the <code>wrappers</code> option to specify 'Template:Side box' as a wrapper, we can make <code><nowiki>{{#invoke:Side box|main|text=Some text}}</nowiki></code> work from most pages, while still not requiring that the module check for arguments on the [[Template:Side box]] page itself.

Wrappers can be specified either as a string, or as an array of strings.

<source lang="lua">
local args = getArgs(frame, {
	wrappers = 'Template:Wrapper template'
})
</source>


<source lang="lua">
local args = getArgs(frame, {
	wrappers = {
		'Template:Wrapper 1',
		'Template:Wrapper 2',
		-- Any number of wrapper templates can be added here.
	}
})
</source>

Notes:
# The module will automatically detect if it is being called from a wrapper template's /sandbox subpage, so there is no need to specify sandbox pages explicitly.
# The ''wrappers'' option effectively changes the default of the ''frameOnly'' and ''parentOnly'' options. If, for example, ''parentOnly'' were explicitly set to false with ''wrappers'' set, calls via wrapper templates would result in both frame and parent arguments being loaded, though calls not via wrapper templates would result in only frame arguments being loaded.
# If the ''wrappers'' option is set and no parent frame is available, the module will always get the arguments from the frame passed to <code>getArgs</code>.

=== Writing to the args table ===

Sometimes it can be useful to write new values to the args table. This is possible with the default settings of this module. (However, bear in mind that it is usually better coding style to create a new table with your new values and copy arguments from the args table as needed.)

<source lang="lua">
args.foo = 'some value'
</source>

It is possible to alter this behaviour with the <code>readOnly</code> and <code>noOverwrite</code> options. If <code>readOnly</code> is set then it is not possible to write any values to the args table at all. If <code>noOverwrite</code> is set, then it is possible to add new values to the table, but it is not possible to add a value if it would overwrite any arguments that are passed from #invoke.

=== Ref tags ===

This module uses [[mw:Extension:Scribunto/Lua reference manual#Metatables|metatables]] to fetch arguments from #invoke. This allows access to both the frame arguments and the parent frame arguments without using the <code>pairs()</code> function. This can help if your module might be passed {{tag|ref}} tags as input.

As soon as {{tag|ref}} tags are accessed from Lua, they are processed by the MediaWiki software and the reference will appear in the reference list at the bottom of the article. If your module proceeds to omit the reference tag from the output, you will end up with a phantom reference - a reference that appears in the reference list, but no number that links to it. This has been a problem with modules that use <code>pairs()</code> to detect whether to use the arguments from the frame or the parent frame, as those modules automatically process every available argument.

This module solves this problem by allowing access to both frame and parent frame arguments, while still only fetching those arguments when it is necessary. The problem will still occur if you use <code>pairs(args)</code> elsewhere in your module, however.

=== 已知限制 ===

元表（metatable）的使用也有其缺点。大多数正常Lua表工具都不会对args表正常工作，包括<code>#</code>操作符号、<code>next()</code>函数和表库（table library）中的函数。如果这对你的模块重要，你需要使用你自己的用来处理参数的函数，而不是这个模块。