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

assert(la condition [, le message])
collectgarbage ([la limite])
dofile(nomDeFichier)
error(leMessage [, leNiveau])
gcinfo()
_G
getfenv (f)
ipairs (table)
loadfile(nomDeFichier)
loadstring (string [, chunkname])
next(table[, index])
pairs (table)
pcall (myFunktion, Parameter1, Parameter2, ...)
print (e1, e2, ...)
rawequal (v1, v2)
rawget (table, index)
rawset (table, index, value)
require (packagename)
setfenv (f, table)
setmetatable (table, metatable)
tonumber (e [, base])
tostring (e)
type( variable )
unpack (list)
_VERSION
xpcall (f, err)


Aussitôt que la condition sera fausse ou zéro, le programme(l'émission) sera arrêté et rend le message.

Le message ressemble :

filename:lineNo:message

Meule traceback :

Ensuite nous obtenons l'information où le problème est trouvé.

exemple:

assert( 1 == 2, "c'est incorrect" )

--> Nom du fichier:Numéro de lignes:c'est incorrect




Der garbage collector. L'éboueur.

Comme le nom répète déjà, avec cette fonction l'éboueur du programme(de l'émission) peut être commencé. La limite spécifie la grandeur de la mémoire réservée du collectionneur cargabe.
L'éboueur nettoie la mémoire d'espace occupé. Spécifier la limite est optionnel. Si aucune limite n'est spécifiée, la fonction prend 0.


exemple:

print( gcinfo()) --> 17 29
grosserString = string.rep('a', 100000) -- beaucoup de mémoire sera utilisée
print( gcinfo()) --> 322 197
collectgarbage (10000)
print( gcinfo()) --> 163 10000 apparemment il n'a pas été utilisé autant de mémoire que nous avons pensé. La limite est montrée à 10000.
collectgarbage (5)
print( gcinfo()) --> 139 279 quelque chose a été trouvée, donc la limite de 5 nous mettons, semble être trop petit.
grosserString = nil -- la valeur de bigString n'est disponible plus. Nous avons été effacés cela.
collectgarbage ()
print( gcinfo()) --> 29 59


!!!!!!!!! Depuis lua 5.1 collectgarbage ("count") a été remplacé la fonction gcinfo () !!!!!!!!!!



S'ouvre le dossier a appelé nomDeFichier et l'exécute au Lua-code.

Revenez : que le dossier rend comme le résultat de code de dossier.

Avec cette fonction nous serons capables de déchirer notre projet dans n'importe quels dossiers séparés. Il est alors tellement, comme si c'était écrit dans un coulage.
Il est alors tellement, comme si c'était écrit dans un coulage.

exemple:

Le dossier 1 (Unit1.lua)

return "je suis le Dossier 1"

Le dossier 2 (Unit2.lua) <-- est exporté ( lancé )

print( dofile("Unit1.lua") ) --> je suis le Dossier 1



error de fonction rend l'insecte qui a été produit par le dernier code exécuté dans le sujet à la valeur leNiveau et fait avorter le programme(l'émission).

Pour expliquer leNiveaude paramètre je vous montrerai la fonction suivante:


1 function IchHabDenFehler()
2 a = ""
3 print( a..b ) -- b sont le nil donc l'erreur
4 end
5
6 function myError()
7 _, cError = pcall(IchHabDenFehler) -- à cette ligne la fonction sera exécutée avec pcall (protégé)
8 end
9
10 function Call_1()
11 error(cError,1) -- le Message d'erreur sera rendu et le programme(l'émission) sera fait avorter.
12 end
13
14 function Call_2() -- une sorte de station intermédiaire
15 Call_1()
16 end
17 myError() -- l'appel de fonction, qui crée l'erreur dans un environnement protégé
18
19 Call_2() -- l'appel de fonction qui rend l'erreur en utilisant la station intermédiaire


Qu'est-ce qui arrive ?

• Toutes les fonctions seront importées / lu dans.
• La fonction myError sera exécutée.
• Cela appelle dans un environnement protégé la fonction IFoundTheBug en utilisant pcall.
• En utilisant pcall le message d'erreur ne sera pas le retour directement.
• Le message sera conservé dans cError.
• Alors la fonction Call_2 sera exécutée.
• Cela commence Call_1
• La fonction Call_1 rend la personne à charge cError sur leNiveau.

Maintenant les résultats :

leNiveau = 0 --> l'erreur/insecte sera rendu rapidement.



leNiveau = 1 --> un niveau auparavant



leNiveau = 2 --> de nouveau un niveau auparavant



leNiveau = 3 --> 3 niveaux auparavant





!!!!!!!!! Ab lua 5.1 ersetzt collectgarbage("count") diese Funktion !!!!!!!!!!

Cette fonction rend 2 valeurs.

• Le premier: la valeur de mémoire utilisée.
• Le deuxième: la valeur, de la mémoire réservée pour l'éboueur.

l'éboueur est un programme(une émission) travaillant indépendant, qui dégage la mémoire qui ne sera utilisée plus. Voir aussi collectgarbage

Les deux valeurs sont dans le kb.

!!!!!!!!! Depuis lua 5.1 collectgarbage ("count") a été remplacé cette fonction !!!!!!!!!!

Exemple:

print( gcinfo()) --> 17 29
grosserString = string.rep('a', 100000) -- beaucoup de mémoire sera utilisée
print( gcinfo()) --> 322 197



La fonction next ensuite l'index après l'index et chaque valeur associée de table d'une façon non classée. À l'index == le nil les retours next le premier index. Si le dernier index sera atteint, next le nil de retours.

Exemple:



Fonction (Adaptée) sentie inext:

function inext(_table, _index)
_index = next(_table, _index)
if _index then
if type(_index) ~= "number" then
repeat
_index = next(_table, _index)
if type ( _index) == "number" then
break
end
until not _index
end
end
return _index
end



La seule tâche pairs de fonction est, exécuter la fonction next et revenir le selon la table.

myFunc, myTable = pairs( table )

myFunc inclut la fonction next
et dans myTable la table rendue.

Nous pouvons le trouver dans le pour-boucle générique.



La seule tâche de la fonction ipairs ressemble next et revenir le selon la table.
Supposons la fonction inext existerait (semblable à la fonction ensuite aux paires) et il rendrait la chose suivante:

myFunc, myTable = ipairs( table )

Maintenant il y a une fonction existant dans semblablement à next. Pourtant, il rend seulement son index numérique suivant et rend la table allouée à myTable.


Nous pouvons le trouver dans le le pour-boucle générique.



Ouvre le nomDeFichier de dossier et l'exécute, mais pas comme le Lua-code.

Retours 2 valeurs :

• le dossier compilé comme la fonction. ( en cas d'erreur nil)
• le message d'erreur ( en existant, sinon le nil)

Exemple:

loadedFunction, cError = loadfile("dateiName.lua")

• si loadedFunction == le nil --> une erreur se produit. Le texte de message sera dans cError.
• Autrement, le dossier compilé sera dans loadedFunction comme la fonction.

La fonction pcall exécute la fonction myFunction avec le selon les paramètres.

La différence pour l'appel régulier: On ne le répondra pas directement sur une erreur.

La chose suivante de retours de fonction:

• tous ont passé de la façon juste --> true / l'erreur --> false
• suivi par les valeurs que les retours de fonction . En cas d'une erreur un selon le message d'erreur apparaît.

Exemple:



Le programme(L'émission) avorte et vous recevrez le message d'erreur.




Cette fonction rend une ficelle(chaîne) avec un type d'une variable.

Comme les paramètres nous devons réserver la chose suivante :

• La variable qui doit être vérifiée et la valeur qui devrait être allouée.

type (variable)

retours de possibel:

"nil, "number", "string", "boolean, "table", "function", "thread", und "userdata".


Exemple:

ensuivez_vous = type (5)
--> ensuivez_vous == "number"

maVar = "c'est une sentence"
ensuivez_vous = type ( maVar )
--> ensuivez_vous == "string"