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

Soyez bienvenus à une grande spécialité de LUA!

Les tables sont les plus confortables dans LUA que je voyais jamais . Pas qu'ils seraient compliqués beaucoup, mais ils sont si étendus et si bons pour utiliser que nous serons occupés de cela pendant longtemps. Fondamentalement nous n'allons pas arrêter d'être occupés de cela, parce que LUA complet existe dans une table.

À savoir dans


Tout, simplement tout ce qui est connu dans LUA est trouvé dans la table _G.
Si quelque chose n'est pas incluse dans _G il n'existe pas ou c'est quelque part local. (existant ou seulement existant si le selon le gros morceau est exécuté)

En outre, plusieurs fonctions préparées sont disponibles dans quelques LUA-tables. Cela nous aide, parce que nous ne devons pas développer beaucoup de fonctions comme ils existent déjà . Et ces fonctions sont beaucoup plus rapides aussi.
Pourquoi plus vite ? Ils ont été écrits dans le langage de programmation "C" surtout. Cette langue est très près du système d'exploitation.
Cette langue n'est pas facile de programmer. "C" n'est pas aussi facile que LUA mais c'est environ 3 fois plus vite que LUA.
(Mais LUA est très rapide aussi)

Il semble que cette introduction a été plus longue que la préface de la classe de travaux dirigés.;) C'est ça

Que sommes-nous au courant des tables ?

• C'est une variable
• Comme chaque variable il a un nom
• Une table commence avec {
• et sera fini avec }
• Une table peut inclure d'autres variables (toutes les variables et aussi d'autres tables)
• Il y a 2 différente sorte de tables existantes
• Il peut être du type numérique myTable [4]
• ou il peut avoir un nom myTable.myVariable

Das wichtigste überhaupt, ist, dem Übersetzer zu sagen, wir machen ein table
Das sagen wir ihm in dem wir das table initialisieren.

meinTable = {}

Maintenant l'interprète sait que tout ce qui suit et a ce nom appartient à cette table
(il est aussi possible de directement allouer des valeurs mais ce sera appris plus tard)


Maintenant nous retravaillons notre script d'une façon que toutes les valeurs sont une partie d'une table. Cela deviendra uniforme et régulier. Vous verrez.

Point de départ:

joueur1Nom = "Ossler"
joueur1Or = 1000
joueur1Lebt = true
joueur2Nom = "Lorender"
joueur2Or = 1500
joueur2Lebt = true

Le selon les tables:

Initialisation:

joueur1 = {}
joueur2 = {}


Le fait d'allouer la Version 1 de valeurs

-- Joueur 1
joueur1.nom = "Ossler"
joueur1.or = 1000
joueur1.lebt = true

-- Joueur 2
joueur2.nom = "Lorender"
joueur2.or = 1500
joueur2.lebt = true
joueur2.pierre = 800


Le fait d'allouer la Version 2 de valeurs

-- Joueur 1
joueur1 = {
nom = "Ossler", -- n'oublie pas la virgule
or = 1000, -- n'oublie pas la virgule
lebt = true, -- n'oublie pas la virgule (comme c'est le dernier index, vous pouvez aussi le quitter(laisser))
}
-- Joueur 2

joueur2 = {
nom = "Lorender",-- n'oublie pas la virgule
or = 1500, -- n'oublie pas la virgule
lebt = true, -- n'oublie pas la virgule
pierre = 800, -- n'oublie pas la virgule (comme c'est le dernier index, vous pouvez aussi le quitter(laisser))
}

En allouant la Version 3 de valeurs (cette version peut être un petit peu déconcertante; faites attention)

joueur1 = {nom = "Chepulis", or = 1000, lebt = true}

Toutes les 3 versions sont absolument équivalentes. Il dépend de l'aperçu et ce qui est approprié.

Un exemple d'une table qui inclut une autre table:

joueur1.position = { X = 120, Y = 360}

Cela doit être créé comme:

joueur1 = {}
-- nous désignons le joueur 1 d'être une table
joueur1.position = { X = 120, Y = 360}
--[[nous l'allouons aussi joueur1.position est une table et nous allouons selon les valeurs]]

Toutes les versions sont absolument équivalentes. Il dépend de l'aperçu et ce qui est approprié. Nous allons utiliser tous.

Peut-être je suppose que la plupart de ces choses sont déjà connues mais j'apprécie des tables beaucoup. Donc continuons.

La version 1. Que faisons-nous ?

Nous allouons une valeur à une variable. C'est quelque chose que nous savons déjà .
Mais il y a un point à l'intérieur. Ainsi que ?
Le point nous dit, que sur le côté gauche il y a la mère et sur le côté juste il y a son enfant. Pour l'instant si bon.

Une mère peut avoir beaucoup d'enfants. Et pareillement dans la vie réelle chaque enfant est différent.
Et et les enfants des enfants ? C'est aussi possible comme nous ne vivons pas dans la Chine. Vous devez seulement allouer cela là existe des enfants des enfants.

mutter = {} -- nous le définissons il y a des enfants
mutter.tochter = {} -- nous le définissons il y a des enfants
mutter.tochter.kind = 5

Et l'enfant ? Il peut aussi avoir des enfants.

mutter = {} -- nous le définissons il y a des enfants
mutter.tochter = {} -- nous le définissons il y a des enfants
mutter.tochter.kind = {} -- nous le définissons il y a des enfants
mutter.tochter.kind.kindesKind = "willi"

Et cela pourrait continuer et continuer. Pourtant, comme la largeur de notre écran n'est pas assez large nous nous arrêterons.
Et si un de nos enfants n'a pas d'enfant ? Aucun problème du tout. Nous programmons dans LUA.

mutter = {} -- nous le définissons il y a des enfants
mutter.tochter = {} -- nous le définissons il y a des enfants
mutter.tochter.kind2 = 5
mutter.tochter.kind1 = {} -- nous le définissons il y a des enfants
mutter.tochter.kind1.kindesKind1 = "willi"
mutter.tochter.kind1.kindesKind2 = "elvira"
mutter.tochter.kind1.schuhGroesse = 46

D'accord ? Ces tables sont très rarement mais c'est bon savent comment les créer et utiliser. Pourtant, vous voyez que ceux-ci présentent sont durs de lire.


Mais il y avait une autre sorte d'une table. Le numérique.




mutter = {}
mutter[1] = true
mutter[2] = "Schweißfüße"

Ils peuvent aussi avoir des enfants. Aussi bien que les autres. Pourtant, la variété des possibilités le rend un peu plus complexe maintenant.
Il est plus facile de marcher cette voie:

mutter = {}
mutter[1] = {}
mutter[1][1] = "Ottoplatte"

Il semble être idiot mais les valeurs peuvent être 0, les nombres négatifs ou décimaux. Il n'a pas d'importance du tout. LUA change toutes ces valeurs dans une voie que nous n'en prenons pas de notes. Comme montré au-dessus au chapitre "les Tables avec les Noms".
Mais nous prenons des nombres pairs comme c'est plus facile pour nous.

Bien que, nous puissions faire le fait d'exercer ce qui est possible.

À LUA nous pouvons faire beaucoup de choses qui sont impossibles dans d'autres langages de programmation. Pourtant, c'est trop pour moi maintenant et je suis fatigué, donc je veux aller dormir. Je continuerai à travailler avec cette classe de travaux dirigés demain.

Je devine, nous devons l'apprendre par une application.

-- Joueur 1

joueur1[1] = "Ossler"
joueur1[2] = 1000
joueur1[3] = true

-- Joueur 2

joueur2[1] = "Lorender"
joueur2[2] = 1500
joueur2[3] = true
joueur2[4] = 800

Cette voie est bien, mais non raisonnable pour notre but. Nous devrions tenir dans la tête [que 1] est le Nom, [2] est D'or, [3] est IsAlive et [4] est la Pierre.

Si nous serions capables de le mélanger, ce serait mieux pour nous. Heureusement, c'est possible.


joueur = {} -- pour tout suite aux tables

-- Joueur 1

joueur[1] = {}
joueur[1].nom = "Chepulis"
joueur[1].or = 1000
joueur[1].lebt = true

-- Joueur 2

joueur[2] = {}
joueur[2].nöm = "Nagle"
joueur[2].or = 1500
joueur[2].lebt = true
joueur[2].pierre = 800

Grand, c'est tout à fait bon. Par exemple nous sommes maintenant capables de chercher via une boucle que le joueur est vivant ou que le nom est Nagle ou que jamais nous voulons savoir(connaître).

Mais, nous ne savons(connaissons) pas la grandeur de la table! ? Nous allons l'apprendre dans un autre chapitre. Ne paniquer pas.

Nous pouvons mélanger ces méthodes de beaucoup de différentes façons. Nous devons seulement tenir dans la tête pour penser, ce qui est raisonnable pour notre but.

famille = {}
famille[1]={}
famille[1].mutter="Erna"
famille[1].vater="Horst"
famille[1].kinder={}
famille[1].kinder[1]="Jessica"
famille[1].kinder[2]="Thomas"


Une autre peinture: