This is a table of modules and functions that were created specifically for facilitating the creation of other modules. Documentation for modules here is done in the source code with Template:Helper module. In all below descriptions, optional arguments have square brackets around them with default values after a pipe, if appropriate. i.e. foo( x, [y|1] ) means function foo has one required argument, and the second argument is optional and will default to 1.
| Module | Function | Type | Use | Example |
|---|---|---|---|---|
| Array | all( arr, [fn] ) | arr: any[] fn?: any -> boolean | Behaviour depends on the value of fn:
| |
any( arr, [fn] ) | arr: any[] fn?: any -> boolean | Behaviour depends on the value of fn:
| ||
clean( arr ) | arr: any[] -> any[] | Recursively removes all metatables. | ||
clone( arr, [deep] ) | arr: any[] deep?: boolean -> any[] | Make a copy of the input table. Preserves metatables. | ||
contains( arr, val ) | arr: any[] val: any -> boolean | Check if arr contains val. | ||
containsAny( arr, t ) | arr: any[] t: any[] -> boolean | Check if arr contains any of the values in the table t. | ||
containsAll( arr, t ) | arr: any[] t: any[] -> boolean | Check if arr contains all values in the table t. | ||
convolve( x, y ) | x: number[] y: number[] -> number[] | Convolute two number arrays. | ||
condenseSparse( arr ) | arr: any[] -> any[] | Remove nil values from arr while preserving order. | ||
count( arr, fn ) | arr: any[] fn: any -> integer | Behaviour depends on value of val:
| ||
diff( arr, [order|1] ) | arr: number[] order?: number -> number[] | Differentiates arr. The length of the result is #arr - order long. | ||
each( arr, fn ) | arr: any[] fn: fun(elem: any, i?: integer) | Loops over the array part of arr and passes each element as the first argument to fn. This function returns nothing. | ||
filter( arr, fn ) | arr: any[] fn: fun(elem: any, i?: integer): boolean-> any[] | Makes a copy of arr with only elements for which fn returned true. | ||
find( arr, fn, [default] ) | arr: any[] fn: any default?: any -> any?, integer? | Behaviour depends on the value of fn:
| ||
find_index( arr, fn, [default] ) | arr: any[] fn: any default?: any -> integer? | Behaviour depends on the value of fn:
| ||
get( arr, indexes ) | arr: any[] indexes: integer|integer[] -> any[] | Extracts a subset of arr. | ||
int( arr, [start|1], [stop|#arr] ) | arr: number[] start?: number stop?: number -> number[] | Integrates arr from index start to stop. Effectively does <math>\left\{\sum^{n}_{start}{arr[n]} \,\Bigg | ||
intersect( arr1, arr2 ) | arr1: any[] arr2: any[] -> any[] | Returns an array with elements that are present in both tables. | ||
intersects( arr1, arr2 ) | arr1: any[] arr2: any[] -> boolean | Checks if the two inputs have at least one element in common. | ||
insert( arr, val, [index], [unpackVal] )OR insert( arr, val, [unpackVal] ) | arr: any[] val: any index?: integer unpackVal?: boolean -> any[] | Inserts values into arr. If val is an array and unpackVal is true then the individual elements of val are inserted. index is the location to start the insertion. Default is at the end of arr. | ||
last( arr ) | arr: any[] -> any | Returns the last element of arr. | ||
len( arr ) | arr: any[] -> integer | Returns the length of the array but it also works on proxy arrays like mw.loadData or mw.loadJsonData. | ||
map( arr, fn ) | arr: any[] fn: fun(elem: any, i?: integer): any-> any[] | Returns a new table were each element of arr is modified by fn. | ||
max_by( arr, fn ) | arr: any[] fn: fun(elem: any): any-> any, integer | Find the element for which fn returned the largest value. The returned value of fn needs to be comparable using the < operator. Returns three values: The element with the largest fn value, its fn result, and its index. | ||
max( arr ) | arr: any[] -> any, integer | Find the largest value in the array. The values need to be comparable using the < operator. Returns two values: the element and its index. | ||
min( arr ) | arr: any[] -> any, integer | Find the smallest value in the array. The values need to be comparable using the < operator. Returns two values: the element and its index. | ||
new( [arr|{}] ) | arr?: any[] -> any[] | Turn the input table into an Array. This makes it possible to use the colon : operator to access the Array methods. It also enables the use of math operators with the array.
local x = arr.new{ 1, 2, 3 }
local y = arr{ 4, 5, 6 } -- Alternative notation
mw.logObject( -x ) --> { -1, -2, -3 }
mw.logObject( x + 2 ) --> { 3, 4, 5 }
mw.logObject( x - 2 ) --> { -1, 0, 1 }
mw.logObject( x * 2 ) --> { 2, 4, 6 }
mw.logObject( x / 2 ) --> { 0.5, 1, 1.5 }
mw.logObject( x ^ 2 ) --> { 1, 4, 9 }
mw.logObject( x + y ) --> { 5, 7, 9 }
mw.logObject( x .. y ) --> { 1, 2, 3, 4, 5, 6 }
mw.logObject( (x .. y):reject{3, 4, 5} ) --> { 1, 2, 6 }
mw.logObject( x:sum() ) --> 6
mw.logObject( x:update( {1, 3}, y:get{2, 3} * 2 ) ) --> { 10, 2, 12 }
| ||
newIncrementor( [start|1], [step|1] ) | start?: number step?: number -> Incrementor | Returns a new incrementor function. Every time this incrementor function is called it returns a number step higher than the previous call. The current value can be obtained with inc.n or set inc.n = number where inc is an incrementor function. The step size can be changed with inc.step = number. | ||
range( stop )OR range( start, stop, [step|1] ) | start: number stop: number step?: number -> number[] | Returns a table containing a sequence of numbers from start to stop (both inclusive if ints, end-exclusive if floats) by step. range(4) produces {1, 2, 3, 4} (start defaults to 1). range(0, 4) produces {0, 1, 2, 3, 4}. When step is given, it specifies the increment (or decrement). | ||
reduce( arr, fn, [accumulator|arr[1]] ) | arr: any[] fn: fun(elem: any, acc: any, i?: integer): anyaccumulator?: any -> any | Condenses the array into a single value.
For each element If no local t = { 1, 2, 3, 4 }
local sum = arr.reduce( t, function(elem, acc) return acc + elem end ) -- sum == 10
| ||
reject( arr, val ) | arr: any[] val: any -> any[] | Make a copy off arr with certain values removed.
Behaviour for different values of
| ||
rep( val, n ) | val: any n: number -> any[] | Returns a table with n copies of val. | ||
scan( arr, fn, [accumulator|arr[1]] ) | arr: any[] fn: fun(elem: any, acc: any, i?: integer): anyaccumulator?: any -> any[] | Condenses the array into a single value while saving every accumulator value.
For each element If no local t = { 1, 2, 3, 4 }
local x = arr.scan( t, function(elem, acc) return acc + elem end ) -- x = { 1, 3, 6, 10 }
| ||
set( arr, indexes, values ) | arr: any[] indexes: integer|integer[] values: any|any[] -> any[] | Update a range of index with a range of values.
If if only one value is given but multiple indexes than that value is set for all those indexes. Ifvalues is a table then it must of the same length as indexes. | ||
slice( arr, [start|1], [stop|#arr] )OR slice( arr, stop ) | arr: any[] start?: number stop?: number -> any[] | Returns a table containing all the elements of arr between the start and stop indices. The start and stop indices are inclusive. If start or stop are negative values then they are referenced to the end of the table. | ||
split( arr, index ) | arr: any[] index: number -> any[], any[] | Split arr into two arrays. Retuns two tables. The first contains elements from [1, index], and the second from [index + 1, #arr]. | ||
sum( arr ) | arr: number[] -> number | Returns the sum of all elements of arr. | ||
take( arr, count, [start|1] ) | arr: any[] count: number start?: number -> any[] | Extract a subtable from arr of count elements long starting from the start index. | ||
take_every( arr, n, [start|1], [count|#arr] ) | arr: any[] n: integer start?: integer count?: integer -> any[] | Extract a subtable from arr.
local t = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }
local x = arr.take_every( t, 2 ) --> x = { 1, 3, 5, 7, 9 }
local x = arr.take_every( t, 2, 3 ) --> x = { 3, 5, 7, 9 }
local x = arr.take_every( t, 2, 3, 2 ) --> x = { 3, 5 }
| ||
unique( arr, [fn] ) | arr: any[] fn?: fun(elem: any): any-> any[] | Return a new table with all duplicates removed. fn is an optional function to generate an id for each element. The result will then contain elements that generated unique ids. The order of first occurance is preserved. | ||
zip( ... ) | ...any[] -> any[][] | Combine elements with the same index from multiple arrays.
local x = {1, 2, 3}
local y = {4, 5, 6, 7}
local z = arr.zip( x, y ) --> z = { { 1, 4 }, { 2, 5 }, { 3, 6 }, { 7 } }
| ||
| Mw.html extension | addClassIf(cond, class) | boolean, string | If cond = true it behaves the same as the normal addClass function, otherwise it's a no-op. Ex.: mw.html.create('div'):addClassIf(true, 'align-left-1') | |
attrIf(cond, name, value) | boolean, string/table, string/nil | Similar to addClassIf | ||
cssIf(cond, name, value) | boolean, string/table, string/nil | Similar to addClassIf | ||
doneIf(cond) | boolean | Similar to addClassIf | ||
tagIf(cond, tag) | boolean, string | Similar to addClassIf | ||
wikitextIf(cond, text) | boolean, string | Similar to addClassIf | ||
na() | N/A | Shortcut for :tag('td'):attr('data-sort-value', 0):attr('class','table-na'):wikitext('<small>N/A</small>'):done() | ||
naIf(cond) | boolean | Similar to addClassIf | ||
tr([settings]) | table/nil | Shortcut for :tag('tr') but also auto closes the previous 'tr', 'th' or 'td' tag (so you don't need to add :done() before it). settings is a table with keys:
| ||
th([settings]) | string/table/nil | Shortcut for :tag('th'):wikitext(settings) if settings is a string. Also auto closes the previous 'th' or 'td' tag. settings can also be a table with keys:
| ||
td([settings]) | string/table/nil | Same as :th(). Example:
local tbl = mw.html.create('table')
tbl:tr{ class='sortable' }
:th{'foo', attr={'data-sort-type', 'number'}}
:th('bar')
:tr()
:td('buz')
:attr('data-sort-value', 10)
:td{'N/A', class='table-na'}
| ||
IF(cond) | boolean | Allows for if-blocks without breaking the chain. If the condition is true it is a no-op, if false everything inside the balanced IF-END block will be ignored. Can be nested. Ex.:
mw.html.create('div')
:IF(true)
:wikitext('Conditional text')
:END()
:...
Note: This only prevents elements from being added to your html object, it does not protect against statements that throw errors. I.e mw.html.create('div')
:IF(false)
:wikitext(5 * nil) -- This will still throw an error
:END()
| ||
ELSEIF(cond) | boolean | Used together with IF(). | ||
ELSE() | N/A | Used together with IF(). | ||
END() | N/A | Used together with IF(). Make sure the IF-END tags are balanced, it wont throw an error if they are not. | ||
exec(func, ...) | function, any | Call a function without breaking the chain. See module docs for more info. | ||
addFunction(func, name) | function, string | Add a function to the mw.html class that can then be used on mw.html object. See module docs for more info. | ||
| Paramtest | is_empty(arg) | String | Returns true if arg is not defined or contains only whitespace | |
has_content(arg) | String | Returns true if arg exists and does not only contain whitespace | ||
default_to(arg1,arg2) | String, Any value | If arg1 exists and does not only contain whitespace, the function returns arg1, otherwise returns arg2 | ||
defaults{ {arg1,arg2},...} | {String, Any value}... | Does the same as default_to() run over every table passed | ||
table_is_empty(arg) | Table | Returns true if the table has no content, it does not check if the content of the table contains anything | ||
table_has_content(arg) | Table | returns true if the table has content, it does not check if the content of the table contains anything | ||
| String2 | trim | Trims whitespace characters from the start and end of the string. | ||
title | Capitalizes the first letter of each word in the text, apart from a number of short words: a, an, the, at, by, for, in, of, on, to, up, and, as, but, or, and nor. | |||
sentence | Finds the first letter and capitalises it, then renders the rest of the text in lower case. | |||
ucfirst | Finds the first letter and capitalises it, then renders the rest of the text in lower case. | |||
findlast | Finds the last item in a list | |||
split | Splits text at boundaries specified by separator and returns the chunk for the index idx (starting at 1). | |||
stripZeroes | Finds the first number in a string of text and strips leading zeros, but retains a zero which is followed by a decimal point. For example: "0940" → "940"; "Year: 0023" → "Year: 23"; "00.12" → "0.12" | |||
nowiki | Ensures that a string of text is treated by the MediaWiki software as just a string, not code. It trims leading and trailing whitespace. | |||
val2percent | Scans through a string, passed as either the first unnamed parameter or | |||
one2a | Scans through a string, passed as either the first unnamed parameter or | |||
findpagetext | Returns the position of a piece of text in the wikitext source of a page. | |||
strip | Strips the first positional parameter of the characters or pattern supplied in the second positional parameter. | |||
matchAny | Returns the index of the first positional parameter to match the source parameter. | |||
hyphen2dash | Converts a hyphen to a dash under certain conditions. The hyphen must separate like items; unlike items are returned unmodified. | |||
startswith | Match strings start with a pattern |