Improve object conversion algorithme explanation and apply minor fixes

Author: ArmandDelessert

1-js/04-object-basics/09-object-toprimitive/article.md

@@ -1,31 +1,31 @@
 # Conversion d'objet en primitive
 
-Que se passe-t-il lorsque des objets sont ajoutés `obj1 + obj2`, soustraits `obj1 - obj2` ou imprimés à l'aide de `alert (obj)` ?
+Que se passe-t-il lorsque des objets sont ajoutés `obj1 + obj2`, soustraits `obj1 - obj2` ou affichés à l'aide de `alert(obj)` ?
 
 JavaScript ne permet pas de personnaliser le fonctionnement des opérateurs sur les objets. Contrairement à certains autres langages de programmation, tels que Ruby ou C++, nous ne pouvons pas implémenter une méthode objet spéciale pour gérer un ajout (ou d'autres opérateurs).
 
 Dans le cas de telles opérations, les objets sont auto-convertis en primitives, puis l'opération est effectuée sur ces primitives et aboutit à une valeur primitive.
 
 C'est une limitation importante, car le résultat de `obj1 + obj2` (ou toute autre opération mathématique) ne peut pas être un autre objet !
 
-Par exemple. nous ne pouvons pas créer d'objets représentant des vecteurs ou des matrices (ou des réalisations ou autre), les ajouter et s'attendre à un objet "sommé" comme résultat. De telles prouesses architecturales sont automatiquement "hors jeu".
+Par exemple nous ne pouvons pas créer d'objets représentant des vecteurs ou des matrices (ou des réalisations ou autre), les ajouter et s'attendre à un objet "sommé" comme résultat. De telles prouesses architecturales sont automatiquement "hors jeu".
 
-Donc, parce que nous ne pouvons pas faire grand-chose ici, il n'y a pas de maths avec des objets dans de vrais projets. Lorsque cela se produit, c'est généralement à cause d'une erreur de codage.
+Donc, parce que nous ne pouvons pas faire grand-chose ici, il n'y a pas de maths avec des objets dans de vrais projets. Lorsque cela se produit, c'est généralement à cause d'une erreur de programmation.
 
-Dans ce chapitre, nous verrons comment un objet se convertit en primitif et comment le personnaliser.
+Dans ce chapitre, nous verrons comment un objet se convertit en primitive et comment le personnaliser.
 
 Nous avons deux objectifs :
 
-1. Cela nous permettra de comprendre ce qui se passe en cas d'erreur de codage, lorsqu'une telle opération s'est produite accidentellement.
-2. Il existe des exceptions, où de telles opérations sont possibles et semblent bonnes. Par exemple. soustraire ou comparer des dates (objets `Date`). Nous les verrons plus tard.
+1. Cela nous permettra de comprendre ce qui se passe en cas d'erreur de programmation, lorsqu'une telle opération s'est produite accidentellement.
+2. Il existe des exceptions, où de telles opérations sont possibles et semblent bonnes. Par exemple, soustraire ou comparer des dates (objets `Date`). Nous les verrons plus tard.
 
 ## Règles de conversion
 
-Dans le chapitre <info:type-conversions> nous avons vu les règles pour les conversions numériques, chaînes et booléennes de primitives. Mais nous avions mis de côté les objets. Maintenant que nous connaissons les méthodes et les symboles, il devient possible de l'aborder.
+Dans le chapitre <info:type-conversions> nous avons vu les règles de conversion des types primitifs numériques, chaînes de caractères et booléens. Mais nous avions mis de côté les objets. Maintenant que nous connaissons les méthodes et les symboles, il devient possible de l'aborder.
 
 1. Il n'y a pas de conversion en booléen. Tous les objets sont "true" dans un contexte booléen, aussi simple que cela. Il n'existe que des conversions numériques et de chaînes de caractères.
 2. La conversion numérique se produit lorsque nous soustrayons des objets ou appliquons des fonctions mathématiques. Par exemple, les objets `Date` (à traiter dans le chapitre <info:date>) peut être soustrait et le résultat de `date1 - date2` est la différence de temps entre deux dates.
-3. En ce qui concerne la conversion de chaîne de caractères - cela se produit généralement lorsque nous affichons un objet tel que `alert (obj)` et dans des contextes similaires.
+3. En ce qui concerne la conversion de chaîne de caractères, cela se produit généralement lorsque nous affichons un objet tel que `alert(obj)` et dans des contextes similaires.
 
 Nous pouvons implémenter nous-mêmes la conversion de chaînes de caractères et de chiffres, en utilisant des méthodes d'objet spéciales.
 
@@ -35,7 +35,7 @@ Passons maintenant aux détails techniques, car c'est le seul moyen d'aborder le
 
 Comment JavaScript décide-t-il quelle conversion appliquer ?
 
-Il existe trois variantes de conversion de type, qui se produisent dans diverses situations. Ils sont appelés "hints", comme décrit dans la [spécification](https://tc39.github.io/ecma262/#sec-toprimitive) :
+Il existe trois variantes de conversion de type, qui se produisent dans diverses situations. Ils sont appelés "hints" (indices), comme décrit dans la [spécification](https://tc39.github.io/ecma262/#sec-toprimitive) :
 
 Il existe trois variantes de conversion de type, appelées "hints", décrites dans la [specification](https://tc39.github.io/ecma262/#sec-toprimitive) :
 
@@ -67,24 +67,25 @@ let delta = date1 - date2;
 let greater = user1 > user2;
 ```
 
-    Most built-in mathematical functions also include such conversion.
+La plupart des fonctions mathématiques intégrées comprennent également ce type de conversion.
 
-`"default"`
-: Se produit dans de rares cas où l'opérateur n'est "pas sûr" du type auquel il doit s'attendre.
+**`"default"`**
 
-    Par exemple, le binaire plus `+` peut fonctionner à la fois avec des chaînes de caractères (les concaténer) et des nombres (les ajouter). Donc, si le plus binaire obtient un objet sous forme d'argument, il utilise le hint `"default"` pour le convertir.
+Se produit dans de rares cas où l'opérateur n'est "pas sûr" du type auquel il doit s'attendre.
 
-    En outre, si un objet est comparé à l'aide de `==` avec une chaîne de caractères, un nombre ou un symbole, il est également difficile de savoir quelle conversion doit être effectuée, par conséquent l'indicateur `"default"` est utilisé.
+Par exemple, le plus binaire `+` peut fonctionner à la fois avec des chaînes de caractères (les concaténer) et des nombres (les ajouter). Donc, si le plus binaire obtient un objet sous forme d'argument, il utilise le hint `"default"` pour le convertir.
 
-    ```js
-    // binary plus uses the "default" hint
-    let total = obj1 + obj2;
+En outre, si un objet est comparé à l'aide de `==` avec une chaîne de caractères, un nombre ou un symbole, il est également difficile de savoir quelle conversion doit être effectuée, par conséquent l'indicateur `"default"` est utilisé.
 
-    // obj == number uses the "default" hint
-    if (user == 1) { ... };
-    ```
+```js
+// binary plus uses the "default" hint
+let total = obj1 + obj2;
+
+// obj == number uses the "default" hint
+if (user == 1) { ... };
+```
 
-    Les opérateurs de comparaison supérieurs et inférieurs, tels que `<` `>`, peuvent également fonctionner avec des chaînes de caractères et des nombres. Néanmoins, ils utilisent l'indicateur `"number"`, pas `default`. C'est pour des raisons historiques,
+Les opérateurs de comparaison supérieurs et inférieurs, tels que `<` et `>`, peuvent également fonctionner avec des chaînes de caractères et des nombres. Néanmoins, ils utilisent l'indicateur `"number"`, pas `default`. C'est pour des raisons historiques.
 
 En pratique cependant, les choses sont un peu plus simples.
 
@@ -94,11 +95,9 @@ Pourtant, il est important de connaître les 3 hints, nous verrons bientôt pour
 
 **Pour effectuer la conversion, JavaScript essaie de trouver et d'appeler trois méthodes d'objet :**
 
-1. Appeler `obj[Symbol.toPrimitive](hint)` - la méthode avec la clé symbolique `Symbol.toPrimitive` (symbole système), si une telle méthode existe,
-2. Sinon, si l'indice est `"string"`
-    - essaie d'appeler `obj.toString()` et `obj.valueOf()`, tout ce qui existe.
-3. Sinon, si l'indice est `"number"` ou `"default"`
-    - essaie d'appeler `obj.valueOf()` et `obj.toString()`, tout ce qui existe.
+1. Appeler la méthode `obj[Symbol.toPrimitive](hint)` avec la clé symbolique `Symbol.toPrimitive` (symbole système), si une telle méthode existe.
+2. Sinon, si l'indice est `"string"`, essaie d'appeler `obj.toString()` puis `obj.valueOf()`, selon ce qui existe.
+3. Sinon, si l'indice est `"number"` ou `"default"`, essaie d'appeler `obj.valueOf()` puis `obj.toString()`, selon ce qui existe.
 
 ## Symbol.toPrimitive
 
@@ -108,7 +107,7 @@ Commençons par la première méthode. Il existe un symbole intégré appelé `S
 obj[Symbol.toPrimitive] = function(hint) {
   // voici le code pour convertir cet objet en une primitive
   // il doit retourner une valeur primitive
-  // hint = un de "string", "number", "default"
+  // hint = "string" ou "number" ou "default"
 };
 ```
 
@@ -213,7 +212,7 @@ En l'absence de `Symbol.toPrimitive` et de `valueOf`, `toString` gérera toutes
 
 La chose importante à savoir sur toutes les méthodes de conversion de primitives est qu'elles ne renvoient pas nécessairement la primitive "hinted".
 
-Il n'y a pas de control pour vérifier si `ToString()` renvoie exactement une chaîne de caractères ou si la méthode `Symbol.toPrimitive` renvoie un nombre pour le hint `"number"`.
+Il n'y a pas de control pour vérifier si `toString` renvoie exactement une chaîne de caractères ou si la méthode `Symbol.toPrimitive` renvoie un nombre pour le hint `"number"`.
 
 **La seule chose obligatoire : ces méthodes doivent renvoyer une primitive, pas un objet.**
 
@@ -248,7 +247,7 @@ alert(obj * 2); // 4, objet converti en primitive "2", puis la multiplication le
 1. La multiplication `obj * 2` convertit d'abord l'objet en primitive (cela devient une chaîne de caractère `"2"`).
 2. Ensuite `"2" * 2` devient `2 * 2` (la chaîne de caractères est convertie en nombre).
 
-Le binaire plus va concaténer des chaînes de caractères dans la même situation, car il accepte volontiers une chaîne de caractères :
+Le plus binaire `+` va concaténer des chaînes de caractères dans la même situation, car il accepte volontiers une chaîne de caractères :
 
 ```js run
 let obj = {
@@ -268,17 +267,15 @@ Il en existe 3 types (hints) :
 
 - `"string"` (pour `alert` et d'autres opérations qui nécessitent une chaîne de caractères)
 - `"number"` (pour des maths)
-- `"default"` (peu d'opérateurs, généralement des objets l'implémentent de la même manière que `"number"`)
+- `"default"` (peu d'opérateurs, généralement les objets l'implémentent de la même manière que `"number"`)
 
-La spécification décrit explicitement quel opérateur utilise quel conseil.
+La spécification décrit explicitement quel opérateur utilise quel hint.
 
 L'algorithme de conversion est :
 
 1. Appeler `obj[Symbol.toPrimitive](hint)` si la méthode existe,
-2. Sinon, si l'indice est `"string"`
-    - essaie `obj.toString()` et `obj.valueOf()`, tout ce qui existe.
-3. Sinon, si l'indice est `"number"` ou `"default"`
-    - essaie `obj.valueOf()` et `obj.toString()`, tout ce qui existe.
+2. Sinon, si l'indice est `"string"`, essaie `obj.toString()` puis `obj.valueOf()`, selon ce qui existe.
+3. Sinon, si l'indice est `"number"` ou `"default"`, essaie `obj.valueOf()` puis `obj.toString()`, selon ce qui existe.
 
 Toutes ces méthodes doivent renvoyer une primitive pour fonctionner (si elle est définie).