Transcription
1. Introduction: Bienvenue dans le cours d'introduction
à la programmation Lua. L'objectif de ce cours est de passer en revue les bases de la programmation, ainsi que les
bases de l'utilisation de Lua Si vous n'avez jamais
programmé auparavant, ce cours sera
parfait pour
vous faire une première idée
de ce qu'est le
codage et apprendre tous les
concepts utilisés dans tous les langages de
programmation. Si vous avez déjà
une certaine expérience du codage, vous apprendrez très rapidement les
bases de Lua Les vidéos sur les tables sont
cependant à regarder absolument. C'est ce qui distingue vraiment
Lua des autres langues. À la fin du cours, un projet
vous sera attribué, ce qui sera une excellente
occasion pour vous d'
expérimenter le langage
et de créer quelque chose de cool. Commencer à utiliser
Lua est très simple. Je vais suivre chaque
leçon uniquement dans un navigateur Web. Si vous allez sur ua.org, vous pouvez accéder à ce lien de
téléchargement, vous pouvez accéder à ce lien de
téléchargement,
accéder à la démo en direct, et vous
pouvez choisir parmi plusieurs
sites différents vous
pouvez choisir parmi plusieurs
sites Chacun d'entre eux comporte une
petite section de
texte qui
vous permet d'écrire du code Lua, et vous pouvez l'exécuter
directement dans le navigateur Une fois que tout est prêt, passez
à la leçon suivante, où nous allons écrire notre
premier bit de code Lua
2. Variables: La toute première chose
dont nous allons parler concerne les variables. Une variable est une donnée stockée dont
la valeur peut être modifiée. Pour le démontrer, allons-y et
ajoutons-en un dans notre code. En haut du
fichier, je vais écrire un message égal, puis entre
guillemets, Lua est génial Dans cette ligne, nous venons de
créer une variable. Le nom de la variable est message, et la valeur que
contient cette variable est le texte
Lua is awesome Maintenant, pour nous assurer que
nous l'avons fait correctement, imprimons la valeur
de cette variable. Donc, en version imprimée, au lieu
de Hello World, allons-y et
passons le message. Donc, celui que nous publierons, nous verrons que
le texte Lua est génial. Il va simplement
récupérer la valeur que contient
cette variable. Et toutes sortes de
données peuvent être stockées. Dans ce cas, il stocke du texte. Et en programmation, un texte comme
celui-ci s'appelle une chaîne de caractères. Une chaîne n'est composée que de quelques mots ou lettres entourés de
guillemets comme celui-ci. Une variable peut
également stocker des nombres. Par exemple, nous pourrions définir cette variable de message sur
cinq, uniquement sur le chiffre cinq. Et gardez à l'esprit que nous ne voulons
pas de guillemets autour de cinq, car
nous voulons que cela soit traité comme un
nombre et non comme une chaîne. Et comme avant, si nous imprimons
la valeur du message, nous devrions en voir cinq
ici dans le résultat. Peut avoir à peu près
autant de variables que nous le souhaitons. Par exemple,
introduisons une autre variable, et je l'appellerai poulet. Et fixons-le à dix. Nous avons donc maintenant une variable de
message, et nous avons une variable de type poulet. Mais même lorsque nous courrons, il y aura
toujours
cinq ici parce que nous
imprimons des messages spécifiquement. Créons une troisième variable, que nous appellerons un résultat. Mais cette fois, faisons quelque
chose d'un peu différent. Au lieu de le
définir comme une nouvelle valeur, définissons-le comme égal à poulet. Alors maintenant, la variable result contient
désormais la
valeur du poulet. Puisque le poulet en a dix, et essayons d'imprimer le
résultat cette fois, nous devrions voir dix dans le résultat car le résultat contient la
valeur du poulet, et nous imprimons le résultat. Lors de
la programmation, la valeur stockée dans une variable peut changer
ultérieurement dans le programme. Ainsi, même si, par exemple, poulet commence à dix, je pourrais plus tard le remplacer poulet égal à
25, par exemple. Et lorsque nous imprimons du poulet, nous devrions voir 25, car même s'il
commence par dix, cette ligne le fait passer à 25, et nous l'
imprimons à ce moment-là. Cette variable de résultat est définie sur chicken ici
à la troisième ligne. À ce stade, comme
le programme s'exécute de haut en bas, le
poulet est défini sur dix, résultat est défini sur poulet, ce qui signifie que le résultat
en contient en fait dix, et nous pouvons le voir si
nous imprimons le résultat et exécutons. Il est dix heures. Les variables peuvent également changer dans votre programme en
effectuant des
opérations arithmétiques de base sur celles-ci. Cela signifie que nous pouvons
faire des additions, des soustractions, multiplications ou des divisions
avec ces variables Essayons donc cela
avec un résultat. Au lieu de définir le résultat
juste égal au poulet, fixons-le égal
au poulet plus un. Donc,
puisque le poulet est égal à dix, nous verrons dix plus un. Et lorsque nous imprimerons le résultat, nous en verrons 11. Il a effectué cette opération
arithmétique ici même. Et tu peux jouer n'importe quel type. Comme je l'ai dit, vous pouvez faire moins
un ou plusieurs fois 20. Nous verrons que cela indique 200, ou vous pouvez faire une division. De même, nous
obtiendrons la valeur décimale. N'oubliez pas que ce calcul ne
fonctionne que lorsque nous
travaillons avec des nombres. Si disons que le poulet est une
ficelle, bonjour. Eh bien, cela devient soudainement étrange parce que nous essayons de prendre la chaîne hello
et de la diviser par 20. Et cela n'a pas
vraiment de sens. En fait, lorsque vous essayez d'
exécuter, une erreur s'affiche. Et lorsque vous programmez, il est très fréquent de
rencontrer des erreurs. C'est juste une
partie naturelle de l'apprentissage et une
partie naturelle de la programmation. Même les experts se heurtent à des erreurs. Et ici, nous pouvons voir qu'il essaie de faire de l'
arithmétique Sur une valeur de chaîne,
global chicken. Vous ne pouvez donc pas effectuer d'
arithmétique sur des chaînes, et c'est pourquoi nous
devrions reconvertir en nombre
pour que cela fonctionne correctement Et même une fois qu'une variable
est déjà initialisée, nous pouvons toujours modifier sa valeur
ultérieurement en utilisant l'arithmétique Ainsi, pour le poulet, par exemple, je pourrais dire que le poulet
est égal au poulet plus dix. Ici, le poulet
commence à un, puis cette ligne
va définir poulet égal à la valeur
actuelle du poulet, qui est un plus dix. Cela devrait donc nous donner 11, et si nous l'
imprimons, nous en verrons 11. Cet article couvre les
bases de l'utilisation des variables. Ce sont les bases
de tout programme, et avoir une bonne
idée de leur fonctionnement fera de vous un développeur très
compétent.
3. Déclarations subséquentes: Ensuite, nous allons aborder les déclarations I, LSF et autres. Ces types d'instructions
peuvent être appelés instructions
conditionnelles
car ils déterminent si une section
de notre code s'
exécutera ou non à un moment donné en
fonction d'une condition. Nous allons commencer avec
notre code qui ressemble à ceci où nous avons une variable de
message, et nous sommes en train de l'imprimer. Et quand on court, on ne
voit que zéro ici. Ajoutons également une autre
variable au programme, et je vais simplement l'
appeler condition. Tu peux l'appeler
comme tu veux. Et vous pouvez également le
régler comme vous le souhaitez. Je vais le fixer à 25. Nous allons utiliser cette
variable dans le cadre d' une
instruction conditionnelle qui va modifier la valeur du message. Nous allons
commencer par une instruction if, qui commence par si la
condition est supérieure à zéro, puis se termine. Maintenant, entre
ceci et cette fin, nous allons mettre ce qui
se passe réellement lorsque la
condition est vraie. Je vais donc définir
un message égal à un. Cette ligne se lit comme si la valeur de la condition était
supérieure à zéro, alors et ce n'est que lorsque cette
condition est vraie qu'elle exécutera
ce qu'elle contient. Il va dire que le message
est égal à un. Nous pouvons le tester. Le message commence à zéro, mais si nous l'exécutons, nous pouvons
voir qu'il passe à un. Sinon, changeons la
condition à moins 25. Maintenant, cette instruction if
ne sera plus vraie car moins 25
n'est pas supérieur à zéro. Comme cette condition n'est pas vraie, cela signifie que cette
ligne ne fonctionnera pas. Encore une fois, lorsque nous exécutons, nous voyons que le
message reste à zéro. Cette ligne n'arrive jamais. allons ajouter une autre
instruction conditionnelle à notre code, et ce sera une idée très
similaire à celle d'avant. Mais cette fois, il
vérifiera si condition est alors inférieure
ou égale à zéro. Et ici, nous allons définir un message
égal à moins un. Donc, même idée que précédemment, il va voir si la condition
est
inférieure ou égale à zéro. Et ce n'est que si c'est le cas message
sera défini
comme négatif ? Et nous veillerons à
ce que cela se produise. Cette ligne est atteinte car
sa condition est vraie. Mais encore une fois, tous nos programmes
se déroulent de haut en bas. Donc, d'abord,
cette ligne apparaît, puis cette ligne, et ensuite il va
vérifier cette condition Dans notre cas, cette
condition n'est pas vraie. Cette ligne ne se produit donc pas. Ensuite, il passe
à cette condition, et puisque celle-ci est vraie, cette ligne se produit. Écrire notre code de cette façon avec deux instructions if distinctes, l'une juste après l'
autre, est acceptable, mais il existe un moyen beaucoup plus simple
et efficace d'écrire
exactement la même chose. Je vais donc supprimer cette deuxième condition ou
la deuxième instruction if, et à la place, nous allons ajouter
à cette première. Je peux mettre autre chose et dire que le
message est égal à un négatif. Il s'agit d'un nouveau type de condition, où il est simplement dit le contraire. La façon dont cela se lit est qu'il va d'
abord vérifier
cette condition. Si la condition est
supérieure à zéro, cette ligne apparaît. Mais si cette condition n'
est pas vraie, ou si la condition est inférieure à zéro au lieu
de supérieure à, alors elle dira le contraire, et une fois cette autre condition atteinte,
c'est ce qui se trouve entre le reste et la fin qui est exécuté. Dans ce cas, le message
est égal à moins un. Il s'agit exactement de la même
fonctionnalité qu'auparavant, mais elle est plus compacte avec un
seul ensemble de if and then else ». Et
nous pouvons le tester. Si nous courons, nous obtenons toujours notre
négatif en sortie. Jusqu'à présent, nous avons utilisé des instructions
if, nous avons utilisé
des instructions else, et enfin, nous allons passer à
la dernière condition qui est quelque sorte une combinaison
entre les deux et elle s'appelle else if. Allez-y, mettez-en un ici, et je vais en retirer le nôtre pour le moment, juste
pour le nettoyer un peu. Mais à sa place, je
vais ajouter le LI. Donc, vous dites el if, un mot comme ça, et nous
ajouterons une condition à cela. La condition est
donc
inférieure à moins dix, et dans ce cas, nous dirons que le message
est égal à moins un. C'est donc différent de ce qu' auparavant parce que
notre déclaration n'était
assortie d'aucune condition. Donc, ce qui va se passer, c'est cette condition
va d'abord être vérifiée, et si c'est vrai, c'est ce que nous
allons faire. Mais si cette condition n'
est pas vraie, elle va passer
à ici SIF, et elle va
vérifier cette condition. Et si celle-ci est vraie, alors cette ligne
va s'exécuter. Mais si aucune de ces
conditions n'est vraie, aucune de
ces lignes ne fonctionnera du tout. Donc, en testant cela, puisque condition est négative de
25 en ce moment, nous obtenons toujours notre résultat négatif. Mais si nous changeons cela en, disons plutôt moins cinq, sorte que moins cinq ne
soit pas supérieur à zéro, on passe
donc au SIF, et moins cinq ne soit pas
inférieur à moins dix non plus. Aucune de ces
conditions n'était donc remplie, ce qui signifie que le message reste à zéro, à
son point de départ. Maintenant, pour tout lier
ensemble, vous pouvez mettre un autre en plus
de tout le reste. Je vais donc mettre message égal, et mettons-le dans une chaîne. Aucune condition n'est remplie. Donc, avec cet
exemple de moins cinq, ce n'est pas vrai. Ce n'est pas vrai, donc
tout le reste va être touché, et cette limite
va se produire. Nous pouvons donc voir si nous
courons, aucune condition n'est remplie. Maintenant, avec
des blocs de code comme celui-ci, vous pouvez en avoir un si. Tu peux en avoir un autre. Mais entre l'autre et le if, vous pouvez avoir autant de ces portions d'
el if que vous le souhaitez. Je vais donc en mettre
un autre, en fait. Je vais dire ls si la condition, et nous dirons qu'elle est égale
à moins cinq. Alors. Et dans ce cas, je dirais que message est égal à bonjour. Maintenant, gardez à l'esprit que j'utilise le double signe égal ici. Lorsque vous utilisez un
double signe égal, c'est ainsi
que vous
testez pour voir cela
est égal à cela. Mais lorsque vous utilisez
un signe égal, cela s'appelle une assignation, ce qui
signifie que cette valeur est
directement affectée à cette variable. Nous ne fixons donc pas la
condition à moins cinq. Nous testons pour voir si la
condition est égale
à moins cinq. Et si c'est le cas,
cette ligne se produira. Et nous pouvons le tester Si nous courons, nous verrons bonjour. Un dernier commentaire à ce sujet est que dans ces intersections, vous pouvez avoir autant de lignes
que vous le souhaitez En plus du bonjour, je pourrais faire une impression supplémentaire et dire « Bonjour ». Lorsque je clique sur Exécuter, nous obtenons
à la fois le i et le bonjour Ces
deux lignes s'exécutent parce que tout
ce
qui se trouve entre ceci et cela, toute
la section intérieure en
retrait, toute
la section intérieure en
retrait, va être exécuté
4. Boucles: Le sujet suivant concerne les boucles, et ce n'est pas pour rien
que je vous
les montre juste après les instructions
conditionnelles. Les boucles sont des sections de
code qui s'
exécutent plusieurs fois selon
certaines conditions. Pour le montrer, nous allons
passer directement à notre premier type de
boucle, la boucle ile. Je commence par le code
qui ressemble à celui-ci où nous avons notre message, et
nous sommes en train de l'imprimer. Et après le message, nous allons écrire la
première boucle, et c'est une boucle. Nous dirons que le message Y
est inférieur à dix, D. Et puis ici, disons que message est égal à
message plus un. Passons en revue cette
section de code
ligne par ligne pour mieux
comprendre ce qu'il fait. Nous commençons par ile, puis ce message
est inférieur à dix. C'est donc très similaire à nos instructions
if où il s'
agit d'une condition. Et seulement si cette
condition est vraie, allons-nous à l'intersection ? Et à l'intérieur de cette boucle de fichier, nous disons que le message est égal à la
valeur actuelle du message, qui est zéro plus un. Donc, une fois cette ligne exécutée, cela signifierait que ce
message serait égal à un. Mais ce qui rend Loops intéressant c'
est qu'une fois qu'il arrive ici, à
la fin, il revient en arrière et explique pourquoi, message est inférieur à dix. Il va donc
vérifier à nouveau l'état, juste après l'
avoir vérifié pour la première fois. Et le message n'en est plus qu'un. Il va donc se demander : est-ce qu'un
est inférieur à dix ? Et comme c'est le cas, cela
signifie que le message va passer
à deux. Et encore une fois, je vais
revenir ici, il y en a deux, moins de dix, puis maintenant il y en a trois, trois, moins de dix, et encore et encore,
ça va continuer à tourner en boucle, où vient la boucle des
noms Jusqu'à ce que finalement, le message
passe à dix, et il indiquera dix, moins de dix. Et puisque dix
n'est pas inférieur à dix, cela signifie
que la
condition n'est plus vraie et que cette intersection
cesse de fonctionner. Il ne fonctionne plus par la suite
. Et puis ça passe à autre chose. Après cette course, cela signifie que cette intersection s'est déroulée
dix fois au total et que le message a fini par être dix.
Et nous pouvons le constater. Si nous imprimons le message
et que nous l'exécutons, nous en voyons dix. Gardez à l'esprit que
tout ce processus dont nous venons de parler
se déroule instantanément Comme les ordinateurs sont
incroyablement rapides, le programme le trouve
en boucle ici et peut presque immédiatement
passer à travers toutes les itérations Vous pouvez même sauter
ce dix jusqu'à 10 000, et il
fonctionnera toujours instantanément Il effectue les 10 000
itérations en un rien de temps. En parlant de cela, ce message équivaut à message plus un en est un exemple
très basique. Entre le do et la fin, vous pouvez avoir autant de
code que vous le souhaitez, comme dans les instructions if, et tout sera exécuté tant que la
condition est vraie. Par exemple, nous pourrions
ajouter une deuxième variable. Je vais l'appeler
simplement test, et je le mettrai à zéro. Ensuite, dans la boucle,
faisons quelque chose comme test égal à
test moins cinq. Je vais donc aussi le ramener à dix, pour
que
ce soit un peu
plus facile à comprendre. Donc, comme avant, cette boucle va s'
exécuter dix fois, qui signifie que cette ligne ici va
également être exécutée dix fois, ce qui signifie que le test, si nous imprimons le test, sera négatif de 50. Il a été soustrait
cinq ou dix fois. Plus tôt, j'ai mentionné
que la boucle
s'exécutera jusqu'à ce que la condition ne
soit plus vraie. Et en tant que programmeur, il est de votre responsabilité de vous
assurer que chaque fois que
vous utilisez une boucle while, elle finira par s'arrêter. Sinon, votre boucle
continuera indéfiniment. Et comme expérience d'
apprentissage, nous pouvons aller de l'avant et l'
essayer juste pour voir ce qui se passe. fin de la boucle
est la ligne de liste, car le message continue de croître jusqu'à ce qu'
il ne soit plus inférieur à dix. Donc, si nous changeons cela
en moins un, eh bien, cette boucle va
continuer indéfiniment
car le message sera
toujours inférieur à dix. Donc, si nous courons, nous pouvons voir
que nous sommes en quelque sorte bloqués. Donc, si vous répondez « Oui »
, le temps expire. Si vous le faites sur
votre propre ordinateur, attention, vous devrez peut-être
forcer la fermeture du programme. Mais oui, c'est ce qui arrive chaque fois que la
boucle est illimitée. Ça ne s'arrête jamais
et ça expire. Donc, avant d'oublier,
rechangeons cela en plus, et nous reviendrons à la normale. Cela couvre de larges boucles. Passons donc au
second type de boucle
, appelé boucle à quatre. Ce type de boucle est tout
aussi utile que le fichier, mais il est utile dans
différentes situations. En programmation, vous
remarquerez qu'il existe
généralement de nombreuses façons de
faire les choses Vous aurez
donc toujours
des options pour résoudre les problèmes. Commençons par créer à nouveau
une nouvelle variable, et je vais
simplement l'appeler pickle Peu importe comment
tu l'appelles. Et je vais le mettre à zéro. Et c'est la valeur que nous
allons imprimer, Pickle. Et après la boucle de fichier, nous allons commencer
les quatre boucles. Et voilà à quoi ça ressemble. Tu dis quatre. Je suis égal à un, virgule trois, un, deux Et puis à l'intérieur, faisons un cornichon égal à un
cornichon plus dix Maintenant, en regardant ce code, il est un peu moins
explicite que
la boucle de fichier. Passons-en donc en
revue petit à petit afin de mieux comprendre
ce qui se passe ici. Cette première ligne indique
trois valeurs différentes. Tout d'abord, nous avons i égal à un. Dans une boucle
à quatre, cela va agir comme notre itérateur, ce qui signifie essentiellement que c'est une valeur qui sera
mise à jour à chaque fois que
cette boucle à quatre boucles Le numéro suivant de la séquence, ce trois, est le nombre que
notre itérateur approchera Et une fois ce nombre
atteint, la boucle se terminera. Enfin, ce dernier chiffre est la valeur de l'étape pour la boucle. Ou en d'autres termes, c'est la
quantité que notre itérateur
augmentera à chaque
fois que cela bouclera Je sais donc que c'était beaucoup d'
informations à la fois. Permettez-moi donc de vous expliquer ce qui
se passera lorsque cette boucle sera terminée. La boucle va commencer.
Je commence par une. Et encore une fois, c'est notre itérateur. Alors la boucle commence, le cornichon
va augmenter de 0 à 10. Donc, zéro plus dix font dix. Alors maintenant, le cornichon a dix ans.
Maintenant, la boucle se termine. Cela remonte au début. Mais cette fois, j'
augmente de cette valeur. Donc, je passe de
un plus un à deux. Donc maintenant c'est deux. Et puisque deux, la valeur
actuelle de i est inférieure à cette valeur, les trois, cela signifie que
la boucle va continuer. Nous allons donc rentrer
dans le vif du sujet une fois de plus. Le cornichon va encore
augmenter de dix, alors maintenant le cornichon Et encore une fois, nous revenons
au début de la boucle. Cela va augmenter de 2 à 3. Maintenant, je suis égal à trois. Maintenant que i est égal à
ce nombre du milieu, trois est égal à
trois, cela signifie
qu' il s'agit de la dernière
itération de la boucle Le cornichon va donc
augmenter de 101 fois, puis la boucle est enfin
terminée et on passe Cela signifie donc que cette ligne
au milieu,
ou devrais-je dire que toute
cette section
a été parcourue trois fois au total,
de une à trois. Nous pouvons donc voir que le cornichon après
tout cela devrait être 30. À première vue, cette boucle
peut sembler un
peu plus compliquée que la
boucle de Wile que nous avons faite plus tôt, car il nous reste encore
quelques chiffres à suivre Mais une fois qu'on s'y est habitué, je pense que c'est assez
explicite. La boucle commencera
à ce nombre, augmentera de ce nombre à chaque fois jusqu'à ce qu'elle
atteigne ce nombre. C'est donc un moyen facile d'avoir un ensemble de boucles
prédéterminé. Une chose intéressante
et très utile que vous pouvez faire avec
quatre boucles est que vous pouvez utiliser cette valeur d'itérateur
à l'intérieur de la boucle elle-même. Par exemple, je pourrais
augmenter le cornichon par i. Cela signifie que je
vais commencer par un, donc le cornichon va
augmenter d'un, puis il va
augmenter de deux, puis il va
augmenter de trois Un plus deux plus trois font six. Il s'agit d'une méthode très courante d' utiliser quatre boucles,
car dans
de nombreuses
circonstances, vous aurez besoin cette valeur d'itérateur pour effectuer
certains calculs
5. Fonctions: En programmation, il est
important de se rappeler que copier-coller du code n'
est pas une très bonne pratique Si jamais vous avez besoin de
copier une section de votre code et coller à un autre endroit pour qu'
il y ait désormais deux copies
du même code, vous devriez plutôt
envisager d'utiliser une fonction. Une fonction est une section
de code que vous définissez, puis vous pouvez
appeler cette section de
code pour qu' elle soit exécutée ailleurs
dans le programme. Vous comprendrez ce que je
veux dire dans un instant. Nous commençons le code
avec juste un message égal à zéro, puis nous imprimons le
message, qui produit zéro. Mais après le message, nous
allons écrire notre
première fonction. Nous allons dire
le mot-clé function, et le nom de notre fonction
sera increase message. Et puis dans
cette fonction, nous dirons que message est égal à
message plus cinq. Ici, le
mot-clé function indique que la prochaine chose est le
nom de notre fonction. Les deux parenthèses sont nécessaires pour indiquer
qu'il s'agit d'une fonction. Et puis tout avant la fin, donc quoi qu'il y
ait, cela sera exécuté chaque fois que la fonction sera appelée. Maintenant, par défaut, le simple fait
que
nous définissions cette fonction ne signifie pas
nécessairement que ce code
sera exécuté dès le départ. si je clique sur Exécuter, nous
verrons que notre sortie
est toujours nulle. Pour que ce
code soit exécuté, nous devons appeler la fonction. Cela signifie simplement que nous
tapons le nom de la fonction, augmentons le message, puis que nous
mettons les deux parenthèses C'est ce
qu'on appelle l'appel de la fonction, qui signifie simplement que
lorsque vous tapez cette ligne, ce
qui signifie simplement que
lorsque vous tapez cette ligne,
elle va prendre le code contenu dans la fonction et l'exécuter. Nous allons donc voir maintenant que lorsque
nous exécutons l'ensemble du programme, valeur de
notre message est cinq. Et de même, pour le
démontrer, je pourrais copier cet appel de
fonction et dire, appelez-le deux fois de plus. Nous appelons donc cette
fonction trois fois au total, qui signifie que ce code
va s'exécuter trois fois, ce qui signifie finalement
que notre message est 15. Nous allons rendre
la fonction un peu plus intéressante. Lorsque vous écrivez une fonction, vous avez la possibilité de
lui donner des paramètres. Les paramètres sont ce qui se
trouve entre parenthèses, peu comme ce que
nous faisons avec cette fonction d'impression ici Nous pourrions le modifier pour
que cette fonction accepte un paramètre. Nous dirons qu'il accepte
quelque chose appelé Pu, puis nous pouvons utiliser ce
paramètre dans la fonction. Nous allons donc dire « plus up ». Au lieu d'en ajouter
cinq à chaque fois, cela ajoutera la
valeur que nous transmettrons. Ainsi, lorsque nous appelons un message
accru, je peux y mettre
la valeur que je veux. Je peux dire 99, par
exemple, quand
je cours, nous en avons 99. Mais je peux aussi parler de message augmenté pour la
deuxième fois, mais cette fois, je vais en transmettre deux. Et cette fois, c'est un contre un. Il a appelé ce code deux fois. La première fois, Fu
est égal à 99, et la deuxième fois,
Fu est égal à deux. Bien que dans notre exemple, nous n'ayons qu'un seul paramètre
dans cette fonction, vous pouvez en mettre
autant que vous le souhaitez, mettant
des
virgules entre chacun Donc, si j'en voulais un
autre appelé Val et qu'un autre
m'appelait, peu importe. Tu les as tous mis dans un ordre. Ensuite, lorsque vous
appelez la fonction, vous transmettez des valeurs
supplémentaires pour
chacun de ces paramètres. Voici donc à quoi cela ressemblerait si vous vouliez le faire de cette façon. Maintenant, une
chose très importante à savoir à propos des fonctions est que vous avez la possibilité de renvoyer une valeur. Pour expliquer ce que cela signifie, modifions notre fonction pour qu'elle renvoie quelque chose. Je vais
nettoyer un peu ce code, revenons
donc
au seul paramètre Pu. Donc, au lieu de
voir le message augmenter uniquement de la valeur de Fu,
faisons en sorte que
fu soit égal à fu
multiplié par deux. Nous allons donc
transmettre une valeur, puis immédiatement nous
allons doubler cette valeur. Et ensuite, retournons Fu. Maintenant, la fonction se comporte un peu différemment de ce
qu'elle était auparavant Avant, nous disions manuellement que message allait
augmenter de Fu, mais maintenant nous changeons simplement
Fu puis renvoyons Fu. Ce qui se passe, c'est que
pour
appliquer réellement cette fonction au message, nous dirions que message
est égal à augmentation du message, puis passons en dix. Ce qui va se passer ici, c' est que
ce dix va
être transmis dans SFU, puis fu va doubler, sorte que dix va
se transformer en 20, puis il va
renvoyer la nouvelle valeur de Fu,
qui, comme je viens de le dire, est 20 Ainsi, lorsque quelque chose
est renvoyé dans une fonction, cela signifie essentiellement
que l'appel de fonction va
se remplacer par le résultat. Donc, puisque nous
en donnions 20 ici, c'est essentiellement la même
chose que de
se remplacer par le résultat. Il s'agit donc essentiellement de le faire. Mais ce qui est beau, c'est que vous pouvez transmettre la valeur
que vous voulez. Et il va le prendre
et l'appliquer. Donc dans ce cas, j'ai tapé 99, le résultat est 198 Cela double simplement cette valeur. Et comme nous
définissons un message égal à cette valeur renvoyée, c'est ce
que nous obtenons à l'impression. La raison pour laquelle cela est utile est que maintenant, si je voulais appliquer cette fonction pour dire une
nouvelle variable comme chicken, la façon dont je l'avais
configurée auparavant où je disais manuellement le message
à l'intérieur de cette fonction. Cela signifierait que cela ne s'appliquait qu'à cette
variable, et c'est tout. Mais maintenant, quand je
renvoie quelque chose, je peux l'utiliser pour n'importe quelle variable. Je pourrais donc dire poulet égal
à 5 pour augmenter le message 5. Et puis si j'imprime du poulet, nous devrions en voir dix. Une chose intéressante que vous
pouvez faire avec les fonctions est transmettre d'autres variables
en tant que paramètres. Par exemple,
en haut du programme, créons une nouvelle variable. Je vais l'appeler Monkey, et
fixons-le à 100. Alors ce que je peux faire, c'est
transmettre cette variable singe, disons ici. Donc je vais juste dire singe. Donc, ce qui se passe, c'est que la
valeur du singe, qui
est de 100 , sera transmise
dans un message accru, puis
appliquée au poulet, ce qui donne 200. présence de fonctions dans
notre ceinture à outils vous sera extrêmement utile au fur et à mesure que vous
progresserez dans la programmation. Vous verrez à quelle fréquence des
sections de code doivent être exécutées à différents
moments du programme. Et il est beaucoup plus facile de tout
gérer
lorsque le code se trouve au même endroit que de copier-coller
dans tout le fichier
6. Commentaires: Jusqu'à présent, tout ce
que nous avons écrit dans notre fichier LuA est du code Lua Mais dans presque tous les
langages de programmation, les
programmeurs ont la possibilité de mettre petites notes qui
ne sont pas traitées comme du code, et ces notes sont
appelées commentaires Par exemple, dans ce code
de la leçon précédente, nous avons une fonction
appelée augmenter le message. Si j'écrivais un
tas de code et que j'avais une tonne de fonctions
écrites dans mes fichiers, il pourrait être difficile de
suivre le fonctionnement de chaque
fonction. Il est donc utile
d'écrire des commentaires dans votre code pour vous
aider à vous en souvenir. Dans Lua, vous écrivez des
commentaires en tapant dah, dah, puis tout ce qui suit est
considéré comme un commentaire Je peux donc écrire que mon message
double une valeur et la renvoie. Donc, ce message est
ignoré par le programme, mais il m'aide ou aide la
personne qui lit mon code. Cela vous donne juste
un peu plus de contexte. C'est un petit rappel. Une astuce sympa que vous pouvez
faire de temps en temps
s'appelle commenter du code. Les commentaires sont utiles pour ces petits
rappels comme celui-ci, mais vous pouvez également les utiliser pour désactiver certaines
sections de code. Donc, par exemple, si je
voulais voir ce qui se passerait si je supprimais
complètement cette
ligne, je pourrais la supprimer, ou peut-être simplement la supprimer
temporairement en faisant d. Maintenant, cette ligne
est considérée comme un commentaire, et lorsque je lance le programme, il prétend simplement que
cette ligne n'existe pas du tout, mais en même temps, il est très facile
pour moi de la récupérer Il est également possible de
traiter
des sections entières de code comme des commentaires. Vous pouvez le faire en tapant base
carrée base carrée », puis lorsque vous souhaitez
terminer la section des commentaires, vous pouvez utiliser base carrée base carrée. Tout ce qui se trouve entre
ceci et cela est considéré comme un commentaire, aucune de ces lignes
ne sera lue. de
prendre l'habitude de commenter Il est très important de
prendre l'habitude de commenter
votre code. Cela vous
aide à prendre des notes, mais si quelqu'un d'autre
veut parcourir votre code, commentaires font une
énorme différence pour
comprendre ce que vous, en tant que programmeur, essayiez de faire lorsque
vous l'avez écrit. Il
peut parfois être difficile de lire le code d'autres personnes, mais le fait d'avoir des commentaires
pour vous guider tout
au long du
processus facilite considérablement le processus.
7. Local ou mondial: Dans Lua et dans de nombreux autres langages de
programmation, il existe deux types
de variables, les variables globales et les variables
locales Jusqu'à présent, nous avons
travaillé avec des acteurs internationaux. Les variables globales sont
des choses comme un message. Une fois que vous l'avez défini, il est
accessible n'
importe où dans le programme, et c'est ce que
Global désigne. Nous pourrions taper un message
n'importe où dans le fichier, et le programme
saura que nous faisons référence à cette
variable ici. L'alternative à une
variable globale est une variable locale. Et tout ce que vous avez à
faire pour rendre une variable locale est ajouter ce
mot clé local au préalable. Et comme son nom l'indique, la variable locale
n'est accessible que dans la même section de code dans
laquelle la variable
a été déclarée. Ainsi, par exemple, mettons à jour
cette
fonction d'augmentation du message pour faire quelque chose de différent et
utiliser une variable locale. Je vais créer une nouvelle variable
locale ici et l'appeler local VR. Et je vais le
définir comme égal à FU. Ensuite, sur la
ligne suivante, je vais faire en sorte que VR soit égal à R divisé par deux. Enfin, nous
allons revenir à la réalité virtuelle. Alors maintenant, plutôt que de
doubler le message, nous le réduisons de moitié parce que nous
donnons
à la réalité virtuelle la même valeur que
le passé, nous le
réduisons de moitié, puis nous le renvoyons à la réalité virtuelle Mais il est important de noter que la variable VR ne sera utilisée que dans cette section
de code de la fonction. Et puisque c'est le cas, il logique
d'utiliser le local ici. Nous ne voudrions pas que la
réalité virtuelle
soit utilisée en dehors de cette
section de code ici. Et c'est là que le local devient vraiment utile lorsque vous
gérez votre projet. Il existe un grand nombre de variables dans l'ensemble de
votre programme. Il est plus probable
qu'une erreur soit commise lorsqu'il y a
de nombreux globaux différents, car si vous créiez
une deuxième variable plus tard et que je l'appelais VR Eh bien, il se peut que l'on ne sache pas de
quelle voiture il s'agit. Mais si tout est local à la section de code correspondante, il ne fait aucun doute à
quelle Var cela fait référence,
juste au cas où vous auriez nommé deux
variables du même nom C'est donc une habitude que je vous
encourage vivement à adopter, en particulier pour l'
écriture de fonctions Je dirais que c'est un scénario
très courant où j'utilise des variables locales parce que je ne veux pas
que
ces variables soient utilisées en dehors de la fonction dans laquelle je les déclare.
8. Tableaux: Tout ce que
nous avons abordé jusqu'à présent est très courant dans le monde
de la programmation. Vous trouverez toutes ces choses dans pratiquement toutes les langues. Cependant, notre prochain
sujet concerne les tables, et il s'agit d'une structure
de données assez unique à Lua Chaque langue
aura des options similaires,
mais les tables de Lua sont des outils uniques en leur
genre et incroyablement puissants Vous les utilisez pour stocker des
ensembles de données connexes. Et comme ces données
sont toutes stockées au même endroit, il est beaucoup plus facile d'y accéder et de
tout organiser. Tout comme les variables. Une variable stocke une donnée
, et c'est tout. Rien d'autre
que cette seule chose. Une table est capable de stocker plusieurs éléments de données
dans la même variable, sauf qu'il s'agit d'une table et
non d'une variable. Passons donc en revue
un exemple à partir de zéro sur la façon d'
utiliser les tables. Je vais commencer par le fait que notre message
type est égal à zéro, puis nous imprimons le message. Après cette variable de message, créons un nouveau tableau. J'appellerai ça les résultats des tests. Ensuite, lorsque nous avons créé
une nouvelle table, nous l'avons définie comme étant égale à des accolades À Lua, si vous voyez
ces bretelles bouclées, c'est comme
ça que vous savez que
nous travaillons avec une table Et comme il n'y a rien
entre les bretelles bouclées, cela signifie
que la table est vide. Ici, nous initialisons les résultats des
tests pour qu'ils soient un tableau vide. Pour cette démonstration,
nous allons stocker un ensemble de
scores inventés dans ce tableau. Pour ce faire, nous
allons attribuer un score à son propre
index dans le tableau. Voyons comment procéder. Tout d'abord, nous voulons écrire le nom de la
table, les résultats des tests. Ensuite, juste après, nous
allons mettre des crochets. Ensuite, entre
crochets, nous allons mettre un index. Vous verrez ce que cela
signifie dans un instant. Pour commencer, nous allons
mettre dans l'index 1. Et je vais régler l'indice 1 à 95, par
exemple. Et c'est tout. Nous avons attribué notre premier score au tableau
des résultats des tests de l'Index 1. Nous pouvons maintenant passer
au deuxième résultat du test. Nous allons en déduire
les résultats des tests, puis deux. Nous allons régler celui-ci à 87. Pour l'instant, nous allons ajouter
un autre résultat au test. Je dirais trois résultats au test, et je mettrai celui-ci à 98. À ce stade, nous avons maintenant
un tableau appelé résultats
des tests, qui contient trois scores, un pour chacun de ces
trois indices. Maintenant, pour accéder aux
données que nous venons de saisir, il suffit d'écrire
le nom de la table et faire référence à l'index dont
nous parlons. Supposons donc que nous
voulions définir un message égal aux résultats du test Index 2. Donc, cela va juste récupérer la valeur
se trouvant à l'index deux, qui est 87, et nous
imprimons un message ici, donc nous devrions voir 87. N'oubliez pas que nous n'avons
attribué des valeurs qu'à l'index un, l'index deux et à l'index trois. Que se passerait-il si nous
essayions d'accéder à l'index 4 ? Nous n'
y avons rien mis. Alors, que se passerait-il ? Si nous définissons un message égal aux résultats du test Index 4
et que nous essayons de l'exécuter, nous voyons en fait NIL. Ainsi, lorsque rien n'est attribué
à un index particulier, celui-ci contient en fait
la valeur NIL. Maintenant, NIL est un
mot réservé en Lua, qui représente simplement
le sens de rien Cela signifie simplement que rien n'existe
ici dans cette position. Donc, cette méthode
d'attribution valeurs à la table est correcte, mais il existe un moyen
plus efficace faire exactement la même chose Je vais procéder à la
suppression de ces trois lignes. Et au lieu d'écrire trois lignes différentes
pour ces devoirs, nous pouvons revenir à cette section
originale de Curly Berry et y inscrire ces trois partitions
différentes Et c'était 95, 87 et 98. Toute cette ligne
accomplit donc exactement la même chose que nous faisions auparavant avec les trois entrées manuelles
pour ces trois partitions En d'autres termes, cette
valeur est à l'indice un, cette valeur est à l'indice deux et cette valeur est à l'indice trois. Et nous
pouvons le tester. Allons-y et définissons message sur Index
trois des résultats du test, et nous obtenons 98, qui
est cette valeur. Bien que ce soit le moyen le plus simple mettre des valeurs dans un tableau, il existe une autre méthode qui reste
importante à suivre. Nous allons refaire
tout cela en faisant
simplement en sorte que les résultats des tests commencent à vide, et
comme nous le faisions auparavant, nous allons écrire
trois lignes distinctes Mais cette fois,
nous allons utiliser cette fonction appelée insertion de
table. Même idée que précédemment, lorsque
nous avons écrit nos propres fonctions. Le
langage de programmation LuA est livré avec un tas de fonctions écrites
pour nous que nous pouvons utiliser, et table point insert
est l'une d'entre elles. Cette fonction
prend simplement une valeur et la
place dans une table. La fonction possède deux
paramètres que nous
devons transmettre
avant de pouvoir l'utiliser. Le premier paramètre
est le nom de la table. Tapons donc les résultats des tests. C'est le nom de la table dans
laquelle nous voulons insérer. Et le paramètre suivant est la valeur que
nous voulons insérer. Mettons d'abord le
score de 95 au test, et nous pouvons faire de même. Avec les deux autres scores
, disons 87 et 98. L'avantage de
cette fonction d' insertion de points dans les tableaux par rapport à ce que nous faisions auparavant est que nous n'avons pas à spécifier l'indice auquel nous voulons attribuer
ces scores. Et vous vous retrouverez dans
des situations où vous ne saurez pas réellement sur
quel index vous vous trouvez. Vous allez écrire du code
qui dit simplement mettre cette valeur dans le tableau. Mais vous ne saurez pas à ce moment-là combien d'éléments se trouvent dans le
tableau ni s'il y a des lacunes. Cette fonction d'insertion s'occupe donc de
tout cela pour vous. Juste une petite remarque. Lorsque vous attribuez des valeurs
à une table dans LuA, il est courant de
commencer à l'index 1, puis de monter à partir de Il est probablement plus courant que les langues commencent
à l'index zéro, mais LuA est une langue qui
commence à l'index un Mais vous n'avez même pas besoin d'
utiliser des chiffres comme index. Vous pouvez également utiliser des chaînes. Vous pourriez dire les résultats des tests, puis
entre crochets, je dirais « bonjour ». Ensuite, nous y
mettrons la valeur 90. Ensuite, comme avant, je peux simplement me souvenir des mêmes données en
transmettant l'index
approprié. Et nous en avons 90. Mais
comme je l'ai dit plus tôt ,
l'approche
unidirectionnelle, si vous savez déjà quelles données vont
s'
y trouver, dans ce cas, 95 87 et 998, est la manière la plus
compacte de procéder Et lorsque vous avez des tableaux remplis
de données, comme
c'est le cas ici, il est important de
pouvoir
parcourir efficacement et facilement toutes ces données
pour trouver ce que vous recherchez, effectuer des calculs ou faire tout ce pour quoi vous
avez besoin de ces informations. Heureusement, Lua nous
offre une option très simple pour parcourir toutes les entrées de la
table et examiner les
données qu'elle contient Souvenez-vous des quatre
boucles précédentes, nous pouvons les utiliser d'une nouvelle manière ici afin de
parcourir facilement le tableau. Et voici comment procéder. On peut dire quatre, et
je dirais que je suis deux par deux. Ensuite, le tableau
que nous voulons parcourir est
celui des résultats des tests D. Et puis, dans
les quatre boucles, je dirai que message est égal à
message plus S. Maintenant, cette boucle va
parcourir chaque élément du tableau,
et pour chaque élément, et pour chaque élément, elle exécutera le code qui
se trouve à l'intérieur de la boucle. Ce I fait référence à l'
indice actuel sur lequel se trouve la boucle, et ce S fait référence à la valeur ou aux données qui
existent à cet indice. Dans ce cas, les résultats des tests actuellement
trois scores
différents. Cela signifie que
cette boucle va tourner en boucle trois fois différentes. La première fois, I
sera un, et S sera la valeur située à
l'indice 1 ou 95. À ce stade,
le message augmentera de 95. Ensuite, la boucle
recommencera. Je vais être deux cette fois, S va être 87 ou
la valeur à l'indice deux. Et encore une fois,
le message va augmenter. En général, cela
va simplement additionner tous
les scores et les
mettre dans le message. Je vais donc me
débarrasser de cette ligne, et nous pourrons courir et voir
que la somme est de 280. C'est ce que nous obtenons si vous
ajoutez 95 plus 87 plus 98. Il y a une dernière chose à propos des tables que j'
aimerais passer en revue. Une fonctionnalité intéressante à leur sujet est que vous pouvez leur ajouter des
propriétés, qui sont essentiellement une variable directement liée
à la table elle-même. Allons-y et ajoutons-en
un aux résultats de ce test. Je dirais que les résultats des tests indiquent un
point égal à un sujet, et entre guillemets, les mathématiques. Et c'est tout. Nous pouvons maintenant obtenir cette propriété en l'
appelant simplement de la même manière que
n'importe quelle autre variable, et nous devrions obtenir des mathématiques. Il s'agit d'une
méthode pratique pour
indiquer clairement ce que représente chaque donnée
. Mais en réalité, cette
ligne ne fait que les résultats des tests,
puis, entre crochets,
le sujet de la chaîne. C'est égal aux maths. Ces deux lignes accomplissent la même chose. Il s'agit simplement d'une autre façon de procéder et vice versa. Cela montre vraiment à
quel point les tables sont flexibles, et elles vous permettent de
personnaliser réellement la façon dont
votre code est organisé.
9. Conclusion: Il est temps de parler du
projet pour ce cours. Je vais
vous donner ce code ici, et je veux que vous l'ajoutiez. Vous pouvez soit taper tout ce code directement
à partir de cette vidéo, soit télécharger un fichier LuA depuis la
section projet du cours, puis le
copier-coller dans le même navigateur que lors des
leçons précédentes Voici le problème. Je vous donne cette fonction appelée
somme de tous les nombres. Mais pour le moment, cela
ne fonctionne pas correctement. Cette fonction est
censée prendre un nombre, nous
appelons num
comme paramètre, et elle doit additionner tous
les entiers compris entre
un et num. Par exemple, si nous
transmettions quatre, cela signifierait qu'il faudrait ajouter un plus deux plus
trois plus quatre, et le résultat serait dix. Ensuite, il définirait ce dix comme
résultat et renverrait le résultat. heure actuelle, cependant, lorsque nous exécutons, cela renvoie toujours zéro, peu
importe ce que nous transmettons pour cet appel de
fonction sum numbers. Ce que nous devons faire, c'est corriger cela afin que
la valeur que nous transmettons
soit utilisée dans la fonction et renvoie
une réponse appropriée. D'ailleurs, lorsque nous passons
12 pour additionner tous les nombres, nous devrions nous attendre à ce que le
résultat soit 78. Donc, dans un premier temps, vous devriez vous
efforcer d' obtenir au moins ce
chiffre correct ici. Bien entendu, en fin de compte, il devrait être en mesure d'
accepter n'importe quel numéro. La quantité totale de
code que vous devez écrire ne
doit être que d'environ
cinq ou six lignes. Pour résoudre ce problème, repensez aux leçons
précédentes. L'un de ces sujets fonctionne particulièrement bien
pour ce problème. Lorsque vous trouvez
une solution, assurez-vous de prendre une
capture d'écran de votre code ici et de la publier sur la page du projet de
classe. Je vais y jeter un œil et vous
faire part de mes commentaires. Si vous passez du
temps à réfléchir à ce problème et que vous
n'arrivez pas à le résoudre, assurez-vous de me contacter
et je vous donnerai quelques conseils. D'ici là, bonne chance. Une fois le projet terminé, ce cours sera terminé. Merci beaucoup d'avoir
parcouru ce matériel avec moi. Je ne l'ai pas encore fait,
merci de laisser un commentaire. Et si vous avez apprécié le
cours, n'hésitez pas à le recommander. J'apprécie beaucoup
votre soutien. l'avenir, je
recommande approfondir chacun des sujets
abordés en classe. Nous ne faisons qu'effleurer la surface
de ce que Lua a à offrir. Le langage dispose
d'une excellente documentation et de tutoriels sur ua.org Je recommande donc vivement
de consulter ce site. Cela dit, je crois que
cela couvre tout. Merci encore d'
avoir suivi mon cours, et j'ai
hâte de vous voir au prochain.