|
Данный модуль служит для облегчения обработки аргументов, передаваемых в {{code|#invoke}}. Это мета-модуль, предназначенный для использования в других модулях, а не вики-страницах напрямую. Его функционал включает:
<noinclude><!--
* Облегчение обрезки аргументов и удаления пустых аргументов.
-->{{#ifeq:{{SUBPAGENAME}}|doc||{{Documentation subpage}}}}<!--
* Аргументы, передаваемые не только текущим фреймов, но и родительским фреймом. (См. ниже)
--><languages /><!--
* Аргументы, передаваемые из другого модуля или отладочной консоли.
--></noinclude>{{#switch:<translate></translate>
* Аргументы передаются как надо, что может помочь избежать части проблем с тэгами {{xtag|ref|p}}.
| =
* Большинство возможностей поддаются настройке.
<includeonly>{{Languages|Module:Arguments/doc}}</includeonly>
<!-- Add categories where indicated at the bottom of this page and interwikis at Wikidata -->
{{Shared Template Warning|Module:Arguments|Module:Arguments}}
{{Used in system}}
{{Module rating|release}}
{{Module rating|protected}}
== Базовое использование ==
<translate><!--T:1--> This module provides easy processing of arguments passed from <tvar name=1>{{Magic word|#invoke|...|ext=Scribunto|code=1|nowrap=1}}</tvar>.</translate>
Первым делом, необходимо загрузить модуль. Он содержит всего одну функцию — {{code|getArgs}}.
<translate><!--T:2--> It is a meta-module, meant for use by other modules, and should not be called from <tvar name=1>{{tlc|<nowiki>#invoke:...</nowiki>}}</tvar> directly.</translate>
{{luacode|1=
<translate><!--T:3--> Its features include:</translate>
* <translate><!--T:4--> Easy trimming of arguments and removal of blank arguments.</translate>
* <translate><!--T:5--> Arguments can be passed by both the current frame and by the parent frame at the same time.</translate> <translate><!--T:6--> (More details below.)</translate>
* <translate><!--T:7--> Arguments can be passed in directly from another Lua module or from the debug console.</translate>
* <translate><!--T:8--> Arguments are fetched as needed, which can help avoid (some) problems with <tvar name=1>{{xtag|ref}}</tvar> tags.</translate>
* <translate><!--T:9--> Most features can be customized.</translate>
<translate>
== Basic use == <!--T:10-->
</translate>
<translate><!--T:11--> First, you need to load the module.</translate>
<translate><!--T:12--> It contains one function, named <tvar name=1><code>getArgs</code></tvar>.</translate>
<syntaxhighlight lang="lua">
local getArgs = require('Module:Arguments').getArgs
}}
</syntaxhighlight>
В наиболее простом сценарии вы можете использовать {{code|getArgs}} в главной функции вашего модуля. Переменная {{code|args}} содержит таблицу аргументов, переданных в {{code|#invoke}}.
{{luacode|1=
<translate><!--T:13--> In the most basic scenario, you can use <tvar name=1><code>getArgs</code></tvar> inside your main function.</translate>
<translate><!--T:14--> The variable <tvar name=1><code>args</code></tvar> is a table containing the arguments from <tvar name=2>{{tlc|<nowiki>#invoke:...</nowiki>}}</tvar>.</translate>
<translate><!--T:15--> (See below for details.)</translate>
<syntaxhighlight lang="lua">
local getArgs = require('Module:Arguments').getArgs
local p = {}
function p.main(frame)
local args = getArgs(frame)
-- Основной код модуля.
-- <translate nowrap><!--T:16--> Main module code goes here.</translate>
end
return p
}}
</syntaxhighlight>
Тем не менее, принятая практика заключается в использовании функции отдельной функции для получения аргуметов из {{code|#invoke}} и отдельной функции для их обработки — чтобы было проще вызывать ваши функции из другого модуля без передачи аргумента {{code|frame}}, что положительно влияет на производительность.
<translate><!--T:17--> However, the recommended practice is to use a function just for processing arguments from <tvar name=1>{{tlc|<nowiki>#invoke:...</nowiki>}}</tvar>.</translate>
<translate><!--T:18--> This means that if someone calls your module from another Lua module you don't have to have a frame object available, which improves performance.</translate>
{{luacode|1=
<syntaxhighlight lang="lua">
local getArgs = require('Module:Arguments').getArgs
local p = {}
function p._main(args)
-- Основной код модуля.
-- <translate nowrap><!--T:19--> Main module code goes here.</translate>
end
return p
}}
</syntaxhighlight>
Если вам нужно несколько разных функций, использующих аргументы вызова, вы можете использовать функцию-обёртку.
<translate>
<!--T:20-->
If you want multiple functions to use the arguments, and you also want them to be accessible from <tvar name=1>{{tlc|<nowiki>#invoke:...</nowiki>}}</tvar>, you can use a wrapper function.
</translate>
{{luacode|1=
<syntaxhighlight lang="lua">
local getArgs = require('Module:Arguments').getArgs
function p._func1(args)
-- Код первой функции.
-- <translate nowrap><!--T:21--> Code for the first function goes here.</translate>
end
function p._func2(args)
-- Код второй функции.
-- <translate nowrap><!--T:22--> Code for the second function goes here.</translate>
end
return p
}}
</syntaxhighlight>
<translate>
=== Options === <!--T:23-->
</translate>
<translate><!--T:24--> The following options are available.</translate>
<translate><!--T:25--> They are explained in the sections below.</translate>
=== Опции ===
<syntaxhighlight lang="lua">
Доступные опции приведены ниже.
{{luacode|1=
local args = getArgs(frame, {
trim = false,
removeBlanks = false,
valueFunc = function (key, value)
-- код, обрабатывающий единственный аргумент
-- <translate nowrap><!--T:26--> Code for processing one argument</translate>
end,
frameOnly = true,
parentFirst = true,
wrappers = {
'Шаблон:Обёртка',
'Template:A wrapper template',
'Шаблон:Другая обёртка'
'Template:Another wrapper template'
},
readOnly = true,
noOverwrite = true
})
}}
</syntaxhighlight>
=== Обрезка и удаление пробелов ===
<translate>
Пустые аргументы могут представлять сложность при портировании кода шаблонов на Lua. В синтаксисе шаблонов пустые строки или строки из пробелов приравниваются к {{luafalse}}. В Lua же такие строки соответствуют {{luatrue}}. Поэтому, если вы уделите недостаточно внимания обработке таких аргументов, может нарушиться задуманная логика шаблона. Чтобы избежать такого развития событий, по умолчанию модуль удаляет все пустые аргументы.
=== Trimming and removing blanks === <!--T:27-->
</translate>
<translate><!--T:28--> Blank arguments often trip up coders new to converting MediaWiki templates to Lua.</translate>
<translate><!--T:29--> In template syntax, blank strings and strings consisting only of whitespace are considered <tvar name=1><code>false</code></tvar>.</translate>
<translate><!--T:30--> However, in Lua, blank strings and strings consisting of whitespace are considered <tvar name=1><code>true</code></tvar>.</translate>
<translate><!--T:31--> This means that if you don't pay attention to such arguments when you write your Lua modules, you might treat something as <tvar name=1><code>true</code></tvar> that should actually be treated as <tvar name=2><code>false</code></tvar>.</translate>
<translate><!--T:32--> To avoid this, by default this module removes all blank arguments.</translate>
Кроме того, пробелы могут вызывать проблемы при обработке позиционных аргументов. При вызове {{code|#invoke}} из именованных параметров пробелы по краям удаляются сами, но сохраняются для позиционных параметров. Большинство таких пробелов на самом деле не нужно, поэтому модуль по умолчанию их обрезает.
<translate><!--T:33--> Similarly, whitespace can cause problems when dealing with positional arguments.</translate>
<translate><!--T:34--> Although whitespace is trimmed for named arguments coming from <tvar name=1>{{tlc|<nowiki>#invoke:...</nowiki>}}</tvar>, it is preserved for positional arguments.</translate>
<translate><!--T:35--> Most of the time this additional whitespace is not desired, so this module trims it off by default.</translate>
Однако же, если требуется сохранить эти пробелы, можно задать опциям {{code|trim}} и {{code|removeBlanks}} значение {{luafalse}}.
<translate><!--T:36--> However, sometimes you want to use blank arguments as input, and sometimes you want to keep additional whitespace.</translate>
<translate><!--T:37--> This can be necessary to convert some templates exactly as they were written.</translate>
<translate><!--T:38--> If you want to do this, you can set the <tvar name=1><code>trim</code></tvar> and <tvar name=2><code>removeBlanks</code></tvar> arguments to <tvar name=3><code>false</code></tvar>.</translate>
{{luacode|1=
<syntaxhighlight lang="lua">
local args = getArgs(frame, {
trim = false,
removeBlanks = false
})
}}
</syntaxhighlight>
<translate>
=== Custom formatting of arguments === <!--T:39-->
</translate>
<translate><!--T:40--> Sometimes you want to remove some blank arguments but not others, or perhaps you might want to put all of the positional arguments in lower case.</translate>
<translate><!--T:41--> To do things like this you can use the <tvar name=1><code>valueFunc</code></tvar> option.</translate>
<translate><!--T:42--> The input to this option must be a function that takes two parameters, <tvar name=1><code>key</code></tvar> and <tvar name=2><code>value</code></tvar>, and returns a single value.</translate>
<translate><!--T:43--> This value is what you will get when you access the field <tvar name=1><code>key</code></tvar> in the <tvar name=2><code>args</code></tvar> table.</translate>
=== Произвольное форматирование аргументов ===
'''<translate><!--T:44--> Example 1:</translate>'''
В некоторых случаях может потребоваться удалить только часть пустых аргументов или, например, привести все позиционные аргументы к нижнему регистру. Для этого можно использовать опцию {{code|valueFunc}}. На вход этой опции должна подавиться функция от двух параметров, {{var|key}} и {{var|value}}, возвращающая единственное значение. Это значение будет записано в поле {{code|key}} таблицы {{code|args}}.
<translate><!--T:45--> This function preserves whitespace for the first positional argument, but trims all other arguments and removes all other blank arguments.</translate>
Пример 1: оставлять нетронутыми пробелы в первом позиционном аргументе и применять стандартную обрезку для прочих.
<syntaxhighlight lang="lua">
{{luacode|1=
local args = getArgs(frame, {
valueFunc = function (key, value)
end
})
}}
</syntaxhighlight>
'''<translate><!--T:46--> Example 2:</translate>'''
<translate><!--T:47--> This function removes blank arguments and converts all arguments to lower case, but doesn't trim whitespace from positional parameters.</translate>
Пример 2: удалить пробельные и пустые аргументы и привести все аргументы к нижнему регистру, но не обрезать пробелы из позиционных аргументов.
<syntaxhighlight lang="lua">
{{luacode|1=
local args = getArgs(frame, {
valueFunc = function (key, value)
end
})
</syntaxhighlight>
{{Note|text=
<translate><!--T:48--> The above functions will fail if passed input that is not of type <tvar name=1><code>string</code></tvar> or <tvar name=2><code>nil</code></tvar>.</translate>
<translate><!--T:49--> This might be the case if you use the <tvar name=1><code>getArgs</code></tvar> function in the main function of your module, and that function is called by another Lua module.</translate>
<translate><!--T:50--> In this case, you will need to check the type of your input.</translate>
<translate><!--T:51--> This is not a problem if you are using a function specially for arguments from <tvar name=1>{{tlc|<nowiki>#invoke:...</nowiki>}}</tvar> (i.e. you have <tvar name=2><code>p.main</code></tvar> and <tvar name=3><code>p._main</code></tvar> functions, or something similar).</translate>
}}
Замечание: функции выше выдадут ошибку, если входные аргументы не будут принадлежать к типу {{code|string}} или {{luanil}}. Это может произойти при вызове функции {{code|getArgs}} из другого модуля. В этом случае требуется проверка типов. В обычном случае при вызове из {{code|#invoke}} такая проблема не стоит.
{{Collapse top|1=<translate><!--T:52--> Examples 1 and 2 with type checking</translate>}}
<translate>
{{Начало скрытого блока|Примеры 1 и 2 с проверкой типов}}
<!--T:53-->
Пример 1:
Example 1:
{{luacode|1=
</translate>
<syntaxhighlight lang="lua">
local args = getArgs(frame, {
valueFunc = function (key, value)
end
})
}}
</syntaxhighlight>
Пример 2 2:
<translate>
{{luacode|1=
<!--T:54-->
Example 2:
</translate>
<syntaxhighlight lang="lua">
local args = getArgs(frame, {
valueFunc = function (key, value)
end
})
}}
</syntaxhighlight>
{{конец скрытого блока}}
{{Collapse bottom}}
Также следует обращать внимание, что функция {{code|valueFunc}} вызывается приблизительно при каждом запросе к таблице {{code|args}}, так что если стоит вопрос производительности, эта функция не должна быть дорогой.
<translate>
<!--T:55-->
Also, please note that the <tvar name=1><code>valueFunc</code></tvar> function is called more or less every time an argument is requested from the <tvar name=2><code>args</code></tvar> table, so if you care about performance you should make sure you aren't doing anything inefficient with your code.
=== Фреймы и родительские фреймы ===
=== Frames and parent frames === <!--T:56-->
Аргументы в таблице {{code|args}} могут одновременно передаваться из текущего фрейма и его родительского фрейма. Это можно понять на примере. Например, есть модуль {{code|Module:ExampleArgs}}, работа которого заключается в выводе двух первых переданных позиционных аргументов.
</translate>
{{Начало скрытого блока|Код модуля ExampleArgs}}
<translate><!--T:57--> Arguments in the <tvar name=1><code>args</code></tvar> table can be passed from the current frame or from its parent frame at the same time.</translate>
{{luacode|1=
<translate><!--T:58--> To understand what this means, it is easiest to give an example.</translate>
<translate><!--T:59--> Let's say that we have a module called <tvar name=1><code>Module:ExampleArgs</code></tvar>.</translate>
<translate><!--T:60--> This module prints the first two positional arguments that it is passed.</translate>
{{Collapse top|1=<translate><!--T:61--> <tvar name=1>Module:ExampleArgs</tvar> code</translate>}}
<syntaxhighlight lang="lua">
local getArgs = require('Module:Arguments').getArgs
local p = {}
return p
}}
</syntaxhighlight>
{{конец скрытого блока}}
{{Collapse bottom}}
{{code|Модуль:ExampleArgs}} вызывается шаблоном {{tc|ExampleArgs}}, код которого — {{tc|#invoke:ExampleArgs|main|первый_аргумент_вызова}}. По умолчанию он возвращает текст «первый_аргумент_вызова».
<translate><!--T:62--> <tvar name=1><code>Module:ExampleArgs</code></tvar> is then called by <tvar name=2><code>Template:ExampleArgs</code></tvar>, which contains the code <tvar name=3><code><nowiki>{{#invoke:ExampleArgs|main|firstInvokeArg}}</nowiki></code></tvar>.</translate>
<translate><!--T:63--> This produces the result <tvar name=1>"firstInvokeArg"</tvar>.</translate>
Далее возможны следующие варианты:
<translate>
<!--T:64-->
Now if we were to call <tvar name=1><code>Template:ExampleArgs</code></tvar>, the following would happen:
</translate>
{{(!}}| class="wikitable" style="width: 50em70em; max-width: 100%;"
|-
{{!}}-
! style="width: 60%;" {{!}}| <translate><!--T:65--> Code</translate>Код
! style="width: 40%;" {{!}}| <translate><!--T:66--> Result</translate>Результат
|-
{{!}}-
{{!}}| <code><nowiki>{{tc|ExampleArgs}}</nowiki></code>
| первый_аргумент_вызова
{{!}} firstInvokeArg
|-
{{!}}-
| {{tc|ExampleArgs|первый_аргумент_вызова}}
{{!}} <code><nowiki>{{ExampleArgs|firstTemplateArg}}</nowiki></code>
| первый_аргумент_вызова
{{!}} firstInvokeArg
|-
{{!}}-
| {{tc|ExampleArgs|первый_аргумент_вызова|второй_аргумент_вызова}}
{{!}} <code><nowiki>{{ExampleArgs|firstTemplateArg|secondTemplateArg}}</nowiki></code>
| первый_аргумент_вызова второй_аргумент_вызова
{{!}} firstInvokeArg secondTemplateArg
|}
{{!)}}
Это поведение можно изменить тремя опциями: {{code|frameOnly}}, {{code|parentOnly}} и {{code|parentFirst}}. При установке {{code|frameOnly}} будут обрабатываться только аргументы фрейма, где происходит непосредственно вызов {{code|#invoke}}; при установке {{code|parentOnly}} будут обрабатываться только аргументы родительского фрейма; при установке {{code|parentFirst}} будут обрабатываться аргументы из обоих фреймов, но в первую очередь родительского. В случае рассматриваемого {{tc|ExampleArgs}} это будет выглядеть так:
<translate><!--T:67--> There are three options you can set to change this behaviour: <tvar name=1><code>frameOnly</code></tvar>, <tvar name=2><code>parentOnly</code></tvar> and <tvar name=3><code>parentFirst</code></tvar>.</translate>
<translate><!--T:68--> If you set <tvar name=1><code>frameOnly</code></tvar> then only arguments passed from the current frame will be accepted; if you set <tvar name=2><code>parentOnly</code></tvar> then only arguments passed from the parent frame will be accepted; and if you set <tvar name=3><code>parentFirst</code></tvar> then arguments will be passed from both the current and parent frames, but the parent frame will have priority over the current frame.</translate>
<translate><!--T:69--> Here are the results in terms of <tvar name=1><code>Template:ExampleArgs</code></tvar>:</translate>
; frameOnly
<dl>
{| class="wikitable" style="width: 70em; max-width: 100%;"
<dt><code>frameOnly</code></dt>
|-
<dd>
{{(!}} class="wikitable" style="width: 50em60%;" max-width:| 100%;"Код
! style="width: 40%;" | Результат
{{!}}-
|-
! style="width: 60%;" {{!}} <translate><!--T:70--> Code</translate>
| {{tc|ExampleArgs}}
! style="width: 40%;" {{!}} <translate><!--T:71--> Result</translate>
| первый_аргумент_вызова
{{!}}-
|-
{{!}} <code><nowiki>{{ExampleArgs}}</nowiki></code>
| {{tc|ExampleArgs|первый_аргумент_шаблона}}
{{!}} firstInvokeArg
| первый_аргумент_вызова
{{!}}-
|-
{{!}} <code><nowiki>{{ExampleArgs|firstTemplateArg}}</nowiki></code>
| {{tc|ExampleArgs|первый_аргумент_шаблона|второй_аргумент_шаблона}}
{{!}} firstInvokeArg
| первый_аргумент_вызова
{{!}}-
|}
{{!}} <code><nowiki>{{ExampleArgs|firstTemplateArg|secondTemplateArg}}</nowiki></code>
{{!}} firstInvokeArg
{{!)}}
</dd>
<dt><code>; parentOnly</code></dt>
{| class="wikitable" style="width: 70em; max-width: 100%;"
<dd>
|-
{{(!}} class="wikitable" style="width: 50em; max-width: 100%;"
! style="width: 60%;" | Код
{{!}}-
! style="width: 6040%;" {{!}}| <translate><!--T:72--> Code</translate>Результат
|-
! style="width: 40%;" {{!}} <translate><!--T:73--> Result</translate>
| {{tc|ExampleArgs}}
{{!}}-
|
{{!}} <code><nowiki>{{ExampleArgs}}</nowiki></code>
|-
{{!}}
| {{tc|ExampleArgs|первый_аргумент_шаблона}}
{{!}}-
| первый_аргумент_шаблона
{{!}} <code><nowiki>{{ExampleArgs|firstTemplateArg}}</nowiki></code>
|-
{{!}} firstTemplateArg
| {{tc|ExampleArgs|первый_аргумент_шаблона|второй_аргумент_шаблона}}
{{!}}-
| первый_аргумент_шаблона второй_аргумент_шаблона
{{!}} <code><nowiki>{{ExampleArgs|firstTemplateArg|secondTemplateArg}}</nowiki></code>
|}
{{!}} firstTemplateArg secondTemplateArg
{{!)}}
</dd>
<dt><code>; parentFirst</code></dt>
{| class="wikitable" style="width: 70em; max-width: 100%;"
<dd>
|-
{{(!}} class="wikitable" style="width: 50em; max-width: 100%;"
! style="width: 60%;" | Код
{{!}}-
! style="width: 6040%;" {{!}}| <translate><!--T:74--> Code</translate>Результат
|-
! style="width: 40%;" {{!}} <translate><!--T:75--> Result</translate>
| {{tc|ExampleArgs}}
{{!}}-
| первый_аргумент_вызова
{{!}} <code><nowiki>{{ExampleArgs}}</nowiki></code>
|-
{{!}} firstInvokeArg
| {{tc|ExampleArgs|первый_аргумент_шаблона}}
{{!}}-
| первый_аргумент_шаблона
{{!}} <code><nowiki>{{ExampleArgs|firstTemplateArg}}</nowiki></code>
|-
{{!}} firstTemplateArg
| {{tc|ExampleArgs|первый_аргумент_шаблона|второй_аргумент_шаблона}}
{{!}}-
| первый_аргумент_шаблона второй_аргумент_шаблона
{{!}} <code><nowiki>{{ExampleArgs|firstTemplateArg|secondTemplateArg}}</nowiki></code>
|}
{{!}} firstTemplateArg secondTemplateArg
{{!)}}
</dd>
</dl>
Замечания:
{{Note|text=
# При установке одновременно опций {{code|frameOnly}} и {{code|parentOnly}} модуль не получит никаких аргументов из {{code|#invoke}}. Так делать не стоит.
{{Ordered list
# В некоторых ситуациях родительский фрейм может быть недоступен, например, если он был сразу подан на вход функции {{code|getArgs}}. Тогда могут использоваться лишь аргументы этого фрейма (если установлена опция {{code|parentOnly}}, то никакие аргументы получить не удастся), а {{code|parentFirst}} и {{code|frameOnly}} не будут иметь эффекта.
|1=
<translate><!--T:76--> If you set both the <tvar name=1><code>frameOnly</code></tvar> and <tvar name=2><code>parentOnly</code></tvar> options, the module won't fetch any arguments at all from <tvar name=3>{{tlc|<nowiki>#invoke:...</nowiki>}}</tvar>.</translate>
<translate><!--T:77--> This is probably not what you want.</translate>
|2=
<translate><!--T:78--> In some situations a parent frame may not be available, e.g. if <tvar name=1><code>getArgs</code></tvar> is passed the parent frame rather than the current frame.</translate>
<translate><!--T:79--> In this case, only the frame arguments will be used (unless <tvar name=1><code>parentOnly</code></tvar> is set, in which case no arguments will be used) and the <tvar name=2><code>parentFirst</code></tvar> and <tvar name=3><code>frameOnly</code></tvar> options will have no effect.</translate>
}}
}}
=== Обёртки ===
<translate>
Опция {{var|wrappers}} используется для указания ограниченного числа шаблонов как ''шаблонов-обёрток'', то есть шаблонов, чьей единственной целью является вызов модуля. Если модуль обнаружит, что вызывается из шаблона-обёртки, то будут проверяться только аргументы родительского фрейма, иначе будут проверяться только аргументы непосредственного вызывающего фрейма. Это позволяет вызвать модули через {{code|#invoke}} и через шаблон-обёртку без потери производительности из-за поиска аргументов в двух фреймах.
=== Wrappers === <!--T:80-->
</translate>
Например, единственное содержимое шаблона {{tl|optp}} вне тэгов {{tag|noinclude}} это вызов <nowiki>{{#invoke:Template call code|onlyParams}}</nowiki>. Нет смысла проверять аргументы, передаваемые {{code|#invoke}} на странице шаблона, поскольку там их никогда не будет. Этого можно избежать с помощью опции {{var|parentOnly}}, но тогда {{code|#invoke}} не будет работать и на других страницах. В таком случае параметр {{para|text|Некий текст}} в коде <code><nowiki>{{#invoke:Template call code|onlyParams|text=Некий текст}}</nowiki></code> игнорировался бы на всех страницах. Но если мы укажем в опции {{var|wrappers}} 'Шаблон:Optp', код <code><nowiki>{{#invoke:Template call code|onlyParams|text=Некий текст}}</nowiki></code> будет работать на всех страницах, не проверяя аргументы на странице шаблона.
<translate><!--T:81--> The <tvar name=1><code>wrappers</code></tvar> option is used to specify a limited number of templates as ''wrapper templates'', that is, templates whose only purpose is to call a module.</translate>
<translate><!--T:82--> 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 <tvar name=1><code>getArgs</code></tvar>.</translate>
<translate><!--T:83--> This allows modules to be called by either <tvar name=1>{{tlc|<nowiki>#invoke:...</nowiki>}}</tvar> 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.</translate>
Обёртки могут задаваться строкой или массивом строк.
<translate><!--T:84--> For example, the only content of <tvar name=1>{{tlx|Navbox}}</tvar> (excluding content in <tvar name=2>{{tag|noinclude}}</tvar> tags) is <tvar name=3><code><nowiki>{{#invoke:Navbox|navbox}}</nowiki></code></tvar>.</translate>
<translate><!--T:85--> There is no point in checking the arguments passed directly to the <tvar name=1>{{tlc|<nowiki>#invoke:...</nowiki>}}</tvar> statement for this template, as no arguments will ever be specified there.</translate>
<translate><!--T:86--> We can avoid checking arguments passed to <tvar name=1>{{tlc|<nowiki>#invoke:...</nowiki>}}</tvar> by using the <tvar name=2><code>parentOnly</code></tvar> option, but if we do this then <tvar name=1>{{tlc|<nowiki>#invoke:...</nowiki>}}</tvar> will not work from other pages either.</translate>
<translate><!--T:87--> If this were the case, then {{<tvar name=1>tmpl|0={{para|text|$1}}</tvar>|Some text}} in the code {{<tvar name=2>tmpl|0={{tlc|<nowiki>#invoke:Navbox</nowiki>|navbox|3=text=$1}}</tvar>|Some text}} would be ignored completely, no matter what page it was used from.</translate>
<translate><!--T:88--> By using the <tvar name=1><code>wrappers</code></tvar> option to specify <tvar name=2>[[Template:Navbox]]</tvar> as a wrapper, we can make {{<tvar name=3>tmpl|0={{tlc|<nowiki>#invoke:Navbox</nowiki>|main|3=text=$1}}</tvar>|Some text}} work from most pages, while still not requiring that the module check for arguments on the <tvar name=2>[[Template:Navbox]]</tvar> page itself.</translate>
{{luacode|1=
<translate>
<!--T:89-->
Wrappers can be specified either as a string, or as an array of strings.
</translate>
<syntaxhighlight lang="lua">
local args = getArgs(frame, {
wrappers = 'TemplateШаблон:Wrapper templateОбёртка'
})
}}
</syntaxhighlight>
{{luacode|1=
<syntaxhighlight lang="lua">
local args = getArgs(frame, {
wrappers = {
'TemplateШаблон:WrapperОбёртка 1',
'TemplateШаблон:WrapperОбёртка 2',
-- Тут может быть задано любое количество шаблонов.
-- <translate nowrap><!--T:90--> Any number of wrapper templates can be added here.</translate>
}
})
</syntaxhighlight>
{{Note|text=
{{Ordered list
|1=
<translate><!--T:91--> The module will automatically detect if it is being called from a wrapper template's <tvar name=1><code>/sandbox</code></tvar> subpage, so there is no need to specify sandbox pages explicitly.</translate>
|2=
<translate><!--T:92--> The <tvar name=1><code>wrappers</code></tvar> option effectively changes the default of the <tvar name=2><code>frameOnly</code></tvar> and <tvar name=3><code>parentOnly</code></tvar> options.</translate>
<translate><!--T:93--> If, for example, <tvar name=1><code>parentOnly</code></tvar> were explicitly set to <tvar name=2><code>false</code></tvar> with <tvar name=3><code>wrappers</code></tvar> 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.</translate>
|3=
<translate><!--T:94--> If the <tvar name=1><code>wrappers</code></tvar> option is set and no parent frame is available, the module will always get the arguments from the frame passed to <tvar name=2><code>getArgs</code></tvar>.</translate>
}}
}}
Замечания:
<translate nowrap>
# Модуль автоматически определяет, если вызывается с подстраницы /песочница шаблона-обёртки, такие страницы не надо задавать явным образом.
=== Writing to the <tvar name=1><code>args</code></tvar> table === <!--T:95-->
# Опция{{var|wrappers}} изменяет поведение по умолчанию опций {{var|frameOnly}} и {{var|parentOnly}}. Например, если {{var|parentOnly}} явным образом установлена в {{luafalse}} при установленных {{var|wrappers}}, вызов через обёртку будет приводить к проверке аргументов текущего и родительского фрейма, тогда как другие вызовы будут проверять только текущие аргументы.
</translate>
# Если опция {{var|wrappers}} установлена и родительский фрейм недоступен, модуль всегда будет получать аргументы, переданные функции {{code|getArgs}}.
<translate><!--T:96--> Sometimes it can be useful to write new values to the <tvar name=1><code>args</code></tvar> table.</translate>
<translate><!--T:97--> This is possible with the default settings of this module.</translate>
<translate><!--T:98--> (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 <tvar name=1><code>args</code></tvar> table as needed.)</translate>
=== Запись в таблицу args ===
<syntaxhighlight lang="lua">
Иногда может быть полезно записать новые значения в таблицу {{code|args}}. При настройках данного модуля по умолчанию это возможно. (Тем не менее, в большинстве случаев лучшим подходом будет создать новую таблицу с новыми значениями и копировать туда нужные значения {{code|args}}.)
args.foo = '<translate nowrap><!--T:99--> some value</translate>'
</syntaxhighlight>
{{luacode|1=
<translate><!--T:100--> It is possible to alter this behaviour with the <tvar name=1><code>readOnly</code></tvar> and <tvar name=2><code>noOverwrite</code></tvar> options.</translate>
args.foo = 'some value'
<translate><!--T:101--> If <tvar name=1><code>readOnly</code></tvar> is set then it is not possible to write any values to the <tvar name=2><code>args</code></tvar> table at all.</translate>
}}
<translate><!--T:102--> If <tvar name=1><code>noOverwrite</code></tvar> 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 <tvar name=2>{{tlc|<nowiki>#invoke:...</nowiki>}}</tvar>.</translate>
С помощью установки опций {{var|readOnly}} и {{var|noOverwrite}} это поведение можно переопределить. Если установлена опция {{var|readOnly}}, в таблицу {{code|args}} нельзя вносить изменения вообще. При установке же опции {{var|noOverwrite}} можно добавлять новые значения, но нельзя менять уже имеющиеся в таблице значения, полученные из {{code|#invoke}}.
<translate>
=== Ref tags === <!--T:103-->
</translate>
<translate><!--T:104--> This module uses [[<tvar name=1>mw:Special:MyLanguage/Extension:Scribunto/Lua reference manual#Metatables</tvar>|metatables]] to fetch arguments from <tvar name=2>{{tlc|<nowiki>#invoke:...</nowiki>}}</tvar>.</translate>
<translate><!--T:105--> This allows access to both the frame arguments and the parent frame arguments without using the <tvar name=1><code>pairs()</code></tvar> function.</translate>
<translate><!--T:106--> This can help if your module might be passed <tvar name=1>{{xtag|ref}}</tvar> tags as input.</translate>
=== Тэги ref ===
<translate><!--T:107--> As soon as <tvar name=1>{{xtag|ref}}</tvar> 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.</translate>
Данный модуль использует [[mw:Extension:Scribunto/Lua reference manual/ru#Metatables|метатаблицы]], чтобы получить аргументы {{code|#invoke}}. Это даёт доступ одновременно к аргументом фрейма и родительского фрейма без использования функции {{luacode|pairs()|inline=1}}. Это может быть полезно при передаче на вход тэгов {{xtag|ref|p}}.
<translate><!--T:108--> 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.</translate>
<translate><!--T:109--> This has been a problem with modules that use <tvar name=1><code>pairs()</code></tvar> to detect whether to use the arguments from the frame or the parent frame, as those modules automatically process every available argument.</translate>
Поскольку из Lua происходит доступ к тэгам {{tag|ref}}, они обрабатываются движком MediaWiki и примечание появляется в списке примечаний ({{tag|referenes|s}}). Если модуль не выводит содержимое тэгов, то может появиться сноска-призрак, отображающаяся только в списке примечаний, но не в основном тексте. Это может являться проблемой для модулей, использующих {{luacode|pairs()|inline=1}} для доступа к аргументам, поскольку эта функция осуществляет доступ ко всем доступным аргументам.
<translate><!--T:110--> 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.</translate>
<translate><!--T:111--> The problem will still occur if you use <tvar name=1><code>pairs(args)</code></tvar> elsewhere in your module, however.</translate>
Эта проблема не стоит при использовании данного модуля, поскольку хотя доступ к аргументам производится только по необходимости. Однако же при явном вызове {{luacode|pairs(args)|inline=1}} в коде функций, ошибочное поведение может воспроизводиться.
<translate>
=== Known limitations === <!--T:112-->
</translate>
<translate><!--T:113--> The use of metatables also has its downsides.</translate>
<translate><!--T:114--> Most of the normal Lua table tools won't work properly on the <tvar name=4><code>args</code></tvar> table, including the <tvar name=1><code>#</code></tvar> operator, the <tvar name=2><code>next()</code></tvar> function, and the functions in the <tvar name=3><code>table</code></tvar> library.</translate>
<translate><!--T:115--> If using these is important for your module, you should use your own argument processing function instead of this module.</translate>
=== Известные ограничения ===
<translate>
У использования метатаблиц есть свои недостатки. Большинство инструментов для работы с обычными таблицами Lua не будут корректно работать с таблицей {{code|args}}, включая оператор {{code|#}}, функцию {{luacode|next()|inline=1}} и функции из стандартной библиотеки {{code|table}}. Если данные функции необходимы для работы модуля, может понадобиться своя реализация обработки аргументов. Также возможно использование функций из модуля [[Module:TableTools|TableTools]].
== Tests == <!--T:116-->
<includeonly>{{#ifeq:{{SUBPAGENAME}}|sandbox||
</translate>
[[Категория:Модули:Базовые]]
{{ModuleQuality}}
}}</includeonly>{{Sandbox other||
<!-- Categories below this line; interwikis at Wikidata -->
[[Category:Lua metamodules{{#translation:}}]]
}}</includeonly><noinclude>
[[Category:Module documentation pages{{#translation:}}]]
</noinclude>
| #default=
{{#invoke:Template translation|renderTranslatedTemplate|template=Module:Arguments/doc|noshift=1|uselang={{int:lang}}}}
}}
|