From ae73dd671f521527f6e58a877026c35d58173671 Mon Sep 17 00:00:00 2001 From: Geoffrey Roguelon Date: Wed, 14 Aug 2013 19:12:21 +0200 Subject: Add the French translation of the Ruby language. --- fr-fr/ruby-fr.html.markdown | 406 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 406 insertions(+) create mode 100644 fr-fr/ruby-fr.html.markdown (limited to 'fr-fr/ruby-fr.html.markdown') diff --git a/fr-fr/ruby-fr.html.markdown b/fr-fr/ruby-fr.html.markdown new file mode 100644 index 00000000..f6bfe42a --- /dev/null +++ b/fr-fr/ruby-fr.html.markdown @@ -0,0 +1,406 @@ +--- +language: ruby +filename: learnruby-fr.rb +contributors: + - ["David Underwood", "http://theflyingdeveloper.com"] + - ["Joel Walden", "http://joelwalden.net"] + - ["Luke Holder", "http://twitter.com/lukeholder"] + - ["Tristan Hume", "http://thume.ca/"] + - ["Nick LaMuro", "https://github.com/NickLaMuro"] +translators: + - ["Geoffrey Roguelon", "https://github.com/GRoguelon"] +lang: fr-fr +--- + +```ruby +# Ceci est un commentaire + +=begin +Ceci est un commentaire multiligne +Personne ne les utilise +Vous devriez en faire de même +=end + +# Tout d'abord : Tout est un objet. + +# Les nombres sont des objets + +3.class #=> Fixnum + +3.to_s #=> "3" + +# Arithmétique de base +1 + 1 #=> 2 +8 - 1 #=> 7 +10 * 2 #=> 20 +35 / 5 #=> 7 + +# L'arithmétique est juste un raccourci +# pour appeler la méthode d'un objet +1.+(3) #=> 4 +10.* 5 #=> 50 + +# Les valeurs spéciales sont des objets +nil # Nothing to see here +true # truth +false # falsehood + +nil.class #=> NilClass +true.class #=> TrueClass +false.class #=> FalseClass + +# Égalité +1 == 1 #=> true +2 == 1 #=> false + +# Inégalité +1 != 1 #=> false +2 != 1 #=> true +!true #=> false +!false #=> true + +# à part false lui-même, nil est la seule autre valeur 'false' + +!nil #=> true +!false #=> true +!0 #=> false + +# Plus de comparaisons +1 < 10 #=> true +1 > 10 #=> false +2 <= 2 #=> true +2 >= 2 #=> true + +# Les chaînes de caractères sont des objets + +'Je suis une chaîne de caractères'.class #=> String +"Je suis également une chaîne de caractères".class #=> String + +placeholder = "utiliser l'interpolation de chaîne de caractères" +"Je peux #{placeholder} quand j'utilise les guillemets" +#=> "Je peux utiliser l'interpolation de chaîne de caractères quand j'utilise les guillemets" + +# Afficher sur la sortie standard +puts "J'affiche à l'écran!" + +# Variables +x = 25 #=> 25 +x #=> 25 + +# Notez que l'affectation retourne la valeur affectée. +# Cela signifie que vous pouvez affecter plusieurs fois de suite : + +x = y = 10 #=> 10 +x #=> 10 +y #=> 10 + +# Par convention, utiliser snake_case (à base d'underscore) +# comme nom de variable +snake_case = true + +# Utiliser des noms de variable explicites +path_to_project_root = '/nom/correct/' +path = '/mauvais/nom/' + +# Symboles (sont des objets) +# Les symboles sont immuables, constants, +# réutilisables et représentés en interne +# par une valeur entière. Ils sont souvent +# utilisés à la place des chaînes de caractères +# pour transmettre efficacement des valeurs +# spécifiques ou significatives + +:pending.class #=> Symbol + +status = :pending + +status == :pending #=> true + +status == 'pending' #=> false + +status == :approved #=> false + +# Tableaux + +# Ceci est un tableau +array = [1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5] + +# Les tableaux contiennent différents types d'élément. + +[1, "hello", false] #=> [1, "hello", false] + +# Les tableaux peuvent être indéxés +# Du début +array[0] #=> 1 +array[12] #=> nil + +# Comme l'arithmétique, la syntaxe [var] est juste un raccourci +# pour appeler la méthode [] d'un objet +array.[] 0 #=> 1 +array.[] 12 #=> nil + +# À la fin +array[-1] #=> 5 + +# Avec un index de début et de fin +array[2, 4] #=> [3, 4, 5] + +# Ou avec un interval +array[1..3] #=> [2, 3, 4] + +# Ajouter un élément au tableau comme ceci +array << 6 #=> [1, 2, 3, 4, 5, 6] + +# Les Hashes sont des dictionnaires Ruby contenant des paires de clé/valeur. +# Les Hashes sont délimitées par des accolades : +hash = {'color' => 'green', 'number' => 5} + +hash.keys #=> ['color', 'number'] + +# Les Hashes peuvent retourner rapidement +# la valeur en utilisant la clé : +hash['color'] #=> 'green' +hash['number'] #=> 5 + +# Rechercher une clé inexistante dans une Hash retourne nil: +hash['nothing here'] #=> nil + +# Depuis Ruby 1.9, Une syntaxe spécifique est apparue en utilisant les symboles comme clés : + +new_hash = { defcon: 3, action: true} + +new_hash.keys #=> [:defcon, :action] + +# Astuce : Les tableaux et les Hashes sont dénombrables +# Ils partagent un certain nombre de méthodes pratiques +# telle que each, map, count, etc... + +# Structures de contrôle + +if true + "si instruction" +elsif false + "autrement si, facultatif" +else + "autrement, également facultatif" +end + +for compteur in 1..5 + puts "itération #{compteur}" +end +#=> itération 1 +#=> itération 2 +#=> itération 3 +#=> itération 4 +#=> itération 5 + +# CEPENDANT, Personne n'utilise la boucle for. +# À la place, vous devrez utiliser la méthode "each" +# et lui passer un bloc de code. +# Un bloc de code est un ensemble d'instructions que vous pouvez passer à une methode comme "each". +# Les blocs sont similaires aux lambdas, les fonctions anonymes ou les closures dans d'autres langages. +# +# La méthode "each" exécute le bloc de code pour chaque élément de l'interval d'éléments. +# Le bloc de code passe un paramètre compteur. +# Appeler la méthode "each" avec un bloc de code comme ceci : + +(1..5).each do |compteur| + puts "itération #{compteur}" +end +#=> itération 1 +#=> itération 2 +#=> itération 3 +#=> itération 4 +#=> itération 5 + +# Vous pouvez également mettre un bloc de code entre accolades : +(1..5).each {|compteur| puts "itération #{compteur}"} + +# Le contenu des structures de données peut être parcouru +# en utilisant la méthode each. +array.each do |element| + puts "#{element} est une partie du tableau" +end +hash.each do |cle, valeur| + puts "#{cle} est #{valeur}" +end + +compteur = 1 +while compteur <= 5 do + puts "itération #{compteur}" + compteur += 1 +end +#=> itération 1 +#=> itération 2 +#=> itération 3 +#=> itération 4 +#=> itération 5 + +grade = 'B' + +case grade +when 'A' + puts "Excellence" +when 'B' + puts "Plus de chance la première fois" +when 'C' + puts "Vous pouvez faire mieux" +when 'D' + puts "C'est pas terrible" +when 'F' + puts "Vous avez échoué!" +else + puts "Sytème de notation alternatif" +end + +# Fonctions + +def double(x) + x * 2 +end + +# Les fonctions (et tous les blocs de code) retournent +# implicitement la valeur de la dernière instruction évaluée +double(2) #=> 4 + +# Les paranthèses sont facultative +# où il n'y a pas d'ambiguïté sur le résultat +double 3 #=> 6 + +double double 3 #=> 12 + +def sum(x,y) + x + y +end + +# Les paramètres de méthode sont séparés par des virgules +sum 3, 4 #=> 7 + +sum sum(3,4), 5 #=> 12 + +# yield +# Toutes les méthodes ont un argument de type bloc de code +# facultatif et implicite +# il peut être appelé avec le mot clé 'yield' + +def surround + puts "{" + yield + puts "}" +end + +surround { puts 'Bonjour tout le monde' } + +# { +# Bonjour tout le monde +# } + + +# Définir une classe avec le mot clé 'class' +class Humain + + # Une variable de classe, + # elle est partagée par toutes les instances de cette classe. + @@espece = "H. sapiens" + + # Constructeur de classe + def initialize(nom, age = 0) + # Affecter l'argument à la variable d'instance 'nom' + # pour la durée de vie de l'instance de cette classe + @nom = nom + # Si le paramètre 'age' est absent, + # la valeur par défaut définie dans la liste des arguments sera utilisée. + @age = age + end + + # Une simple méthode setter + def nom=(nom) + @nom = nom + end + + # Une simple méthode getter + def nom + @nom + end + + # Une méthode de classe utilise le mot clé 'self' + # pour se distinguer de la méthode d'instance. + # La méthode sera alors accessible à partir de la classe + # et non pas de l'instance. + def self.say(msg) + puts "#{msg}" + end + + def species + @@species + end + +end + + +# Instancier une classe +jim = Humain.new("Jim Halpert") + +dwight = Humain.new("Dwight K. Schrute") + +# Appelons quelques méthodes +jim.espece #=> "H. sapiens" +jim.nom #=> "Jim Halpert" +jim.nom = "Jim Halpert II" #=> "Jim Halpert II" +jim.nom #=> "Jim Halpert II" +dwight.espece #=> "H. sapiens" +dwight.nom #=> "Dwight K. Schrute" + +# Appelons la méthode de classe +Humain.say("Hi") #=> "Hi" + +# Les classes sont également des objets en Ruby. +# Par conséquent, les classes peuvent avoir des variables d'instance. +# Les variables de classe sont partagées parmi +# la classe et ses descendants. + +# Classe de base +class Humain + @@foo = 0 + + def self.foo + @@foo + end + + def self.foo=(valeur) + @@foo = valeur + end +end + +# Héritage de classe +class Travailleur < Humain +end + +Humain.foo # 0 +Travailleur.foo # 0 + +Humain.foo = 2 # 2 +Travailleur.foo # 2 + +# Les variables d'instance de classe ne sont pas partagées +# avec les classes héritées. + +class Humain + @bar = 0 + + def self.bar + @bar + end + + def self.bar=(valeur) + @bar = valeur + end +end + +class Docteur < Humain +end + +Humain.bar # 0 +Docteur.bar # nil + +``` -- cgit v1.2.3 From ba34fa65ec582f9fc91180eebb77c57cf41a98ff Mon Sep 17 00:00:00 2001 From: Geoffrey Roguelon Date: Thu, 15 Aug 2013 10:45:06 +0200 Subject: Fix the comments of French Ruby file from the Nami-Doc's comments (adambard/learnxinyminutes-docs#223). Thanks to him. --- fr-fr/ruby-fr.html.markdown | 81 +++++++++++++++++++++++---------------------- 1 file changed, 41 insertions(+), 40 deletions(-) (limited to 'fr-fr/ruby-fr.html.markdown') diff --git a/fr-fr/ruby-fr.html.markdown b/fr-fr/ruby-fr.html.markdown index f6bfe42a..f5212787 100644 --- a/fr-fr/ruby-fr.html.markdown +++ b/fr-fr/ruby-fr.html.markdown @@ -9,6 +9,7 @@ contributors: - ["Nick LaMuro", "https://github.com/NickLaMuro"] translators: - ["Geoffrey Roguelon", "https://github.com/GRoguelon"] + - ["Nami-Doc", "https://github.com/Nami-Doc"] lang: fr-fr --- @@ -29,21 +30,21 @@ Vous devriez en faire de même 3.to_s #=> "3" -# Arithmétique de base +# Les opérateurs de base 1 + 1 #=> 2 8 - 1 #=> 7 10 * 2 #=> 20 35 / 5 #=> 7 -# L'arithmétique est juste un raccourci -# pour appeler la méthode d'un objet +# Les opérateurs sont juste des raccourcis +# pour appeler une méthode sur un objet 1.+(3) #=> 4 10.* 5 #=> 50 # Les valeurs spéciales sont des objets -nil # Nothing to see here -true # truth -false # falsehood +nil # Nul +true # Vrai +false # Faux nil.class #=> NilClass true.class #=> TrueClass @@ -80,7 +81,7 @@ placeholder = "utiliser l'interpolation de chaîne de caractères" "Je peux #{placeholder} quand j'utilise les guillemets" #=> "Je peux utiliser l'interpolation de chaîne de caractères quand j'utilise les guillemets" -# Afficher sur la sortie standard +# Affichez un message puts "J'affiche à l'écran!" # Variables @@ -94,15 +95,15 @@ x = y = 10 #=> 10 x #=> 10 y #=> 10 -# Par convention, utiliser snake_case (à base d'underscore) -# comme nom de variable +# Par convention, utilisez la notation underscore +# pour nommer les variables snake_case = true -# Utiliser des noms de variable explicites +# Utilisez des noms de variable explicites path_to_project_root = '/nom/correct/' path = '/mauvais/nom/' -# Symboles (sont des objets) +# Symboles (aussi des objets) # Les symboles sont immuables, constants, # réutilisables et représentés en interne # par une valeur entière. Ils sont souvent @@ -129,40 +130,40 @@ array = [1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5] [1, "hello", false] #=> [1, "hello", false] -# Les tableaux peuvent être indéxés +# Les tableaux peuvent être indexés # Du début array[0] #=> 1 array[12] #=> nil -# Comme l'arithmétique, la syntaxe [var] est juste un raccourci +# Comme les opérateurs, la syntaxe [var] est juste un raccourci # pour appeler la méthode [] d'un objet array.[] 0 #=> 1 array.[] 12 #=> nil -# À la fin +# Depuis la fin array[-1] #=> 5 # Avec un index de début et de fin array[2, 4] #=> [3, 4, 5] -# Ou avec un interval +# Ou avec un intervalle array[1..3] #=> [2, 3, 4] -# Ajouter un élément au tableau comme ceci +# Ajoutez un élément au tableau comme ceci array << 6 #=> [1, 2, 3, 4, 5, 6] -# Les Hashes sont des dictionnaires Ruby contenant des paires de clé/valeur. -# Les Hashes sont délimitées par des accolades : +# Les Hash sont des dictionnaires Ruby contenant des paires de clé/valeur. +# Les Hash sont délimitées par des accolades : hash = {'color' => 'green', 'number' => 5} hash.keys #=> ['color', 'number'] -# Les Hashes peuvent retourner rapidement -# la valeur en utilisant la clé : +# Les Hash retournent la valeur +# en utilisant la clé associée à la valeur : hash['color'] #=> 'green' hash['number'] #=> 5 -# Rechercher une clé inexistante dans une Hash retourne nil: +# Recherchez une clé inexistante dans une Hash retourne nil : hash['nothing here'] #=> nil # Depuis Ruby 1.9, Une syntaxe spécifique est apparue en utilisant les symboles comme clés : @@ -171,7 +172,7 @@ new_hash = { defcon: 3, action: true} new_hash.keys #=> [:defcon, :action] -# Astuce : Les tableaux et les Hashes sont dénombrables +# Astuce : Les tableaux et les Hash sont dénombrables # Ils partagent un certain nombre de méthodes pratiques # telle que each, map, count, etc... @@ -194,15 +195,15 @@ end #=> itération 4 #=> itération 5 -# CEPENDANT, Personne n'utilise la boucle for. -# À la place, vous devrez utiliser la méthode "each" -# et lui passer un bloc de code. +# CEPENDANT, l'usage de la boucle for est très rare. +# À la place, utilisez la méthode "each" +# et passez lui un bloc de code. # Un bloc de code est un ensemble d'instructions que vous pouvez passer à une methode comme "each". # Les blocs sont similaires aux lambdas, les fonctions anonymes ou les closures dans d'autres langages. # -# La méthode "each" exécute le bloc de code pour chaque élément de l'interval d'éléments. +# La méthode "each" exécute le bloc de code pour chaque élément de l'intervalle d'éléments. # Le bloc de code passe un paramètre compteur. -# Appeler la méthode "each" avec un bloc de code comme ceci : +# Appelez la méthode "each" avec un bloc de code comme ceci : (1..5).each do |compteur| puts "itération #{compteur}" @@ -240,7 +241,7 @@ grade = 'B' case grade when 'A' - puts "Excellence" + puts "Excellent" when 'B' puts "Plus de chance la première fois" when 'C' @@ -264,7 +265,7 @@ end double(2) #=> 4 # Les paranthèses sont facultative -# où il n'y a pas d'ambiguïté sur le résultat +# lorsqu'il n'y a pas d'ambiguïté sur le résultat double 3 #=> 6 double double 3 #=> 12 @@ -279,8 +280,8 @@ sum 3, 4 #=> 7 sum sum(3,4), 5 #=> 12 # yield -# Toutes les méthodes ont un argument de type bloc de code -# facultatif et implicite +# Toutes les méthodes ont un argument facultatif et implicite +# de type bloc de code # il peut être appelé avec le mot clé 'yield' def surround @@ -296,16 +297,16 @@ surround { puts 'Bonjour tout le monde' } # } -# Définir une classe avec le mot clé 'class' +# Définissez une classe avec le mot clé 'class' class Humain - # Une variable de classe, - # elle est partagée par toutes les instances de cette classe. + # Une variable de classe + # est partagée par toutes les instances de cette classe. @@espece = "H. sapiens" # Constructeur de classe def initialize(nom, age = 0) - # Affecter l'argument à la variable d'instance 'nom' + # Affectez l'argument à la variable d'instance 'nom' # pour la durée de vie de l'instance de cette classe @nom = nom # Si le paramètre 'age' est absent, @@ -338,12 +339,12 @@ class Humain end -# Instancier une classe +# Instanciez une classe jim = Humain.new("Jim Halpert") dwight = Humain.new("Dwight K. Schrute") -# Appelons quelques méthodes +# Appelez quelques méthodes jim.espece #=> "H. sapiens" jim.nom #=> "Jim Halpert" jim.nom = "Jim Halpert II" #=> "Jim Halpert II" @@ -351,7 +352,7 @@ jim.nom #=> "Jim Halpert II" dwight.espece #=> "H. sapiens" dwight.nom #=> "Dwight K. Schrute" -# Appelons la méthode de classe +# Appelez la méthode de classe Humain.say("Hi") #=> "Hi" # Les classes sont également des objets en Ruby. @@ -359,7 +360,7 @@ Humain.say("Hi") #=> "Hi" # Les variables de classe sont partagées parmi # la classe et ses descendants. -# Classe de base +# Classe parente class Humain @@foo = 0 @@ -372,7 +373,7 @@ class Humain end end -# Héritage de classe +# Classe fille class Travailleur < Humain end -- cgit v1.2.3 From 7f8e5deba129c4b9fb34b89077a63829546b0bd3 Mon Sep 17 00:00:00 2001 From: Geoffrey Roguelon Date: Thu, 15 Aug 2013 12:22:36 +0200 Subject: Fix a word of French Ruby language. --- fr-fr/ruby-fr.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'fr-fr/ruby-fr.html.markdown') diff --git a/fr-fr/ruby-fr.html.markdown b/fr-fr/ruby-fr.html.markdown index f5212787..5efb2f3c 100644 --- a/fr-fr/ruby-fr.html.markdown +++ b/fr-fr/ruby-fr.html.markdown @@ -243,7 +243,7 @@ case grade when 'A' puts "Excellent" when 'B' - puts "Plus de chance la première fois" + puts "Plus de chance la prochaine fois" when 'C' puts "Vous pouvez faire mieux" when 'D' -- cgit v1.2.3