Extension:Scribunto/Lua reference manual/fr

'ATTENTION : documentation en cours de ré-écriture / mise à jour. Certaines parties peuvent manquer, être en doublon ou être incomplêtes.

Débuter
Sur un wiki utilisant Mediawiki et avec 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! ».

Retourner du texte
La fonction du module doit normalement retourner un chaîne. Quelque soit les valeurs retournées, celles-ci passeront par tostring et les résultats seront concaténés sans séparateur. Cette chaîne résultante est incorporée dans le wikitext en replacement du.

À ce moment du traitement de la page les modèles ont déjà été évalués, les parser-functions et les tags ont déjà été traités, et les transformations de pré-sauvegarde déjà effectuées (comme la signature avec ~ ). Ainsi un module ne peut pas utiliser ces fonctionnalités dans sa sortie. Par exemple si un module retourne, la page contiendra "Salut, monde !  ".

D'un autre coté subst est gérée plus tôt dans le traitement d'une page, donc avec  seules les substitutions ultérieurs ne seront pas évaluées. Comme les substitutions vont rester dans le wikitexte elle ne seront traitées que lors de la prochaine sauvegarde. Cette situation devrait être évitée autant que possible.

Documentation d'un module
Scribunto autorise à documenter un module en utilisant une sous-page particulière du module lui-même. Par défaut il s'agit de la sous-page "/doc", et son contenu est inclue en début de module lors de la visualisation. La sous-page de documentation est au format wikitexte (et non Lua bien que dans l'espace Module:). Par exemple la documentation du module "Module:Banane" serait dans la sous-page "Module:Banane/doc".

Ceci peut se configurer en utilisant MediaWiki-namespace messages :
 * scribunto-doc-subpage-name: fixe le nom de la sous-page de documentation. Cette sous-page est traitée comme étant du wikitexte et non du code Lua (et ne doit donc pas être invoquée avec . Sa valeur par défaut est "doc".
 * scribunto-doc-subpage-does-not-exist: Message affiché lorsque la sous-page de documentation n'existe pas. Le nom de la sous-pages est . Sa valeur par défaut est vide.
 * scribunto-doc-subpage-show: Message affiché lorsque la sous-page de documentation existe. Le nom de la sous-pages est . Le comportement par défaut est la transluction de la documentation.
 * scribunto-doc-subpage-header: Entête affiché quand on lit la sous-page de documentation elle-même. Le nom du module dont c'est la page de documentation est . La valeur par défaut est une courte explication en italique.

Notez que les modules ne peuvent être directement catégorisés ni avoir de liens interwiki. Ceci peut se faire dans la documentation à l'intérieur d'une partie, qui ne sera ainsi appliquée qu'au module et non à la sous-page de documentation elle-même.

Entités
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. Mes sont sont sensibles à la casse : "foo", "Foo" et "FOO" sont trois noms distincts.

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

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 :


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

Commentaires
Un commentaire commence par  n'importe où en dehors d'une chaîne. Si  est immédiatement suivi par un crochet long ouvrant le commentaire se termine au crochet long fermant correspondant, sinon le commentaire se termine à la fin de la ligne où a lieu l'ouverture.

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.

Lua possède huit types basiques, toutefois seuls six sont utilisables en Scribunto. La fonction  retourne le type de toute valeur (sous forme de chaîne).

La fonction  convertie une valeur en chaîne. La fonction  convertie une valeur en nombre si possible, et retourne nil sinon. Il n'existe aucune fonction pour convertir explicitement une valeur dans un autre type.

Les nombres sont automatiquement convertis en chaînes quand ils sont utilisés là où une chaîne est attendue (par exemple avec l'opérateur de concaténation). Les chaînes reconnues par  sont automatiquement converties en nombres quand elles sont utilisées avec des opérateurs arithmétiques. Quand un booléen est attendu toute valeur autre que nil et false est vraie.

nil
"Nil" est le type de donnée pour, qui existe pour représenter l'absence de valeur. Nil ne doit pas être utilisé comme clé dans une table et il n'y a pas de différence entre un élément sans valeur (jamais assigné) et un élément avec la valeur nil.

Sa conversion en chaîne est "nil", et sa conversion en booléen est false.

Booléen
Les valeurs possibles d'un booléen sont  et.

La conversion en chaîne d'un booléen est "true" ou "false". Contraitement à d'autres langages les booléens ne peuvent être convertis directement en nombres. Toujours contrairement à d'autres langages seuls false et nil sont faux, le nombre 0 et la chaîne vide étant tout deux considérés comme true.

Chaîne
Les chaînes en Lua sont considérées comme une série d'octets (8 bits), et c'est à l'application de les interpréter dans un encodage particulier.

Les chaînes constantes peuvent être délimitées par des guillemets ou des apostrophes ( ou  ). Comme en JavaScript et contrairement à PHP il n'y a aucune différence entre ces deux notations. Les séquences d'échappement suivantes sont reconnues en Lua : '\a' (bell), '\b' (backspace), '\f' (form feed), '\n' (newline), '\r' (carriage return), '\t' (horizontal tab), '\v' (vertical tab), '\\' (backslash), '\"' (double quote), and '\&#x27;' (single quote). Un vrai retour à la ligne peut aussi être inclue en le précédant d'un backslash ("\"). Les octets peuvent aussi être donnés en utilisant la séquence d'échappement '\ddd', avec ddd une valeur décimale entre 0 et 255. Pour inclure un caractère Unicode avec des séquences d'échappement chaque octet doit être spécifié en suivant les valeurs du caractère (voir UTF-8). Il est nettement plus simple en général de taper directement le caractère Unicade désiré.

Une chaîne constante peut aussi être définie en utilisant des crochets longs. Un crochet long ouvrant est un crochet ouvrant suivi de 0 ou plus signe égal ("=") suivi d'un autre crochet ouvrant. Exemple :,  , ou. Un crochet long ouvrant doit correspondre à un crochet long fermant (ayant le même nombre de signes égal). Exemple :,  , ou. Les chaînes délimitées par des crochets longs sont non interprétées, ce qui veut dire que les séquences d'échappement sont traitées comme du texte normal. Le seul cas particulier est la présence d'un retour à la ligne juste après le crochet long ouvrant, auquel cas ce retour à la ligne n'est pas intégré à la chaîne.

Notez que toute chaîne est considérée comme vraie quand elle est convertie en booléen, contrairement à la plupart des autres langages où la chaîne vide est fausse.

Nombre
Lua n'a qu'un seul type de nombre représenté en interne par des nombres à virgule flottante double précision. Dans ce format les entiers entre -9007199254740992 et 9007199254740992 peuvent être représentés exactement, et les entiers plus petits ou plus grands auront des erreurs d'arrondi.

Les nombres sont notés avec un point comme indicateur décimal et sans séparateur de groupe (exemple :  ). Les nombres peuvent aussi utiliser la notation en exposant sans espace (exemples :,  , ou  ). Les entiers peuvent aussi être donnés en notation hexadécimale en utilisant le préfix  (exemple :  ).

Bien que Lua gère l'infini positif et négatif ainsi que NaN il n'y a pas de constante permettant de les représenter. La constante  est l'entier positif de même que la division par zéro , et   permet de représenter NaN.

Notez que tous les nombres sont considérés comme vrais en cas de conversion en booléen, contrairement a de nombreux autres langages où 0 est considéré comme faux. Lors d'une conversion en chaîne les nombres finis sont représentés sous forme décimale, éventuellement en notation avec exposant. NaN devient "nan" ou "-nan" et les infinis deviennent "inf" ou "-inf".

Table
Les tables en Lua sont des tableaux associatifs, similaires aux tableaux PHP et aux objets JavaScript.

Les tables sont créées avec les accolades. La table vide est. Pour remplir une table à la création une liste d'éléments séparés par des virgules et/ou des point-virgules peut être insérée entre les accolades. Ceci peut prendre plusieurs formes :
 * utilise la (première) valeur de expression1 comme la clé et la (première) valeur de expression2 comme valeur.
 * est équivalent à
 * est à peu près équivalent à, où i est un entier valant 1 au départ et incrémenté de 1 après chaque ajout de cette forme. Si le dernier champs spécifié est une expression valant plusieurs valeurs toutes ces valeurs sont utilisées. Dans tous les autres cas seul la première l'est.

The fields in a table are accessed using bracket notation, e.g. . String keys that are also valid names may also be accessed using dot notation, e.g.   is equivalent to. Calling a function that is a value in the table may use colon notation, e.g., which is equivalent to.

Une séquence est une table avec des valeurs définies (non nil) pour tous les entiers de 1 à N et des valeurs non définies pour tous les entiers supérieurs à N. De nombreuses fonctions Lua ne fonctionne que sur des séquences (ignorant les clés négatives ou celles placées après une valeur nil).

Contrairement à PHP ou JavaScript toute valeur en dehors de nil et de Nan peuvent être utilisées comme clé et aucune conversion n'est effectuée. Les entrées ci-dessous sont toutes valides et distinctes :

De la même façon n'importe quelle valeur peut être utilisée comme valeur dans une table, à part nil. Stocker nil revient à effacer la clé de la table, et accéder à une clé qui n'a jamais reçue de valeur retourne nil.

Notez que les tables ne sont jamais copiées implicitement en Lua. Une table passée en paramètre à une fonction est passée par référence, si la fonction modifie le contenu de la table les changements seront visibles ensuite pour l'appelant.

Quand un table est convertie en chaîne le résultat est "table". Ceci peut être modifié en changeant la méta-méthode __tostring. Même la table vide est considérée comme vrai en tant que booléen.

Fonction
En Lua les fonctions sont des first-class values (?) : elles peuvent être créées anonymement, être passées en paramètre, assignées à des variables…

Les fonctions sont créées grâce au mot-clé  et appelées en utilisant les parenthèses. Voir Déclaration de fonctions plus loin.

Les fonction en Lua sont des fermetures, ce qui signifie qu'elles maintiennent une référence à l'environnement où elles ont été déclarées et peuvent manipuler les variables de cet environnement.

Comme pour les tables les fonctions sont toujours manipulées par référence, y compris lorsqu'elles sont stockées dans des variables.

La conversion en chaîne d'une fonction retourne "function".

Types non supportés
Le type userdata permet de stocker des données opaques pour les extensions pour Lua écrites dans d'autres langages. Par exemple un userdata peut contenir un pointeur ou une structure C. Ceci n'est pas utilisé en Scribunto.

Le type thread permet de gérer les co-routines, qui ne sont pas disponibles en Scribunto.

Méta-tables
Chaque table peut avoir une table associée appelée méta-table. Les champs dans la méta-table sont utilisés par certains opérateurs et fonctions pour permettre un comportement différent ou par défaut pour la table. La méta-table d'une table peut être accédée en utilisant la fonction getmetatable, et fixée avec la fonction setmetatable.

Quand elles sont accédées pour leurs méta-fonctions, les méta-tables sont accédées avec rawget.

Les champs d'une méta-table qui impactent la table elle-même sont :
 * __index : utilisé quand l'accès  aurait retourné nil. Si la valeur de ce champs est une table l'accès sera tenté de nouveau dans cette table (par exemple  ). Si la valeur de ce champs est une fonction celle-ci est appelée ainsi :  . La fonction rawget court-circuite cette méta-méthode.
 * __newindex : utilisé lorsqu'une valeur est assignée à une clé de la table et qu'il n'y a pas de valeur pour cette clé ( avec   qui aurait retourné nil). Si la valeur de ce champs est une table l'affectation sera répétée dans cette table . Si la valeur de ce champs est une fonction celle-ci est appelée comme suit :  . La fonction rawset court-circuite cette méta-méthode.
 * __call : utilisé quand la syntaxe d'un appel de fonction est utilisé sur une table . Cette valeur doit être une fonction, qui est appelée comme suit :.
 * __mode : utilisé pour que les tables puissent contenir des références faibles (weak references). Cette valeur doit être une chaîne. Par défaut toute valeur utilisée comme clé ou valeur dans une table ne sera pas nettoyée par le nettoyeur de mémoire (garbage collector). Mais si ce méta-champs contient la lettre 'k' les clés peuvent être « nettoyées », et si il contient la lettre 'v' les valeurs peuvent être « nettoyées». Dans les deux cas la paire clé-valeur correspondante sera effacée de la table si l'un des éléments est « nettoyé ». Notez que le comportement est non définit en cas de modification de ce champs dans une méta-table.

Les autres champs de méta-tables sont : † Pour les opérateurs binaires Lua regarde d'abord la méta-table du paramètre de gauche (s'il y en a une) puis celle du paramètre de droite quand il cherche quelle méta-méthode utiliser. ‡ Pour les opérateurs relationnels la méta-méthode est utilisée uniquement si la même fonction est donnée pour les deux paramètres dans leurs méta-tables respectives. Des fonctions anonymes, même avec un contenu identique, ne sont pas considérées comme identiques. * __metatable affecte getmetatable et setmetatable
 * __add†
 * __sub†
 * __mul†
 * __div†
 * __mod†
 * __pow†
 * __unm
 * __concat†
 * __eq‡
 * __lt‡
 * __le‡
 * __pairs
 * __ipairs
 * __metatable*
 * __tostring

Note : en Lua toutes les chaînes partagent une seule et même méta-table, dans laquelle __index fait référence à la table. Cette méta-table n'est pas accessible en Scribunto. De même  n'est pas disponible, seule une copie dans les modules.

Variables
Les variables sont des endroits pour stocker des valeurs. Il y a trois sortes de variables en Lua : les variables globales, les variables locales et les champs de tables.

Un nom (name) représente une variable globale ou locale (ou un paramètre de fonction, qui est une sorte de variable locale). Les variables sont supposées globales à moins d'être explicitement déclarées comme locales en utilisant le mot-clé. Toute variable à laquelle on n'a pas affecté de valeur contient la valeur nil.

Les variables globales sont stockées dans une table Lua appelée environment. Cette est généralement disponible en tant que variable globale. Il est possible de fixer une méta-table à cette table globale. Les méta-méthodes __index et __newindex seront appelées pour les accès et les affectations à des variables globales comme elles le seraient pour n'importe quelle autre table.

L'environnement d'une fonction peut être accédé en utilisant la fonction getfenv et modifié en utilisant la fonction setfenv. En Scribunto ces fonctions sont fortement restreintes voire inutilisables.

Les variables locales ont une portée lexicale. Voir Déclaration de variables locales.

Expressions
Une expression est quelque chose qui a une valeur : les littéraux (nombres, chaînes, true, false, nil), les déclarations de fonctions anonymes, les constructeurs de tables, les références à des variables, les appels de fonction, les expressions vararg (vararg expression), les expressions entre parenthèses, les opérateurs unaires appliqués à des expressions, et les expressions combinées par des opérateurs binaires.

La plupart des expressions ont une valeur. Les appels de fonction et les expressions vararg peuvent en avoir un nombre quelconque. Notez que mettre un appel de fonction ou une expression vararg entre parenthèses fait perdre toutes sauf la première de leurs valeurs.

Les listes d'expressions sont des listes d'expressions séparées par des virgules. Toutes ces expressions sauf la dernière sont forcées à avoir une seule valeur (en ignorant toutes les valeurs additionnelles, et en utilisant nil si l'expression n'a pas de valeurs). Toutes les valeurs de la dernière expression sont incluses dans les valeurs de la liste d'expressions.

Opérateurs arithmétiques
Lua supporte les opérateurs arithmétiques habituels : addition, soustraction multiplication, division, modulo, exposant et négation.

Pour toutes les opérandes qui sont des nombres ou des chaînes qui peuvent se convertir en nombre (tonumber retourne autre chose que nil) ces opérations ont leur fonctionnement habituel.

Si l'un des opérandes est une table avec une méta-méthode, cette méta-méthode est appelée.

Relational operators
En Lua les opérateurs de relation sont,  ,  ,  ,  , et. Le résultat d'un opérateur relationnel est toujours un booléen.

L'égalité compare d'abord le type de ses opérandes. Si ils sont différents le résultat est faux. Ensuite il compare leur valeur : nil, booléen, nombre et chaînes sont comparées de la façon usuelle. Les fonctions sont égales si elles font référence à exactement le même objet fonction ( retournera faux car il s'agit de la comparaison de deux fonctions anonymes différentes). Les tables sont comparées de la même façon mais ceci peut être modifié en utilisant la méta-méthode __eq.

La différence (ou inégalité) est l'exacte négation de l'égalité.

Pour les opérateurs d'ordre, si les deux opérandes sont des nombres ou des chaînes elles sont comparées directement. Ensuite la présence de méta-méthodes est vérifiée : Les aucune méta-méthode n'est trouvée une erreur est générée.
 * utilise __lt
 * utilise __le si disponible, ou si __lt est disponible alors  est utilisé
 * est considéré comme équivalent à
 * est considéré comme équivalent à

Opérateurs logiques
Les opérateurs logiques sont,  , et. Tous considèrent nil et false comme faux et toutes les autres valeurs comme vraies.

Pour, si l'opérande de gauche est fausse alors elle est retournée et l'opérande de droite n'est pas évaluée, sinon l'opérande de droite est retournée.

Pour, si l'opérande de gauche est vraie alors elle est retournée et l'opérande de droite n'est pas évaluée, sinon l'opérande de droite est retournée.

Pour, le résultat est toujours true ou false.

Notez que  et   n'évaluent pas systématiquement leur opérande de droite. Par exemple  appelera   uniquement si   retourne false ou nil comme première valeur.

Opérateur de concaténation
L'opérateur de concaténation est constitué des deux points. Si les deux opérandes sont des nombres ou des chaînes elles sont converties en chaînes et concaténées. Sinon si une méta-méthode __concat est disponible elle est utilisée. Sinon une erreur est générée.

Notez que les chaînes en Lua sont non modifiables et que Lua ne donne aucune moyen d'en construire, donc une boucle qui fait  aura a créer une nouvelle chaîne à chaque itération et éventuellement le nettoyage mémoire s'occupera des chaînes plus utilisées. Si de nombreuses chaînes doivent être concaténées il peut être plus rapide d'utiliser string.format ou d'insérer les chaînes dans une séquence et d'utiliser table.concat ensuite.

Opérateur de longueur
L'opérateur de longueur est, utilisé comment suit :. Si  est une chaîne il retourne la longueur en octets. Si  est une table séquence il retourne la longueur de la séquence.

Si  est une table qui n'est pas une séquence   peut retourner n'importe quelle valeur N telle que   est différent de nil et   vaut nil, même si il y a d'autres valeurs non-nil à des index plus élevés. Par exemple :

Préséance des opérateurs
Voici la préséance des opérateurs, de la plus haute priorité à la plus basse :
 * not # - (négation)
 * + - (soustraction)
 * and
 * or
 * and
 * or
 * and
 * or

Pour une même préséance la plupart des opérateurs sont associatifs à gauche. Par exemple  est interprété comme. L'exposant et la concaténation sont associatifs à droite, par exemple  est interprété comme.

Function calls
Les appels de fonctions en Lua sont similaires à ceux dans la plupart des autres langages : un nom suivi d'une liste de paramètres entre parenthèses.

func( exp-list )

Comme pour toutes les listes d'expressions en Lua la dernière expression peut fournir plusieurs valeurs.

Si une fonction est appelée avec moins de valeurs dans la liste d'expression que le nombre de paramètres définis dans la fonction, les paramètres additionnels auront une valeur nil. Si la liste d'expression contient plus de valeurs que la fonction n'a de paramètres définis les valeurs en trop sont ignorées. Une fonction peut aussi avoir un nombre variable de paramètres. Voir Déclarations de fonctions.

Lua autorise également l'appel direct à la valeur retournée par une fonction. Si une exoression plus complexe qu'un accès de variable est nécessaire pour déterminer quelle fonction doit être appelée une expression entre parenthèses pourra être utilisée.

Lua possède des raccourcis pour deux cas fréquents. Le premier cas quand une table est utilisée comme un objet, et que la fonction est à appeler comme une méthode de cet objet. La syntaxe :

table:name( exp-list )

est strictement équivalente à :

table.name( table, exp-list )

Le second cas est la façon dont Lua met en œuvre les paramètres nommés, en passant comme seul paramètre une table contenant une liste de nom-valeurs. Dans ce cas les parenthèses autour de la liste de paramètres sont optionnelles. Ceci fonctionne aussi si la fonction ne reçoit qu'une chaîne constante. Par exemple les appels :

func{ arg1 = exp, arg2 = exp } func"string"

sont équivalents à :

func( { arg1 = exp, arg2 = exp } ) func( "string" )

Cela peut être combiné. Les appels suivants sont équivalents :

table:name{ arg1 = exp, arg2 = exp } table.name( table, { arg1 = exp, arg2 = exp } )

Déclarations de fonctions
La syntaxe pour déclarer une fonction est :

function ( var-list ) block end

Toutes les variables dans var-list sont locales à la fonction, et ont comme valeurs celles passées lors de l'appel à la fonction. Les variables locales additionnels peuvent être déclarées dans block.

Quand la fonction est appelée les déclarations de block sont exécutées après la création et l'affectation des variables locales correspondant à var-list. Si un return est rencontré le bloc se termine et les valeurs de l'expression correspondant à l'appel de la fonction sont celles passées au return. Si l'exécution attenit la fin du bloc de la fonction sans rencontrer de return celle-ci n'aura aucune valeur.

Les fonctions en Lua sont à fermeture lexicale. Une habitude courante est de déclarer des variables « privées statiques » locales à la portée où la fonction est déclarée. Par exemple :

-- ceci retourne une fonction qui ajoute un nombre à son paramètre function makeAdder( n ) return function( x ) -- la variable n de portée "externe" est disponible ici pour ajout à x        return x + n     end end local add5 = makeAdder( 5 ) mw.log( add5( 6 ) ) -- affiche 11

Une fonction peut être déclarée pour accepter un nombre variable de paramètres en indiquant  comme élément final dans var-list:

function ( var-list, ... ) block end

À l'intérieur du bloc de la fonction l'expression vararg  peut être utilisée. Elle vaut l'ensemble des valeurs passées en paramètre additionnels lors de l'appel à la fonction. Par exemple :

local join = function ( separator, ... ) -- on récupère les paramètres additionnels dans une table local args = { ... }    -- on compte le nombre de paramètre (comme il faut) local n = select( '#', ... ) return table.concat( args, separator, 1, n ) end join( ', ', 'foo', 'bar', 'baz' ) -- retourne la chaine "foo, bar, baz"

La fonction select sert à traiter les expressions vararg. En particulier  doit être utilisée au lieu de   pour compter le nombre de valeurs dans l'expression vararg.

Lua fournit un raccourci syntaxique pour combiner la déclaration et l'assignement à une variable. Voir Déclaration de fonction comme instruction.

Notez que ceci ne marche pas :  local factorial = function ( n ) if n <= 2 then return n   else return n * factorial( n - 1 ) end end Puisque la déclaration d'une fonction est traitée avant la fin de l'assignement des variables locales, "factorial" fait référence à une variable globale de ce nom (probablement « vide »). Ce problème peut être évité en déclarant la variable locale avant et en lui assignant sa valeur dans une instruction postérieure.

Instructions
Une instruction est l'unité élémentaire d'exécition : un assignement, un élément de contrôle, un appel de fonction, une déclaration de variable…

Un morceau (chunk, terme anglais utilisé par la suite plutôt que la traduction qui « perd » un peu de son sens) est une séquence d'instructions, optionnellement séparées par des point-virgules. Un chunk est considéré comme le corps d'une fonction anonyme, donc il peut déclarer des variables locales, recevoir des paramètres et retourner une valeur.

Un bloc (block) est aussi une séquence d'instructions comme un chunk. Un bloc peut être délimité pour créer une seule instruction :. Ceci peut être utilisé pour limiter la portée de variables locales ou pour ajouter une  ou un   au milieu d'un autre bloc.

Affectations
La variable-list est une liste de variables séparées par des virgules. La expression-list est une liste de une ou plusieurs expressions, séparées par des virgules. Outes les expressions sont évaluées avant que la première affectation ne soit effectuée, donc  va effectivement échanger les valeurs contenues dans a et b.

Déclaration locale de variables
Des variables locales peuvent être déclarées n'importe-où dans un bloc. La première forme (sans liste d'instructions) déclare l'existence des variables mais ne leur assigne pas de valeur − elles valent donc nil dans ce bloc. La seconde forme assigne des valeurs à ces variables en plus de les déclarer, comme décrit dans Affectations.

Notez que la visibilité d'une variable locale commence à l'endroit où elle est déclarée. Donc une déclaration telle que  déclare une variable x et lui affecte la valeur de x dans la portée au dessus. Une variable locale reste visible jusqu'à la fin du bloc où elle a été déclarée.

Structures de contrôle
L'instruction while répète le bloc block tant que l'expression exp est vraie.

L'instruction repeat répète le bloc tant que exp est vraie. Les variables locales déclarées dans le bloc peuvent être utilisées dans l'expression exp.

La première forme de boucle for déclare une variable locale et répète le bloc pour des valeurs de cette variable allant de exp1 à exp2 en ajoutant exp3 à chaque itération. exp3 peut être omise auquel cas la valeur 1 est utilisée. Toutes les expressions sont évaluées une fois avant que la boucle ne démarre.

Cette forme de la boucle for est à peu près équivalente à : do    local var, limit, step = tonumber( exp1 ), tonumber( exp2 ), tonumber( exp3 ) if not ( var and limit and step ) then error end while ( step > 0 and var <= limit ) or ( step <= 0 and var >= limit ) do        local name = var block var = var + step end end

mis à part que les variables var, limit et step ne sont pas accessibles. Notez que la variable name est locale au bloc. Pour utiliser sa valeur en dehors de la boucle elle doit être copiée dans une variable déclarée en dehors de cette boucle.

La seconde forme de la boucle for travaille avec une fonction itérateur. Comme dans la première forme exp-list est évalué une fois avant que le début de la boucle.

Cette forme est à peu près équivalente à :

do    local func, static, var = exp-list while true do        local var-list = func( static, var ) var = var1 -- var1 is the first variable in var-list if var == nil then break end block end end

mis à part une fois encore que les variables func, static et var ne sont pas accessibles. Notez que les variables var-list sont locales au bloc. Pour utiliser leurs valeurs en dehors de la boucle il faut les copiers dans des variables déclarées en dehors de cette boucle.

La plupart du temps exp-list est une unique fonction qui retourne trois valeurs. Il est plus efficace d'avoir une fonction itérateur qui ne dépend que des paramètres qu'on lui passe. Sinon Programming in Lua suggère qu'il est préférable d'utiliser une fermeture plutôt que de retourner une table en tant que variable statique et de mettre à jour ses membres à chaque itération.

Exécute block1 si exp1 retourne vrai, sinon exécute block2 si exp2retourne vrai, et block3 sinon. La partie  peut être omise, et la partie   peut être omise ou répétée autant que nécessaire.

L'instruction return est utilisée pour retournée une valeur dans une fonction ou un chunk (qui est une fonction). expression-list est une liste de zéro ou plus expressions séparées par des virgules.

Lua met en œuvre les « appels de queue » (tail calls) : si expression-list consiste uniquement en une expression qui est un appel de fonction, alors la pile courante de la fonction sera réutilisée pour l'appel à cette fonction. Ceci impacte que les fonctions qui manipulent la pile d'appel comme  et.

L'instruction return ne peut être qu'en dernière instruction d'un bloc. Si un return est nécessaire à un autre endroit un bloc explicite (comme ) peut être utilisé.

L'instruction break est utilisée pour terminer l'exécution d'une boucle while, repear ou for, sautant à l'instruction qui suit immédiatement la fin de la boucle.

L'instruction break ne peut être qu'en dernière instruction d'un bloc. Si un break est nécessaire à un autre endroit un bloc explicite (comme ) peut être utilisé.

Appel de fonction comme instruction
Une fonction peut être appelée et utilisée comme une instruction (sans affectation du retour). Dans ce cas l'instruction est utilisée uniquement pour ses effets de bord (par exemple mw.log qui enregistre des messages) et les valeurs retournées éventuelles sont ignorées.

Instruction de déclaration de fonctions
Lua fournit un raccourci syntaxique pour déclarer une fonction et l'affecter à une variable. Les paires de déclarations suivantes sont équivalentes :

-- déclarations "basiques" function func( var-list ) block end func = function ( var-list ) block end

-- fonction local local function func( var-list ) block end local func; func = function ( var-list ) block end

-- fonction comme champs d'une table function table.func( var-list ) block end table.func = function ( var-list ) block end

-- fonction comme méthode d'une table function table:func( var-list ) block end table.func = function ( self, var-list ) block end

Notez que la notation avec les deux-points est parallèle à la notation avec les deux-points pour les appels de fonction, ajoutant explicitement un paramètre "self" au début de la liste des paramètres.

--- 'ATTENTION : à partir de là le reste de cette documentation n'est pas encore mis à jour. Se référer à la documentation en anglais en cas de doute.' ---

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.9). Returns the previous value for pause . </li>

<li>"setstepmul": utilise  comme nouvelle valeur pour le multiplicateur d'étape du nettoyeur (voir &sect;2.9). 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 ).

Les librairies Scribunto
Toutes les librairies Scribunto sont dans la table.

mw.allToString
Appelle tostring sur chacun de ses paramètres, et concatène les résultats en utilisant des tabulations comme séparateur.

mw.clearLogBuffer
Efface toutes les données loguées avec mw.log.

mw.clone
Crée une copie de la valeur donnée. Les tables (et leurs méta-tables) sont reconstruites de zéro, récursivement si besoin. Les fonctions restent toutefois partagées.

mw.executeFunction
Crée une nouvelle copie de frame object, appelle la fonction avec ceci en paramètre, puis appelle tostring sur chaque résultat retourné et les concatène (sans séparateur) et enfin retourne la chaîne résultante.

Notez que ceci ne fonctionnera pas correctement depuis la console de debug, car il n'y a pas de Frame object à copier.

mw.executeModule
Exécute la fonction dans un environnement protégé (« sandbox »). La fonction ne peut rien affecter dans l'environnement courant, à l'exception d'effets de bord.

Le nom « executeModule » vient du fait que cette fonction est utilisée lorsqu'un module est chargé depuis l'espace de nom Module:.

mw.getCurrentFrame
Retourne l'objet frame courant (frame object).

mw.getLogBuffer
Retourne les données loguées par mw.log dans une chaîne.

mw.incrementExpensiveFunctionCount
Ajoute un au compteur "parser function coûteuse", et génère une exception si ce compteur dépasse la limite (voir $wgExpensiveParserFunctionLimit).

mw.loadData
Parfois un module a besoin de charger de grosses tables de données, par exemple un module servant à convertir des unités aura besoin d'une grosse table contenant les unités reconnues et leurs facteurs de conversion. Et ces modules peuvent être utilisés de nombreuses fois sur de nombreux articles. Analyser ces tables à chaque  peut avoir un coût significatif. Pour éviter cela il faut utiliser la fonction.

fonctionne comme  avec les différences suivantes :
 * le module chargé est évalué seulement une fois par page, au lieu d'une fois par  ;
 * le module chargé n'est pas enregistré dans  ;
 * la valeur retournée par le module chargé doit être une table. Les autres types ne sont pas supportés ;
 * la table retournée (et ses sous-tables) peuvent contenir seulement des booléens, chaînes et d'autres tables. Les autres types, en particulier les fonctions, ne sont pas autorisées ;
 * la table retournée (et ses sous-tables) ne peuvent pas avoir de metatable ;
 * toutes les clés de la table doivent être des booléens, des nombres ou des chaînes ;
 * la table retournée par  a des méta-méthodes qui fournissent des accès en lecture seule aux éléments. Comme la table ne contient pas les données directement,   et   fonctionnent mais les autres méthodes comme ,  , et les fonctions de Table library non.

Le module hypothétique mentionné plus haut pourrait stocker son code dans "Module:Convert" et ses données dans "Module:Convert/data", et "Module:Convert" utiliserait  pour charger efficacement les données.

mw.log
Passe les paramètres à mw.allToString, et alors ajoute le résultat au buffer de logs.

Depuis la console de debug la fonction  est un alias pour cette fonction.

-- Traduction / ré-écriture en cours --

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 (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;

Licence
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.'' »