iskm/learnxinyminutes-docs
1
0
Fork 0
mirror of https://github.com/adambard/learnxinyminutes-docs.git synced 2024-12-23 17:41:41 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Added french translation for Lua

Browse Source
This commit is contained in:
Yonaba 2013-12-30 14:49:43 +00:00
parent 0aa7e32f05
commit 071de314fd
1 changed files with 450 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

450
fr-fr/lua-fr.html.markdown Normal file
View File

@ -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) <fn ou table> 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 ()
<contenu de mod.lua>
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:
* <a href="http://lua-users.org/wiki/StringLibraryTutorial">la librairie string</a>
* <a href="http://lua-users.org/wiki/TableLibraryTutorial">la librairie table</a>
* <a href="http://lua-users.org/wiki/MathLibraryTutorial">la librairie math</a>
* <a href="http://lua-users.org/wiki/IoLibraryTutorial">la librairie io</a>
* <a href="http://lua-users.org/wiki/OsLibraryTutorial">la librairie os</a>
Autres références complémentaires:
* <a href="http://nova-fusion.com/2012/08/27/lua-for-programmers-part-1/">Lua for programmers</a>
* <a href="lua-users.org/files/wiki_insecure/users/thomasl/luarefv51.pdf">Courte de référence de Lua</a>
* <a href="http://www.lua.org/pil/contents.html">Programming In Lua</a>
* <a href="http://www.lua.org/manual/">Les manuels de référence Lua</a>
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 <a href="tylerneylon.com">tylerneylon.com</a> et est aussi
disponible en tant que <a href="https://gist.github.com/tylerneylon/5853042">gist</a>.
Il a été traduit en français par Roland Yonaba (voir son <a href="http://github.com/Yonaba">github</a>).
Amusez-vous bien avec Lua!