Merge pull request #299 from javascript-tutorial/sync-7b761858

Sync with upstream @ 7b76185

Author: HachemiH

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

@@ -56,17 +56,34 @@ 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
 
 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. 
+
+For example, a square root is an exponentiation by ½:
+>>>>>>> 7b76185892aa9798c3f058256aed44a9fb413cc3
 
 ```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,9 +371,24 @@ 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 
 
 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: {
+  // ...
+  break label; // works
+  // ...
+}
+```
+
+...Although, 99.9% of the time `break` used is inside loops, as we've seen in the examples above.
+
+A `continue` is only possible from inside a loop.
+>>>>>>> 7b76185892aa9798c3f058256aed44a9fb413cc3
 ````
 
 ## Résumé

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

@@ -14,4 +14,8 @@ 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

1-js/02-first-steps/17-arrow-functions-basics/1-rewrite-arrow/solution.md

@@ -1,7 +1,7 @@
 
 ```js run
 function ask(question, yes, no) {
-  if (confirm(question)) yes()
+  if (confirm(question)) yes();
   else no();
 }
 

1-js/02-first-steps/17-arrow-functions-basics/1-rewrite-arrow/task.md

@@ -5,7 +5,7 @@ Remplacez les expressions de fonction par des fonctions fléchées dans le code
 
 ```js run
 function ask(question, yes, no) {
-  if (confirm(question)) yes()
+  if (confirm(question)) yes();
   else no();
 }
 

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

@@ -25,7 +25,11 @@ 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
 
 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,7 +353,11 @@ 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
 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,11 +88,19 @@ 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
     
     ```js run demo
     function makeArmy() {

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

@@ -26,9 +26,15 @@ 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,7 +146,11 @@ 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