Merge pull request #300 from HachemiH/master

Conflicts fixed after sync with upstream @ 7b76185

Author: HachemiH

1-js/02-first-steps/08-operators/article.md

@@ -56,34 +56,20 @@ alert( 8 % 3 ); // 2, le reste de 8 divisé par 3
 
 ### Exponentiation **
 
-<<<<<<< HEAD
 L'opérateur d'exponentiation `a ** b` multiplie `a` par lui-même `b` fois.
-=======
-The exponentiation operator `a ** b` raises `a` to the power of `b`.
-
-In school maths, we write that as a<sup>b</sup>.
->>>>>>> 7b76185892aa9798c3f058256aed44a9fb413cc3
+En mathématiques à l'école, nous écrivons cela a<sup>b</sup>.
 
 Par exemple:
 
 ```js run
-<<<<<<< HEAD
-alert( 2 ** 2 ); // 4  (2 multiplié par lui-même 2 fois)
-alert( 2 ** 3 ); // 8  (2 * 2 * 2, 3 fois)
-alert( 2 ** 4 ); // 16 (2 * 2 * 2 * 2, 4 fois)
-```
-
-Mathématiquement, l'exponentiation est également définie pour les nombres non entiers. Par exemple, une racine carrée est une exponentiation de `1/2`:
-=======
 alert( 2 ** 2 ); // 2² = 4  
 alert( 2 ** 3 ); // 2³ = 8 
 alert( 2 ** 4 ); // 2⁴ = 16
 ```
 
-Just like in maths, the exponentiation operator is defined for non-integer numbers as well. 
+Mathématiquement, l'exponentiation est également définie pour les nombres non entiers. 
 
-For example, a square root is an exponentiation by ½:
->>>>>>> 7b76185892aa9798c3f058256aed44a9fb413cc3
+Par exemple, une racine carrée est une exponentiation de `½` :
 
 ```js run
 alert( 4 ** (1/2) ); // 2 (la puissance de 1/2 équivaut à une racine carrée)

1-js/02-first-steps/13-while-for/article.md

@@ -371,12 +371,8 @@ break label;  // saute au label ci-dessous (ne fonctionne pas)
 label: for (...)
 ```
 
-<<<<<<< HEAD
-L'appel d'un `continue` n'est possible qu'à partir de l'intérieur de la boucle 
+Une directive `break` doit être à l'intérieur d'un bloc de code. Techniquement, tout bloc de code étiqueté fera l'affaire, par exemple :
 
-La directive `break` peut aussi être placée avant les blocs de code, comme` label: {...} `, mais elle n'est presque jamais utilisée comme ça. Et cela ne fonctionne qu’à l'envers.
-=======
-A `break` directive must be inside a code block. Technically, any labelled code block will do, e.g.:
 ```js
 label: {
   // ...
@@ -385,10 +381,9 @@ label: {
 }
 ```
 
-...Although, 99.9% of the time `break` used is inside loops, as we've seen in the examples above.
+... Bien que 99,9% du temps les `break` utilisés sont à l'intérieur de boucles, comme nous l'avons vu dans les exemples ci-dessus.
 
-A `continue` is only possible from inside a loop.
->>>>>>> 7b76185892aa9798c3f058256aed44a9fb413cc3
+Un `continue` n'est possible que depuis l'intérieur d'une boucle.
 ````
 
 ## Résumé

1-js/02-first-steps/15-function-basics/2-rewrite-function-question-or/solution.md

@@ -14,8 +14,4 @@ function checkAge(age) {
 }
 ```
 
-<<<<<<< HEAD
-Notez que les parenthèses autour de `age > 18` ans ne sont pas obligatoires ici. Ils existent pour une meilleure lisibilité. 
-=======
-Note that the parentheses around `age > 18` are not required here. They exist for better readability.
->>>>>>> 7b76185892aa9798c3f058256aed44a9fb413cc3
+Notez que les parenthèses autour de `age > 18` ne sont pas obligatoires ici. Elles existent pour une meilleure lisibilité. 

1-js/05-data-types/08-weakmap-weakset/01-recipients-read/solution.md

@@ -25,11 +25,7 @@ messages.shift();
 // maintenant readMessages a 1 élément (techniquement, la mémoire peut être nettoyée plus tard)
 ```
 
-<<<<<<< HEAD
-Le `WeakSet` permet de stocker un ensemble de messages et de vérifier facilement l’existence d’un message.
-=======
-The `WeakSet` allows to store a set of messages and easily check for the existence of a message in it.
->>>>>>> 7b76185892aa9798c3f058256aed44a9fb413cc3
+Le `WeakSet` permet de stocker un ensemble de messages et de vérifier facilement l’existence d’un message dedans.
 
 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.
 

1-js/05-data-types/11-date/article.md

@@ -353,11 +353,7 @@ let time1 = 0;
 let time2 = 0;
 
 *!*
-<<<<<<< HEAD
-// lance le test(upperSlice) et le test(upperLoop) toutes les 10 fois en alternance
-=======
-// run bench(diffSubtract) and bench(diffGetTime) each 10 times alternating
->>>>>>> 7b76185892aa9798c3f058256aed44a9fb413cc3
+// exécute bench(diffSubtract) et bench(diffGetTime) chaque 10 fois en alternance
 for (let i = 0; i < 10; i++) {
   time1 += bench(diffSubtract);
   time2 += bench(diffGetTime);

1-js/06-advanced-functions/03-closure/10-make-army/solution.md

@@ -88,19 +88,11 @@ Examinons exactement ce qui se fait à l'intérieur de `makeArmy`, et la solutio
     
     Ici, `let j = i` déclare une variable "itération-locale" `j` et y copie `i`. Les primitives sont copiées "par valeur", donc nous obtenons en fait une copie indépendante de `i`, appartenant à l'itération de boucle courante.
 
-<<<<<<< HEAD
     Les shooters fonctionnent correctement, car la valeur de `i` vit maintenant un peu plus près. Pas dans l'environnement lexical `makeArmy()`, mais dans l'environnement lexical qui correspond à l'itération de la boucle actuelle :
     
     ![](lexenv-makearmy-while-fixed.svg)
     
-    Un tel problème pourrait également être évité si nous utilisions `for` au début, comme ceci :
-=======
-    The shooters work correctly, because the value of `i` now lives a little bit closer. Not in `makeArmy()` Lexical Environment, but in the Lexical Environment that corresponds to the current loop iteration:
-    
-    ![](lexenv-makearmy-while-fixed.svg)
-    
-    Such a problem could also be avoided if we used `for` in the beginning, like this:
->>>>>>> 7b76185892aa9798c3f058256aed44a9fb413cc3
+    Ce genre de problème pourrait également être évité si nous utilisions `for` au début, comme ceci :
     
     ```js run demo
     function makeArmy() {

1-js/06-advanced-functions/03-closure/7-let-scope/solution.md

@@ -26,15 +26,9 @@ Le code ci-dessus le démontre.
 ```js
 function func() {
 *!*
-<<<<<<< HEAD
   // la variable locale x est connue du moteur depuis le début de la fonction,
   // mais "non initialisée" (inutilisable) jusqu'à let ("zone morte")
   // d'où l'erreur
-=======
-  // the local variable x is known to the engine from the beginning of the function,
-  // but "uninitialized" (unusable) until let ("dead zone")
-  // hence the error
->>>>>>> 7b76185892aa9798c3f058256aed44a9fb413cc3
 */!*
 
   console.log(x); // ReferenceError: Cannot access 'x' before initialization

1-js/06-advanced-functions/03-closure/article.md

@@ -146,11 +146,7 @@ Bien que simples, des variantes légèrement modifiées de ce code ont des utili
 
 Comment cela marche-t-il ? Si nous créons plusieurs compteurs, seront-ils indépendants ? Que se passe-t-il avec les variables ici ?
 
-<<<<<<< HEAD
 La compréhension de ce genre de choses est excellente pour la connaissance globale de JavaScript et bénéfique pour les scénarios plus complexes. Allons donc un peu en profondeur.
-=======
-Understanding such things is great for the overall knowledge of JavaScript and beneficial for more complex scenarios. So let's go a bit in-depth.
->>>>>>> 7b76185892aa9798c3f058256aed44a9fb413cc3
 
 ## Lexical Environment
 

1-js/06-advanced-functions/06-function-object/5-sum-many-brackets/solution.md

@@ -52,8 +52,4 @@ function f(b) {
 }
 ```
 
-<<<<<<< HEAD
-Ce `f` sera utilisé lors du prochain appel et se renvera lui-même autant de fois que nécessaire. Ensuite, lorsqu'il est utilisé sous forme de nombre ou de chaîne, le `toString` renvoie le `currentSum`. Nous pourrions aussi utiliser `Symbol.toPrimitive` ou` valueOf` ici pour la conversion.
-=======
-This `f` will be used in the next call, again return itself, as many times as needed. Then, when used as a number or a string -- the `toString` returns the `currentSum`. We could also use `Symbol.toPrimitive` or `valueOf` here for the conversion.
->>>>>>> 7b76185892aa9798c3f058256aed44a9fb413cc3
+Ce `f` sera utilisé lors du prochain appel et se renvera lui-même autant de fois que nécessaire. Ensuite, lorsqu'il est utilisé sous forme de nombre ou de chaîne de caractères, le `toString` renvoie le `currentSum`. Nous pourrions aussi utiliser `Symbol.toPrimitive` ou` valueOf` ici pour la conversion.

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

@@ -110,13 +110,8 @@ alert(typeof User); // function
 // ...ou, plus précisément, le constructeur de la méthode
 alert(User === User.prototype.constructor); // true
 
-<<<<<<< HEAD
-// Les méthodes sont dans  User.prototype, e.g:
-alert(User.prototype.sayHi); // alert(this.name);
-=======
-// The methods are in User.prototype, e.g:
-alert(User.prototype.sayHi); // the code of the sayHi method
->>>>>>> 7b76185892aa9798c3f058256aed44a9fb413cc3
+// 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