Merge pull request #290 from HachemiH/master

Conflicts fixed after sync with upstream @ e01998b

Author: HachemiH

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

@@ -64,11 +64,7 @@ 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
+### OR "||" cherche la première valeur vraie[#or-cherche-la-premiere-valeur-vraie]
 
 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,11 +319,7 @@ 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
+Le `break` ordinaire après `input` ne ferait que briser la boucle intérieure. Ce n’est pas suffisant -- les *labels* viennent à la rescousse.
 
 Une *label* est un identifiant avec deux points avant une boucle :
 ```js
@@ -370,22 +366,14 @@ 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
+break label;  // saute au label ci-dessous (ne fonctionne pas)
 
 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.
+L'appel d'un `continue` n'est possible qu'à partir de l'intérieur de la boucle 
 
-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
+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.
 ````
 
 ## Résumé

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

@@ -100,11 +100,7 @@ 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
+## Clonage et fusion, Object.assign [#clonage-et-fusion-object-assign]
 
 Copier une variable object créé une référence en plus vers le même objet.
 
@@ -191,11 +187,7 @@ 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/03-string/article.md

@@ -535,11 +535,7 @@ 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
+### Les comparaisons correctes [#comparaisons-correctes]
 
 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,11 +326,7 @@ 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
+Le code externe a toujours sa variable `sayHi` ou `welcome`. Et `func` est un "nom de fonction interne", comment la fonction peut s'appeler en interne.
 
 ```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,11 +125,7 @@ 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
+## Héritage de méthodes et de propriétés statiques [#heritage-de-methodes-et-proprietes-statiques]
 
 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,14 +1,8 @@
 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`.
+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
+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.
 
 ```js run
 function f() {

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

@@ -6,11 +6,7 @@ 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
+1. Le premier utilise `finally` pour exécuter le code après `try..catch` :
 
     ```js
     try {
@@ -23,11 +19,7 @@ Comparez les deux fragments de code.
     */!*
     }
     ```
-<<<<<<< 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
+2. Le deuxième fragment fait le nettoyage juste après `try..catch` :
 
     ```js
     try {