Merge pull request #328 from javascript-tutorial/sync-eda333d4

Sync with upstream @ eda333d

Author: HachemiH

1-js/01-getting-started/1-intro/article.md

@@ -26,11 +26,19 @@ Le navigateur a un moteur intégré, parfois il peut être également appelé "l
 
 Différents moteurs ont différents "nom de code", par exemple:
 
+<<<<<<< HEAD
 - [V8](<https://fr.wikipedia.org/wiki/V8_(moteur_JavaScript)>) -- dans Chrome et Opera.
 - [SpiderMonkey](https://fr.wikipedia.org/wiki/SpiderMonkey) -- dans Firefox.
 - … Il existe d'autres noms de code comme "Chakra" pour IE, "JavaScriptCore", "Nitro" et "SquirrelFish" pour Safari etc.
 
 Les termes ci-dessus sont bons à retenir, car ils sont utilisés dans les articles destinés aux développeurs sur Internet. Nous les utiliserons aussi. Par exemple, si "une fonctionnalité X est prise en charge par V8", cela fonctionne probablement dans Chrome et Opera.
+=======
+- [V8](https://en.wikipedia.org/wiki/V8_(JavaScript_engine)) -- in Chrome, Opera and Edge.
+- [SpiderMonkey](https://en.wikipedia.org/wiki/SpiderMonkey) -- in Firefox.
+- ...There are other codenames like "Chakra" for IE, "JavaScriptCore", "Nitro" and "SquirrelFish" for Safari, etc.
+
+The terms above are good to remember because they are used in developer articles on the internet. We'll use them too. For instance, if "a feature X is supported by V8", then it probably works in Chrome, Opera and Edge.
+>>>>>>> eda333d423db8ade41f75d2e2d30ea06c7d997ef
 
 ```smart header="Comment fonctionnent les moteurs ?"
 

1-js/01-getting-started/3-code-editors/article.md

@@ -40,6 +40,13 @@ Les options suivantes méritent votre attention :
 - [Vim](http://www.vim.org/) et [Emacs](https://www.gnu.org/software/emacs/) sont également cool, si vous savez comment les utiliser.
 
 
+<<<<<<< HEAD
+=======
+- [Atom](https://atom.io/) (cross-platform, free).
+- [Sublime Text](http://www.sublimetext.com) (cross-platform, shareware).
+- [Notepad++](https://notepad-plus-plus.org/) (Windows, free).
+- [Vim](http://www.vim.org/) and [Emacs](https://www.gnu.org/software/emacs/) are also cool if you know how to use them.
+>>>>>>> eda333d423db8ade41f75d2e2d30ea06c7d997ef
 
 ## Ne discutons pas
 

1-js/02-first-steps/09-comparison/article.md

@@ -7,7 +7,14 @@ Il y a de nombreux opérateurs de comparaison que nous connaissons des mathémat
 - Le contrôle d'égalité est écrit en tant que `a == b` (veuillez noter le signe de la double équation `=`. Un seul symbole `a = b` signifierait une affectation).
 - Pas égal. En maths, la notation est `≠`, en JavaScript, elle est écrite comme une assignation avec un signe d’exclamation : <code>a != b</code>.
 
+<<<<<<< HEAD
 Dans cet article, nous en apprendrons plus sur les différents types de comparaisons, sur la façon dont JavaScript les fait, y compris sur les particularités importantes.
+=======
+- Greater/less than: <code>a &gt; b</code>, <code>a &lt; b</code>.
+- Greater/less than or equals: <code>a &gt;= b</code>, <code>a &lt;= b</code>.
+- Equals: `a == b`, please note the double equality sign `==` means the equality test, while a single one `a = b` means an assignment.
+- Not equals: In maths the notation is <code>&ne;</code>, but in JavaScript it's written as <code>a != b</code>.
+>>>>>>> eda333d423db8ade41f75d2e2d30ea06c7d997ef
 
 À la fin, vous trouverez une bonne recette pour éviter les problèmes liés aux "bizarreries JavaScript".
 

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

@@ -123,7 +123,11 @@ Cela conduit à des usages intéressants par rapport à un "OR pur, classique, b
 
     Cela signifie que `||` traite ses arguments jusqu'à ce que la première valeur de vérité soit atteinte, puis la valeur est renvoyée immédiatement, sans même toucher l'autre argument.
 
+<<<<<<< HEAD
     L'importance de cette fonctionnalité devient évidente si un opérande n'est pas seulement une valeur, mais une expression avec un effet secondaire, comme une affectation de variable ou un appel de fonction.
+=======
+    The importance of this feature becomes obvious if an operand isn't just a value, but an expression with a side effect, such as a variable assignment or a function call.
+>>>>>>> eda333d423db8ade41f75d2e2d30ea06c7d997ef
 
     Dans l'exemple ci-dessous, seul le deuxième message est imprimé :
 

1-js/03-code-quality/02-coding-style/article.md

@@ -307,11 +307,19 @@ Ce qui est génial avec eux, c'est que la vérification du style trouve égaleme
 
 Voici quelques linters bien connus :
 
+<<<<<<< HEAD
 - [JSLint](http://www.jslint.com/) -- l'un des premiers linters.
 - [JSHint](http://www.jshint.com/) -- plus de paramètres que JSLint.
 - [ESLint](http://eslint.org/) -- probablement le plus récent.
 
 Tous peuvent faire le travail. L'auteur utilise [ESLint](http://eslint.org/).
+=======
+- [JSLint](https://www.jslint.com/) -- one of the first linters.
+- [JSHint](https://jshint.com/) -- more settings than JSLint.
+- [ESLint](https://eslint.org/) -- probably the newest one.
+
+All of them can do the job. The author uses [ESLint](https://eslint.org/).
+>>>>>>> eda333d423db8ade41f75d2e2d30ea06c7d997ef
 
 La plupart des linters sont intégrés aux éditeurs: il suffit d'activer le plug-in dans l'éditeur et de configurer le style.
 
@@ -345,7 +353,11 @@ Il est aussi possible de télécharger des ensembles de règles de style à part
 
 L'utilisation d'un linter a un effet secondaire formidable: les linters prennent les fautes de frappe. Par exemple, quand on accède à une variable non définie, un linter la détecte et (s'il est intégrée à un éditeur) la met en évidence. Dans la plupart des cas, il s’agit d’un mauvais type. Nous pouvons donc régler le problème tout de suite.
 
+<<<<<<< HEAD
 Pour cette raison, même si vous n’êtes pas préoccupé par les styles, il est vivement recommandé d’utiliser un linter.
+=======
+It is also possible to download style rule sets from the web and extend them instead. See <https://eslint.org/docs/user-guide/getting-started> for more details about installation.
+>>>>>>> eda333d423db8ade41f75d2e2d30ea06c7d997ef
 
 De plus, certains IDE prennent en charge le linting nativement, ce qui peut également être bien, mais pas aussi ajustables que ESLint.
 

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

@@ -135,6 +135,7 @@ alert( user.name ); // c'est toujour john dans l'objet copié
 
 On peut aussi utiliser la méthode [Object.assign](mdn:js/Object/assign) pour cela.
 
+
 La syntaxe est :
 
 ```js

1-js/05-data-types/01-primitives-methods/article.md

@@ -48,7 +48,11 @@ La solution semble peu commode, mais la voici:
 2. Le langage permet d'accéder aux méthodes et aux propriétés des chaînes de caractères, des nombres, des booléens et des symboles.
 3. Pour que cela fonctionne, un "wrapper d'objet" (conteneur)  spécial est crée pour fournir la fonctionnalité supplémentaire, puis il est détruit.
 
+<<<<<<< HEAD
 Les "wrapper d'objets" (conteneurs) sont différents pour chaque type de primitive et sont appelés: `String`, `Number`, `Boolean` et `Symbol`. Ainsi, ils fournissent différents ensembles de méthodes.
+=======
+The "object wrappers" are different for each primitive type and are called: `String`, `Number`, `Boolean`, `Symbol` and `BigInt`. Thus, they provide different sets of methods.
+>>>>>>> eda333d423db8ade41f75d2e2d30ea06c7d997ef
 
 Par exemple, il existe une méthode de string [str.toUpperCase()](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase) qui renvoie une chaîne de caractères `str` en majuscule. 
 

1-js/06-advanced-functions/01-recursion/05-output-single-linked-list-reverse/solution.md

@@ -33,7 +33,11 @@ printReverseList(list);
 
 # En utilisant une boucle
 
+<<<<<<< HEAD
 La variante de boucle est aussi un peu plus compliquée que la sortie directe.
+=======
+The loop variant is also a little bit more complicated than the direct output.
+>>>>>>> eda333d423db8ade41f75d2e2d30ea06c7d997ef
 
 Il n'y a aucun moyen d'obtenir la dernière valeur de notre `list`. Nous ne pouvons pas non plus "revenir en arrière".
 

1-js/11-async/03-promise-chaining/article.md

@@ -34,17 +34,29 @@ new Promise(function(resolve, reject) {
 
 L'idée est que le résultat est transmis à travers la chaîne de gestionnaires `.then`.
 
+<<<<<<< HEAD
 Ici, le flux est:
 1. La promesse initiale est résolue en 1 seconde `(*)`,
 2. Ensuite, le gestionnaire `.then` est appelé `(**)`.
 3. La valeur qu'elle renvoie est transmise au prochain gestionnaire `.then` `(***)`
 4. ...et ainsi de suite.
+=======
+Here the flow is:
+1. The initial promise resolves in 1 second `(*)`,
+2. Then the `.then` handler is called `(**)`, which in turn creates a new promise (resolved with `2` value).
+3. The next `then` `(***)` gets the result of the previous one, processes it (doubles) and passes the next handler.
+4. ...and so on.
+>>>>>>> eda333d423db8ade41f75d2e2d30ea06c7d997ef
 
 Lorsque le résultat est transmis le long de la chaîne de gestionnaires, nous pouvons voir une séquence d'appels `alert`: `1` -> `2` -> `4`.
 
 ![](promise-then-chain.svg)
 
+<<<<<<< HEAD
 Le tout fonctionne, car un appel à `promise.then` renvoie une promesse, de sorte que nous puissions appeler le prochain` .then` dessus.
+=======
+The whole thing works, because every call to a `.then` returns a new promise, so that we can call the next `.then` on it.
+>>>>>>> eda333d423db8ade41f75d2e2d30ea06c7d997ef
 
 Lorsqu'un gestionnaire renvoie une valeur, cela devient le résultat de cette promesse. Le prochain `.then` est appelé avec.
 

2-ui/1-document/01-browser-environment/article.md

@@ -17,7 +17,7 @@ Il existe un objet "racine" appelé `window`. Il a 2 rôles :
 
 Par exemple, nous l'utilisons ici comme un objet global :
 
-```js run
+```js run global
 function sayHi() {
   alert("Hello");
 }