Merge pull request #465 from ArmandDelessert/patch-1-js-09-classes

Apporte plusieurs corrections aux parties 1 à 4 du chapitre 1.9 (Classes)

Author: HachemiH

1-js/09-classes/01-class/article.md

@@ -13,7 +13,8 @@ Mais dans le JavaScript moderne, il y a une construction de la "classe" plus ava
 
 ## La syntaxe de "classe"
 
-La syntaxe de base est:
+La syntaxe de base est :
+
 ```js
 class MyClass {
   // Les méthodes de la classe
@@ -27,9 +28,9 @@ class MyClass {
 
 Vous pouvez ensuite utiliser `new MyClass()` pour créer un nouvel objet ayant toute la liste des méthodes.
 
-La méthode `constructor()`  est automatiquement appelée par `new`, donc nous pouvons initialiser l'objet à ce niveau.
+La méthode `constructor()` est automatiquement appelée par `new`, donc nous pouvons initialiser l'objet à ce niveau.
 
-Par exemple:
+Par exemple :
 
 ```js run
 class User {
@@ -50,81 +51,80 @@ user.sayHi();
 ```
 
 Lorsque `new User("John")` est appelé :
+
 1. Un nouvel objet est créé.
 2. Le `constructor` s'exécute avec les arguments qui lui sont passés et assigne `this.name` a l'objet.
 
 ...ensuite nous pouvons appeler les méthodes de l'objet, tel que `user.sayHi()`.
 
-
 ```warn header="Pas de virgule entre les méthodes de la classe"
-Un piège fréquent des développeurs novices est de mettre une virgule entre les méthodes de la classe,  entrainant ainsi une erreur syntaxique.
+Un piège fréquent des développeurs novices est de mettre une virgule entre les méthodes de la classe, entrainant ainsi une erreur syntaxique.
 
 La notation ici ne doit pas être confondue avec les objets littéraux. A l'intérieure d'une classe, aucune virgule n'est requise.
 ```
 
-## Qu'est-ce qu'une classe?
+## Qu'est-ce qu'une classe ?
 
-Alors, c'est quoi exactement une `class`? Ce n'est pas totalement une nouvelle  entité au niveau de la langue, comme on pourrait le penser.
+Alors, c'est quoi exactement une `class` ? Ce n'est pas totalement une nouvelle entité au niveau du langage, comme on pourrait le penser.
 
-Dévoilons maintenant la magie et regardons ce qu'est réellement une classe.  Cela va nous aider à comprendre plusieurs aspects complexes.
+Dévoilons maintenant la magie et regardons ce qu'est réellement une classe. Cela va nous aider à comprendre plusieurs aspects complexes.
 
 En JavaScript, une classe est une sorte de fonction.
 
-Regardons ici:
+Regardons ici :
 
 ```js run
 class User {
   constructor(name) { this.name = name; }
   sayHi() { alert(this.name); }
 }
 
-// La preuve: User est une fonction
+// La preuve : User est une fonction
 *!*
 alert(typeof User); // function
 */!*
 ```
 
-Ce que `class User {...}` la construction fait en réalité est de:
+Ce que la construction de la classe `classe User {...}` fait réellement, c'est :
 
-1. Créer une fonction nommée `User`,  qui devient le résultat de la déclaration de la classe. Le code  de la fonction est tirée de la méthode `constructor` (considérée comme étant vide au cas ou cette méthode n'est pas écrite).
+1. Créer une fonction nommée `User`, qui devient le résultat de la déclaration de la classe. Le code de la fonction est tirée de la méthode `constructor` (considérée comme étant vide au cas ou cette méthode n'est pas écrite).
 2. Garde les méthodes de la classe, telle que `sayHi`, dans `User.prototype`.
 
 Après la création de `new User`, lorsque nous appelons sa méthode, elle est extraite du prototype, comme décrit dans le chapitre <info:function-prototype>. Donc, l'objet a accès aux méthodes de classe.
 
-Nous pouvons illustrer le résultat de la déclaration de `class User` par :
+Nous pouvons illustrer le résultat de la déclaration de `class User` ainsi :
 
-Nous pouvons illustrer le résultat de la déclaration de `class User` ainsi:
 ![](class-user.svg)
 
-Voici le code pour une introspection:
+Voici le code pour une introspection :
 
 ```js run
 class User {
   constructor(name) { this.name = name; }
   sayHi() { alert(this.name); }
 }
 
-// classe est une function
+// classe est une fonction
 alert(typeof User); // function
 
 // ...ou, plus précisément, le constructeur de la méthode
 alert(User === User.prototype.constructor); // true
 
-// Les méthodes sont dans  User.prototype, par exemple :
+// Les méthodes sont dans User.prototype, par exemple :
 alert(User.prototype.sayHi); // le code de la méthode sayHi
 
 // Il y a exactement deux méthodes dans le prototype
 alert(Object.getOwnPropertyNames(User.prototype)); // constructeur, sayHi
 ```
 
-## Pas simplement un sucre syntaxique 
+## Pas simplement un sucre syntaxique
 
-Parfois certaines personnes disent que la notion de `class` est un "sucre syntaxique" (une syntaxe qui est destinée à rendre la lecture plus facile, mais elle n'introduit  rien de nouveau), parce qu'en réalité nous pouvons  déclarer la même chose sans utiliser le mot clé `classe` :
+Parfois certaines personnes disent que la notion de `class` est un "sucre syntaxique" (une syntaxe qui est destinée à rendre la lecture plus facile, mais elle n'introduit rien de nouveau), parce qu'en réalité nous pouvons déclarer la même chose sans utiliser le mot clé `class` :
 
 ```js run
 // Réécriture de class User en fonctions pures
 
-// 1. Créer la fonction constructeur 
+// 1. Créer la fonction constructeur
 function User(name) {
   this.name = name;
 }
@@ -158,7 +158,7 @@ Cependant, il existe des différences importantes.
     User(); // Erreur: le constructeur Class User ne peut être invoque sans 'new'
     ```
 
-    Aussi, la représentation en chaine de caractère d'un constructeur de class dans la plupart des moteurs de JavaScript commence avec la "class..."
+    Aussi, la représentation en chaîne de caractères d'un constructeur de class dans la plupart des moteurs de JavaScript commence avec "class..." :
 
     ```js run
     class User {
@@ -167,10 +167,11 @@ Cependant, il existe des différences importantes.
 
     alert(User); // class User { ... }
     ```
-    There are other differences, we'll see them soon.
+
+    Il y a d'autres différences, nous les verrons bientôt.
 
 2. Les méthodes de Class sont non-énumérable.
-    Une définition de la classe attribue à la propriété  `énumérable` le drapeau de `false` a  les méthodes du `"prototype"`.
+    Une définition de la classe attribue `false` à la propriété `enumerable` pour toutes les méthodes du `"prototype"`.
 
     C'est bien, parce que si nous exécutons un `for..in` sur un Object, souvent nous ne voulons pas accéder aux méthodes de sa classe.
 
@@ -179,11 +180,11 @@ Cependant, il existe des différences importantes.
 
 En outres, la syntaxe `classe` apporte beaucoup d'autres caractéristiques que nous allons explorer plus tard.
 
-##  L'Expression Class
+## L'Expression Class
 
 Tout comme les fonctions, les classes peuvent être définies a l'intérieur d'une autre expression, passées en paramètres, retournées, assignées etc.
 
-Voici un exemple d'expression d'une classe:
+Voici un exemple d'expression d'une classe :
 
 ```js
 let User = class {
@@ -195,46 +196,45 @@ let User = class {
 
 Similairement aux Fonction Expressions nommées, les expressions de classe peuvent avoir un nom.
 
-Si une expression de classe a un nom, il est visible à l'intérieur de la classe uniquement:
+Si une expression de classe a un nom, il est visible à l'intérieur de la classe uniquement :
 
 ```js run
 // "Expression de Classe nommée"
 // (Terme non existant dans la spécification, mais elle est similaire a une Expression de Fonction nommée)
 let User = class *!*MyClass*/!* {
   sayHi() {
-    alert(MyClass); // le nom MyClass  est seulement visible dans la classe
+    alert(MyClass); // le nom MyClass est seulement visible dans la classe
   }
 };
 
-new User().sayHi(); // ça fonctionne, montre la définition de MyClass 
+new User().sayHi(); // ça fonctionne, montre la définition de MyClass
 
 alert(MyClass); // erreur, le nom MyClass n'est pas visible en dehors de la classe
 ```
 
-Nous pouvons même créer les classes dynamiquement "a la demande", comme ainsi :
+Nous pouvons même créer les classes dynamiquement "à la demande", comme suit :
 
 ```js run
 function makeClass(phrase) {
-  // déclare une classe et la retourne 
+  // déclare une classe et la retourne
   return class {
     sayHi() {
       alert(phrase);
     }
   };
 }
 
-// Cree une nouvelle classe
+// Crée une nouvelle classe
 let User = makeClass("Hello");
 
 new User().sayHi(); // Hello
 ```
 
-
 ## Accesseurs/Mutateurs
 
 Tout comme les objets littéraux, les classes peuvent inclure des accesseurs/mutateurs, des propriétés évaluées etc.
 
-Voici un exemple pour `user.name` implémente en utilisant les propriétés `get/set`:
+Voici un exemple pour `user.name` implémenté en utilisant les propriétés `get`/`set` :
 
 ```js run
 class User {
@@ -292,7 +292,7 @@ Ces caractéristiques sont faciles à retenir, car elles ressemblent à celles d
 
 ## Champs de classe
 
-```warn header="les anciens navigateurs peuvent avoir besoin de polyfill"
+```warn header="Les anciens navigateurs peuvent avoir besoin de polyfill"
 Les propriétés de classe sont un ajout récent au langage.
 ```
 
@@ -316,9 +316,9 @@ class User {
 new User().sayHi(); // Hello, John!
 ```
 
-So, we just write "<property name> = <value>" in the declaration, and that's it.
+Il suffit donc d'écrire "<property name> = <value>" dans la déclaration, et c'est tout.
 
-The important difference of class fields is that they are set on individual objects, not `User.prototype`:
+La différence importante des champs de classe est qu'ils sont définis sur des objets individuels, et non sur `User.prototype` :
 
 ```js run
 class User {
@@ -345,7 +345,6 @@ let user = new User();
 alert(user.name); // John
 ```
 
-
 ### Création de méthodes liées avec des champs de classe
 
 Comme démontré dans le chapitre <info:bind> les fonctions en JavaScript ont un `this` dynamique. Cela dépend du contexte de l'appel.
@@ -377,7 +376,7 @@ Le problème est appelé "perdre le `this`".
 Il existe deux approches pour le corriger, comme indiqué dans le chapitre <info:bind> :
 
 1. Passer une fonction wrapper, telle que `setTimeout(() => button.click(), 1000)`.
-2. Liez la méthode à un objet, par exemple chez le constructeur :
+2. Lier la méthode à l'objet, par exemple dans le constructeur.
 
 Les champs de classe fournissent une syntaxe plus élégante :
 
@@ -404,17 +403,17 @@ C'est particulièrement utile dans un environnement de navigateur, pour les éco
 
 ## Résumé
 
-La syntaxe de base d'une classe ressemble à ceci:
+La syntaxe de base d'une classe ressemble à ceci :
 
 ```js
 class MyClass {
-  prop = value; // propriete
+  prop = value; // propriété
 
   constructor(...) { // constructeur
     // ...
   }
 
-  method(...) {} // methode
+  method(...) {} // méthode
 
   get something(...) {} //  méthode définie avec un accesseur
   set something(...) {} //  méthode définie avec un mutateur