Extension:Scribunto/Lua reference manual/fr

Introduction
Ce manuel documente Lua dans son utilisation dans Mediawiki à traverts l'extension Scribunto. The manuel est inspiré de Lua 5.1 reference manual, qui est publié sous licence MIT. Ce travail dérivé doit donc être copié en conservant cette même licence.

Copyright © 1994–2012 Lua.org, PUC-Rio.

« ''Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

''THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.'' »

Débuter
Sur un wiki utilisant Mediawiki et Lua activé, créez une page dont le titre commence par « Module: », par exemple « Module:Banane ». Dans cette page copiez le texte suivant :

Sauvegardez puis, dans une autre page (qui ne soit pas un module) écrivez :

Vous pouvez remplacer « Banane » par le nom de module de votre choix. Ceci va appeler la fonction « hello » exportée par ce module. Le code sera remplacé par le texte que cette fonction retourne, dans cet exemple « Hello, world! ».

Le langage
Cette section détaille le lexique, la syntaxe et la sémantique de Lua. Elle décrit donc quels mot-clés sont valides, comment les combiner et ce que leurs combinaisons signifie.

La construction du langage sera expliquée en utilisant la notation extended Backus–Naur Form (EBNF), dans laquelle : { a } signifie 0 ou plus a, et [ a ] signifie un a optionnel. Les éléments non terminaux sont affichés comme non terminaux, les mot-clés sont affichés en gras, les autres symboles terminaux sont affichés sous la forme `=&acute;. La syntaxe complête se trouve à la fin de ce manuel.

Conventions lexicales
Les Noms (aussi appelés identifiants ) dans Lua peuvent être formés de n'importe quelle séquence de lettres, chiffres et tirets bas (underscore) à l'exception du premier caractère qui ne peut être un chiffre. Ceci correspond à la définition des noms dans la plupart des langages. (la définition de « lettre » dépend de la locale courante: tout caractère considéré comme alphabétique dans la locale courante peut être utilisé dans un identifiant). Les identifiants sont utilisés pour nommer les variables et les champs des tables.

Les mot-clés suivants sont réservés et ne peuvent servir de nom:


 * and
 * break
 * do
 * else
 * elseif
 * end
 * false
 * for
 * function
 * if
 * in
 * local
 * nil
 * not
 * or
 * repeat
 * return
 * then
 * true
 * until
 * while

Lua est un langage sensible à la casse: est un mot-clé réservé mais  et   sont deux noms différents et valides. Par convention les mot-clés commençant pas un tiret bas et suivis de lettres capitales sont réservés comme variables globales internes à Lua (exemple : ).

Les séquences de caractères suivantes correspondent à d'autres mot-clés de Lua :


 * }
 * ]
 * }
 * ]
 * }
 * ]
 * }
 * ]
 * }
 * ]
 * }
 * ]
 * }
 * ]
 * }
 * ]
 * }
 * ]
 * ]
 * ]

Les chaînes constantes (ou textes ) peuvent être délimitées par une paire de guillemets (version anglaise : ") ou une paire d'apostrophe (version anglaise : '), et peuvent contenir les séquences d'échappement (similaires à celles utilisées en C) suivantes : ' ' (bell), ' ' (backspace), ' ' (form feed), ' ' (nouvelle ligne), ' ' (retour en début de ligne), ' ' (tabulation horizontale), ' ' (tabulation verticale), ' ' (barre oblique inversée (backslash)), ' ' (guillement), et ' ' (apostrophe). De plus un backslash suivi par un vrai retour à la ligne correspond à un retour à la ligne dans la chaîne. Un caractère dans une chaîne peut aussi est spécifié par sa valeur numérique en utilisant la séquence d'échappement, avec ddd une séquence comprenant jusqu'à trois chiffres (note : si cette séquence est utilisée directement suivie d'un chiffre il faut obligatoirement fournir trois chiffres). Les chaînes dans Lua peuvent contenir n'importe quelle valeur codée sur un octet, y compris la valeur 0 qui peut être insérée avec ' '.

Les chaînes littérales peuvent aussi être définies en utilisant un format long entouré par des crochets longs. Ouvrir un crochet long de niveau n consiste à ouvrir un crochet suivi de n signes égal suivi d'un autre crochet ouvrant. Un crochet long de niveau 0 correspond donc à  et un crochet long de niveau 1 à  … Un crochet long fermant se définit symétriquement :  est ainsi un crochet long fermant de niveau 4.

Une chaîne longue débute avec un crochet long ouvrant − peu importe le niveau − et se termine par un crochet long fermant de même niveau. Entre cette ouverture et fermeture la chaîne peut être sur plusieurs lignes et Lua n'effectue aucune interprétation des caractères comme les séquences d'échappement. De plus Lua ignore les crochets longs de niveau différent.

Pour aider le programmeur quand un crochet long ouvrant est immédiatement suivi d'un retour à la ligne celui-ci n'est pas intégré à la chaîne. Dans l'exemple qui suit et qui utilise le système ASCII (' ' vaut 97, le retour à la ligne vaut 10 et le caractère ' ' vaut 49) les cinq chaînes littérales suivantes correspondent au même contenu :

Une constante numérique peut s'écrire avec une partie décimale optionnelle ainsi qu'un exposant décimal optionnel. Lua accepte aussi les entiers hexadécimaux en les préfixant par. Quelques exemples de constantes numériques correctes :


 * 3
 * 3.0
 * 3.1416
 * 314.16e-2
 * 0.31416E1
 * 0xff
 * 0x56

Un commentaire commence par un double tiret (ou « moins ») où que ce soit sauf à l'intérieur d'une chaîne. Si juste après les  il y a un crochet ouvrant long il s'agit d'un commentaire long, qui se continue (éventuellement sur plusieurs lignes) jusqu'au crochet long fermant correspondant. Sinon il s'agit d'un commentaire court qui se termine implicitement à la fin de la ligne.

Types et valeurs
Lua est un langage typé dynamiquement. Cela signifie que les variables n'ont pas de type, seules les valeurs en ont. Il n'y a aucune définition de type dans ce langage, chaque valeur transportant son propre type.

Toutes les valeurs dans Lua sont des first-class values (traduction correcte ?). Cela signifie que toute valeur peut être stockée dans une variable, passée à des fonctions ou retournée comme résultat.

Il y a huit types de base en Lua : nil, boolean , number , string, function , userdata , thread, et table. nil est le type de la valeur nil, dont le rôle est d'être différent de toutes les autres valeurs possibles, et qui représente en général l'absence de valeur. boolean est le type des valeurs vraies ou fausses (false et true). Les valeurs nil et false sont toutes les deux considérées comme fausses pour les tests, toute autre valeur étant considérée comme vraie. number correspond aux nombres réels (double-précision). (Il est facile de créer un interpréteur Lua utilisant d'autres représentations internes pour les nombres, voir ) string représente les tableaux de caractères (ou chaînes de caractères, ou chaînes, ou textes).

Les chaînes peuvent contenir n'importe quel caractère codé sur 8 bits (un octet) y compris la valeur zéro (' ') (voir &sect;2.1).

Lua peut appeler (et manipuler) des fonctions écrites en Lua et en C (voir &sect;2.5.8).

Le type userdata permet de construire des structures de données C arbitraires et de les stocker dans des variables Lua. Ce type correspond à un bloc brut de mémoire et Lua ne possède aucune opération pré-définie qui s'y applique, à par l'assignement et la comparaison d'égalité. Toutefois en utilisant les metatables le programmeur peut définir les opérations applicables aux valeurs userdata (voir &sect;2.8). Ces valeurs userdata ne peuvent être créées ni modifiées depuis Lua mais seulement à travers l'API C. Ceci est une garantie de l'intégrité des données fournies par le programme hôte.

Le type thread représente des threads d'exécution indépendants et est utilisé pour implémenter les co-routines (qui ne sont actuellement pas supportées dans MediaWiki). Ne confondez-pas les threads de Lua avec les threads des systèmes d'exploitation. Lua supporte les co-routines sur tous les systèmes, y compris ceux n'ayant pas de support pour les threads.

Le type table implémente des tableaux associatifs c'est-à-dire des tableaux qui peuvent être indexés avec n'importe quelle valeur Lua (à part nil). Les tables peuvent être hétérogènes et donc contenir des valeurs de types différents (à part nil). Les tables sont le seul mécanisme de structuration de l'information dans Lua, elles peuvent servir pour représenter des tableaux classiques, des tables de symboles, des graphes, des arbres… Pour représenter des enregistrements Lua utilise le champs comme index. Le langage support cette représentation en fournissant  qui est un raccourci syntaxique pour. Il existe de nombreuses méthodes pour créer des tables en Lua (voir &sect;2.5.7).

Comme pour les indices les valeurs des éléments d'une table peuvent être de n'importe quel type (sauf nil). En particulier − puisque les fonctions sont des first-class values, les champs d'une table peuvent contenir des fonctions. Il est ainsi possible d'avoir des méthodes dans les tables (voir &sect;2.5.9).

Les tables, les fonctions, les threads et les userdata sont des objets : les variables ne contiennent pas ces valeurs mais uniquement des références vers ces valeurs. Les passer à des fonctions ou les retourner n'implique aucune forme de copie.

La fonction  retourne une chaîne décrivant le type de la valeur passée en paramètre.

Coercition
Lua effectue des conversions automatiques entre les chaînes et les nombres à l'exécution. Toute opération arithmétique sur une chaîne tentera de convertir cette chaîne en nombre. De la même façon toute action qui attend une chaîne et qui reçoit un nombre convertira ce nombre en chaîne, dans un format « raisonnable ». Pour un contrôle complet sur comment les nombres sont convertis en chaînes utilisez la fonction  de la librairie string (voir  ).

Variables
Les variables sont des emplacements pour stocker des valeurs.

Il y a trois types de variables en Lua : les variables globales, les variables locales, et les champs de tables.

Un nom simple peut faire référence à une variable globale ou locale (ou à un paramètre formel de fonction, qui est une forme de variable locale) :

var ::= Name

Name dénote un identifiant, comme défini dans &sect;2.1.

Toute variable est supposée globale à moins qu'elle soit explicitement déclarée locale (voir &sect;2.4.7). Les variables locales ont une portée lexicale : elles peuvent être librement accédées par les fonctions définies à l'intérieur de leur portée (voir &sect;2.6).

Avant la première affectation d'une valeur à une variable celle-ci contient la valeur nil.

Les crochets sont utilisés pour indexer une table :

var ::= prefixexp `[&acute; exp `]&acute;

L'accès aux variables globales et aux champs des tables peut être modifié via les méta-tables. L'accès à la variable indexée  est équivalent à un appel à. (voir &sect;2.8 pour une description complête de la fonction . Cette fonction n'est pas définie ni utilisable en Lua, elle est décrite ici uniquement à des fins d'illustration du propos.)

La syntaxe  est une facilité syntaxique pour   :

var ::= prefixexp `.&acute; Name

Toutes les variables globales sont en fait des champs d'une table Lua, appelée table d'environnement ou plus simplement environnement.

Chaque fonction a sa propre référence d'un environnement, donc toute les variables globales dans cette fonction font référence à cette table d'environnement. Quand une fonction est créée elle hérite de l'environnement de la fonction qui l'a créé.

Un accès à la variable globale  est équivalent à , qui est lui même équivalent à

où   est l'environnement de la fonction en cours d'exécution. (Voir &sect;2.8 pour une description complête de la fonction . Cette fonction n'est pas définie ni utilisable en Lua, elle est décrite ici uniquement à des fins d'illustration du propos.)

En Lua natif il est possible d'accéder et de modifier l'environnement d'une fonction. Toutefois ceci n'est pas possible dans MediaWiki.

Instructions (statements)
Lua supporte des instructions relativement conventionnelles, similaires à celles du Pascal ou du C. Ceci inclue les assignations, les structures de contrôle, les appels de fonction et la déclaration de variables.

Morceaux (Chunks)
L'unité d'exécution en Lua est appelée chunk. Un chunk est simplement une séquence d'instructions qui sont exécutées séquentiellement. Chaqua instruction peut être suivie d'un point-virgule optionnel :

chunk ::= {stat [`;&acute;]}

Il n'existe pas d'instruction vide, ainsi ' ' n'est pas valide.

Lua gère un chunk comme le corps d'une fonction anonyme avec un nombre variable de paramètres (voir &sect;2.5.9). Ainsi les chunks peuvent définir des variables locales, recevoir des paramètres et retourner des valeurs.

Un chunk peut être stocké dans un fichier ou une chaîne dans le programme hôte. Pour exécuter un chunk Lua commence par le pré-compiler en instruction pour sa machine virtuelle, puis exécute le code résultant dans l'interpréteur de cette machine virtuelle.

Les chunks peuvent aussi être pré-compilés sous forme binaire (voir le programme  pour plus de détails). Les programmes sous forme de sources ou compilés sont interchangeables, Lua détectant automatiquement le type de fichier et le traitant de la façon adaptée.

Les blocs
Un bloc est une liste d'instructions. Syntaxiquement un bloc est identique à un chunk :

block ::= chunk

Un bloc peut être délimité explicitement pour en faire une instruction unique (appelés blocs explicites :

stat ::= do block end

Les blocs explicites sont utiles pour contrôler la portée des variables. Les blocs explicites sont également parfois utilisés pour ajouter un return ou un break au milieu d'un autre bloc (voir &sect;2.4.4).

Affectation
Lua autorique des affectations multiples. C'est pourquoi la syntaxe d'une affectation comporte une liste de variables dans sa partie gauche et une liste d'expressions dans sa partie droite. Les éléments de chaque liste sont séparés par des virgules :

stat ::= varlist `=&acute; explist varlist ::= var {`,&acute; var} explist ::= exp {`,&acute; exp}

Les expressions sont détaillées dans &sect;2.5.

Avant l'affectation la liste des valeurs est ajustée à la longueur de la liste des variables. S'il y a plus de valeurs que nécessaire les valeurs en trop sont ignorées. S'il y a moins de valeurs que de variables la liste des valeurs est étendue autant que nécessaire en complétant par des nil. Si la liste des expressions se termine par un appel de fonction alors toutes les valeurs retournées par cet appel sont insérées dans la liste des valeurs, avant que l'ajustement n'ait lieu (sauf si l'appel est entouré de parenthèses, voir &sect;2.5).

L'affectaction commence d'abord par évaluer toutes les expressions et seulement après les affectations sont effectuées. Ainsi le code

met la valeur 20 dans  car   dans   est évalué (à la valeur 3) avant l'assignement qui fixe la valeur de   à 4. De même la ligne

échange les valeurs contenues dans  et  , et

permute cycliquement les valeurs de,  , et.

Le sens d'une affectation à des variables globales ou des tableaux peut être changé via les méta-tables. Une affectation à la variable indexée  est équivalent à . (Voir &sect;2.8 pour une description complête de la fonction . Cette fonction n'est pas définie ni utilisable en Lua, elle est décrite ici uniquement à des fins d'illustration du propos.)

Une affectation à une variable globale  est équivalente à l'affectation , qui est à son tour équivalente à

où   est l'environnement de la fonction en cours d'exécution. (La variable  n'est pas définie en Lua. Elle est utilisée afin d'illustrer le propos)

Structures de contrôle
Les structures de contrôle

if, while, et repeat ont leur sens habituel (dans les langages de programmation impératifs) et une syntaxe similaire :

stat ::= while exp do block end stat ::= repeat block until exp stat ::= if exp then block {elseif exp then block} [else block] end

Lua possède également une instruction for en deux versions (voir &sect;2.4.5).

La condition d'une structure de contrôle peut retourner n'importe quelle valeur. Les valeurs false et nil sont considérées comme fausse, toutes les autres valeurs sont vraies (en particulier le nombre 0 et la chaîne vide sont vrais).

Dans la boucle repeat–until le bloc d'instructions ne se termine pas au mot-clé until mais après la condition. Ainsi la condition peut utiliser des variables locales déclarées dans le bloc de la boucle.

Le mot-clé (qui est une instruction) return est utilisé pour retourner une valeur depuis une fonction ou un chunk (qui est une fonction).

Les fonctions et les chunks peuvent retourner plus d'une valeur, ainsi la syntaxe de return est

stat ::= return [explist]

L'instruction break est utilisée pour terminer l'exécution d'une boucle while, repeat, ou for, sautant à l'instruction qui suit la boucle :

stat ::= break

Un break termine la boucle la plus « profonde » dans laquelle il se trouve.

Les instructions return et break peuvent uniquement se trouver en dernière instruction d'un bloc. S'il est réellement nécessaire d'utiliser return ou break au milieu d'un bloc alors un bloc explicite peut être utilisé, comme dans et , car ils sont bien ainsi la dernière instruction de leur bloc.

Instruction for
L'instruction for possède deux formes : l'une numérique et l'autre générique.

La forme numérique répète un bloc d'instruction pendant qu'une variable de contrôle effectue une progression arithmétique. Il a la syntaxe suivante :

stat ::= for Name `=&acute; exp `,&acute; exp [`,&acute; exp] do block end

Le bloc est répété pour name commençant à la valeur de la première exp et jusqu'à ce qu'il dépasse la seconde exp par étapes (ou pas) de la troisième exp. Plus précisément une instruction for de la forme

for v = e1, e2 , e3 do block end

est équivalente au code :

do      local var, limit , step = tonumber( e1 ), tonumber( e2 ), tonumber( e3 ) if not ( var and limit and step ) then error end while ( step &gt; 0 and var &lt;= limit ) or ( step &lt;= 0 and var &gt;= limit ) do        local v = var block var = var + step end end

Notez que :



 Toutes les expressions de contrôle ne sont évaluées qu'une seule fois, avant que la boucle ne démarre. Elles doivent toutes générer un nombre. 

 ,, et   sont des variables invisibles. Leur nom est indiqué ici uniquement pour illustrer le propos. 

 Si la troisième expression (l'étape ou pas) est absente alors la valeur 1 est utilisée. 

 Vous pouvez utiliser break pour quitter une boucle for. 

 La variable de boucle  est locale à la boucle. Vous ne pouvez pas utiliser sa valeur après le for. Si vous avez besoin de cette valeur vous devez l'assigner à une autre variable (non locale) avant que la boucle ne se termine ou que vous la quittiez. 



La forme générique du for utilise des fonctions appelées itérateurs. À chaque itération l'itérateur est appelé pour produire une nouvelle valeur, et la boucle s'arrête quand cette nouvelle valeur vaut nil. La syntaxe du for génétique est la suivante :

stat ::= for namelist in explist do block end namelist ::= Name {`,&acute; Name}

Une instruction for de la forme

for var_1, &middot;&middot;&middot;, var_n in explist do block end

est équivalente au code :

do      local f, s , var = explist while true do        local var_1, &middot;&middot;&middot;, var_n = f ( s , var ) var = var_1 if var == nil then break end block end end

Notez que :



 est évalué une seule fois. Son résultat est une fonction itérateur, un état , et une valeur initiale pour la première variable d'itération. </li>

 ,, et   sont des variables invisibles. Leur noms sont donnés uniquement pour illustrer le propos. </li>

 Vous pouvez utiliser break pour sortir d'une boucle for. </li>

 La variable de boucle  est locale à la fonction. Vous ne pouvez pas utiliser sa valeur après le for. Si vous avez besoin de cette valeur vous devez l'assigner à une autre variable (non locale) avant que la boucle ne se termine ou que vous la quittiez. </li>

</ul>

Appel de fonctions en tant qu'instruction
Pour permettre des effets de bord (side-effects) les appels de fonctions peuvent être exécutés comme des instructions :

stat ::= functioncall

Dans ce cas les valeurs éventuellement retournées sont toutes ignorées. Les appels de fonctions sont détaillées dans &sect;2.5.8.

Déclarations locales
Les variables locales peuvent être déclarées n'importe où à l'intérieur d'un bloc. La déclaration peut inclure un assignement inital :

stat ::= local namelist [`=&acute; explist]

Si présent l'assignement initial à la même sémantique qu'un assignement multiple (voir &sect;2.4.3). Sinon la variable est initialisée à la valeur nil.

Un chunk est aussi un bloc (voir &sect;2.4.1), ainsi dans variables locales peuvent être déclarées en dehors d'un bloc explicite. La portée d'une telle variable s'étend jusqu'à la fin du chunk.

Les règles de visibilité des variables locales sont détaillées dans&sect;2.6.

Expressions
Les expressions de base en Lua sont :

exp ::= prefixexp exp ::= nil | false | true exp ::= Number exp ::= String exp ::= function exp ::= tableconstructor exp ::= `...&acute; exp ::= exp binop exp exp ::= unop exp prefixexp ::= var | functioncall | `(&acute; exp `)&acute;

Les nombres et chaînes littérales sont détaillées dans &sect;2.1, les variables dans &sect;2.3, les fonctions dans &sect;2.5.9, les appels de fonctions dans &sect;2.5.8, les constructeurs de tables dans &sect;2.5.7. Les arguments variables (varargs) notés par trois points (' ') ne peuvent être utilisés que directement à l'intérieur d'une fonction à arguments variables. Ils sont détaillés dans &sect;2.5.9.

Les opérateurs binaires comprennent les opérateurs arithmétiques (voir &sect;2.5.1), les opérateurs de relation (voir &sect;2.5.2), les opérateurs logiques (voir &sect;2.5.3), et l'opérateur de concaténation (voir &sect;2.5.4). Les opérateurs unaires comprennent le moins unaire (voir &sect;2.5.1), le not (négation) unaire (voir &sect;2.5.3), et l' opérateur de longueur unaire (length operator) (voir &sect;2.5.5).

Les appels de fonctions et les arguments variables peuvent retourner des valeurs multiples. Si une expression est utilisée comme instruction (seulement possible avec les appels de fonctions (see &sect;2.4.6)) alors ce qu'elle retourne est ajusté à une liste de zéro éléments, donc toutes les valeurs retournées sont ignorées. Si une expression est utilisée comme dernier (ou seul) élément d'une liste d'expression alors aucun ajustement n'est effectué (sauf si l'appel est entouré de parenthèses). Dans tous les autres contextes Lua ajuste la liste de résultats à un élément, ignorant toutes les valeurs sauf la première.

Quelques exemples :

Toute expression entourée de parenthèses retournera toujours seulement une valeur. Ainsi correspond toujours à une seule valeur, même si  en retourne plusieurs. (la valeur de  est la première retournée par  ou nil si   ne retourne aucune valeur.)

Opérateurs arithmétiques
Lua supporte les opérateurs arithmétiques habituels : le  (addition), (soustraction),  (multiplication), (division),  (modulo), et   (exponentiation), et le  unaire (négation). Les les opérandes sont des nombres ou des chaînes qui peuvent être converties en nombres (voir &sect;2.2.1), alors toutes les opération opèrent de façon classique.

L'exponentiation fonction pour tous les exposants. Par exemple  calcule l'inverse de la racine carrée de. Le modulo est définit comme

That is, it is the remainder of a division that rounds the quotient towards minus infinity.

Opérateurs relationnels
Les opérateurs relationnels en Lua sont

<div style="column-width: 10em; -moz-column-width: 10em; -webkit-column-width: 10em; font-family: monospace">
 * &lt;
 * &gt;
 * &lt;=
 * &gt;=
 * &lt;=
 * &gt;=

Ces opérateurs retournent toujours false ou true (faux ou vrai).

L'égalité compare tout d'abord le type de ses opérandes. Si les types sont différents alors le résultat est false. Sinon les valeurs sont comparées. Les nombres et les chaînes sont comparées de façon classique. Les objets (tables, userdata, threads et fonctions) sont comparés par référence : deux objets sont considérés comme égaux seulement s'ils sont le même objet. Chaque fois que vous créez un nouvel objet celui-ci est différent de tous les objets précédemment créés.

Vous pouvez modifier la façon dont Lua compare les tables et les userdata en utilisant la méta-méthode « eq » (voir &sect;2.8).

Les règles de conversion de &sect;2.2.1 ne s'appliquent pas à l'opérateur d'égalité. Ainsi  est false, et  et   correspondent à des entrées différentes de la table.

L'opérateur  est l'exacte négation de l'opérateur d'égalité.

L'ordre des opérateur fonctionne comme suit. Si les deux arguments sont des nombres ils sont comparés en tant que tel. Sinon si les deux arguments sont des chaînes elles sont comparées en suivant la locale courante. Sinon Lua tente d'appelé les méta-méthodes « lt » ou « le » (pour less-than = « moins-que » et ''less-or-equal-- = « moins-ou-égal ») (voir &sect;2.8). Une comparaison  est convertie en  et   est convertie en.

Opérateurs logiques
Les opérateurs logiques en Lua sont and, or, et not. Comme pour les structures de contrôle (voir &sect;2.4.4) tous les opérateurs logiques considèrent false et nil comme faux et toutes les autres valeurs comme vraies.

L'opérateur de négation not retourne toujours false ou true. L'opérateur de conjonction and retourne son premier argument si celui-ci est faux (false ou nil) et sinon il retourne son deuxième argument. L'opérateur de disjonction or retourne son premier argument si celui-ci est vrai (différent de false ou nil) et sinon il retourne son deuxième argument. Ces deux opérateurs (and et or) utilisent des raccourcis d'évaluation : le second argument n'est évalué que si c'est nécessaire.

Quelques exemples :

10 or 20           --&gt; 10 10 or error      --&gt; 10 nil or "a"         --&gt; "a" nil and 10         --&gt; nil false and error  --&gt; false false and nil      --&gt; false false or nil       --&gt; nil 10 and 20          --&gt; 20

(ici  indique le résultat de l'expression qui précède)

Concaténation
L'opérateur de concaténation de chaîne en Lua s'eprime avec deux points (' '). Si les deux opérandes sont des chaînes ou des nombres alrs ils sont convertis en chaîne en suivant les règles détaillées dans &sect;2.2.1. Sinon la méta-méthode « concat » est appelée (voir &sect;2.8).

Opérateur de longueur
L'opérateur de longueur s'exprime par l'opérateur unaire. La longueur d'une chaîne correspond à son nombre d'octets (la longueur d'une chaîne quand ses caractères sont codés sur un seul octet). Note : cette longueur ne correspond pas au nombre de caractères si la chaîne contient des caractères UTF-8.

La longueur d'une table  est définit comme étant tout index entier tel que  ne contienne pas nil et que   contienne nil. De plus si  vaut nil,   peut valoir zéro. Pour un tableau régulier, sans valeurs nil entre 1 et un  donné, sa longueur est exactement  , l'index de la dernière valeur. Si le tableau contient des « trous » (des valeurs nil entre des valeurs autres) alors  sera l'indice qui précède la valeur nil dans ce tableau (en pratique cela signifie que pour l'opérateur de longueur la valeur nil désigne la fin du tableau).

Précédence
La précédente entre les opérateurs en Lua suit l'ordre donné dans la table suivante, de la priorité la plus basse à la plus haute :

or    and &lt;    &gt;     &lt;=    &gt;=    ~=    == ..    +     -     *     /     %     not   #     - (unary) ^

Vous pouvez utiliser les parenthèses pour modifier la précédence d'une expression. La concaténation (' ') et l'exponentiation (' ') sont associatifs à droite. Tous les autres opérateurs binaires sont associatifs à gauche.

Constructeur de tables
Les constructeurs de tables sont des expressions qui créent des tables. Chaque fois qu'un constructeur est évalué une nouvelle table est créée. Un constructeur peut être utilisé pour créer une table vide or une table avec certains champs initialisés. La syntaxe générale des constructeurs est

tableconstructor ::= `{&acute; [fieldlist] `}&acute; fieldlist ::= field {fieldsep field} [fieldsep] field ::= `[&acute; exp `]&acute; `=&acute; exp | Name `=&acute; exp | exp fieldsep ::= `,&acute; | `;&acute;

Chaque champs de la forme  ajoute à la nouvelle table une entrée avec pour clé  et pour valeur. Un champs de la forme  est équivalent à . Enfin, les champs de la forme  sont équivalents à , où  correspond à des nombres entiers consécutifs en commençant par 1. Les champs utilisant les autres formats n'affectent pas le comptage de. Par exemple,

est équivalent à

Si le dernier champs dans la liste a la forme et que cette expression est un appel de fonction ou des arguments variables alors toutes les valeurs retournées par cette expression sont insérées dans la liste consécutivement (voir &sect;2.5.8). Pour éviter cela mettez l'appel de fonction ou les paramètres variables entre parenthèse (voir &sect;2.5).

Le dernier élément d'une liste de champs peut avoir un séparateur final optionnel (sans effet), afin de simplifier − par exemple − les cas de code généré par programme.

Appel de fonctions
Un appel de fonction en Lua a la syntaxe suivante :

functioncall ::= prefixexp args

Dans un appel de fonction prefixexp et args sont évalués en premier. Si la valeur de prefixexp est de type function alors cette fonction est appelée avec ses paramètres. Sinon la méta-méthode « call » de prefixexp est appelée, avec prefixexp comme premier paramètre suivi des paramètres de l'appel d'origine (voir &sect;2.8).

La forme

functioncall ::= prefixexp `:&acute; Name args

peut être utilisé pour appeler une « méthode ». L'appel est une facilité syntaxique pour , hormis que  n'est évalué qu'une seule fois.

Les paramètres (ou arguments) ont la syntaxe suivante :

args ::= `(&acute; [explist] `)&acute; args ::= tableconstructor args ::= String

Tous les paramètres sont évalués avant l'appel. Un appel de la forme  est une facilité syntaxique pour, c'est-à-dire que la liste des paramètres est une seule nouvelle table. Un appel de la forme (ou  ou  ) est une facilité syntaxique pour, c'est-à-dire que la liste des paramètres est une seule chaîne littérale.

Il y a une exception à la liberté de syntaxe de Lua : vous ne pouvez pas mettre de retour à la ligne avec le ' ' pour un appel de fonction. Cette restriction permet d'éviter certaines ambiguïtés dans le langage. Si vous écrivez

Lua pourrait voir cela comme une seule instruction :. Donc si vous voulez deux instructions vous aurez à introduire un point-virgule entre elles. Si vous voulez réellement appeler, vous devez enlever le retour à la ligne avant.

Un appel de la forme  functioncall est appelé un appel de queue.

Lua implémente des appels de queue propres (ou récursions de queue propres ) : dans un appel de queue la fonction appelée réutilise la pile de la fonction appelante. Ainsi il n'y a pas de limite au nombre d'appels de ce genre qu'un programme peut exécuter. Toutefois un appel de queue écrase toutes les informations de debug à propos de la fonction appelante. Notez qu'un appel de queue ne se produit qu'avec une syntaxe particulière, où le return a un seul appel de fonction comme paramètre : ceci fait que la fonction considérée retourne exactement ce que retourne la fonction appelée. Ainsi aucun des exemples ci-dessous ne sont des appels de queue :

Définition de fonctions
La syntaxe d'une définition de fonction est

function ::= function funcbody funcbody ::= `(&acute; [parlist] `)&acute; block end

Les facilités syntaxiques existent pour simplifier la définition de fonctions :

stat ::= function funcname funcbody stat ::= local function Name funcbody funcname ::= Name {`.&acute; Name} [`:&acute; Name]

L'instruction

function f body end

se traduit par

f = function body end

L'instruction

function t.a.b.c.f body end

se traduit par

t.a.b.c.f = function body end

L'instruction

local function f body end

se traduit par

local f; f = function body end

et non par

local f = function body end

(Ceci ne fait de différence que lorsque le corps de la fonction contient des références vers .)

Une définition de fonction est une expression exécutable, qui a le type function. Quand Lua pré-compile un chunk tous les corps de fonctions qu'il contient sont pré-compilées également. Ainsi quand Lua exécute la définition de fonction la fonction est instanciée (or fermée ). Cette instance de fonction (ou fermeture ) est la valeur finale de l'expression. Différentes instances d'une même fonction peuvent faire référence à des variables locales externes différentes et avoir des enviromments différents.

Les paramètres sont traités comme des variables locales qui sont instanciées avec les valeurs des arguments à l'appel :

parlist ::= namelist [`,&acute; `...&acute;] | `...&acute;

Quand une fonction est appelée sa liste d'arguments est ajustée à la longueur de la liste des paramètres, sauf si la fonction est variadic (avec un nombre non spécifié de paramètres) ou une fonction à paramètres variables ; qui est indiqué par trois points (' ') à la fin de sa liste de paramètres. Une fonction à paramètres variables n'ajuste pas la liste d'argument. Elle récupère tous les arguments additionnels et les passe à la fonction via une expression de paramètres variables, qui se note également par trois points. La valeur de cette expression est une liste contenant les paramètres additionnels, similaire au comportement d'une fonction retournant plusieurs résultats. Si une expression de paramètres variables est utilisé à l'intérieur d'une autre expression ou au milieu d'une liste d'expressions alors son contenu est ajusté à un élément. Si l'expression est utilisée en dernier élément d'une liste d'expression aucun ajustement n'est effectué (sauf si la dernière expression est entourée de parenthèses).

Comme exemple, considérez les définitions suivantes :

Alors nous avons la mise en correspondance suivante entre les arguments et les paramètres (ou expression de paramètres variables) :

CALL           PARAMETERS f(3)            a=3, b=nil f(3, 4)         a=3, b=4 f(3, 4, 5)      a=3, b=4 f(r, 10)      a=1, b=10 f(r)          a=1, b=2 g(3)            a=3, b=nil, ... --&gt; (nothing) g(3, 4)         a=3, b=4,   ... --&gt; (nothing) g(3, 4, 5, 8)   a=3, b=4,   ... --&gt; 5  8 g(5, r)       a=5, b=1,   ... --&gt; 2  3

Les résultats sont retounés en utilisant return (voir &sect;2.4.4). Il l'exécution atteint la fin d'une fonction sans rencontrer de return la fonction se termine sans retourner de résultat.

La syntaxe des deux-points est utilisée pour définir une méthode, c'est-à-dire des fonctions qui ont un paramètre implicite additionnel appelé. Ainsi la déclaration

function t.a.b.c:f ( params ) body end

est une facilité syntaxique pour

t.a.b.c.f = function (self, params ) body end

Règles de visibilité
Lua est un langage à portée lexicale. La portée des variables commence à la première instruction qui suit leur déclaration et se termine à la fin du dernier bloc qui inclue cette déclaration. Voez l'exemple suivant :

Notez que dans une déclaration telle que, le nouveau   déclaré est pas encore accessible, ainsi le second  (en partie droite) fait référence à la variable à l'extérieur du bloc (ici la variable globale).

De part les règles de visibilité lexicales une variable local peut être librement accédée par les fonctions définies à l'intérieur de leur portée. Une variable local utilisée dans une fonction définie à l'intérieur de sa portée est appelée une upvalue ou variable locale externe, au sein de cette fonction.

Notez que chaque exécution de l'instruction local une nouvelle variable locale est créée.

Par exemple :

La boucle crée dix fermetures (c'est-à-dire dix instances d'une fonction anonyme). Chacune de ces fermetures utilise une variable  différente, mais elles partagent toutes le même.

Gestion des erreurs
Comme Lua est un embedded extension language (langage à extension intégrées ?), toutes les actions en Lua débutent par du code C dans le programme hôte qui va appeler une fonction de la librairie Lua. Si une erreur se produit durant la compilation ou l'exécution le contrôle revient à la fonction C qui prend les mesures adéquates (comme d'afficher un message d'erreur).

Il est possible de générer explicitement une erreur en appelant la fonction . Si vous avez besoin d'intercepter les erreurs en Lua vous pouvez utiliser la fonction.

Metatables
Chaque valeur en Lua peut avoir une <metatable (méta-table). Cette méta-table est une table Lua ordinaire qui définit le comportement de la valeur d'origine pour certaines opérations particulières. Vous pouvez modifier de nombreux aspects du comportement des opérateurs sur une valeur en modifiant certains champs spécifiques dans sa méta-table. Par exemple quand une valeur non numérique est l'opérande d'une addition Lua regarde s'il existe une fonction dans le champs  de cette méta-table. Si c'est le cas Lua appelle cette fonction pour effectuer cette addition.

Nous appelons les clés d'une méta-tables des évènements et leurs valeurs des méta-méthodes. Dans l'exemple précédent l'évenement est  et la méta-métode est la fonction qui effectue l'addition.

Vous pouvez accéder à la méta-table de n'importe quelle valeur en utilisant la fonction.

Vous pouvez remplacer la méta-table de tables en utilisant la fonction.

Vous ne pouvez pas changer la méta-table des autres types en Lua (à part via la librairie de debug), vous devez passer par l'API C pour cela.

Les tables et les userdata possèdent des méta-tables individuelles (même si plusieurs tables et userdata peuvent partager leur méta-table). Les valeurs de tous les autres types partagent la même et unique méta-table par type : il existe donc une seul méta-table pour les nombre, une seule pour les chaînes…

Une méta-table contrôle la façon dont un objet se compote dans les opérations arithmétiques, les comparaisons, la concaténation, l'opération de longueur, et l'indexation. Une méta-table définit également une fonction à appeler lorsqu'un userdata doit être nettoyé de la mémoire (garbage collection). Pour chacune de ces opérations Lua associe une clé spécifique appelée évenement. Quand Lua effectue l'une de ces opérations sur une valeur il vérifie si cette valeur a une méta-table associée et possédant un évenement correspondant. Si c'est le cas la valeur associée avec cette clé (la méta-méthode) contrôle comment Lua effectue l'opération.

Les méta-tables contrôlent les opérations listées ci-dessous. Chaque opération est identifiée par son nom. La clé de chaque opération est une chaîne préfixée par deux tirets bas (underscore) ' '. Par exemple pour l'opération "addition" ("add") la clé associée est la chaîne. La sémantique de ces opérations est plus simple à expliquer par une fonction Lua décrivant comment l'interpréteur exécute l'opération.

Le code ci-dessous est strictement illustratif : l'interpréteur utilise du code interne pour réaliser cela ce qui est nettement plus efficace. Toutes les fonctions utilisées dans ces descriptions (, , …) sont décrites dans &sect;3.1. En particulier pour retrouver la méta-méthode d'un objet donné nous utilisons l'expression

Ceci doit se lire comme

C'est-à-dire que l'accès à une méta-méthode l'invoque pas d'autres méta-méthodes, et l'accès à des objets sans méta-tables ne provoque pas d'erreur (cela retourne simplement nil).



"add": L'opération.

La fonction  définit comment Lua choisi un gestionnaire (handler) pour une opération binaire. En premier lieu Lua teste le premier opérande. Si son type ne définit pas de gestionnaire pour l'opération alors Lua teste son second opérand.

En utilisant cette fonction le comportement de  est

</li>

"sub": l'opération  (soustraction).

Comportement similaire à l'addition. </li>

"mul": l'opération  (multiplication).

Comportement similaire à l'addition. </li>

"div": l'opération  (division).

Comportement similaire à l'addition. </li>

"mod": l'opération  (modulo).

Comportement similaire à l'addition, avec l'opération comme comportement d'origine. </li>

"pow": l'opération  (exponentiation).

Comportement similaire à l'addition, avec l'opération (de la librairie mathématique du C) comme comportement d'origine. </li>

"unm": L'opération  unaire (négation).

</li>

"concat": l'opération  (concaténation).

</li>

"len": l'opération  (longueur).

Voir &sect;2.5.5 pour plus de détails sur la longueur d'une table. </li>

"eq": L'opération  (égalité).

La fonction  définit comment Lua sélectionne la méta-méthode pour les opérateurs de comparaison. Une méta-méthode est choisie uniquement si les deux objets à comparer sont de même type et qu'ils ont la même méta-méthode pour l'opération concernée.

L'évenement "eq" est définit comme suit :

est équivalent à. </li>

"lt": l'opération  (inférieur).

est équivalent à. </li>

<li>"le": l'opération  (inférieur ou égal).

est équivalent à. Notez qu'en l'absence de la méta-méthode "le" (plus-petit-ou-égal) Lua tente "lt" (plus-petit-que) en supposant que  est équivalent à. </li>

<li>"index": L'accès indexé.

</li>

<li>"newindex": L'assignement indexé.

</li>

<li>"call": appelé quand Lua accède une valeur.

</li>

</ul>

Nettoyage de la mémoire (garbage collection)
'Pas traduit pour le moment, ou seulement partiellement. C'est intéressant mais sans intérêt pratique − il me semble − dans le cadre des modules Scribunto et de mediaWiki.'

Lua gère automatiquement la mémoire. Cela signifie que vous n'avez pas à vous préoccuper d'allouer de la mémoire pour de nouveau objets ni de libérer cette mémoire quand un objet ne sert plus. Lua effectue cette gestion en faisant tourner un garbage collector (un « éboueur ») de temps en temps pour collecter les « objets morts ».

(that is, objects that are no longer accessible from Lua). All memory used by Lua is subject to automatic management: tables, userdata, functions, threads, strings, etc.

Lua implements an incremental mark-and-sweep collector. It uses two numbers to control its garbage-collection cycles: the garbage-collector pause and the garbage-collector step multiplier. Both use percentage points as units (so that a value of 100 means an internal value of 1).

The garbage-collector pause controls how long the collector waits before starting a new cycle. Larger values make the collector less aggressive. Values smaller than 100 mean the collector will not wait to start a new cycle. A value of 200 means that the collector waits for the total memory in use to double before starting a new cycle.

The step multiplier controls the relative speed of the collector relative to memory allocation. Larger values make the collector more aggressive but also increase the size of each incremental step. Values smaller than 100 make the collector too slow and can result in the collector never finishing a cycle. The default, 200, means that the collector runs at "twice" the speed of memory allocation.

You can change these numbers by calling. With this function you can also control the collector directly (e.g., stop and restart it).

Garbage-Collection Metamethods
Using the C API, you can set garbage-collector metamethods for userdata (see &sect;2.8). These metamethods are also called finalizers. Finalizers allow you to coordinate Lua's garbage collection with external resource management (such as closing files, network or database connections, or freeing your own memory).

Garbage userdata with a field  in their metatables are not collected immediately by the garbage collector. Instead, Lua puts them in a list. After the collection, Lua does the equivalent of the following function for each userdata in that list:

At the end of each garbage-collection cycle, the finalizers for userdata are called in reverse order of their creation, among those collected in that cycle. That is, the first finalizer to be called is the one associated with the userdata created last in the program. The userdata itself is freed only in the next garbage-collection cycle.

Tables « faibles » (weak tables)
Une table faible est une table dont les éléments sont des références faibles. Une référence faible est ignorée par le garbage collector. En d'autres termes si la seule référence vers un objet est une référence faible le garbage collector va collecter (donc libérer) cet objet.

A weak table can have weak keys, weak values, or both. A table with weak keys allows the collection of its keys, but prevents the collection of its values. A table with both weak keys and weak values allows the collection of both keys and values. In any case, if either the key or the value is collected, the whole pair is removed from the table. The weakness of a table is controlled by the field of its metatable. If the  field is a string containing the character ' ', the keys in the table are weak. If  contains ' ', the values in the table are weak.

After you use a table as a metatable, you should not change the value of its  field. Otherwise, the weak behavior of the tables controlled by this metatable is undefined.

Librairies standards
La librairie standard Lua fournie divers fonctions utiles qui sont directement implémentées via l'API C. Certaines de ces fonctions fournissent essentiellement des services au niveau du langage (exemples,  et  ). D'autres fournissent des services « externes » (par exemple les entrées/sorties). D'autres enfin pourraient être implémentées en Lua mais sont particulièrement utiles ou ont des contraintes de performance nécessitant une implémentation en C (exemples, ).

Toutes les librairies sont implémentées en utilisant l'API C officielle et sont fournies dans des modules séparés. À l'heure actuelle Lua comprend les librairies standards suivantes :

<ul>

<li>la librairie de base, qui inclue la sous-librairie de gestion des co-routines ;</li>

<li>la librairie de « packages » (rôle ?) ;</li>

<li>les manipulations de chaînes ;</li>

<li>les manipulations de tables ;</li>

<li>les fonctions mathématiques (sin, log, …) ;</li>

<li>les entrées et sorties ;</li>

<li>les éléments relatifs au système d'exploitation ;</li>

<li>les outils de debug.</li>

</ul>

À l'exception des librairies de base et de packages toutes les librairies fournissent leurs fonctions et champs via une table globale ou via des méthodes de leurs objets.

Fonctions basiques
La librairie de base fournie certaines fonctions de bases à Lua. Si vous n'inculez pas cette librairie dans votre application vous devez vérifier précisément vos besoins car vous aurez sans doute à fournir vos propres implémentations pour certaines fonctionnalités.

Génère une erreur quand la valeur de son paramètre  est fausse (nil ou false), sinon retourne tous ses paramètres. est un message d'erreur. S'il est absent le message par défaut est « assertion failed! »

Cette fonction est une interface générique avec le garbage collector (le nettoyeur de mémoire). Il applique diverses fonctions selon son premier paramètre, :

<ul>

<li>"collect": effectue un garbage-collection (nettoyage de la mémoire) complet. C'est le comportement par défaut. </li>

<li>"stop": arrête le garbage collector. </li>

<li>"restart": redémarre le garbage collector. </li>

<li>"count": retourne la quantité totale de mémoire utilisée par Lua (en kilo-octets). </li>

<li>"step": effectue une étape de garbage-collection (nettoyage de la mémoire). La « taille » de l'étape est contrôlée par (une grande valeur signifie plus d'étapes) sans que le sens de cette valeur soit spécifié. Si vous désirez contrôler la taille des étapes vous devez déterminer expérimentalement la valeur de. Retourne true si l'étape termine un cycle de nettoyage. </li>

<li>"setpause": utilise  comme nouvelle valeur pour la pause du nettoyeur (voir &sect;2.10). Returns the previous value for pause. </li>

<li>"setstepmul": utilise  comme nouvelle valeur pour le multiplicateur d'étape du nettoyeur (voir &sect;2.10). Returns the previous value for step. </li>

</ul>

Termine la dernière fonction protégée appelée et retourne  comme message d'erreur. Cette fonction ne retourne jamais.

En général  ajoute des informations sur la position de l'erreur au début de son message. Le paramètre  précise comment obtenir cette information de position. La valeur 1 (valeur par défaut) indique où la fonction  a été appelée. La valeur 2 indique où la fonction qui a appelé  a été appelée (et ainsi de suite). Fournir la valeur 0 désactive l'ajout de la position de l'erreur dans le message.

Une variable globale (et non une fonction) qui contient l'environnement globale de l'exécution (c'est-à-dire que ). Lua n'utilise pas cette variable, la modifier n'affecte aucun environnement et inversement.

Si  n'a pas de méta-table retourne nil. Sinon si la méta-table de l'objet a un champs, retourne la valeur associée. Sinon retourne la méta-table de l'objet.

Retourne trois valeurs : une fonction itératrice, la table, et 0, ainsi le code

for i,v in ipairs(t) do body end

va itérer à travers toutes les paires, , &middot;&middot;&middot;, jusqu'à la première clé entière absente de la table.

Permet à un programme de traverser toutes les champs d'une table. Son premier paramètre est une table et son second un index dans cette table. retourne l'index suivant de la table et sa valeur associée. Quand appelé avec nil comme second paramètre retourne un index initial et sa valeur associée. Quand appelé avec le dernier index ou avec nil dans une table vide, retourne nil. Si le second paramètre est absent alors il est interprété comme valant nil. En particulier vous pouvez utiliser  pour vérifier si une table est vide.

L'ordre dans lequel les indices sont parcourus n'est pas spécifié, même dans le cas d'indices numériques. (Pour parcourir une table dans un ordre numérique utilisez un for numérique ou la fonction .)

Le comportement de  est indéfini si, durant le parcours, vous assignez une valeur à un champs inexistant de la table. Vous pouvez toutefois modifier un champs existant. En particulier vous pouvez supprimer un champs existant.

Retourne trois valeurs : la fonciton, la table  , et nil, Ainsi le code

for k,v in pairs(t) do body end

va itérer sur chaque paire de clé-valeur de la table.

Voir la fonction  pour les contraintes sur la modification de la table durant son parcours.

Appelle la fonction  avec les paramètres fournis en mode protégé. Ceci signifie que toute erreur se produisant dans  n'est pas propagée. Au lieu de ça  intercepte l'erreur et retourne un code d'erreur. Son premier résultat est le code d'erreur, un booléen, qui est vrai (true) si l'appel à réussi sans erreur. Dans un tel cas  retourne ensuite tous les résultats retournés par   après le premier résultat. En cas d'erreur  retourne false suivi du message d'erreur.

Cette fonction est uniquement accessible si le code est exécuté depuis la console de debug, disponible dans certaines installations de MediaWiki durant l'édition d'un module. Elle est équivalente à mw.log.

Regarde si  est égal à sans invoqué aucune méta-méthode. Retourne un booléen.

Récupère la valeur réelle de , sans invoquer aucune méta-méthode. doit être une table, peut être de n'importe quel type.

Fixe la valeur réelle de  à  , sans invoquer aucune méta-méthode. doit être une table, n'importe quelle valeur différente de nil, et  n'importe quelle valeur Lua.

Cette fonction retourne.

Si  est un nombre, retourne tous les paramètres après le paramètre numéro. Sinon  doit être la chaîne  , et  retourne le nombre total de paramètres additionnels reçus.

Fixe la méta-table de la table indiquée. (Vous ne pouvez pas changer la méta-table des autres types depuis Lua, seulement depuis le C.) Si  est nil, supprime la méta-table de la table indiquée. Si la méta-table originale a un champs, génère une erreur.

Cette fonction retourne.

Tente de convertir son paramètre en nombre. Si le paramètre est déjà un nombre ou une chaîne convertible en nombre, alors  retourne ce nombre, sinon il retourne nil.

Un paramètre optionel permet de préciser la base numérique pour interpréter le nombre. La base peut être n'importe quel entier entre 2 et 36 inclus. Dans les bases supérieurs à 10, la lettre ' ' (minuscule ou majuscule) représente 10, ' ' représente 11, et ainsi de suite, avec ' ' représantant 35. En base 10 (par défaut), le nombre peut avoir une partie décimale, ainsi qu'une partie exposant (voir &sect;2.1). Dans les autres bases seuls les entiers non signés sont acceptés.

Reçoit en paramètre une valeur de n'importe quel type et convertie cette dernière en chaîne en utilisant un format « raisonnable ». Pour un contrôle complet sur la façon dont les nombres sont convertis utilisez.

La la méta-table de  a un champs  , alors  appelle la valeur correspondante avec   en paramètre, et utilise le résultat pour sa valeur de retour.

Retourne le type de son paramètre unique, codé dans une chaîne. Les résultats possibles sont " " (la chaîne "nil", pas la valeur nil), " ", " ", " ", " ", " ", " ", et " ".

Retourne les éléments de la table fournie en premier paramètre. Cette fonction est équivalente à

mis à part que le code ci-dessus ne peut être écrit que pour un nombre fixé d'éléments. Par défaut  vaut 1 et   est la longueur de la liste, comme définit par l'opérateur de longueur (voir &sect;2.5.5).

Une variable globale (pas une fonction) qui contient une chaîne donnant la version de l'interpréteur Lua utilisé. Cette variable contient " " (dans la présente version).

Cette fonction est similaire à , mis à part que vous pouvez fixer un nouveau gestionnaire d'erreur.

appelle la fonction  en mode protégé, en utilisant comme gestionnaire d'erreur. Toute erreur dans  n'est pas propagée. Au lieu de cela  récupère l'erreur puis appelle la fonction avec le message d'erreur d'origine, et retourne son code d'erreur.

Son premier résultat est le code d'erreur (un booléen), qui est vrai (true) si l'appel s'est déroulé sans erreur. Dans ce cas  retourne également tous les résultats de l'appel après le booléen. En cas d'erreur  retourne false suivi du résultat de.

Modules
La librairie packages fournit des fonctionnalités basiques pour charger et construire des modules en Lua. Il exporte la fonction  directement dans l'environnement global. Tout le reste est exporté dans une table.

Charge le module indiqué. La fonction commence par chercher dans la table pour déterminer si  est déjà chargé. Si c'est le cas alors  retourne la valeur stockée dans . Sinon il tente de trouver un chargeur (loader) pour le module.

Pour trouver un chargeur  est guidé par le tableau. En modifiant ce tableau on peut modifier la façon de chercher les modules.

Une table utilisée par  pour contrôler quels modules sont déjà chargés. Quand vous demandez un module  et que n'est pas faux, retourne simplement la valeur correspondante.

Une table utilisée par  pour contrôler comment charger les modules.

Chaque entrée de cette table est une fonction de recherche. Quand  cherche un module il appelle chacune de ces fonctions de recherche dans l'ordre ascendant, avec le nom du module en paramètre (le paramètre passé à ) comme seul paramètre). La fonction peut retourner une autre fonction (le chargeur du module) ou une chaîne expliquant pourquoi le module n'a pas été trouvé (ou nil s'il n'y a pas d'explication). Lua initialise cette table avec quatre fonctions.

La première cherche simplement dans la table.

La seconde appelle MediaWiki. MediaWiki fournit plusieurs modules intégrés, et autorise les modules du wiki local à être chargés en utilisant le préfixe "Module:".

Une table pour stocker les chargeurs (loaders) pour des modules spécifiques (voir ).

Manipulation de chaînes
Cette librairie fournit des fonctions génériques pour la manipulation des chaînes, comme chercher et extraire des sous-chaînes ou de la recherche de motifs (pattern matching). Quand on indexe une chaîne en Lua le premier caractère est à la position 1 (et non 0 comme en C). Les indices peuvent être négatifs et sont alors interprétés comme des index à partir de la fin de la chaîne. Ainsi le dernier caractère d'une chaîne est à la position -1 et ainsi de suite.

La librairie string fournit toutes ses fonctions dans la table. C'est aussi une méta-table pour les chaînes ou le champs  pointe sur la table. Vous pouvez donc utiliser les fonctions sur les chaînes avec une notation orientée objet. Par exemple  peut s'écrire.

La librairie string suppose de les caractères sont encodés sur un octet (pas de support de l'UTF-8).

Retourne le code numérique interne associé au caractère , , &middot;&middot;&middot;,. La valeur par défaut de  est 1, la valeur par défaut de   est.

Reçoit zéro ou plus entiers. Retourne une chaîne de même longueur que le nombre de ses paramètres, dans laquelle chaque caractère a le code numérique interne égal au paramètre correspondant.

Cherche la première correspondance de  dans la chaîne. Si une correspondance est trouvée alors  retourne les indices de  ou cette occurrence commence et se termine, sinon il retourne nil.

Un troisième paramètre optionnel  spécifie l'indice où commencer la recherche, sa valeur par défaut étant 1 et pouvant être négative. Une valeur true comme quatrième (et optionnel) paramètre  désactive la fonctionnalité de pattern matching transformation la fonction en une opération de recherche littérale de sous-chaîne, aucun des caractères de  n'étant considéré comme ayant de sens particulier. Notez que si  est fournit alors   doit l'être aussi.

Si un motif comporte une capture, alors si une correspondance est trouvée le résultat de la capture est également retourné après les deux indices.

Retourne une version formatée de ses paramètres qui peuvent être en nombre variable, en suivant la description donnée dans son premier paramètre (qui doit être une chaîne). La chaîne de format suit les mêmes règles que les fonctions de la famille  en C standard. Les seules différences sont que les options/modificateurs ,,  ,  ,  , et   ne sont pas supportées et qu'il existe une option supplémentaire,. L'option  formate une chaîne de façon à ce qu'elle soit sainement utilisable par l'interpréteur Lua : la chaîne est écrite entre guillements, les guillemets, retours à la ligne, codes zéros et les barres obliques inversées (backslash) dans la chaîne sont échappées correctement. Par exemple l'appel

produira la chaîne :

Les options,  ,  ,  ,  , ,,  ,  ,  ,  , et  attendent toutes un nombre en paramètre, alors que   et   attendent une chaîne.

Cette fonction n'accepte pas les chaînes qui contiennent des codes zéros, à part comme argument pour l'option.

Retourne une fonction d'itération qui, chaque fois qu'elle est appelée, retourne la capture suivante de  dans la chaîne. Si  ne spécifie pas de captures alors la correspondance complête est retournée.

Par exemple la boucle suivante

va itérer sur chaque mot de la chaîne , affichant chaque mot seul sur une ligne. L'exemple suivant récupère toutes les paires  de la chaîne fournie et les range dans une table :

Pour cette fonction, un ' ' au début du motif n'a pas de sens spécial, car cela bloquerait l'itération.

Retourne une copie de dans laquelle toutes (ou les   premières, si le paramètre est indiqué) les occurrences du motif  ont été remplacées par la chaîne de remplacement précisée dans , qui peut être une chaîne, une table ou une fonction. retourne également comme deuxième valeur le nombre total de correspondances trouvées.

Si  est une chaîne alors sa valeur est utilisée pour le remplacement. Le caractère  fonctionne comme un caractère d'échappement : toute séquence dans  de la forme  , avec n un entier entre 1 et 9, signifie la valeur de la em>n -ème sous-chaîne capturée (voir plus bas). La séquence  correspond à la correspondance complête. La séquence  correspond à un simple.

Si  est une table alors cette table est utilisée pour chaque correspondance, en utilisant la première capture comme clé : si le motif ne spécifie pas de capture alors la correspondance complête est utilisée comme clé.

Si  est une fonction alors cette fonction est appelée à chaque fois qu'une correspondance est trouvée, avec toutes les sous-chaînes capturées en paramètres, dans l'ordre. Si le motif ne spécifie pas de capture alors la correspondance complête est passée comme seul paramètre.

Si la valeur retournée par l'accès à la table ou par la fonction est une chaîne ou un nombre alors il est utilisé comme chaîne de remplacement. Sinon si la valeur retournée est nil ou false aucun remplacement n'a lieu (ce qui signifie que la correspondance est conservée dans la chaîne).

Quelques exemples :

Reçoit une chaîne et retourne sa longueur. La chaîne vide  a une longueur de 0. Les zéros sont comptabilisés, donc   a une longueur de 5.

Reçoit une chaîne et retourne une copie de cette chaîne avec tous les caractères en majuscule changés en minuscule. Tous les autres caractères sont laissés tels quels. La définition de ce qui est une majuscule dépend de la locale.

Cherche la première correspondance de  dans la chaîne. Si une correspondance est trouvée  retourne la capture correspondante, sinon nil. Si  ne précise pas de capture alors la chaîne complête est retournée. Un troisième paramètre optionnel  permet de spécifier la position de départ dans la chaîne où commencer la recherche. Sa valeur par défaut est 1 et il peut être négatif.

Retourne une chaîne qui est la concaténation de  copies de la chaîne.

Retourne une chaîne qui est la la chaîne  renversée (début ↔ fin). probablement non fonctionnel avec des caractères UTF-8

Retourne une sous-chaîne de  qui débute à la position et continue jusqu'à la position , et  pouvant être négatifs. Si  est absent il est considéré comme valant -1 (qui signifie la longueur de la chaîne). En particulier  retourne un préfixe de   de longueur  , et  retourne un suffixe de longueur   de.

Reçoit une chaîne et retourne une copie de cette chaîne avec tous les caractères en minuscule changés en majuscule. Tous les autres caractères sont laissés tels quels. La définition de ce qui est une minuscule dépend de la locale.

Classes de caractères :
Une classe de caractères est utilisée pour représenter un ensemble de caractères. Les combinaisons suivantes sont autorisées pour représenter une classe de caractères :

<ul> <li> x : (où x n'est pas un caractère « magique » ) représente le caractère x lui-même.</li> <li> : (un point) représente tous les caractères.</li> <li> : représente toutes les lettres.</li> <li> : représente tous les caractères de contrôle.</li> <li> : représente tous les chiffres.</li> <li> : représente toutes les lettres minuscules.</li> <li> : représente tous les signes de ponctuation.</li> <li> : représente tous les caractères séparateurs (espace…).</li> <li> : représente tous les lettres majuscules.</li> <li> : représente tous les caractères alphanumériques</li> <li> : représente tous les chiffres hexadécimaux.</li> <li> : représente le caractère  (le caractère dont la valeur numérique est 0).</li> <li> : (où x est n'importe quel caractère non-alphanumérique) représente le caractère x. Ceci est la façon habituelle pour utiliser explicitement un caractère « magique » (ayant un sens de contrôle) Tout caractère de ponctuation (même les non « magiques ») peut être précédé d'un ' ' quand il représente lui-même/ </li>

<li> : représente la classe qui est l'union de tous les caractères présents dans set. On peut indiquer un intervalle de caractère en séparant les caractères qui bornent cet intervalle avec un ' '. Toutes les classes x décrites plus haut peuvent aussi être utilisées dans un set. Tous les autres caractères dans un set représentent eux-mêmes. Par exemple  (ou  ) représente tous les caractères alphanumériques et le tiret bas (underscore), représente les chiffres octals, et  représente les chiffres octals plus les lettre minuscules plus le caractère ' '.

Utiliser à la fois les intervalles et les classes a un effet non spécifié. Ainsi des motifs comme  ou   n'ont pas de sens. </li>

<li> : représente le complément de set (voir l'interprétation de set ci-dessus), c'est-à-dire tous les caractères n'appartenant pas à set. </li>

</ul> Pour toutes les classes représentées par une seule lettre (, , …), la lettre majuscule correspondante représente le complément de cette classe. Par exemple  représente tous les caractères qui ne sont pas des séparateurs.

La définition de ce qu'est une lettre, un espace et autres groupes de caractères dépend de la locale. En particulier la classe  peut ne pas être équivalente à la clase.

Élément de motif (pattern item) :
Un élément de motif peut être

<ul>

<li> un singleton d'une classe de caractère, qui correspond à un caractère unique dans la classe ; </li>

<li> un singleton d'une classe de caractère suivi d'un ' ', qui correspond à 0 ou plus répétition de tout caractère de la classe. Cette répétition correpond toujours à la plus longue répétition possible ; </li>

<li> un singleton d'une classe de caractère suivi d'un ' ', qui correspond à 1 ou plus répétition de tout caractère de la classe. Cette répétition correpond toujours à la plus longue répétition possible ; </li>

<li> un singleton d'une classe de caractère suivi d'un ' ', qui correspond également à 0 ou plus répétition de tout caractère de la classe. Contrairement à ' ' cette correspont toujours à la plus petite répétition possible ; </li>

<li> un singleton d'une classe de caractère suivi d'un ' ', qui correspond à 0 ou 1 occurrence d'un caractère de la classe ; </li>

<li> , pour n compris entre 1 et 9. Cet élément correspond à une sous-chaîne valant la n -ème chaîne capturée (voir plus bas) ; </li>

<li> , ou x et y sont deux caractères distincts. Cet élément correspond à la chaîne qui commence par x, se termine par y , et où x et y sont équilibrés (balanced). Cela signifie, en lisant la chaîne de gauche à droite, compter +1 pour chaque x et -1 pour chaque y , le y terminal est le premier y pour lequel le compte atteint 0. Par exemple l'élément  correspond à une expression avec des parenthèses équilibrées. </li>

</ul>

Motif (pattern) :
Un motif est une séquence d'éléments de motif. Un ' ' au début d'un motif correspond au début de la ligne de la chaîne traitée. Un ' ' à la fin du motif correspond à la fin de la ligne de la chaîne traitée. Aux autres positions ' ' et ' ' n'ont pas de sens particulier et représentent le caractère qui les constitue.

Captures :
Un motif (pattern) peut contenir des sous-motifs entourés de parenthèses, qui décrivent des captures. Quand une correspondance réussie, la sous-chaîne de la chaîne qui correspond est stockée ( capturée ) pour usage ultérieur. Les captures sont numérotées dans l'ordre de leur parenthèse de gauche. Par exemple dans le motif , la partie de la chaîne qui concorde avec  est stockée dans la première capture (et a donc le numéro 1). Le caractère qui concorde avec " " est stocké dans la capture numéro 2, et la partie qui concorde avec " " a le numéro 3.

La capture vide  est spéciale et capture la position courante dans la chaîne (un nombre). Par exemple si on applique le motif  sur la chaîne  , il y aura deux captures : 3 et 5.

Un motif ne peut contenir de zéros. Utilisez  à la place.

Manipulation de tables
Cette librairie fournit des fonctions génériques pour la manipulation des tables. Elle fournit toutes ses fonctions dans une table. La plupart de ces fonctions supposent que la table représente un tableau ou une liste. Pour ces fonctions quand on parle de longueur de la table cela signifie le résultat de l'opérateur de longueur.

Étant donné un tableau où tous les éléments sont des chaînes ou des nombres, cette fonction retourne. La valeur par défaut de  est la chaîne vide, et la valeur par défaut de  est 1, et la valeur par défaut de  est la longueur de la table. Si  est plus grand que , la fonction retourne la chaîne vide.

Insert un élément  à la position   dans  , décalant les autres éléments pour faire de la place, si besoin. La valeur par défaut pour  est  , où  est la longueur de la table (voir &sect;2.5.5), ainsi l'appel  insert   à la fin de la table.

Retourne le plus grand index numérique positif de la table indiquée, ou zéro si la table n'a pas d'indice numérique positif. (Pour ce faire cette fonction effectue une traversée linéaire de toute la table.)

Retire de  l'élément à la position  , décalant vers le « bas » les éléments restant pour « boucher le trou », si nécessaire. Retourne la valeur de l'élément retiré. La valeur par défaut de  est  , avec  la longueur de la table, ainsi l'appel  retire le dernier élément de la table.

Trie les éléments de la table dans un ordre donné, sur place (donc en modifiant la table), de  à  , avec  la longueur de la table. Si  est fournit, ce doit être une fonction qui prend deux éléments de la table en paramètre, et qui retourne vrai si le premier est plus petit que le second (ainsi  sera vrai après le tri). Si  n'est pas présent l'opérateur Lua standard   est utilisé à la place.

L'algorithme de tri n'est pas stable ce qui signifie que si des éléments sont considérés comme égaux par la fonction de tri les éléments en question peuvent avoir leur position relative modifiée par le tri.

Fonctions mathématiques
Cette librairie est une interface pour la librairie mathématique C standard. Elle founrit toutes ses fonctions dans une table.

Retourne la valeur absolue de.

Retourne l'arc cosinus de  (en radians).

Retourne l'arc sinus de  (en radians).

Retourne l'arc tangent de  (en radians).

Retourne l'arc tangent de  (en radians), mais utilise le signe des deux paramètres pour trouver le quadrant du résultat. (Il gère aussi correctement le cas où  vaut zéro.)

Retourne le plus petit entier plus grand ou égal à.

Retourne le cosinus de  (exprimé en radians).

Retourne le cosinus hyperbolique de.

Retourne l'angle  (donné en radians) en degrés.

Retourne la valeur ex.

Retourne le plus grand entier plus petit ou égal à.

Retourne le reste de la division de  par qui arrondi le quotient à zéro.

Retourne  et   tels que x = m2e , est un entier et la valeur absolue de  est dans l'interval [0.5, 1) (ou zéro quand  vaut zéro).

La valeur , une valeur plus large ou égale à n'importe quelle valeur numérique.

Retourne m2e ( doit être un entier).

Retourne le logarithme naturel de.

Retourne le logarithme en base 10 de.

Retourne la valeur la plus grande parmi les paramètres reçus.

Retourne la valeur la plus petite parmi les paramètres reçus.

Retourne deux nombres, la partie entière de  et la partie fractionnaire de.

La valeur de pi.

Retourne xy. (Vous pouvez aussi utiliser l'expression  pour calculer cette valeur.)

Retourne l'angle  (donné en degrés) en radians.

Cette fonction est une interface au générateur de nombres pseudo-aléatoires  de ANSI-C. (Aucune garantie n'est donnée sur la distribution statistique des nombres renvoyés.)

Quand la fonction est appelée sans paramètre elle retourne un nombre pseudo-aléatoire réel dans l'intervalle [0,1) . Quand appelé avec un nombre entier,   retourne un nombre pseudo-aléatoire entier dans l'intervalle [1, m] . Quand appelé avec deux entiers   and  ,  retourne un nombre pseudo-aléatoire entier  dans l'intervalle [m, n].

Fixe  comme « graine » pour le générateur de nombres pseudo-aléatoires : une même graine produit la même séquence de nombres.

Retourne le sinus de  (supposé être en radians).

Retourne le sinus hyperbolique de.

Retourne la racine carrée de. (Vous pouvez utiliser également  pour calculer cette valeur.)

Retourne la tangente de  (supposé être en radians).

Retourne la tangente hyperbolique de.

The Debug Library
Cette librairie fournit des fonctionnalité de l'interface de debug pour les programmes en Lua. Vous devez utiliser ces fonction avec attention, ces fonction devant être utilisées exclusivement pour débuguer ou des opérations similaires comme du profiling. Merci de ne pas les utiliser comme des outils de programmation usuels : ils peuvent être très lents. De plus plusieurs de ces fonctions violent certaines règles de fonctionnement de Lua (par exemple le fait qu'une variable locale à une fonction ne puisse être accéder en dehors de celle-ci ou que les méta-tables userdata ne puissent être changées depuis du code Lua) et peuvent donc compromettre la sécurité du code.

Toutes les fonctions de cette librairie sont fournies dans la table. Toutes les fonctions qui opèrent sur un thread ont un premier paramètre optionnel qui est le thread sur lequel travailler. Par défaut le thread courant est utilisé.

Retourne une chaîne contenant l'état de la pile d'appels. Un chaîne de message optionnel  est ajoutée au début du résultat. Un niveau optionnel  indique à quel niveau commencer dans la pile d'appel (la valeur par défaut est 1 et correspond à la fonction qui appelle ).

La table
La table  contient des fonctions utilitaires générales. Elle est toujours disponible.

Retourne une copie indépendante de la valeur spécifiée. Dans Lua les tables sont assignées et passées par référence, ce qui signifie que si vous modifiez une table par l'une de ses références, la table d'origine est également modifiée ainsi que pour toutes les autres références sur cette même table. Par exemple

mw.clone copie récursivement tous les élements de la table, ainsi que toute méta-table attachée à la table ou à ses éléments.

Cloner une table qui contient des références circulaires donne une table avec une référence circulaire équivalente. Par exemple :

Ajoute le message indiqué dans le tampon (buffer) des logs, avec un retour à la ligne à la fin. Dans la console de débugage, tous les messages logués ajoutés au buffer de cette façon durant l'exécution seront affichés à l'écran à la fin de l'exécution.

The object
Quand vous appelez une fonction Lua depuis un wikitexte avec, la fonction Lua reçoit un objet   avec les propriétés et méthodes suivantes :

frame.args est une table avec une méta-méthode "index" qui fournit l'accès aux paramètres passés au. Par exemple si on utilise comme suit :

Alors le code Lua suivant dans Module:Test produira "bar" :

Si des paramètres non nommés sont fournis, alors ils sont accessibles à partir de l'index 1, avec 1 le premier paramètre non nommé (après le nom de la fonction). Par exemple avec le wikitexte :

Et le code Lua :

Ceci retournera "foo".

Comme dans les appels de modèles dans WikiMedia, les paramètres nommés sont nettoyés des espaces avant et après tant pour leur nom que pour leur valeur avant d'être envoyés à Lua, alors que pour les paramètres non nommés aucun nettoyage n'est effectué.

Si un paramètre nommé a un nom qui est une valeur numérique qui entre en conflit avec le numéro assigné à un paramètre non nommé, celui qui est le plus à droite aura la précédence. Par exemple :

Ceci retournera "bar". De façon similaire si deux paramètres nommés ont le même nom alors celui le plus à droite sera vu par Lua.

Pour des raisons de performance frame.args est une méta-table et non une vrai table de paramètres. Les valeurs des paramètres sont récupérés de WikiMedia à la demande. Ceci signifie que vous ne pouvez utiliser  pour parcourir tous les paramètres. À la place utilisez la méthode.

Si des élements interprétés par le pré-processeur sont présents en paramètre (comme l'inclusion d'un modèle) ceux-ci seront évalués avant d'être passés à Lua. Si certains tags spéciaux écrits en notation XML (comme, ,   et  ) sont utilisés dans les paramètres à #invoke, ceux-ci seront convertis en « strip markers » − des chaînes spéciales qui commencent par le caractère ASCII 127 (delete), pour être remplacés par du code HTML après le retour de.

retourne une fonction d'itération. Chaque fois que cette fonction est appelée elle retourne le nom et la valeur d'un paramètre passé à. Par exemple :

Ceci affichera la chaîne "1=x, 2=y, 3=z".

exécute le pré-processeur de wikitexte de MediaWiki sur la chaîne indiquée, en retournant le résultat obtenu. Les modèles et les parser functions dans la chaîne sont évaluées. Certains tags écris en notation XML returning the result. Templates and parser functions in the string will be expanded. Certain special tags written in XML-style notation(comme, ,   et  ) sont utilisés dans les paramètres à #invoke, ceux-ci seront convertis en « strip markers » − des chaînes spéciales qui commencent par le caractère ASCII 127 (delete), pour être remplacés par du code HTML après le retour de.

Notez que les paramètres de, accessible via  , sont déjà pré-processés. Il faut faire attention quand on passe ce genre de paramètres à  car le résultat d'un double pré-précessage peut être malvenu. Par exemple :

va contenir le modèle  évalué (par convention le caractère "|"). Donc passer ce paramètre à un modèle à travers  échouera (ou ne fera pas ce qui est voulu) :

Pour éviter cela, et pour améliorer la performance, frame:expandTemplate devrait être utilisé le moins possible.

résoud un modèle MediaWiki, avec le nom du modèle et ses paramètres comme paramètres de la fonction. Aucun pré-processage n'est appliqué à ces variables avant leur envoi au modèle.

accepte une unique table comme paramètre. La table contient des arguments nommés. Une telle fonction peut être appelée en utilisant la syntaxe spécifique pour les paramètres nommés, avec les parenthèses omises.

Le paramètre  est obligatoire. Il contient une chaîne qui indique le modèle à appeler. Comme dans toute invocation de modèle, s'il n'y a pas de deux-points le préfixe "Modèle:" sera ajouté automatiquement. Sinon le nom du modèle est utilisé tel quel.

Le paramètre  est optionnel. Il contient une table des paramètres à passer au modèle. S'il est omis alors le modèle est appelé sans paramètre.

La syntaxe complête de Lua
Voici la description complête de la syntaxe Lua au format BNF étendue. (Ceci ne décrit la précédence des opérateurs.)

chunk ::= {stat [`;&acute;]} [laststat [`;&acute;]] block ::= chunk stat ::= varlist `=&acute; explist | functioncall | do block end | while exp do block end | repeat block until exp | if exp then block {elseif exp then block} [else block] end | for Name `=&acute; exp `,&acute; exp [`,&acute; exp] do block end | for namelist in explist do block end | function funcname funcbody | local function Name funcbody | local namelist [`=&acute; explist] laststat ::= return [explist] | break funcname ::= Name {`.&acute; Name} [`:&acute; Name] varlist ::= var {`,&acute; var} var ::= Name | prefixexp `[&acute; exp `]&acute; | prefixexp `.&acute; Name namelist ::= Name {`,&acute; Name} explist ::= {exp `,&acute;} exp exp ::= nil | false | true | Number | String | `...&acute; | function | prefixexp | tableconstructor | exp binop exp | unop exp prefixexp ::= var | functioncall | `(&acute; exp `)&acute; functioncall ::= prefixexp args | prefixexp `:&acute; Name args args ::= `(&acute; [explist] `)&acute; | tableconstructor | String function ::= function funcbody funcbody ::= `(&acute; [parlist] `)&acute; block end parlist ::= namelist [`,&acute; `...&acute;] | `...&acute; tableconstructor ::= `{&acute; [fieldlist] `}&acute; fieldlist ::= field {fieldsep field} [fieldsep] field ::= `[&acute; exp `]&acute; `=&acute; exp | Name `=&acute; exp | exp fieldsep ::= `,&acute; | `;&acute; binop ::= `+&acute; | `-&acute; | `*&acute; | `/&acute; | `^&acute; | `%&acute; | `..&acute; | `&lt;&acute; | `&lt;=&acute; | `&gt;&acute; | `&gt;=&acute; | `==&acute; | `~=&acute; | and | or unop ::= `-&acute; | not | `#&acute;