Help:Extension:ParserFunctions/fr

Cette extension MediaWiki est une collection de fonctions du parseur permettant la programmation au sein des modèles. Les fonctions du parseur ont cette syntaxe typique :

{{#nom_de_la_fonction: argument 1 | argument 2 | argument 3...}}

Fonctions

Ce module définit les fonctions suivantes pour le moment : #expr:, #ifexpr:, #if:, #ifeq:, #ifexist:, #rel2abs:, #switch:, #time:, #timel:, #titleparts:...

#expr:

La fonction #expr: calcule des expressions mathématiques. La syntaxe est :

{{ #expr: expression }}

Les opérateurs booléens considèrent toute valeur numérique valide non nulle comme vraie et 0 comme faux. Les nombres doivent être écris avec leur décimale marquée par le point décimal « . ».

Le résultat de #expr sera formaté sous forme décimale, en utilisant la notation exponentielle si l’exposant de base 10 sort de l’intervalle -4 à 13, mais durant le calcul la précision interne de calcul est plus élevée et utilise des nombres réels codés en binaire en double précision, conformément à la norme IEEE 754 (54 bits de mantisse, un bit de signe et 11 bits pour l'exposant de base 2 représentant des exposants signés entre -1024 et 1023, mais la mantisse est normalisée de façon à pouvoir représenter au moins 1 bit de mantisse significatif pour les valeurs absolues entre 2 puissance -1074 et 2 puissance 1024, y compris les valeurs dénormalisées pour les petits nombres, ainsi que la valeur zéro ainsi que des valeurs infinies signées et au moins une valeur indéfinie). Certaines fonctions décrites ci-dessous ont toutefois une précision plus limitée (notamment les fonctions logarithmiques, exponentielles, et trigonométriques). La précision effective de certains calculs dépend de la précision des bibliothèques mathématiques compilées dans la version de PHP installée sur le serveur, et même avec des bibliothèques conformes à la norme IEEE 754, les marges de tolérance peuvent varier d’un système à l’autre.

Certains calculs peuvent donner un résultat infini (INF ou -INF) ou non significatif (NAN) qui n'est pas considéré comme une erreur dans les calculs mais sera retourné dans la chaîne du résultat final. Cette chaîne ne peut alors pas être reconnue dans une autre expression #expr: englobante et produira une erreur, alors que la fonction #iferror: (voir-ci-dessous) ne détecte pas la validité de ces résultats. On peut y pallier en englobant l’évaluation de #expr: dans une autre expression #expr: qui sera testée par #iferror:. Par exemple :

• {{#expr: 0/0}} retourne «  » qui est détecté par #iferror: :
  • {{#iferror: {{#expr: 0/0}}|erreur !}} retourne « erreur ! ».
• {{#expr: 1e1000}} retourne « INF » qui n’est pas détecté directement par #iferror:
  • {{#iferror: {{#expr: 1e1000}}|erreur !}} retourne « INF ».
  • {{#iferror: {{#expr: {{#expr: 1e1000}} }}|erreur !}} retourne « erreur ! ».

Une des opérations (mod) utilise uniquement la précision des entiers supportés par le système PHP sur laquelle MediaWiki est installé. Pour les applications mathématiques, on lui préférera l’emploi de l’opérateur floor afin de correctement effectuer les divisions entières sur un domaine de valeurs plus étendu et calculer le reste réel de cette division.

Les opérateurs supportés (classés par ordre de priorité de traitement) sont :

Priorité	Type	Opérateurs	Exemples
1	Groupement d’évaluation prioritaire (parenthèses)	( )	{{#expr: (1 + 2) * 3}} = 9 {{#expr: 1 + 2 * 3}} = 7 {{#expr: 1 + (2 * 3)}} = 7
2	Nombres décimaux et constantes	1234.5 e pi	{{#expr: 1.50}} = 1.5 {{#expr: e}} = 2.718281828459 {{#expr: pi}} = 3.1415926535898
3	Changements de signe (fonction ou opérateur monadique)	+ - abs	{{#expr: +1.50}} = 1.5 {{#expr: --1.5}} = 1.5 {{#expr: -0}} = 0 {{#expr: +0}} = 0 {{#expr: abs 1.5}} = 1.5 {{#expr: abs 0}} = 0 {{#expr: abs -1.5}} = 1.5
	Arrondis à un entier proche (fonction ou opérateur monadique) (inférieur, vers zéro, ou supérieur)	floor trunc ceil	{{#expr: floor -1.5}} = -2 {{#expr: floor 1.5}} = 1 {{#expr: trunc -1.5}} = -1 {{#expr: trunc 1.5}} = 1 {{#expr: ceil -1.5}} = -1 {{#expr: ceil 1.5}} = 2
	Logarithme naturel ou népérien (de base e)	ln	{{#expr: ln e}} = 1 {{#expr: ln 1000 / ln 10}} = 3 (= log10 1000) {{#expr: ln 8 / ln 2}} = 3 (= log2 8)
	Sinus et arcsinus (angles exprimé en radians)	sin asin	{{#expr: sin -pi}} = -1.2246467991474E-16 (devrait être aussi proche de 0 que possible) {{#expr: sin(-pi/2)}} = 1 {{#expr: sin 0}} = 0 {{#expr: sin(pi/2)}} = 1 {{#expr: sin(2*pi/3) ^ 2}} = 0.75 {{#expr: sin(pi/4) ^ 2}} = 0.5 {{#expr: sin(pi/6)}} = 0.5 {{#expr: sin pi}} = 1.2246467991474E-16 (devrait être aussi proche de 0 que possible) {{#expr: (asin -1) / pi}} = -0.5 {{#expr: (asin 0) / pi}} = 0 {{#expr: (asin 1) / pi}} = 0.5
	Cosinus et arccosinus (angles exprimé en radians)	cos acos	{{#expr: cos -pi}} = -1 {{#expr: cos(-pi/2)}} = 6.1232339957368E-17 (devrait être aussi proche de 0 que possible) {{#expr: cos 0}} = 1 {{#expr: cos(pi/2)}} = 6.1232339957368E-17 (devrait être aussi proche de 0 que possible) {{#expr: cos(2*pi/3)}} = -0.5 {{#expr: cos(pi/4) ^ 2}} = 0.5 {{#expr: cos(pi/6) ^ 2}} = 0.75 {{#expr: cos pi}} = -1 {{#expr: (acos -1) / pi}} = 1 {{#expr: (acos 0) / pi}} = 0.5 {{#expr: (acos 1) / pi}} = 0
	Tangeante et arctangeante (angles exprimé en radians)	tan atan	{{#expr: tan -pi}} = 1.2246467991474E-16 (résultat qui devrait être nul, mais souvent proche de zéro et de signe indéterminé) {{#expr: tan(-pi/2)}} = -1.6331239353195E+16 (résultat de signe indéterminé et de valeur absolue très grande mais indéfinie, ou bien erreur) {{#expr: tan 0}} = 0 {{#expr: tan(pi/2)}} = 1.6331239353195E+16 (résultat de signe indéterminé et de valeur absolue très grande mais indéfinie, ou bien erreur) {{#expr: tan(3*pi/4) ^ 2}} = 1 {{#expr: tan(pi/4) ^ 2}} = 1 {{#expr: tan(pi/6) ^ 2}} = 0.33333333333333 {{#expr: tan pi}} = -1.2246467991474E-16 (résultat qui devrait être nul, mais souvent proche de zéro et de signe indéterminé) {{#expr: (atan -1) / pi}} = -0.25 {{#expr: (atan 0) / pi}} = 0 {{#expr: (atan 1) / pi}} = 0.25
	Non logique (retourne 1 si le paramètre est égal à zéro, sinon retourne 0)	not	{{#expr: not 0}} = 1 {{#expr: not 0.2}} = 0 {{#expr: not 1}} = 0 {{#expr: not -1}} = 0 {{#expr: not 2}} = 0
4	Multiplication par une puissance de 10 (limité entre -323 et +308 : en deça donne zéro, au delà donne l’infini) (Noter que le second paramètre de l’exposant de base 10 n’est pas nécessairement entier)	e	{{#expr: 0.1 e 309}} = INF (infini, car exposant supérieur à la limite haute) {{#expr: -0.1 e 309}} = -INF (infini, car exposant supérieur à la limite haute) {{#expr: 1.797693134862316 e 308}} = INF {{#expr: 1.797693134862315 e 308}} = 1.7976931348623E+308 (plus grand nombre représentable) {{#expr: ln 1.797693134862315 e 308 / ln 2}} = 1024 (plus grande puissance de 2 représentable) {{#expr: 1 e 14}} = 1.0E+14 (notation exponentielle utilisée dans ce résultat) {{#expr: 9.99 e 13}} = 99900000000000 (pas de notation exponentielle dans ce résultat) {{#expr: 1 e 0.5}} = 3.1622776601684 (racine carrée de 10) {{#expr: 1 e 0}} = 1 (pas de notation exponentielle dans ce résultat) {{#expr: 1 e -4}} = 0.0001 (pas de notation exponentielle dans ce résultat) {{#expr: 9 e -5}} = 9.0E-5 (notation exponentielle utilisée dans ce résultat) {{#expr: 1 e -30}} = 1.0E-30 (notation exponentielle utilisée dans le résultat) {{#expr: 1 e -323}} = 9.8813129168249E-324 {{#expr: 10 e -324}} = 0 (et non comme le précédent) {{#expr: 0.2500001 e -323}} = 4.9406564584125E-324 (plus petit nombre représentable, arrondi ici) {{#expr: ln 0.2500001 e -323 / ln 2}} = -1074 (plus petite puissance de 2 représentable) {{#expr: 0.2500001 e -323 / 1.499}} = 4.9406564584125E-324 (résultat arrondi au dessus) {{#expr: 0.2500001 e -323 / 1.5}} = 4.9406564584125E-324 (résultat arrondi à zéro) {{#expr: 0.25 e -323}} = 0 (zéro, car exposant inférieur à la limite basse)
	Exponentiation Les puissances de 2 représentables sont celles dont l’ordre est compris entre -1074 et +1024 (bornes exclues) : voir les exemples ci-dessus et ci-contre. Les puissances de 10 représentables sont celles dont l’ordre est compris entre -323 et +308 (bornes inclues) : voir également ci-dessus. Il n'y a pas d’opérateur spécifique pour la racine carrée, mais on l’obtient avec une très bonne précision avec la puissance 0.5 (voir exemple ci-contre). Les puissances de nombres négatifs ne sont supportées que si l’exposant est entier (afin d’en déterminer la parité et le signe du résultat), sinon le résultat est indéfini (NAN).	^	{{#expr: 2 ^ 1024}} = INF (infini car dépassement de capacité) {{#expr: 1.999999999999999888 * 2 ^ 1023}} = 1.7976931348623E+308 (plus grande puissance de 2 représentable) {{#expr: 2 ^ 2}} = 4 {{#expr: 2 ^ 0.5}} = 1.4142135623731 (racine carrée de 2) {{#expr: 2 - (2 ^ 0.5) ^ 2}} = -4.4408920985006E-16 (précision de la racine carrée de 2) {{#expr: 2 ^ 0}} = 1 (élément absorbant) {{#expr: 2 ^ -1074}} = 4.9406564584125E-324 (plus petite puissance de 2 représentable) {{#expr: 1.999999999999999888 * 2 ^ -1075}} = 0 (zéro car limite de représentation dépassée) {{#expr: (-1) ^ 2}} = 1 {{#expr: (-1.5) ^ 7}} = -17.0859375 {{#expr: (-1) ^ 0.5}} = NAN {{#expr: e ^ 0}} = 1 (élément absorbant) {{#expr: e ^ ln 2}} = 2 (inversion du logarithme)
5	Produit, division ou reste (de gauche à droite) Attention : l’opérateur mod n’est pas un reste au sens mathématique du terme, il tronque d'abord ses opérandes à l’entier le plus proche dont la valeur absolue est inférieure celle du nombre, puis réduit ces entiers sur 32 bits ou 64 bits (selon la plateforme du serveur pour laquelle PHP est compilé et installé). Il effectue ensuite la division entière des deux opérandes entiers obtenus, et retourne le reste de cette division, du même signe que le quotient entier, et toujours inférieur, en valeur absolue, à celle du diviseur entier. Il retourne une erreur si la valeur absolue du diviseur n'est pas supérieure ou égal à 1 ; il retourne toujours 0 si le diviseur n'est pas au moins égal à 2 en valeur absolue.	* / div mod	{{#expr: 22 * 3}} = 66 {{#expr: 22 / 3}} = 7.3333333333333 {{#expr: 22 div 3}} = 7.3333333333333 (opérateur synonyme, identique à la division réelle) {{#expr: 22 mod 3}} = 1 (modulo entier, voir note ci-contre) {{#expr: 21.999 mod 3}} = 0 (modulo entier, voir note ci-contre) {{#expr: 22 / 1.5}} = 14.666666666667 {{#expr: 22 div 1.5}} = 14.666666666667 (identique à la division réelle) {{#expr: 22 mod 1.5}} = 0 (reste de la division des opérandes d’abord tronqués en entiers) {{#expr: floor(22/1.5)}} = 14 (partie entière inférieure de la division) {{#expr: 22-floor(22/1.5)*1.5}} = 1 (reste de cette dernière division)
6	Somme ou différence (de gauche à droite)	+ -	{{#expr: 30 + 7}} = 37 {{#expr: 30 - 7}} = 23
7	Arrondit à n décimales, pour limiter la précision de l’affichage (la précision maximale ne peut pas dépasser 14 chiffres significatifs, mais le second opérande mentionne une précision absolue indépendante de la valeur du premier opérande).	round	{{#expr: 30 / 7}} = 4.2857142857143 {{#expr: 30 / 7 round 14}} = 4.2857142857143 {{#expr: 30 / 7 round 7}} = 4.2857143 {{#expr: 30e50 / 7 round 7}} = 4.2857142857143E+50 {{#expr: 30e-50 / 7 round 7}} = 0
8	Relation d’égalité numérique Attention aux approximations numériques des résultats intermédiaires. Une très faible différence peut suffire (notamment pour les fonctions trigonométriques, logarithmes et exponentielles).	= != <>	{{#expr: 30 = 7}} = 0 {{#expr: 30 <> 7}} = 1 {{#expr: 30 != 7}} = 1 {{#expr: 30 = 30.0}} = 1 {{#expr: 1 / 17 * 17}} = 1 (résultat non garanti, devrait être 1) {{#expr: 1 - 1 / 17 * 17}} = 0 (résultat non garanti, devrait être 0) {{#expr: 1 = (1/pi^3 * pi^2 * pi)}} = 1 (résultat non garanti, devrait être 1) {{#expr: 1 - (1/pi^3 * pi^2 * pi)}} = 0 (résultat non garanti, devrait être 0) {{#expr: 3 = (3 ^ 0.5 ^ 2)}} = 0 (résultat non garanti, devrait être 1) {{#expr: 3 - (3 ^ 0.5 ^ 2)}} = 4.4408920985006E-16 (résultat non garanti, devrait être 0) {{#expr: 3 != (3 ^ 0.5 ^ 2)}} = 1 (résultat non garanti, devrait être 0)
	Relation d’ordre total (inférieur ou égal à, supérieur ou égal à)	<= >=	{{#expr: 30 <= 7}} = 0 {{#expr: 30 >= 7}} = 1
	Relation d’ordre partiel (inférieur strictement à, supérieur strictement à)	< >	{{#expr: 30 < 7}} = 0 {{#expr: 30 > 7}} = 1
9	Et logique Tout opérande non nul est considéré comme vrai. Retourne 1 si les deux opérandes sont vrais, sinon retourne 0.	and	{{#expr: 0 and 0}} = 0 {{#expr: 0 and 7}} = 0 {{#expr: 30 and 0}} = 0 {{#expr: 30 and 7}} = 1
10	Ou logique Tout opérande non nul est considéré comme vrai. Retourne 0 si les deux opérandes sont faux, sinon retourne 1.	or	{{#expr: 0 or 0}} = 0 {{#expr: 0 or 7}} = 1 {{#expr: 30 or 0}} = 1 {{#expr: 30 or 7}} = 1

Exemple :

{{ #expr: (100 - 32) / 9 * 5 round 0 }}

donne :

38

qui correspond à 100 °F converti en °C, résultat arrondi au nombre entier le plus proche.

#ifexpr:

#ifexpr: évalue une expression mathématique (de la même façon que #expr:) et renvoie une des chaînes en paramètres selon le résultat.

Si l’expression est évaluée à une valeur non nulle, alors renvoie le paramètre alors texte, sinon renvoie le paramètre sinon texte :

{{ #ifexpr: <expression> | <alors texte> | <sinon texte> }}

Si l’expression est évaluée à une valeur non nulle, alors renvoie le paramètre alors texte, sinon renvoie un texte vide :

{{ #ifexpr: <expression> | <alors texte> }}

Si l’expression ne peut pas être évaluée et retourne une erreur, la fonction #ifexpr: retourne cette erreur et non l’un des deux textes en paramètres :

{{#ifexpr: 0/0|oui|non}} retourne «  ».

Avertissement : bien que l’on ait :

{{#ifexpr: 1E1000|oui|non}} qui retourne « oui »,

l’expression en paramètre ne retourne pas un nombre fini (car il n’est pas exprimable dans les calculs intermédiaires en tant que nombre en virgule flottante double-précision IEEE 754) :

{{#expr: 1E1000}} retourne « INF »,

et ce nombre « infini » produit par la suite une erreur, s’il est réévalué par #ifexpr: (ou un autre #expr: englobant) :

{{#ifexpr: {{#expr:1E1000}}|oui|non}} retourne «  ».

#if:

La fonction #if: est une construction if-then-else. Sa syntaxe est la suivante :

{{ #if: <condition> | <alors texte1> | <sinon texte2> }}

Si la condition est une chaîne qui n'est ni vide ni composée d'espaces uniquement, elle est considérée comme vraie et <alors texte1> est renvoyé. Sinon, c'est <sinon texte2> sera renvoyé. Le <sinon texte2> peut être omis, dans ce cas le résultat retourné sera vide si la condition est fausse.

Exemples :

{{#if: | vrai}} ->
{{#if: | vrai | faux}} -> faux

{{#if: quelquechose | vrai}} -> vrai
{{#if: quelquechose | vrai | faux}} -> vrai
{{#if: quelquechose | | faux}} ->

En général, la condition utilisée sera la valeur d'un paramètre. On utilise alors la syntaxe suivante :

{{ #if: {{{paramètre|}}} | <alors texte1> | <sinon texte2> }}

Le texte renvoyé est :

• <alors texte1> si le paramètre paramètre est défini et n'est ni vide ni égal à une suite d'espaces ;
• <sinon texte2> dans le cas contraire, à savoir : paramètre n'est pas défini ou est vide ou égal à une suite d'espaces.

On a donc le schéma suivant (si le #if est utilisé dans le code de « Modèle » avec « paramètre » présent, non défini ou vide) :

    {{Modèle|paramètre=quelquechose}}    {{Modèle}}    {{Modèle|paramètre=}}
                    \_____________            \______________/ 
                                  |                |  
                                 _|_              _|_ 
{{ #if: {{{paramètre|}}} | <alors texte1> | <sinon texte2> }}

Remarques :

• La syntaxe {{ #if:{{{paramètre}}}| <alors texte1> | <sinon texte2> }} ne donne pas le résultat auquel on s'attendrait de prime abord. En effet, dans ce cas, si paramètre n'est pas défini, c'est <alors texte1> qui sera renvoyé. La raison en est simple : lorsque paramètre n'est pas défini, la chaîne {{{paramètre}}} n'est pas interprétée, et vaut donc {{{paramètre}}}, ce qui n'est ni une chaîne vide, ni une suite d'espaces. La condition est donc considérée comme vraie. La solution consiste à préciser un paramètre vide par défaut : {{{paramètre|}}}.
• La fonction if ne connaît pas le signe « = » ni les expressions mathématiques. {{#if: 1 = 2|oui|non }} renverra « oui » car la chaîne « 1 = 2 » n'est pas vide. Pour comparer des chaînes, utilisez ifeq. Pour comparer des nombres, utilisez ifexpr.

#ifeq:

#ifeq: compare deux chaînes et retourne une autre chaîne selon le résultat de la comparaison. La syntaxe est la suivante :

{{ #ifeq: <texte à comparer 1> | <texte à comparer 2> | <texte retourné si égal> | <texte retourné si différent> }}

Noter que les blancs, sauts de lignes et commentaires HTML sont supprimés au début et à la fin des paramètres des textes à comparer et des textes à retourner.

On peut limiter cette suppression automatique des blancs en insérant un <nowiki/> pour protéger les espaces à supprimer, mais il faut savoir que ces codes ne sont pas totalement transparents pour la comparaison de chaînes avec #ifeq: (et aussi #switch:) car les sections nowiki sont temporairement remplacées par un code unique pour chaque occurence syntaxiquement différente, qui fera partie des valeurs comparées.

Ainsi, on obtient de façon surprenante :

« {{ #ifeq: <nowiki /> | <nowiki/> | oui | non }} » retourne « non »,

« {{ #ifeq: <nowiki></nowiki> | <nowiki/> | oui | non }} » retourne « non ».

« {{ #ifeq: <nowiki/> | <nowiki/> | oui | non }} » retourne « non ».

« {{ #ifeq: <nowiki/>a<nowiki/> | <nowiki/>a<nowiki/> | oui | non }} » retourne « non »,

en dépit du fait que les valeurs comparées sont logiquement identiques (y compris jusque dans leur syntaxe dans la source dans les deux derniers exemples), car à chaque occurence d’une section « nowiki » leur sont attribués des codes uniques différents, qui ne seront supprimés du texte qu’à la fin de l’expansion et la substitution des modèles et fonctions parseur, lors de la génération du HTML final, et non pas traités comme de simples délimiteurs syntaxiques.

Il est possible qu’à l'avenir cette anomalie soit corrigée, et donc aucun modèle ne devrait être conçu en profitant de cette anomalie, et on évitera donc l’emploi de sections « nowiki » dans les valeurs à comparer (y compris celles générées à l’intérieur d’un sous-modèle).

Il est donc préférable d’utiliser plutôt les entités de caractères HTML (avec la syntaxe « &#32; » par exemple pour coder une espace).

#iferror:

Cette function prend un paramètre chaîne en entrée et retourne un des résultats fournis dans un ou deux paramètres suivants ; la fonction évalue le premier paramètre comme vrai si la chaîne donnée en entrée contient un objet HTML ayant la class="error", qui est générée par d’autres fonctions de parseur telles que #expr:, #time: et #rel2abs:, des erreurs de modèles telles que des boucles et récursions, et d’autres erreurs de parseur à erreur non fatale.

{{#iferror: chaîne testée | valeur retournée si erreur | valeur retournée si correct }}

L’une ou l’autre des chaînes de retour peut être omise :

• Si la valeur retournée si erreur est omise, la fonction retournera une chaine vide en cas d’erreur détectée dans la chaîne testée.
• Sinon si la valeur retournée si correcte est omise, la chaîne testée sera retournée simplement si elle n’est pas erronée.

{{#iferror: {{#expr: 1 + 2 }} | erreur | correct }} → correct

{{#iferror: {{#expr: 1 + X }} | erreur | correct }} → erreur

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

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

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

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

{{#iferror: <strong class="error">message</strong> | error | correct }} → erreur

#ifexist:

#ifexist: retourne une chaîne selon l'existence ou non d'une page.

{{#ifexist: <nom de la page> | <texte si la page existe> | <texte si la page n'existe pas>}}

{{#ifexist:}} ne gère pas les chemins relatifs (comme '../foo') ; pour cela, l'utiliser en combinaison avec {{#rel2abs:}}.

#rel2abs:

#rel2abs: convertit un chemin relatif en un chemin absolu.

{{#rel2abs: <chemin>}}
{{#rel2abs: <chemin> | <chemin de base> }}

Un chemin relatif est un chemin commençant par '/', './', '../', contenant '/../' ou '/.', ou est simplement la chaîne '..' ou '.'. Si un chemin de base est donné, il doit être défini de façon absolue.

#switch:

#switch: compare une valeur unique à plusieurs autres et renvoie une chaîne si une correspondance est trouvée. La syntaxe est principalement :

{{ #switch: <valeur à comparer>
| <valeur1> = <résultat1>
| <valeur2> = <résultat2>
| ...
| <valeurn> = <résultatn>
| <résultat par défaut>
}}

#switch: cherchera à travers toutes les valeurs jusqu'à ce qu'une correspondance soit trouvée. Lorsque la correspondance est trouvée, le résultat pour cette valeur est renvoyée (la chaîne de texte après le signe égal). Si aucune correspondance n'a été trouvée, le dernier résultat trouvé n'ayant pas de signe égal sera renvoyé comme texte par défaut. Si votre résultat par défaut doit comporter un signe égal, vous devez utiliser #default :

{{ #switch: <valeur à comparer>
| <valeur> = <résultat>
| #default = <résultat par défaut>
}}

Notez qu’il est également possible d'avoir une « dégringolade » de valeurs (qui réduit la nécessité de résultats dupliqués). Par exemple :

{{ #switch: <valeur à comparer>
| <valeur1>
| <valeur2>
| <valeur3> = <résultat3>
| ...
| <valeurn> = <résultatn>
| <résultat par défaut>
}}

Notez la façon dont les valeur₁ et valeur₂ n'ont pas de signe égal. Si elles entrent en correspondance, elles auront alors le résultat de la valeur₃ (c'est-à-dire que nous aurons le résultat₃).

En revanche (comme aussi le switch de nombreux langages de programmation), le code suivant ne pourra pas retourner plusieurs résultats simultanément :

{{ #switch: <valeur à comparer>
| <valeur1>
| <valeur2> = <résultat1>
| ...
| <valeur1> = <résultatn>
| <résultat par défaut>
}}

Ci-dessus, quand la <valeur à comparer> est <valeur₁>, le résultat sera <résultat₁> seulement (et les branches suivantes seront ignorées). Si plusieurs résultats doivent être retournés, il faut soit employer un deuxième #switch:, soit combiner les résultats multiple dans la même branche. Le #switch: ne permet pas non plus la continuation d’une branche à l’autre.

#time:

Code	Description	Valeur actuelle
		avec #time	avec #timel
Année
Y	L’année grégorienne, sur 4 chiffres.	2012	2012
y	L’année grégorienne, sur 2 chiffres.	12	12
o ¹	L’année ISO 8601, sur 4 chiffres. ²	2012 ³	2012 ³
¹ Requiert PHP 5.1.0 ou supérieur et rev:45208. ² Ceci produit la même valeur que Y, excepté que si le numéro de semaine ISO 8601 (W) appartient à l’année grégorienne précédente ou suivante, cette année est retournée à la place (cette différence ne peut se produire au plus que pour les 3 premiers jours de janvier ou les 3 derniers jours de décembre). ³ Ceci affichera la lettre littérale o si la condition ¹ n’est pas remplie.
Mois
n	Le numéro du mois de l’année grégorienne, sur 1 ou 2 chiffres, entre 1 et 12, sans zéro initial.	5	5
m	Le numéro du mois de l’année grégorienne, sur 2 chiffres, entre 01 et 12, avec un zéro initial éventuel.	05	05
M	Une abréviation du nom du mois de l’année grégorienne, dans la langue et l’écriture principales du site.	May	May
F	Le nom complet du mois de l’année grégorienne, dans sa déclinaison au nominatif de la langue et l’écriture principales du site.	May	May
xg	Le nom complet du mois de l’année grégorienne, dans sa déclinaison au génitif pour les langues de sites qui distinguent les cas du nominatif et du génitif, sinon identique au précédent.	Exemple en polonais : nominatif : {{#time:d F Y|20 June 2010}} → 20 czerwiec 2010 génitif : {{#time:d xg Y|20 June 2010}} → 20 czerwca 2010
Jour du mois ou de l’année
j	Le numéro du jour du mois de l’année grégorienne, sur 1 ou 2 chiffres, entre 1 et 28, 29, 30 ou 31, sans zéro initial.	30	30
d	Le numéro du jour du mois de l’année grégorienne, sur 2 chiffres, entre 01 et 28, 29, 30 ou 31, avec un zéro initial éventuel.	30	30
z	Le nombre de jours écoulés depuis le début de l’année grégorienne, sur 1, 2 ou 3 chiffres, entre 0 (le 1erjanvier) et 364 ou 365, sans zéros initiaux. Note : Pour obtenir le numéro ISO 8601 du jour de l’année, ajouter 1.	150	150
Semaine
W	Le numéro de la semaine ISO 8601 dans l’année ISO 8601, sur deux chiffres, entre 01 et 52 ou 53, avec un zéro initial éventuel.	22	22
Jour de la semaine
D	Une abréviation du nom du jour de la semaine ISO 8601, souvent en anglais (Sun à Sat) car rarement internationalisé dans la langue et l’écriture principales du site.	Wed	Wed
l	Le nom complet du jour de la semaine ISO 8601, souvent en anglais (Sunday à Saturday) car rarement internationalisé dans la langue et l’écriture principales du site.	Wednesday	Wednesday
N	Le numéro du jour de la semaine ISO 8601, sur 1 chiffre, de 1 (le lundi) à 7 (le dimanche).	3	3
w	Le numéro du jour de la semaine américain, sur 1 chiffre, de 0 (le dimanche) à 6 (le samedi).	3	3
Cadran horaire et heure du jour
a	Le cadran horaire, « am » le matin ou à midi inclus (01:00:00 → 12:59:59), « pm » l’après-midi et à minuit inclus (13:00:00 → 00:59:59).	pm	pm
A	Le cadran horaire, comme a ci-dessus mais écrit en lettres capitales, « AM » ou « PM ».	PM	PM
g	L’heure du cadran, sur 1 ou 2 chiffres, de 1 à 12 (midi ou minuit), sans zéro initial.	4	4
h	L’heure du cadran, sur 2 chiffres, de 01 à 12 (midi ou minuit), avec un zéro initial éventuel.	04	04
G	L’heure du jour, sur 1 ou 2 chiffres, de 0 (minuit) à 23, sans zéro initial.	16	16
H	L’heure du jour, sur 2 chiffres, de 00 (minuit) à 23, avec un zéro initial éventuel.	16	16
Minute et seconde horaires
i	Nombre de minutes passées dans l’heure, sur 2 chiffres, de 00 à 59, avec un zéro initial éventuel.	37	37
s	Nombre de secondes passées dans la minute, sur 2 chiffres, de 00 à 59 (parfois 58 ou 60 juste avant minuit), avec un zéro initial éventuel.	47	47
Divers
U	Nombre de secondes passées depuis le 1er janvier 1970 à 00:00:00 UTC (indépendant du fuseau horaire).	1338395867	1338395867
t	Le nombre de jours dans le mois grégorien actuel.	31	31
L	1 or 0 selon que l’année grégorienne est bissextile ou non.	1	1
c	La date du calendrier grégorien au format ISO 8601, équivalent à Y-m-dTH:i:s+00:00.	2012-05-30T16:37:47+00:00	2012-05-30T16:37:47+00:00
r	La date du calendrier grégorien au format RFC 2822, équivalent à D, j M Y H:i:s +0000, avec les noms du jour de la semaine et du mois en anglais.	Wed, 30 May 2012 16:37:47 +0000	Wed, 30 May 2012 16:37:47 +0000
Calendriers non grégoriens
Calendrier perso-iranien
xiY	Le numéro complet de l’année, sur 4 chiffres.	1391	1391
xin	Le numéro du mois, sur 1 ou 2 chiffres.	3	3
xiF	Le nom complet du mois.	Khordad	Khordad
xij	Le numéro du jour du mois, sur 1 ou 2 chiffres.	10	10
Calendrier hébreu
xjY	Le numéro complet de l’année, sur 4 chiffres.	5772	5772
xjn	Le numéro du mois, sur 1 ou 2 chiffres.	9	9
xjF	Le nom complet du mois, au nominatif.	Sivan	Sivan
xjx	Le nom complet du mois, au génitif.	Sivan	Sivan
xjj	Le numéro du jour du mois, sur 1 ou 2 chiffres.	9	9
Calendrier musulman traditionnel (hijri)
xmY	Le numéro complet de l’année, sur 4 chiffres.	1433	1433
xmn	Le numéro du mois, sur 1 ou 2 chiffres.	7	7
xmF	Le nom complet du mois.	Rajab	Rajab
xmj	Le numéro du jour du mois, sur 1 ou 2 chiffres.	9	9
Calendrier solaire thaï
xkY	Le numéro complet de l’année, sur 4 chiffres.	2555	2555
Drapeaux
xn	Indique d’utiliser les chiffres arabo-européens de 0 à 9 et non les chiffres de la langue locale du serveur pour formater le champ numérique qui suit immédiatement le drapeau.	Dans la langue hindi (écrite en devanagari), {{#time:H, xnH}} produit par exemple « ०६, 06 ».
xN	Similaire à xn mais en tant que drapeau à bascule, dont l’effet se poursuit jusqu’à la fin de la chaîne ou la prochaine occurence de xN dans la chaîne.
xr	Indique de formater en numération romaine et en lettres capitales le champ numérique qui suit immédiatement le drapeau. Ne fonctionne que pour les nombres jusqu’à 3000.	{{#time:xrY}} → MMXII	{{#timel:xrY}} → MMXII

La fonction parseur #time: évalue l’heure courante sur le serveur (UTC sur les sites de la fondation WikiMedia). Son paramètre est une chaîne de format, dont certaines lettres sont reconnues pour générer un champ basé sur l’heure actuelle, les autres caractères de la chaîne étant conservés verbatim dans le résultat (ces chaînes de format sont identiques à celles supportées dans le langage de programmation PHP utilisé sur le serveur). Les valeurs retournées dépendent de la la locale du serveur (langue, écriture, jeux de chiffres, conventions locales de formats de dates, heures et nombres, fuseau horaire), soit la locale anglo-américaine et l’heure UTC sur le serveur Meta de WikiMedia.

#timel:

Même chose que la fonction parseur #time: (avec les mêmes paramètres) mais cette fois utilise l’heure et la date locale sur le serveur (selon sa locale par défaut et non l’heure et la date UTC).

Sur les serveurs Meta de la Fondation Wikimedia, la date UTC est utilisée comme date locale, et cette fonction produit les mêmes résultats que la précédente.

#titleparts:

Cette fonction sépare un titre de page en segments délimités par les barres obliques « / », puis retourne certains de ces segments dans son résultat.

{{#titleparts: nom de page | nombre de segments à retourner | premier segment à retourner }}

Si le paramètre nombre de segments à retourner n’est pas indiqué, sa valeur par défaut est 0, qui retourne tous les segments. Si le paramètre premier segment à retourner n’est pas indiqué ou est 0, sa valeur par défaut est 1 :

{{#titleparts: {{ns:1}}:Foo/bar/baz/quok }} → Talk:Foo/bar/baz/quok

{{#titleparts: {{ns:1}}:Foo/bar/baz/quok | 1 }} → Talk:Foo

{{#titleparts: {{ns:1}}:Foo/bar/baz/quok | 2 }} → Talk:Foo/bar

{{#titleparts: {{ns:1}}:Foo/bar/baz/quok | 2 | 2 }} → bar/baz

Les valeurs négatives sont acceptées pour les deux valeurs. Les valeurs négatives du nombre de segments à retourner indiquent d’éliminer des segments à partir de la fin de la chaîne. Les valeurs négatives du premier segment à retourner se traduisent en « ajouter cette valeur au nombre total de segments », ce qui est plus ou moins équivalent à « décompter depuis la fin de la chaîne » :

{{#titleparts: {{ns:1}}:Foo/bar/baz/quok | -1 }} → Talk:Foo/bar/baz

{{#titleparts: {{ns:1}}:Foo/bar/baz/quok | | -1 }} → quok

{{#titleparts: {{ns:1}}:Foo/bar/baz/quok | -1 | 2 }} → bar/baz (élimine un segment depuis la fin de la chaîne, puis retourne les segments restants à partir du second.)

La chaîne est découpée en un maximum de 25 segments ; les barres obliques suivantes sont ignorées. La chaîne est également limitée à 255 caractères, puisqu’elle est traitée comme un titre de page :

{{#titleparts: a/b/c/d/e/f/g/h/i/j/k/l/m/n/o/p/q/r/s/t/u/v/w/x/y/z/aa/bb/cc/dd/ee | 1 | 25 }} → y/z/aa/bb/cc/dd/ee

Avertissement :

Vous pouvez utiliser #titleparts: comme un petit « analyseur et convertisseur de chaîne », mais il faut considérer que cela retourne la première sous-chaîne avec une capitale initiale (seulement sur les Wikis dont le titre des pages est implicitement converti avec une capitale initiale, ce qui n’est pas le cas par exemple sur le Wiktionnaire). Si des minuscules sont nécessaires, on pourra utiliser la fonction lc: pour contrôler le résultat :

{{#titleparts: un/deux/trois/quatre | 1 | 1 }} → Un

{{#titleparts: un/deux/trois/quatre | 1 | 2 }} → deux

{{lc: {{#titleparts: un/deux/trois/quatre | 1 | 1 }} }} → un

subst: et safesubst:

L’emploi de subst: et safesubst: associé à une fonction du parseur fonctionne, à condition qu’il n’y ait aucun espace entre « subst: » ou « subst: » d’une part, et « # » d’autre part. Voir également la substitution récursive optionnelle.

Génération du caractère pipe de la syntaxe Wiki des tableaux et paramètres optionnels de liens

Actuellement, la syntaxe du pipe « | » des tableaux du wiki ne peut pas fonctionner au sein des expressions conditionnelles. Il y a deux moyens de contourner le problème :

• cacher à la fonction parseur tous les pipe nécessaires aux tableaux, en l’incluant depuis un modèle, par exemple {{!}} ;
• utiliser la syntaxe HTML des tableaux à la place (solution souvent préférable dans le code des modèles, même si elle ne résoud pas nécessairement tous les problèmes dans des tableaux au formatage complexe).

La même technique peut être utilisée pour générer de façon conditionnelle des paramètres optionnels pour les liens, images ou clés de catégories, en remplaçant un pipe conditionnel (nécessaire pour séparer ces paramètres optionnels) qui devrait être inclus dans un des paramètres de retour d’un #if: ou #switch:, par un appel du même modèle utilitaire {{!}}.

Un tel modèle est présent sous ce nom et s’est standardisé sur la plupart des wikis réalisés avec MediaWiki (dont tous ceux hébergés par la Fondation Wikimedia).

Cette dissimilation des pipes n’est pas nécessaire si le lien est inclus en totalité avec ses paramètres optionnels (avec les [[doubles crochets]] englobants) dans un des paramètres de retour d’un #if: ou #switch:.

Cela n’est pas nécessaire non plus pour séparer les paramètres d’un appel de modèle (ou ceux d’une autre fonction parseur, ou la valeur par défaut d’un paramètre de l’appelant) inclus en totalité (avec ses {doubles ou triples accolades} englobantes) dans l’un quelconque des paramètres de retour d’un #if: ou #switch:.

Installation

Ne concerne que ceux qui ont installé un autre wiki sur leur propre site et désirent intégrer cette fonction.
Ouvrez le dépôt SVN listant les branches de codes à l'adresse suivante :http://svn.wikimedia.org/viewvc/mediawiki/branches/ et cliquez sur la branche correspondant à la version de votre MediaWiki
Par exemple, si la version du logiciel MediaWiki que vous avez installée est 1.15.x, cliquez sur REL1_15/

Cliquez ensuite sur la branche "extensions/" puis sur la branche "ParserFunctions/" Il va falloir copier les fichiers

• Expr.php
• ParserFunctions.php
• ParserFunctions.i18n.php
• ParserFunctions.i18n.magic.php
• ParserFunctions_body.php

dans un nouveau répertoire appelé ParserFunctions, dans votre répertoire extensions.

Pour copier un de ces fichiers, cliquez sur le numéro de la colonne Rev. faisant face au nom du fichier puis sur le lien "download" en haut de la page ainsi accédée.
Il ne reste plus qu'à copier le fichier en cliquant dans le menu "Fichier/enregistrer sous" de votre navigateur

Ensuite, placez le texte suivant à la fin de votre LocalSettings.php :

require_once( "$IP/extensions/ParserFunctions/ParserFunctions.php" );

MediaWiki 1.6

La plupart des ParserFunctions fonctionnent aussi bien depuis la version MediaWiki, mais la syntaxe des ParserFunctions est maintenant précédée du caractère '#'. Si vous voulez ajouter le caractère '#' sur une version plus ancienne, recherchez cette partie du code dans ParserFunctions.php:

 $wgParser->setFunctionHook( 'expr', array( &$wgExtParserFunctions, 'expr' ) );
 $wgParser->setFunctionHook( 'if', array( &$wgExtParserFunctions, 'ifHook' ) );
 $wgParser->setFunctionHook( 'ifeq', array( &$wgExtParserFunctions, 'ifeq' ) );
 $wgParser->setFunctionHook( 'ifexpr', array( &$wgExtParserFunctions, 'ifexpr' ) );
 $wgParser->setFunctionHook( 'switch', array( &$wgExtParserFunctions, 'switchHook' ) );

Puis, replacez avec ce code :

 $wgParser->setFunctionHook( '#expr', array( &$wgExtParserFunctions, 'expr' ) );
 $wgParser->setFunctionHook( '#if', array( &$wgExtParserFunctions, 'ifHook' ) );
 $wgParser->setFunctionHook( '#ifeq', array( &$wgExtParserFunctions, 'ifeq' ) );
 $wgParser->setFunctionHook( '#ifexpr', array( &$wgExtParserFunctions, 'ifexpr' ) );
 $wgParser->setFunctionHook( '#switch', array( &$wgExtParserFunctions, 'switchHook' ) );

Voir aussi

• Help:Extension:ParserFunctions pour une aide plus détaillée et à jour ;
• Extension:StringFunctions ;
• Extension:DynamicFunctions ;
• Extension:VariablesExtension.

Liens externes

• The discussion about the ParserFunctions in the Wikitech-l list archive
• meta:Category:Templates using ParserFunctions
• en:Category:Templates using ParserFunctions