Cours complet de programmation Lua en PDF


Télécharger Cours complet de programmation Lua en PDF

★★★★★★★★★★3.5 étoiles sur 5 basé sur 1 votes.
Votez ce document:

Télécharger aussi :


Cours complet de programmation Lua [Eng]

... .... ...

[Extrait]

Commencer

Pour rester fidèle à la tradition, notre premier programme en Lua imprime juste "Hello World": print ("Hello World")

Si vous utilisez l'interpréteur Lua autonome, tout ce que vous avez à faire pour exécuter votre premier programme est d'appeler l'interprète appelé habituellement lua avec le nom du fichier texte qui contient votre programme. Si vous écrivez le programme ci-dessus dans un fichier hello.lua, la commande suivante doit l'exécuter:

% lua hello.lua

Comme exemple plus complexe, le programme suivant définit une fonction pour calculer la factorielle d'un nombre donné, puis demande à l'utilisateur un nombre et imprime sa factorielle:

- définit une fonction factorielle

fait de fonction (n)

si n == 0 alors

retour 1

autre

retour n * fait (n-1)

fin

fin

print ("entrez un nombre:")

a = io.read ("* number") - lire un nombre

imprimer (fait (a))

Si vous utilisez Lua dans une application, comme CGILua ou IUPLua, vous devrez peut-être vous référer au manuel d'application (ou à un «gourou local») pour apprendre à exécuter vos programmes. . Néanmoins, Lua est toujours la même langue; La plupart des choses que nous verrons ici sont valides, peu importe comment vous utilisez Lua. Je vous recommande de commencer votre étude de Lua en utilisant l'interpréteur autonome (lua) pour exécuter vos premiers exemples et expériences.

1.1 morceaux

Chaque morceau de code exécuté par Lua, tel qu'un fichier ou une ligne unique en mode interactif, est appelé un morceau. Un morceau est simplement une séquence de commandes (ou d'instructions).

Lua n'a pas besoin de séparateur entre les déclarations consécutives, mais vous pouvez utiliser un point-virgule si vous le souhaitez. Ma convention personnelle est d'utiliser des points-virgules uniquement pour séparer deux ou plusieurs énoncés écrits dans la même ligne. Les sauts de ligne ne jouent aucun rôle dans la syntaxe de Luaâ € ™; par exemple, les quatre morceaux suivants sont tous valides et équivalents:

a = 1

b = a * 2

a = 1;

b = a * 2;

a = 1; b = a * 2

a = 1 b = a * 2 - laid, mais valide

Un morceau peut être aussi simple qu'une seule déclaration, comme dans l'exemple «Hello World», ou il peut être composé d'une combinaison d'instructions et de définitions de fonctions (qui sont en réalité des affectations, comme nous verrons plus tard), comme l'exemple factoriel. Un morceau peut être aussi grand que vous le souhaitez. Parce que Lua est également utilisé comme langage de description de données, les morceaux de plusieurs mégaoctets ne sont pas rares. L'interprète Lua n'a aucun problème avec de gros morceaux.

Au lieu d'écrire votre programme dans un fichier, vous pouvez exécuter l'interpréteur autonome en mode interactif. Si vous appelez lua sans aucun argument, vous obtiendrez son invite:

...

Par la suite, chaque commande que vous tapez (comme l'impression "Hello World") s'exécute immédiatement après l'avoir saisie. Pour quitter le mode interactif et l'interpréteur, il suffit de taper le caractère de contrôle de fin de fichier (ctrl-D dans Unix, ctrl-Z sous DOS / Windows), ou d'appeler la fonction de sortie, depuis la bibliothèque du système d'exploitation , ¬ vous devez taper os.exit ().

En mode interactif, Lua interprète généralement chaque ligne que vous tapez comme un bloc complet. Cependant, s'il détecte que la ligne ne forme pas un bloc, il attend plus d'entrée, jusqu'à ce qu'il ait un morceau complet. De cette façon, vous pouvez entrer une définition multiligne, telle que la fonction factorielle, directement en mode interactif. Cependant, il est généralement plus pratique de placer ces définitions dans un fichier, puis d'appeler Lua pour exécuter ce fichier.

Vous pouvez utiliser l'option -i pour indiquer à Lua de démarrer une session interactive après avoir exécuté le bloc donné. Une ligne de commande comme

% lua -i prog

va exécuter le morceau dans le fichier prog et vous invite à l'interaction. Ceci est particulièrement utile pour le débogage et les tests manuels. À la fin de ce chapitre, nous verrons d'autres options pour l'interpréteur autonome.

Une autre façon d'exécuter des morceaux est avec la fonction dofile, qui exécute immédiatement un fichier. Par exemple, supposons que vous ayez un fichier lib1.lua avec le code suivant:

retour de la fonction (x, y) (x "2 + y" 2) "0.5 fin

fonction deux fois (x) retour 2 * x fin

Ensuite, en mode interactif, vous pouvez taper

> dofile ("lib1.lua") - charger votre bibliothèque

> n = norme (3,4, 1,0)

> print (deux fois (n)) -> 7.0880180586677

La fonction dofile est également utile lorsque vous testez un code. Vous pouvez travailler avec deux fenêtres: l'une est un éditeur de texte avec votre programme (dans un fichier prog.lua, disons) et l'autre est une console exécutant Lua en mode interactif. Après avoir enregistré une modification dans votre programme, vous exécutez dofile ("prog.lua") dans la console Lua pour charger le nouveau code; alors vous pouvez exercer le nouveau code, en appelant ses fonctions et en imprimant les résultats.

1.2 Quelques conventions lexicales

Les identificateurs dans Lua peuvent être n'importe quelle chaîne de lettres, de chiffres et de traits de soulignement, ne commençant pas par un chiffre; par exemple

je j i10 _ij

aSomewhatLongName _INPUT

Vous devez éviter les identificateurs commençant par un trait de soulignement suivi d'une ou plusieurs lettres majuscules (par exemple, _VERSION); ils sont réservés pour des utilisations spéciales à Lua. Habituellement, je réserve l'identifiant _ (un seul trait de soulignement) pour les variables factices.

Dans Lua, le concept de ce qu'est une lettre dépend des paramètres régionaux. Avec une locale appropriée, vous pouvez utiliser des noms de variables tels que indice ou açࢠo. Cependant, de tels noms rendront votre programme impropre à fonctionner sur des systèmes qui ne prennent pas en charge cette locale.

Les mots suivants sont réservés; nous ne pouvons pas les utiliser comme identifiants:

et casser autrement elseif

fin faux pour la fonction si

en local nul ou

répéter le retour puis vrai jusqu'à

tandis que

Lua est sensible à la casse: et est un mot réservé, mais And et AND sont deux autres identifiants différents.

Un commentaire commence n'importe où avec un double trait d'union (-) et s'exécute jusqu'à la fin de la ligne. Lua propose également des commentaires de bloc, qui commencent par - [[et s'exécutent jusqu'au prochain]]. 1 Une astuce courante, quand on veut commenter un morceau de code, est de placer le code entre - [[et - ]], comme ici:

- [[

print (10) - aucune action (commentaire)

-]]

Pour réactiver le code, nous ajoutons un seul trait d'union à la première ligne:

--- [[

impression (10) -> 10

-]]

Dans le premier exemple, le - dans la dernière ligne est toujours dans le commentaire de bloc. Dans le second exemple, la séquence --- [[commence un commentaire ordinaire, à une seule ligne, au lieu d'un commentaire de bloc. Ainsi, la première et la dernière ligne deviennent des commentaires indépendants. Dans ce cas, l'impression est en dehors des commentaires.



1.3 Variables globales

Les variables globales n'ont pas besoin de déclarations. Vous attribuez simplement une valeur à une variable globale pour la créer. Ce n'est pas une erreur d'accéder à une variable non initialisée; vous obtenez juste la valeur spéciale nil comme résultat:

imprimer (b) -> nul b = 10

imprimer (b) -> 10

Habituellement, vous n'avez pas besoin de supprimer les variables globales; Si votre variable va avoir une vie courte, vous devez utiliser une variable locale. Mais, si vous avez besoin de supprimer une variable globale, attribuez-lui simplement nil:

b = néant

imprimer (b) -> nul

Après cette affectation, Lua se comporte comme si la variable n'avait jamais été utilisée. En d'autres termes, une variable globale existe si (et seulement si) elle a une valeur non nulle.

En fait, les commentaires de bloc peuvent être plus complexes que cela, comme nous le verrons à la section 2.4.

1.4 L'interprète autonome

L'interpréteur autonome (aussi appelé lua.c en raison de son fichier source, ou simplement lua en raison de son exécutable) est un petit programme qui permet l'utilisation directe de Lua. Cette section présente ses principales options.

Lorsque l'interpréteur charge un fichier, il ignore sa première ligne si cette ligne commence par un signe de numéro (â € ¢ â € œâ € ¢). Cette fonctionnalité permet l'utilisation de Lua en tant qu'interprète de script dans les systèmes Unix. Si vous commencez votre script avec quelque chose comme

#! / usr / local / bin / lua

(en supposant que l'interpréteur autonome se trouve dans / usr / local / bin), ou #! / usr / bin / env lua

alors vous pouvez appeler le script directement, sans appeler explicitement l'interprète Lua.

L'utilisation de lua est

lua [options] [script [args]]

Tout est optionnel. Comme nous l'avons déjà vu, lorsque nous appelons lua sans arguments, l'interprète entre en mode interactif.

L'option -e nous permet d'entrer du code directement dans la ligne de commande, comme ici:

% lua -e "print (math.sin (12Ã" »-> -0.53657291800043

(Unix a besoin des guillemets pour empêcher le shell d'interpréter les parentheÃ,Âses.)

L'option -l charge une bibliothèque. Comme nous l'avons vu précédemment, -i entre en mode interactif après avoir exécuté les autres arguments. Ainsi, par exemple, l'appel

% lua -i -l a -e "x = 10"

va charger la bibliothèque, puis exécuter l'assignation x = 10, et enfin présenter une invite pour l'interaction.

Chaque fois que la variable globale _PROMPT est définie, lua utilise sa valeur comme invite lors de l'interaction. Ainsi, vous pouvez modifier l'invite avec un appel comme celui-ci:

% lua -i -e "_PROMPT = lua> lua> lua>

Nous supposons que "% â €" est l'invite de la shellâ € ™ s. Dans l'exemple, les guillemets externes empêchent le shell d'interpréter les guillemets internes, qui sont interprétés par Lua. Plus précisément, Lua reçoit la commande suivante pour s'exécuter:

_PROMPT = à ¢ â,¬â "¢ lua> à ¢ â,¬â" ¢

Cela assigne la chaîne «lua» à la variable globale _PROMPT.

En mode interactif, vous pouvez imprimer la valeur de n'importe quelle expression en écrivant une ligne commençant par un signe égal suivi de l'expression:

> = math.sin (3) -> 0.14112000805987

> a = 30

> = a -> 30

Cette fonctionnalité aide à utiliser Lua comme une calculatrice.

Avant d'exécuter ses arguments, lua recherche une variable d'environnement nommée LUA_INIT. S'il y a une telle variable et son contenu est @filename, alors lua exécute le fichier donné. Si LUA_INIT est défini mais ne commence pas par à ¢ â,¬Ëœ @ à ¢ â,¬Â ¢, alors Lua suppose qu'il contient du code Lua et l'exécute. LUA_INIT nous donne une grande puissance lors de la configuration de l'interpréteur autonome, car nous avons la pleine puissance de Lua dans la configuration. Nous pouvons pré-charger des paquets, modifier l'invite et le chemin, définir nos propres fonctions, renommer ou supprimer des fonctions, etc.

Un script peut récupérer ses arguments dans la variable globale arg. Dans un appel comme

% lua script a b c

lua crée l'argument table avec tous les arguments de la ligne de commande avant d'exécuter le script. Le nom du script va dans l'index 0; son premier argument (â € "aà ¢ â,¬ dans l'exemple), va à l'index 1, et ainsi de suite. Les options précédentes vont aux index négatifs, tels qu'ils apparaissent avant le script. Par exemple, dans l'appel

% lua -e "sin = math.sin" script a b lua recueille les arguments comme suit:

arg [-3] = "lua"

arg [-2] = "-e"

arg [-1] = "sin = math.sin"

arg [0] = "script"

arg [1] = "a"

arg [2] = "b"

Le plus souvent, le script n'utilise que les indices positifs (arg [1] et arg [2], dans l'exemple).

Dans Lua 5.1, un script peut également récupérer ses arguments via la syntaxe vararg. Dans le corps principal d'un script, l'expression ... (trois points) donne les arguments au script. Nous discuterons de la syntaxe vararg à la section 5.2.

2 types et valeurs

Lua est un langage dynamiquement typé. Il n'y a aucune définition de type dans la langue; chaque valeur porte son propre type.

Il existe huit types de base dans Lua: nil, booléen, nombre, chaîne, données utilisateur, fonction, thread et table. La fonction type donne le nom du type d'une valeur donnée:

print (tapez "Hello world")) -> string

print (type (10.4 * 3)) -> nombre

print (type (print)) -> fonction

print (type (type)) -> fonction

print (type (true)) -> booléen

impression (type (néant)) -> néant

print (type (type (X))) -> chaîne

La dernière ligne résultera en «chaîne», peu importe la valeur de X, car le résultat de type est toujours une chaîne.

Les variables n'ont pas de types prédéfinis; n'importe quelle variable peut contenir des valeurs de n'importe quel type:

print (type (a)) -> nil (aà ¢ â,¬â "¢ n'est pas initialisé)

a = 10

print (type (a)) -> numéro

a = "une chaîne !!"

print (type (a)) -> chaîne

a = print - oui, c'est valide!

a (type (a)) -> fonction

Notez les deux dernières lignes: les fonctions sont des valeurs de première classe dans Lua; Ainsi, nous pouvons les manipuler comme n'importe quelle autre valeur. (Plus d'informations sur cette fonctionnalité au chapitre 6.)

Habituellement, lorsque vous utilisez une seule variable pour différents types, le résultat est un code désordonné. Cependant, parfois l'utilisation judicieuse de cette facilité est utile, par exemple dans l'utilisation de zéro pour différencier une valeur de retour normale d'une condition anormale.

2,1 Nul

Nil est un type avec une seule valeur, nil, dont la propriété principale est d'être différente de toute autre valeur. Comme nous l'avons vu, une variable globale a une valeur nulle par défaut, avant sa première affectation, et vous pouvez assigner nil à une variable globale pour la supprimer. Lua utilise nil comme une sorte de non-valeur, pour représenter l'absence d'une valeur utile.



2.2 Booléens

Le type booléen a deux valeurs, false et true, qui représentent les valeurs booléennes tradi- tionnelles. Cependant, les booléens ne détiennent pas le monopole des valeurs de condition: dans Lua, n'importe quelle valeur peut représenter une condition. Les conditions (telles que celles dans les structures de contrôle) considèrent à la fois faux et nul comme faux et toute autre chose comme vraie. Prenez garde, contrairement à d'autres langages de script, Lua considère que zéro et la chaîne vide sont vrais dans les tests conditionnels.

2.3 Numéros

Le type de nombre représente les nombres réels (en virgule flottante double précision). Lua n'a pas de type entier, car il n'en a pas besoin. Il y a une idée fausse répandue à propos des erreurs arithmétiques en virgule flottante; certaines personnes craignent que même un simple incrément puisse devenir bizarre avec des nombres à virgule flottante. Le fait est que, lorsque vous utilisez un double pour représenter un entier, il n'y a pas d'erreur d'arrondi (sauf si le nombre est supérieur à 1014). Plus précisément, un nombre Lua peut représenter n'importe quel nombre entier de 32 bits sans arrondir les problèmes. De plus, la plupart des processeurs modernes font de l'arithmétique en virgule flottante aussi vite que (ou même plus vite que) l'arithmétique entière.

Néanmoins, il est facile de compiler Lua pour qu'il utilise un autre type de nombres, tels que les nombres longs ou les nombres flottants simples. Ceci est particulièrement utile pour les plates-formes sans support matériel pour virgule flottante. Voir le fichier luaconf.h dans la distribution pour des instructions détaillées.

Nous pouvons écrire des constantes numériques avec une partie décimale optionnelle, plus un exposant décimal optionnel. Des exemples de constantes numériques valides sont:

4 0,4 ​​4,57e-3 0,3e12 5e + 20

2.4 Chaînes

Les chaînes de Lua ont la signification habituelle: une séquence de caractères. Lua est propre à huit bits et ses chaînes peuvent contenir des caractères avec n'importe quel code numérique, y compris les zéros incorporés. Cela signifie que vous pouvez stocker des données binaires dans une chaîne.

Les chaînes de Lua sont des valeurs immuables. Vous ne pouvez pas changer un caractère à l'intérieur d'une chaîne, comme vous le pouvez en C; à la place, vous créez une nouvelle chaîne avec les modifications souhaitées, comme dans l'exemple suivant:

a = "une chaîne"

b = string.gsub (a, "un", "autre") - change les parties de la chaine

print (a) -> une chaîne

print (b) -> une autre chaîne

Les chaînes de Lua sont soumises à une gestion automatique de la mémoire, comme tous les autres objets Lua (tables, fonctions, etc.). Cela signifie que vous n'avez pas à vous soucier de l'allocation et de la désallocation des chaînes; Lua s'occupe de ça pour toi. Une chaîne peut contenir une seule lettre ou un livre entier. Lua manipule les longues ficelles assez efficacement. Les programmes qui manipulent des chaînes avec des caractères 100K ou 1M ne sont pas inhabituels dans Lua.

Nous pouvons délimiter les chaînes littérales en faisant correspondre des guillemets simples ou doubles:

a = "une ligne"

b = à ¢ â,¬Â "¢ une autre ligneà ¢ â,¬â" ¢

En termes de style, vous devez toujours utiliser le même type de guillemets (simple ou double) dans un programme, sauf si la chaîne elle-même a des guillemets; alors vous utilisez l'autre citation, ou échappez à ces citations avec des antislashs. Les chaînes dans Lua peuvent contenir les séquences d'échappement de type C suivantes:

\une cloche

\ b retour de l'espace

\ f flux de formulaire

\ n newline

\ r retour chariot

\ t onglet horizontal

\ v l'onglet vertical

\\ antislash

\" double citation

\ à ¢ â,¬â "¢ guillemet simple

Les exemples suivants illustrent leur utilisation:

> print ("une ligne \ nnext line \ n \" entre guillemets \ ", ã ¢ â ¢" ¢ "¢" ¢ ") une ligne suivante" entre guillemets ", â ¢, ¬ "dans les devisâ € ™

> imprimer (une barre oblique inversée entre guillemets): une barre oblique inversée entre guillemets: à ¢ â,¬Â "¢ \ à ¢ â,¬Â ¢ ¢

> print ("un moyen plus simple:") "" un moyen plus simple: "¢"

Nous pouvons spécifier un caractère dans une chaîne aussi par sa valeur numérique à travers la séquence d'échappement \ ddd, où ddd est une séquence de jusqu'à trois chiffres décimaux. Comme un exemple assez complexe, les deux littéraux "alo \ n123 \" "et â €" 97lo \ 10 \ 04923 "â €" ont la même valeur, dans un système utilisant ASCII : 97 est le code ASCII pour à ¢ â,¬Ã ¢ â ¢ ¢ â,¬Â ¢, 10 est le code pour newline, et 49 est le code pour le chiffre  ¢ â,¬Ëœ1 â € ¢. (Dans cet exemple, nous devons écrire 49 avec trois chiffres, comme \ 049, car il est suivi d'un autre chiffre, sinon Lua lirait le nombre comme 492.)

Nous pouvons également délimiter des chaînes littérales en faisant correspondre de doubles crochets, comme nous le faisons avec de longs commentaires. Les littéraux de cette forme entre crochets peuvent s'exécuter sur plusieurs lignes et n'interprètent pas les séquences d'échappement. De plus, cette forme ignore le premier caractère de la chaîne lorsque ce caractère est un saut de ligne. Ce formulaire est particulièrement pratique pour écrire des chaînes contenant des morceaux de programme, comme dans l'exemple suivant:

page = [[

 

<tête>

Une page HTML

 

 

...

 

 

]]

écrire (page)

Parfois, vous pouvez inclure un morceau de code contenant quelque chose comme a = b [c [i]] (notez le]] dans ce code). Ou vous pourriez avoir besoin de joindre du code qui contient déjà du code. Pour gérer ces cas, vous pouvez ajouter n'importe quel nombre de signes égaux entre les deux parenthèses ouvertes, comme dans [=== [. 2 Après ce changement, la chaîne littérale se termine uniquement aux parenthèses fermantes suivantes avec le même nombre de signes égaux dans entre (] ===], dans notre exemple). Les paires de parenthèses avec un nombre différent de signes égaux sont simplement ignorées. En choisissant un nombre approprié de signes, vous pouvez entourer n'importe quelle chaîne littérale sans avoir à y ajouter des fuites.

Cette même installation est également valable pour les commentaires. Par exemple, si vous commencez un long commentaire avec - [= [, il s'étend jusqu'au prochain] =]. Cette fonctionnalité vous permet de commenter facilement un morceau de code contenant des parties déjà commentées.

Lua fournit des conversions automatiques entre les nombres et les chaînes au moment de l'exécution. Toute opération numérique appliquée à une chaîne tente de convertir la chaîne en un nombre:

2Cette installation est nouvelle dans Lua 5.1.



1053