Iz Wikipedije, proste enciklopedije
Documentation icon Dokumentacija modula[predogled] [uredi] [zgodovina] [osveži]

This module counts the number of parameters that are passed to a template. For example, you might put the code {{#invoke:ParameterCount|all}} inside the {{my template}} template. If you then use {{my template}} like this:

{{my template
| one
| two
| three

Then the {{#invoke:ParameterCount|all}} code inside the template will give the result 3.

This module can be configured to count all parameters, or specific parameters defined by a template author. This module is only useful in templates. It should not be used on non-template pages.

The module has two functions available, all and main.

all[uredi kodo]

The all function is used to count all parameters specified when using a template, regardless of whether or not they are used in the template itself.




If the code {{#invoke:ParameterCount|all}} was added to the {{my example template}} template, the code {{my example template|1|2|foo=bar}} would make ParameterCount produce 3.

main[uredi kodo]

The main function is used to count parameters with specific names. There are two ways of specifying parameters: by name, and using Lua patterns.

By name


To specify a parameter by name, add the parameter name as a positional parameter.

By pattern


To specify parameters by Lua Ustring pattern, add the pattern to |pattern1=, |pattern2= etc. For information on constructing Lua patterns, see the Lua Users' Wiki pattern tutorial, as well as the Lua reference manual sections on Lua patterns and Ustring patterns.


If the code {{#invoke:ParameterCount|main|1|2|abc}} was added to the {{my example template}} template, the code {{my example template|1|2|abc=some value|other=some other value}} would make ParameterCount produce 3.

If the code {{#invoke:ParameterCount|main|pattern1=^param%d+$}} was added to the {{my example template}} template, the code {{my example template|param1=a value|param2=another value|param5=yet another value}} would make ParameterCount produce 3.

Checking for blanks[uredi kodo]


By default, the module doesn't count parameters whose values contain only whitespace, e.g. |abc=   . If you wish to count all parameters, regardless of their value, use |checkblanks=no. This works with both the all and main functions.


If the code {{#invoke:ParameterCount|all|checkblanks=no}} was added to the {{my example template}} template, the code {{my example template|1|2|foo=bar|baz=}} would make ParameterCount produce 4.

-- This module produces a count of all the arguments passed to it.

local yesno = require('Modul:Yesno')

-- Trim a string
local function trim(s)
	return s:match('^%s*(.-)%s*$')

-- Test whether a string is blank
local function isBlank(s)
	return not s:find('%S')

-- Tests whether a string is a valid positional key, and if so, returns it. If
-- the key is invalid, this returns nil.
local function isPositionalKey(s)
	s = trim(s)
	if s:find('^[1-9][0-9]*$') then
		return tonumber(s)

-- Return the count of all arguments for which testFunc returns a truthy value.
local function count(args, testFunc)
	local ret = 0
	for key, val in pairs(args) do
		if testFunc(key, val) then
			ret = ret + 1
	return ret

-- Check shared arguments and get the parent argument count.
local function main(frame, testFunc)
	local blankifiedTestFunc
	if yesno(frame.args.checkblanks) ~= false then
		-- Extend the test function to check for blanks as well.
		blankifiedTestFunc = function (key, val)
			if not isBlank(val) then
				return testFunc(key, val)
		blankifiedTestFunc = testFunc
	return count(frame:getParent().args, blankifiedTestFunc)

return {
	-- Called with {{#invoke:ParameterCount|all}}
	-- All specified parameters are counted, even those not supported by the
	-- template.
	all = function (frame)
		return main(frame, function () return true end)

	-- Called with {{#invoke:ParameterCount|main}}
	-- Users can specify a list of parameters to check, and a list of Lua
	-- Ustring patterns to check each parameter against.
	main = function (frame)
		local args = frame.args
		local keys, patterns = {}, {}
		-- Get key list
		for i, key in ipairs(args) do
			local positionalKey = isPositionalKey(key)
			if positionalKey then
				keys[positionalKey] = true
				keys[trim(key)] = true

		-- Get patterns
			local function getPattern(i)
				local pattern = args['pattern' .. tostring(i)]
				if pattern and pattern ~= '' then
					return pattern
			local i = 1
			local pattern = getPattern(i)
			while pattern do
				patterns[i] = pattern
				i = i + 1
				pattern = getPattern(i)

		-- Construct the test function
		local testFunc = function (key, val)
			if keys[key] then
				return true
			for i, pattern in ipairs(patterns) do
				if mw.ustring.find(tostring(key), pattern) then
					return true
			return false

		return main(frame, testFunc)