Projet:Scribunto/Guide/Les variables

Introduction

Une variable est une « entité » qui possède un nom et qui contient une information. On peut modifier et lire cette information. On peut également passer cette information à d'autres fonctions.
Les variables sont la base de la programmation (de ce type de programmation, en tout cas) en ce sens qu'elles conditionnent le déroulement du programme, qui va agir sur les informations et en fonction des informations.

Les variables en Lua

En Lua une variable n'a pas de type, ou du moins elle a le type de ce qu'elle contient. Ainsi une même variable peut contenir du texte, une table, un nombre… au cours du temps, selon l'utilisation qu'on en fait.

Les types connus en Lua sont :

• nil : la valeur nil est un type à elle toute seule.
• boolean : vrai/faux. Les valeurs correspondantes sont true et false.
• number : nombres, avec ou sans virgule.
• string : textes, sans restrictions particulières.
• function : une fonction. On peut ranger des fonctions dans des variables et les appeler ensuite.
• table : une table, c'est-à-dire une collection de "champs = valeur", champs pouvant être un entier (index) ou un texte (hash).
• thread : utilisé pour les co-routines. Non expliqué ici (et normalement non utilisable en Scribunto).
• userdata : structures libres. Non expliqué ici (et normalement non utilisable en Scribunto).

Déclaration d'une variable

Une variable se déclare en indiquant le mot-clé local suivi du nom de la variable. Exemple : local var (indique l'existence de la variable var).
Il est possible de fixer une valeur à la création de la variable. Cette valeur peut être une constante ou bien le résultat d'une évaluation (le contenu d'une autre variable, un calcul, le retour d'une fonction ou une combinaison). Exemple :

local var
local var2 = 5
local toto = "Bonjour"
local x = var2 + 5
local y = z.fonction(var2) * 3

Il est possible de déclarer plusieurs variables d'un coup en les séparant par des vigules : var x, y

Note : à sa création, et si on ne lui fixe pas explicitement de valeur, une variable est créée avec la valeur nil.

Temporalité des variables

Ce n'est pas spécifique à Lua mais c'est une erreur fréquente chez les personnes ayant une vision mathématique des variables : le contenu d'une variable peut changer au cours du temps, la notion de temps étant l'ordre d'exécution des instructions du programme.
Ainsi une même variable peut changer de valeur un nombre arbitraire de fois au cours de l'exécution d'un programme. Quand on lit son contenu on trouve la dernière valeur qu'on aura mis dedans précédemment.

De même il est important de savoir que dans une affectation (signe "=") Lua évalue la partie à droite du signe "=" puis range le résultat dans la variable à gauche de ce signe "=".
Ainsi le code suivant :

local var = 5
var = var + 1

conduit à var qui vaut 6. En effet dans var = var + 1 Lua commence par évaluer var + 1 : à ce moment-là var vaut 5, Lua effectue le calcul (5 + 1 = 6), puis il range ce résultat dans la variable indiquée à gauche, qui se trouve être var et qui vaut à partir de ce moment-là 6.

Visibilité d'une variable

Une variable peut être déclarée n'importe où dans le code. Elle est « visible » (c'est-à-dire qu'elle existe) à partir du moment de sa déclaration et jusqu'à la fin du bloc où elle a été déclarée.
Un bloc est une zone logique (un ensemble de code) qui va de son ouverture jusqu'à sa fermeture par le mot-clé end. Exemple : entre le then et le end d'un if, entre le début et la fin d'une fonction…

Dans des blocs distincts (par exemple deux fonctions) on peut déclarer des variables ayant le même nom : celles-ci sont indépendantes et n'ont aucun rapport entre elles. Elles peuvent contenir des choses différentes, et modifier l'une n'interfère pas avec l'autre.

Les variables qui n'existent pas

En Lua accéder à une variable non déclarée n'est pas une erreur. Celle-ci vaut simplement nil. à vérifier

Variables globales

Il est possible de déclarer des variables globales. Elles se déclarent de la même manière mais en dehors de tout bloc (en fait ce n'est pas vrai : elles sont déclarées dans le bloc qui correspond au module lui-même).
Ces variables globales sont alors utilisables dans toutes les fonctions et en modifier une depuis une fonction est visible depuis les autres fonctions.

Attention : les variables globales sont dangereuses (en terme de fonctionnement d'un programme) pour plusieurs raisons :

• elles sont déclarées « loin » de leur utilisation. Cela augmente le risque d'une erreur de nom.
• une fonction peut déclarer une variable de même nom qu'une variable globale. Dans la fonction c'est la variable locale qui est « visible » (elle masque la variable globale). C'est source d'erreur car mettre une valeur dans cette variable n'a pas le même effet que dans d'autres fonctions
• comme elle peut être modifiée et lue dans des fonctions différentes il devient plus difficile de s'assurer de la cohérence de son contenu, de part la « distance » logique entre les différents codes qui interagissent avec elle.

Bref, il est préférable de s'en passer lorsque c'est possible.

Note : ce qui est décrit ici ne correspond pas à ce que sont réellement les variables globales en Lua. La différence étant subtile et les variables globales (vraies ou pas) étant dangereuses je ne vois pas d'intérêt à expliciter quelque chose qui n'apporte que des problèmes .

Passage de variables aux fonctions

Lorsqu'on appelle une fonction on peut lui passer en paramètre différentes valeurs, qui peuvent être des constantes ou des variables.

Les variables « simples » sont passées par valeur : cela signifie que si la fonction qui reçoit la variable la modifie cela n'a pas d'impact sur la votre. Exemple :

function z.fonction_qui_modifie(var)
  -- je modifie var (un nombre)
  var = var + 1
end

(…)
-- je crée une variable
local i = 5
-- je passe cette variable à la fonction
z.fonction_qui_modifie(i)

Après l'appel à la fonction fonction_qui_modifie() la variable i vaut toujours 5 (et non 6) car la fonction a reçu une copie de la valeur (elle a donc modifié sa propre copie, sans pouvoir changer l'original).

Toutefois : il y a une exception en Lua : les tables sont passées par référence. Cela signifie que lorsque je passe une table à une fonction cette fonction reçoit ma table. Donc si cette fonction modifie le contenu de cette table je verrai ces modifications lorsque la fonction aura terminé son travail.

À tester, c'est décrit comme ça dans la doc mais je n'ai pas testé