Merge pull request #464 from ArmandDelessert/patch-1-js-08-prototypes

Apporte plusieurs corrections au chapitre 1.8 (Prototypes)

Author: HachemiH

1-js/08-prototypes/01-prototype-inheritance/1-property-after-delete/task.md

@@ -6,7 +6,7 @@ importance: 5
 
 Voici le code qui crée une paire d'objets, puis les modifie.
 
-Quelles sont les valeurs affichées dans le processus?
+Quelles sont les valeurs affichées dans le processus ?
 
 ```js
 let animal = {

1-js/08-prototypes/01-prototype-inheritance/article.md

@@ -319,12 +319,12 @@ Remarque, il y a une chose amusante. D'où vient la méthode `rabbit.hasOwnPrope
 
 ...Mais pourquoi `hasOwnProperty` n'apparaît pas dans la boucle `for..in`, comme `eats` et `jumps`, s'il répertorie toutes les propriétés héritées.
 
-La réponse est simple : ce n'est pas énumérable. Comme toutes les autres propriétés de `Object.prototype`, il possède l'attribut `enumerable: false`. C'est pourquoi ils ne sont pas répertoriés. Et `for..in` ne répertorie que les propriétés énumérables. C'est pourquoi elle et le reste des propriétés `Object.prototype` ne sont pas listés.
+La réponse est simple : ce n'est pas énumérable. Comme toutes les autres propriétés de `Object.prototype`, il possède l'attribut `enumerable: false`. C'est pourquoi ils ne sont pas répertoriés. Et `for..in` ne répertorie que les propriétés énumérables. C'est pourquoi elle et le reste des propriétés de `Object.prototype` ne sont pas listés.
 
 ```smart header="Presque toutes les autres méthodes d'obtention de clé/valeur ignorent les propriétés héritées"
 Presque toutes les autres méthodes d'obtention de clé/valeur, telles que `Object.keys`, `Object.values` et ainsi de suite ignorent les propriétés héritées.
 
-Ils ne fonctionnent que sur l'objet lui-même. Les propriétés du prototype ne sont *pas* prises en compte.
+Elles ne fonctionnent que sur l'objet lui-même. Les propriétés du prototype ne sont *pas* prises en compte.
 ```
 
 ## Résumé

1-js/08-prototypes/02-function-prototype/1-changing-prototype/solution.md

@@ -1,5 +1,5 @@
 
-Réponses:
+Réponses :
 
 1. `true`.
 
@@ -13,7 +13,7 @@ Réponses:
 
 3. `true`.
 
-     Toutes les opérations `delete` sont appliquées directement à l'objet. `Delete rabbit.eats` tente ici de supprimer la propriété `eats` de `rabbit`, mais ne l’a pas. Donc l'opération n'aura aucun effet.
+     Toutes les opérations `delete` sont appliquées directement à l'objet. `delete rabbit.eats` tente ici de supprimer la propriété `eats` de `rabbit`, mais ne l’a pas. Donc l'opération n'aura aucun effet.
 
 4. `undefined`.
 

1-js/08-prototypes/02-function-prototype/1-changing-prototype/task.md

@@ -6,7 +6,7 @@ importance: 5
 
 Dans le code ci-dessous, nous créons `new Rabbit`, puis essayons de modifier son prototype.
 
-Au début, nous avons ce code:
+Au début, nous avons ce code :
 
 ```js run
 function Rabbit() {}
@@ -19,8 +19,7 @@ let rabbit = new Rabbit();
 alert( rabbit.eats ); // true
 ```
 
-
-1. Nous avons ajouté une chaîne de caractères supplémentaire (surlignée), qu'affiche `alert` maintenant?
+1. Nous avons ajouté une chaîne de caractères supplémentaire (surlignée), qu'affiche `alert` maintenant ?
 
     ```js
     function Rabbit() {}
@@ -37,7 +36,7 @@ alert( rabbit.eats ); // true
     alert( rabbit.eats ); // ?
     ```
 
-2. ...Et si le code est comme ça (une ligne remplacé)?
+2. ...Et si le code est comme ça (une ligne remplacée) ?
 
     ```js
     function Rabbit() {}
@@ -54,7 +53,7 @@ alert( rabbit.eats ); // true
     alert( rabbit.eats ); // ?
     ```
 
-3. Et comme ceci (une ligne remplacée)?
+3. Et comme ceci (une ligne remplacée) ?
 
     ```js
     function Rabbit() {}
@@ -71,7 +70,7 @@ alert( rabbit.eats ); // true
     alert( rabbit.eats ); // ?
     ```
 
-4. La dernière variante:
+4. La dernière variante :
 
     ```js
     function Rabbit() {}

1-js/08-prototypes/02-function-prototype/4-new-object-same-constructor/solution.md

@@ -1,6 +1,6 @@
 Nous pouvons utiliser cette approche si nous sommes sûrs que la propriété `"constructeur"` a la valeur correcte.
 
-Par exemple, si nous ne touchons pas le `"prototype"` par défaut, alors ce code fonctionne à coup sûr:
+Par exemple, si nous ne touchons pas le `"prototype"` par défaut, alors ce code fonctionne à coup sûr :
 
 ```js run
 function User(name) {
@@ -10,14 +10,14 @@ function User(name) {
 let user = new User('John');
 let user2 = new user.constructor('Pete');
 
-alert( user2.name ); // Pete (ça marche!)
+alert( user2.name ); // Pete (ça marche !)
 ```
 
 Cela a fonctionné, car `User.prototype.constructor == User`.
 
 ..Mais si quelqu'un, pour ainsi dire, écrase `User.prototype` et oublie de recréer `constructor` pour faire référence à `User`, il échouera.
 
-Par exemple:
+Par exemple :
 
 ```js run
 function User(name) {
@@ -33,9 +33,9 @@ let user2 = new user.constructor('Pete');
 alert( user2.name ); // undefined
 ```
 
-Pourquoi `user2.name` est `undefined`?
+Pourquoi `user2.name` est `undefined` ?
 
-Voici comment `new user.constructor('Pete')` fonctionne:
+Voici comment `new user.constructor('Pete')` fonctionne :
 
 1. Tout d'abord, il cherche `constructor` dans `user`. Rien.
 2. Ensuite, il suit la chaîne de prototypes. Le prototype de `user` est `User.prototype`, et il n'a pas non plus de `constructor` (parce que nous avons "oublié" de le régler correctement !).

1-js/08-prototypes/02-function-prototype/4-new-object-same-constructor/task.md

@@ -6,10 +6,10 @@ importance: 5
 
 Imaginez nous avons un objet arbitraire `obj`, créé par une fonction constructeur - nous ne savons pas lequel, mais nous aimerions créer un nouvel objet à l'aide de celui-ci.
 
-Pouvons-nous le faire comme ça?
+Pouvons-nous le faire comme ça ?
 
 ```js
 let obj2 = new obj.constructor();
 ```
 
-Donne un exemple de fonction constructeur pour `obj` qui laisse ce code fonctionner correctement. Et un exemple qui fait que ça marche mal.
+Donne un exemple de fonction constructeur pour `obj` qui laisse ce code fonctionner correctement. Et un exemple qui fait que ça marche mal.

1-js/08-prototypes/02-function-prototype/article.md

@@ -5,14 +5,14 @@ Rappelez-vous que de nouveaux objets peuvent être créés avec une fonction con
 Si `F.prototype` est un objet, alors l'opérateur `new` l'utilise pour définir `[[Prototype]]` pour le nouvel objet.
 
 ```smart header="Veuillez noter"
-JavaScript avait l'héritage prototypique depuis le début. C'était l'une des caractéristiques principales de la langue.
+JavaScript avait l'héritage prototypique depuis le début. C'était l'une des caractéristiques principales du langage.
 
 Mais dans le passé, il n'y avait pas d'accès direct. La seule chose qui fonctionnait de manière fiable est une propriété `"prototype"` de la fonction constructeur décrite dans ce chapitre. Donc, il y a beaucoup de scripts qui l'utilisent encore.
 ```
 
 Veuillez noter que `F.prototype` signifie ici une propriété régulière nommée `"prototype"` sur `F`. Cela ressemble quelque peu au terme "prototype", mais nous entendons ici une propriété régulière portant ce nom.
 
-Voici l'exemple:
+Voici l'exemple :
 
 ```js run
 let animal = {
@@ -32,27 +32,27 @@ let rabbit = new Rabbit("White Rabbit"); //  rabbit.__proto__ == animal
 alert( rabbit.eats ); // true
 ```
 
-Définir `Rabbit.prototype=animal` énonce littéralement ce qui suit: "Lorsqu'un `new Rabbit` est créé, assigner son `[[Prototype]]` à `animal`".
+Définir `Rabbit.prototype=animal` énonce littéralement ce qui suit : "Lorsqu'un `new Rabbit` est créé, assigner son `[[Prototype]]` à `animal`".
 
-C'est l'image résultante:
+Voici l'image résultante :
 
 ![](proto-constructor-animal-rabbit.svg)
 
 Sur l'image, `"prototype"` est une flèche horizontale, ce qui signifie une propriété normale, et `[[Prototype]]` est vertical, ce qui signifie l'héritage de `rabbit` de `animal`.
 
 ```smart header="`F.prototype` utilisé uniquement pendant `new F`"
-La propriété `F.prototype` est utilisée uniquement lorsque `new F` est appelé, elle attribue `[[Prototype]]` du nouvel objet. Après cela, il n'y a plus de connexion entre `F.prototype` et le nouvel objet. 
+La propriété `F.prototype` est utilisée uniquement lorsque `new F` est appelé, elle attribue `[[Prototype]]` du nouvel objet. Après cela, il n'y a plus de connexion entre `F.prototype` et le nouvel objet.
 
 Si, après la création, la propriété `F.prototype` change (`F.prototype = <un autre objet>`), les nouveaux objets créés par `new F` auront un autre objet comme `[[Prototype]]`, mais les objets déjà existants conservent l'ancien.
 ```
 
 ## F.prototype par défaut, propriété du constructeur
 
-Chaque fonction a la propriété `"prototype "` même si nous ne la fournissons pas.
+Chaque fonction a la propriété `"prototype"` même si nous ne la fournissons pas.
 
 Le `"prototype"` par défaut est un objet avec comme seule propriété `constructor` qui renvoie à la fonction elle-même.
 
-Comme ça:
+Comme ça :
 
 ```js
 function Rabbit() {}
@@ -64,7 +64,7 @@ Rabbit.prototype = { constructor: Rabbit };
 
 ![](function-prototype-constructor.svg)
 
-Nous pouvons le vérifier:
+Nous pouvons le vérifier :
 
 ```js run
 function Rabbit() {}
@@ -74,7 +74,7 @@ function Rabbit() {}
 alert( Rabbit.prototype.constructor == Rabbit ); // true
 ```
 
-Naturellement, si nous ne faisons rien, la propriété `constructor` est disponible pour tous les "rabbits" via `[[Prototype]]`:
+Naturellement, si nous ne faisons rien, la propriété `constructor` est disponible pour tous les "rabbits" via `[[Prototype]]` :
 
 ```js run
 function Rabbit() {}
@@ -90,7 +90,7 @@ alert(rabbit.constructor == Rabbit); // true (de prototype)
 
 Nous pouvons utiliser la propriété `constructor` pour créer un nouvel objet en utilisant le même constructeur que l'existant.
 
-Comme ici:
+Comme ici :
 
 ```js run
 function Rabbit(name) {
@@ -111,11 +111,11 @@ Mais probablement la chose la plus importante à propos de `"constructor"` est q
 
 **...JavaScript lui-même n'assure pas la bonne valeur de `"constructor"`.**
 
-Oui, il existe dans le `"prototype"` par défaut pour les fonctions, mais c'est tout. Ce qui se passe avec apres le fait - dépend totalement de nous.
+Oui, il existe dans le `"prototype"` par défaut des fonctions, mais c'est tout. Ce qu'il en adviendra par la suite dépend entièrement de nous.
 
 En particulier, si nous remplaçons le prototype par défaut dans son ensemble, il ne contiendra pas de "constructor".
 
-Par exemple:
+Par exemple :
 
 ```js run
 function Rabbit() {}
@@ -129,7 +129,7 @@ alert(rabbit.constructor === Rabbit); // false
 */!*
 ```
 
-Donc, pour garder le bon `"constructor"`, nous pouvons choisir d'ajouter/supprimer des propriétés au `"prototype"` par défaut au lieu de l'écraser dans son ensemble:
+Donc, pour garder le bon `"constructor"`, nous pouvons choisir d'ajouter/supprimer des propriétés au `"prototype"` par défaut au lieu de l'écraser dans son ensemble :
 
 ```js
 function Rabbit() {}
@@ -140,7 +140,7 @@ Rabbit.prototype.jumps = true
 // le Rabbit.prototype.constructor par défaut est conservé
 ```
 
-Ou bien, recréez manuellement la propriété `constructor`:
+Ou bien, recréez manuellement la propriété `constructor` :
 
 ```js
 Rabbit.prototype = {
@@ -153,18 +153,18 @@ Rabbit.prototype = {
 // maintenant le constructeur est également correct, car nous l'avons ajouté
 ```
 
-
 ## Résumé
 
 Dans ce chapitre, nous avons brièvement décrit la manière de définir un `[[Prototype]]` pour les objets créés via une fonction constructeur. Plus tard, nous verrons des modèles de programmation plus avancés qui en dépendent.
 
 Tout est assez simple, juste quelques précisions pour clarifier les choses :
 
-- La propriété `F.prototype` (ne pas confondre avec `[[Prototype]]`) définit `[[Prototype]]` de nouveaux objets lorsque `new F()` est appelée.
+- La propriété `F.prototype` (ne pas confondre avec `[[Prototype]]`) définit `[[Prototype]]` sur les nouveaux objets lorsque `new F()` est appelée.
 - La valeur de `F.prototype` devrait soit être un objet ou `null` : les autres valeurs ne fonctionneront pas.
 - La propriété `"prototype"` n'a cet effet spécial que lorsqu'elle est définie dans une fonction constructeur et invoquée avec `new`.
 
-Sur les objets ordinaires, le `prototype` n'a rien de spécial:
+Sur les objets ordinaires, le `prototype` n'a rien de spécial :
+
 ```js
 let user = {
   name: "John",

1-js/08-prototypes/03-native-prototypes/1-defer-to-prototype/solution.md

@@ -1,5 +1,3 @@
-
-
 ```js run
 Function.prototype.defer = function(ms) {
   setTimeout(this, ms);

1-js/08-prototypes/03-native-prototypes/1-defer-to-prototype/task.md

@@ -6,7 +6,7 @@ importance: 5
 
 Ajoutez au prototype de toutes les fonctions la méthode `defer(ms)`, qui exécute la fonction après `ms` millisecondes.
 
-Une fois que vous le faites, ce code devrait fonctionner:
+Une fois que vous le faites, ce code devrait fonctionner :
 
 ```js
 function f() {

1-js/08-prototypes/03-native-prototypes/2-defer-to-prototype-extended/solution.md

@@ -1,5 +1,3 @@
-
-
 ```js run
 Function.prototype.defer = function(ms) {
   let f = this;
@@ -8,17 +6,17 @@ Function.prototype.defer = function(ms) {
   }
 };
 
-// vérifier
+// vérification
 function f(a, b) {
   alert( a + b );
 }
 
 f.defer(1000)(1, 2); // montre 3 après 1 seconde
 ```
 
-Please note: we use `this` in `f.apply` to make our decoration work for object methods.
+Notez que nous utilisons `this` dans `f.apply` pour que notre décoration fonctionne pour les méthodes d'objets.
 
-So if the wrapper function is called as an object method, then `this` is passed to the original method `f`.
+Ainsi, si la fonction wrapper est appelée en tant que méthode d'objet, alors `this` est passé à la méthode originale `f`.
 
 ```js run
 Function.prototype.defer = function(ms) {

1-js/08-prototypes/03-native-prototypes/2-defer-to-prototype-extended/task.md

@@ -6,7 +6,7 @@ importance: 4
 
 Ajoutez au prototype de toutes les fonctions la méthode `defer(ms)`, qui renvoie un wrapper, retardant l’appel de `ms` millisecondes.
 
-Voici un exemple de la façon dont cela devrait fonctionner:
+Voici un exemple de la façon dont cela devrait fonctionner :
 
 ```js
 function f(a, b) {