Modul:Arguments/doc

Modul ini menyediakan pemprosesan argumen yang mudah dihantar dari #invoke. Ini adalah meta-modul, yang dimaksudkan untuk digunakan oleh modul lain, dan tidak boleh dipanggil langsung dari #invoke. Ciri-cirinya merangkumi:

• Pemangkasan argumen dan penghapusan argumen kosong dengan mudah.
• Argumen dapat dilalui oleh bingkai semasa dan bingkai induk pada masa yang sama. (Maklumat lebih lanjut di bawah.)
• Argumen boleh disampaikan terus dari modul Lua lain atau dari konsol debug.
• Argumen diambil mengikut keperluan, yang dapat membantu mengelakkan (beberapa) masalah dengan tag <ref>...</ref>.
• Sebilangan besar ciri boleh disesuaikan.

Penggunaan asas

Pertama, anda perlu memuatkan modul. Ia mengandungi satu fungsi, yang dinamakan getArgs.

local getArgs = require('Modul:Arguments').getArgs

Dalam senario paling asas, anda boleh menggunakan getArgs di dalam fungsi utama anda. Pemboleh ubah args adalah meja/jadual yang mengandungi hujah dari #invoke. (Lihat di bawah untuk maklumat lanjut.)

local getArgs = require('Modul:Arguments').getArgs
local p = {}

function p.main(frame)
	local args = getArgs(frame)
	-- Main module code goes here.
end

return p

Walau bagaimanapun, amalan yang disarankan adalah menggunakan fungsi hanya untuk memproses argumen dari #invoke. Ini bermaksud bahawa jika seseorang memanggil modul anda dari modul Lua yang lain, anda tidak perlu menyediakan objek bingkai, yang meningkatkan prestasi.

local getArgs = require('Modul:Arguments').getArgs
local p = {}

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

function p._main(args)
	-- Main module code goes here.
end

return p

Sekiranya anda mahu beberapa fungsi menggunakan argumen, dan anda juga mahu fungsi tersebut dapat diakses dari #invoke, anda boleh menggunakan fungsi pembalut.

local getArgs = require('Modul: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)
	-- Code for the first function goes here.
end

p.func2 = makeInvokeFunc('_func2')

function p._func2(args)
	-- Code for the second function goes here.
end

return p

Pilihan

Pilihan berikut ada. Ianya dijelaskan dalam bahagian di bawah.

local args = getArgs(frame, {
	trim = false,
	removeBlanks = false,
	valueFunc = function (key, value)
		-- Code for processing one argument
	end,
	frameOnly = true,
	parentOnly = true,
	parentFirst = true,
	wrappers = {
		'Templat:A wrapper template',
		'Templat:Another wrapper template'
	},
	readOnly = true,
	noOverwrite = true
})

Memotong dan mengeluarkan kosong

Argumen kosong sering kali membuat pengekod baru untuk menukar templat MediaWiki ke Lua. Dalam sintaks templat, rentetan dan rentetan kosong yang hanya terdiri daripada ruang kosong dianggap salah. Namun, di Lua, tali dan tali kosong yang terdiri daripada ruang kosong dianggap benar. Ini bermaksud bahawa jika anda tidak memperhatikan hujah-hujah tersebut semasa anda menulis modul Lua anda, anda mungkin memperlakukan sesuatu yang benar yang sebenarnya harus dianggap sebagai salah. Untuk mengelakkannya, secara lalai modul ini membuang semua argumen kosong.

Begitu juga, ruang kosong boleh menyebabkan masalah ketika berhadapan dengan posisi argumen. Walaupun ruang kosong dipangkas untuk argumen bernama yang berasal #invoke, ia disimpan untuk posisi argumen. Selalunya ruang kosong tambahan ini tidak diingini, jadi modul ini memotongnya secara lalai.

Walau bagaimanapun, kadang-kadang anda mahu menggunakan argumen kosong sebagai input, dan kadang-kadang anda mahu mengekalkan ruang kosong tambahan. Ini boleh menjadi perlu untuk menukar beberapa templat anda sama seperti yang ditulis. Sekiranya anda mahu melakukan ini, anda boleh menetapkan trim dan removeBlanks argumen kepada false.

local args = getArgs(frame, {
	trim = false,
	removeBlanks = false
})

Pemformatan argumen khusus

Kadang-kadang anda ingin membuang beberapa argumen kosong tetapi tidak yang lain, atau mungkin anda mungkin mahu meletakkan semua posisi argumen dengan huruf kecil. Untuk melakukan perkara seperti ini, anda boleh menggunakan pilihan valueFunc. Input untuk pilihan ini mestilah fungsi yang mengambil dua parameter, key dan value, dan mengembalikan satu nilai. Nilai ini adalah apa yang akan anda perolehi semasa anda memasuki lapangan key dalam args meja/jadual.

Contoh 1: fungsi ini mengekalkan ruang kosong untuk argumen kedudukan pertama, tetapi memotong semua argumen lain dan membuang semua argumen kosong yang lain.

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

Contoh 2: fungsi ini membuang argumen kosong dan menukar semua argumen menjadi huruf kecil, tetapi tidak memotong ruang kosong dari posisi parameter.

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

Nota: fungsi di atas akan gagal sekiranya input yang dikeluarkan bukan jenis string atau nil. Ini mungkin berlaku jika anda menggunakan fungsi getArgs dalam fungsi utama modul anda, dan fungsi itu dipanggil oleh modul Lua yang lain. Dalam kes ini, anda perlu memeriksa jenis input anda. Ini tidak menjadi masalah jika anda menggunakan fungsi khas untuk argumen dari #invoke (iaitu anda perlu fungsi p.main dan p._main, atau yang serupa).

Contoh 1 dan 2 dengan jenis pemeriksaan

Contoh 1: 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 }) Contoh 2: 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 })

Juga, harap maklum bahawa fungsi valueFunc dipanggil lebih kurang setiap kali argumen diminta dari meja/jadual args, jadi jika anda mementingkan prestasi, anda harus memastikan bahawa anda tidak melakukan sesuatu yang tidak cekap dengan kod anda.

Frames and parent frames

Arguments in the args table can be passed from the current frame or from its parent frame at the same time. To understand what this means, it is easiest to give an example. Let's say that we have a module called Module:ExampleArgs. This module prints the first two positional arguments that it is passed.

Module:ExampleArgs code
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

Module:ExampleArgs is then called by Template:ExampleArgs, which contains the code {{#invoke:ExampleArgs|main|firstInvokeArg}}. This produces the result "firstInvokeArg".

Now if we were to call Template:ExampleArgs, the following would happen:

Code	Result
{{ExampleArgs}}	firstInvokeArg
{{ExampleArgs|firstTemplateArg}}	firstInvokeArg
{{ExampleArgs|firstTemplateArg|secondTemplateArg}}	firstInvokeArg secondTemplateArg

There are three options you can set to change this behaviour: frameOnly, parentOnly and parentFirst. If you set frameOnly then only arguments passed from the current frame will be accepted; if you set parentOnly then only arguments passed from the parent frame will be accepted; and if you set parentFirst then arguments will be passed from both the current and parent frames, but the parent frame will have priority over the current frame. Here are the results in terms of Template:ExampleArgs:

frameOnly

Code	Result
{{ExampleArgs}}	firstInvokeArg
{{ExampleArgs|firstTemplateArg}}	firstInvokeArg
{{ExampleArgs|firstTemplateArg|secondTemplateArg}}	firstInvokeArg

parentOnly

Code	Result
{{ExampleArgs}}
{{ExampleArgs|firstTemplateArg}}	firstTemplateArg
{{ExampleArgs|firstTemplateArg|secondTemplateArg}}	firstTemplateArg secondTemplateArg

parentFirst

Code	Result
{{ExampleArgs}}	firstInvokeArg
{{ExampleArgs|firstTemplateArg}}	firstTemplateArg
{{ExampleArgs|firstTemplateArg|secondTemplateArg}}	firstTemplateArg secondTemplateArg

Notes:

1. If you set both the frameOnly and parentOnly options, the module won't fetch any arguments at all from #invoke. This is probably not what you want.
2. In some situations a parent frame may not be available, e.g. if getArgs is passed the parent frame rather than the current frame. In this case, only the frame arguments will be used (unless parentOnly is set, in which case no arguments will be used) and the parentFirst and frameOnly options will have no effect.

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 <noinclude>...</noinclude> tags) is {{#invoke:Side box|main}}. 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 |text=Some text in the code {{#invoke:Side box|main|text=Some text}} would be ignored completely, no matter what page it was used from. By using the wrappers option to specify 'Template:Side box' as a wrapper, we can make {{#invoke:Side box|main|text=Some text}} 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.

local args = getArgs(frame, {
	wrappers = 'Template:Wrapper template'
})

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

Notes:

1. 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.
2. 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.
3. If the wrappers option is set and no parent frame is available, the module will always get the arguments from the frame passed to getArgs.

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.)

args.foo = 'some value'

It is possible to alter this behaviour with the readOnly and noOverwrite options. If readOnly is set then it is not possible to write any values to the args table at all. If noOverwrite 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 metatables to fetch arguments from #invoke. This allows access to both the frame arguments and the parent frame arguments without using the pairs() function. This can help if your module might be passed <ref>...</ref> tags as input.

As soon as <ref>...</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 pairs() 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 pairs(args) elsewhere in your module, however.

Known limitations

The use of metatables also has its downsides. Most of the normal Lua table tools won't work properly on the args table, including the # operator, the next() function, and the functions in the table library. If using these is important for your module, you should use your own argument processing function instead of this module.