Fuhrer: 1 wersja

2026-07-24T10:03:50Z

1 wersja

← poprzednia wersja		Wersja z 10:03, 24 lip 2026
(Brak różnic)

mediawiki>HanV o 13:21, 13 lis 2025

2025-11-13T13:21:52Z

Nowa strona

<noinclude>{{#ifeq:{{SUBPAGENAME}}|doc||{{Documentation subpage}}}}<languages /></noinclude>{{#switch:
| =
<includeonly>{{Languages|Module:Arguments/doc}}</includeonly>

{{Used in system}}
{{Module rating|release}}
{{Module rating|protected}}

Deze module biedt eenvoudige verwerking aan van argumenten die door {{Magic word|#invoke|...|ext=Scribunto|code=1|nowrap=1}} zijn doorgegeven.
Het is een meta-module, bedoeld voor gebruik door andere modules, en mag niet direct vanaf {{tlc|<nowiki>#invoke:...</nowiki>}} worden aangeroepen.
De functies bevatten:

* Eenvoudig trimmen van argumenten en verwijderen van lege argumenten.
* Argumenten kunnen tegelijkertijd door zowel het huidige frame als het bovenliggende frame worden doorgegeven. (Meer details hieronder.)
* Argumenten kunnen rechtstreeks vanuit een andere Lua-module of vanuit de debug-console worden doorgegeven.
* Argumenten worden indien nodig opgehaald, wat kan helpen om (sommige) problemen met de {{xtag|ref}} tags te voorkomen.
* De meeste functies kunnen worden aangepast.


== Basisgebruik ==
Eerst moet u de module laden.
Het bevat één functie, <code>getArgs</code>.

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

In het meest eenvoudige scenario kunt u <code>getArgs</code> gebruiken binnen uw hoofdfunctie.
De variabele <code>args</code> is een tabel met de argumenten van {{tlc|<nowiki>#invoke:...</nowiki>}}.
(Voor meer details zie hieronder.)

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

function p.main(frame)
local args = getArgs(frame)
-- Hier komt de hoofdmodule.
end

return p
</syntaxhighlight>

De aanbevolen praktijk is echter om een functie alleen te gebruiken voor het verwerken van argumenten vanaf {{tlc|<nowiki>#invoke:...</nowiki>}}.
Dit betekent dat als iemand de module uit een andere Lua-module roept, men geen frame-object hoeft te hebben, wat de prestaties verbetert.

<syntaxhighlight 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)
-- Hier komt de code van de hoofdmodule.
end

return p
</syntaxhighlight>

Als u meerdere functies wilt gebruiken om de argumenten te gebruiken, en u wilt ook dat ze vanaf {{tlc|<nowiki>#invoke:...</nowiki>}} toegankelijk zijn, kunt u een wrapper-functie gebruiken.

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

local p = {}

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

p.func1 = makeInvokeFunc('_func1')

function p._func1(args)
-- De code voor de eerste functie komt hier.
end

p.func2 = makeInvokeFunc('_func2')

function p._func2(args)
-- De code voor de tweede functie komt hier.
end

return p
</syntaxhighlight>


=== Opties ===
De volgende opties zijn beschikbaar:
Deze worden in de onderstaande secties uitgelegd.

<syntaxhighlight lang="lua">
local args = getArgs(frame, {
trim = false,
removeBlanks = false,
valueFunc = function (key, value)
-- Code voor het verwerken van een argument
end,
frameOnly = true,
parentOnly = true,
parentFirst = true,
wrappers = {
'Template:A wrapper template',
'Template:Another wrapper template'
},
readOnly = true,
noOverwrite = true
})
</syntaxhighlight>


=== Trimmen en verwijderen van spaties ===
Lege argumenten zorgen vaak voor problemen bij programmeurs die nieuw zijn bij het omzetten van MediaWiki-sjablonen naar Lua.
In de sjabloonsyntaxis worden lege teksten en teksten die alleen uit spaties bestaan als <code>false</code> beschouwd.
In Lua worden deze beide echter als <code>true</code> beschouwd.
Dit betekent dat als men niet let op dergelijke argumenten let wanneer men een Lua-modules schrijft, men iets als <code>true</code> zou kunnen behandelen dat eigenlijk als <code>false</code> zou moeten worden behandeld.
Om dit te voorkomen verwijdert deze module standaard alle lege argumenten.

Op dezelfde manier kan witruimte (spaties) problemen veroorzaken bij het omgaan met positionele argumenten.
Hoewel witruimte is getrimd voor benoemde argumenten die afkomstig zijn van {{tlc|<nowiki>#invoke:...</nowiki>}}, wordt het bewaard voor positionele argumenten.
De meeste tijd is deze extra witruimte niet gewild, dus trimt deze module het standaard af.

Soms wil men echter lege argumenten gebruiken als input, en soms wil men extra witruimte behouden.
Dit kan nodig zijn om sommige sjablonen precies zoals ze werden geschreven om te zetten.
Als men dit wil doen, kan men de argumenten <code>trim</code> en <code>removeBlanks</code> instellen op <code>false</code>.

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


=== Aangepaste opmaak van argumenten ===
Soms wil men enkele lege argumenten verwijderen, maar niet andere, of misschien wil men al de positionele argumenten in kleine letters omzetten.
Om zoiets te doen kan men de optie <code>valueFunc</code> gebruiken.
De invoer van deze optie moet een functie zijn die twee parameters, <code>key</code> en <code>value</code>, heeft en een enkele waarde teruggeeft.
Deze waarde wordt verkregen wanneer u het veld <code>key</code> in de tabel <code>args</code> opzoekt.

'''Voorbeeld 1:'''
Deze functie behoudt witruimte voor het eerste positionele argument, maar trimt alle andere argumenten en verwijdert alle andere lege argumenten.

<syntaxhighlight 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
})
</syntaxhighlight>

'''Voorbeeld 2:'''
Deze functie verwijdert lege argumenten en zet alle argumenten om in kleine letters, maar trimt geen witruimte van positionele parameters.

<syntaxhighlight 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
})
</syntaxhighlight>

{{Note|text=
De bovenstaande functies zullen falen als invoert wordt doorgegeven die niet van type <code>string</code> of <code>nil</code> is.
Dit kan het geval zijn als u de functie <code>getArgs</code> gebruikt in de hoofdfunctie van uw module, en die functie wordt aangeroepen door een andere Lua-module.
In dit geval moet u het type van uw invoer controleren.
Dit is geen probleem als u een functie gebruikt speciaal voor argumenten van {{tlc|<nowiki>#invoke:...</nowiki>}} (d.w.z. u heeft functies van <code>p.main</code> en <code>p._main</code> of iets soortgelijks).
}}

{{Collapse top|1=Voorbeelden 1 en 2 met typecontrole}}
Voorbeeld 1:
<syntaxhighlight 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
})
</syntaxhighlight>

Voorbeeld 2:
<syntaxhighlight 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
})
</syntaxhighlight>
{{Collapse bottom}}

Houd er ook rekening mee dat de functie <code>valueFunc</code> meer of minder wordt aangeroepen elke keer dat een argument wordt gevraagd uit de <code>args</code> tabel, dus als u om prestaties geeft moet u ervoor zorgen dat u niets inefficiënt doet in uw code.


=== Frames en bovenliggende frames ===

Argumenten in de tabel <code>args</code> kunnen tegelijkertijd worden doorgegeven vanuit het huidige frame of vanuit het bovenliggende frame (parent).
Om beter te begrijpen wat dit betekent, geven we een voorbeeld.
Laten we zeggen dat we een module <code>Module:ExampleArgs</code> hebben.
Deze module print de eerste twee positionele argumenten die het ontvangt.

{{Collapse top|1=code Module:ExampleArgs}}
<syntaxhighlight 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
</syntaxhighlight>
{{Collapse bottom}}

<code>Module:ExampleArgs</code> wordt dan aangeroepen door <code>Template:ExampleArgs</code>, die de code <code><nowiki>{{#invoke:ExampleArgs|main|firstInvokeArg}}</nowiki></code> bevat.
Dit geeft het resultaat "firstInvokeArg".

Als we nu <code>Template:ExampleArgs</code> zouden aanroepen, zou het volgende gebeuren:

{{(!}} class="wikitable" style="width: 50em; max-width: 100%;"
{{!}}-
! style="width: 60%;" {{!}} Code
! style="width: 40%;" {{!}} Resultaat
{{!}}-
{{!}} <code><nowiki>{{ExampleArgs}}</nowiki></code>
{{!}} firstInvokeArg
{{!}}-
{{!}} <code><nowiki>{{ExampleArgs|firstTemplateArg}}</nowiki></code>
{{!}} firstInvokeArg
{{!}}-
{{!}} <code><nowiki>{{ExampleArgs|firstTemplateArg|secondTemplateArg}}</nowiki></code>
{{!}} firstInvokeArg secondTemplateArg
{{!)}}

Er zijn drie opties die u kunt instellen om dit gedrag te veranderen: <code>frameOnly</code>, <code>parentOnly</code> en <code>parentFirst</code>.
Als u <code>frameOnly</code> instelt, worden alleen de argumenten die zijn overgebracht uit het huidige frame geaccepteerd; als u <code>parentOnly</code> instelt, zullen alleen de argumenten die zijn overgenomen uit het bovenliggende frame worden geaccepteerd; en als u <code>parentFirst</code> instelt, dan zullen argumenten worden overgebracht van zowel het huidige als het bovenliggende frame, maar het bovenliggende frame zal voorrang hebben boven het huidige frame.
Dit zijn de resultaten in termen van <code>Template:ExampleArgs</code>:

<dl>
<dt><code>frameOnly</code></dt>
<dd>
{{(!}} class="wikitable" style="width: 50em; max-width: 100%;"
{{!}}-
! style="width: 60%;" {{!}} Code
! style="width: 40%;" {{!}} Resultaat
{{!}}-
{{!}} <code><nowiki>{{ExampleArgs}}</nowiki></code>
{{!}} firstInvokeArg
{{!}}-
{{!}} <code><nowiki>{{ExampleArgs|firstTemplateArg}}</nowiki></code>
{{!}} firstInvokeArg
{{!}}-
{{!}} <code><nowiki>{{ExampleArgs|firstTemplateArg|secondTemplateArg}}</nowiki></code>
{{!}} firstInvokeArg
{{!)}}
</dd>

<dt><code>parentOnly</code></dt>
<dd>
{{(!}} class="wikitable" style="width: 50em; max-width: 100%;"
{{!}}-
! style="width: 60%;" {{!}} Code
! style="width: 40%;" {{!}} Resultaat
{{!}}-
{{!}} <code><nowiki>{{ExampleArgs}}</nowiki></code>
{{!}}
{{!}}-
{{!}} <code><nowiki>{{ExampleArgs|firstTemplateArg}}</nowiki></code>
{{!}} firstTemplateArg
{{!}}-
{{!}} <code><nowiki>{{ExampleArgs|firstTemplateArg|secondTemplateArg}}</nowiki></code>
{{!}} firstTemplateArg secondTemplateArg
{{!)}}
</dd>

<dt><code>parentFirst</code></dt>
<dd>
{{(!}} class="wikitable" style="width: 50em; max-width: 100%;"
{{!}}-
! style="width: 60%;" {{!}} Code
! style="width: 40%;" {{!}} Resultaat
{{!}}-
{{!}} <code><nowiki>{{ExampleArgs}}</nowiki></code>
{{!}} firstInvokeArg
{{!}}-
{{!}} <code><nowiki>{{ExampleArgs|firstTemplateArg}}</nowiki></code>
{{!}} firstTemplateArg
{{!}}-
{{!}} <code><nowiki>{{ExampleArgs|firstTemplateArg|secondTemplateArg}}</nowiki></code>
{{!}} firstTemplateArg secondTemplateArg
{{!)}}
</dd>
</dl>

{{Note|text=
{{Ordered list
|1=
Als u de opties <code>frameOnly</code> en <code>parentOnly</code> instelt, zal de module helemaal geen argumenten ophalen van {{tlc|<nowiki>#invoke:...</nowiki>}}.
Dit is waarschijnlijk niet wat u wilt.
|2=
In sommige situaties is een bovenliggend frame mogelijk niet beschikbaar, bijvoorbeeld als <code>getArgs</code> juist wordt doorgegeven door het bovenliggende frame.
In dit geval worden alleen de frame-argumenten gebruikt (tenzij <code>parentOnly</code> is ingesteld, in welk geval geen argumenten worden gebruikt) en hebben de opties <code>parentFirst</code> en <code>frameOnly</code> geen effect.
}}
}}

=== Wrappers ===

De optie <code>wrappers</code>e wordt gebruikt om een beperkt aantal sjablonen op te geven als ''wrapper-sjablonen'', dat wil zeggen sjablonen waarvan het enige doel is om een module aan te roepen.
Als de module ziet dat deze wordt aangeroepen vanuit een wrapper-sjabloon, controleert deze alleen op argumenten in het bovenliggende frame; Anders wordt er alleen gecontroleerd op argumenten in het frame dat is doorgegeven aan <code>getArgs</code>.
Dit maakt het mogelijk om modules aan te roepen met {{tlc|<nowiki>#invoke:...</nowiki>}} of via een wrapper-sjabloon zonder het verlies aan prestaties vanwege het moeten controleren van zowel het frame als het bovenliggende frame voor elke zoekopdracht naar argumenten.

Voorbeeld: de enige inhoud van {{tlx|Navbox}} (exclusief inhoud in tags {{tag|noinclude}}) is <code><nowiki>{{#invoke:Navbox|navbox}}</nowiki></code>.
Het is niet zinvol om de argumenten die rechtstreeks worden overgedragen aan het statement {{tlc|<nowiki>#invoke:...</nowiki>}} voor dit sjabloon te controleren, omdat er nooit argumenten worden gespecificeerd.
We kunnen voorkomen dat argumenten die naar {{tlc|<nowiki>#invoke:...</nowiki>}} worden overgedragen worden gecontroleerd door de optie <code>parentOnly</code> te gebruiken, maar als we dit doen, zal {{tlc|<nowiki>#invoke:...</nowiki>}} ook niet werken vanaf andere pagina's.
Als dit het geval zou zijn, dan zou {{tmpl|0={{para|text|$1}}|Wat tekst}} in de code {{tmpl|0={{tlc|<nowiki>#invoke:Navbox</nowiki>|navbox|3=text=$1}}|Sommige tekst}} volledig worden genegeerd, ongeacht vanaf welke pagina het werd gebruikt.
Door de optie <code>wrappers</code> te gebruiken om [[Template:Navbox]] als wrapper op te geven, kunnen we {{tmpl|0={{tlc|<nowiki>#invoke:Navbox</nowiki>|main|3=text=$1}}|Sommige tekst}} laten werken vanaf de meeste pagina's, terwijl het nog steeds niet vereist is dat de module controleert op argumenten op de pagina [[Template:Navbox]] zelf.

Wrappers kunnen worden gespecificeerd als een string of als een matrix strings.

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

<syntaxhighlight lang="lua">
local args = getArgs(frame, {
wrappers = {
'Template:Wrapper 1',
'Template:Wrapper 2',
-- Hier kan elk aantal wrapper-sjablonen worden toegevoegd.
}
})
</syntaxhighlight>

{{Note|text=
{{Ordered list
|1=
De module detecteert automatisch of het wordt aangeroepen vanaf de subpagina <code>/sandbox</code> van een wrapper-sjabloon, dus het is niet nodig om zandbak-pagina's expliciet op te geven.
|2=
De optie <code>wrappers</code> verandert effectief de standaard van de opties <code>frameOnly</code> en <code>parentOnly</code>.
Als bijvoorbeeld <code>parentOnly</code> expliciet op <code>false</code> met <code>wrappers</code> werd ingesteld, zouden aanroepen via wrapper-sjablonen resulteren in het laden van zowel frame als bovenliggende frame argumenten, hoewel aanroepen zonder wrapper-sjablonen alleen argumenten van het frame zouden worden geladen.
|3=
Als de optie <code>wrappers</code> is ingesteld en er geen bovenliggend frame beschikbaar is, krijgt de module altijd de argumenten van het frame overgedragen naar <code>getArgs</code>.
}}
}}

=== Schrijven naar de tabel <code>args</code> ===
Soms kan het nuttig zijn om nieuwe waarden in de tabel <code>args</code> te schrijven.
Dit is mogelijk met de standaardinstellingen van deze module.
(Houd er echter rekening mee dat het meestal beter is om een nieuwe tabel met uw nieuwe waarden te maken en indien nodig argumenten uit de tabel <code>args</code> te kopiëren.)

<syntaxhighlight lang="lua">
args.foo = 'een waarde'
</syntaxhighlight>

Het is mogelijk om dit gedrag te veranderen met de opties <code>readOnly</code> en <code>noOverwrite</code>.
Als <code>readOnly</code> is ingesteld, is het niet mogelijk om waarden in de tabel <code>args</code> te schrijven.
Als <code>noOverwrite</code> is ingesteld, is het mogelijk om nieuwe waarden toe te voegen aan de tabel, maar het is niet mogelijk om een waarde toe te voegen als het argumenten zou overschrijven die worden doorgegeven vanaf {{tlc|<nowiki>#invoke:...</nowiki>}}.

=== Ref tags ===
Deze module gebruikt [[mw:Special:MyLanguage/Extension:Scribunto/Lua reference manual#Metatables|meta-tabellen]] om argumenten uit {{tlc|<nowiki>#invoke:...</nowiki>}} op te halen.
Dit maakt toegang tot zowel de frame-argumenten als de bovenliggende frame-argumenten mogelijk zonder de functie <code>pairs()</code> te gebruiken.
Dit kan helpen als uw module tags {{xtag|ref}} als invoer kan doorsturen.

Zodra {{xtag|ref}} tags vanaf Lua worden gehaald, worden ze verwerkt door de MediaWiki-software en de referentie verschijnt in de referentielist onderaan het artikel.
Als uw module de referentie-tag uit de uitvoer weglaat, krijgt u een fantoom-referentie - een referentie die in de referentielist verschijnt, maar geen nummer dat ermee verbinding maakt.
Dit is een probleem met modules die <code>pairs()</code> gebruiken om te detecteren of ze de argumenten uit het frame of het bovenliggende frame moeten gebruiken, omdat die modules automatisch elk beschikbaar argument verwerken.

Deze module lost dit probleem op door toegang te geven tot zowel frame- als bovenliggende frame-argumenten, terwijl deze nog steeds alleen worden opgehaald wanneer dat nodig is.
Het probleem zal echter nog steeds optreden als u <code>pairs(args)</code> elders in uw module gebruikt.


=== Bekende beperkingen ===
Het gebruik van meta-tabellen heeft ook zijn nadelen.
De meeste normale Lua-tabel-hulpmiddelen werken niet goed op de tabel <code>args</code>, inclusief de operator <code>#</code>, de functie <code>next()</code> en de functies in de bibliotheek <code>table</code>.
Als het gebruik van deze is belangrijk voor uw module, moet u uw eigen functie voor argument-verwerking maken in plaats van deze module te gebruiken.


== Testen ==
{{ModuleQuality}}
<includeonly>{{Sandbox other||

[[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}}}}
}}

Moduł:Arguments/doc/nl - Historia wersji

Fuhrer: 1 wersja

mediawiki>HanV o 13:21, 13 lis 2025