Bases du langage Lua

Bienvenue dans cet article consacré aux bases du langage Lua. Nous allons découvrir les fondamentaux de ce langage pour préparer la découverte des articles consacrés à EEP et Lua.

Comme disais je ne sais plus qui, "la découverte crée l'envie de découvrir davantage un peu plus chaque jour."

Cette phrase s'applique parfaitement pour l'apprentissage du langage Lua. Cet article s'adresse en particulier aux néophytes et à toutes les personnes qui n'y connaissent absolument rien en programmation.

Le langage Lua n'est pas à proprement parler un langage de programmation mais un langage de scripting. Ainsi Lua se veut bien plus simple à appréhender et à maitriser qu'un langage plus complexe comme le C++ par exemple.

Vous devez comprendre qu'un langage essaye de se comporter le plus possible comme des humains pour les seconder dans les tâches les plus courantes comme prendre une décision, mémoriser des informations, respecter des process, etc...

Pour arriver à reproduire ces mécanismes, les langages informatiques s'appuient sur des logiques communes pour exécuter des taches diverses et variées. Voici quelques exemples :

• Effectuer des calculs,
• Communiquer des informations à l'utilisateur par le biais d'affichage,
• Prendre une décision par rapport à un critère ou un évènement,
• Enregistrer des informations pour les retrouver plus tard,
• Effectuer des tâches répétitives,
• Poser des questions,
• Etc, etc...

Si les logiques sont communes, à l'inverse chaque langage possède sa propre syntaxe, ses mots-clés, ses fonctions... Même si certains mots clés peuvent se retrouver d'un langage à l'autre, il subsiste toujours quelques petites différences dans la manière de les écrire et de les utiliser.

Dans les chapitres suivants, nous allons découvrir les fondamentaux à connaître pour bien débuter avec le langage Lua. Ils sont finalement faciles à apprendre et à retenir pour la simple et bonne raison qu'ils font appel à la logique que vous utilisez dans votre vie quotidienne sans même vous en rendre compte la plupart du temps.

Lorsqu'un interlocuteur vous parle, vous l'écoutez afin de le comprendre et de retenir le maximum d'informations. Il en va de même avec Lua. Bien-sûr nous allons remplacer la voix de votre interlocuteur par des informations à afficher sur l'écran. Il existe un mot-clé tout prêt pour cela et il se nomme print (print = imprimer ou encore afficher). Démarrez EEP, créez un projet avec les valeurs par défaut, ouvrez l'éditeur Lua et entrez ceci sous la dernière ligne après le mot-clé end de la fonction EEPMain() :

print("Voici ma première phrase, j'apprends à écrire en Lua !")

Une fois cet extrait collé dans l'éditeur, cliquez sur le bouton Recharger le script en bas de la fenêtre. Avant de continuer, vérifiez si la fenêtre d'évènements est affichée. Si ce n'est pas le cas, allez dans les paramètres EEP pour l'activer.

Maintenant affichez la fenêtre 3D. Vous devriez voir votre phrase s'afficher dans la fenêtre d'évènements :

Bravo ! vous venez d'écrire votre première phrase en Lua ! Ici comme dans la réalité, lorsqu'un interlocuteur vous parle vous n'entendez que ses mots. Et bien Lua fait exactement la même chose avec print ! Ne sont affichés que les mots situés entre les guillemets. Les parenthèses et les guillemets sont exclus car ils sont réservés au mot-clé print pour dire à Lua : "Tu affiches tout ce qui est entre guillemets".

Bien-sûr, vous pouvez afficher aussi des parenthèses mais elles doivent être placées entre les deux guillemets comme ceci :

print("Voici ma deuxième phrase, j'apprends (toujours) à écrire en Lua !")

Et le résultat dans la fenêtre 3D :

Nos deux parenthèses sont bien affichées à l'intérieur de la phrase car elles sont placées entre les deux guillemets.

Dans ces deux exemples, la phrase est affichée tout en haut de la fenêtre d'évènements mais parfois il est bon d'avoir un peu d'espace entre les phrases.

Lorsqu'un interlocuteur vous parle, il fait régulièrement une pause pour reprendre sa respiration dans la narration de ses phrases. Et bien avec Lua c'est aussi la même chose, il existe une possibilité d'aérer les phrases pour créer de l'espace afin que celles-ci ne soient pas affichées tout en bloc et permet ainsi de faciliter la lecture. Voici un exemple :

print("\nJ'apprends les bases du langage Lua pour écrire bientôt des scripts dans mes futurs projets EEP.")
print("\nAinsi mes réseaux seront automatisés et je pourrai profiter tranquillement des vues caméras.")

Après avoir activé la fenêtre 3D :

L'interligne entre les deux phrases est rendu possible via la séquence \n en début de phrase. Le texte est plus aéré et plus facile à lire.

Nous reviendrons sur le mot-clé print plus loin dans l'article avec d'autres exemples.

Lua comme les humains peut mémoriser tout type d'information mais la différence est que sa mémoire est bien plus performante que la notre ! Là où nous sommes capables de mémoriser notre code de carte bancaire, certains mots de passe, notre date de naissance, etc... Lua est capable de mémoriser toutes les informations qui transitent entre lui et la mémoire de l'ordinateur ce qui peut représenter une quantité très importante d'informations. De plus, il est capable de restituer à 100 % avec une précision inégalée toute donnée déjà enregistrée. Aucun oubli, aucune approximation. Tout sera strictement identique entre l'enregistrement et la restitution. Alors comment fait-il ?

Et bien Lua stocke et range toutes ces informations dans une partie de la mémoire de l'ordinateur. Un peu comme s'il les rangeait dans des petits tiroirs. Et lorsqu'on lui demande de restituer une information, il sait ouvrir le bon tiroir au moment opportun.

Ce mécanisme est rendu possible grâce aux variables. Les variables sont utilisés depuis les débuts de l'ère de l'informatique. C'est dire si elles sont utiles et indispensables !

Nous aussi, nous allons tirer profit des variables pour réaliser des scripts capables de mener à bien certaines opérations dans EEP.

Alors une variable ressemble à quoi ? quand les utiliser ? comment les utiliser ?

Une variable contient une valeur, une donnée, une information appelée à être modifiée (ou pas) durant l'exécution d'un script. Pour utiliser une variable, il faut d'abord la créer, ce qui revient à dire que les variables doivent être déclarées en tout début de script, de préférence avant la fonction EEPMain(). Ainsi une fois déclarée, nous pouvons les utiliser autant de fois que nécessaire selon les besoins du script.

La création d'une variable est très simple. Il suffit de lui donner un nom explicite suivi du signe = sous la forme : variable = quelque chose. Exemple ci-dessous :

ma_variable = 0

Nous venons de créer notre première variable ! son nom est ma_variable et nous lui avons demandé de mémoriser le nombre 0. Si vous activez la fenêtre 3D, rien ne sera affiché car créer une variable ne déclenche pas son affichage. Pour afficher l'information mémorisée dans cette variable, il faut utiliser le mot clé print et ça tombe plutôt bien car nous venons de l'étudier.

Copiez-collez le code suivant dans l'éditeur pour remplacer le code déjà existant :

clearlog()

ma_variable = 0

function EEPMain()
	return 1
end

print("\nla valeur de ma variable est égale à : ", ma_variable)

Activez maintenant la fenêtre 3D :

Sans surprise à la ligne n° 9 nous retrouvons notre phrase entre guillemets. Juste derrière une virgule a été ajoutée. Cette virgule sert de "séparateur" pour indiquer à print d'afficher une autre information après la phrase. Ainsi après la virgule, il suffit de recopier le nom de la variable et terminer le mot-clé print par sa parenthèse de fin.

Lors de l'exécution du script, print va afficher tout simplement la valeur contenue dans la variable et non pas textuellement le nom de la variable, car celle-ci n'est pas entre guillemets.

Dans notre exemple, nous avons affecté la valeur 0 à notre variable, mais comme une variable est susceptible de contenir n'importe quel type de valeur, nous pouvons très bien affecter une phrase à une deuxième variable ! Exemple :

clearlog()

ma_variable = 0
ma_nouvelle_variable = "Cette 2ème phrase est contenue dans la variable ma_nouvelle_variable"

function EEPMain()
	return 1
end

print("\nLa valeur de ma_variable est toujours égale à : ", ma_variable)
print("\nNouvelle phrase : ", ma_nouvelle_variable)

Et le résultat :

Comme vous avez pu le constater, une phrase forme une chaine de caractères. Toutes les chaines de caractères doivent être écrites entre les guillemets ! Pour le moment nous avons deux variables avec deux types de données différents :

• Une donnée numérique avec le chiffre 0,
• Une donnée alphanumérique avec une chaine de caractères.

Avec Lua le type des variables est assez limité comparé à d'autres langages plus typés. Les variables les plus utilisées dans EEP avec Lua sont numérique, alphanumérique. Il existe d'autres type de variables que nous étudierons plus tard.

Quoi qu'il en soit, une variable doit toujours être déclarée. C'est une bonne habitude à prendre dès le départ. Même si Lua n'impose pas la déclaration explicite des variables. Des variables bien nommées et déclarées évitent déjà des éventuelles erreurs d'exécution et font gagner un temps précieux lorsqu'il faut fouiller dans le code et cela est d'autant plus vrai quand le code est volumineux.

Vous aimerez coder davantage si vous écrivez proprement votre code Lua. Pour vous aider à bien le rédiger, vous pouvez ajouter des lignes de commentaires car elles sont totalement ignorées lors de l'exécution du script mais sont d'une grande utilité pour documenter le code. Un code correctement documenté et lisible apporte un gain de temps évident si le script doit être remanié ou amélioré quelques mois plus tard.

Dans Lua, la syntaxe pour les commentaires sur une ligne sont les deux tirets du chiffre 6 ou deux signes moins :

-- Ceci est un commentaire dans le code Lua
-- Et voici encore un autre commentaire

Maintenant regardez les lignes n° 4 à 9 dans le listing ci-dessous, le code présent entre ces deux lignes est simplement ignoré car il est aussi considéré comme un commentaire mais sur plusieurs lignes. Récapitulons avec un exemple :

-- Je suis un commentaire sur une seule ligne

--[[
  Je suis un commentaire écrit sur plusieurs lignes
  et j'ai besoin de plus d'espace pour décrire l'action
  exécutée par le code qui va suivre.
  
  Je peux également être utilisé pour désactiver
  temporairement un morceau de code à des fins de test.
]]

La syntaxe pour écrire plusieurs lignes de commentaires commence par --[[ et se termine par ]]. Tout contenu entre ces deux lignes sera purement et simplement ignoré.

Très souvent nous sommes confrontés à des prises de décisions tout au long de notre vie. Par exemple :

• Est-ce-que je dois aller faire le plein d'essence,
• S'il me reste moins de 5 ou 10 euros en poche, est-ce-que je dois aller au distributeur,
• Est-ce-que Oui ou Non je dois aller faire mes courses aujourd'hui,
• Etc...

Il en est de même avec Lua. Tout langage informatique est conçu pour prendre des décisions. Sans ce mécanisme, l'informatique ne serait pas ce qu'elle est actuellement. Pour prendre une décision dans Lua, il suffit de tester la valeur d'une variable pour la comparer à une valeur recherchée. Si telle valeur est égale à la valeur 100 par exemple alors le script exécute un bout de code pour cette valeur. Mais si cette même valeur est différente de 100 alors le script exécute un autre bout de code à la place. On appelle cela le test conditionnel car on introduit la notion de condition.

Un test conditionnel peut avoir une ou plusieurs conditions. Dans l'exemple ci-dessous, nous trouvons le cas le plus simple avec le test à une condition :

clearlog()

-- On déclare une variable numérique égale à 100
ma_variable = 100

function EEPMain()
  return 1
end

-- Le test commence à la ligne ci-dessous... 
if ma_variable == 100 then 
	print("\nLa valeur de ma_variable est bien égale à 100")
end

Le test se trouve à la ligne n° 11 et commence par le mot clé if (qui signifie si). Si ma_variable est égale à 100 alors (then signifie alors), on affiche l'instruction print. Le test se termine par le mot-clé end à la ligne n° 13. Les mots-clés sont écrits en rouge dans les lignes en surbrillance. Regardons le résultat ci-dessous :

Maintenant les mots-clés Lua pour tester plusieurs conditions sont : if - then - else - end. Dans l'exemple ci-dessous ils sont écrits en rouge dans les lignes en surbrillance :

clearlog()

-- On déclare une variable numérique égale à 80
ma_variable = 80

function EEPMain()
  return 1
end

-- Le test commence à la ligne ci-dessous...
if ma_variable == 100 then  -- Si ma_variable est égale à 100 alors exécute la ligne de code ci-dessous

    print("\nLa valeur de ma_variable est bien égale à 100 : ", ma_variable)
    
  else  -- Sinon si ma_variable n'est pas égale à 100, exécute la ligne de code ci-dessous
  
    print("\nLa valeur de ma_variable n'est pas égale à 100 : ", ma_variable)
    
end

Une fois cet extrait collé dans l'éditeur, cliquez sur le bouton Recharger le script en bas de la fenêtre et activez la fenêtre 3D pour afficher le résultat dans la fenêtre d'évènements :

Comme pour le test simple, le mot-clé if est utilisé pour débuter le test à la ligne n° 11. if (si) ma_variable est égale == à 100 then (alors) la ligne n° 13 est exécutée else (sinon) dans le cas contraire si ma_variable n'est pas égale à 100 (ce qui est le cas ici dans la déclaration de la variable à la ligne n° 4 avec la valeur égale à 80), le programme "sautera" directement à la ligne n° 17 et naturellement la ligne n° 13 ne sera pas exécutée. Les deux lignes ne peuvent pas être exécutées en même temps, c'est soit l'une ou l'autre mais pas les deux. N'oubliez jamais que le mot-clé if se termine toujours par le mot-clé end (ici à la ligne n° 19).

Dans notre exemple ci-dessus, nous avons testé deux conditions, à savoir si notre variable était égale à la valeur 100. Ce test à deux conditions est tout particulièrement indiqué pour tester si une valeur est vraie ou fausse. Il existe dans Lua deux constantes pour tester les valeurs vraies ou fausses. Une constante est un mot-clé dont sa valeur ne change jamais. Ces constantes s'appellent respectivement true et false :

• true = vrai
• false = faux

Comme tous les mots-clé dans Lua, true et false sont écrits en minuscules. Ces deux constantes se retrouvent dans la quasi totalité des langages informatiques.

Alors comment tester si une valeur est vraie ou fausse ? prenons un cas très concret dans EEP avec la fonction EEPGetTrainSpeed. Cette fonction nous indique si un convoi ferroviaire est en mouvement ou pas et retourne la vitesse de ce dernier. Exemple :

clearlog()

-- On déclare une variable numérique égale à 100
ma_variable = 100
-- On initialise la variable Resultat à la valeur nil (mot-clé nil = valeur inconnue à ce stade)
Resultat = nil
-- On initialise la variable Vitesse à la valeur nil (mot-clé nil = valeur inconnue à ce stade)
Vitesse = nil

function EEPMain()
  return 1
end

-- Appel la fonction EEP EEPGetTrainSpeed()
Resultat, Vitesse = EEPGetTrainSpeed("#LeNomDeMonTrain")

-- Le test commence à la ligne ci-dessous... 
if Resultat == true then  -- Si Resultat est égal à true alors exécute la ligne de code ci-dessous

    print("\nMon train roule à : ", Vitesse)
    
  else  -- Sinon si Resultat est égal à false, exécute la ligne de code ci-dessous
  
    print("\nMon train est actuellement à l'arrêt ou n'existe pas")
    
end

Après avoir copié cet exemple dans le presse-papier, créez un nouveau projet par défaut dans EEP et ouvrez la fenêtre de l'éditeur Lua pour coller ce script dedans. Ensuite activez la fenêtre 3D pour afficher le résultat dans la fenêtre d'évènements :

Comme le projet est vide, le train #LeNomDeMonTrain indiqué entre parenthèses dans la fonction EEPGetTrainSpeed n'existe évidemment pas. La variable Resultat est donc égale à false. La ligne n° 24 est ainsi exécutée. Pour afficher la valeur de Resultat, il suffit d'ajouter une instruction print à la ligne n° 25 comme ceci :

  
    print("\nMon train est actuellement à l'arrêt")
    print("\nLa valeur de la variable Resultat est égale à : ", Resultat)

Le résultat :

Nous avons bien la valeur false contenue dans la variable Resultat. Les valeurs true et false sont appelées valeurs booléennes. Ces valeurs sont les plus simples à retenir car elles ne changent jamais.

Tout en haut du script, aux lignes n° 6 et 8, nous avons déclaré les deux variables Resultat et Vitesse comme égales à la valeur nil. Le mot clé nil est important dans Lua. Ce mot clé indique simplement que l'on "prépare" la variable à recevoir une valeur mais donc le type de données n'est pas encore connu à l'avance vu que la fonction EEPGetTrainSpeed est exécutée après la déclaration des variables.

Qui dans sa vie n'a jamais effectué de calculs ? Il en est de même avec Lua sauf qu'il sera toujours plus rapide que vous, n'essayez même pas d'aller plus vite que lui, vous avez perdu d'avance !

Lua est capable de calculs très simples comme l'addition ou la soustraction jusqu'à des calculs très complexes qui dépasseraient largement le cadre de cet article ! Nous allons pour le moment nous en tenir aux quatre opérateurs arithmétiques les plus couramment utilisés :

1. L'addition représentée par le signe +
2. La soustraction représentée par le signe -
3. La multiplication représentée par le signe *
4. La division représentée par le signe /

Par exemple, nous voulons additionner le chiffre 5 au chiffre 10, comment procéder avec Lua ? Regardons l'exemple ci-dessous :

clearlog()

-- On déclare une variable numérique égale à 0
mon_resultat = 0

function EEPMain()
  return 1
end

-- On demande le résultat de l'addition des chiffres 5 et 10
mon_resultat = 5 + 10

print("\nLe résultat du calcul est égal à : ", mon_resultat)

Le résultat :

Dans cet exemple, la déclaration de la variable mon_resultat est égale à 0 (ligne n°5). Pourquoi ? car contrairement à la valeur nil, ici nous savons à l'avance qu'une valeur numérique va être récupérée suite au résultat de l'addition. Mais déclarer la variable mon_resultat = nil serait correct également.

Ci-dessous, nous allons toujours utiliser l'addition pour calculer un résultat mais cette fois-ci à partir d'une variable :

clearlog()

-- On déclare une variable numérique égale à 0
mon_resultat = 0

function EEPMain()
  return 1
end

-- On demande le résultat de l'addition des chiffres 5 et 10
mon_resultat = 5 + 10  -- mon_resultat = 15

mon_resultat = mon_resultat + 8  -- Après calcul mon_resultat = 23

print("\nLe résultat du calcul est égal à : ", mon_resultat)

Vous remarquerez à la ligne n° 14, l'utilisation de la variable mon_resultat dans le calcul pour modifier la valeur de la variable. Regardons comment Lua procède pour trouver le nombre 23 :

1. A la ligne n° 12, Lua a déjà additionné les deux nombres 5 et 10 avec un total égal à 15,
2. A la ligne n° 14, Lua récupère dans un premier temps le résultat de la ligne n° 12 (c'est-à-dire la valeur 15) et additionne le chiffre 8,
3. Dans un deuxième temps, le résultat du calcul est ensuite transféré à nouveau dans la variable mon_resultat qui désormais est égale à la valeur 23,

Ce même calcul écrit sur du papier et un crayon ressemblerait à ceci : ma_variable + 8 = 23. Sauf que Lua calcule d'abord ma_variable + 8 (15 + 8) et affecte la nouvelle valeur à gauche du signe = dans ma_variable. Ce qui fait que la nouvelle valeur dans ma_variable devient égale à 23. Pour résumer on pourrait écrire : mon_resultat [nouvelle_valeur] = mon_ resultat [ancienne_valeur] + 8.

Dans l'exemple suivant, nous allons utiliser la multiplication :

clearlog()

-- On déclare une variable numérique égale à 0
mon_resultat = 0

function EEPMain()
  return 1
end

-- On demande le résultat de la multiplication des chiffres 16 * 52.55
mon_resultat = 16 * 52.55

print("\nLe résultat du calcul est égal à : ", mon_resultat)

Le résultat :

Dans cet exemple, la résultat est la multiplication des chiffres 16 et 52.55. En effet, nous pouvons aussi utiliser des chiffres décimaux. Dans Lua les chiffres décimaux ne comportent pas de virgule mais un point. Si vous remplacez le point par une virgule, Lua supprimera la partie décimale et conservera la partie entière à gauche de la virgule, c'est-à-dire 16 * 52 ce qui donnerait comme résultat 832.

Toujours répéter la même action peut devenir vite lassant sauf pour Lua. En effet il possède des fonctions spécialement dédiées pour ce type de travail ! En informatique les actions répétitives s'appellent des boucles. Lua peut faire tourner en boucle un morceau de code jusqu'à un certain point et lorsqu'une condition à l'intérieur de la boucle est vérifiée, celle-ci se termine et le script continue à la prochaine ligne.

Les boucles sont indispensables pour compter, parcourir une liste de valeurs, scanner des modèles dans EEP, créer une temporisation, etc...

Une boucle est constituée de deux éléments obligatoires à savoir une valeur de départ et une valeur de fin.

La boucle la plus simple à mettre en œuvre s'appelle la boucle for. Exemple ci-dessous :

clearlog()

function EEPMain()
	return 1
end

-- Début de la boucle for
for i = 1, 10 do

  print(i)

end

print("\nLa boucle est terminée.")

Dans cet exemple la boucle commence à la ligne n° 8 et commence par le mot-clé for et se termine par le mot-clé end à la ligne n° 12. Ensuite la valeur de début commence à 1 et la valeur de fin se termine à 10. Notre boucle va donc parcourir tous les chiffres de 1 à 10. Cette valeur sera transmise dans la variable i à chaque itération. Pour le vérifier, il suffit de placer une instruction print dans la boucle pour afficher la variable i et regarder le résultat dans la fenêtre d'évènements :

La variable i a stocké temporairement les chiffres de 1 à 10. Avec Lua, il n'est pas nécessaire de déclarer les variables des boucles pour la simple raison qu'elles sont initialisées automatiquement. Les variables des boucles doivent être les plus courtes possibles. En général, les mêmes lettres sont souvent utilisées : i, j, k ou encore s.

Nous allons nous arrêter là pour le moment mais nous verrons dans les articles traitant des fonctions Lua, d'autres possibilités offertes avec les boucles.

Il est essentiel et primordial de bien assimiler la notion des variables car nous allons les utiliser très souvent. Les variables sont stockées dans une petite case de la mémoire de l'ordinateur. Chaque case peut s'apparenter à un tiroir dans lequel sont rangées les données.

Les noms des variables sont soumis à quelques règles incontournables. Enumérons-les ci-dessous :

1. Le nom d'une variable peut contenir des chiffres mais doit toujours commencer par une lettre,
2. Les espaces ne sont pas autorisés. Pour simuler un espace utilisez le soulignement bas du chiffre 8 : _ . Ne commencez pas l'écriture de la variable par ce caractère car il est réservé pour les variables globales internes à Lua.
3. Bannissez définitivement les caractères spéciaux et les lettres accentuées,
4. Le nom d'une variable ne peut pas être celui d'un mot-clé réservé du langage Lua.

A part ça, Lua n'impose pas de déclarer le type des variables contrairement à d'autres langages informatiques. Néanmoins, dans un souci de clarté pour la lecture du code, il est souhaitable de trouver votre propre méthode pour nommer les variables correctement afin de voir au premier coup d’œil que telle ou telle variable s'attend à recevoir telle ou telle valeur. En effet, il ne serait pas opportun d'utiliser la même variable pour y stocker tantôt une valeur de type numérique et plus loin dans le code une valeur de type alphanumérique. Cela pourrait provoquer une erreur d'exécution.

Comme vous avez pu le constater, il existe plusieurs types de données utilisables dans nos variables :

1. Le type numérique avec exclusivement des nombres,
2. Le type alphanumérique avec des lettres et des nombres,
3. Le type booléen avec les valeurs true ou false,
4. Le type table que nous verrons plus tard.

L'idée serait d'identifier au premier coup d’œil quel type de données est contenu dans une variable. Pour arriver à ce résultat, Nous allons vous présenter une méthode de nommage des variables. Il s'agit d'une méthode parmi tant d'autres mais qui a fait ses preuves. Vous n'êtes pas obligés de l'adopter, cette méthode est présentée juste pour l'exemple. L'essentiel est de trouver votre méthode avec laquelle vous vous sentirez le plus à l'aise.

1. Le type Numérique : ne peut contenir que des nombres avec ou sans virgule. Dans notre cas, nous allons faire simple et retenir comme abréviation le mot nbr (comme nombre),
2. Le type Alphanumérique : une chaine de caractères pouvant contenir des lettres et des chiffres et toujours placée entre guillemets. En informatique une chaine de caractères se nomme string mais nous allons retenir comme abréviation str,
3. Le type Booléen : ne peut contenir que la valeur Vraie ou Fausse (essentiel pour vérifier si une condition est vraie ou fausse). En informatique, un type booléen se nomme bool. Nous allons conserver cette même abréviation,
4. Le type table : s'apparente au classeur d'un tableur avec des lignes et éventuellement plusieurs colonnes. En informatique, un type table se nomme array. Nous allons retenir tout simplement l'abréviation tbl (comme table).

Une fois de plus, même si Lua n'impose pas la déclaration des variables, nous allons prendre de bonnes habitudes et le faire nous-même. Les variables sont toujours déclarées au début du script juste avant la fonction EEPMain(). Ces variables ont par défaut le statut global car elles restent visibles et accessibles dans toutes les fonctions du script. Chaque fonction pourra accéder à n'importe quel moment aux valeurs stockées dans ces variables. Il est bon de commencer l'écriture de ces variables par le préfixe g_ (g comme global). Après ce préfixe, l'idée est d'ajouter le type de donnée que doit contenir la variable :

1. nbr pour une donnée de type numérique,
2. str pour une donnée de type alphanumérique,
3. bool pour une donnée de type booléen,
4. tbl pour une donnée type table.

Comme toujours l'affectation d'une valeur s'effectue tout simplement à l'aide du signe = (nom de la variable = quelque chose) :

-- Numéro de département (préfixe 'g_' suivi du type 'nbr' suivi de l'abréviation du mot Département 'Dep')
g_nbrDep = 37

-- Variable alphanumérique pour stocker le nom d'une locomotive
-- Nom d'une locomotive (Préfixe 'g_' suivi du type 'str'suivi du mot 'Locomotive')
g_strNom_Locomotive = "BB9200 SNCF"

-- Variable booléenne pour recevoir la valeur true ou false de la fonction EEPGetTrainSpeed() par exemple
g_boolResult = nil
-- Variable numérique pour recevoir la vitesse de la fonction EEPGetTrainSpeed()
g_nbrVitesse = 0

-- Appel la fonction EEP EEPGetTrainSpeed()
g_boolResult, g_nbrVitesse= EEPGetTrainSpeed("#LeNomDeMonTrain")

function EEPMain()
  return 1
end

print("Nous habitons dans le département n° ", g_nbrDep)
print("Le nom de la locomotive est : ", g_strNom_Locomotive)
print("La valeur de la variable g_boolResult est égale à : ", g_boolResult)
print("La valeur de la variable g_nbrVitesse est égale à : ", g_nbrVitesse)

Bien-sûr, on aurait très bien pu déclarer les variables g_boolResult et g_nbrVitesse plus tard lors de la première affectation par le script à la ligne n° 14 ou même ne pas les déclarer du tout car Lua est capable de le faire explicitement pendant l'exécution de la fonction EEPGetTrainSpeed mais c'est une bonne habitude de déclarer au préalable les variables surtout si celles-ci doivent rester accessibles pour les autres fonctions.

Les plus perspicaces d'entre-vous pourront se dire qu'une variable peut aussi être utilisée pour stocker toujours la même valeur ! Oui naturellement c'est possible mais dans ce cas, on ne parle plus de variable mais de constante. La vocation d'une constante est justement de rester constante et de stocker n'importe quelle valeur qui ne sera jamais modifiée. Pour reconnaitre la différence entre les deux, il existe un moyen très simple pour y parvenir. Exemple ci-dessous :

ma_Variable = "Une variable est écrite en minuscule et peut être modifiable à tout moment"
MA_CONSTANTE = "UNE CONSTANTE EST TOUJOURS ECRITE EN MAJUSCULES ET NE SERA JAMAIS MODIFIEE"

La différence concerne l'écriture. Une variable par convention est écrite majoritairement en minuscules alors qu'une constante est écrite exclusivement en MAJUSCULES.

Le principal avantage d'une constante est de donner de la lisibilité dans un code informatique et pas seulement en langage Lua. Ceci prévaut également pour d'autres langages informatiques comme le C++, Javascript...

Prenons un bout de code simple avec la fonction EEPSetSwitch() utilisée pour modifier la position de l'aiguille dans un aiguillage. Cette fonction accepte en 2ème argument le chiffre 1 pour bouger l'aiguille sur "Branche principale" et le chiffre 2 pour bouger l'aiguille sur "Embranchement" :

function EEPMain()
  return 1
end

-- Positionne l'aiguille sur Branche principale pour l'aiguillage n° 6
EEPSetSwitch(6, 1)
-- Positionne l'aiguille sur Embranchement pour l'aiguillage n° 6
EEPSetSwitch(6, 2)

-- Constantes pour les aiguillages
CONST_BRANCHE_PRINCIPALE = 1
CONST_EMBRANCHEMENT = 2

function EEPMain()
  return 1
end

-- Positionne l'aiguille sur Branche principale pour l'aiguillage n° 6
EEPSetSwitch(6, CONST_BRANCHE_PRINCIPALE)
-- Positionne l'aiguille sur Embranchement pour l'aiguillage n° 6
EEPSetSwitch(6, CONST_EMBRANCHEMENT)

Dans le 2ème exemple, nous avons affecté les valeurs 1 et 2 à deux constantes et explicitement écrit l'action à effectuer. Ainsi il est plus facile de comprendre ce qu'est censée faire l'action EEPSetSwitch(6, CONST_BRANCHE_PRINCIPALE) que EEPSetSwitch(6, 1). La lecture du code est ainsi plus claire et surtout vous avez la certitude que :

1. Vous n'avez plus à vous poser la question de savoir à quelle action correspond la valeur 1 ou 2.
2. Cette valeur sera toujours la même pendant toute la durée de l'exécution du script,

Maintenant après avoir assimilé les bases du langage, vous allez pouvoir commencer l'étude de la première partie des fonctions Lua pour EEP.

Si vous voulez en savoir plus sur les mots-clés du langage Lua, voici l'adresse d'un excellent site pour découvrir ou approfondir vos connaissances avec ce langage.

Merci d'avoir lu cet article. Si vous avez des questions ou des suggestions, n’hésitez pas à nous en faire part en bas de cette page en commentaires.

Amusez-vous à lire un autre article. A bientôt !