Merge pull request #16 from HachemiH/master

Translate Map, Set, WeakMap and WeakSet in french language

Author: HachemiH

1-js/05-data-types/07-map-set-weakmap-weakset/01-array-unique-map/task.md

@@ -2,13 +2,13 @@ importance: 5
 
 ---
 
-# Filter unique array members
+# Filtrer les membres uniques du tableau
 
-Let `arr` be an array.
+Disons que `arr` est un tableau.
 
-Create a function `unique(arr)` that should return an array with unique items of `arr`.
+Créez une fonction `unique(arr)` qui devrait renvoyer un tableau avec les éléments uniques d'arr.
 
-For instance:
+Par exemple :
 
 ```js
 function unique(arr) {
@@ -22,6 +22,6 @@ let values = ["Hare", "Krishna", "Hare", "Krishna",
 alert( unique(values) ); // Hare, Krishna, :-O
 ```
 
-P.S. Here strings are used, but can be values of any type.
+P.S. Ici, les chaînes de caractères sont utilisées, mais elles peuvent être des valeurs de n'importe quel type.
 
-P.P.S. Use `Set` to store unique values.
+P.P.S. Utilisez `Set` pour stocker des valeurs uniques.

1-js/05-data-types/07-map-set-weakmap-weakset/02-filter-anagrams/solution.md

@@ -1,6 +1,6 @@
-To find all anagrams, let's split every word to letters and sort them. When letter-sorted, all anagrams are same.
+Pour trouver tous les anagrammes, divisons chaque mot en lettres et trions-les. Lorsque ils sont triés par lettres, tous les anagrammes sont identiques.
 
-For instance:
+Par exemple :
 
 ```
 nap, pan -> anp
@@ -9,14 +9,14 @@ cheaters, hectares, teachers -> aceehrst
 ...
 ```
 
-We'll use the letter-sorted variants as map keys to store only one value per each key:
+Nous allons utiliser les variantes triées par lettre comme clés de map pour stocker une seule valeur pour chaque clé :
 
 ```js run
 function aclean(arr) {
   let map = new Map();
 
   for (let word of arr) {
-    // split the word by letters, sort them and join back
+    // diviser le mot en lettres, les trier et les rejoindre
 *!*
     let sorted = word.toLowerCase().split('').sort().join(''); // (*)
 */!*
@@ -31,9 +31,9 @@ let arr = ["nap", "teachers", "cheaters", "PAN", "ear", "era", "hectares"];
 alert( aclean(arr) );
 ```
 
-Letter-sorting is done by the chain of calls in the line `(*)`.
+Le tri des lettres se fait par la chaîne d'appels en ligne `(*)`.
 
-For convenience let's split it into multiple lines:
+Pour plus de commodité, divisons-le en plusieurs lignes :
 
 ```js
 let sorted = arr[i] // PAN
@@ -43,21 +43,21 @@ let sorted = arr[i] // PAN
   .join(''); // anp
 ```
 
-Two different words `'PAN'` and `'nap'` receive the same letter-sorted form `'anp'`.
+Deux mots différents, `'PAN'` et `'nap'`, reçoivent la même forme de lettre triée `'anp'`.
 
-The next line put the word into the map:
+La ligne suivante place le mot dans le map :
 
 ```js
 map.set(sorted, word);
 ```
 
-If we ever meet a word the same letter-sorted form again, then it would overwrite the previous value with the same key in the map. So we'll always have at maximum one word per letter-form.
+Si nous rencontrons à nouveau un mot trié de la même manière, il écrasera la valeur précédente avec la même clé dans le map. Nous aurons donc toujours au maximum un mot par lettre.
 
-At the end `Array.from(map.values())` takes an iterable over map values (we don't need keys in the result) and returns an array of them.
+À la fin `Array.from(map.values())` prends un itérable sur les valeurs du `Map` (nous n'avons pas besoin des clés dans le résultat) et renvoi un tableau avec celles-ci.
 
-Here we could also use a plain object instead of the `Map`, because keys are strings.
+Ici, nous pourrions également utiliser un objet simple au lieu du `Map`, car les clés sont des chaînes de caractères.
 
-That's how the solution can look:
+Voilà à quoi la solution peut ressembler :
 
 ```js run demo
 function aclean(arr) {

1-js/05-data-types/07-map-set-weakmap-weakset/02-filter-anagrams/task.md

@@ -1,28 +1,28 @@
-importance: 4
+importance: 4 
 
 ---
 
-# Filter anagrams
+# Filter les anagrams
 
-[Anagrams](https://en.wikipedia.org/wiki/Anagram) are words that have the same number of same letters, but in different order.
+[Anagrams](https://fr.wikipedia.org/wiki/Anagramme) sont des mots qui ont le même nombre de mêmes lettres, mais dans un ordre différent.
 
-For instance:
+Par exemple :
 
 ```
 nap - pan
 ear - are - era
 cheaters - hectares - teachers
 ```
 
-Write a function `aclean(arr)` that returns an array cleaned from anagrams.
+Ecrivez une fonction `aclean(arr)` qui retourne un tableau nettoyé des anagrammes.
 
-For instance:
+Par exemple :
 
 ```js
 let arr = ["nap", "teachers", "cheaters", "PAN", "ear", "era", "hectares"];
 
-alert( aclean(arr) ); // "nap,teachers,ear" or "PAN,cheaters,era"
+alert( aclean(arr) ); // "nap,teachers,ear" ou "PAN,cheaters,era"
 ```
 
-From every anagram group should remain only one word, no matter which one.
+De chaque groupe d’anagrammes ne devrait rester qu’un mot, peu importe lequel.
 

1-js/05-data-types/07-map-set-weakmap-weakset/03-iterable-keys/solution.md

@@ -1,7 +1,7 @@
 
-That's because `map.keys()` returns an iterable, but not an array.
+C’est parce que `map.keys()` retourne un itérable, mais pas un tableau.
 
-We can convert it into an array using `Array.from`:
+Nous pouvons le convertir en tableau en utilisant `Array.from` :
 
 
 ```js run

1-js/05-data-types/07-map-set-weakmap-weakset/03-iterable-keys/task.md

@@ -2,11 +2,11 @@ importance: 5
 
 ---
 
-# Iterable keys
+# Clés Iterables
 
-We want to get an array of `map.keys()` and go on working with it (apart from the map itself).
+Nous voulons obtenir un tableau de `map.keys()` et continuer à l'utiliser (en dehors du map lui même).
 
-But there's a problem:
+Mais il y a un problème :
 
 ```js run
 let map = new Map();
@@ -21,4 +21,4 @@ keys.push("more");
 */!*
 ```
 
-Why? How can we fix the code to make `keys.push` work?
+Pourquoi ? Comment pouvons-nous corriger le code pour que `keys.push` fonctionne ?

1-js/05-data-types/07-map-set-weakmap-weakset/04-recipients-read/solution.md

@@ -1,4 +1,4 @@
-The sane choice here is a `WeakSet`:
+Le bon choix ici est un `WeakSet`:
 
 ```js
 let messages = [
@@ -9,33 +9,33 @@ let messages = [
 
 let readMessages = new WeakSet();
 
-// two messages have been read
+// deux messages ont été lus
 readMessages.add(messages[0]);
 readMessages.add(messages[1]);
-// readMessages has 2 elements
+// readMessages a 2 éléments
 
-// ...let's read the first message again!
+// ...Relisons le premier message !
 readMessages.add(messages[0]);
-// readMessages still has 2 unique elements
+// readMessages a encore 2 éléments uniques
 
-// answer: was the message[0] read?
+// réponse : le message[0] a-t-il été lu ?
 alert("Read message 0: " + readMessages.has(messages[0])); // true
 
 messages.shift();
-// now readMessages has 1 element (technically memory may be cleaned later)
+// maintenant readMessages a 1 élément (techniquement, la mémoire peut être nettoyée plus tard)
 ```
 
-The `WeakSet` allows to store a set of messages and easily check for the existance of a message in it.
+Le `WeakSet` permet de stocker un ensemble de messages et de vérifier facilement l’existence d’un message.
 
-It cleans up itself automatically. The tradeoff is that we can't iterate over it. We can't get "all read messages" directly. But we can do it by iterating over all messages and filtering those that are in the set.
+Il se nettoie automatiquement. Le compromis est que nous ne pouvons pas le parcourir. Nous ne pouvons pas obtenir "tous les messages lus" directement. Mais nous pouvons le faire en parcourant tous les messages et en filtrant ceux qui sont dans le set.
 
-P.S. Adding a property of our own to each message may be dangerous if messages are managed by someone else's code, but we can make it a symbol to evade conflicts.
+P.S. Ajouter une propriété propre à chaque message peut être dangereux si les messages sont gérés par le code d’une autre personne, mais nous pouvons en faire un symbole pour éviter les conflits.
 
-Like this:
+Comme ceci :
 ```js
-// the symbolic property is only known to our code
+// la propriété symbolique n'est connue que de notre code
 let isRead = Symbol("isRead");
 messages[0][isRead] = true;
 ```
 
-Now even if someone else's code uses `for..in` loop for message properties, our secret flag won't appear.
+Maintenant, même si le code de quelqu'un d'autre utilise `for..in` pour les propriétés du message, notre indicateur secret n'apparaîtra pas.

1-js/05-data-types/07-map-set-weakmap-weakset/04-recipients-read/task.md

@@ -2,9 +2,9 @@ importance: 5
 
 ---
 
-# Store "unread" flags
+# Stocker les messages non-lus
 
-There's an array of messages:
+Il y a un tableau de messages :
 
 ```js
 let messages = [
@@ -14,10 +14,10 @@ let messages = [
 ];
 ```
 
-Your code can access it, but the messages are managed by someone else's code. New messages are added, old ones are removed regularly by that code, and you don't know the exact moments when it happens.
+Votre code peut y accéder, mais les messages sont gérés par le code d’une autre personne. De nouveaux messages sont ajoutés, les anciens sont régulièrement supprimés par ce code et vous ne connaissez pas le moment exact où cela se produit.
 
-Now, which data structure you could use to store information whether the message "have been read"? The structure must be well-suited to give the answer "was it read?" for the given message object.
+Maintenant, quelle structure de données pouvez-vous utiliser pour stocker des informations si le message "a été lu"? La structure doit être bien adaptée pour donner la réponse "a-t-il été lu ?" Pour l'objet de message donné.
 
-P.S. When a message is removed from `messages`, it should disappear from your structure as well.
+P.S. Lorsqu'un message est supprimé des `messages`, il doit également disparaître de votre structure.
 
-P.P.S. We shouldn't modify message objects directly. If they are managed by someone else's code, then adding extra properties to them may have bad consequences.
+P.P.S. Nous ne devrions pas modifier les objets de message directement. Si elles sont gérées par le code d’une autre personne, l’ajout de propriétés supplémentaires peut avoir de graves conséquences.

1-js/05-data-types/07-map-set-weakmap-weakset/05-recipients-when-read/solution.md

@@ -1,5 +1,5 @@
 
-To store a date, we can use `WeakMap`:
+Pour stocker une date, nous pouvons utiliser `WeakMap`:
 
 ```js
 let messages = [
@@ -11,5 +11,5 @@ let messages = [
 let readMap = new WeakMap();
 
 readMap.set(messages[0], new Date(2017, 1, 1));
-// Date object we'll study later
+// objet Date que nous étudierons plus tard
 ```

1-js/05-data-types/07-map-set-weakmap-weakset/05-recipients-when-read/task.md

@@ -2,9 +2,9 @@ importance: 5
 
 ---
 
-# Store read dates
+# Stocker les dates de lectures
 
-There's an array of messages as in the [previous task](info:task/recipients-read). The situation is similar.
+Il existe un tableau de messages comme dans la [previous task](info:task/recipients-read). La situation est similaire.
 
 ```js
 let messages = [
@@ -14,6 +14,6 @@ let messages = [
 ];
 ```
 
-The question now is: which data structure you'd suggest to store the information: "when the message was read?".
+La question qui se pose maintenant est la suivante : quelle structure de données suggérez-vous pour stocker les informations : "quand le message a-t-il été lu ?".
 
-In the previous task we only needed to store the "yes/no" fact. Now we need to store the date and it, once again, should disappear if the message is gone.
+Dans la tâche précédente, nous n'avions besoin que de stocker le fait "oui/non". Nous devons maintenant stocker la date et cette fois encore, elle devrait disparaître si le message a disparu.