Ayuda:Funciones

Esta página es un manual sobre el trabajo con algunas de las funciones utilizadas en la programación wiki y que son están presentes en el software MediaWiki. Todas las funciones tienen la forma:

{{ #functionname: argumento 1 | argumento 2 | argumento 3 ... }}

#expr:

Tipo	Operadores
Agrupadores (paréntesis)	( )
Números	1234..   2.56..    2.4E5 e (2.718) pi (3.142)
Lógicos	or, and, not
	= , != (or <>) , > , < , <= , >=
Redondeo	round , ceil , floor , abs
Binarios	+ , - , mod
	* , / (or div)
	^
Otros	trunc , ln , sin , cos , tan , acos , asin , atan

Esta función, evalúa una expresión matemática, y devuelve el resultado.

Los operadores disponibles están listados a continuación, en orden de preferencia. Para más información sobre la sintaxis y uso de cada operador, se puede consultar la documentación Ayuda:Operaciones de Cálculo. La exactitud y el formato del resultado devuelto, depende del sistema operativo del servidor que ejecuta la wiki, y el formáto numérico que use el servidor.

Los números se dan en decimales desde el punto decimal "."

Los operadores booleanos (verdadero/falso) consideran el 0 como falso (false) y cualquier otro (positivo o negativo) como verdadero (true).

{{#expr: 1 and -1 }} → 1

Un valor vacío en la <expresion>, devuelve un valor vacío; una <expresion> incorrecta o con sintaxis mal formada, devolverá un error que puede ser evaluado con la función #iferror::

{{#expr: }} →

{{#expr: 1+ }} →

{{#expr: 1 foo 2 }} →

#if

La función if es de construcción if-then-else. La sintaxis es:

Si la <condición> es una cadena vacía o consiste sólo de espacios en blanco, entonces se considera falsa, y la función da como resultado el <texto else>. De lo contrario, da como resultado el <texto then>. El <texto else> podría omitirse, por lo cual el resultado será una cadena vacía si la condición es falsa.

Por esta razón, si la <condición> es cualquier cadena de texto, devolverá siempre el <texto then>, por este motivo la <condición> no podrá ser del tipo {{#if:1>2|sí|no}};
para comparar números, utilice #ifexpr, y para comparar cadenas, utilice #ifeq

{{#if: | yes | no}} → no

{{#if: string | yes | no}} → yes

{{#if:      | yes | no}} → no

{{#if: | yes | no}} → no

El texto de la <condición>, siempre se interpreta como una cadena, así que no se interpretan expresiones matemáticas.

{{#if: 1==2 | yes | no}} → yes

También se pueden omitir valores.

{{#if: foo | yes }} → yes

{{#if: | yes }} →

{{#if: foo | | no}} →

#ifeq

Esta función compara dos cadenas de texto (o numéricas): <string1> y <string2>; si son iguales, devuelve <valor si identicas>, si no, devuelve <valor si distintas>. Si se trata de cadenas de texto, la función es case sensitive (es decir, que distingue mayúsculas de minúsculas)

Si ambas cadenas a comparar, son cadenas numéricas, las compara numéricamente:

{{#ifeq: 01 | 1 | yes | no}} → yes

{{#ifeq: 0 | -0 | yes | no}} → yes

{{#ifeq: "01" | "1" | yes | no}} → no

#ifexpr

Esta función evalúa una condición lógica –que puede incluir una expresión matemática–, y da como resultado una de dos cadenas, dependiendo que la condición sea o no verdadera.

La <condición> es evaluada como #expr:, –arriba descrita–, y el resultado es evaluado como una expresión booleana, –siendo verdadera, si el resultado es distinto a cero.
La función, es equivalente a usar #ifeq: y #expr:: de esta manera:

{{#ifexpr: 5+3 | yes | no }} = {{#ifeq: {{#expr: 5+3 }} | 0 | no | yes }} → yes

Si la <condición> se deja vacía, la función devuelve <texto else>:

{{#ifexpr: | yes | no}} → no

#iferror

Esta función toma una <cadena de texto de entrada>, y devuelve una cadena de entre dos dadas, en función de que la <cadena de texto de entrada> contenga un objeto HTML con la clase class="error", tal y como se genera en otras parser functions –como #expr:, #time: o #rel2abs: entre otras.

{{#expr: 1 + X }} →

{{#iferror: {{#expr: 1 + 2 }} | error | correcto }} → correcto

{{#iferror: {{#expr: 1 + X }} | error | correcto }} → error

{{#iferror: <span class="error">foo</span> | error | correcto }} → error

{{#iferror: <span class="no-error">foo</span> | error | correcto }} → correcto

Se pueden omitir las cadenas de salida, de manera que si se omite la <cadena devuelta si no hay error>, y resulta que la <cadena de texto de entrada> devuelve error, la función #iferror: devolverá una cadena vacía; en cambio devolverá la misma <cadena de texto de entrada>, si esta no es un objeto HTML con la clase class="error":

{{#iferror: {{#expr: 1 + 2 }} | error }} → 3

{{#iferror: {{#expr: 1 + X }} | error }} → error

{{#iferror: {{#expr: 1 + 2 }} }} → 3

{{#iferror: {{#expr: 1 + X }} }} →

#ifexist

#rel2abs

#switch

switch compara un sólo valor con varios otros, dando como resultado una cadena si es que se encuentra un valor igual. La sintaxis es básicamente:

| <valor1> = <resultado1>
| <valor2> = <resultado2>
| ...
| <valorn> = <resultadon>
| <resultado por defecto>
}}

switch buscará en cada uno de los valores dados hasta que se encuentre uno que sea igual. Una vez encontrado, la función da el resultado correspondiente (la cadena de texto encontrada después del signo de igual). Si no se encuentra uno igual, pero el último item no tiene un signo igual, se da el <resultado por defecto>. Si tu resultado por defecto debe tener un signo de igual, puedes utilizar #default:

| <value> = <resultado>
| #default = <resultado por defecto>
}}

Nótese que también es posible tener valores "permeables" (reduciendo así la necesidad de duplicar resultados).
Es decir, que si <valor₁> y <valor₂> no contienen un signo igual, y se les encuentra como valores iguales en la comparación, se da el resultado de <valor₃> (es decir, lo que sea que esté como <resultado₃>) Por ejemplo:

| <value1>
| <value2>
| <value3> = <resultado3>
| ...
| <valuen> = <resultadon>
| <resultado por defecto>
}}

Como ocurre con #ifeq:, la comparación se hace de forma numérica si es posible; en caso contrario, se comparan las cadenas como case sensitive –diferenciando mayúsculas de minúsculas.

{{ #switch: 07 | 6 | 7 | 8 = resultado 1 | 9 = resultado 2 | #default = valor = por defecto }} → resultado 1

{{ #switch: "07" | 6 | 7 | 8 = resultado 1 | 9 = resultado 2 | #default = valor = por defecto }} → valor = por defecto

{{ #switch: aEioU | aeiou = case-insensitive | aEioU = case-sensitive }} → case-sensitive

#time

#titleparts

Esta función separa el título de una página –pasada la ruta como parámetro–, lo divide en segmentos según los slashes –barras (|)– que tenga, y devuelve el segmento o segmentos que se le pida.

Si no se especifica el numero de <segmentos a devolver>, el valor por defecto es 0, es decir, que se devuelven todos los segmentos.
Si no se especifica el <primer segmento> devuelto, o se especifica como 0, el valor por defecto es 1:

{{#titleparts: Discusión:Foo/bar/baz/quok }} → Discusión:Foo/bar/baz/quok

{{#titleparts: Discusión:Foo/bar/baz/quok | 1 }} → Discusión:Foo

{{#titleparts: Discusión:Foo/bar/baz/quok | 2 }} → Discusión:Foo/bar

{{#titleparts: Discusión:Foo/bar/baz/quok | | 2 }} → bar/baz/quok

{{#titleparts: Discusión:Foo/bar/baz/quok | 2 | 2 }} → bar/baz

Se aceptan valores negativos para ambos parámetros.
Un número negativo en <segmentos a devolver>, se entiende como cuántas partes se eliminarán, contando desde el final.
Un número negativo como <primer segmento>, lo toma contando desde la derecha.

{{#titleparts: Discusión:Foo/bar/baz/quok/foo1/foo2/foo3/foo4 | -1 | -3 }} → foo2/foo3

{{#titleparts: Discusión:Foo/bar/baz/quok/foo1/foo2/foo3/foo4 | -2 | 3}} → baz/quok/foo1/foo2

{{#titleparts: Discusión:Foo/bar/baz/quok/foo1/foo2/foo3/foo4 | 2 | -3 }} → foo2/foo3

{{#titleparts: Discusión:Foo/bar/baz/quok/foo1/foo2/foo3/foo4 | 2 | 3}} → baz/quok

{{#titleparts: Discusión:Foo/bar/baz/quok/foo1/foo2/foo3/foo4 | | -3 }} → foo2/foo3/foo4

{{#titleparts: Discusión:Foo/bar/baz/quok/foo1/foo2/foo3/foo4 | | 3 }} → baz/quok/foo1/foo2/foo3/foo4

{{#titleparts: Discusión:Foo/bar/baz/quok/foo1/foo2/foo3/foo4 | -2 }} → Discusión:Foo/bar/baz/quok/foo1/foo2

{{#titleparts: Discusión:Foo/bar/baz/quok/foo1/foo2/foo3/foo4 | 2 }} → Discusión:Foo/bar

Advertencias

Sustitución

Una función del analizador sintáctico puede ser sustituida por su valor, de manera automática cuando se guarda la página, añadiendo el prefijo subst: al nombre de la función.

Esta "sustitución" hace que una vez que la página ha sido guardada, la parser function dejará de actuar como tal, para pasar a tener de manera definitiva, el valor que tenía en el momento exacto del guardado:

{{#time:j/M/Y(H:i)}} → 20/abr/2024(02:24) La parser function, hace que cada vez que alguien ve esa página, se muestre la fecha/hora de la wiki local en ese momento concreto.

{{subst:#time:j/M/Y(H:i)}} → 19/May/2009(11:27) Guarda la fecha/hora en que se guardó la página, y así queda para futuras visitas.

Tablas

Las funciones pueden arruinar la sintaxis de las wikitablas, tomando todos los caracteres de una celda, como parámetros de la función (en tanto que se usa el mismo caracter para separar celdas, que para separar parámetros «|» dentro de una parser function).
Hay dos maneras de evitar este inconveniente:

• Para evitar esto, la mayoría de las wikis disponen de la plantilla {{Plantilla:!}}, cuyo contenido es el caracter en cuestión «|». Esto, oculta el caracter problemático para el analizador de MediaWiki, asegurando que no se tenga encuenta el mismo, hasta que todas las plantillas, variables y funciones, hayan sido expandidas.
• También se puede usar la sintaxis de tablas propia del HTML.

Caracteres en blanco

Los caracteres en blanco, tabulaciones, espacios o saltos de línea son eliminados al principio y el final de todos los parámetros de estas parser function. Si se desea conservar estos caracteres especiales, se puede usar algún caracter especial del HTML, o codificación Unicode antes o después de los caracteres en blanco, tabulaciones, espacios o saltos de línea que se quieran mantener como parámetros.

{{#ifeq: foo    |    foo | igual | distinto }} → igual

{{#ifeq: foo   &#32|&#32;   foo | igual | distinto }} → distinto