Merge branch 'master' of github.com:adambard/learnxinyminutes-docs

fr-fr/javascript-fr.html.markdown

@@ -0,0 +1,525 @@
+---
+language: javascript
+contributors:
+    - ['Adam Brenecki', 'http://adam.brenecki.id.au']
+    - ['Ariel Krakowski', 'http://www.learneroo.com']
+filename: javascript-fr.js
+translators:
+    - ['@nbrugneaux', 'https://nicolasbrugneaux.me']
+lang: fr-fr
+---
+
+JavaScript a été créé par Brendan Eich, travaillant alors a Netscape, en 1995.
+Le langage avait à l'origine pour but d'être un langage de scripting simple
+pour les sites web, complétant le Java (à ne pas confondre avec JavaScript)
+pour des applications web complexes. Mais son intégration très proche et 
+simple des pages web, ainsi que le support natif des navigateurs a rendu 
+le JavaScript incontournable aujourd'hui tant bien dans le front-end que 
+dans le back-end.
+
+En effet, le JavaScript n'est plus uniquement limité aux navigateurs, grâce à
+Node.JS, un projet qui offre un environnement indépendant dans lequel un 
+interpréteur Javascript, basé sur le célèbre moteur V8 de Google Chrome, 
+peut être utilisé directement côté serveur pour exécuter des programmes écrits
+en JavaScript.
+
+```js
+// Les commentaires sont comme en C. Les commentaires mono-ligne commencent par 2 slashs,
+/* et les commentaires sur plusieurs lignes commencent avec slash-étoile
+   et finissent avec étoile-slash */
+
+// Toutes les expressions peuvent finir par ;
+doStuff();
+
+// ... mais n'en n'ont pas forcément besoin, les point-virgules sont ajoutés 
+// lors de l’interprétation aux sauts de ligne, sauf exceptions
+doStuff()
+
+// Parce que ces cas peuvent produire des effets inattendus, nous utiliserons
+// des point-virgules dans ce guide.
+
+
+///////////////////////////////////
+// 1. Nombres, Chaines de caractères et Opérateurs
+
+// JavaScript a un seul type de nombre (qui est un 64-bit IEEE 754 double (décimaux))
+// Comme avec le Lua, ne paniquez pas à cause du manque d'int (entiers) : les
+// doubles ont un mantisse de 52 bits, ce qui est assez pour stocker des int jusqu'à
+// 9 x 10¹⁵ exactement.
+3; // = 3
+1.5; // = 1.5
+
+// L'arithmétique de base fonctionne comme vous vous y attendriez
+1 + 1; // = 2
+8 - 1; // = 7
+10 * 2; // = 20
+35 / 5; // = 7
+
+// Ainsi que les divisions non-entières
+5 / 2; // = 2.5
+
+// Les opérations bits à bits fonctionnent aussi, quand vous effectuez une opération
+// bits à bits, votre nombre décimal est converti en entier *jusqu'à* 32 bits.
+1 << 2; // = 4
+
+// Comme en mathématiques, la priorité est donnée aux parenthèses.
+(1 + 3) * 2; // = 8
+
+// Il existe 3 valeurs spéciales pour les nombres:
+Infinity; // le résultat de 1/0 par exemple
+-Infinity; // le résultat de -1/0 par exemple
+NaN; // le résultat de 0/0 par exemple
+
+// Il existe également le type booléen.
+true; // vrai
+false; // faux
+
+// Les chaines de caractères (strings) sont créees avec " ou ' indifféremment, la seule
+// raison de choisir l'un ou l'autre est la cohérence dans votre code.
+"abc";
+'Hello, world';
+
+// La négation utilise le symbole !
+!true; // = false
+!false; // = true
+
+// L'égalité est === ou ==
+// === compare la valeur exacte 2 === '2' // = false
+// == convertit la valeur pour comparer 2 === '2' // = true
+// En général, il vaut mieux utiliser === pour ne pas faire d'erreur.
+1 === 1; // = true
+2 === 1; // = false
+
+// L'inégalité est !== ou !=, basé sur le même principe qu'avant.
+1 !== 1; // = false
+2 !== 1; // = true
+
+// Plus de comparaisons :
+1 < 10; // = true
+1 > 10; // = false
+2 <= 2; // = true
+2 >= 2; // = true
+
+// Les chaines de caractères se concatènent avec +
+'Hello ' + 'world!'; // = 'Hello world!'
+
+// et peuvent être comparées alphabétiquement avec < et >
+'a' < 'b'; // = true
+
+// Vous pouvez accéder les caractères dans une string avec charAt
+'This is a string'.charAt(0);  // = 'T'
+
+// ... ou utiliser substring pour avoir un plus gros morceau
+'Hello world'.substring(0, 5); // = 'Hello'
+
+// la longueur, length, est une propriété, donc n'utilisez pas de ()
+'Hello'.length; // = 5
+
+// Il y a également null et undefined
+null; // utilisé pour une non-valeur
+undefined; // utilisé pour une valeur actuellement non présente (cependant, 
+           // undefined est aussi une valeur valide)
+
+// false, null, undefined, NaN, 0 and '' sont 'presque-faux' (falsy), tout le reste
+// est 'presque-vrai' (truthy)
+// Notez que 0 est falsy mais '0' est truthy, alors même que 0 == '0' (mais 0 !== '0')
+
+
+///////////////////////////////////
+// 2. Variables, Tableaux et Objets
+
+// Les variables sont déclarées avec le mot clé var. Le typage en JavaScript est 
+// dynamique, donc pas besoin de spécifier le type. L'assignement utilise un seul =.
+var someVar = 5;
+
+// si vous oubliez le mot clé var, vous n'aurez pas d'erreur (sauf en mode strict)
+someOtherVar = 10;
+
+// ... mais la variable aura une portée globale (plus communément trouvé en tant 
+// que "global scope" en anglais), et non pas une portée limitée à la fonction 
+// dans laquelle vous l'aviez définie.
+
+// Les variables déclarées et non assignées sont undefined par défaut
+var someThirdVar;
+var someThirdVar = undefined;
+
+// ... sont deux déclarations identiques.
+
+// Il y a des raccourcis pour les opérations mathématiques:
+someVar += 5; // équivalent pour someVar = someVar + 5;
+someVar *= 10; // de même, someVar = someVar * 100;
+someVar++;    // = someVar += 1;
+someVar--;  // = someVar -= 1;
+
+// Les tableaux (Arrays) sont des listes ordonnées de valeurs, de tous types.
+var myArray = ['Hello', 45, true];
+
+// Leurs membres peuvent être accédés en utilisant les crochets
+// Les indices commencent à 0.
+myArray[1]; // = 45
+
+// Les tableaux sont modifiables, ainsi que leurs longueurs
+myArray.push( 'World' );
+myArray.length; // = 4
+
+// Ajout/Modification à un index spécifique
+myArray[3] = 'Hello';
+
+// Les objets JavaScript sont appelés 'dictionnaires' ou 'maps' dans certains autres
+// langages : ils sont une liste non-ordonnée de paires clé-valeur.
+var myObj = {key1: 'Hello', key2: 'World'};
+
+// Les clés sont des strings, mais les ' ou " sont optionels si elles sont des
+// noms valides en JavaScript. Les valeurs peuvent être de n'importe quel type.
+var myObj = {myKey: 'myValue', 'my other key': 4};
+
+// Les attributs d'objets peuvent être accédés avec les crochets
+myObj['my other key']; // = 4
+
+// .. ou avec un point si la clé est un identifiant valide.
+myObj.myKey; // = 'myValue'
+
+// Les objets sont eux aussi modifiables.
+myObj.myThirdKey = true;
+
+// Si vous essayez d'accéder à une valeur non-définie, vous obtiendrez undefined
+myObj.myFourthKey; // = undefined
+
+
+///////////////////////////////////
+// 3. Logique et structures de contrôle
+
+// Les si (if) fonctionnent comme vous vous y attendez.
+var count = 1;
+if (count === 3) {
+  // seulement quand count est 3
+}
+else if (count === 4) {
+  // uniquement quand count est 4
+}
+else {
+  // le reste du temps, si ni 3, ni 4. 
+}
+
+// De même pour while.
+while (true) {
+  // Une boucle infinie !
+}
+
+// Les boucles do-while sont pareilles, mais sont exécutées au moins une fois.
+var input
+do {
+  input = getInput();
+} while (!isValid(input))
+
+// La boucle for est la même qu'en C ou en Java:
+// initialisation; condition pour continuer; itération
+for (var i = 0; i < 5; i++){
+    // sera exécutée 5 fois
+}
+
+// && est le "et" logique, || est le "ou" logique
+if (house.size === 'big' && house.colour === 'blue'){
+    house.contains = 'bear';
+}
+if (colour === 'red' || colour === 'blue'){
+    // colour est soit 'red' soit 'blue'
+}
+
+// Les raccourcis && et || sont pratiques pour instancier des valeurs par defaut.
+var name = otherName || 'default';
+
+// Ceci est l'équivalent de
+var name = otherName;
+if (!name){
+  name = 'default';
+}
+
+// Le switch vérifie les égalités avec ===
+// utilisez un "break" à la fin de chaque cas
+// ou les cas suivants seront eux aussi exécutés
+grade = 'B';
+switch (grade) {
+  case 'A':
+    console.log('Great job');
+    break;
+  case 'B':
+    console.log('OK job');
+    break;
+  case 'C':
+    console.log('You can do better');
+    break;
+  default:
+    console.log('Oy vey');
+    break;
+}
+
+
+///////////////////////////////////
+// 4. Fonctions, Scope (Environnement) et Closures
+
+// Les fonctions sont déclarées avec le mot clé function
+function myFunction(thing){
+    return thing.toUpperCase();
+}
+myFunction('foo'); // = 'FOO'
+
+// Les fonctions JavaScript sont des objets de première classe, donc peuvent 
+// être réassignées à d'autres variables et passées en tant que paramètres pour
+// d'autres fonctions
+function myFunction(){
+    // ce code s'exécutera dans 5 secondes
+}
+setTimeout(myFunction, 5000);
+// Note: setTimeout ne fait pas parti du langage, mais les navigateurs ainsi
+// que Node.js le rendent disponible
+
+// Les fonctions n'ont pas nécessairement besoin d'un nom, elles peuvent être 
+// anonymes
+setTimeout(function(){
+    // ce code s'exécutera dans 5 secondes
+}, 5000);
+
+// Le Javascript crée uniquement un scope, une portée d'action limitée, pour 
+// les fonctions, et pas dans les autres blocs.
+if (true){
+    var i = 5;
+}
+i; // = 5 - et non undefined comme vous pourriez vous y attendre
+
+// Cela a mené à un style commun de fonctions anonymes immédiatement exécutée;
+// ou "immediately-executing anonymous functions"
+(function(){
+    var temporary = 5;
+    // Nous pouvons accéder au scope global en assignant à l'objet global,
+    // qui dans les navigateurs est "window". Il est différent dans Node.js,
+    // le scope global sera en fait local au module dans lequel vous 
+    // vous trouvez. http://nodejs.org/api/globals.html
+    window.permanent = 10;
+})();
+// Cela permet de ne pas avoir de fuites de variables qui polluent
+// l’environnement global.
+temporary; // raises ReferenceError
+permanent; // = 10
+
+// Une des fonctionnalités les plus puissantes de Javascript est le système de 
+// closures. Si une fonction est définie dans une autre fonction, alors la 
+// fonction interne aura accès aux variables de la fonction parente, même si
+// celle-ci a déjà finie son exécution.
+function sayHelloInFiveSeconds(name){
+    var prompt = 'Hello, ' + name + '!';
+    // Fonction interne
+    function inner(){
+        alert(prompt);
+    }
+    setTimeout(inner, 5000);
+    // setTimeout is asynchrone, donc la fonction sayHelloInFiveSeconds quittera
+    // immédiatement, et setTimeout appelera inner après.
+}
+sayHelloInFiveSeconds('Adam'); // ouvre un popup avec 'Hello, Adam!' dans 5sec
+
+
+///////////////////////////////////
+// 5. Encore plus à propos des Objets; Constructeurs and Prototypes
+
+// Les objets peuvent contenir des fonctions.
+var myObj = {
+    myFunc: function(){
+        return 'Hello world!';
+    }
+};
+myObj.myFunc(); // = 'Hello world!'
+
+// Lorsqu'une fonction attachée à un objet est appelée, elle peut accéder à
+// l'objet avec le mot clé this.
+myObj = {
+    myString: 'Hello world!',
+    myFunc: function(){
+        return this.myString;
+    }
+};
+myObj.myFunc(); // = 'Hello world!'
+
+// La valeur de "this" change de par l'endroit où la fonction est appelée, et 
+// non de l'endroit où elle est définie. Donc elle ne fonctionnera pas si elle
+// est appelée hors du contexte l'objet.
+var myFunc = myObj.myFunc;
+myFunc(); // = undefined
+
+// A l'inverse, une fonction peut être attachée à un objet et y gagner l'accès
+// au travers de "this"
+var myOtherFunc = function(){
+    return this.myString.toUpperCase();
+}
+
+myObj.myOtherFunc = myOtherFunc;
+myObj.myOtherFunc(); // = 'HELLO WORLD!'
+
+// Le contexte correspond à la valeur de "this".
+// Nous pouvons aussi spécifier un contexte, forcer la valeur de "this, 
+// pour une fonction quand elle est appelée grâce à "call" ou "apply".
+var anotherFunc = function(s){
+    return this.myString + s;
+}
+anotherFunc.call(myObj, ' And Hello Moon!'); // = 'Hello World! And Hello Moon!'
+
+// 'apply' est presque identique, mais prend un tableau comme liste d’arguments.
+
+anotherFunc.apply(myObj, [' And Hello Sun!']); // = 'Hello World! And Hello Sun!'
+
+Math.min(42, 6, 27); // = 6
+Math.min([42, 6, 27]); // = NaN (uh-oh!)
+Math.min.apply(Math, [42, 6, 27]); // = 6
+
+// Mais, "call" and "apply" fonctionnenent uniquement au moment de l'appel de la 
+// fonction. Pour lier le contexte de façon permanente, nous pouvons utiliser 
+// "bind" pour garder une référence à la fonction avec ce "this".
+var boundFunc = anotherFunc.bind(myObj);
+boundFunc(' And Hello Saturn!'); // = 'Hello World! And Hello Saturn!'
+
+// "bind" peut aussi être utilisé pour créer une application partielle de la 
+// fonction (curry)
+var product = function(a, b){ return a * b; }
+var doubler = product.bind(this, 2);
+doubler(8); // = 16
+
+// Lorsque vous appelez une fonction avec le mot clé "new", un nouvel objet est 
+// crée et mis à disposition de la fonction via "this". Ces fonctions sont
+// communément appelées constructeurs.
+var MyConstructor = function(){
+    this.myNumber = 5;
+}
+myNewObj = new MyConstructor(); // = {myNumber: 5}
+myNewObj.myNumber; // = 5
+
+// Chaque objet en Javascript a un "prototype". Quand vous essayez d'accéder à
+// une propriété que l'objet n'a pas, l'interpréteur va regarder son prototype.
+
+// Quelques implémentations de JS vous laissent accéder au prototype avec la 
+// propriété "magique" __proto__. Ceci peut être utile, mais n'est pas standard 
+// et ne fonctionne pas dans certains des navigateurs actuels.
+var myObj = {
+    myString: 'Hello world!'
+};
+var myPrototype = {
+    meaningOfLife: 42,
+    myFunc: function(){
+        return this.myString.toLowerCase()
+    }
+};
+
+myObj.__proto__ = myPrototype;
+myObj.meaningOfLife; // = 42
+myObj.myFunc(); // = 'hello world!'
+
+myPrototype.__proto__ = {
+    myBoolean: true
+};
+myObj.myBoolean; // = true
+
+
+// Pour obtenir le prototype il existe également Object.getPrototypeOf
+Object.getPrototypeOf( myObj ) // = {meaningOfLife: 42, myFunc: function}
+
+// Il n'y a pas de copie ici. Chacun des objets stocke une référence à son
+// prototype. Cela veut dire que l'on peut le modifier et cela se répercutera
+// partout.
+myPrototype.meaningOfLife = 43;
+myObj.meaningOfLife; // = 43
+
+// L'inverse n'est cependant pas vrai. Changer la propriété d'un objet ne change
+// pas la chaine prototypale.
+myObj.meaningOfLife = 42;
+myPrototype.meaningOfLife; // = 43
+
+// Comme précédemment dit, __proto__ n'est pas standard et ne devrait pas être
+// utilisé. Il y a deux autres moyen de créer un nouvel objet avec un prototype
+// donné.
+
+// Le premier est Object.create, mais c'est assez récent et risque de ne pas
+// fonctionner dans tous les navigateurs.
+var myObj = Object.create(myPrototype);
+myObj.meaningOfLife; // = 43
+
+// Le deuxième moyen, qui marche partout, fonctionne avec les constructeurs.
+// Les constructeurs ont un propriété appelée prototype. Ce n'est *pas* le
+// prototype du constructeur de la fonction elle-même, c'est le prototype que
+// les nouveaux objets crées grâce à ce constructeur avec "new" auront.
+MyConstructor.prototype = {
+    myNumber: 5,
+    getMyNumber: function(){
+        return this.myNumber;
+    }
+};
+var myNewObj2 = new MyConstructor();
+myNewObj2.getMyNumber(); // = 5
+myNewObj2.myNumber = 6
+myNewObj2.getMyNumber(); // = 6
+
+// Les types pré-définis tels que les strings ou nombres ont aussi des
+// constructeurs
+var myNumber = 12;
+var myNumberObj = new Number(12);
+myNumber == myNumberObj; // = true
+
+// ... mais ils ne sont pas exactement équivalent.
+typeof myNumber; // = 'number'
+typeof myNumberObj; // = 'object'
+myNumber === myNumberObj; // = false
+if (0){
+    // 0 est falsy, le code ne fonctionnera pas.
+}
+if (Number(0)){
+    // Parce que Number(0) est truthy, le code fonctionnera
+}
+
+// Cependant, vous pouvez ajouter des fonctionnalités aux types de bases grâce à
+// cette particularité.
+String.prototype.firstCharacter = function(){
+    return this.charAt(0);
+}
+'abc'.firstCharacter(); // = 'a'
+
+// C'est très souvent utilisé pour le "polyfilling", qui implémente des nouvelles
+// fonctionnalités de JavaScript dans de plus anciens environnements, tels que 
+// les vieux navigateurs.
+
+//Par exemple, Object.create est assez récent, mais peut être implémenté grâce à
+// ce polyfill
+if (Object.create === undefined){ // pour ne pas reécrire si la fonction existe déjà
+    Object.create = function(proto){
+        // on crée un constructeur temporaire avec le bon prototype
+        var Constructor = function(){};
+        Constructor.prototype = proto;
+        // puis on utilise "new" pour créer un object avec ce même prototype
+        return new Constructor();
+    }
+}
+```
+
+## Pour aller plus loin (en anglais)
+
+The [Mozilla Developer
+Network](https://developer.mozilla.org/fr-FR/docs/Web/JavaScript) expose une
+excellente documentation pour le Javascript dans les navigateurs. Et contient 
+également un wiki pour s'entraider.
+
+MDN's [A re-introduction to
+JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript)
+recouvre les principaux sujets vus ici. Le guide est délibérément uniquement
+à propos du JavaScript, et ne parle pas des navigateurs; pour cela, dirigez vous 
+plutôt ici :
+[Document Object
+Model](https://developer.mozilla.org/en-US/docs/Using_the_W3C_DOM_Level_1_Core)
+
+[Learn Javascript by Example and with Challenges](http://www.learneroo.com/modules/64/nodes/350) quelques challenges. 
+
+[JavaScript Garden](http://bonsaiden.github.io/JavaScript-Garden/) is an in-depth
+un guide pour vous éviter les faux-amis dans le JavaScript.
+
+[JavaScript: The Definitive Guide](http://www.amazon.com/gp/product/0596805527/) un classique. A lire. 
+
+En addition aux contributeurs de cet article, du contenu provient du 
+"Python tutorial" de Louie Dinh, et de [JS
+Tutorial](https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript)
+sur le réseau Mozilla.

go.html.markdown

@@ -92,7 +92,8 @@ can include line breaks.` // Same string type.
 
 	// Arrays have size fixed at compile time.
 	var a4 [4]int           // An array of 4 ints, initialized to all 0.
-	a3 := [...]int{3, 1, 5} // An array of 3 ints, initialized as shown.
+	a3 := [...]int{3, 1, 5} // An array initialized with a fixed size of three
+	// elements, with values 3, 1, and 5.
 
 	// Slices have dynamic size. Arrays and slices each have advantages
 	// but use cases for slices are much more common.

ruby.html.markdown

@@ -9,6 +9,7 @@ contributors:
   - ["Nick LaMuro", "https://github.com/NickLaMuro"]
   - ["Marcos Brizeno", "http://www.about.me/marcosbrizeno"]
   - ["Ariel Krakowski", "http://www.learneroo.com"]
+  - ["Dzianis Dashkevich", "https://github.com/dskecse"]
 
 ---
 
@@ -35,7 +36,7 @@ You shouldn't either
 8 - 1 #=> 7
 10 * 2 #=> 20
 35 / 5 #=> 7
-2 ** 5 #=> 32
+2**5 #=> 32
 
 # Arithmetic is just syntactic sugar
 # for calling a method on an object
@@ -78,14 +79,17 @@ false.class #=> FalseClass
 'I am a string'.class #=> String
 "I am a string too".class #=> String
 
-placeholder = "use string interpolation"
+placeholder = 'use string interpolation'
 "I can #{placeholder} when using double quoted strings"
 #=> "I can use string interpolation when using double quoted strings"
 
+# Prefer single quoted strings to double quoted ones where possible
+# Double quoted strings perform additional inner calculations
+
 # Combine strings, but not with numbers
-"hello " + "world"  #=> "hello world"
+'hello ' + 'world'  #=> "hello world"
-"hello " + 3 #=> TypeError: can't convert Fixnum into String
+'hello ' + 3 #=> TypeError: can't convert Fixnum into String
-"hello " + 3.to_s #=> "hello 3"
+'hello ' + 3.to_s #=> "hello 3"
 
 # print to the output
 puts "I'm printing!"
@@ -130,7 +134,7 @@ array = [1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5]
 
 # Arrays can contain different types of items
 
-[1, "hello", false] #=> [1, "hello", false]
+[1, 'hello', false] #=> [1, "hello", false]
 
 # Arrays can be indexed
 # From the front
@@ -157,7 +161,7 @@ array << 6 #=> [1, 2, 3, 4, 5, 6]
 
 # Hashes are Ruby's primary dictionary with keys/value pairs.
 # Hashes are denoted with curly braces:
-hash = {'color' => 'green', 'number' => 5}
+hash = { 'color' => 'green', 'number' => 5 }
 
 hash.keys #=> ['color', 'number']
 
@@ -170,7 +174,7 @@ hash['nothing here'] #=> nil
 
 # Since Ruby 1.9, there's a special syntax when using symbols as keys:
 
-new_hash = { defcon: 3, action: true}
+new_hash = { defcon: 3, action: true }
 
 new_hash.keys #=> [:defcon, :action]
 
@@ -180,11 +184,11 @@ new_hash.keys #=> [:defcon, :action]
 # Control structures
 
 if true
-  "if statement"
+  'if statement'
 elsif false
-  "else if, optional"
+  'else if, optional'
 else
-  "else, also optional"
+  'else, also optional'
 end
 
 for counter in 1..5
@@ -216,7 +220,7 @@ end
 #=> iteration 5
 
 # You can also surround blocks in curly brackets:
-(1..5).each {|counter| puts "iteration #{counter}"}
+(1..5).each { |counter| puts "iteration #{counter}" }
 
 # The contents of data structures can also be iterated using each.
 array.each do |element|
@@ -241,32 +245,30 @@ grade = 'B'
 
 case grade
 when 'A'
-  puts "Way to go kiddo"
+  puts 'Way to go kiddo'
 when 'B'
-  puts "Better luck next time"
+  puts 'Better luck next time'
 when 'C'
-  puts "You can do better"
+  puts 'You can do better'
 when 'D'
-  puts "Scraping through"
+  puts 'Scraping through'
 when 'F'
-  puts "You failed!"
+  puts 'You failed!'
 else
-  puts "Alternative grading system, eh?"
+  puts 'Alternative grading system, eh?'
 end
-
 #=> "Better luck next time"
 
 # cases can also use ranges
 grade = 82
 case grade
-    when 90..100
+when 90..100
-      puts "Hooray!"
+  puts 'Hooray!'
-    when 80...90
+when 80...90
-      puts "OK job" 
+  puts 'OK job'
-    else
+else
-      puts "You failed!"
+  puts 'You failed!'
 end
-
 #=> "OK job"
 
 
@@ -284,23 +286,23 @@ double 3 #=> 6
 
 double double 3 #=> 12
 
-def sum(x,y)
+def sum(x, y)
   x + y
 end
 
 # Method arguments are separated by a comma
 sum 3, 4 #=> 7
 
-sum sum(3,4), 5 #=> 12
+sum sum(3, 4), 5 #=> 12
 
 # yield
 # All methods have an implicit, optional block parameter
 # it can be called with the 'yield' keyword
 
 def surround
-  puts "{"
+  puts '{'
   yield
-  puts "}"
+  puts '}'
 end
 
 surround { puts 'hello world' }
@@ -311,25 +313,25 @@ surround { puts 'hello world' }
 
 
 # You can pass a block to a function
-# "&" marks a reference to a passed block 
+# "&" marks a reference to a passed block
 def guests(&block)
- block.call "some_argument" 
+  block.call 'some_argument'
 end
- 
+
 # You can pass a list of arguments, which will be converted into an array
-# That's what splat operator ("*") is for 
+# That's what splat operator ("*") is for
 def guests(*array)
- array.each { |guest| puts "#{guest}" }
+  array.each { |guest| puts guest }
 end
 
 # Define a class with the class keyword
 class Human
 
   # A class variable. It is shared by all instances of this class.
-  @@species = "H. sapiens"
+  @@species = 'H. sapiens'
 
   # Basic initializer
-  def initialize(name, age=0)
+  def initialize(name, age = 0)
     # Assign the argument to the "name" instance variable for the instance
     @name = name
     # If no age given, we will fall back to the default in the arguments list.
@@ -356,20 +358,19 @@ class Human
   # A class method uses self to distinguish from instance methods.
   # It can only be called on the class, not an instance.
   def self.say(msg)
-    puts "#{msg}"
+    puts msg
   end
 
   def species
     @@species
   end
-
 end
 
 
 # Instantiate a class
-jim = Human.new("Jim Halpert")
+jim = Human.new('Jim Halpert')
 
-dwight = Human.new("Dwight K. Schrute")
+dwight = Human.new('Dwight K. Schrute')
 
 # Let's call a couple of methods
 jim.species #=> "H. sapiens"
@@ -380,7 +381,7 @@ dwight.species #=> "H. sapiens"
 dwight.name #=> "Dwight K. Schrute"
 
 # Call the class method
-Human.say("Hi") #=> "Hi"
+Human.say('Hi') #=> "Hi"
 
 # Variable's scopes are defined by the way we name them.
 # Variables that start with $ have global scope
@@ -399,7 +400,7 @@ defined? @@var #=> "class variable"
 Var = "I'm a constant"
 defined? Var #=> "constant"
 
-# Class also is object in ruby. So class can have instance variables.
+# Class is also an object in ruby. So class can have instance variables.
 # Class variable is shared among the class and all of its descendants.
 
 # base class
@@ -415,7 +416,7 @@ class Human
   end
 end
 
-#  derived class
+# derived class
 class Worker < Human
 end
 
@@ -451,8 +452,8 @@ module ModuleExample
   end
 end
 
-# Including modules binds the methods to the object instance
+# Including modules binds their methods to the class instances
-# Extending modules binds the methods to the class instance
+# Extending modules binds their methods to the class itself
 
 class Person
   include ModuleExample
@@ -467,7 +468,7 @@ Person.new.foo # => 'foo'
 Book.foo       # => 'foo'
 Book.new.foo   # => NoMethodError: undefined method `foo'
 
-# Callbacks when including and extending a module are executed
+# Callbacks are executed when including and extending a module
 
 module ConcernExample
   def self.included(base)
@@ -500,9 +501,8 @@ Something.new.qux # => 'qux'
 
 ## Additional resources
 
-- [Learn Ruby by Example with Challenges](http://www.learneroo.com/modules/61/nodes/338) - A variant of this reference with in-browser challenges. 
+- [Learn Ruby by Example with Challenges](http://www.learneroo.com/modules/61/nodes/338) - A variant of this reference with in-browser challenges.
 - [Official Documentation](http://www.ruby-doc.org/core-2.1.1/)
 - [Ruby from other languages](https://www.ruby-lang.org/en/documentation/ruby-from-other-languages/)
-- [Programming Ruby](http://www.amazon.com/Programming-Ruby-1-9-2-0-Programmers/dp/1937785491/) - An older [free addition](http://ruby-doc.com/docs/ProgrammingRuby/) is available online. 
+- [Programming Ruby](http://www.amazon.com/Programming-Ruby-1-9-2-0-Programmers/dp/1937785491/) - An older [free addition](http://ruby-doc.com/docs/ProgrammingRuby/) is available online.
-
+- [Ruby Style Guide](https://github.com/bbatsov/ruby-style-guide) - A community-driven Ruby coding style guide.
-

zh-cn/markdown-cn.html.markdown

@@ -0,0 +1,240 @@
+---
+language: Markdown
+contributors:
+    - ["Dan Turkel", "http://danturkel.com/"]
+translators:
+    - ["Fangzhou Chen"]
+filename: learnmarkdown-cn.md
+lang: zh-cn
+---
+
+Markdown 由 John Gruber 于 2004年创立. 它旨在成为一门容易读写的语法结构，并可以便利地转换成 HTML（以及其他很多）格式。
+
+欢迎您多多反馈以及分支和请求合并。
+
+
+```
+<!-- Markdown 是 HTML 的父集，所以任何 HTML 文件都是有效的 Markdown。
+这意味着我们可以在 Markdown 里使用任何 HTML 元素，比如注释元素，
+且不会被 Markdown 解析器所影响。不过如果你在 Markdown 文件内创建了 HTML 元素，
+你将无法在 HTML 元素的内容中使用 Markdown 语法。-->
+
+<!-- 在不同的解析器中，Markdown 的实现方法有所不同。
+此教程会指出当某功能是否通用及是否只对某一解析器有效。 -->
+
+<!-- 标头 -->
+<!-- 通过在文本前加上不同数量的hash(#), 你可以创建相对应的 <h1> 
+到 <h6> HTML元素。-->
+
+# 这是一个 <h1>
+## 这是一个 <h2>
+### 这是一个 <h3>
+#### 这是一个 <h4>
+##### 这是一个 <h5>
+###### 这是一个 <h6>
+
+<!-- 对于 <h1> 和 <h2> 元素，Markdown 额外提供了两种添加方式。 -->
+这是一个 h1
+=============
+
+这是一个 h2
+-------------
+
+<!-- 简易文本样式 -->
+<!-- 文本的斜体，粗体，和删除线在 Markdown 中可以轻易地被实现。-->
+
+*此文本为斜体。*
+_此文本也是。_
+
+**此文本为粗体。**
+__此文本也是__
+
+***此文本是斜体加粗体。***
+**_或者这样。_**
+*__这个也是！__*
+
+<!-- 在 Github 采用的 Markdown 中 -->
+
+~~此文本为删除线效果。~~
+
+<!-- 单个段落由一句或多句邻近的句子组成，这些句子由一个或多个空格分隔。-->
+
+这是第一段落. 这句话在同一个段落里，好玩么？
+
+现在我是第二段落。
+这句话也在第二段落！
+
+这句话在第三段落！
+
+<!-- 如果你插入一个 HTML中的<br />标签，你可以在段末加入两个以上的空格，
+然后另起一段。-->
+
+此段落结尾有两个空格（选中以显示）。      
+
+上文有一个 <br /> ！
+
+<!-- 段落引用可由 > 字符轻松实现。-->
+
+> 这是一个段落引用. 你可以
+> 手动断开你的句子，然后在每句句子前面添加 “>” 字符。或者让你的句子变得很长，以至于他们自动得断开。
+> 只要你的文字以“>” 字符开头，两种方式无异。
+
+> 你也对文本进行
+>> 多层引用
+> 这多机智啊！
+
+<!-- 序列 -->
+<!-- 无序序列可由星号，加号或者减号来建立 -->
+
+* 项目
+* 项目
+* 另一个项目
+
+或者
+
++ 项目
++ 项目
++ 另一个项目
+
+或者 
+
+- 项目
+- 项目
+- 最后一个项目
+
+<!-- 有序序列可由数字加点来实现 -->
+
+1. 项目一
+2. 项目二
+3. 项目三
+
+<!-- 即使你的标签数字有误，Markdown 依旧会呈现出正确的序号，
+不过这并不是一个好主意-->
+
+1. 项目一
+1. 项目二
+1. 项目三
+<!-- (此段与前例一模一样) -->
+
+<!-- 你也可以使用子序列 -->
+
+1. 项目一
+2. 项目二
+3. 项目三
+    * 子项目
+    * 子项目
+4. 项目四
+
+<!-- 代码段落 -->
+<!-- 代码段落（HTML中 <code>标签）可以由缩进四格（spaces）
+或者一个标签页（tab）实现-->
+
+    This is code
+    So is this
+
+<!-- 在你的代码中，你仍然使用tab可以进行缩进操作 -->
+
+    my_array.each do |item|
+        puts item
+    end
+
+<!-- 内联代码可由反引号 ` 实现 -->
+
+John 甚至不知道 `go_to()` 方程是干嘛的!
+
+<!-- 在Github的 Markdown中，对于代码你可以使用特殊的语法 -->
+
+\`\`\`ruby <!-- 插入时记得移除反斜线， 仅留```ruby ！ -->
+def foobar
+    puts "Hello world!"
+end
+\`\`\` <!-- 这里也是，移除反斜线，仅留 ``` -->
+
+<!-- 以上代码不需要缩进，而且 Github 会根据```后表明的语言来进行语法高亮 -->
+
+<!-- 水平线 （<hr />） -->
+<!-- 水平线可由三个或以上的星号或者减号创建，可带可不带空格。 -->
+
+***
+---
+- - - 
+****************
+
+<!-- 链接 -->
+<!-- Markdown 最棒的地方就是简易的链接制作。链接文字放在中括号[]内，
+在随后的括弧()内加入url。-->
+
+[点我点我!](http://test.com/)
+
+<!-- 你也可以为链接加入一个标题：在括弧内使用引号 -->
+
+[点我点我!](http://test.com/ "连接到Test.com")
+
+<!-- 相对路径也可以有 -->
+
+[去 music](/music/).
+
+<!-- Markdown同样支持引用样式的链接 -->
+
+[点此链接][link1]以获取更多信息！
+[看一看这个链接][foobar] 如果你愿意的话.
+
+[link1]: http://test.com/ "Cool!"
+[foobar]: http://foobar.biz/ "Alright!"
+
+<!-- 链接的标题可以处于单引号中，括弧中或是被忽略。引用名可以在文档的任意何处，
+并且可以随意命名，只要名称不重复。-->
+
+<!-- “隐含式命名” 的功能可以让链接文字作为引用名 -->
+
+[This][] is a link.
+
+[this]: http://thisisalink.com/
+
+<!-- 但这并不常用 -->
+
+<!-- 图像 -->
+<!-- 图像与链接相似，只需在前添加一个感叹号 -->
+
+![这是我图像的悬停文本(alt text)](http://imgur.com/myimage.jpg "可选命名")
+
+<!-- 引用样式也同样起作用 -->
+
+![这是我的悬停文本.][myimage]
+
+[myimage]: relative/urls/cool/image.jpg "在此输入标题"
+
+<!-- 杂项 -->
+<!-- 自动链接 -->
+
+<http://testwebsite.com/> 与
+[http://testwebsite.com/](http://testwebsite.com/) 等同
+
+<!-- 电子邮件的自动链接 -->
+
+<foo@bar.com>
+
+<!-- 转义字符 -->
+
+我希望 *将这段文字置于星号之间* 但是我不希望它被
+斜体化, 所以我就: \*这段置文字于星号之间\*。
+
+<!-- 表格 -->
+<!-- 表格只被 Github 的 Markdown 支持，并且有一点笨重，但如果你真的要用的话: -->
+
+| 第一列        | 第二列    | 第三列       |
+| :----------   | :------:  | ----------:  |
+| 左对齐        | 居个中    | 右对齐       |
+| 某某某        | 某某某    | 某某某       |
+
+<!-- 或者, 同样的 -->
+
+第一列 | 第二列 | 第三列
+:-- | :-: | --:
+这太丑了 | 药不能 | 停
+
+<!-- 结束! -->
+
+```
+
+更多信息, 请于[此处](http://daringfireball.net/projects/Markdown/syntax)参见 John Gruber 关于语法的官方帖子，及于[此处](https://github.com/adam-p/Markdown-here/wiki/Markdown-Cheatsheet) 参见 Adam Pritchard 的摘要笔记。