Extension:Loops

The Loops extension provides parser functions for performing loops.

#while
  performs a loop (i.e. it repeatedly parses a given wiki markup block statement) so long as the condition mark-up evaluates to non-whitespace.


 * Examples

The wiki markup:





produces the following:



#dowhile
  performs exactly like , with the exception that the block statement is guaranteed to be parsed and displayed (if it results in displayable text) at least once. This is done before the condition text is evaluated.

#loop
  repeatedly parses and displays the block statement a number of times equal to the absolute value of .  is placed in a variable (accessible by   parser function) using the name. After each loop, the variable is incremented by one if  is positive, or decremented by one if  is negative.

Note: of all the loop functions,  should have the best performance, since there is no condition which has to be expanded and validated for each cycle.

The following code:
 * Examples





produces





#forargs
  is to be used in templates. It takes arguments that are passed to the template and puts them in variables accessible by   parser function.

This function iterates through each argument whose name begins with. With each iteration it puts the argument name minus into as if calling. It then takes the value of the argument and puts it into in a similar method. The block statement is then expanded. The block statement may contain  and   to access the stored arguments.

If the page "Template:Loops Test" contains
 * Example





then the wiki markup

produces


 * 1 = val1
 * 5 = val5
 * ument = value

#fornumargs
  performs similarly to    with two major differences: it doesn't take a prefix argument, and it only works on numbered arguments whether they're explicitly numbered:

or implicitly numbered:

Note: mixing these methods in a single template call may cause values to get overwritten.

If "Template:Loops Test" is edited to contain:
 * Examples





then

will result in

<li>1 = Apricot</li><li>2 = Caramel slice</li><li>5 = Eclair</li></ul>

Arrays
Loops can also be used in a template to simulate a numbered array, in this case using loops. If the page "Template:Loops Test" contains



</ul>

then the wiki-markup

produces

<li>zero</li><li>one</li><li>two</li><li>three</li><li>four</li></ul>

Notice how a variable is being used in the name of an argument in. This is completely valid in MediaWiki syntax, and is what makes array-style storage possible. In fact, variables with names dependent on other variables can be created dynamically. Take the following as an example:

This would create 5 variables named,  ,  ,  , and  , and assign them each the values 0, 1, 2, 3, and 4 respectively. These members can then be accessed in a similar way to before:

The above two examples together produces the following output:

In this case, the same page output is achieved as the first example under, however twice the loops and 6x as many variable definitions are used in the process. Since there's a maximum 200 loop limit per page, it's important to try and think first about exactly what is being accomplish to avoid unnecessary loop usage. The main use for this kind of dynamic variable naming would be for cases where swapping of the contents of each variable is necessary (such as sorting algorithms).

Whitespace and Page Output
It's important to note that any trailing whitespace touching either a | pipe character or the inside of a template/extension call's brackets is stripped during parsing. This includes newlines, tabs, and spaces. If this is not desirable, adding any non-whitespace characters will prevent further stripping. An easy way to achieve this is with a  tag, since it will otherwise have no affect on page output. However, other than this automatic culling, no other culling is done for extra spaces outside of brackets or between characters, meaning that in practice most templates will need to be scrunched up to avoid display problems (including the examples here).