fr translation

Author: Sebastien Nicoud

doc/fr/array/constructor.md

@@ -0,0 +1,27 @@
+## Le constructeur `Array`
+
+Le constructeur `Array` traite ses paramètres de façon ambigu.
+Il est fortement recommandé d'utiliser le littéral de tableau  - notation `[]` - pour créer de nouveaux tableaux.
+
+    [1, 2, 3]; // Résultat: [1, 2, 3]
+    new Array(1, 2, 3); // Résultat: [1, 2, 3]
+    
+    [3]; // Résultat: [3]
+    new Array(3); // Résultat: []
+    new Array('3') // Résultat: ['3']
+
+Dans les cas où il n'y a qu'un seul argument passé au constructeur `Array`, et quand cet argument est un nombre `Number`, le constructeur va retourner un nouveau tableau *clairsemé* avec la propriété `length` (longueur) fixée à la valeur de l'argument.
+Il faut noter que de cette façon, **seulement** la propriété `length` du nouveau tableau sera mise en place, les indices réels du tableau ne seront pas initialisés.
+
+    var arr = new Array(3);
+    arr[1]; // undefined
+    1 in arr; // faux, l'indice n'existe pas
+
+Être en mesure de régler la longueur du tableau à l'avance n'est utile que dans quelques cas, comme la répétition d'une chaîne de caractères, dans lequel on évite l'utilisation d'une boucle.
+
+    new Array(count + 1).join(chaineARepeter);
+
+### En conclusion
+
+Les littéraux sont préférés au constructeur `Array`. Ils sont plus courts, ont une syntaxe plus claire, et augmente la lisibilité du code.
+

doc/fr/array/general.md

@@ -0,0 +1,46 @@
+## Tableaux: iteration et propriétés
+
+Bien que les tableaux soient des objets en JavaScript, il n'y a pas de bonnes raisons d'utiliser la boucle [`for in`](#object.forinloop).
+En fait, il un certain nombre de bonnes raisons **contre** l'utilisation de `for in` sur les tableaux.
+
+**Remarque:** Les tableaux JavaScript ne sont **pas** *associatifs*. JavaScript n'offre que les [objets](#object.general) pour associer des clés à des valeurs. Contrairement aux tableaux associatifs, les objets ne préservent **pas** l'ordre.
+
+La boucle `for in` énumère toutes les propriétés qui sont sur la chaîne de prototypes, et le seul moyen d'exclure ces propriétés consiste à utiliser
+[`hasOwnProperty`](#object.hasownproperty), par conséquent la boucle `for in ` est **vingt fois** plus lente qu'une boucle `for` classique.
+
+### Itération
+
+Pour itérer sur les tableaux de façon performante, il est préférable d'utiliser la boucle `for` classique.
+
+    var list = [1, 2, 3, 4, 5, ...... 100000000];
+    for(var i = 0, l = list.length; i < l; i++) {
+        console.log(list[i]);
+    }
+
+Notez l'optimization supplémentaire dans l'exemple ci-dessus: la longueur du tableau est mise en mémoire "cached" via `l = list.length`.
+
+La propriété `length` est définie sur le tableau lui-même, mais la rechercher à chaque itération de la boucle à un coût.
+Bien que les moteurs JavaScript récents **peuvent** appliquer l'optimisation, il n'y a aucun moyen de savoir si le code s'exécutera sur un de ces nouveaux moteurs.
+
+En effet, mettre la longueur du tableau en mémoire cache peut **doubler** la vitesse d'execution de la boucle.
+
+### La propriété `length`
+
+Le *getter* de la propriété `length` (longueur) renvoie simplement le nombre d'éléments contenus dans le tableau, mais le *setter* peut être utilisé pour
+tronquer le tableau.
+
+    var arr = [1, 2, 3, 4, 5, 6];
+    arr.length = 3;
+    arr; // [1, 2, 3]
+    
+    arr.length = 6;
+    arr.push(4);
+    arr; // [1, 2, 3, undefined, undefined, undefined, 4]
+
+Attribuer une longueur inférieure tronque le tableau. Accroître la longueur crée un tableau clairsemé.
+
+### En conclusion
+
+Pour de meilleures performances, il est recommandé de toujours utiliser la boucle `for` classique et de mettre en mémoire la propriété `length`.
+L'utilisation de la boucle `for in` sur un tableau est un signe de code mal écrit, de mauvaise performance, et sujet à des bogues.
+

doc/fr/core/delete.md

@@ -0,0 +1,76 @@
+## L'opérateur `delete`
+
+Il est *impossible* de supprimer les variables globales, fonctions et autres choses qui ont l'attribut `DontDelete` en JavaScript.
+
+### Le code global et le code de fonction
+
+Quand une variable ou une fonction est définie dans la portée globale ou une [portée de fonction](#function.scopes), c'est une propriété soit de l'objet d'activation, soit de l'objet global.
+Ces propriétés ont un ensemble d'attributs, dont l'un est `DontDelete`. Les déclarations de variables et de fonctions dans le code global et le code de fonction vont toujours créer des propriétés avec `DontDelete`, elle ne peuvent donc pas être supprimées.
+
+    // global variable:
+    var a = 1; // DontDelete est mis
+    delete a; // faux
+    a; // 1
+    
+    // normal function:
+    function f() {} // DontDelete is mis
+    delete f; // faux
+    typeof f; // "function"
+    
+    // reassigner n'aide pas:
+    f = 1;
+    delete f; // faux
+    f; // 1
+
+### Propriétés explicites
+
+Les propriétés crées explicitement peuvent être supprimées normalement.
+
+    // propriété crée explicitement:
+    var obj = {x: 1};
+    obj.y = 2;
+    delete obj.x; // vrai
+    delete obj.y; // vrai
+    obj.x; // undefined
+    obj.y; // undefined
+
+Dans l'exemple ci-dessus, les propriétés `obj.x` et `obj.y` peuvent être supprimées parce qu'elles n'ont pas l'attribut `DontDelete`. C'est aussi pourquoi l'exemple ci-dessous fonctionne également.
+
+    // ceci fonctionne, sauf sur IE:
+    var GLOBAL_OBJECT = this;
+    GLOBAL_OBJECT.a = 1;
+    a === GLOBAL_OBJECT.a; // vrai - juste une var globale
+    delete GLOBAL_OBJECT.a; // vrai
+    GLOBAL_OBJECT.a; // undefined
+
+Ici, nous utilisons une astuce pour supprimer `a`. [`this`](#function.this) se réfère ici à l'objet global et nous déclarons explicitement la variable `a` comme sa propriété, ce qui nous permet de la supprimer.
+
+IE (au moins 6-8) a quelques bogues, le code ci-dessus n'y fonctionne pas.
+
+### Les arguments de fonction et built-ins
+
+Les arguments normaux de fonctions, [objets `arguments`](#Function.arguments) et les propriétés intégrées "built-in" ont aussi l'attribut `DontDelete`.
+
+    // les arguments de fonction et les propriétés:
+    (function (x) {
+    
+      delete arguments; // faux
+      typeof arguments; // "object"
+      
+      delete x; // faux
+      x; // 1
+      
+      function f(){}
+      delete f.length; // faux
+      typeof f.length; // "number"
+      
+    })(1);
+
+### Objets hôtes
+
+Le comportement de l'opérateur `delete` peut être imprévisible pour les objets hébergés "hosted". Dû à la spécification, les objets hôte sont autorisés à mettre en œuvre tout type de comportement.
+    
+### En conclusion
+
+L'opérateur `delete` a souvent un comportement inattendu et ne peut être utilisé que pour supprimer les propriétés explicitement définies sur des objets normaux.
+

doc/fr/core/eval.md

@@ -0,0 +1,42 @@
+## Il ne faut pas utiliser `eval`
+
+La fonction `eval` exécute une chaîne de caractères représentant du code JavaScript dans la portée locale.
+
+    var number = 1;
+    function test() {
+        var number = 2;
+        eval('number = 3');
+        return number;
+    }
+    test(); // 3
+    number; // 1
+
+Cependant, `eval` n'exécute dans la portée locale que quand il est appelé directement *et* quand le nom de la fonction appelée est en fait `eval`.
+
+    var number = 1;
+    function test() {
+        var number = 2;
+        var copyOfEval = eval;
+        copyOfEval('number = 3');
+        return number;
+    }
+    test(); // 2
+    number; // 3
+
+L'utilisation de la fonction `eval` doit être évitée. 99,9% de ses "cas d'utilisation" peuvent être obtenues **sans** elle.
+    
+### `eval` déguisé
+
+Les [fonctions timeout](#other.timeouts) `setTimeout` et `setInterval` acceptent une chaîne comme premier argument.
+Cette chaîne sera **toujours** exécutée dans la portée globale car dans ce cas, `eval` n'est pas appelé directement.
+
+### Problèmes de sécurité
+
+`eval` est aussi un problème de sécurité, car il exécute **n'importe quel** code qu'on lui donne.
+Il devrait **jamais** être utilisé avec des chaînes d'origines inconnues ou douteuses.
+
+### En conclusion
+
+`eval` ne devrait jamais être utilisé. Sa presence met en doute le fonctionnement, la performance, et la sécurité du code qui l'utilise.
+Si quelque chose a besoin d'`eval` pour pouvoir fonctionner, il ne doit **pas** être utilisé en premier lieu. Un *meilleur design* qui n'utilise pas `eval` doit être trouvé et implementé.
+

doc/fr/core/semicolon.md

@@ -0,0 +1,100 @@
+## Insertion automatique du point-virgule
+
+Bien que JavaScript a une syntaxe de style C, il n'impose **pas** les points-virgules dans le code source. Il est donc possible de les omettre.
+
+JavaScript n'est pas un langage sans points-virgules. En fait, les points-virgules sont necessaires pour comprendre le code source. Par conséquent, l'analyseur JavaScript les insère **automatiquement** chaque fois qu'il rencontre une erreur d'analyse due à un point-virgule manquant.
+
+    var foo = function() {
+    } // erreur d'analyse, point-virgule attendu
+    test()
+
+L'analyseur insère un point-virgule, puis tente à nouveau.
+
+    var foo = function() {
+    }; // plus d'error, l'analyse continue
+    test()
+
+L'insertion automatique du point-virgule est considérée comme l'un des **plus gros** défauts de conception dans le langage parce que cela *peut* changer le comportement du code.
+
+### Comment cela marche
+
+Le code ci-dessous n'a pas de points-virgules, l'analyseur va donc décider où les insérer.
+
+    (function(window, undefined) {
+        function test(options) {
+            log('testing!')
+    
+            (options.list || []).forEach(function(i) {
+    
+            })
+    
+            options.value.test(
+                'long string to pass here',
+                'and another long string to pass'
+            )
+    
+            return
+            {
+                foo: function() {}
+            }
+        }
+        window.test = test
+    
+    })(window)
+    
+    (function(window) {
+        window.someLibrary = {}
+    
+    })(window)
+
+Voici le résultat du jeu de devinette de l'analyseur.
+
+    (function(window, undefined) {
+        function test(options) {
+    
+            // pas inséré, les lignes ont fusionné
+            log('testing!')(options.list || []).forEach(function(i) {
+    
+            }); // <- inséré
+    
+            options.value.test(
+                'long string to pass here',
+                'and another long string to pass'
+            ); // <- inséré
+    
+            return; // <- inséré, casse la déclaration return
+            { // traité comme un bloc
+    
+                // un label et une déclaration d'expression
+                foo: function() {} 
+            }; // <- inséré
+        }
+        window.test = test; // <- inséré
+    
+    // les lignes ont fusionné ici encore
+    })(window)(function(window) {
+        window.someLibrary = {}; // <- inséré
+    
+    })(window); //<- inséré
+
+> **Remarque:** L'analyseur JavaScript ne manipule pas "correctement" les déclarations return suivies par une nouvelle ligne.
+
+L'analyseur a radicalement changé le comportement du code ci-dessus. Dans certains cas, il fait la **mauvaise chose**.
+
+### Parenthèse en tête
+
+En cas de parenthèse en tête, l'analyseur ne va **pas** insérer de point-virgule.
+
+    log('testing!')
+    (options.list || []).forEach(function(i) {})
+
+Ce code fusionne en une ligne.
+
+    log('testing!')(options.list || []).forEach(function(i) {})
+
+Il y a de **très** fortes chances que `log` ne retourne **pas** de fonction; par conséquent, le programme ci-dessus va produire une erreur de type `TypeError` indiquant que undefined n'est pas un function `undefined is not a function`.
+
+### En conclusion
+
+Il est fortement recommandé de ne **jamais** omettre les points-virgules. Il est également recommandé de garder les accolades sur la même ligne que leurs déclarations correspondantes et de ne jamais les omettre pour les déclaration en une ligne `if` / `else`. Ces mesures vont non seulement améliorer la cohérence du code, mais elles empêcheront également l'analyseur JavaScript de changer le comportement du code.
+

doc/fr/core/undefined.md

@@ -0,0 +1,55 @@
+## `undefined` et `null`
+
+JavaScript a deux valeurs distinctes pour "rien": `null` et `undefined`, `undefined` étant la plus utile.
+
+### La valeur `undefined`
+
+`undefined` est un type avec exactement une valeur:` undefined`.
+
+Le langage définit également une variable globale qui a la valeur `undefined`. Cette variable est aussi appelée `undefined`. Cependant, cette variable n'est ni une constante, ni un mot clé du langage, ce que signifie que sa *valeur* peut être facilement écrasée.
+
+> **Remarque ES5:** `undefined` dans ECMAScript 5 n'est **plus** inscriptible dans le mode stricte, mais son nom peut toujours être outrepassé, par example par une fonction avec le nom `undefined`.
+
+Voici quelques exemples de cas où la valeur `undefined` est retournée:
+
+ - Accès à la variable globale (non modifié) `undefined`.
+ - Accès à une variable déclarée, mais *pas encore* initialisée.
+ - Retours implicites de fonctions sans déclaration `return`.
+ - Déclarations `return` vides, qui ne renvoient rien.
+ - Recherches de propriétés inexistantes.
+ - Paramètres de fonction qui ne ont pas de valeur explicite passée.
+ - Tout ce qui a été mis à la valeur de `undefined`.
+ - Toute expression sous forme de `void(expression)`.
+
+### Changements à la valeur de `undefined`
+
+Puisque la variable globale `undefined` contient uniquement une copie de la *valeur* réelle `undefined`, l'attribution d'une nouvelle valeur à la variable ne modifie **pas** la valeur du *type* `undefined`.
+
+Pourtant, pour pouvoir comparer quelque chose contre la valeur de `undefined`, il est d'abord nécessaire pour récupérer la valeur de `undefined`.
+
+Afin de protéger le code contre une éventuelle variable `undefined` écrasée, une technique commune utilisée consiste à ajouter un paramètre supplémentaire à une [enveloppe anonyme](#function.scopes) et de lui passer aucun argument.
+
+    var undefined = 123;
+    (function(something, foo, undefined) {
+        // undefined dans la portée locale 
+        // réfère bien à la valeur `undefined`
+
+    })('Hello World', 42);
+
+Une autre façon d'obtenir le même effet est d'utiliser une déclaration à l'intérieur de l'enveloppe.
+
+    var undefined = 123;
+    (function(something, foo) {
+        var undefined;
+        ...
+
+    })('Hello World', 42);
+
+La seule différence étant quelques caractères de plus pour écrire "var".
+
+### Utilisation de `null`
+
+Alors que `undefined` dans le contexte du langage JavaScript est utilisé dans la plupart des cas dans le d'un *null* traditionnel, le `null` réel (un littéral et un type) est juste un autre type de données.
+
+`null` est utilisé par JavaScript (comme signaler la fin de la chaîne de prototypes avec `Foo.prototype = null`), mais dans presque tous les cas, il peut être remplacé par `undefined`.
+