Apply minor fixes in '1-js/08-prototypes/02-function-prototype/article.md'

Author: ArmandDelessert

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",