Apprendre Le Lua | Tutoriel Et Bases Du Langage De Script - IONOS

Aller au contenu principalDigital GuideChercher Produits IONOS Produits IONOSClose

• Domaines
  • Noms de Domaine
  • Transfert de domaine
  • Domaine .fr
  • Nom de domaine gratuit
  • Nouvelles ex­ten­sions
  • Cer­ti­fi­cats SSL
  • Sécurité de domaine
• Sites Internet & e-Commerce
  • Créer un site Internet
  • Nous créons votre site Internet
  • Ré­fé­ren­ce­ment SEO
  • Gestion de la ré­pu­ta­tion par IA
  • Créer une boutique en ligne
  • Service de con­cep­tion e-commerce
  • Plugin e-commerce
  • Bouton d'achat pour les réseaux sociaux
• Hé­ber­ge­ment & WordPress
  • Hé­ber­ge­ment Web
  • Hé­ber­ge­ment pour WordPress
  • Hé­ber­ge­ment pour Woo­Com­merce
  • Jamstack
  • Hé­ber­ge­ment Joomla!
  • Deploy Now
  • Hé­ber­ge­ment virtuel (VPS)
• Office
  • Adresse email pro­fes­sion­nelle
  • Email marketing
  • Archivage d’emails
  • Email Microsoft Exchange
  • Microsoft 365 / Office 365
  • Google Workspace
  • Stockage en ligne HiDrive
  • HiDrive Share
  • Managed Nextcloud
  • My­De­fen­der
• Serveurs
  • Bare Metal Serveur
  • Cloud Backup
  • Cloud GPU VM
  • Serveurs Cloud
  • Dedicated Server
  • Object Storage
  • VPS Windows
  • Serveurs virtuels (VPS)
  • IONOS Cloud
  • IONOS Cloud Object Storage
• Outils
  • Gé­né­ra­teur de nom d’en­tre­prise
  • Gé­né­ra­teur de noms de domaine par IA
  • Gé­né­ra­teur de logo
  • Favicon Generator
  • Vé­ri­fi­ca­teur Whois
  • Analyse de Site Web
  • Audit SEO
  • Test SSL
  • Vé­ri­fi­ca­teur d'adresse IP

Menu principalCloseChercherProduits IONOS

• Sites internet
  • Création de sites internet
  • Web design
  • Dé­ve­lop­pe­ment web
  • Droit d'in­ter­net
• Hé­ber­ge­ment
  • CMS
  • Blogs
  • Aspects tech­niques
• Serveur
  • Know-how
  • Con­fi­gu­ra­tion
  • Sécurité
  • Outils
• Domaines
  • Ex­ten­sions de domaine
  • Gestion de domaine
  • Ac­tua­li­tés sur le domaine
  • Conseils sur le domaine
• Web marketing
  • Vendre sur internet
  • Search Engine Marketing
  • Les média sociaux
  • Analyse web
• Email
  • Marketing email
  • Sécurité email
  • Aspects tech­niques
• Startup
  • Création
  • Gestion
  • Pro­duc­ti­vité

Essayez gra­tui­te­mentClose

1. IONOS
2. Digital Guide
3. Sites internet
4. Dé­ve­lop­pe­ment web
5. Tutoriel Lua

Apprendre le Lua

• L'équipe édi­to­riale IONOS24/02/2021
• • Partager sur Facebook
  • Partager sur Twitter
  • Partager sur LinkedIn

• Tutoriels

REDPIXEL.PLShut­ters­tock

Sommaire

• Apprendre à pro­gram­mer en Lua : premiers pas avec ce langage de script
• Apprendre les bases du langage de script Lua

Lua est un langage de script développé au Brésil au début des années 1990. Le code source d’un programme en Lua est traduit et exécuté sous forme de code byte par un in­ter­pré­teur Lua. L’in­ter­pré­teur lui-même est codé en C, ce qui permet aux pro­grammes en Lua de disposer d’une per­for­mance élevée lors de l’exécution. Par ailleurs, l’API C permet d’intégrer le code Lua dans les pro­grammes C/C++. Le Lua est un langage mul­ti­pa­ra­digmes per­met­tant d’écrire du code impératif, fonc­tion­nel et orienté objet.

La prin­ci­pale ca­rac­té­ris­tique dis­tinc­tive du Lua est son in­té­gra­tion simple dans d’autres systèmes et langages. Le Lua s’est ainsi établi comme un « langage glue » et est utilisé dans de nombreux moteurs de jeux. Ce langage peut en outre être utilisé pour commander des serveurs Web comme Apache et nginx. Via l’interface CGI, le Lua est, d’autre part, souvent utilisé comme langage de pro­gram­ma­tion Internet in­dé­pen­dant. Par ailleurs, ce langage in­ter­vient également dans la pro­gram­ma­tion d’ap­pli­ca­tions mobiles.

Apprendre à pro­gram­mer en Lua : premiers pas avec ce langage de script

Le moyen le plus simple et le plus rapide d’apprendre à pro­gram­mer en Lua consiste à exécuter du code Lua sur la page de démo in­te­rac­tive de Lua. Vous pouvez y tester tous les exemples de code Lua présentés dans la suite de l’article. Copiez l’un des exemples de code dans le champ de saisie puis cliquez sur « run » pour exécuter le code.

En procédant de la sorte, vous n’aurez pas à procéder à une ins­tal­la­tion. Si vous souhaitez utiliser Lua sur votre propre système, suivez les in­for­ma­tions plus bas. Dans le cas contraire, rendez-vous di­rec­te­ment à la section « Apprendre les bases du langage de script Lua ».

Close

Préparer votre système pour apprendre le Lua

L’in­ter­pré­teur Lua est composé d’un unique fichier binaire dis­po­nible dans l’invite de commande sous la commande « lua ». Ce fichier est en­re­gis­tré sur le système et doit le cas échéant être intégré dans le chemin. Lua propose également des bi­blio­thèques per­met­tant l’in­té­gra­tion de code Lua dans les pro­grammes C/C++.

Pour l’ins­tal­la­tion sous Mac et Linux, l’ins­tal­la­tion devra être réalisée à l’aide du ges­tion­naire de paquets « Homebrew ». Après avoir installé Homebrew sur votre système, utilisez la commande suivante dans l’invite de commande pour installer Lua :

brew install lua

Pour installer Lua sur un système Windows, utilisez l’ins­tal­la­teur LuaDist.

Utiliser l’in­ter­pré­teur Lua de façon in­te­rac­tive

Comme pour de nombreux autres langages de script, l’in­ter­pré­teur Lua peut être exécuté de façon in­te­rac­tive. En mode in­te­rac­tif, l’in­ter­pré­teur reçoit le code Lua dans l’invite de commande et l’exécute ligne après ligne. Les valeurs ainsi générées sont di­rec­te­ment indiquées dans l’invite de commande. En tant qu’uti­li­sa­teur, vous avez la pos­si­bi­lité de vérifier et de modifier les valeurs des variables. Cette approche convient donc tout par­ti­cu­liè­re­ment à un pro­to­ty­page rapide. Pour démarrer l’in­ter­pré­teur Lua en mode in­te­rac­tif, nous exécutons la commande suivante dans l’invite de commande :

# Démarrer l’interpréteur Lua en mode interactif Note

Pour quitter à nouveau le mode in­te­rac­tif, saisissez la commande « os.exit() » ou appuyez sur la com­bi­nai­son de touches [Ctrl]+[D].

Close

Exécuter le script Lua pour apprendre le Lua avec l’in­ter­pré­teur Lua

Plutôt que de saisir pro­gres­si­ve­ment le code Lua dans l’invite de commande, vous pouvez également indiquer à l’in­ter­pré­teur Lua d’exécuter un fichier de code source Lua complet. Pour ce faire, nous devons tout d’abord générer un fichier Lua et trans­mettre à l’in­ter­pré­teur Lua le nom du fichier. L’in­ter­pré­teur lit le code source inclut dans le fichier ligne après ligne et les exécute.

# Exécuter le script Lua lua <nomfichier>.lua Note

Les fichiers de code source Lua se terminent par l’extension de fichier « .lua ».

Rendre le script Lua di­rec­te­ment exé­cu­table pour le tutoriel avec le shebang

Sur le système d’ex­ploi­ta­tion Linux/UNIX/macOS, nous avons également la pos­si­bi­lité de rendre di­rec­te­ment exé­cu­table un fichier de code source Lua. Pour ce faire, il nous faut saisir un « shebang » à la première ligne du fichier Lua :

#!/usr/local/bin/lua -- Code Lua pour l’exécution

Comme vous pouvez le constater, le shebang contient l’em­pla­ce­ment de stockage du fichier binaire Lua, dans notre cas « #!/usr/local/bin/lua ». Dans certains cas, l’em­pla­ce­ment de stockage sur votre système local peut être différent. Vous pouvez alors dé­ter­mi­ner le lieu de stockage du fichier binaire Lua en utilisant la commande « which » dans l’invite de commande :

# Déterminer l’emplacement de stockage du fichier binaire Lua which lua

Après avoir doté le script Lua d’un shebang, vous devez marquer le fichier comme exé­cu­table par l’uti­li­sa­teur. Pour cela, utilisez la commande suivante dans l’invite de commande :

# Marquer le fichier Lua comme exécutable chmod u+rx <nomfichier>.lua

Exécutez ensuite le script Lua dans le ré­per­toire actuel :

./<nomfichier>.lua

Close Conseil

Sur les systèmes de type Linux et UNIX comme macOS, l’astuce du shebang fonc­tionne avec la plupart des langages de script. Selon le même schéma, vous pouvez rendre di­rec­te­ment exé­cu­table des scripts Ruby ou Python.

Apprendre les bases du langage de script Lua

Lua est un langage mul­ti­pa­ra­digmes : le style sur lequel il est basé est impératif et fonc­tion­nel. Ce langage est com­plè­te­ment dynamique, ce qui signifie qu’aucune dis­tinc­tion n’est opérée entre « compile time » et « run time ». Lua s’appuie uni­que­ment sur une gestion dynamique de la mémoire : la taille d’un objet dans la mémoire peut évoluer au cours du processus. Un « Garbage Collector » (GC) libère l’espace disque qui n’est plus né­ces­saire de façon à épargner cette tâche au pro­gram­meur.

Apprendre à utiliser les com­men­taires dans les scripts Lua

Les com­men­taires sont des éléments es­sen­tiels dans tous les langages de pro­gram­ma­tion. Ils sont notamment utilisés pour :

• esquisser les éléments de code,
• do­cu­men­ter les fonc­tion­na­li­tés du code,
• activer/dé­sac­ti­ver les lignes de code.

En Lua, un com­men­taire d’une ligne commence avec un double tiret (--) et se poursuit jusqu’à la fin de la ligne :

-- cette ligne sera ignorée par l’interpréteur

En les combinant avec des doubles crochets « [[ » et « ]] », il est également possible d’écrire des com­men­taires multiples :

--[[ Ce commentaire s’étend sur plusieurs lignes. ]]

Valeurs et types pour le tutoriel Lua

À l’instar de la plupart des autres langages de script, Lua est également un langage dynamique stan­dar­disé. Les types ne relèvent pas des variables mais des valeurs. Chaque valeur dispose pré­ci­sé­ment d’un type, qu’il s’agisse d’un nombre, d’une séquence de ca­rac­tères, d’une valeur logique, etc. Au total, Lua dispose d’un nombre de types gérable. Ils sont résumés dans l’aperçu suivant :

Type	Ex­pli­ca­tion
number	Nombre décimal
string	Séquence de ca­rac­tères
boolean	Valeur logique : « true » ou « false »
nil	Valeur non dis­po­nible ; le type a uni­que­ment la valeur « nil »
function	Fonction
table	Type de données composé : liste/Array, Hash/Dic­tio­nary
thread	Co­rou­tines
userdata	Type de données C défini par l’uti­li­sa­teur

Lua connaît la syntaxe littérale pour les valeurs de tous les types à l’exception de « thread » et « userdata ». Pour dé­ter­mi­ner le type d’une valeur, on utilise la fonction « type() ». Cette fonction indique le nom du type sous forme de chaîne de ca­rac­tères. Voici quelques exemples :

type(42) -- Le type est `number` type("Tutoriel Lua") -- Le type est `string` type(false) -- Le type est `boolean` type(var) -- Le type est `nil`, puisque `var` n’est pas défini Note

Veuillez noter que dans les exemples de code suivants le premier élément d’une liste en Lua a l’index 1 au lieu de 0, comme dans la plupart des langages !

Apprendre à pro­gram­mer avec Lua : ex­pres­sions, variables et opé­ra­teurs

Une ex­pres­sion est évaluée par l’in­ter­pré­teur et fournit une valeur. Les ex­pres­sions associent des littéraux, des opé­ra­teurs, des variables et des appels de fonctions. Les ex­pres­sions peuvent également être groupées avec des pa­ren­thèses « () ». En tant que langage dynamique, Lua détermine au­to­ma­ti­que­ment le type de la valeur fournie. Voici plusieurs exemples d’ex­pres­sions :

-- Opération arithmétique dans Lua 1 + 2 -- évalué en tant que la valeur `3` -- Concaténation de chaînes de caractères dans Lua 'Walther' .. 'White' -- évalué comme `WaltherWhite` -- Concaténation de chaînes de caractères avec conversion automatique d’un chiffre dans Lua 'Les ' .. 3 .. ' mousquetaires' -- évalué comme `Les 3 mousquetaires` -- Test d’équivalence dans Lua 7 == '7' -- évaluer comme `false` -- Test d’équivalence dans Lua 'petit' == string.lower('PETIT') -- évalué comme `true` -- information de type dynamique type(var) == 'nil' -- évalué comme `true`, puisque `var` n’est pas défini

Une variable est un nom pour une valeur dans la mémoire. Comme dans la plupart des langages de pro­gram­ma­tion, en Lua, un nom commence avec une lettre ou un tiret bas (_) suivi par d’autres lettres, tirets ou chiffres. Dans ce cas, on opère une dis­tinc­tion stricte entre les ma­jus­cules et les mi­nus­cules. Les mots réservés ci-dessous ne peuvent pas être utilisés seuls comme nom :

« and », « end », « in », « repeat », « break », « false », « local », « return », « do », « for », « nil », « then », « else », « function », « not », « true », « elseif », « if », « or », « until », « while »

Toutefois, ces mots réservés peuvent tout à fait être utilisés comme partie d’un nom :

for = "Peter" -- provoque une erreur for_user = "Peter" -- est autorisé

L’at­tri­bu­tion d’une valeur à une variable est effectuée à l’aide de l’opérateur d’at­tri­bu­tion (=). Celui-ci ne doit pas être confondu avec l’opérateur logique d’équi­va­lence (==). Lors de l’at­tri­bu­tion, on opère comme d’habitude une dis­tinc­tion entre « L-value » et « R-value » : la variable doit se trouver à gauche de l’opérateur d’at­tri­bu­tion, il s’agit de la L-value. Cette variable est attribuée à la valeur évaluée de la R-value située à droite :

nombre = 13 -- correct 13 = nombre -- provoque une erreur puisque le nombre 13 ne peut pas se voir attribuer de nouvelle valeur

Un opérateur génère une nouvelle valeur à partir d’une ou plusieurs opérande(s). On parle alors d’opérateur unaire (à un chiffre) ou binaire (à deux chiffres). Un opérateur associe les opérandes d’un type donné et fournit une valeur d’un certain type. Jetons un œil aux dif­fé­rents opé­ra­teurs en Lua.

Les opé­ra­teurs arith­mé­tiques opèrent sur des nombres et donnent un nombre :

Opérateur arith­mé­tique	Arité	Opération
+	binaire	Addition
-	binaire	Sous­trac­tion
*	binaire	Mul­ti­pli­ca­tion
/	binaire	Division
%	binaire	Modulo
^	binaire	Ex­po­nen­tia­tion
-	unaire	Négation

Tous les opé­ra­teurs re­la­tion­nels sont binaires et testent la façon dont deux opé­ra­teurs se com­por­tent l’un par rapport à l’autre. Ils donnent une valeur logique :

Opérateur re­la­tion­nel	Test
==	Équi­va­lence
~=	Dif­fé­rence
>	Supérieur à
<	Inférieur à
>=	Supérieur ou égal à
<=	Inférieur ou égal à

Les opé­ra­teurs logiques associent des valeurs logiques et donnent une nouvelle valeur logique :

Opérateur logique	Arité	Opération
and	binaire	as­so­cia­tion ET
or	binaire	as­so­cia­tion OU
not	unaire	Négation

Il existe deux autres opé­ra­teurs spé­ci­fiques en Lua. Ils servent à la con­ca­té­na­tion de chaînes de ca­rac­tères (c’est-à-dire à leur en­chaî­ne­ment) ainsi qu’à la dé­ter­mi­na­tion de la puissance d’une valeur composée comme une table ou une chaîne de ca­rac­tères :

Opérateur	Arité	Opération
..	binaire	Con­ca­té­na­tion de chaînes de ca­rac­tères
#	unaire	Dé­ter­mi­ner le nombre d’éléments d’une table/la longueur d’une chaîne de ca­rac­tères

Con­trai­re­ment à de nombreux langages de script, Lua ne reconnaît pas les opé­ra­teurs d’at­tri­bu­tion composés comme « += » et « -= ». Pour in­cré­men­ter et dé­cré­men­ter des variables, l’opération doit être écrite de façon explicite :

prix = 42,99 remise = 0,15 -- 15 % de remise prix -= prix * remise -- `-=` ne fonctionne pas dans Lua -- La décrémentation doit être écrite de façon explicite prix = prix - (prix * remise)

Com­prendre les portées et les blocs pour le tutoriel Lua

Le concept de portée est un concept central dans tous les langages de pro­gram­ma­tion. Une variable n’existe que dans une certaine portée lexicale. Comme en Ja­vaS­cript, en Lua, les variables sont globales par défaut. Toutefois, l’uti­li­sa­tion gé­né­ra­li­sée de variables globales est connue comme un « anti-modèle » qu’il convient d’éviter. En Lua, le mot-clé « local » fournit une solution. Il permet de limiter la portée d’une variable au bloc englobant, de façon similaire à la dé­cla­ra­tion via « let » dans Ja­vaS­cript.

-- cette variable est globale x = 5 -- définir une variable locale local z = 10

En Lua, les corps des fonctions et des boucles ouvrent une nouvelle portée. D’autre part, le Lua utilise le concept du bloc explicite. Un bloc définit une nouvelle portée pour le code situé entre les mots-clés « do » et « end ». Dans Java/C/C++, cela cor­res­pond aux accolades ouvrantes/fermantes « { » et « } ». L’exemple de code suivant illustre la manière dont les blocs, les portées et les variables fonc­tion­nent ensemble :

-- portée externe do local x = 1 do -- portée interne local y = 2 -- générer `z` dans la portée globale -- dans ce cadre, accès à la variable locale `x` de la portée externe -- et variable locale `y` de la portée interne z = x + y -- `z` a maintenant la valeur `3` end print(x) -- donne `1` print(y) -- donne `nil` puisque `y` n’existe pas dans la portée externe print(z) -- donne `3` end -- `z` est global et existe également en dehors de la portée externe z = z + 4 print(z) -- donne `7`

Apprendre à pro­gram­mer en Lua avec les struc­tures de contrôle

Le Lua connaît les struc­tures de contrôle ha­bi­tuelles que l’on retrouve dans d’autres langages de pro­gram­ma­tion. Ces struc­tures incluent les boucles et les ra­mi­fi­ca­tions. Voici un exemple d’ins­truc­tions « if », « then », « else », « elseif » pour Lua :

limit = 42; nombre = 43; if nombre < limit then print("En-dessous de la limite.") elseif nombre == limit then print("Précisément à la limite…") else print("Au-dessus de la limite !") end

Outre la boucle « while » classique, le Lua connaît également sa con­tre­par­tie « repeat »-« until ». Cette ins­truc­tion existe également dans Ruby. Elle exige l’inversion de la condition utilisée. Cela signifie qu’un « while » avec la condition « nombre </= limit » cor­res­pond à un « repeat »-« until » avec la condition « nombre > limit ». Attention avec l’ins­truc­tion « repeat » ! Quelle que soit la condition, le corps de la boucle est exécuté au minimum une fois. Voici un exemple :

limit = 10 nombre = 1 while nombre <= limit do print("nombre:", nombre) nombre = nombre + 1 end -- Attention : bien que `nombre` soit déjà supérieur à `limit`, -- le corps de la boucle est exécuté une fois nombre = 11 repeat print("nombre:", nombre) nombre = nombre + 1 until nombre > limit

À l’instar de la plupart des langages de pro­gram­ma­tion im­pé­ra­tifs, le Lua connaît également l’ins­truc­tion « for » en plus de la boucle « while ». Deux formes sont utilisées ici : une variante similaire à C avec une variable de boucle ainsi qu’une variante avec itérateur. Regardons tout d’abord l’uti­li­sa­tion de l’ins­truc­tion « for » avec la variable de boucle :

début = 1 fin = 10 for nombre = début, fin do print("Nombre actuel :", nombre) -- `1,2,3,4,5,6,7,8,9,10` end -- définir explicitement l’étape sur `2` étape = 2 for nombre = début, fin, étape do print("Nombre actuel :", nombre) -- `1,3,5,7,9` end -- l’étape peut être négative étape = -2 -- permuter le début et la fin avec une étape négative, pour compter de façon décroissante for nombre = fin, début, étape do print("Nombre actuel :", nombre) -- `10,8,6,4,2` end

De façon sur­pre­nante, la variable de boucle définie dans la boucle « for » est locale et non globale, sans qu’il soit pour autant né­ces­saire de la déclarer ex­pli­ci­te­ment comme « locale ». C’est logique et, à cet égard, le Lua se démarque po­si­ti­ve­ment du Ja­vaS­cript. En Ja­vaS­cript, une variable de boucle déclarée sans « let » ou « var » est globale, ce qui peut entraîner des erreurs sérieuses.

Regardons à présent la boucle « for » avec un itérateur en Lua. Sur le principe, l’approche ressemble à celle de Python : au lieu d’in­cré­men­ter une variable de boucle et de l’utiliser comme index dans une liste, nous itérons di­rec­te­ment via les éléments de la liste. Pour générer l’itérateur, on utilise souvent la fonction « ipairs() ». Voici un exemple :

-- Définir une liste d’années décennies = {1910, 1920, 1930, 1940, 1950, 1960, 1970, 1980, 1990} -- accéder aux années individuelles à l’aide d’un itérateur for index, année in ipairs(décennies) do print(index, année) end

Fonctions : en apprendre plus avec Lua

De la même façon qu’en C/C++, Java et Ja­vaS­cript, les fonctions sont définies avec le mot-clé « function ». Comme à l’ac­cou­tu­mée, les noms des fonctions sont suivis de leurs pa­ra­mètres entre pa­ren­thèses. La par­ti­cu­la­rité du Lua réside dans le fait qu’en cas d’appel d’une fonction avec pré­ci­sé­ment un littéral comme argument, il est possible d’omettre les pa­ren­thèses. En Lua, une fonction ne doit pas im­pé­ra­ti­ve­ment donner une valeur. Par dé­fi­ni­tion, une fonction sans valeur est une « procédure » :

-- Définir la procédure function bonjour(nom) print("Bonjour", nom) end -- Appeler la fonction bonjour("très cher monsieur") -- l’écriture suivante est également possible bonjour "très cher monsieur" -- toutefois, la syntaxe suivante ne fonctionne pas nom = "Walther" bonjour nom -- erreur de syntaxe -- avec une variable à la place d’un littéral, la fonction doit être appelée avec des parenthèses bonjour(nom)

Si l’on souhaite obtenir une valeur à partir d’une fonction, il convient d’utiliser le mot-clé « return » comme à l’ac­cou­tu­mée. Ce mot-clé met fin à l’exécution de la fonction et donne la valeur indiquée. Dans l’exemple de code suivant, un chiffre est mis au carré :

-- Fonction avec une valeur de retour unique function carré(nombre) -- l’expression `nombre * nombre` est évaluée -- et sa valeur est obtenue return nombre * nombre end -- Mettre un nombre au carré print(carré(9)) -- `81`

Comme en Python et en Ja­vaS­cript, en Lua, une fonction peut recevoir un nombre variable d’arguments. Les arguments sont en­re­gis­trés dans une cons­truc­tion spéciale « (...) ». Pour accéder aux arguments, il est souvent utile de les ras­sem­bler dans une liste avec l’ex­pres­sion « {...} ». Il est également possible d’utiliser la fonction « select() » qui extrait un argument sous l’index indiqué. Le nombre d’arguments est déterminé avec l’ex­pres­sion « #{...} ».

-- imprimer tous les arguments d’une fonction function var_args(...) for index, arg in ipairs({...}) do print(index, arg) end end var_args('Peter', 42, true)

Outre un nombre variable d’arguments, le Lua permet également de fournir plusieurs valeurs avec une ins­truc­tion « return ». Le processus fonc­tionne à peu de chose près comme en Python, toutefois sans le type explicite « Tupel ». Comme en Python, il est fréquent d’attribuer plusieurs variables à la valeur de retour en cas d’appel de fonction. Voici un exemple :

-- Fonction avec plusieurs valeurs de retour function premier_et_dernier(liste) -- fournit le premier et le dernier élément de la liste -- chaque valeur de retour est séparée par une virgule `,` return liste[1], liste[#liste] end personnes = {"Jim", "Jack", "John"} -- Attribution des valeurs de retour à plusieurs variables premier, dernier = premier_et_dernier(personne) print("Le premier est", premier) print("Le dernier est", dernier)

Si l’une des valeurs de retour n’est pas né­ces­saire, selon une con­ven­tion usuelle, on utilise le tiret bas (_) comme balise, comme dans l’exemple suivant :

function min_moyenne_max(...) -- définir les valeurs de début pour `min` et `max` sur le premier argument local min = select(1, ...) local max = select(1, ...) -- Définir la valeur médiane sur zéro au début local moyenne = 0 -- itérer sur les chiffres -- nous n’avons pas besoin de la variable index -- nous utilisons `_` en tant que balise for _, nombre in ipairs({...}) do -- définir un nouveau minimum le cas échéant if min > nombre then min = nombre end -- définir un nouveau maximum le cas échéant if max < nombre then max = nombre end -- additionner des chiffres pour la moyenne moyenne = moyenne + nombre end -- diviser la somme des nombres par leur nombre moyenne = moyenne / #{...} return min, moyenne, max end -- ici, nous n’avons pas besoin de la valeur `moyenne` -- nous utilisons `_` en tant que balise min, _, max = min_moyenne_max(78, 34, 91, 7, 28) print("Le minimum et le maximum des nombres sont", min, max)

En Lua, les fonctions sont des « first-class citizens ». Cela signifie qu’elles peuvent être rat­ta­chées à des variables et peuvent également être trans­mises à d’autres fonctions comme arguments. D’autre part, une fonction peut servir de valeur de retour d’une fonction. Pris dans son ensemble, le Lua permet donc une pro­gram­ma­tion fonc­tion­nelle, illustrée ici par l’exemple de la célèbre fonction « map() » :

-- fonction `map()` en Lua -- reçoit une fonction `f` et une liste comme arguments function map(f, liste) -- créer une nouvelle liste pour les valeurs de sortie local _liste = {} -- itérer sur les éléments de la liste avec index for index, valeur in ipairs(liste) do -- utiliser la fonction `f()` sur la valeur actuelle de la liste -- et enregistrer la valeur de retour dans la nouvelle liste sur le même index _liste[index] = f(valeur) end -- retourner une nouvelle liste return _liste end -- Liste de chiffres nombres = {3, 4, 5} -- Fonction appliquée à tous les éléments de la liste function carré(nombre) return nombre * nombre end -- génération des carrés via la fonction `map()` carrés = map(carré, nombres) -- `{9, 16, 25}` -- obtenir les carrés for _, nombre in ipairs(carrés) do print(nombre) end

En pro­gram­ma­tion fonc­tion­nelle, on utilise souvent la ré­cur­si­vité qui fait qu’une fonction s’appelle sans cesse elle-même avec des arguments modifiés. Dans le cas du Lua, il convient de faire preuve d’une attention par­ti­cu­lière à cet égard. Les fonctions appelées de façon récursive doivent être ex­pli­ci­te­ment déclarées comme « local ».

function f() -- appel récursif f() -- renvoie le cas échéant à une variable globale `f` end -- à la place local function f() -- appel récursif f() -- renvoie à la fonction englobante end -- équivalente à local f; -- Déclarer explicitement la variable `f` comme `local` f = function() -- Attribution de la fonction à la variable locale `f` f() -- renvoie de façon garantie à la fonction englobante end Tags associés

• Tutoriels

Aller au menu principal

Produits associés

Créer un site Internet Voir les packs

Tout savoir sur l’IA

Inscrivez-vous à notre news­let­ter pour découvrir les dernières tendances de l’IA et recevoir des conseils pratiques.

Je m’inscris

Tout savoir sur l’IA

Close

Inscrivez-vous à notre news­let­ter pour découvrir les dernières tendances de l’IA et recevoir des conseils pratiques.

Articles Po­pu­laires

Revente de nom de domaine : comment gagner de l’argent avec les noms de domaines ?

Acheter et vendre des noms de domaines peut être lucratif, à condition toutefois de savoir…

Lire la suite

5 al­ter­na­tives à Nextcloud en com­pa­rai­son directe

À la recherche d’une al­ter­na­tive à Nextcloud per­for­mante ? Découvrez les meil­leures…

Lire la suite

Com­pa­rai­son des 7 meilleurs services de sau­ve­garde en ligne

Sau­ve­gar­dez vos données de manière fiable dans le Cloud ! Vos données sont en sécurité…

Lire la suite

Debian 13 Upgrade : comment mettre à niveau vers Debian 13 étape par étape ?

Ce guide vous aide à mettre à niveau Debian 13 en toute sécurité, à préparer votre système…

Lire la suite

4 al­ter­na­tives gratuites à Adobe InDesign

La pu­bli­ca­tion assistée par or­di­na­teur (PAO) avec Adobe est trop chère ? Il existe des…

Lire la suite

Articles si­mi­laires

Billion PhotosShut­ters­tock

Tutoriel DART : les premiers pas

Ce tutoriel sur DART vous permet d’acquérir les bases de la pro­gram­ma­tion avec DART. Si vous maîtrisez déjà d’autres langages de pro­gram­ma­tion, vous re­mar­que­rez que DART se concentre sur une syntaxe simple et claire afin d’éviter certaines fai­blesses fon­da­men­tales de Ja­vaS­cript.…

Lire la suite BEST-BACK­GROUNDSShut­ters­tock

Apprendre les bases de la pro­gram­ma­tion

Bienvenue dans l’ère digitale : les uti­li­sa­teurs passent en moyenne plusieurs heures devant un or­di­na­teur ou un smart­phone chaque jour. Pourtant, peu de gens savent comment fonc­tion­nent ces pro­grammes qu’ils utilisent tous les jours. Il est de plus en plus simple d’apprendre la…

• HTML
• CSS
• Ja­vaS­cript
• HTTP
• Tutoriels

Lire la suite Ground PictureShut­ters­tock

Tutoriel Flutter : dé­ve­lop­per des ap­pli­ca­tions avec le SDK de Google

Au cours des dernières années, Google a publié sur le marché de nombreux services utiles comme Gmail, Maps ou Google Workspace, mais aussi dif­fé­rents outils pour la pro­gram­ma­tion de logiciels. L’un de ces outils est le SDK Flutter, par­ti­cu­liè­re­ment in­té­res­sant pour les…

• Tutoriels

Lire la suite hash_bb76f0ceaa177e5753a7035575cfa0f087734722