Leçons de niveau 12

Introduction au Lua/Scribunto objet Frame

Une page de Wikiversité.
Sauter à la navigation Sauter à la recherche
Début de la boite de navigation du chapitre
Scribunto objet Frame
Icône de la faculté
Chapitre no 17
Leçon : Introduction au Lua
Chap. préc. :Scribunto objet Title
Chap. suiv. :Sommaire
fin de la boite de navigation du chapitre
Icon falscher Titel.svg
En raison de limitations techniques, la typographie souhaitable du titre, « Introduction au Lua : Scribunto objet Frame
Introduction au Lua/Scribunto objet Frame
 », n'a pu être restituée correctement ci-dessus.


Un module Lua-Scribunto pour Mediawiki, est une page de l'espace de noms "Module" qui utilise une table comme variable locale pour stocker ses fonctions et variables mais aussi pour renvoyer la réponse à la fin du processus[1].

Le chapitre bibliothèques Scribunto, étudie les fonctions spécifiques permettant ou facilitant l'usage de Lua sur une plateforme MediaWiki. Il s'agit des fonctions ajoutées par la bibliothèque Scribunto au langage Lua. Cette leçon vous apprendra comment passer des paramètres à vos scripts, à travers l'objet Frame et les fonctions associées.

Prérequis[modifier | modifier le wikicode]

Cette leçon suppose que vous ayez assimilé la leçon Tables.

Créer un module Lua-Scribunto avec des arguments (paramètres)[modifier | modifier le wikicode]

  1. Accéder au Module:Sandbox.
  2. Supprimer le code existant.
  3. Ajouter le code suivant et enregistrer la page:
local p = {}

function p.showmyargs(frame)
--[[pframe is usual name for parent frame.]]--
    result = ';Show my arguments:'
    result = result .. "frame.args[1] is: '''" .. frame.args[1] .. "'''</br>"
    result = result .. "frame.args[2] is: '''" .. frame.args[2] .. "'''</br>"
    result = result .. "frame.args['arg_a'] is: '''" .. frame.args['arg_a'] .. "'''</br>"
    result = result .. "</br>---Context arguments---</br>"
    result = result .. "frame:getTitle() is: '''" .. frame:getTitle() .. "'''</br>"
    parentframe = frame:getParent() 
    result = result .. "frame:getParent() then frame:getTitle() gives: '''" .. parentframe:getTitle() .. "'''</br>"
    return result
end

function p.iterateindexedargs(frame)
	result = ';ipairs(frame.args):' 
	for i, v in ipairs(frame.args) do 
		result = result .. "Argument index: '''" .. i .. "''' ; argument value:  '''" .. v .. "'''</br>" end
	return result
end

function p.iterateallargs(frame) 
	result = ';pairs(frame.args):' 
	for k, v in pairs(frame.args) do 
		result = result .. "Argument name: '''" .. k .. "''' ; argument value:  '''" .. v .. "'''</br>" end
	return result
end

function p.parsingtime(frame)
	--[[Citer la doc LUAREF à propos des fonctions parser]]--
    result =  ';Call parser function:' .. frame:callParserFunction('#time', frame.args[1]) .. '\n'
    return result
end

function p.argstemplate(frame)
--[[Cet exemple passe des variables littérales avant transclusion d'un modèle. ]]--
    result = "'''frame:expandTemplate():'''" 
    result = result .. frame:expandTemplate({title = 'Sidebar', args = {title ='[[Introduction au Lua/Scribunto objet Frame | Le test fonctionne, retour à la leçon!]]', navbar = 'none', topimage = '[[Image:Lua-logo-nolabel.svg | 100px | link=Projet:Laboratoire/Lua]]'}}) .. '\n'
    return result
end

return p

Tester votre nouveau script[modifier | modifier le wikicode]

  1. Rendez-vous sur "votre page de test" ou cette page de discussion.
  2. Ajouter le code suivant et enregistrer la page:
{{#Invoke:Sandbox|showmyargs|value 1|value 2|arg_a = value A}}
{{#Invoke:Sandbox|iterateindexedargs|value 1|value 2|arg_a = value A}}
{{#Invoke:Sandbox|iterateallargs | value 1 | value 2 | arg_a = value A }}
{{#Invoke:Sandbox|parsingtime|Dd-M-Y h:i}}
{{#Invoke:Sandbox|argstemplate}}

Le résultat doit correspondre à ceci[modifier | modifier le wikicode]

Show my arguments
frame.args[1] is: value 1
frame.args[2] is: value 2
frame.args['my_arg'] is: value A
---Context arguments---
frame:getTitle() is: Module:Sandbox
frame:getParent() then frame:getTitle() gives: Discussion:Introduction au Lua/Scribunto objet Frame/Scribunto objet Frame

ipairs(frame.args)
Argument index: 1 ; argument value: value 1
Argument index: 2 ; argument value: value 2
pairs(frame.args)
Argument name: 1 ; argument value: value 1
Argument name: 2 ; argument value: value 2
Argument name: arg_a ; argument value: value A
Call parser function
Sam.02-juil-2016 04:34
frame:expandTemplate()




Comprendre le nouveau script[modifier | modifier le wikicode]

  1. function p.showmyargs(frame) défini une fonction nommée showmyargs qui attend l’objet frame comme argument, l’objet frame réalise l’interface avec l’objet appelant.
    • frame.args désigne la table contenant les paramètres passés par l’objet appelant (généralement le code #Invoke par le biais d’une page, d’un modèle, d’un autre module). Les valeurs de arguments sont toujours des chaines de caractères.
    • On accède aux arguments positionnés par leur index numérique.
      • frame.args[1] désigne le premier argument positionnel et retourne sa valeur.
      • frame.args[2] désigne le second argument positionnel et retourne sa valeur.
    • On accède aux arguments nommés par leur nom.
      • frame.args[my_arg] désigne l’argument dont le nom est my_arg et retourne sa valeur.
    Attention, prenez soin de séparer les arguments indexés généralement au début et les arguments nommés généralement à la fin.
  2. frame:getTitle() renvoie le titre associé à l'objet frame sous forme de chaîne. Pour l'objet frame créé par {{#invoke:}}, c'est le titre du module invoqué.
  3. parentframe=frame:getParent() déclare un nouvel objet frame nommé parentframe reçoit l’objet frame de l’objet appelant. Permet d’accéder aux arguments de l’objet parent ; ceux du modèle lorsqu’un modèle appelle un module par exemple.
    • parentframe:getTitle() dans notre cas getTitle retourne le titre de l’objet parent c’est à dire le titre de la page contenant l’appel au module.
  4. function p.iterateindexedargs(frame) défini une fonction iterateindexedargs qui reçoit l’objet frame en argument.
  5. for i, v in ipairs(frame.args) do utilise la fonction ipairs pour itérer uniquement les arguments positionnels ; retourne i et v l’index et la valeur de l’argument.
    Deux fonctions permettent d’itérer les arguments de l’objet frame.args, ipairs agit uniquement sur les arguments indexés alors que pairs tient compte des arguments nommés et indexés.
  6. function p.iterateallargs(frame) défini la fonction iterateallargs qui reçoit l’objet frame en argument.
  7. for k, v in pairs(frame.args) do utilise la fonction pairs pour itérer tous les arguments, qu’ils soient indexés ou nommés ; retourne k et v, la clé (son nom ou son index) et la valeur de l’argument.
  8. function p.parsingtime(frame) défini la fonction "parsingtime" qui exécute une fonction du parseur en lui passant l’objet frame en argument.
  9. frame:callParserFunction('#time', frame.args[1]) appelle la fonction '#time’ du parseur ou interpréteur de page, qui reçoit frame.args[1] le premier argument de l’objet frame et retourne la date selon le format précisé lors de l’appel au module, Dd-M-Y h:i.
    Lorsque c'est possible, les fonctions natives Lua ou Scribunto doivent être préférées à l'utilisation des parser-functions.
  10. function p.argstemplate(frame) défini le nom d’une fonction qui appelle et passe ses arguments à un modèle.
  11. result = result .. frame:expandTemplate({title = 'Sidebar', args = {title ='[[Informatique/Programmation/Lua | Lua pour la Wikiversité]]', navbar = 'none', topimage = '[[Image:Lua-logo-nolabel.svg | 100px | link=Informatique/Programmation/Lua]]'}})
    frame:expandTemplate({title = 'Sidebar’…) appelle la fonction expandTemplate, pour transclure le modèle dont le titre est "Sidebar" ; la fonction attend les arguments du modèle , args = {…} dans une table, typiquement un objet frame. Ici, nous passons les paramètres du modèle littéralement dans la fonction.

Conclusion[modifier | modifier le wikicode]

Nous avons appris à manipuler les arguments contenus dans l’objet frame. Nous pouvons itérer les arguments avec pair et ipairs. Cependant, les autres fonctions Lua de la librairie table ne s’appliquent pas sur les objets frame qui constituent des tables d’arguments particulières. Nous savons échanger des arguments avec une fonction du parseur, avec un modèle. Enfin, nous pouvons accéder à l’objet frame dit parent, comme les arguments du modèle lorsqu’un modèle appel un module Scribuntu. La bibliothèque de fonction Frame Scribuntu propose d’autres fonctions que nous aborderons dans une prochaine leçon.

Félicitation! Vous êtes capable de créer, tester et comprendre un script Lua qui contient des arguments.

Ceci constitue la dernière leçon traduite depuis Lua (en). Nous espérons que le document continue à se développer, et publions un formulaire pour faciliter la rédaction de nouveaux chapitres.

  1. Copier le code suivant sur la nouvelle leçon: {{Subst:Projet:Laboratoire/Lua/Modèle pour ce document}}
  2. ou copier manuellement le "wikitext" du formulaire dans la page de la nouvelle leçon.

Continuez en écrivant une nouvelle leçon!

Voir aussi[modifier | modifier le wikicode]

Références[modifier | modifier le wikicode]

Lua for Wikiversity (en)