mirror of
https://github.com/adambard/learnxinyminutes-docs.git
synced 2025-08-19 04:52:13 +02:00
Merge branch 'master' of github.com:adambard/learnxinyminutes-docs
This commit is contained in:
Adam
525
fr-fr/javascript-fr.html.markdown
Normal file
525
fr-fr/javascript-fr.html.markdown
Normal file
@@ -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.
|
||||
@@ -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.
|
||||
|
||||
@@ -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"]
|
||||
|
||||
---
|
||||
|
||||
@@ -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 " + 3 #=> TypeError: can't convert Fixnum into String
|
||||
"hello " + 3.to_s #=> "hello 3"
|
||||
'hello ' + 'world' #=> "hello world"
|
||||
'hello ' + 3 #=> TypeError: can't convert Fixnum into String
|
||||
'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
|
||||
@@ -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
|
||||
@@ -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
|
||||
puts "Hooray!"
|
||||
puts 'Hooray!'
|
||||
when 80...90
|
||||
puts "OK job"
|
||||
puts 'OK job'
|
||||
else
|
||||
puts "You failed!"
|
||||
puts 'You failed!'
|
||||
end
|
||||
|
||||
#=> "OK job"
|
||||
|
||||
|
||||
@@ -298,9 +300,9 @@ sum sum(3,4), 5 #=> 12
|
||||
# it can be called with the 'yield' keyword
|
||||
|
||||
def surround
|
||||
puts "{"
|
||||
puts '{'
|
||||
yield
|
||||
puts "}"
|
||||
puts '}'
|
||||
end
|
||||
|
||||
surround { puts 'hello world' }
|
||||
@@ -313,20 +315,20 @@ surround { puts 'hello world' }
|
||||
# You can pass a block to a function
|
||||
# "&" 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
|
||||
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)
|
||||
@@ -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
|
||||
@@ -451,8 +452,8 @@ module ModuleExample
|
||||
end
|
||||
end
|
||||
|
||||
# Including modules binds the methods to the object instance
|
||||
# Extending modules binds the methods to the class instance
|
||||
# Including modules binds their methods to the class instances
|
||||
# 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)
|
||||
@@ -504,5 +505,4 @@ Something.new.qux # => 'qux'
|
||||
- [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.
|
||||
|
||||
|
||||
- [Ruby Style Guide](https://github.com/bbatsov/ruby-style-guide) - A community-driven Ruby coding style guide.
|
||||
|
||||
240
zh-cn/markdown-cn.html.markdown
Normal file
240
zh-cn/markdown-cn.html.markdown
Normal file
@@ -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/
|
||||
|
||||
<!-- 但这并不常用 -->
|
||||
|
||||
<!-- 图像 -->
|
||||
<!-- 图像与链接相似，只需在前添加一个感叹号 -->
|
||||
|
||||
|
||||
|
||||
<!-- 引用样式也同样起作用 -->
|
||||
|
||||
![这是我的悬停文本.][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 的摘要笔记。
|
||||
Reference in New Issue
Block a user