Impressum | Haftungsausschluss |

LUA : pour les Débutants

Le fait de commencer

• Qu'est-ce qui Programme?
• Le Rédacteur en chef
• Variables dans Lua
• Commentaires - Mots clé
• LUA - Mathe
• Les opérations de Comparaison / les Opérations Logiques
• Gros morceaux / Blocs
• Fonctions
• Tables

Lua - Fonctions

• Fonctions Fondamentales
• table

L'autre

• Différents Rédacteurs en chef
• Pacman pour LuaX avec SDL

Utiliser Lua dans C

• Bonjour le Monde avec Lua

Liens(Liaisons)

• Liens(Liaisons) dans anglais

Quelles sont des variables ?

Nous travaillons avec un ordinateur et avons beaucoup de valeurs pour tenir dans la tête quand nous avons besoin d'eux plus tard sur. Ces données seront conservées dans la mémoire d'ordinateurs à un certain endroit. Comment ce sera fait et où cette mémoire est trouvée ... nous n'avons pas besoin de le savoir(connaître) pendant que nous travaillons avec LUA.

Pourtant, pour être capable de travailler avec ces variables plus tard sur nous leur donnons des noms. Avec ces noms nous renverrons les données à la chaque fois nous avons besoin d'eux.



Il n'a pas d'importance comment nous appelons une variable. Pourtant, il y a quelques règles de réfléchir.

• Un nom variable doit commencer avec une lettre (le caractère) ou le fait de souligner.
• Le haut de cas se et le bas de cas se dans un nom d'une variable sont très importants: player1 n'est pas égal à Player1
• Seulement les caractères, numérote le fait de souligner sont permis.

Il y a des régions(domaines) existantes, où les Variables sont vaild. Les raisons sont différentes mais c'est utile. Dans beaucoup de langages de programmation il y a différent sopes de d'application existant.

LUA offre seulement deux (heureusement).

• Global
• Local

Globalvariables existent allways et partout.

Les Variables locales Local es existent seulement dans le bloc où ils ont été créés et ils existent aussi longtemps que le bloc est actif. Nous devons seulement considérer une exception. Ce sera expliqué au chapitre "Functions".

Quelque chose des blocs:

Au langage de programmation LUA tout sera fait à l'intérieur des blocs. Ils commencent avec une déclaration, suivie par un bloc d'attributions et finalement le mot "la fin" (de nouveau avec une exception; expliqué plus tard sur). Les blocs peuvent aussi être insérés et existant à l'intérieur d'autres blocs.

Nous rencontrerons souvent de nouveau des blocs. Pourtant, j'essaierai de visualiser la différence entre local et global.

Imaginez une maison faite du verre. Vous pouvez feuilleter le verre dans une direction seulement. De n'est pas dehors possible de regarder à l'intérieur de la maison, qui devrait être notre bloc. Les variables, appelées comme local à l'intérieur de notre maison de verre, ne peuvent pas être vues de l'extérieur de la maison. Seulement les variables sans le mot local devant cela peuvent être vues de l'extérieur de notre maison. On appelle de telles variables globales.

Pour le compilateur une variable locale sera identifiée, quand il a le mot local devant cela.

À propos, local et end sont deux des mots réservés dans LUA.



Les variables conservent des valeurs. Ces valeurs peuvent être de la différente sorte. Ils peuvent être des nombres, les caractères (les ficelles(chaînes)), les conditions (vrai ou faux) etc.

Là existent :

• Nil (rien) (de vide) ( n'existant pas)
• nombres
• charcacters (les lettres, les mots, etc.)
• les conditions (vraies/fausses) (oui/non) (1/0)
• les fonctions (comme le cas spécial d'un bloc)

Deux d'autres existent, mais au-dessus mentionné devrait être enugh pour ce moment.



Même il n'y a presque rien pour répéter du NIL, nous sommes heureux qu'il existe. La chaque fois nous voulons travailler avec une variable qui n'existe pas, nous renverrons le NIL de valeur. Notre ordinateur ne s'écrase pas, ne fera rien d'étrange ou enchaînera demi-cadratin l'erreur.

Si nous voulons effacer une variable, nous allouons nil de valeur à cette variable. Maintenant, notre variable n'existe plus.


Attribution :

Jusqu'à maintenant, nous avons déjà appris beaucoup de variables. Mais pas, comment allouer ou allouer une valeur à une variable. Comme nous avons une valeur maintenant, nous ferons ainsi

willi234 = nil

"Le =" est appelé l'opérateur d'allocation (l'attribution). Avec cet opérateur notre variable willv234 sera allouée au ZÉRO de valeur. Notre variable a été effacée.



Comme chacun sait, nous avons besoin des nombres pour le calcul. Donc on appelle ce type "le nombre". Presque dans tous les langages de programmation il y a des différences existant dans le type "le nombre". À LUA, nous n'avons pas de différences.

Allocation (Attribution)

_lAgeDeLaMamie = 74
lIntelligenceDeWilli = 105
monDepot = -55.26
uneRacineDonc_a_MoitieDe2 = 0.707107


Dont c'est le code ?

• Don' l'utilisation une virgule pour le point décimal de nombres. Utilisez le point.
• Pour utiliser les nombres negativ (comme ma balance) utilisent un moins devant.
• L'attribution avec l'opérateur =
• Les différentes notations de noms pour les variables.

Nous avons non seulement des nombres pour travailler avec. Par exemple nous voulons aussi écrire quelque chose sur l'écran. Pour ce but nous avons vraiment un autre Type: "string"

Une string est une concaténation d'ASCII-valeurs (qu'est-ce qu'est cela ? ? ?)

Le rendre facile : ceux-ci sont des nombres aussi. Comme nous les avons déclinés comme une ficelle(chaîne), notre ordinateur sait qu'il doit calculer avec eux.

Un caractère peut être représenté par une valeur de nombre entier qui est conservée dans la gamme de 0 à 255.

Par exemple : un caractère sera conservé et à l'intérieur de la mémoire nous avons le nombre entier numéro 56. C'est égal au caractère "D"

Pour cette compilation l'ordinateur aura l'approche à l'ASCII [1] - la table.

Une concaténation du numéro 76, 85 et 65 signifiera LUA après la compilation.


Attribution :


leNomDeLaMamie = "Mlle Elly"
leNomDuBistroDeWilli = 'le Nœud de Diamand'
varTyp1 = "function"
myCV = [[ né : oui lieu de naissance : aucune idée ]]


Dont c'est le code ?

Les ficelles(chaînes) seront fixées à l'intérieur des guillemets. Vous pouvez utiliser la citation double aussi bien que la citation simple (qui aura de benfit plus tard sur). Pourtant, cela doit être la même sorte de citation au commencement et à la fin.

Nous pouvons aussi inclure le texte dans [[ et ]]. Avec ces parenthèses nous serons capables de continuer notre texte à une nouvelle ligne.

L'attribution avec l'opérateur =

Les ficelles(chaînes) et les nombres peuvent être concaténés très facilement. Pour ce but nous devons utiliser deux points. Nous ne devons pas convertir le nombre en ficelle(chaîne).

Exemple:

print( "Player"..5 )




Avec les conditions nous avons vraiment un type de variable qui sait(connaît) seulement 2 conditions. Ce type est appelé "booléen" et peut être désigné différemment comme montré au-dessus. Avec LUA nous utilisons vrai et faux.

Allocation (Attribution) :

williEstSoul = true
siLaMamieEstMechante = false
lEpouseDeWilliEstMechante = true

Dont c'est le code ?

• Une Attribution sera faite avec les mots réservés true ou false.
• Willi ne devait pas tant pinter

Les fonctions sont des variables qui font quelque chose quand on les appelle. Nous serons souvent retenus dans l'utilisation des fonctions plus tard sur.

Les fonctions seront commencées l'un ou l'autre avec


Calcule = function()
-- ou avec
function Calcule()

et ils seront finis avec

end

Comme montré au-dessus, nous voyons qu'il y a deux possibilites existant pour allouer une valeur au type "de fonction" variable. Tous les deux sont équivalents.

Entre le commencement et la fin d'une fonction il y a le bloc qui décrit ce qui doit être fait.

Maintenant, nous viendrons à l'exception de local.

Hypothèse : nous avons vraiment un bloc qui est une fonction globale. À l'intérieur de ce bloc nous avons vraiment une variable locale, qui sera utilisée de cette fonction. Après le fait d'exécuter ce bloc la variable (locale) existe toujours à l'intérieur de la fonction, mais seulement à l'intérieur de cette fonction.

Exemple :


do -- le Début de bloc
local cnt = 1 -- alloué pour ce bloc
function inc () -- la création d'une fonction
cnt = cnt + 1 -- a variable cnt sera utilisé
return cnt -- le fait de rendre la valeur pour le contrôle
end -- la Fin de fonction
end -- la Fin de bloc

print(inc()) --> la Production 2
print(cnt) --> la Production nil

Cette variable n'est pas seulement une copie qui sera transférée à la fonction. Apperently c'est la variable lui-même, qui vit dans le twilightzone entre global et local.

(Ma) preuve, que ce n'est pas une copie, mais la variable originale :

do
local cnt = 1
function inc ()
cnt = cnt + 1
return cnt
end
cnt = 5 -- la Valeur sera changé après le fait de créer la fonction
end

print(inc()) --> la Production 6



Les tables sont des variables conservant d'autres variables à l'intérieur d'eux.

Variable - table de Type

La variable de type "la table" rend le travail avec les colonnes plus facile. Nous avons le possibilty pour arranger notre chaos ou apportant la lumière dans l'obscurité.;)

Ce type de variable nous retiendra pendant longtemps. Avant tout une pénétration brève.

Attribution :


maTable = {}

Dont c'est le code ?

Nous savons(connaissons) déjà le nom et l'opérateur pour une allocation.

Une table sera entourée dans {pour le commencement et} pour la fin.

Entre {et} nous pouvons conserver des variables. Dans notre exemple il n'y a aucune valeur à l'intérieur {et}. Donc nous avons une table vide.

Un exemple court sans explication. Ne vous inquiétez pas, cela suivra plus tard sur.;)

Attribution :

maTable = { 1, 4, "Willi", true, function() faisQuelqueChose end }
maTable2 = { X= 255 , Y =10, vitesse =88)

le fait de lire à haute voix les valeurs :

• maTable[1] -> 1
• maTable[2] -> 4
• maTable[3] -> "Willi"
• maTable[4] -> true
• maTable[5] -> function() machwas end
• maTable2.X -> 255
• maTable2.Y -> 10
• maTable2.vitesse -> 88
• maTable2["vitesse"] -> 88

Comme nous pouvons voir, il y a deux différentes sortes de tables existantes. Un avec les nombres et d'autre avec les noms.

Encore un commentaire : les tables peuvent inclure d'autres tables comme les variables.

À l'intérieur de la table il n'est pas essentiel de devoir chercher un arrangement bon et nécessaire comme il sera facile de vivre avec ce chaos à l'intérieur d'une table.

C'était une introduction courte et brève de variables utilisées pour programmer dans LUA. La poursuite préalable de l'apprentissage de LUA, je voudrais (ont mieux à) montrer que j'ai fait une fraude. Une fraude de la voie j'écris les noms de variables.

Nous avons appris que nous n'avons pas de restriction dans l'énumération des variables à part quelques restrictions.

Pourtant, il est conseillé de prendre des dispositions pour cela. Nous pouvons imaginer beaucoup d'activité.

Mon propre arrangement:

• Dans es variables générales commencera avec un bas de cas se
• Les noms de fonctions commenceront avec un haut de cas se
• Les paramètres (nous apprendrons de plus tard) sera commencé avec le fait de souligner
• Chaque nouveau mot dans le nom des variables est écrit en majuscules encore. Cela sert à la lisibilité.

Dernier mais pas le moins(moindre) : les variables ne sont pas restreintes par leurs types. Une variable de nombre peut être changée dans une ficelle(chaîne)-varibale par une attribution nécessaire par exemple.

[1] ASCII / le Code Standard américain pour l'Échange D'information