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 :



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

#expr:
La fonction #expr:</tt> calcule des expressions mathématiques. La syntaxe est :

Les opérateurs booléens considèrent toute valeur numérique valide non nulle comme vraie et 0 comme faux. Les nombres doivent être écrits 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-après 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:</tt> englobante et produira une erreur, alors que la fonction #iferror:</tt> (voir ci-après) ne détecte pas la validité de ces résultats. On peut y pallier en englobant l’évaluation de #expr:</tt> dans une autre expression #expr:</tt> qui sera testée par #iferror:</tt>. Par exemple :


 *  </tt> retourne «  » qui est détecté par #iferror:</tt> :
 *  </tt> retourne «  ».
 *  </tt> retourne «  » qui n’est pas détecté directement par #iferror:</tt>
 *  </tt> retourne «  ».
 *  </tt> retourne «  ».

Une des opérations (mod</tt>) 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 <tt>floor</tt> 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 :



!scope="col" | Priorité !scope="col" | Type !scope="col" | Opérateurs !scope="col" | Exemples
 * -valign="top"

!scope="row" | 1 <tt> </tt> =
 * -valign="top"
 * Groupement d’évaluation prioritaire (parenthèses)
 * style="word-spacing:0.5em;font-family:monospace;font-weight:bold"|
 * style="width: 60%;" |

<tt> </tt> =

<tt> </tt> =

!scope="row" | 2 <tt> </tt> =
 * -valign="top"
 * Nombres décimaux et constantes
 * style="word-spacing:0.5em;font-family:monospace;font-weight:bold"| 1234.5 e pi

<tt> </tt> =

<tt> </tt> =

!scope="row" rowspan="7"| 3 <tt> </tt> =
 * -valign="top"
 * Changements de signe (fonction ou opérateur monadique)
 * style="word-spacing:0.5em;font-family:monospace;font-weight:bold"| + - abs

<tt> </tt> =

<tt> </tt> =

<tt> </tt> =

<tt> </tt> =

<tt> </tt> =

<tt> </tt> =

(inférieur, vers zéro, ou supérieur) <tt> </tt> =
 * -valign="top"
 * Arrondis à un entier proche (fonction ou opérateur monadique)
 * style="word-spacing:0.5em;font-family:monospace;font-weight:bold"| floor trunc ceil

<tt> </tt> =

<tt> </tt> =

<tt> </tt> =

<tt> </tt> =

<tt> </tt> =

(de base e) <tt> </tt> =
 * -valign="top"
 * Logarithme naturel ou népérien
 * style="word-spacing:0.5em;font-family:monospace;font-weight:bold"| ln

<tt> </tt> =  (= log10 1000)

<tt> </tt> =  (= log2 8)

(angles exprimé en radians) <tt> </tt> =  (devrait être aussi proche de 0 que possible)
 * -valign="top"
 * Sinus et arcsinus
 * style="word-spacing:0.5em;font-family:monospace;font-weight:bold"| sin asin

<tt> </tt> =

<tt> </tt> =

<tt> </tt> =

<tt> </tt> =

<tt> </tt> =

<tt> </tt> =

<tt> </tt> =  (devrait être aussi proche de 0 que possible)

<tt> </tt> =

<tt> </tt> =

<tt> </tt> =

(angles exprimés en radians) <tt> </tt> =
 * -valign="top"
 * Cosinus et arccosinus
 * style="word-spacing:0.5em;font-family:monospace;font-weight:bold"| cos acos

<tt> </tt> =  (devrait être aussi proche de 0 que possible)

<tt> </tt> =

<tt> </tt> =  (devrait être aussi proche de 0 que possible)

<tt> </tt> =

<tt> </tt> =

<tt> </tt> =

<tt> </tt> =

<tt> </tt> =

<tt> </tt> =

<tt> </tt> =

(angles exprimé en radians) <tt> </tt> =  (résultat qui devrait être nul, mais souvent proche de zéro et de signe indéterminé)
 * -valign="top"
 * Tangeante et arctangeante
 * style="word-spacing:0.5em;font-family:monospace;font-weight:bold"| tan atan

<tt> </tt> =  (résultat de signe indéterminé et de valeur absolue très grande mais indéfinie, ou bien erreur)

<tt> </tt> =

<tt> </tt> =  (résultat de signe indéterminé et de valeur absolue très grande mais indéfinie, ou bien erreur)

<tt> </tt> =

<tt> </tt> =

<tt> </tt> =

<tt> </tt> =  (résultat qui devrait être nul, mais souvent proche de zéro et de signe indéterminé)

<tt> </tt> =

<tt> </tt> =

<tt> </tt> =

<tt> </tt> =
 * -valign="top"
 * Non logique (retourne 1 si le paramètre est égal à zéro, sinon retourne 0)
 * style="word-spacing:0.5em;font-family:monospace;font-weight:bold"| not

<tt> </tt> =

<tt> </tt> =

<tt> </tt> =

<tt> </tt> =

!scope="row" rowspan="2"| 4 (limité entre -323 et +308 : en-deçà 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) <tt> </tt> =  (infini, car exposant supérieur à la limite haute)
 * -valign="top"
 * Multiplication par une puissance de 10
 * style="word-spacing:0.5em;font-family:monospace;font-weight:bold"| e

<tt> </tt> =  (infini, car exposant supérieur à la limite haute)

<tt> </tt> =

<tt> </tt> =  (plus grand nombre représentable)

<tt> </tt> =  (plus grande puissance de 2 représentable)

<tt> </tt> =  (notation exponentielle utilisée dans ce résultat)

<tt> </tt> =  (pas de notation exponentielle dans ce résultat)

<tt> </tt> =  (racine carrée de 10)

<tt> </tt> =  (pas de notation exponentielle dans ce résultat)

<tt> </tt> =  (pas de notation exponentielle dans ce résultat)

<tt> </tt> =  (notation exponentielle utilisée dans ce résultat)

<tt> </tt> =  (notation exponentielle utilisée dans le résultat)

<tt> </tt> =

<tt> </tt> =  (et non comme le précédent)

<tt> </tt> =  (plus petit nombre représentable, arrondi ici)

<tt> </tt> =  (plus petite puissance de 2 représentable)

<tt> </tt> =  (résultat arrondi au dessus)

<tt> </tt> =  (résultat arrondi à zéro)

<tt> </tt> =  (zéro, car exposant inférieur à la limite basse)

Les puissances de 2 représentables sont celles dont l’ordre est compris entre -1074 et +1024 (bornes exclues) : voir les exemples ci-avant et ci-contre. Les puissances de 10 représentables sont celles dont l’ordre est compris entre -323 et +308 (bornes incluses) : voir également ci-avant. 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). <tt> </tt> =  (infini car dépassement de capacité)
 * -valign="top"
 * Exponentiation
 * style="word-spacing:0.5em;font-family:monospace;font-weight:bold"| ^

<tt> </tt> =  (plus grande puissance de 2 représentable)

<tt> </tt> =

<tt> </tt> =  (racine carrée de 2)

<tt> </tt> =  (précision de la racine carrée de 2)

<tt> </tt> =  (élément absorbant)

<tt> </tt> =  (plus petite puissance de 2 représentable)

<tt> </tt> =  (zéro car limite de représentation dépassée)

<tt> </tt> =

<tt> </tt> =

<tt> </tt> =

<tt> </tt> =  (élément absorbant)

<tt> </tt> =  (inversion du logarithme)

!scope="row" | 5 Attention : l’opérateur  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 plate-forme 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 ni égale à 1 ; il retourne toujours 0 si le diviseur n'est pas au moins égal à 2 en valeur absolue. <tt> </tt> =
 * -valign="top"
 * Produit, division ou reste (de gauche à droite)
 * style="word-spacing:0.5em;font-family:monospace;font-weight:bold"| * / div mod

<tt> </tt> =

<tt> </tt> =  (opérateur synonyme, identique à la division réelle)

<tt> </tt> =  (modulo entier, voir note ci-contre)

<tt> </tt> =  (modulo entier, voir note ci-contre)

<tt> </tt> =

<tt> </tt> =  (identique à la division réelle)

<tt> </tt> =  (reste de la division des opérandes d’abord tronqués en entiers)

<tt> </tt> =  (partie entière inférieure de la division)

<tt> </tt> =  (reste de cette dernière division)

!scope="row" | 6 <tt> </tt> =
 * -valign="top"
 * Somme ou différence (de gauche à droite)
 * style="word-spacing:0.5em;font-family:monospace;font-weight:bold"| + -

<tt> </tt> =

!scope="row" | 7 <tt> </tt> =
 * -valign="top"
 * Arrondi à 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).
 * style="word-spacing:0.5em;font-family:monospace;font-weight:bold"| round

<tt> </tt> =

<tt> </tt> =

<tt> </tt> =

<tt> </tt> =

!scope="row" rowspan="3"| 8 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). <tt> </tt> =
 * -valign="top"
 * Relation d’égalité numérique
 * style="word-spacing:0.5em;font-family:monospace;font-weight:bold"| = != &lt;&gt;

<tt> </tt> =

<tt> </tt> =

<tt> </tt> =

<tt> </tt> =  (résultat non garanti, devrait être 1)

<tt> </tt> =  (résultat non garanti, devrait être 0)

<tt> </tt> =  (résultat non garanti, devrait être 1)

<tt> </tt> =  (résultat non garanti, devrait être 0)

<tt> </tt> =  (résultat non garanti, devrait être 1)

<tt> </tt> =  (résultat non garanti, devrait être 0)

<tt> </tt> =  (résultat non garanti, devrait être 0)

<tt> </tt> =
 * -valign="top"
 * Relation d’ordre total (inférieur ou égal à, supérieur ou égal à)
 * style="word-spacing:0.5em;font-family:monospace;font-weight:bold"| &lt;= &gt;=

<tt> </tt> =

<tt> </tt> =
 * -valign="top"
 * Relation d’ordre partiel (strictement inférieur à, strictement supérieur à)
 * style="word-spacing:0.5em;font-family:monospace;font-weight:bold"| &lt; &gt;

<tt> </tt> =

!scope="row" | 9 Tout opérande non nul est considéré comme vrai. Retourne 1 si les deux opérandes sont vrais, sinon retourne 0. <tt> </tt> =
 * -valign="top"
 * Et logique
 * style="word-spacing:0.5em;font-family:monospace;font-weight:bold"| and

<tt> </tt> =

<tt> </tt> =

<tt> </tt> =

!scope="row" | 10 Tout opérande non nul est considéré comme vrai. Retourne 0 si les deux opérandes sont faux, sinon retourne 1. <tt> </tt> =
 * -valign="top"
 * Ou logique
 * style="word-spacing:0.5em;font-family:monospace;font-weight:bold"| or

<tt> </tt> =

<tt> </tt> =

<tt> </tt> =


 * }

Exemple :

donne :

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

#ifexpr:
<tt>#ifexpr:</tt> évalue une expression mathématique (de la même façon que <tt>#expr:</tt>) 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 :

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

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

bien que l’on ait :
 * <tt> </tt> qui retourne «  »,

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) :
 * <tt> </tt> retourne «  »,

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

#if:
La fonction <tt>#if:</tt> est une construction si-alors-sinon. Sa syntaxe est la suivante :

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 &lt;alors texte1&gt; est renvoyé. Sinon, c'est &lt;sinon texte2&gt; sera renvoyé. Le &lt;sinon texte2&gt; peut être omis, dans ce cas le résultat retourné sera vide si la condition est fausse.

Exemples :

&rarr;

&rarr;

&rarr;

&rarr;

&rarr;

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

Le texte renvoyé est :
 * &lt;alors texte1&gt; si le paramètre paramètre  est défini et n'est ni vide ni égal à une suite d'espaces ;
 * &lt;sinon texte2&gt; 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) : \_____________           \______________/                                   |                |                                   _|_              _|_

Remarques :
 * La syntaxe  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 &lt;alors texte1&gt; qui sera renvoyé. La raison en est simple : lorsque paramètre n'est pas défini, la chaîne  n'est pas interprétée, et vaut donc, 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 :.
 * La fonction <tt>if</tt> ne connaît pas le signe « = » ni les expressions mathématiques.  renverra « oui » car la chaîne « 1 = 2 » n'est pas vide. Pour comparer des chaînes, utilisez <tt>ifeq</tt>. Pour comparer des nombres, utilisez <tt>ifexpr</tt>.

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

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 <tt>&lt;nowiki/&gt;</tt> 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 <tt>#ifeq:</tt> (et aussi <tt>#switch:</tt>) 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 :


 * « <tt> </tt> » retourne «  »,
 * « <tt> </tt> » retourne «  ».
 * « <tt> </tt> » retourne «  ».
 * « <tt> </tt> » retourne «  »,

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 « <tt>&amp;#32;</tt> » 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 <tt>class="error"</tt>, qui est générée par d’autres fonctions de parseur telles que <tt>#expr:</tt>, <tt>#time:</tt> et <tt>#rel2abs:</tt>, des erreurs de modèles telles que des boucles et récursions, et d’autres erreurs de parseur à erreur non fatale.


 * <tt> </tt>

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.


 * <tt> </tt> →  
 * <tt> </tt> →  
 * <tt> </tt> →  
 * <tt> </tt> →  
 * <tt> </tt> →  
 * <tt> </tt> →  
 * <tt> </tt> →  

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

ne gère pas les chemins relatifs (comme « ../foo ») ; pour cela, l'utiliser en combinaison avec.

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

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:
compare une valeur unique à plusieurs autres et renvoie une chaîne si une correspondance est trouvée. La syntaxe est principalement :

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  :

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 :

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

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

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

#time:
La fonction parseur <tt>#time:</tt> é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 <tt>#time:</tt> (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.


 * <tt> </tt>

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


 * <tt> </tt> → 
 * <tt> </tt> → 
 * <tt> </tt> →  
 * <tt> </tt> → 

Les valeurs négatives sont acceptées pour les deux valeurs. Les valeurs négatives du <tt>nombre de segments à retourner</tt> indiquent d’éliminer des segments à partir de la fin de la chaîne. Les valeurs négatives du <tt>premier segment à retourner</tt> 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 » :


 * <tt> </tt> → 
 * <tt> </tt> → 
 * <tt> </tt> →  (é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 :


 * <tt> </tt> → 

Vous pouvez utiliser <tt>#titleparts:</tt> 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 <tt>lc:</tt> pour contrôler le résultat :


 * <tt> </tt> → 
 * <tt> </tt> → 
 * <tt> </tt> → 

subst: et safesubst:
L’emploi de <tt>subst:</tt> et <tt>safesubst:</tt> associé à une fonction du parseur fonctionne, à condition qu’il n’y ait aucun espace entre « <tt>subst:</tt> » ou « <tt>subst:</tt> » d’une part, et « <tt>#</tt> » 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 pipes 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 <tt>#if:</tt> ou <tt>#switch:</tt>, 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 <tt> </tt>doubles crochets<tt>  </tt> englobants) dans un des paramètres de retour d’un <tt>#if:</tt> ou <tt>#switch:</tt>.

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 <tt> { </tt>doubles ou triples accolades<tt> } </tt> englobantes) dans l’un quelconque des paramètres de retour d’un <tt>#if:</tt> ou <tt>#switch:</tt>.

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 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 dans un nouveau répertoire appelé ParserFunctions, dans votre dossier extensions.
 * Expr.php
 * ParserFunctions.php
 * ParserFunctions.i18n.php
 * ParserFunctions.i18n.magic.php
 * ParserFunctions_body.php

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 choisissant « Enregistrer sous… » dans le menu « Fichier » 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, remplacez par 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