Voir la source de Initiation au Lua avec Scribunto/Autres fonctions standards

{{Chapitre
  | idfaculté  = informatique
  | précédent  = [[../Fonctions mathématiques/]]
  | suivant    = [[../Gestion de l'environnement/]]
  | page_liée  = Exercices/Sur les autres fonctions standards
  | numéro     = 8
  | niveau     = 10
}}

Dans les chapitres précédents, nous avons étudié certaines catégories de fonctions. Ces catégories étaient suffisamment grandes pour que nous leur consacrions un chapitre entier. Il nous reste toutefois à étudier d'autres catégories de fonctions qui contiennent peu de fonctions. Nous consacrons donc ici ce chapitre aux fonctions qui appartiennent aux catégories restantes.
__TOC__
{{Clr}}
== Fonctions concernant les tables  ==

Les exemples donnés dans ce paragraphe se trouvent dans le [[Module:Tables]].

==== table.insert ====

La fonction '''table.insert''' permet de rajouter un élément dans une table avec clé numérique, mais pas forcément à la fin comme on a l'habitude de le faire. La fonction '''insert''' permet d'insérer un élément à une clé déjà existante en décalant tous les objets déjà présents à partir de cette clé. Prenons un exemple pour mieux comprendre.

Des voitures s’apprêtent à faire une course sur un circuit. Supposons les voitures numérotées dans lesquelles se trouvent des conducteurs. Supposons que Natacha arrive en retard et veuille absolument conduire la voiture 3 (déjà occupé) car 3 est son numéro fétiche. On va donc donner la voiture 3 à Natacha. Le conducteur de la 3 ira dans la 4. Le conducteur de la 4 ira dans la 5 et ainsi de suite. Ceci est réalisé grâce à l'instruction '''table.insert(circuit,3,"Natacha")'''

Le programme décrivant l'occupation des voitures avant et après l'arrivée de Natacha est le suivant :

<syntaxhighlight lang="lua">
local p = {}

local circuit = {"Laurent","Cécile","Alain","Cloé","Amandine"}

function p.insertion()
	local reponse = " "
	reponse = reponse.."<br><u>voitures avant l'arrivée de Natacha.</u>"
	for voiture, conducteur in ipairs(circuit) do
		reponse = reponse.."<br>La voiture "..voiture.." est conduite par "..conducteur.."."
	end
	table.insert(circuit,3,"Natacha")
	reponse = reponse.."<br><u>voitures après l'arrivée de Natacha dans la voiture 3.</u>"
	for voiture, conducteur in ipairs(circuit) do
		reponse = reponse.."<br>La voiture "..voiture.." est conduite par "..conducteur.."."
	end
	return reponse
end

return p
</syntaxhighlight>

En tapant '''<nowiki>{{#invoke:Tables|insertion}}</nowiki>''', on obtient : {{#invoke:Tables|insertion}}

<br>

==== table.remove ====

La fonction '''table.remove''' réalise le contraire de ce que faisait la fonction '''table.insert'''. Elle retire un élément de la table avec clé numérique et décale les éléments suivants de façon à boucher le trou.

Reprenons l'exemple précédent en supposant, cette fois qu'Alain, le conducteur de la voiture 3, ne se sente pas bien et renonce à prendre le départ. Pour éviter qu’il y ait une discontinuité dans la numérotation des voitures, le conducteur de la voiture 4 va aller dans la 3. Le conducteur de la 5 va aller dans la 4 et ainsi de suite. Ceci est réalisé grâce à l'instruction '''table.remove(circuit,3)'''. Cette fonction retourne l'élément retiré.

Le programme décrivant l'occupation des voitures avant et après le départ d'Alain est le suivant :

<syntaxhighlight lang="lua">
local p = {}

local circuit = {"Laurent","Cécile","Alain","Cloé","Amandine"}

function p.retrait()
	local reponse = " "
	local souffrant
	reponse = reponse.."<br><u>voitures au départ du circuit.</u>"
	for voiture, conducteur in ipairs(circuit) do
		reponse = reponse.."<br>La voiture "..voiture.." est conduite par "..conducteur.."."
	end
	souffrant = table.remove(circuit,3)
	reponse = reponse.."<br><u>voitures après le départ de "..souffrant.." de la voiture 3.</u>"
	for voiture, conducteur in ipairs(circuit) do
		reponse = reponse.."<br>La voiture "..voiture.." est conduite par "..conducteur.."."
	end
	return reponse
end

return p
</syntaxhighlight>

En tapant '''<nowiki>{{#invoke:Tables|retrait}}</nowiki>''', on obtient : {{#invoke:Tables|retrait}}

<br>

==== table.concat ====

La fonction '''table.concat''' permet d'obtenir une chaîne de caractères exposant le contenu (ou une partie du contenu) d'une table. Elle s'utilise sous la forme : '''table.concat(''table'', ''séparateur'', ''début'', ''fin'')'''


Les paramètres ''séparateur'', ''début'' et ''fin'' sont facultatifs. Si le paramètre ''séparateur'' est absent, il n'y aura pas de séparateurs. Si le paramètre ''début'' est absent, la concaténation se fera à partir du début de la table. Si le paramètre ''fin'' est absent, la concaténation se fera jusqu'à la fin de la table.


Écrivons, en exemple, une fonction qui nous donne les conducteurs des exemples précédents sauf le premier.

<syntaxhighlight lang="lua">
local p = {}

local circuit = {"Laurent","Cécile","Alain","Cloé","Amandine"}

function p.conducteurs()
	return table.concat( circuit, " et aussi ",2,5)
end

return p
</syntaxhighlight>

En tapant '''<nowiki>{{#invoke:Tables|conducteurs}}</nowiki>''', on obtient : {{#invoke:Tables|conducteurs}}

<br />

==== table.maxn ====

Retourne le plus grand index numérique positif utilisé dans la table.

<syntaxhighlight lang="lua">
local p = {}

local circuit = {"Laurent","Cécile","Alain","Cloé","Amandine"}

function p.sup()
	return table.maxn(circuit)
end

return p
</syntaxhighlight>

En tapant '''<nowiki>{{#invoke:Tables|sup}}</nowiki>''', on obtient : {{#invoke:Tables|sup}}

<br />

==== table.sort ====

Permet de trier la table.

<syntaxhighlight lang="lua">
local p = {}

local circuit = {"Laurent","Cécile","Alain","Cloé","Amandine"}

function p.trie()
	table.sort(circuit)
	return "le nouvel ordre est : "..table.concat(circuit,", ")
end

return p
</syntaxhighlight>

En tapant '''<nowiki>{{#invoke:Tables|trie}}</nowiki>''', on obtient : {{#invoke:Tables|trie}}


Nous voyons que les éléments de la table ont été triés par ordre alphabétique.

<br />

== Fonctions concernant le système d'exploitation  ==
{{...}}


Les exemples donnés dans ce paragraphe se trouvent dans le [[Module:Temps]].

==== os.time ====
{{...}}

cette fonction nous ramène un nombre mystérieux à 10 chiffres qui probablement contient, sous forme codé la date et l’heure.

<syntaxhighlight lang="lua">
local p = {}

function p.heure()
	return "La fonction os.time nous retourne : "..os.time()
end

return p
</syntaxhighlight>

'''<nowiki>{{#invoke:Temps|heure}}</nowiki>''' nous retourne : {{#invoke:Temps|heure}}

<br />

==== os.difftime ====
{{...}}

Cette fonction semble être destinée à faire la différence entre deux temps donnée sous un format particulier. En tout cas, elle fait la différence entre deux nombres.

<syntaxhighlight lang="lua">
local p = {}

function p.delais()
	return "La fonction os.difftime nous retourne : "..os.difftime(74,3)
end

return p
</syntaxhighlight>

'''<nowiki>{{#invoke:Temps|delais}}</nowiki>''' nous retourne : {{#invoke:Temps|delais}}

<br />

==== os.clock ====

Cette fonction donne le temps CPU d'exécution d'un programme en seconde. Cette fonction permet donc de mesurer le temps qui s'écoule entre deux parties d'un programme. Pour des exemples d'application voir, dans le chapitre sur la gestion de l'environnement, le paragraphe sur la vitesse d'exécution d'un programme. Voir aussi l'exercice 7-1.

Le temps CPU démarre au moment où commence à s'afficher la page dans laquelle se trouve le module contenant la fonction '''os.clock''' et pas au moment où est lancé le module. Par conséquent, si dans une page, on met plusieurs modules utilisant la fonction '''os.clock''', on observera un temps d'autant plus grand que le module est près du bas de la page.

Le temps CPU est donné en seconde et est le plus souvent compris entre 2 et 20 millisecondes.

Si l’on veut chronométrer le temps d'exécution d'une partie d'un programme, on est obligé de mettre l'instruction avant et après la partie à chronométrer et de faire la différence entre les deux temps obtenus. On obtient alors un temps généralement très inférieur à la milliseconde.

{{Attention|Compte tenu du fait que nos programmes s'exécutent sur un système multitâche, le temps donné par la fonction '''os.clock''' est très approximatif et sera différent d'une exécution à l'autre.}}


Si dessous nous présentons un exemple donnant le temps écoulé, depuis le début de l’affichage de cette page, en millisecondes :

<syntaxhighlight lang="lua">
local p = {}

function p.horloge()
	local reponse = ""
	local temps = os.clock()
	reponse = reponse.. "<br>La fonction os.clock nous retourne : "..temps
	temps = temps*1000
	reponse = reponse.."<br>Ce qui signifie que "..temps.." millisecondes se sont écoulées depuis le début de l’affichage de cette page."
	return reponse
end

return p
</syntaxhighlight>
'''<nowiki>{{#invoke:Temps|horloge}}</nowiki>''' nous donne : {{#invoke:Temps|horloge}}

<br>

==== os.date ====
{{...}}

Cette fonction permet de donner la date et l’heure sous un format choisi. Elle peut fournir une chaîne de caractère ou remplir un tableau avec les différents éléments de la date et de l’heure.

<syntaxhighlight lang="lua">
local p = {}

function p.date()
	return "La fonction os.date nous retourne : "..os.date()
end

return p
</syntaxhighlight>

'''<nowiki>{{#invoke:Temps|date}}</nowiki>''' nous retourne : {{#invoke:Temps|date}}

<br />

== Fonctions concernant la librairie Scribunto  ==
{{...}}


Les exemples donnés dans ce paragraphe se trouvent dans le [[Module:Scribunto]]


==== mw.clone ====

Nous savons que les tables et les fonctions sont affectées par référence. Si A est une table, l'instruction '''B = A''' affectera à B l'adresse de la table A et toutes les modifications effectuées sur A sembleront se répercuter sur B. Pour réaliser une véritable recopie du contenu de la table A dans la table B, on utilisera la fonction préprogrammée '''mw.clone''' en écrivant '''B = mw.clone(A)'''. Cette fois, les tables A et B seront totalement indépendantes bien que contenant les mêmes objets juste après l'affectation.

Dans l'exemple ci-dessous, nous vérifions ce que nous venons de dire en créant une table A que nous affectons à une table B grâce à '''B = A''' et à une table C grâce à '''C = mw.clone(A)'''. Nous modifions ensuite A et nous vérifions que cette modification s'est bien répercutée sur B mais pas sur C.

<syntaxhighlight lang="lua">
local p = {}

function p.duplique()
	local A = {"truc", "machin", "chose"}
	local B = A
	local C = mw.clone(A)
	A[2] = "bidule"
	return "B[2] contient "..B[2].." et C[2] contient "..C[2]
end

return p
</syntaxhighlight>


'''<nowiki>{{#invoke:Scribunto|duplique}}</nowiki>''' nous donne : {{#invoke:Scribunto|duplique}}

<br />

==== mw.loadData ====

Cette fonction permet de charger une table (ou plusieurs) se trouvant dans un autre module. Cette table contient en général un grand nombre de données. Plusieurs raisons justifient le fait que cette table soit écrite dans un autre module :
* Elle est susceptible d’être utilisée par plusieurs modules.
* Cette table n'est chargée qu'une seule fois par page, même si celle-ci utilise plusieurs commandes '''#invoke''', ce qui entraîne une économie de temps.


Certaines restrictions doivent être respectées :
* On ne peut pas charger autre chose qu'une table.
* La table que l’on charge ne doit pas contenir de fonctions.
* Les fonctions '''pairs''' et '''ipairs''' fonctionnent sur la table retournée. Le fonctionnement des autres fonctions spécialisées dans les tables n’est pas garanti.


Dans l'exemple ci-dessous, la fonction '''codehex''' permet de convertir un nom de couleur (de la page [[w:Liste de couleurs|Liste de couleurs]]) en son code hexadécimal qu'elle retourne.

La fonction '''mw.loadData''' de l'exemple ci-dessous charge une table se trouvant dans le [[Module:Nomcouleur]]. Dans le [[Module:Nomcouleur]], la table chargée se nomme nuancier. On remarquera, en fin de module, l'instruction '''return nuancier''' pour que la table puisse être chargée par la fonction '''mw.loadData''' à partir d'un autre module.


<syntaxhighlight lang="lua">
local p = {}

function p.codehex(frame)
	local code = mw.loadData("Module:Nomcouleur")
	local couleur = frame.args[1]
	return "Le code hexadécimal correspondant à la couleur "..couleur.." est "..code[couleur]
end

return p
</syntaxhighlight>

Nous voyons, dans l'exemple ci-dessus, que la fonction '''mw.loadData''' attend un argument sous forme de chaîne de caractères. Nous lui avons donc donné le nom du module contenant la table à charger, à savoir '''"Module:Nomcouleur"''', sans oublier les guillemets et le mot ''module''.

'''<nowiki>{{#invoke:Scribunto|codehex|caca d'oie}}</nowiki>''' nous retourne : {{#invoke:Scribunto|codehex|caca d'oie}}


'''Nota :''' Si l’on souhaite charger plusieurs tables s'appelant, par exemple, A, B, C à l'aide de la fonction '''mw.loadData''', il faut que dans le module appelé, il y ait l'instruction '''return {A, B, C}'''. En fait, on retourne une table de tables.

<br />

==== mw.allToString ====

La fonction mw.allTostring convertit en chaînes de caractères tous ses arguments et concatène les chaînes de caractères obtenues en les séparant par une tabulation. Dans l'exemple, ci-dessous, nous convertissons et concaténons des arguments de types différents : Le nombre ''2'', la chaîne ''"mouche"'', le type ''nil'' et le booléen ''true''. 

<syntaxhighlight lang="lua">
local p = {}

function p.converti()
	return mw.allToString(2,"Mouche",nil,true)
end

return p
</syntaxhighlight>


'''<nowiki>{{#invoke:Scribunto|converti}}</nowiki>''' nous retourne : {{#invoke:Scribunto|converti}}


Nous vérifierons en exercice qu’il y a bien une tabulation comme séparateur.

<br />

==== mw.getCurrentFrame ====

Cette fonction retourne l’objet ''frame'' courant. Elle permet donc, par exemple, une recopie de l’objet ''frame'' actuel. Dans l'exemple qui suit, l’objet ''frame'' a été recopié dans l’objet ''frami'' qui peut s'utiliser comme l’objet ''frame''. Un des avantages est que l’utilisation du nouvel objet sera plus rapide car ne nécessitant plus un appel extérieur au programme.


En réalité, l'explication que nous venons de donner est très fragmentaire car nécessitant des éléments que nous n'avons pas encore étudiés. Nous reviendrons donc sur l'étude de cette fonction dans le chapitre consacré à l’objet ''frame'' pour essayer d’en donner une explication plus complète.

Pour le moment, nous nous contenterons de l'exemple suivant ou l’objet ''frame'' est recopié dans l’objet ''frami''. On visualise ensuite le contenu de l’objet ''frami'' comme on le ferait pour l’objet ''frame''.

<syntaxhighlight lang="lua">
local p = {}

function p.courant(frame)
	frami = mw.getCurrentFrame()
	reponse = ""
	for i = 1,5 do
		reponse = reponse.."<br />à la clé "..i..", on trouve : "..frami.args[i]
	end
	return reponse
end

return p
</syntaxhighlight>


'''<nowiki>{{#invoke:Scribunto|courant|Marmite|17|Tuile|5|Maison}}</nowiki>''' nous retourne : {{#invoke:Scribunto|courant|Marmite|17|Tuile|5|Maison}}

<br />

==== mw.incrementExpensiveFunctionCount ====
{{...}}

<br />

==== mw.log ====
{{...}}

<br />

== Fonctions concernant le chargement (Librairie Package)  ==
{{...}}


Les exemples donnés dans ce paragraphe se trouvent dans le [[Module:Package]]


==== require ====

Cette fonction sera étudiée dans le chapitre sur la gestion de l'environnement.

<br />

==== package.loaders ====
{{...}}

<br />

==== package.preload ====
{{...}}

<br />

==== package.seeall ====
{{...}}

<br />

{{Bas de page
  | idfaculté  = informatique
  | précédent  = [[../Fonctions mathématiques/]]
  | suivant    = [[../Gestion de l'environnement/]]
}}