introduction d'Une référence court sur Lua en PDF


Télécharger introduction d'Une référence court sur Lua en PDF

★★★★★★★★★★3.5 étoiles sur 5 basé sur 1 votes.
Votez ce document:

Télécharger aussi :


Introduction d'Une référence court sur Lua [Eng]

...

Pourquoi Lua?

Lua a été choisi comme le langage de script de choix en raison de sa rapidité, de sa compacité, de sa facilité d'intégration et surtout de sa courbe d'apprentissage douce. Ces caractéristiques permettent à l'utilisateur de créer des scripts simples jusqu'à des solutions de programmation avancées qu'un diplômé en informatique apprécierait. En d'autres termes, Lua a toute la profondeur et la sophistication d'une langue moderne, mais reste très accessible au non-programmeur.

Lua est originaire du Brésil et a un forum très actif et utile. Bien que conçu à l'origine comme un langage de description de données scientifiques, son plus grand domaine d'application unique a été le jeu sur ordinateur. Les caractéristiques qui le rendent populaire pour le jeu correspondent étroitement à celles requises pour l'acquisition de données - une machine de script efficace contrôlant un moteur d'acquisition rapide écrit dans le "Câ € ™.

Remerciements

Lua 5.1 Short Reference est une version reformatée et mise à jour de "Lua 5.0 Short Reference (draft 2)" d'Enrico Colombini dans lequel il a reconnu les autres "Je suis reconnaissant à tous personnes qui ont contribué avec des notes et des suggestions, y compris John Belmonte, Alberto Jan Brouwer, Tiago Dionizio, Marius Gheorghe, Asko Kauppi, Philippe Lhoste, Virgil Smith, Ando Sonenblick, Nick Trout et bien sûr Roberto Ierusalimschy, dont «Lua 5.0 Reference Manual» et 'Programmation à Lua' ont été mes principales sources de Lua loreâ € ™. Cette mise à jour Lua 5.1 reconnaît en outre et remercie Enrico Colombini pour son Lua 5.0 Short Reference (projet 2), 'Lua 5.1 Reference Manual' de Roberto Ierusalimschy et 'Programming in Lua, 2ème édition' et plus récemment - Lua Programming Gemsâ édité par Luiz Henrique de Figueiredo et al.

Cette mise à jour de Short Reference a été initialement faite comme un moyen de se familiariser avec Lua, donc elle a été éditée, clarifiée et étendue du point de vue d'un nouveau venu à Lua. Merci également à Matthias Seifert pour certains commentaires récents.

Lua Core Language

Mots réservés

et casser sinon elseif fin faux pour

fonction si en local nul ou pas

répéter le retour puis vrai jusqu'à ce que tout

_A ... Une variable système, où A n'importe quelle lettre majuscule.

Autres chaînes réservées

+ - * /% ^ # == ~ = <=> = <> = ()

{} []; :,. .. ...

Identifiants

Toute chaîne de lettres, de chiffres et de caractères de soulignement ne commençant pas par un chiffre et pas un mot réservé. Les identifiants commençant par des traits de soulignement et des majuscules sont réservés.

commentaires

- Commentaire à la fin de la ligne.

- [[...]] Commentaire multiligne (généralement - [[à -]])

#! Au début de la première ligne pour l'exécutable Linux.

Chaînes et séquences d'échappement

'' "" [[]] [= [] =]

délimiteurs de chaînes; [[]] peut être multi-ligne, les séquences d'échappement sont ignorées. Si [= [] =] le nombre de = doit s'équilibrer.

\ a - bell \ b - retour arrière \ f - retour de formulaire

\ n - nouvelle ligne \ r - return \ t - tab

\ v - vert. tabulation \\ - backslash \ "- guillemets doubles

\ '- guillemets simples \ [- crochet carré \] - crochet

\ ddd (caractère représenté nombre décimal).

Les types

Le type appartient à la valeur, PAS la variable:

booléen nil et faux compte comme faux, tout autre vrai, y compris

0 et chaîne nulle. Utilisez type (x) pour découvrir le type de x.

nombre 64 bit IEEE virgule flottante

chaîne Peut inclure zéro, haché en interne.

table Index par numéros, chaînes

function Peut renvoyer plusieurs valeurs

thread Une coroutine coopérative.

userdata C pointeur vers un objet C. Peut être assigné un metatable pour permettre l'utilisation comme une table ou une fonction

néant Une valeur spéciale signifiant «rien».

Opérateurs dans l'ordre de priorité

^ (droit-associatif, math lib requis)

pas # (longueur) - (unaire négatif) (unaire positif illégal)

* /%

+ à ¢ â,¬Â

.. (concaténation de chaînes, droit-associatif)

<> <=> =

et (s'arrête sur false ou nil, renvoie la dernière valeur évaluée)

ou (s'arrête sur true (pas faux ou nul), renvoie la dernière évaluation

valeur)

Exemples d'affectation et de coercition

a = 5 Affectation simple.

a = à ¢ â,¬Å "hià ¢ â,¬ Les variables ne sont pas tapà © es, elles peuvent contenir

différents types.

a, b, c = 1, 2, 3 Affectation multiple.

a, b = b, a Valeurs de swap, car les valeurs de droite

évalué avant l'affectation.

a, b = 4, 5, 6 Trop de valeurs, 6 est rejeté.

a, b = ã € ã € ã € € Trop peu de valeurs, nul n'est assigné à b.

a = la valeur précédente de nil a sera recueillie si

non référencé ailleurs.

a = #b Taille de b. Si table, premier index suivi de zéro.

a = z Si z n'est pas défini a = nil.

a = à ¢ â,¬Å "3â ¢ â,¬" 2â ¢ â,¬ Chaînes converties en nombres: a = 5.

a = 3 .. 2 Les nombres sont convertis en chaînes: a = "32".

Résultats d'expression conditionnelle

Faux: valeurs fausses et nulles uniquement

Vrai: tout ce qui n'est pas faux, y compris 0 et les chaînes vides

Exemples relationnels et booléens

 € "abcà ¢ â €" abeà ¢ â,¬ True: base premier caractère diffà © rà ©

 € "Abâ € â €" abcà ¢ â,¬ True: le personnage manquant est moins que tout

Portée, blocs et morceaux

Par défaut, toutes les variables ont une portée globale à partir de la première utilisation.

local Réduit la portée du point de définition à la fin du bloc.

var_name local initialisé à zéro. Locals significativement

plus rapide pour accéder

bloc Est le corps d'une structure de contrôle, le corps d'une fonction ou un morceau.

morceau Un fichier ou une chaîne de caractères.

Structures de contrôle

En suivant exp et var ont une portée locale

si exp puis bloquer {elseif exp puis bloquer} [else block] end

faire une fin de bloc (simplement un moyen de forcer la portée locale)

alors que exp fait la fin du bloc

répétez le bloc jusqu'à exp

pour var = from_exp, to_exp [, step_exp] fait la fin du bloc

pour var (s) dans itérateur, fin du bloc (var (s) local à la boucle)

break, renvoie une sortie, mais doit être la dernière en bloc

Constructeurs de table

t = {} Nouvelle table vide affectée à t.

t = {"yes", "no"} Un tableau, t [1] = oui, t [2] = non.

t = {[2] = "non", [1] = "oui"} Identique à la ligne ci-dessus.

t = {[-900] = 3, [900] = 4} Tableau fragmenté, deux éléments.

t = {x = 5, y = 10} Table de hachage t ["x"], t ["y"], t.x, t.y

t = {x = 5, y = 10; "oui", "non"} Champs mixtes: t.x, t.y, t [1], t [2].

t = {"choice", {"yes", "no"}} Table imbriquée. Voir table.insert () etc ci-dessous pour plus d'informations.



Définition de la fonction

Les fonctions peuvent renvoyer plusieurs résultats.

nom de la fonction (args) body [renvoie les valeurs] end

Fonction globale

nom de la fonction locale (args) body [return values] end

Fonction locale à tronçon.

f = corps de fonction (args) [valeurs de retour] fin

Fonction anonyme affectée à la variable f

function (...) body [renvoie les valeurs] end

(...) indique des arguments variables et {...} les place dans une table

accarré comme à° °.

function t.name (args) body [renvoie les valeurs] end

Raccourci pour t.name = fonction [...]

function obj: nom (args) body [renvoie les valeurs] end

Fonction d'objet obtenant l'arg supplémentaire supplémentaire.

Appel de fonction

f (args) Appel simple, renvoyant zéro ou plusieurs valeurs.

f arg Appel avec une seule chaîne ou un seul argument de table

t.f (args) Fonction d'appel stockée dans le champ f de la table t.

t: f (args) Abréviation de t.f (t, args).

arg: f Abréviation de f (arg).

Opérations métatables

Bibliothèque de base requise. Les opérations métatables permettent de redéfinir et

ajout de nouveaux comportements de table.

setmetatable (t, mt)

Définit mt comme métatable pour t, sauf si la variable metable a un

champ __metable. Retours t

getmetatable (t)

Renvoie le champ __metable de la variable metable, ou la variable metable,

ou nul.

rawget (t, i)

Obtient t [i] d'une table sans invoquer de métaméthodes.

rawset (t, i, v)

Définit t [i] = v sur une table sans invoquer de métaméthodes.

rawequal (t1, t2)

Renvoie la valeur booléenne (t1 == t2) sans invoquer de métaméthodes.

Champs modifiables pour les tables et les données d'utilisateur

__add Définit le gestionnaire h (a, b) pour '+'.

__sub Définit le gestionnaire h (a, b) pour le binaire '-'.

__mul Définit le gestionnaire h (a, b) pour '*'.

__div Définit le gestionnaire h (a, b) pour '/'.

__pow Définit le gestionnaire h (a, b) pour '^'.

__unm Définit le gestionnaire h (a) pour unaire '-'.

__concat Définit le gestionnaire h (a, b) pour '..'.

__eq Définit le gestionnaire h (a, b) pour '==', '~ ='.

__lt Définit le gestionnaire h (a, b) pour '<', '>' et '<=', '> ='

si non __le

__le Définit le gestionnaire h (a, b) pour '<=', '> ='.

__index Définit le gestionnaire h (t, k) pour un champ inexistant

accès.

__newindex Définit le gestionnaire h (t, k) pour l'affectation à non

champ existant.

__call Définit le gestionnaire h (f, ...) pour l'appel de fonction, en utilisant

l'objet en tant que fonction.

__tostring Définit le gestionnaire h (a) à convertir en chaîne, par ex.

pour imprimer ().

__gc Définit le finalizer h (ud) pour userdata (peut être défini

du côté C seulement).

__mode Mode table: 'k' = touches faibles, 'v' = faible

valeurs, 'kv' = les deux.

__metatable Valeur d'ensemble renvoyée par getmetatable ().

La bibliothèque de base

La bibliothèque de base fournit de nombreuses fonctions standard et ne nécessite pas de préfixe comme pour les bibliothèques de modules complémentaires.

Environnement et variables globales

getfenv ([f])

Si f une fonction, retourne son environnement; si f un nombre, retourne l'environnement de fonction au niveau f (1 = courant [défaut], 0 = global); si l'environnement a un champ __fenv, cela est retourné. setfenv (f, t)

Définit l'environnement pour la fonction f ou la fonction au niveau f (0 = fil courant); Retourne f ou rien si f = 0; si l'environnement d'origine a un champ __fenv, déclenche une erreur.

_G Variable dont la valeur = environnement global.

_VERSION Variable avec la version de l'interpréteur.

Chargement et exécution

exiger (module)

Charge le module et renvoie la valeur finale de package.loaded [module] ou déclenche une erreur. Dans l'ordre, vérifie si déjà chargé, pour le module Lua, pour la bibliothèque C.

module (nom [, ...])

Crée un module Si une table dans package.loaded [nom] est le module, sinon si une table globale t de nom, cette table est le module, sinon crée une nouvelle table t assignée à name. Initialise t._NAME pour nommer, t._M to et t._PACKAGE avec le nom du package. Fonctions optionnelles passées à être appliquées sur le module

dofile ([nom de fichier])

Charge et exécute le contenu du nom de fichier [par défaut: entrée standard]. Renvoie les valeurs renvoyées du fichier.

charger (fonction [, nom])

Charge un morceau en utilisant la fonction pour obtenir ses pièces. Chaque appel de fonction renvoie une chaîne (last = nil) concaténée. Renvoie le bloc compilé en tant que fonction ou nil et le message d'erreur. Nom de bloc facultatif pour le débogage.

loadfile (nom de fichier)

Charge le contenu du nom de fichier, sans l'exécuter. Renvoie le bloc compilé en tant que fonction, ou nil et le message d'erreur. loadstring (chaîne [, nom])

Renvoie le bloc de chaîne compilé en tant que fonction, ou nil et le message d'erreur. Définit le nom du morceau pour le débogage.

loadlib (bibliothèque, func)

Liens vers la bibliothèque dynamique (.so ou .dll). Renvoie la fonction nommée func, ou nil et le message d'erreur.

pcall (fonction [, args])

Les appels fonctionnent en mode protégé; renvoie vrai et résultats ou faux et message d'erreur.

xpcall (fonction, gestionnaire)

Comme pcall () mais passe le gestionnaire d'erreur au lieu d'args supplémentaires; renvoie comme pcall () mais avec le résultat de handler () comme message d'erreur, (utilisez debug.traceback () pour les informations d'erreur étendues).

Sortie simple et retour d'erreur

imprimer (args)

Imprime chacun des arguments passés sur stdout en utilisant tostring.

erreur (msg [, n])

Termine le programme ou le dernier appel protégé (par exemple pcall

()) avec le message d'erreur msg quoting level n [par défaut: 1, current

fonction].

assert (v [, msg])

Appelle l'erreur (msg) si v est nul ou faux [msg par défaut: "assertion

échoué!"].

Information et conversion

sélectionnez (i, ...)

Pour l'index numérique i, renvoie le i'th argument du ...

liste d'arguments. Pour i = chaîne - "" (y compris les guillemets) renvoie le total

nombre d'arguments y compris nil.

type (x)

Renvoie le type de x en tant que chaîne, par ex. "nil", "chaîne", "numéro".

tostring (x)

Convertit x en chaîne, en utilisant le paramètre __tostring de la table si

disponible.

tonumber (x [, b])

Convertit la chaîne x représentant un nombre dans la base b [2..36,

défaut: 10] à un nombre, ou nul si invalide; pour la base 10 accepte



format complet (par exemple "1.5e6").

déballer (t)

Retourne t [1] .. t [n] comme valeurs séparées, où n = #t.

Iterators

ipairs (t)

Retourne un itérateur obtenant l'index, les paires de valeurs du tableau t dans

ordre numérique.

paires (t)

Retourne un itérateur obtenant la clé, valeur paires de la table t dans aucun

ordre particulier.

suivant (t [, index])

Renvoie la paire de valeurs d'index suivante (nulle à la fin) à partir de l'index (valeur par défaut nulle, c'est-à-dire commençant) de la table t.

Collecte des ordures

collectgarbage (option [, v]) où l'option peut être:

 € ™ "arrête" Arrête la collecte des garbage.

 € ™ "restartÂ" Redémarrez la récupération de place.

 € "collectà ¢ â,¬ Lance une collecte garbage pleine.

 € "countâ € ¢ Renvoie la mémoire totale utilisée.

 € "stepâ € ™ Effectuer la taille de pas de récupération de place v, renvoie true si elle a terminé un cycle.

 € "setpauseà ¢ â €" Mettre en pause (par défaut 2) à v / 100. Les valeurs plus grandes sont moins agressives.

Coroutines

coroutine.create (fonction)

Crée une nouvelle coroutine avec fonction et la renvoie. coroutine.resume (coroutine, args)

Démarre ou continue à exécuter la coroutine en lui transmettant des arguments. Renvoie true (et éventuellement values) si coroutine appelle coroutine.yield () ou se termine, ou retourne false et message d'erreur.

coroutines.running ()

Retourne la coroutine en cours d'exécution ou nulle si le thread principal. coroutine.yield (args)

Suspend l'exécution de la coroutine d'appel (pas à partir des fonctions C, métaméthodes ou itérateurs), tous les arguments deviennent des valeurs de retour supplémentaires de coroutine.resume ().

coroutine.status (co)

Renvoie le statut de coroutine co en tant que chaîne: "running", "suspended" ou "dead".

coroutine.wrap (fonction)

Crée un coroutine avec la fonction en tant que body et renvoie une fonction qui agit comme coroutine.resume () sans premier argument et première valeur de retour, propageant les erreurs.

Modules et la bibliothèque de packages

Un package est une collection de modules. Un module est une librairie qui définit un nom global contenant une table contenant tout ce que le module met à disposition après avoir été require () module (module, ...)

Crée un module qui est une table dans package.loaded [module], une table globale nommée module ou une nouvelle table globale est créée package.path, package.cpath

Variable utilisée par require () pour un loader Lua ou C. Défini au démarrage des variables d'environnement LUA_PATH ou LUA_CPATH. (Voir Formats de chemin ci-dessous).

package.loaded

Tableau des paquets déjà chargés. Utilisé par require () package.loadlib (library, function)

Liens dynamiques vers la bibliothèque, qui doit inclure le chemin. Cherche la fonction et la retourne, ou 0 et un message d'erreur. package.preload

Une table pour stocker les chargeurs pour des modules spécifiques (voir require). package.seeall (module)

Définit une metatable pour le module avec le champ _index faisant référence à l'environnement global.

Formats de chemin

Un chemin est une séquence de modèles de chemin séparés par des points-virgules. Pour chaque gabarit, require (nom de fichier) remplacera chaque "?" Par nom de fichier, dans lequel chaque point est remplacé par un "séparateur de répertoire" ("/" sous Linux); alors il va essayer de charger le nom de fichier résultant. Exemple:

require (dog.cat) avec le chemin /usr/share/lua/?.lua;lua/?.lua va tenter de charger cat.lua depuis / usr / share / lua / dog / ou lua / dog /

La bibliothèque de table

Tableaux sous forme de tableaux (listes)

table.insert (table, [i,] v)

Insère v à l'index numérique i [par défaut: après la fin] dans la table, incrémente la taille de la table.

table.remove (table [, i])

Enlève l'élément à l'index numérique i [défaut: dernier élément] de la table, décrémente la taille de la table, renvoie l'élément supprimé. table.maxn (table)

Renvoie le plus grand index numérique positif de la table. Lent. table.sort (table [, cf])

Trie les éléments (in-situ) de la table [1] à la table [#t], en utilisant la fonction de comparaison cf (e1, e2) [par défaut: '<']. Peut échanger des égales. table.concat (table [, chaîne [, i [, j]]])

Renvoie une seule chaîne créée en concaténant les éléments de la table [i] à la table [j] (par défaut: i = 1, j = longueur de la table) séparés par une chaîne (par défaut = nil). Renvoie une chaîne vide si aucun élément donné ou i> j

Itérer sur le contenu de la table

Utilisez les itérateurs paires ou ipairs dans une boucle for. Exemple: pour k, v en paires (tableau), l'impression (k, v) fin imprimera la clé (k) et la valeur (v) de tout le contenu de la table.

La bibliothèque de mathématiques

Opérations de base

math.abs (x) Retourne la valeur absolue de x.

math.fmod (x, y) Renvoie le reste de x / y sous la forme d'un entier arrondi, pour y ~ = 0.

math.floor (x) Renvoie x arrondi à l'entier inférieur.

math.ceil (x) Renvoie x arrondi à l'entier le plus proche.

math.min (args) Retourne la valeur minimale des arguments. math.max (args) Renvoie la valeur maximale des arguments.

math.huge Renvoie le plus grand nombre représenté

math.modf (x) Renvoie un entier ET des parties fractionnaires de x

Exponentiel et logarithmique

math.sqrt (x) Renvoie la racine carrée de x, pour x> = 0.

math.pow (x, y) Renvoie x élevé à la puissance de y, c'est-à-dire x ^ y;

si x <0, y doit être entier.

math.exp (x) Renvoie e à la puissance de x, c'est-à-dire e ^ x.

math.log (x) Renvoie le logarithme naturel de x, pour x> = 0.

math.log10 (x) Renvoie le log de base-10 de x, pour x> = 0.

math.frexp (x) Si x = m2e, renvoie m (0, 0.5-1) et entier

math.ldexp (x, y) Renvoie x2y avec y un entier.

Trigonométrique

math.deg (a) Convertit l'angle a de radians en degrés.

math.rad (a) Convertit l'angle a de degrés en radians.

math.pi Constante contenant la valeur de Pi.

math.sin (a) Sinus d'angle a en radians.

math.cos (a) Cosinus de l'angle a en radians.

math.tan (a) Tangente de l'angle a en radians.

math.asin (x) Arc sinus de x en radians, pour x en [-1, 1].

math.acos (x) Arc cosinus de x en radians, pour x en [-1, 1].

math.atan (x) Arc tangente de x en radians.

Numéros pseudo-aléatoires

math.random ([n [, m])

Nombre pseudo-aléatoire dans l'intervalle [0, 1], [1, n] ou [n, m]. math.randomseed (n)



73