|
Programmation en language LUA | |
Itération avec for |
La boucle d'itération for est disponible sous deux formes.
Une peut être employé pour réitérer par une
progression numérique et l'autre peut être employé pour réitérer
des fonctions finies appelées les iterators.
La version numérique de progression de for a la syntaxe suivante
:
for variable = from_expression , to_expression
[, step_expression] do instruction end
La boucle d'itération for positionne la valeur variable à
from_exp avant d'éxécuter l'intruction.
L'intruction est exécutée seulement si la variable n'a
pas passé la dernière valeur de to_exp.
Ceci inclut la première
fois que la boucle est réitérée. Chaque fois que instruction est exécuter step_exp est
ajouté à la variable. L'indication
de step_exp est
facultative. Si on ne l'indique pas la valeur de 1 est
employée. Par exemple,
> for i = 1,3 do print(i) end -- count from 1 to 3
1
2
3
> for i = 3,1 do print(i) end -- count from 3 to 1 in steps of 1. zero iterations!
> for i = 3,1,-1 do print(i) end -- count down from 3 to 1
3
2
1
> for i=1,0,-0.25 do print(i) end -- we're not limited to integers
1
0.75
0.5
0.25
0
for i = e1,e2,e3 do end est équivalent au code suivant de Lua
:
do
local i, limit, step = tonumber(e1), tonumber(e2), tonumber(e3) or 1
if not (i and limit and step) then error() end
while (step>0 and i<=limit) or (step<=0 and i>=limit) do
-- block code
i = i + step
end
end
La deuxième forme de la boucle for a la
syntaxe :
for var {, var} in explist do block end
l'explist (liste d'expressions) est évalué avant l'entrée dans la boucle. Les résultats de cette évaluation sont une fonction
iterative (qui place les valeurs de var), un état (d'ou les valeurs peuvent être lues), et une valeur initiale (d'ou part l'itération).
Si nous mettions une table au lieu d'explist Lua fournira l'explist correct pour nous. Chaque élément dans une table est représenté par une paire de clef et de valeur. Lisez Table pour plus de détails au sujet de l'utilisation des tables. Pourafficher tous les éléments dans une table nous pouvons faire ce qui suit :
t = { 3,7,10,17; banana="yellow", pi=3.14159 }
> for key,value in t do print(key,value) end
1 3
2 7
3 10
4 17
pi 3.14159
banana yellow
Lua fournit une fonction pairs() pour créer l'information d'explist pour
itèration d'une table. La fonction pairs()permettra l'itération
sur les paires de clef-valeur.
for key,value in pairs(t) do print(key,value) end
1 3
2 7
3 10
4 17
pi 3.14159
banana yellow
ipairs() La fonction permettra l'itération
sur des paires d'index-valeur. Ce sont des
paires de clef-valeur où les clefs sont des
index dans une rangée du tableau:
> for index,value in ipairs(t) do print(index,value) end
1 3
2 7
3 10
4 17
Remarquez comment seulement la rangée de la table est affiché parce que seulement ces éléments ont des clefs d'index.
La fonction next(table [,index]) réalise une itèration
sur une table. Avce une table et un index elle renvoie
la prochaine paire de clef-valeur
de la table, par exemple,
= next(t) -- index will be nil, the beginning
1 3
>
= next(t,"pi")
banana yellow
pairs() La fonction renvoie un
explist (liste d'expressions) contenant next() ainsi nous pouvons
faire une itération sur les tables. Nous pouvons passer notre propre
liste d'expression à la condition for comme suit
:
> for key,value in next,t,nil do print(key,value) end
1 3
2 7
3 10
4 17
pi 3.14159
banana yellow
Nous passons next,table,nil comme
liste
d'expression à la condition for . Nous disons
ici que nous voulons employer la fonction d'iteration next(),
sur la table appelée la "table", commençant à nil (le commencement).
La condition for continue à s'exécuter jusqu'à ce que la
fonction next() retourne nil (l'extrémité de la
table).
Lua fournit d'autres iteration utiles, comme io.lines([filename]) dans
la
bibliothèque io.
Nous pouvons
démontrer ceci en créant un dossier fait sur commande contenant
quelques lignes de texte.
io.output(io.open("my.txt","w"))
>
io.write("This is\nsome sample text\nfor Lua.")
> io.close()
La bibliothèque io fournit une autre
manière de lire les lignes de texte d'un fichier.
> for line in io.lines("my.txt") do print(line)
end
This is
some sample text
for Lua.
> file = assert(io.open("my.txt", "r"))
>
for line in file:lines() do print(line) end
This is
some sample text
for Lua.
>
file:close()
Quelles sont les différences avec io.lines()?
Vous devez explicitement ouvrir et fermez le ficheir.
Un des avantage est que si le dossier ne peut pas
être ouvert, vous pouvez gérer cet échec dans le code.
Ici, assert a le même effet que io.lines:
l'interprèteur LUA s'arrête avec un message d'erreur et pointe sur la ligne défectueuse
; mais vous pouvez tester sur la valeur nil
de file et faire autre chose.
Un autre avantage est que vous pouvez commencer la boucle sur n'importe quelle ligne :
file = assert(io.open("list.txt", "r"))
local line = file:read()
if string.sub(line, 1, 1) ~= '#' then
ProcessLine(line) -- File doesn't start with a comment, process the first line
end
-- We could also loop on the first lines, while they are comment
-- Process the remainder of the file
for line in file:lines() do
ProcessLine(line)
end
file:close()
Nous pouvons écrire nos propres iterations,
similaires à next(), pour réaliser des itérations sur
des séquences quelconques de données. Ceci est couvert plus en détail
dans Iterations.
 www.loriotpro.com |
|