From 071de314fd97959f6defb6fffd077cc185c9400e Mon Sep 17 00:00:00 2001 From: Yonaba Date: Mon, 30 Dec 2013 14:49:43 +0000 Subject: Added french translation for Lua --- fr-fr/lua-fr.html.markdown | 450 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 450 insertions(+) create mode 100644 fr-fr/lua-fr.html.markdown diff --git a/fr-fr/lua-fr.html.markdown b/fr-fr/lua-fr.html.markdown new file mode 100644 index 00000000..e3979f08 --- /dev/null +++ b/fr-fr/lua-fr.html.markdown @@ -0,0 +1,450 @@ +--- +language: lua +filename: learnlua-fr.lua +contributors: + - ["Tyler Neylon", "http://tylerneylon.com/"] +translators: + - ["Roland Yonaba", "http://github.com/Yonaba"] +lang: fr-fr +--- + +```lua +-- Les commentaires unilignes commencent par un double-tiret. + +--[[ + Les doubles crochets ouverts ([[) et fermés (]]) à la suite + du double-tiret permettent d'avoir des commentaires + multilignes. +--]] + +---------------------------------------------------- +-- 1. Variables et contrôle d'exécution. +---------------------------------------------------- + +num = 42 -- Tous les nombres sont de type double. +-- Rassurez vous cependant, les doubles stockés sur 64-bits +-- en réservent 52 pour la valeur exacte des entiers. La +-- précision n'est donc pas un problème pour tout entier qui +-- peut être codé sur moins de 52 bits. + +s = 'walternate' -- Chaines de caractères immuables comme en Python. +t = "une chaine avec des guillemets doubles" +u = [[les double crochets permettent + d'avoir une chaine de caractères + sur plusieurs lignes.]] +t = nil -- Affecte la valeur nulle à t; Lua possède un ramasse-miettes + +-- Le do/end définit un bloc de code +while num < 50 do + num = num + 1 -- Pas d'opérateurs de type ++ ou +=. +end + +-- Les structures en if: +if num > 40 then + print('supérieur à 40') +elseif s ~= 'walternate' then -- ~= : est différent de. + -- Le test d'égalité se fait avec == comme en Python. + io.write('inférieur à 40\n') -- Ecrit par defaut sur la sortie stdout. +else + -- Les variables sont globales par défaut. + thisIsGlobal = 5 -- le style camelCase est courant. + + -- Une variable locale est déclarée avec le mot-clé local: + local line = io.read() -- Permet de lire la ligne suivante dans stdin. + + -- .. est l'opérateur de concaténation: + print("L'hiver approche, " .. line) +end + +-- Les variables non définies reçoivent par défaut la valeur nil. +foo = anUnknownVariable -- Maintenant, foo = nil. + +aBoolValue = false + +-- Seuls nil et false sont des valeurs fausses. +-- Mais 0 et '' sont des valeurs vraies! +if not aBoolValue then print('etait faux') end + +-- L'évaluation du 'or' et du 'and' est court-circuitée. +-- Comme avec les ternaires du C et de JS: a?b:c +ans = aBoolValue and 'oui' or 'non' --> 'non' + +karlSum = 0 +for i = 1, 100 do -- Les bornes sont incluses dans l'intervalle. + karlSum = karlSum + i +end + +-- Utilisez "100, 1, -1" pour la décrémentation: +fredSum = 0 +for j = 100, 1, -1 do fredSum = fredSum + j end + +-- En général, l'intervalle est début, fin[, pas]. + +-- Un autre type de boucle: +repeat + print('the way of the future') + num = num - 1 +until num == 0 + + +---------------------------------------------------- +-- 2. Fonctions. +---------------------------------------------------- + +function fib(n) + if n < 2 then return n end + return fib(n - 2) + fib(n - 1) +end + +-- Lua implémente les fermetures et les fonctions anonymes: +function adder(x) + -- La fonction retournée est créée lorsque adder est appelé + -- et elle se rappelle de la valeur de x. + return function (y) return x + y end +end +a1 = adder(9) +a2 = adder(36) +print(a1(16)) --> 25 +print(a2(64)) --> 100 + +-- Les valeurs de retour, les appels de fonction, les assignations +-- supportent tous les listes qui peuvent ne pas correspondre en longueur. +-- Dans ce cas, les variables à assigner en supplément recoivent nil +-- tandis que les valeurs à attribuer en supplément sont ignorées + +x, y = 1, 2 -- x = 1 et y = 2 +x, y, z = 1, 2 -- x = 1, y = 2 et z = nil +x, y, z = 1, 2, 3, 4 -- x = 1, y = 2, z = 3, et 4 est ignoré. + +function bar(a, b, c) + print(a, b, c) + return 4, 8, 15, 16, 23, 42 +end + +x, y = bar('zaphod') --> affiche "zaphod nil nil" +-- x = 4, y = 8, les valeurs 15 à 42 sont ignorées. + +-- Les fonctions sont des valeurs de première classe +-- et peuvent être locales/globales. +-- Les déclarations suivantes sont identiques: +function f(x) return x * x end +f = function (x) return x * x end + +-- Il en va de même pour les déclarations suivantes: +local function g(x) return math.sin(x) end +local g = function(x) return math.sin(x) end +-- Sauf que pour le dernier cas, même si local g = function(x) +-- est équivalent à local function g(x), il n'est pas possible +-- de faire appel à g à l'intérieur du corps de la fonction (récursion) + +-- A moins de déclarer la fonction auparavant: +local g; g = function (x) return math.sin(x) end + +-- A propos, les fonctions trigonométriques interprètent +-- leurs arguments en radians. +print(math.cos(math.pi)) -- affiche "-1" +print(math.sin(math.pi)) -- affiche "0" + +-- Lorsqu'une fonction est appellée avec un seul argument qui est une chaine, +-- les parenthèses peuvent être omises: +print 'hello' -- équivalent à print('hello'). + +-- Lorsqu'une fonction est appellée avec un seul argument qui est une table, +-- les parenthèses peuvent aussi être omises. +print {} -- équivalent à print({}). + + +---------------------------------------------------- +-- 3. Tables. +---------------------------------------------------- + +-- Tables = Seule structure de données en Lua; +-- Ce sont des listes assotiatives. +-- Elles sont similaires aux tables PHP ou aux objets JS : +-- des tables-dictionnaires que l'on peut utiliser en tant que listes. + +-- Tables en tant que dictionnaires: + +-- Les clés sont des chaines de caractères par défaut: +t = {key1 = 'valeur1', key2 = false} + +-- Elles peuvent être indexées avec la notation en point, comme en JS: +print(t.key1) -- Affiche "valeur1". +t.newKey = {} -- Ajoute une nouvelle paire clé/valeur. +t.key2 = nil -- Supprime la clé "key2" de la table. + +-- Notation littérale pour toute valeur non nulle en tant que clé: +u = {['@!#'] = 'qbert', [{}] = 1729, [6.28] = 'tau'} +print(u[6.28]) -- affiche "tau" + +-- La correspondance des clés se fait par valeur pour +-- les nombres et les chaines, mais par référence pour les tables. +a = u['@!#'] -- a = 'qbert'. +b = u[{}] -- On pourrait s'attendre à 1729, mais l'on obtient nil: +-- b = nil car la clé utilisée n'est pas le même objet que celui +-- utilisé pour stocker la valeur originale 1729. + +-- Si une fonction prend en argument une seule table, l'on peut +-- omettre les parenthèses: +function h(x) print(x.key1) end +h{key1 = 'Sonmi~451'} -- Affiche 'Sonmi~451'. + +for key, val in pairs(u) do -- Parcours d'une table. + print(key, val) +end + +-- _G est une table spéciale contenant toutes les variables globales, +-- et donc elle même. +print(_G['_G'] == _G) -- Affiche 'true'. + +-- Tables en tant que listes: + +-- De manière implicite, les clés sont des nombres entiers: +v = {'value1', 'value2', 1.21, 'gigawatts'} +for i = 1, #v do -- #v retourne la taille d'une table si elle est une liste. + print(v[i]) -- Attention, en Lua, les index commencent à 1! +end +-- Il n'existe pas vraiment de type 'liste' en Lua, v est juste +-- une table avec des clés qui sont des nombres entiers consécutifs +-- commençant à 1. Lua le traite comme étant une liste. + +---------------------------------------------------- +-- 3.1 Métatables and métaméthodes. +---------------------------------------------------- + +-- Une table peut avoir une métatable qui confère à la table +-- un patron/prototype de conception (surcharge d'opération). Nous verrons +-- dans la suite comment les métatables imitent le prototypage de JS. + +f1 = {a = 1, b = 2} -- Représente la fraction a/b. +f2 = {a = 2, b = 3} + +-- Ceci créée une erreur: +-- s = f1 + f2 + +metafraction = {} +function metafraction.__add(f1, f2) + local sum = {} + sum.b = f1.b * f2.b + sum.a = f1.a * f2.b + f2.a * f1.b + return sum +end + +setmetatable(f1, metafraction) +setmetatable(f2, metafraction) + +s = f1 + f2 -- appèle __add(f1, f2) de la métatable de f1 + +-- f1, f2 ne possède pas de clé qui pointent vers leur métatable, comme +-- avec les prototypes en JS. Mais l'on peut utiliser getmetatable(f1). +-- La métatable est une table normale avec des clés prédéfinie, comme __add. + +-- Mais la ligne suivante génère une erreur puisque s n'a pas de métatable: +-- t = s + s +-- En implémentant de l'orienté-objet, comme nous le verrons dans la suite, +-- le problème est résolu. + +-- Une clé __index dans une métatable mt surcharge l'indexation dans sa table t +-- si la clé est absente de cette table t: +defaultFavs = {animal = 'gru', food = 'donuts'} +myFavs = {food = 'pizza'} +setmetatable(myFavs, {__index = defaultFavs}) +eatenBy = myFavs.animal -- Affiche "gru"! merci à la métatable! + +-- Ainsi donc, un accès direct à une valeur dans une table via une clé +-- inexistante (ce qui normalement retourne "nil") conduira à exploiter +-- le champ __index de la métatable. Cela peut être récursif. + +-- Le champ __index peut aussi être une fonction (tbl, clé) +-- ce qui permet une gestion plus souple des indexations. + +-- Les clés __index, __add,... sont appelées métaméthodes. +-- En voici la liste complète: + +-- __add(a, b) pour a + b +-- __sub(a, b) pour a - b +-- __mul(a, b) pour a * b +-- __div(a, b) pour a / b +-- __mod(a, b) pour a % b +-- __pow(a, b) pour a ^ b +-- __unm(a) pour -a +-- __concat(a, b) pour a .. b +-- __len(a) pour #a +-- __eq(a, b) pour a == b +-- __lt(a, b) pour a < b +-- __le(a, b) pour a <= b +-- __index(a, b) pour a.b +-- __newindex(a, b, c) pour a.b = c +-- __call(a, ...) pour a(...) + +---------------------------------------------------- +-- 3.2 Pseudo-orienté objet et héritage. +---------------------------------------------------- + +-- Lua n'implémente pas d'orienté objet par défaut. +-- Mais il reste possible d'imiter de plusieurs manières +-- le concept de "classe" grâce aux tables et aux métatables. + +-- L'explication pour l'exemple qui suit vient juste après. + +Dog = {} -- 1. + +function Dog:new() -- 2. + local newObj = {sound = 'woof'} -- 3. + self.__index = self -- 4. + return setmetatable(newObj, self) -- 5. +end + +function Dog:makeSound() -- 6. + print('Je dis: ' .. self.sound..'!') +end + +mrDog = Dog:new() -- 7. +mrDog:makeSound() -- 'Je dis: woof! -- 8. + +-- 1. Dog agit comme une classe; c'est une simple table. +-- 2. L'expression tbl:fn(...) est identique à +-- tbl.fn(self, ...) +-- La notation : permet de passer par défaut un premier +-- argument appellé "self" à la fonction tbl.fn +-- Voir 7 & 8 ci-après pour comprendre comment self prend +-- sa valeur. +-- 3. newObj sera une instance de la classe Dog. +-- 4. self = la classe instanciée. Souvent, self = Dog, mais +-- cela peut changer du fait de l'héritage. +-- newObj reçoit les fonctions de self si l'__index des +-- métatables de newObj et de self pointent vers self. +-- 5. Rappel: setmetatable retourne son premier argument. +-- 6. La notation : fonctionne comme au 2, mais cette fois, self +-- est une instance au lieu d'être une classe. +-- 7. Similaire à Dog.new(Dog), donc self = Dog dans new(). +-- 8. Similaire à mrDog.makeSound(mrDog); self = mrDog. + +---------------------------------------------------- + +-- Exemple d'héritage: + +LoudDog = Dog:new() -- 1. + +function LoudDog:makeSound() + local s = self.sound .. ' ' -- 2. + print(s .. s .. s..'!') +end + +seymour = LoudDog:new() -- 3. +seymour:makeSound() -- 'woof woof woof!' -- 4. + +-- 1. LoudDog reçoit les méthodes et les variables de Dog. +-- 2. self possède une clé 'sound', reçue de new(), voir 3. +-- 3. Similaire à LoudDog.new(LoudDog) et traduit en Dog.new(LoudDog), +-- puisque LoudDog ne possède pas de clé 'new', mais a une métatable +-- qui a la clé __index = Dog. +-- Résulat: la métatable de seymour est LoudDog, et +-- LoudDog.__index = LoudDog. Donc seymour.key deviendra soit égal à +-- seymour.key, LoudDog.key, Dog.key, selon le fait qu'il s'agira +-- de la première table ayant la clé 'key' en question, en remontant +-- dans la hiérarchie. +-- 4. La clé 'makeSound' est trouvée dans LoudDog; cela est similaire +-- à LoudDog.makeSound(seymour). + +-- Si besoin est, la méthode new() de la sous-classe est +-- identique à la méthode new() de sa classe mère: +function LoudDog:new() + local newObj = {} + -- Prépare self à être la superclasse de newObj: + self.__index = self + return setmetatable(newObj, self) +end + +---------------------------------------------------- +-- 4. Modules. +---------------------------------------------------- + + +--[[ Cette section est mise en commentaire afin que le reste du +-- ce script reste exécutable. +``` + +```lua +-- Supposons que le fichier mod.lua contienne ceci: +local M = {} + +local function sayMyName() + print('Hrunkner') +end + +function M.sayHello() + print('hello') + sayMyName() +end + +return M + +-- Un autre fichier peut exploiter le contenu défini dans mod.lua's: +local mod = require('mod') -- Exécute le fichier mod.lua. + +-- require est le moyen par défaut d'inclure des modules. +-- require agit comme: (si non trouvé en cache; voir ci-après) +local mod = (function () + +end)() +-- Comme si le contenu de mod.lua est enveloppé dans le corps d'une fonction, +-- si bien que les variables locales contenues dans mod.lua deviennent +-- inaccessibles en dehors de ce module. + +-- Le code suivant fonctionne car mod = M (dans mod.lua): +mod.sayHello() -- Dis bonjour à Hrunkner. + +-- Le code suivant génère une erreur car sayMyName est local à mod.lua: +mod.sayMyName() -- erreur! + +-- Les valeurs retournées par require sont mises en cache, ce qui fait +-- qu'un module est toujours chargé une seule fois, même s'il est inclus +-- avec require à plusieurs reprises. + +-- Supposons que mod2.lua contienne le code "print('Hi!')". +local a = require('mod2') -- Affiche "Hi!" +local b = require('mod2') -- N'affiche rien; et a = b. + +-- dofile est identique à require, sauf qu'il ne fait pas de mise en cache: +dofile('mod2') --> Hi! +dofile('mod2') --> Hi! (le code de mod2.lua est encore exécuté) + +-- loadfile charge le contenu d'un fichier, sans l'exécuter. +f = loadfile('mod2') -- L'appel f() exécute le contenu de mod2.lua. + +-- loadstring est similaire à loadfile, mais pour les chaines de caractères. +g = loadstring('print(343)') -- Retourne une fonction. +g() -- Affiche 343; Rien n'est affiché avant cet appel. + +--]] + +``` +## Références + +*Les références qui suivent sont en Anglais.* + +Les sujets non abordés dans ce tutoriel sont couverts en intégralité par +les librairies standard: + +* la librairie string +* la librairie table +* la librairie math +* la librairie io +* la librairie os + +Autres références complémentaires: + +* Lua for programmers +* Courte de référence de Lua +* Programming In Lua +* Les manuels de référence Lua + +A propos, ce fichier est exécutable. Sauvegardez-le sous le nom learn.lua et +exécutez-le avec la commande "lua learn.lua" ! + +Ce tutoriel a été originalement écrit pour tylerneylon.com et est aussi +disponible en tant que gist. +Il a été traduit en français par Roland Yonaba (voir son github). + +Amusez-vous bien avec Lua! \ No newline at end of file -- cgit v1.2.3 From bb673a40a9779a8abe9e3a430160f58670e01a5b Mon Sep 17 00:00:00 2001 From: Yonaba Date: Mon, 30 Dec 2013 14:54:30 +0000 Subject: Bit of prettification --- fr-fr/lua-fr.html.markdown | 19 +++++++++---------- 1 file changed, 9 insertions(+), 10 deletions(-) diff --git a/fr-fr/lua-fr.html.markdown b/fr-fr/lua-fr.html.markdown index e3979f08..63b65c38 100644 --- a/fr-fr/lua-fr.html.markdown +++ b/fr-fr/lua-fr.html.markdown @@ -12,9 +12,8 @@ lang: fr-fr -- Les commentaires unilignes commencent par un double-tiret. --[[ - Les doubles crochets ouverts ([[) et fermés (]]) à la suite - du double-tiret permettent d'avoir des commentaires - multilignes. + Les doubles crochets à la suite du double-tiret + permettent d'insérer des commentaires multilignes. --]] ---------------------------------------------------- @@ -427,11 +426,11 @@ g() -- Affiche 343; Rien n'est affiché avant cet appel. Les sujets non abordés dans ce tutoriel sont couverts en intégralité par les librairies standard: -* la librairie string -* la librairie table -* la librairie math -* la librairie io -* la librairie os +* La librairie string +* La librairie table +* La librairie math +* La librairie io +* La librairie os Autres références complémentaires: @@ -440,8 +439,8 @@ Autres références complémentaires: * Programming In Lua * Les manuels de référence Lua -A propos, ce fichier est exécutable. Sauvegardez-le sous le nom learn.lua et -exécutez-le avec la commande "lua learn.lua" ! +A propos, ce fichier est exécutable. Sauvegardez-le sous le nom *learn.lua* et +exécutez-le avec la commande `lua learn.lua` ! Ce tutoriel a été originalement écrit pour tylerneylon.com et est aussi disponible en tant que gist. -- cgit v1.2.3 From a0ee6f45a973092ef58b08759c0300a2ce772e00 Mon Sep 17 00:00:00 2001 From: Yonaba Date: Mon, 30 Dec 2013 15:35:44 +0000 Subject: Fixed a lot of typos (thanks @Nami-Doc for the proofreading) --- fr-fr/lua-fr.html.markdown | 40 ++++++++++++++++++++-------------------- 1 file changed, 20 insertions(+), 20 deletions(-) diff --git a/fr-fr/lua-fr.html.markdown b/fr-fr/lua-fr.html.markdown index 63b65c38..8535848a 100644 --- a/fr-fr/lua-fr.html.markdown +++ b/fr-fr/lua-fr.html.markdown @@ -9,10 +9,10 @@ lang: fr-fr --- ```lua --- Les commentaires unilignes commencent par un double-tiret. +-- Les commentaires unilignes commencent par un double tiret. --[[ - Les doubles crochets à la suite du double-tiret + Les doubles crochets à la suite du double tiret permettent d'insérer des commentaires multilignes. --]] @@ -43,7 +43,7 @@ if num > 40 then print('supérieur à 40') elseif s ~= 'walternate' then -- ~= : est différent de. -- Le test d'égalité se fait avec == comme en Python. - io.write('inférieur à 40\n') -- Ecrit par defaut sur la sortie stdout. + io.write('inférieur à 40\n') -- Écrit par defaut sur la sortie stdout. else -- Les variables sont globales par défaut. thisIsGlobal = 5 -- le style camelCase est courant. @@ -64,8 +64,8 @@ aBoolValue = false -- Mais 0 et '' sont des valeurs vraies! if not aBoolValue then print('etait faux') end --- L'évaluation du 'or' et du 'and' est court-circuitée. --- Comme avec les ternaires du C et de JS: a?b:c +-- L'évaluation du 'or' et du 'and' est court-circuité. +-- Comme avec les ternaires du C et du JS: a?b:c ans = aBoolValue and 'oui' or 'non' --> 'non' karlSum = 0 @@ -108,7 +108,7 @@ print(a2(64)) --> 100 -- Les valeurs de retour, les appels de fonction, les assignations -- supportent tous les listes qui peuvent ne pas correspondre en longueur. --- Dans ce cas, les variables à assigner en supplément recoivent nil +-- Dans ce cas, les variables à assigner en supplément reçoivent nil -- tandis que les valeurs à attribuer en supplément sont ignorées x, y = 1, 2 -- x = 1 et y = 2 @@ -120,7 +120,7 @@ function bar(a, b, c) return 4, 8, 15, 16, 23, 42 end -x, y = bar('zaphod') --> affiche "zaphod nil nil" +x, y = bar('zaphod') --> affiche "zaphod nil nil" -- x = 4, y = 8, les valeurs 15 à 42 sont ignorées. -- Les fonctions sont des valeurs de première classe @@ -136,19 +136,19 @@ local g = function(x) return math.sin(x) end -- est équivalent à local function g(x), il n'est pas possible -- de faire appel à g à l'intérieur du corps de la fonction (récursion) --- A moins de déclarer la fonction auparavant: +-- À moins de déclarer la fonction auparavant: local g; g = function (x) return math.sin(x) end --- A propos, les fonctions trigonométriques interprètent +-- À propos, les fonctions trigonométriques interprètent -- leurs arguments en radians. print(math.cos(math.pi)) -- affiche "-1" print(math.sin(math.pi)) -- affiche "0" --- Lorsqu'une fonction est appellée avec un seul argument qui est une chaine, +-- Lorsqu'une fonction est appelée avec un seul argument qui est une chaine, -- les parenthèses peuvent être omises: print 'hello' -- équivalent à print('hello'). --- Lorsqu'une fonction est appellée avec un seul argument qui est une table, +-- Lorsqu'une fonction est appelée avec un seul argument qui est une table, -- les parenthèses peuvent aussi être omises. print {} -- équivalent à print({}). @@ -200,8 +200,8 @@ print(_G['_G'] == _G) -- Affiche 'true'. -- De manière implicite, les clés sont des nombres entiers: v = {'value1', 'value2', 1.21, 'gigawatts'} -for i = 1, #v do -- #v retourne la taille d'une table si elle est une liste. - print(v[i]) -- Attention, en Lua, les index commencent à 1! +for i = 1, #v do -- #v retourne la taille de la table v si elle est une liste. + print(v[i]) -- Attention, en Lua, les indices commencent à 1! end -- Il n'existe pas vraiment de type 'liste' en Lua, v est juste -- une table avec des clés qui sont des nombres entiers consécutifs @@ -213,7 +213,7 @@ end -- Une table peut avoir une métatable qui confère à la table -- un patron/prototype de conception (surcharge d'opération). Nous verrons --- dans la suite comment les métatables imitent le prototypage de JS. +-- dans la suite comment les métatables imitent le prototypage du JS. f1 = {a = 1, b = 2} -- Représente la fraction a/b. f2 = {a = 2, b = 3} @@ -236,11 +236,11 @@ s = f1 + f2 -- appèle __add(f1, f2) de la métatable de f1 -- f1, f2 ne possède pas de clé qui pointent vers leur métatable, comme -- avec les prototypes en JS. Mais l'on peut utiliser getmetatable(f1). --- La métatable est une table normale avec des clés prédéfinie, comme __add. +-- La métatable est une table normale avec des clés prédéfinies, comme __add. -- Mais la ligne suivante génère une erreur puisque s n'a pas de métatable: -- t = s + s --- En implémentant de l'orienté-objet, comme nous le verrons dans la suite, +-- En implémentant de l'orienté objet, comme nous le verrons par la suite, -- le problème est résolu. -- Une clé __index dans une métatable mt surcharge l'indexation dans sa table t @@ -305,7 +305,7 @@ mrDog:makeSound() -- 'Je dis: woof! -- 8. -- 2. L'expression tbl:fn(...) est identique à -- tbl.fn(self, ...) -- La notation : permet de passer par défaut un premier --- argument appellé "self" à la fonction tbl.fn +-- argument appelé "self" à la fonction tbl.fn -- Voir 7 & 8 ci-après pour comprendre comment self prend -- sa valeur. -- 3. newObj sera une instance de la classe Dog. @@ -383,12 +383,12 @@ return M local mod = require('mod') -- Exécute le fichier mod.lua. -- require est le moyen par défaut d'inclure des modules. --- require agit comme: (si non trouvé en cache; voir ci-après) +-- require agit comme: (si non trouvé en cache; voir ci-après) local mod = (function () end)() --- Comme si le contenu de mod.lua est enveloppé dans le corps d'une fonction, --- si bien que les variables locales contenues dans mod.lua deviennent +-- Comme si le contenu de mod.lua était enveloppé dans le corps d'une fonction, +-- si bien que les variables locales contenues dans mod.lua sont -- inaccessibles en dehors de ce module. -- Le code suivant fonctionne car mod = M (dans mod.lua): -- cgit v1.2.3 From f3d043f7b8d8e318557eabd0a9cdac05bc39779d Mon Sep 17 00:00:00 2001 From: Yonaba Date: Mon, 30 Dec 2013 15:50:33 +0000 Subject: Typo fix, again --- fr-fr/lua-fr.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/fr-fr/lua-fr.html.markdown b/fr-fr/lua-fr.html.markdown index 8535848a..922d6ebc 100644 --- a/fr-fr/lua-fr.html.markdown +++ b/fr-fr/lua-fr.html.markdown @@ -234,7 +234,7 @@ setmetatable(f2, metafraction) s = f1 + f2 -- appèle __add(f1, f2) de la métatable de f1 --- f1, f2 ne possède pas de clé qui pointent vers leur métatable, comme +-- f1, f2 ne possèdent pas de clé qui pointent vers leur métatable, comme -- avec les prototypes en JS. Mais l'on peut utiliser getmetatable(f1). -- La métatable est une table normale avec des clés prédéfinies, comme __add. -- cgit v1.2.3