Modul:Example – Hrvatska internetska enciklopedija

# Modul: Example

Izvor: Hrvatska internetska enciklopedija
More actions

<templatestyles src="Modul:Dokumentacija/styles.css"></templatestyles>

Dokumentacija modula[stvori]
Možda želite stvoriti dokumentaciju ovog Scribuntovog modula.
Molimo dodajte kategorije na /doc podstranicu. Podstranice ovog modula.

    --- Example module.
    -- @module example
    -- @alias p

    local p = {}	    --All Lua modules on HIE must begin by defining a variable
                        --that will hold their externally accessible functions.
                        --Such variables can have whatever name you want and may
                        --also contain various data as well as functions.

    --- Hello world function
    -- @param {table} frame current frame
    -- @return Hello world
    p.hello = function( frame )     --Add a function to "p".
                                            --Such functions are callable in HIE
                                            --via the #invoke command.
                                            --"frame" will contain the data that HIE
                                            --sends this function when it runs.
                                     -- 'Hello' is a name of your choice. The same name needs to be referred to when the module is used.

        local str = "Hello World!"  --Declare a local variable and set it equal to
                                    --"Hello World!".

        return str    --This tells us to quit this function and send the information in
                      --"str" back to HIE.

    end  -- end of the function "hello"

    --- Hello world function
    -- @param {table} frame current frame
    -- @param {string} frame.args[1] name
    -- @return Hello world
    function p.hello_to(frame)		-- Add another function
    	local name = frame.args[1]  -- To access arguments passed to a module, use `frame.args`
    							    -- `frame.args[1]` refers to the first unnamed parameter
    							    -- given to the module
    	return "Hello, " .. name .. "!"  -- `..` concatenates strings. This will return a customized
    									 -- greeting depending on the name given, such as "Hello, Fred!"
    end

    --- Counts fruit
    -- @param {table} frame current frame
    -- @param {string} frame.args.bananas number of bananas
    -- @param {string} frame.args.apples number of apples
    -- @return Number of apples and bananas
    function p.count_fruit(frame)

    	local num_bananas = tonumber(frame.args.bananas) or 0	-- Named arguments ({{#invoke:Example|count_fruit|foo=bar}})
    	local num_apples = tonumber(frame.args.apples) or 0		-- are likewise accessed by indexing `frame.args` by name (`frame.args["bananas"]`,
    															--  or equivalently `frame.args.bananas`.

    	local conj_bananas = num_bananas == 1 and 'banana' or 'bananas'
        local conj_apples = num_apples == 1 and 'apple' or 'apples'
        										-- Ternary operators assign values based on a condition in a compact way.
    											-- Here, `conj_bananas` gets `'banana'` if `num_bananas` is 1, else `'bananas'`.
    											-- Similarly, `conj_apples` gets `'apple'` if `num_apples` is 1, else `'apples'`.

        return 'I have ' .. num_bananas ..  ' ' .. conj_bananas .. ' and ' .. num_apples .. ' ' .. conj_apples
    										   -- Like above, concatenate a bunch of strings together to produce
    										   -- a sentence based on the arguments given.
    end

    --- Lucky function
    -- @param {string} a
    -- @param {string} b
    -- @return Whether a is lucky.
    local function lucky(a, b) -- One can define custom functions for use. Here we define a function 'lucky' that has two inputs a and b. The names are of your choice.
    	if b == 'yeah' then -- Condition: if b is the string 'yeah'. Strings require quotes. Remember to include 'then'.
    		return a .. ' is my lucky number.' -- Outputs 'a is my lucky number.' if the above condition is met. The string concatenation operator is denoted by 2 dots.
    	else -- If no conditions are met, i.e. if b is anything else, output specified on the next line.  'else' should not have 'then'.
    		return a -- Simply output a.
    	end -- The 'if' section should end with 'end'.
    end -- As should 'function'.

    --- Name2
    -- @param {table} frame current frame
    -- @return Some output
    function p.Name2(frame)
    	-- The next five lines are mostly for convenience only and can be used as is for your module. The output conditions start on line 50.
    	local pf = frame:getParent().args -- This line allows template parameters to be used in this code easily. The equal sign is used to define variables. 'pf' can be replaced with a word of your choice.
    	local f = frame.args -- This line allows parameters from {{#invoke:}} to be used easily. 'f' can be replaced with a word of your choice.
    	local M = f[1] or pf[1] -- f[1] and pf[1], which we just defined, refer to the first parameter. This line shortens them as 'M' for convenience. You could use the original variable names.
    	local m = f[2] or pf[2] -- Second shortened as 'm'.
    	local l = f.lucky or pf.lucky -- A named parameter 'lucky' is shortend as l. Note that the syntax is different from unnamed parameters.
    	if m == nil then -- If the second parameter is not used.
    		return 'Lonely' -- Outputs the string 'Lonely' if the first condition is met.
    	elseif M > m then -- If the first condition is not met, this line tests a second condition: if M is greater than m.
    		return lucky(M - m, l) -- If the condition is met, the difference is calculated and passed to the self defined function along with l. The output depends on whether l is set to 'yeah'.
    	else
    		return 'Be positive!'
    	end
    end

    return p    --All modules end by returning the variable containing their functions to HIE.
    -- Now we can use this module by calling {{#invoke: Example | hello }},
    -- {{#invoke: Example | hello_to | foo }}, or {{#invoke:Example|count_fruit|bananas=5|apples=6}}
    -- Note that the first part of the invoke is the name of the Module's HIEpage,
    -- and the second part is the name of one of the functions attached to the
    -- variable that you returned.

    -- The "print" function is not allowed in HIE.  All output is accomplished
    -- via strings "returned" to HIE.

Dobavljeno iz "https://enciklopedija.cc/index.php?title=Modul:Example&oldid=582660"