Mòdul:ParameterCount

Documentació del mòdul [ mostra ] [ modifica el codi ] [ mostra l'historial ] [ refresca ]

A continuació es mostra la documentació transclosa de la subpàgina /ús. [salta a la caixa de codi]

---

Aquest mòdul compte el nombre de paràmetres que es passen a una plantilla. Per exemple, és possible posar el codi {{#invoke:ParameterCount|all}} dins de la plantilla {{la meva plantilla}}. Si utilitzeu {{la meva plantilla}} així:

{{la meva plantilla
| un
| dos
| tres
}}

Llavors el codi {{#invoke:ParameterCount|all}} dins de la plantilla retornarà 3.

Aquest mòdul es pot configurar per comptar tots els paràmetres, o paràmetres específics definits per un autor de la plantilla. Aquest mòdul només és útil en plantilles. No s'ha d'utilitzar en pàgines que no són una plantilla.

El mòdul té dues funcions disponibles, all i main.

all

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

Ús

{{#invoke:ParameterCount|all}}

Exemples

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

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

Per nom

{{#invoke:ParameterCount|main|1|2|3|abc|def}}

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

Per patró

{{#invoke:ParameterCount|main|pattern1=^param%d+$|pattern2=^abc}}

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.

Exemples

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.

Comprovació de paràmetres en blanc

{{#invoke:ParameterCount|all|checkblanks=no}}

{{#invoke:ParameterCount|main|checkblanks=no}}

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.

Exemples

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('Module:Yesno')

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

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

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

-- 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
        end
    end
    return ret
end

-- 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)
            end
        end
    else
        blankifiedTestFunc = testFunc
    end
    return count(frame:getParent().args, blankifiedTestFunc)
end

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)
    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
            else
                keys[trim(key)] = true
            end
        end

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

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

        return main(frame, testFunc)
    end
}