|
Documentation language LUA |
Les fonctions du noyau LUA |
Ces fonctions permettent d'accéder aux
fonctionnalités du noyau de Lua. Nous n'entrerons pas dans le
détail au sujet de toutes les matières ici.
Semblable assert() à la fonction en C. Si
la condition d'essai est fausse ou zéro une erreur est augmenté ;
autrement examinez est retourné. Un message facultatif
est retourné au lieu d'un message système. En outre, voyez error() la fonction. Par exemple,
> assert(1==1) -- aucune erreur comme essai
n'était > assert(1==0) stdin:1 vrai : l'affirmation a échoué
! traceback de pile : [ C ] : dans le ` de fonction
affirmez 'stdin:1 : dans le gros morceau principal [ C ] :
? > assert("green"=="blue", "couleurs") stdin:1 non égal
: Traceback non égal de pile de couleurs : [ C ] :
dans le ` de fonction affirmez 'stdin:1 : dans le gros
morceau principal [ C ] : ?
Beaucoup de fonctions de Lua, comme io.open,
renvoient une valeur sur le succès, ou renvoient zéro et un message
d'erreur sur l'échec. Ceci fonctionne bien avec assert:
dossier = assert(io.open(filename))
Ce ou s'ouvre filename pour la lecture et
l'assigne à file, ou elle soulève une erreur avec le message
en la deuxième valeur de retour de io.open.
Fixe la limite d'attribution de mémoire à laquelle le collecteur d'ordures s'appellera. Si la nouvelle limite est moins que la quantité courante d'attribution de mémoire de Lua, ou aucun argument n'est donné, le collecteur s'appelle immédiatement. Voyez le GarbageCollectionTutorial pour plus d'information dessus.
> = gcinfo() -- trouvez la stat courante de mémoire,
c.-à-d. 21kb a employé 21 35 > bigalloc = string.rep('a ', 100000)
-- créez une grande corde > = le gcinfo() -- 164kb a assigné
maintenant 164 327 > collectgarbage() -- collection de force > =
gcinfo() -- nous avons libéré une certaine mémoire sur la
collection 139 278 > bigalloc = zéro -- libèrent la corde que nous
avons créée > = gcinfo() -- il n'est pas supprimé jusqu'à ce que
ses 140 278 rassemblés > collectgarbage() -- nous rassemblons > =
gcinfo() -- il est supprimé 29 59
_G est une variable globale qui se dirige à
l'environnement global. Par exemple pour montrer toutes les
variables de globals nous pourrions faire ce qui suit :
> table.foreach(_G, table de corde de print) : fonction de 00357098 xpcall : fonction 00354E10 tostring : fonction du gcinfo 00354708 : fonction du loadlib 00354E90 : table d'OS 00358B40 : 00355AE0 déballent la fonction : 003547C8 le niveau 2 exigent la fonction : fonction du getfenv 00354F90 : 00354548... -- etc...
_G est également récursif en tant que _G vies
dedans _G! C.-à-d. le suivant tout le point à la
même table (qui tient les variables globales) :
> = _ table de G : 00353710 > = _ table de G._G : 00353710 > = _ table de G._G._G : 00353710
Lua lui-même n'emploie pas cette variable, ainsi
changer sa valeur n'affecte aucun environnement. Vous devriez
employer setfenv() pour changer des environnements.
for i,v in ipairs(t) do ... end réitère
au-dessus des paires (1, t[1 ]), (2, t[2 ])..., jusqu'à la première
clef de nombre entier avec une valeur de zéro dans la table.
Cette fonction lie le programme avec la
bibliothèque dynamique de C "libname". À l'intérieur de
cette bibliothèque, elle recherche une fonction "funcname" et
renvoie cette fonction comme fonction de C. libname doit être le
nom de fichier complet de la bibliothèque de C, y compris n'importe
quels chemin et prolongation certains. Cette fonction n'est pas
soutenue par la norme ANSI C. En tant que tels, elle est
seulement disponible sur quelques plateformes (Windows, Linux,
Solaris, schéma, plus d'autres systèmes d'Unix qui soutiennent la
norme de dlfcn).
loadlib vous donne la capacité d'augmenter vos manuscrits de lua
avec des fonctions de C écrites par art de l'auto-portrait. L'exemple
suivant devrait vous donner quelques conseils si vous voulez mettre en
application votre propre substance. Ceci a été examiné dans
Linux mais devrait travailler à d'autres plateformes aussi.
Vous devriez savoir créer les bibliothèques des programmes
résultants partagées. Tous les dossiers dans l'exemple
devraient être dans le même annuaire.
/ * mylib.c pourrait ressembler à ceci : */#
incluent "lua.h" # incluent "" de stdio.h/* cette fonction sera
exportée vers le lua */lua_myfunc(lua_State interne statique * l)
{printf("blabla") ; retour 0 ; }/* cette fonction est
notre initialisation */init(lua_State interne * l) {fonctions
personnelles printf("Registering") ; lua_register(l, "myfunc",
lua_myfunc) ; printf("Done s'enregistrant") ; retour 0 ;
}
Compilez-maintenant le comme bibliothèque (dans * niez ou Cygwin) :
GCC - Mur - g - O2 - lua-config partagées de ` -- include` - c mylib.c - GCC mylib.o - mur de o mylib.o - g - O2 - lua-config partagées de ` -- lua-config de ` d'include` -- libs` - o mylib.a
Après que ceci vous devrait avoir un dossier
appelé mylib.a, c'est notre bibliothèque. Laisse
maintenant écrire un manuscrit simple d'essai dans le lua :
luainit = loadlib("./mylib.a", "init") -- appelez
maintenant la fonction enregistrée par print("New de luainit() de
routine d'initialisation : ".. myfunc) -- commencez le nouveau
print("well de myfunc() de fonction fait.")
print peut être passé à tout nombre de virgule
seperated les arguments qu'il imprime les valeurs de au stdout. print des utilisations tostring de convertir les arguments
en corde forment pour être imprimées. Par exemple.
> print(1,2, "bouclent ma chaussure", 22/7) 1 2 bouclent ma chaussure 3.1428571428571
print est très simple et pas le recurse dans des
tables imprimant le contenu, il imprimera juste le type et une
identification unique.
>}) table print({1,2,3 : 002FE9C8
print ne compose pas le texte. Afin de faire ceci
vous devriez employer string.format() la fonction en même temps que print (voir le StringLibraryTutorial) par exemple,
> print(string.format("Pi est approximativement
%.4f", 22/7)) pi est approximativement 3.1429
tostring convertit son argument (juste son premier argument s'il y
a plus de d'un) en corde et retours qui ficellent. print est
employer mis en application tostring ainsi vous êtes probablement
déjà au courant du format de rendement. Des valeurs simples
(nombres, chaînes de caractères , booleans, et zéro) sont converties comme vous
prévoyez probablement. Des Tableaux, Userdata, et les fils,
sont imprimés comme table de ` : ', userdata de ` : ', ou
fil de ` : ', suivi de l'adresse d'un objet interne
d'interprète (qui devrait dans aucun cas être compté au moment).
Notez cela différent print, tostring n'imprimez rien, lui les convertis justes son argument
à une corde et des retours il.
tostringle 'comportement de s est extensible. Si la valeur
à convertir a un metatable avec __tostring une entrée puis que
l'entrée s'appelle avec la valeur à convertir et le résultat de cet
appel est retourné. Ceci vous permet de changer comment tostring des travaux sur (certaines) tables, en leur donnant un
metatable avec __tostring une fonction qui exécute la conversion
que vous voulez.
type renvoie une corde décrivant le type de l'objet
passé à lui.
> = type(1), type(true), type("hello"), type({}), fonction
booléenne de table de corde de nombre de fin de type(function())
La note, le type de nil est "zéro".
> = zéro de type(nil)
Les types possibles retournés dans Lua 5.0 sont : "numérotez", "corde", "booléen," table "," fonction "," fil ", et" userdata ". Un "fil" est un coroutine, et l'"userdata" est un type de données de C avec une référence à lui dans Lua.
unpack prend les éléments d'une liste et les renvoie,
par exemple :
> = unpack({1,2,3}) 1 2 3 > = unpack({"one", 2, 6*7}) un 2
42
Le nombre d'éléments déballés est défini par la taille de la table, qui n'est pas nécessairement le nombre d'éléments dans la table ! Voyez le TableLibraryTutorial pour plus de détails sur ceci.
> t = {"one", 2, 6*7} > t.n = 2 > = table.getn(t) 2 > =
unpack(t) un 2
Directement de du manuel, _VERSION est "une
variable globale (pas une fonction) cette des prises une corde
contenant la version courante d'interprète."
> = _ VERSION Lua 5.0
 www.loriotpro.com |
|