====== Fonctions ======

Pas de grande différence avec Python. On fonction pourra notamment renvoyer plusieurs résultats sous forme d'un tuple bien que le type tuple n'existe pas en lua.

<Code:lua>
function test(a, b)
    local x = a + b
    local y = a - b
    return x, y

-- exemple d'utilisation
c, d = test(11, 23)
print(c) -- affiche 34
print(d) -- affiche -12
</Code>

===== Fonction anonyme =====

Comme en Javascript, on peut définir une fonction de cette façon :

<Code:lua>
function(a,b)
   ...
end
</Code>

La fonction n'a alors pas de nom, elle est **anonyme**. Cette fonction est une donnée au même titre qu'un entier ou une chaîne de caractères et on peut donc l'affecter à une variable.

<Code:lua>
test = function(a,b)
    ...
end
-- equivalent à function test(a,b)
</Code>

===== fausses variables =====

La fonction ''%%test%%'' précédente renvoie une paire. Supposons que dans un cas particulier, seule la seconde nous intéresse. On pourra l'écrire ainsi :

<Code:lua>
_, d = test(11, 23)
</Code>

Le caractère ''%%_%%'' a été utilisé pour signifier qu'on ne comptait pas utiliser la première partie du résultat de la fonction ''%%test%%''. C'est juste une sorte de code d'écriture, pour rendre les choses plus claires. Après tout, on pouvait tout aussi bien écrire ''%%c, d = test(11,23)%%'' et ne pas utiliser le contenu de ''%%c%%''. Le ''%%_%%'' permet seulement d'exprimer clairement qu'on ne se servira pas de cette partie du résultat.

Exemple d'une fonction renvoyant 6 résultats et dont on ne récupère que le 1er et le 4e :

<Code:lua>
x, _, _, y, _, _ = fonctionASixResultats()
</Code>

On a utilisé ''%%_%%'' pour signifier que les résultats 2, 3, 5 et 6 n'étaient pas utiles pour nous. 

Cela peut sembler étrange. Pour comprendre il faut penser que l'on utilisera des fonctions renvoyant tout un tas d'information. Par exemple, si je demande des informations sur la fenêtre de programme en cours, je peux récupérer le titre de la fenêtre, sa position x, y, sa largeur, sa hauteur... Dans toutes ces informations, peut-être que seule la largeur m'intéresse.

===== souplesse de l'unpack =====

Lua sera particulièrement souple sur l'unpack du renvoi d'une fonction.

<Code:python>
# Python
def troisRetours():
    # fonction exemple renvoyant 3 résultats
    return 10, 20, 30

c = troisRetours()       # c reçoit le tuple (10, 20, 30)
c, d = troisRetours()    # déclenche une erreur
c, d, e = troisRetours() # c reçoit 10, d reçoit 20 et e reçoit 30
c, d, e, f = troisRetours() # déclenche une erreur
</Code>

<Code:lua>
-- Lua
function troisRetours():
    -- fonction exemple renvoyant 3 résultats
    return 10, 20, 30
end

c = troisRetours()       -- c reçoit 10, le reste perdu
c, d = troisRetours()    -- c reçoit 10, d reçoit 20, reste perdu
c, d, e = troisRetours() -- c reçoit 10, d reçoit 20 et e reçoit 30
c, d, e, f = troisRetours() -- idem précédent et f reçoit nil
</Code>

Lua s'adapte donc sans déclencher d'erreur. C'est typique d'un langage de script que l'on veut garder pratique et simple. Mais cela ne facilite pas la recherche d'erreur !