Cours Lua

Cours Lua sur Les stéroides en PDF


Télécharger Cours Lua sur Les stéroides en PDF

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

Télécharger aussi :


Cours Lua sur Les stéroides concepts de base [Eng]

...

Identifiants réservés et commentaires

et casser sinon elseif fin faux pour la fonction si dans le local nil pas ou répéter le retour puis vrai jusqu'à ce que tout

-

 ... commenter à la fin de la ligne - [= [] =] commentaire multiligne (zéro ou multiple '=' sont valides)

_X est "réservé" (par convention) pour les constantes (avec X étant n'importe quelle séquence de majuscules)

#! Shebang Unix habituel; Lua ignore toute la première ligne si cela commence la ligne.

Types (les valeurs de chaîne sont les résultats possibles du type de fonction de bibliothèque de base ())

"nil" "booléen" "nombre" "chaîne" "table" "fonction" "fil" "userdata"

Note: pour le type booléen, nil et faux comptent comme faux; tout le reste est vrai (y compris 0 et "").

Chaînes et séquences d'échappement

'...' et "..." délimiteurs de chaînes; interpréter les évasions. [= [...] =] chaîne multiligne; les séquences d'échappement sont ignorées.

\ une cloche \ b backspace \ f flux de formulaire \ n newline \ r retour \ t horiz. tabulation \ v vert. languette

\\ backslash \ » d. Citation \ » citation \ [sq. Support \] support carré. \ Décimale ddd (jusqu'à 3 chiffres)

Opérateurs, priorité décroissante

^ (droit associatif, bibliothèque mathématique requise)

pas # (longueur des cordes et des tables) - (unaire)

* /%

+ -

.. (concaténation de chaînes, droite associative)

<> <=> = ~ = ==

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 valeur évaluée)

Affectation et coercition

a = 5 b = "salut"

local a = a

affectation simple les variables ne sont pas typées et peuvent contenir différents types. Les variables locales sont étendues lexicalement; leur portée commence après la déclaration complète (de sorte que local a = 5).

a, b, c = 1, 2, 3 affectations multiples sont supportées

a, b = b, valeurs de swap: le côté droit est évalué avant l'affectation

a, b = 4, 5, "6" les valeurs excédentaires sur le côté droit ("6") sont évaluées mais rejetées

a, b = "là" pour les valeurs manquantes du côté droit nul est supposé

a = nul détruit un; son contenu est éligible pour la collecte des ordures s'il n'est pas référencé.

a = z si z n'est pas défini, il est nul, donc nul est assigné à un (le détruisant)

a = "3" + "2" nombres attendus, les chaînes sont converties en nombres (a = 5)

a = 3 .. 2 chaînes attendues, les nombres sont convertis en chaînes (a = "32")

Structures de contrôle

faire un bloc de fin de bloc; introduit la portée locale.

si exp puis bloc {elseif exp puis bloc} [bloc autre] mettre fin à l'exécution conditionnelle alors que exp ne bloquent boucle d'extrémité tant que exp est vrai bloc de répétition jusqu'à ce que les sorties exp lorsque exp devient vrai; exp est dans la portée de la boucle.

pour var = start, end [, step] fait une fin de bloc numérique pour la boucle; var est local à la boucle.

pour les variables dans itérateur, bloque l'itérateur de fin en fonction de la boucle; Les variables sont locales à la boucle.

briser les boucles de sortie; doit être la dernière déclaration en bloc.

Constructeurs de table

t = {} crée une table vide et l'affecte à t

t = {"yes", "no", "?"} tableau simple; les éléments sont t [1], t [2], t [3].

t = {[1] = "oui", [2] = "non", [3] = "?" } comme ci-dessus, mais avec des champs explicites

t = {[-900] = 3, [900] = 4} tableau clairsemé avec seulement deux éléments (pas d'espace gaspillé)

t = {x = 5, y = 10} table de hachage, les champs sont t ["x"], t ["y"] (ou t.x, t.y)

t = {x = 5, y = 10; "Oui Non"}

mixtes, les champs / éléments sont t.x, t.y, t [1], t [2]

t = {msg = "choice", {"yes", "no", "?"}} les tables peuvent contenir d'autres tables sous forme de champs

Définition de la fonction

nom de la fonction (args) body [renvoie les valeurs] end définit la fonction et affecte le nom de la variable globale nom de la fonction locale (args) body [renvoie les valeurs] end définit la fonction comme locale sur le bloc

f = corps (args) [valeurs de retour] fin fonction anonyme affectée à la variable f

function ([args,] ...) body [renvoie les valeurs] end variable liste d'arguments, dans le corps accédé comme ...

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

function obj: nom (args) body [renvoie les valeurs] end object function, obtient obj comme premier argument supplémentaire

Appel de fonction

f (x) appel simple, renvoyant éventuellement une ou plusieurs valeurs

f "bonjour" raccourci pour f ("bonjour")

f raccourci de "au revoir" pour f ("au revoir")

f [[à bientôt]] raccourci pour f ([[à bientôt]])



f {x = 3, y = 4} raccourci pour f ({x = 3, y = 4})

t.f (x) appelant une fonction affectée au champ f de la table t

x: move (2, -3) appel d'objet: raccourci pour x.move (x, 2, -3)

Opérations pouvant être converties (bibliothèque de base requise)

setmetatable (t, mt) met mt comme metatable pour t, sauf si t metatable a un champ __metable, et renvoie t

getmetatable (t) retourne le champ __metable de la variable metable de t ou metatable ou t

rawget (t, i) obtient t [i] d'une table sans invoquer de métaméthodes

rawset (t, i, v) met t [i] = v sur une table sans invoquer de métaméthodes

rawequal (t1, t2) renvoie booléen (t1 == t2) sans invoquer de métaméthodes

Champs modifiables (pour les tables et les données utilisateur)

__add, __sub définit le gestionnaire h (a, b) pour '+' et pour binaire '-' __mul, __div définit le gestionnaire h (a, b) pour '*' et pour '/'

__mod set gestionnaire h (a, b) pour '%' __pow définit le gestionnaire h (a, b) pour '^'

__unm définit le gestionnaire h (a) pour le gestionnaire unary '-' __len h (a) pour l'opérateur # (userdata)

__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 éventuellement '<=',

'> =' (si non __le)

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

__index définit le gestionnaire h (t, k) pour l'accès aux zones inexistantes

Champ

__newindex définit le gestionnaire h (t, k, v) pour l'affectation à nonexisting

champ

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

objet en tant que fonction)

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

impression()

__gc définit finalizer h (ud) pour userdata (doit être défini

de C)

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

valeurs; 'kv' = les deux.

__metable définit la valeur à renvoyer par getmetatable ()

Le bas

e bibliothèque [aucun préfixe]

Environnement et variables globales

getfenv ([f]) si f est une fonction, retourne son environnement; si f est un nombre, retourne l'environnement de fonction

au niveau f (1 = courant [défaut], 0 = global); si l'environnement a un champ __fenv, renvoie

au lieu.

setfenv (f, t) définit l'environnement pour la fonction f (ou la fonction au niveau f, 0 = le thread en cours); si l'environnement d'origine a un champ __fenv, déclenche une erreur. Renvoie la fonction f si f ~ = 0.

_G variable globale dont la valeur est l'environnement global (c'est-à-dire, _G._G == _G)

_

VERSION variable globale contenant la version de l'interpréteur (par exemple "Lua 5.1")

Chargement et exécution

require (pkgname) charge un paquet, augmente l'erreur s'il ne peut pas être chargé

dofile ([nom de fichier]) charge et exécute le contenu du nom de fichier [par défaut: entrée standard]; renvoie ses valeurs renvoyées.

load (func [, nom de morceau]) charge un morceau (avec le nom de morceau défini par son nom) en utilisant func pour obtenir ses morceaux; résultats

bloc compilé en tant que fonction (ou nil et message d'erreur).

loadfile (filename) charge le nom de fichier du fichier; retourne des valeurs comme load ().

loadstring (s [, nom]) charge la chaîne s (avec le nom du morceau défini par son nom); retourne des valeurs comme load ().

pcall (f [, args]) appelle f () en mode protégé; renvoie les résultats true et function ou false et le message d'erreur.

xpcall (f, h) en tant que pcall () mais passe le gestionnaire d'erreur h à la place des arguments supplémentaires; retourne comme pcall () mais avec le résultat

de h () comme message d'erreur, le cas échéant.

Sortie simple et retour d'erreur

print (args) imprime chacun des arguments transmis à stdout en utilisant tostring () (voir ci-dessous)

error (msg [, n]) termine le programme ou le dernier appel protégé (par exemple pcall ()) avec le message d'erreur msg

niveau n [par défaut: 1, fonction actuelle]

assert (v [, msg]) appelle error (msg) si v est nul ou faux [msg par défaut: "assertion failed!"]

Information et conversion

select (index, ...) renvoie les arguments après l'argument numéro index ou (si index est "#") le nombre total d'arguments reçus après index

type (x) renvoie le type de x en tant que chaîne (par exemple "nil", "string"); Voir les types ci-dessus.

tostring (x) convertit x en une chaîne, en utilisant le __tostring de metatable de t si disponible

tonumber (x [, b]) convertit la chaîne x représentant un nombre dans la base b [2..36, par défaut: 10] en un nombre, ou zéro si elle est invalide; pour la base 10 accepte le format complet (par exemple "1.5e6").

unpack (t) renvoie t [1] .. t [n] (n = #t) comme valeurs séparées

Iterators

ipairs (t) retourne un itérateur obtenant l'index, paires de valeurs du tableau t dans des paires d'ordre numérique (t) retourne un itérateur obtenant la clé, paires de valeurs du tableau t dans un ordre non spécifié



next (t [, inx]) si inx est nul [défaut] retourne l'index, la paire de valeurs de la table t; si inx est l'index précédent, retourne l'indice suivant, la paire de valeurs ou nil une fois terminé.

collectgarbage (opt [, arg]) interface générique vers le garbage collector; opt définit la fonction effectuée.

Modules et la bibliothèque de paquets [paquet]

module (nom, ...) crée le nom du module. S'il y a une table dans package.loaded [nom], cette table est le module.

Sinon, s'il existe un nom de table global, cette table est le module. Sinon, crée une nouvelle table et la définit comme la valeur du nom global et la valeur de package.loaded [nom].

Les arguments facultatifs sont des fonctions à appliquer sur le module.

package.loadlib (lib, func) charge la bibliothèque dynamique lib (par exemple .so ou .dll) et renvoie la fonction func (ou nil et le message d'erreur)

package.path, package.cpath contient les chemins utilisés par require () pour rechercher un chargeur Lua ou C, respectivement

package.loaded une table utilisée par require pour contrôler quels modules sont déjà chargés (voir module)

package.preload une table pour stocker des chargeurs pour des modules spécifiques (voir require)

package.seeall (module) définit une metatable pour le module avec son champ __index se référant à l'environnement global

La bibliothèque de coroutine [coroutine]

coroutine.create (f) crée un nouveau coroutine avec la fonction Lua f () en tant que corps et le retourne

coroutine.resume (co, args) démarre ou continue d'exécuter coroutine co, lui passant des arguments; renvoie true (et éventuellement des valeurs) si co appelle coroutine.yield () ou termine ou false et un message d'erreur.

coroutine.yield (args) suspend l'exécution de la coroutine d'appel (pas à partir des fonctions C, metamethods ou itérateurs); tous les arguments deviennent des valeurs de retour supplémentaires de coroutine.resume ().

coroutine.status (co) retourne le statut de coroutine co: soit "en cours", "suspendu" ou "mort"

coroutine.running () renvoie la coroutine en cours d'exécution ou nil lorsqu'il est appelé par le thread principal

coroutine.wrap (f) crée un nouveau coroutine avec la fonction Lua f comme corps et retourne une fonction; cette fonction agira comme coroutine.resume () sans le premier argument et la première valeur de retour, propageant toutes les erreurs.

La bibliothèque de table [table]

table.insert (t, [i,] v) insère v à l'index numérique i [par défaut: après la fin] dans le tableau t

table.remove (t [, i]) supprime l'élément à l'index numérique i [par défaut: dernier élément] de la table t; renvoie l'élément supprimé ou nul sur une table vide.

table.maxn (t) renvoie le plus grand indice numérique positif de la table t ou zéro si t n'a pas d'indices positifs

table.sort (t [, cf]) trie (en place) les éléments de t [1] à #t, en utilisant la fonction de comparaison cf (e1, e2) [défaut: '<']

table.concat (t [, s [, i [, j]]]) renvoie une seule chaîne créée en concaténant les éléments de table t [i] à t [j] [par défaut: i = 1, j = #t] séparés par chaîne s; renvoie une chaîne vide si aucun élément n'existe ou i> j.

La bibliothèque mathématique [math]

Opérations de base

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

math.mod (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 le plus proche

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

math.min (args) renvoie la valeur minimale des args reçus

math.max (args) renvoie la valeur maximale des args reçus

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.

Fonction globale __pow (x, y) ajoutée par la bibliothèque mathématique pour que l'opérateur '^' fonctionne

math.exp (x) renvoie e (base de logs naturels) élevé à 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 logarithme en base 10 de x, pour x> = 0

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

Constante math.pi contenant la valeur de pi

math.sin (a) renvoie le sinus de l'angle a (mesuré en radians)

math.cos (a) renvoie le cosinus de l'angle a (mesuré en radians)

math.tan (a) renvoie la tangente de l'angle a (mesuré en radians)

math.asin (x) retourne l'arc sinus de x en radians, pour x en [-1, 1]

math.acos (x) renvoie l'arc cosinus de x en radians, pour x dans [-1, 1]

math.atan (x) renvoie l'arc tangente de x en radians

math.atan2 (y, x) similaire à math.atan (y / x) mais avec quadrant et permettant x = 0

Fractionnement sur les puissances de 2

math.frexp (x) divise x en fraction normalisée et exposant de 2 et renvoie les deux

math.ldexp (x, y) renvoie x * (2 ^ y) avec x = fraction normalisée, y = exposant de 2

Numéros pseudo-aléatoires

math.random ([n [, m]) renvoie un nombre pseudo-aléatoire dans la plage [0, 1] si aucun argument n'est donné; dans l'intervalle [1, n] si n est donné, dans l'intervalle [n, m] si n et



m sont passés.

math.randomseed (n) définit une graine n pour une séquence aléatoire (même graine = même séquence)

La bibliothèque de chaînes [chaîne de caractères]

Remarque: les index de chaîne s'étendent de 1 à #string, ou de fin de chaîne si négatif (index -1 fait référence au dernier caractère).

Remarque: la bibliothèque de chaînes définit une métaible pour les chaînes où le champ __index pointe vers la table de chaînes. Les fonctions de chaîne peuvent être utilisées dans un style orienté objet, par ex. string.len (s) peut être écrit s: len (); les littéraux doivent être placés entre parenthèses, par ex. ("xyz"): len ().

Opérations de base

string.len (s) renvoie la longueur de la chaîne s, y compris les zéros incorporés (voir aussi opérateur #)

string.sub (s, i [, j]) retourne la sous-chaîne de s de la position i à j [par défaut: -1]

string.rep (s, n) renvoie une chaîne composée de n copies concaténées de chaîne s

string.upper renvoie une copie de s convertie en majuscule en fonction des paramètres régionaux

string.lower (s) renvoie une copie de s converti en minuscule en fonction des paramètres régionaux

Codes de caractères

string.byte (s [, i [, j]]) renvoie le code numérique dépendant de la plate-forme (par exemple ASCII) des caractères s [i], s [i + 1], Â · Â · Â ·, S [j]. La valeur par défaut pour i est 1; la valeur par défaut pour j est i.

string.char (args) renvoie une chaîne composée des caractères dont les codes numériques dépendants de la plateforme sont passés en arguments

Stockage de fonction

string.dump (f) retourne une représentation binaire de la fonction f (), pour une utilisation ultérieure avec loadstring () (f () doit être une fonction Lua sans valeur up)

Formatage

string.format (s [, args]) retourne une copie de s où les directives de formatage commencent par '

% 'sont remplacés par la valeur des arguments args, dans l'ordre indiqué (voir les directives de formatage ci-dessous)

Directives de formatage pour string.format

% [flags] [field_width] [.precision] type

Formatage des types de champs

% d nombre entier décimal

% o octal entier

% x nombre entier hexadécimal, majuscule si% X

% f point flottant sous la forme [-] nnnn.nnnn

% e point flottant dans exp. Formulaire [-] n.nnnn e [+ | -] nnn, majuscule si% E

% g point flottant en% e si exp. <-4 ou> = précision, sinon en% f; majuscule si% G.

Caractère% c ayant le code (dépendant du système) transmis en entier

Chaîne% s sans zéros incorporés

% q chaîne entre guillemets, avec tous les caractères spéciaux échappés

%% '%' personnage

Formatage des drapeaux

- left-justifies dans field_width [défaut: right-justify]

+ préfixe signe (s'applique uniquement aux chiffres)

(espace) préfixe signe si négatif, sinon espace vide

# ajoute "0x" avant% x, force le point décimal pour% e,% f, laisse des zéros à la fin pour% g

Formatage de la largeur et de la précision du champ

n met au moins n (<100) caractères, pad avec des espaces

0n met au moins n (<100) caractères, touche gauche avec zéros

.n met au moins n (<100) chiffres pour les entiers; arrondit à n décimales pour le point flottant; ne met pas plus de n

(<100) caractères pour les chaînes.

Exemples de formatage

string.format ("results:% d,% d", 13, 27) résultats: 13, 27

string.format ("<% 5d>", 13) <13>

string.format ("<% - 5d>", 13) <13>

string.format ("<% 05d>", 13) <00013>

string.format ("<% 06.3d>", 13) <013>

string.format ("<% f>", math.pi) <3.141593>

string.format ("<% e>", math.pi) <3.141593e + 00>

string.format ("<%. 4f>", math.pi) <3.1416>

string.format ("<% 9.4f>", math.pi) <3.1416>

string.format ("<% c>", 64) <@>

string.format ("<%. 4s>", "au revoir") <bon>

string.format ("% q", [[elle a dit "salut"]]) "elle a dit" salut ""



250