merging all conflicts

Author: iliakan

1-js/02-first-steps/11-logical-operators/article.md

@@ -64,7 +64,11 @@ if (hour < 10 || hour > 18 || isWeekend) {
 }
 ```
 
+<<<<<<< HEAD
 ### OR "||" cherche la première valeur vraie
+=======
+## OR "||" finds the first truthy value [#or-finds-the-first-truthy-value]
+>>>>>>> e01998baf8f85d9d6cef9f1add6c81b901f16d69
 
 La logique décrite ci-dessus est quelque peu classique. Maintenant, apportons les fonctionnalités "supplémentaires" de JavaScript.
 

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

@@ -319,7 +319,11 @@ alert('Done!');
 
 Nous avons besoin d'un moyen d'arrêter le processus si l'utilisateur annule la saisie.
 
+<<<<<<< HEAD
 Le `break` ordinaire après `input` ne ferait que briser la boucle intérieure. Ce n’est pas suffisant. Les *labels* viennent à la rescousse.
+=======
+The ordinary `break` after `input` would only break the inner loop. That's not sufficient -- labels, come to the rescue!
+>>>>>>> e01998baf8f85d9d6cef9f1add6c81b901f16d69
 
 Une *label* est un identifiant avec deux points avant une boucle :
 ```js
@@ -366,12 +370,22 @@ Les labels ne nous permettent pas de sauter dans un endroit arbitraire du code.
 
 Par exemple, il est impossible de faire ceci :
 ```js
+<<<<<<< HEAD
 break label;  // ne saute pas au label ci-dessous
+=======
+break label; // jump to the label below (doesn't work)
+>>>>>>> e01998baf8f85d9d6cef9f1add6c81b901f16d69
 
 label: for (...)
 ```
 
+<<<<<<< HEAD
 L'appel d'un `break/continue` n'est possible qu'à partir de l'intérieur de la boucle et le libellé doit se situer quelque part au dessus de la directive.
+=======
+A call to `continue` is only possible from inside the loop.
+
+The `break` directive may be placed before code blocks too, as `label: { ... }`, but it's almost never used like that. And it also works only inside-out.
+>>>>>>> e01998baf8f85d9d6cef9f1add6c81b901f16d69
 ````
 
 ## Résumé

1-js/04-object-basics/02-object-copy/article.md

@@ -100,7 +100,11 @@ alert( a == b ); // false
 
 Pour des comparaisons comme `obj1 > obj2` ou des comparaisons avec une primitive `obj == 5`, les objets sont convertis en primitive. Nous étudierons comment les conversions d'objets fonctionnent très bientôt, mais pour dire la vérité, de telles comparaisons sont rarement nécessaires, en général elles sont le résultat d'une erreur de programmation.
 
+<<<<<<< HEAD
 ## Clonage et fusionage, Object.assign
+=======
+## Cloning and merging, Object.assign [#cloning-and-merging-object-assign]
+>>>>>>> e01998baf8f85d9d6cef9f1add6c81b901f16d69
 
 Copier une variable object créé une référence en plus vers le même objet.
 
@@ -187,7 +191,11 @@ let clone = Object.assign({}, user);
 
 Cela copie toutes les propriétés de `user` dans l'objet vide et le retourne.
 
+<<<<<<< HEAD
 Il existe également d'autres méthodes de clonage d'un objet, par ex. en utilisant la [syntaxe spread](info:rest-parameters-spread) `clone = {...user}`, abordé plus loin dans le tutoriel.
+=======
+There are also other methods of cloning an object, e.g. using the [spread syntax](info:rest-parameters-spread) `clone = {...user}`, covered later in the tutorial.
+>>>>>>> e01998baf8f85d9d6cef9f1add6c81b901f16d69
 
 ## Clonage imbriqué
 

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

@@ -161,7 +161,7 @@ Il y a deux façons de le faire:
     ```js run
     let num = 1.23456;
 
-    alert( Math.floor(num * 100) / 100 ); // 1.23456 -> 123.456 -> 123 -> 1.23
+    alert( Math.round(num * 100) / 100 ); // 1.23456 -> 123.456 -> 123 -> 1.23
     ```
 
 2. La méthode [toFixed(n)](https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Objets_globaux/Number/toFixed) arrondit le nombre à `n` chiffres après le point et renvoie unechaîne de caractères du résultat.

1-js/05-data-types/03-string/article.md

@@ -535,7 +535,11 @@ Les caractères sont comparés par leur code numérique. Le plus grand code sign
 - Certaines lettres comme `Ö` se distinguent de l'alphabet principal. Ici, le code est supérieur à tout ce qui va de `a` à `z`.
 
 
+<<<<<<< HEAD
 ### Les comparaisons correctes
+=======
+### Correct comparisons [#correct-comparisons]
+>>>>>>> e01998baf8f85d9d6cef9f1add6c81b901f16d69
 
 L'algorithme "approprié" pour effectuer des comparaisons de chaînes est plus complexe qu'il n'y paraît, car les alphabets diffèrent d'une langue à l'autre.
 

1-js/06-advanced-functions/06-function-object/article.md

@@ -326,7 +326,11 @@ welcome(); // Hello, Guest (l'appel imbriqué fonctionne)
 
 Maintenant cela fonctionne, car le nom `'func'` est local à la fonction. Il n'est pas pris de l'extérieur (et non visible là-bas). La spécification garantit qu'elle fera toujours référence à la fonction actuelle.
 
+<<<<<<< HEAD
 Le code externe a toujours sa variable `sayHi` ou `welcome`. Et `func` est un "nom de fonction interne", c'est comment la fonction peut s'appeler en interne.
+=======
+The outer code still has its variable `sayHi` or `welcome`. And `func` is an "internal function name", how the function can call itself internally.
+>>>>>>> e01998baf8f85d9d6cef9f1add6c81b901f16d69
 
 ```smart header="Il n'y a rien de tel pour la déclaration de fonction"
 La fonctionnalité "nom interne" décrite ici n'est disponible que pour les expressions de fonction, pas pour les déclarations de fonction. Pour les déclarations de fonctions, il n’y a aucune possibilité de syntaxe d’ajouter un nom "interne" supplémentaire.

1-js/09-classes/03-static-properties-methods/article.md

@@ -125,7 +125,11 @@ C’est la même chose qu’une assignation directe à `Article`:
 Article.publisher = "Ilya Kantor";
 ```
 
+<<<<<<< HEAD
 ## Héritage de méthodes et de propriétés statiques
+=======
+## Inheritance of static properties and methods [#statics-and-inheritance]
+>>>>>>> e01998baf8f85d9d6cef9f1add6c81b901f16d69
 
 Les propriétés et méthodes statiques sont héritées.
 

1-js/10-error-handling/1-try-catch/1-finally-or-code-after/solution.md

@@ -1,8 +1,14 @@
 La différence devient évidente quand on regarde le code dans une fonction.
 
+<<<<<<< HEAD
 Le comportement est différent s'il y a un "saut" en dehors de `try..catch`.
 
 Par exemple, quand il y a un `return` dans `try..catch`. La clause `finally` fonctionne en cas de *toute* sortie de` try..catch`, même via l'instruction `return`: juste après la fin de `try..catch`, mais avant que le code appelant obtienne le contrôle.
+=======
+The behavior is different if there's a "jump out" of `try...catch`.
+
+For instance, when there's a `return` inside `try...catch`. The `finally` clause works in case of *any* exit from `try...catch`, even via the `return` statement: right after `try...catch` is done, but before the calling code gets the control.
+>>>>>>> e01998baf8f85d9d6cef9f1add6c81b901f16d69
 
 ```js run
 function f() {
@@ -11,7 +17,7 @@ function f() {
 *!*
     return "result";
 */!*
-  } catch (e) {
+  } catch (err) {
     /// ...
   } finally {
     alert('cleanup!');
@@ -28,11 +34,11 @@ function f() {
   try {
     alert('start');
     throw new Error("an error");
-  } catch (e) {
+  } catch (err) {
     // ...
     if("can't handle the error") {
 *!*
-      throw e;
+      throw err;
 */!*
     }
 

1-js/10-error-handling/1-try-catch/1-finally-or-code-after/task.md

@@ -6,25 +6,33 @@ importance: 5
 
 Comparez les deux fragments de code.
 
+<<<<<<< HEAD
 1. Le premier utilise `finally` pour exécuter le code après `try..catch`:
+=======
+1. The first one uses `finally` to execute the code after `try...catch`:
+>>>>>>> e01998baf8f85d9d6cef9f1add6c81b901f16d69
 
     ```js
     try {
       work work
-    } catch (e) {
+    } catch (err) {
       handle errors
     } finally {
     *!*
       cleanup the working space
     */!*
     }
     ```
+<<<<<<< HEAD
 2. Le deuxième fragment met le "cleanup" juste après `try..catch`:
+=======
+2. The second fragment puts the cleaning right after `try...catch`:
+>>>>>>> e01998baf8f85d9d6cef9f1add6c81b901f16d69
 
     ```js
     try {
       work work
-    } catch (e) {
+    } catch (err) {
       handle errors
     }