Merge pull request #452 from ArmandDelessert/translate-2023-05-19

Translation of some untranslated sections

Author: HachemiH

1-js/05-data-types/02-number/article.md

@@ -335,33 +335,33 @@ alert( isFinite(num) );
 
 Veuillez noter qu'une chaîne de caractères vide ou une chaîne de caractères contenant seulement un espace est traitée comme `0` dans toutes les fonctions numérique, y compris `isFinite`.
 
-````smart header="`Number.isNaN` and `Number.isFinite`"
-[Number.isNaN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isNaN) and [Number.isFinite](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isFinite) methods are the more "strict" versions of `isNaN` and `isFinite` functions. They do not autoconvert their argument into a number, but check if it belongs to the `number` type instead.
+````smart header="`Number.isNaN` et `Number.isFinite`"
+Les méthodes [Number.isNaN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isNaN) et [Number.isFinite](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isFinite) sont des versions plus "strictes" des fonctions `isNaN` et `isFinite`. Elles ne convertissent pas automatiquement leur argument en nombre, mais vérifient s'il appartient au type `number`.
 
-- `Number.isNaN(value)` returns `true` if the argument belongs to the `number` type and it is `NaN`. In any other case it returns `false`.
+- `Number.isNaN(value)` retourne `true` si l'argument appartient au type `number` et s'il vaut `NaN`. Dans tous les autres cas, elle retourne `false`.
 
     ```js run
     alert( Number.isNaN(NaN) ); // true
     alert( Number.isNaN("str" / 2) ); // true
 
-    // Note the difference:
-    alert( Number.isNaN("str") ); // false, because "str" belongs to the string type, not the number type
-    alert( isNaN("str") ); // true, because isNaN converts string "str" into a number and gets NaN as a result of this conversion
+    // Notez la différence :
+    alert( Number.isNaN("str") ); // false, car "str" est de type "string"
+    alert( isNaN("str") ); // true, car isNaN convertit la string "str" en un nombre et obtient NaN comme résultatde la conversion
     ```
 
-- `Number.isFinite(value)` returns `true` if the argument belongs to the `number` type and it is not `NaN/Infinity/-Infinity`. In any other case it returns `false`.
+- `Number.isFinite(value)` retourne `true` si l'argument appartient au type `number` et s'il vaut ni `NaN`, ni `Infinity`, ni `-Infinity`. Dans tous les autres cas, elle retourne `false`.
 
     ```js run
     alert( Number.isFinite(123) ); // true
     alert( Number.isFinite(Infinity) ); // false
     alert( Number.isFinite(2 / 0) ); // false
 
-    // Note the difference:
-    alert( Number.isFinite("123") ); // false, because "123" belongs to the string type, not the number type
-    alert( isFinite("123") ); // true, because isFinite converts string "123" into a number 123
+    // Notez la différence :
+    alert( Number.isFinite("123") ); // false, car "123" est de type "string"
+    alert( isFinite("123") ); // true, car isFinite convertit la string "123" en un nombre 123
     ```
 
-In a way, `Number.isNaN` and `Number.isFinite` are simpler and more straightforward than `isNaN` and `isFinite` functions. In practice though, `isNaN` and `isFinite` are mostly used, as they're shorter to write.
+En quelque sorte, les fonction `Number.isNaN` et `Number.isFinite` sont plus simples et plus directes que les fonctions `isNaN` et `isFinite`. Cependant, en pratique `isNaN` et `isFinite` sont plus souvent utilisées car elles sont plus courtes à écrire.
 ````
 
 ```smart header="Comparer avec Object.is"

1-js/05-data-types/07-map-set/article.md

@@ -152,12 +152,12 @@ recipeMap.forEach( (value, key, map) => {
 });
 ```
 
-## Object.entries: Map from Object
+## Object.entries: Créer une Map à partir d'un objet
 
-When a `Map` is created, we can pass an array (or another iterable) with key/value pairs for initialization, like this:
+Lorsqu'une `Map` est créée, nous pouvons passer un tableau (ou un autre itérable) contenant des paires clé/valeur pour l'initialisation, comme ceci :
 
 ```js run
-// array of [key, value] pairs
+// tableau de paires [clé, valeur]
 let map = new Map([
   ['1',  'str1'],
   [1,    'num1'],
@@ -167,9 +167,9 @@ let map = new Map([
 alert( map.get('1') ); // str1
 ```
 
-If we have a plain object, and we'd like to create a `Map` from it, then we can use built-in method [Object.entries(obj)](mdn:js/Object/entries) that returns an array of key/value pairs for an object exactly in that format.
+Si nous avons un objet simple et que nous souhaitons en créer une `Map`, nous pouvons utiliser la méthode intégrée [Object.entries(obj)](mdn:js/Object/entries) qui renvoie un tableau de paires clé/valeur pour un objet exactement dans ce format.
 
-So we can create a map from an object like this:
+Nous pouvons donc créer une `Map` à partir d'un objet de la manière suivante :
 
 ```js run
 let obj = {
@@ -184,14 +184,13 @@ let map = new Map(Object.entries(obj));
 alert( map.get('name') ); // John
 ```
 
-Here, `Object.entries` returns the array of key/value pairs: `[ ["name","John"], ["age", 30] ]`. That's what `Map` needs.
+Ici, `Object.entries` renvoie le tableau de paires clé/valeur : `[ ["name", "John"], ["age", 30] ]`. C'est ce dont a besoin la `Map`.
 
+## Object.fromEntries: Objet à partir d'une Map
 
-## Object.fromEntries: Object from Map
+Nous venons de voir comment créer une `Map` à partir d'un objet simple avec `Object.entries(obj)`.
 
-We've just seen how to create `Map` from a plain object with `Object.entries(obj)`.
-
-There's `Object.fromEntries` method that does the reverse: given an array of `[key, value]` pairs, it creates an object from them:
+Il existe une méthode `Object.fromEntries` qui fait l'inverse : étant donné un tableau de paires `[clé, valeur]`, elle crée un objet à partir de ces paires :
 
 ```js run
 let prices = Object.fromEntries([
@@ -200,16 +199,16 @@ let prices = Object.fromEntries([
   ['meat', 4]
 ]);
 
-// now prices = { banana: 1, orange: 2, meat: 4 }
+// maintenant, prices = { banana: 1, orange: 2, meat: 4 }
 
 alert(prices.orange); // 2
 ```
 
-We can use `Object.fromEntries` to get a plain object from `Map`.
+Nous pouvons utiliser `Object.fromEntries` pour obtenir un objet simple à partir d'une `Map`.
 
-E.g. we store the data in a `Map`, but we need to pass it to a 3rd-party code that expects a plain object.
+Par exemple, nous stockons les données dans une `Map`, mais nous devons les transmettre à un code tiers qui attend un objet simple.
 
-Here we go:
+Voici comment procéder :
 
 ```js run
 let map = new Map();
@@ -218,23 +217,24 @@ map.set('orange', 2);
 map.set('meat', 4);
 
 *!*
-let obj = Object.fromEntries(map.entries()); // make a plain object (*)
+let obj = Object.fromEntries(map.entries()); // créer un objet simple (*)
 */!*
 
-// done!
+// terminé!
 // obj = { banana: 1, orange: 2, meat: 4 }
 
 alert(obj.orange); // 2
 ```
 
-A call to `map.entries()` returns an iterable of key/value pairs, exactly in the right format for `Object.fromEntries`.
+Un appel à `map.entries()` renvoie un itérable de paires clé/valeur, exactement dans le bon format pour `Object.fromEntries`.
+
+Nous pourrions également raccourcir la ligne (*) :
 
-We could also make line `(*)` shorter:
 ```js
-let obj = Object.fromEntries(map); // omit .entries()
+let obj = Object.fromEntries(map); // .entries() omis
 ```
 
-That's the same, because `Object.fromEntries` expects an iterable object as the argument. Not necessarily an array. And the standard iteration for `map` returns same key/value pairs as `map.entries()`. So we get a plain object with same key/values as the `map`.
+C'est la même chose, car `Object.fromEntries` attend un objet itérable en argument. Pas nécessairement un tableau. Et l'itération standard pour une `map` renvoie les mêmes paires clé/valeur que `map.entries()`. Ainsi, nous obtenons un objet simple avec les mêmes clés/valeurs que la `map`.
 
 ## Set