merging all conflicts

Author: iliakan

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

@@ -27,9 +27,15 @@ 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 "Trident", "Chakra" pour différentes version d'Internet Explorer, "ChakraCore" pour Microsoft Edge, "Nitro" ans "SquirrelFish" pour Safari etc.
+=======
+- [V8](https://en.wikipedia.org/wiki/V8_(JavaScript_engine)) -- in Chrome and Opera.
+- [SpiderMonkey](https://en.wikipedia.org/wiki/SpiderMonkey) -- in Firefox.
+- ...There are other codenames like "Chakra" for IE, "JavaScriptCore", "Nitro" and "SquirrelFish" for Safari, etc.
+>>>>>>> 8558fa8f5cfb16ef62aa537d323e34d9bef6b4de
 
 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.
 

1-js/02-first-steps/02-structure/article.md

@@ -46,7 +46,11 @@ alert(3 +
 + 2);
 ```
 
+<<<<<<< HEAD
 Le code génère `6`, car JavaScript n'insère pas de point-virgule ici. Il est intuitivement évident que si la ligne se termine par un plus `"+"`, alors c'est une "expression incomplète", aucun point-virgule requis. Et dans ce cas, cela fonctionne comme prévu.
+=======
+The code outputs `6` because JavaScript does not insert semicolons here. It is intuitively obvious that if the line ends with a plus `"+"`, then it is an "incomplete expression", so a semicolon there would be incorrect. And in this case, that works as intended.
+>>>>>>> 8558fa8f5cfb16ef62aa537d323e34d9bef6b4de
 
 **Mais il existe des situations où JavaScript "échoue" à prendre un point-virgule là où il est vraiment nécessaire.**
 
@@ -56,40 +60,63 @@ Les erreurs qui surviennent dans de tels cas sont assez difficiles à trouver et
 Si vous êtes curieux de voir un exemple concret d’une telle erreur, vérifiez ce code :
 
 ```js run
-[1, 2].forEach(alert)
+alert("Hello");
+
+[1, 2].forEach(alert);
 ```
 
+<<<<<<< HEAD
 Pas besoin de penser à la signification des crochets `[]` et `forEach` pour le moment. Nous les étudierons plus tard, pour l'instant, cela n'a pas d'importance. Retenons simplement le résultat: il affiche `1`, puis `2`.
 
 Maintenant, ajoutons une `alert` avant le code et **ne le terminons pas** par un point-virgule :
+=======
+No need to think about the meaning of the brackets `[]` and `forEach` yet. We'll study them later. For now, just remember the result of running the code: it shows `Hello`, then `1`, then `2`.
+
+Now let's remove the semicolon after the `alert`:
+>>>>>>> 8558fa8f5cfb16ef62aa537d323e34d9bef6b4de
 
 ```js run no-beautify
-alert("There will be an error")
+alert("Hello")
 
-[1, 2].forEach(alert)
+[1, 2].forEach(alert);
 ```
 
+<<<<<<< HEAD
 Maintenant, si nous l'exécutons, seul le premier `alert` est affiché, puis nous avons une erreur!
 
 Mais tout va bien à nouveau si on ajoute un point-virgule après `alert` :
 ```js run
 alert("All fine now");
+=======
+The difference compared to the code above is only one character: the semicolon at the end of the first line is gone.
+>>>>>>> 8558fa8f5cfb16ef62aa537d323e34d9bef6b4de
 
-[1, 2].forEach(alert)  
-```
+If we run this code, only the first `Hello` shows (and there's an error, you may need to open the console to see it). There are no numbers any more.
 
+<<<<<<< HEAD
 Nous avons maintenant le message `"All fine now"`, puis `1` et `2`.
 
 
 L'erreur dans la variante sans point-virgule se produit car JavaScript n'implique pas de point-virgule avant les crochets `[...]`.
 
 Ainsi, le point-virgule n'étant pas inséré automatiquement, le code du premier exemple est traité comme une seule instruction. C'est comme ça que le moteur le voit :
+=======
+That's because JavaScript does not assume a semicolon before square brackets `[...]`. So, the code in the last example is treated as a single statement.
+
+Here's how the engine sees it:
+>>>>>>> 8558fa8f5cfb16ef62aa537d323e34d9bef6b4de
 
 ```js run no-beautify
-alert("There will be an error")[1, 2].forEach(alert)
+alert("Hello")[1, 2].forEach(alert);
 ```
 
+<<<<<<< HEAD
 Mais ce devrait être deux déclarations distinctes, pas une seule. Une telle fusion dans ce cas est tout simplement erronée, d'où l'erreur. Il y a d'autres situations où une telle chose peut se produire.
+=======
+Looks weird, right? Such merging in this case is just wrong. We need to put a semicolon after `alert` for the code to work correctly.
+
+This can happen in other situations also.
+>>>>>>> 8558fa8f5cfb16ef62aa537d323e34d9bef6b4de
 ````
 
 Il est recommandé de mettre les points-virgules entre les instructions, même si elles sont séparées par des nouvelles lignes. Cette règle est largement adoptée par la communauté. Notons encore une fois - *il est possible* de laisser de côté les points-virgules la plupart du temps. Mais il est plus sûr -- surtout pour un débutant -- de les utiliser.

1-js/02-first-steps/05-types/article.md

@@ -65,7 +65,7 @@ Les valeurs numériques spéciales appartiennent formellement au type "number".
 
 Nous allons en voir plus sur le travail avec les nombres dans le chapitre <info:number>.
 
-## BigInt
+## BigInt [#bigint-type]
 
 En JavaScript, le type "number" ne peut pas représenter des valeurs entières supérieures à <code>(2<sup>53</sup>-1)</code> (c'est `9007199254740991`), ou moins que <code>-(2<sup>53</sup>-1)</code> pour les chiffres négatifs. C'est une limitation technique causée par leur représentation interne.
 

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

@@ -62,8 +62,8 @@ En mathématiques à l'école, nous écrivons cela a<sup>b</sup>.
 Par exemple:
 
 ```js run
-alert( 2 ** 2 ); // 2² = 4  
-alert( 2 ** 3 ); // 2³ = 8 
+alert( 2 ** 2 ); // 2² = 4
+alert( 2 ** 3 ); // 2³ = 8
 alert( 2 ** 4 ); // 2⁴ = 16
 ```
 

1-js/02-first-steps/15-function-basics/article.md

@@ -20,10 +20,14 @@ function showMessage() {
 }
 ```
 
+<<<<<<< HEAD
 Le mot-clé `function` commence en premier, puis le *nom de la fonction*, puis une liste de *paramètres* entre les parenthèses (séparés par des virgules, vides dans l'exemple ci-dessus) et enfin le code de la fonction, également appelé "le corps de la fonction", entre des accolades.
+=======
+The `function` keyword goes first, then goes the *name of the function*, then a list of *parameters* between the parentheses (comma-separated, empty in the example above, we'll see examples later) and finally the code of the function, also named "the function body", between curly braces.
+>>>>>>> 8558fa8f5cfb16ef62aa537d323e34d9bef6b4de
 
 ```js
-function name(parameters) {
+function name(parameter1, parameter2, ... parameterN) {
   ...body...
 }
 ```
@@ -138,26 +142,31 @@ C'est une bonne pratique de minimiser l'utilisation de variables globales. Le co
 
 ## Arguments
 
+<<<<<<< HEAD
 Nous pouvons transmettre des données arbitraires à des fonctions à l'aide de paramètres (également appelés *arguments de fonction*).
+=======
+We can pass arbitrary data to functions using parameters.
+>>>>>>> 8558fa8f5cfb16ef62aa537d323e34d9bef6b4de
 
 Dans l'exemple ci-dessous, la fonction a deux paramètres: `from` et `text`.
 
 ```js run
+<<<<<<< HEAD
 function showMessage(*!*from, text*/!*) { // arguments : from, text
+=======
+function showMessage(*!*from, text*/!*) { // parameters: from, text
+>>>>>>> 8558fa8f5cfb16ef62aa537d323e34d9bef6b4de
   alert(from + ': ' + text);
 }
 
-*!*
-showMessage('Ann', 'Hello!'); // Ann: Hello! (*)
-showMessage('Ann', "What's up?"); // Ann: What's up? (**)
-*/!*
+*!*showMessage('Ann', 'Hello!');*/!* // Ann: Hello! (*)
+*!*showMessage('Ann', "What's up?");*/!* // Ann: What's up? (**)
 ```
 
 Lorsque la fonction est appelée dans les lignes `(*)` et `(**)`, les valeurs données sont copiées dans les variables locales `from` et `text`. Ensuite, la fonction les utilise.
 
 Voici un autre exemple: nous avons une variable `from` et la transmettons à la fonction. Remarque : la fonction change `from`, mais le changement n'est pas visible à l'extérieur, car une fonction obtient toujours une copie de la valeur :
 
-
 ```js run
 function showMessage(from, text) {
 
@@ -176,19 +185,43 @@ showMessage(from, "Hello"); // *Ann*: Hello
 alert( from ); // Ann
 ```
 
+<<<<<<< HEAD
 ## Les valeurs par défaut
 
 Si un paramètre n'est pas fourni, sa valeur devient `undefined`.
+=======
+When a value is passed as a function parameter, it's also called an *argument*.
+
+In other words, to put these terms straight:
+
+- A parameter is the variable listed inside the parentheses in the function declaration (it's a declaration time term)
+- An argument is the value that is passed to the function when it is called (it's a call time term).
+
+We declare functions listing their parameters, then call them passing arguments.
+
+In the example above, one might say: "the function `sayMessage` is declared with two parameters, then called with two arguments: `from` and `"Hello"`".
+
+
+## Default values
+
+If a function is called, but an argument is not provided, then the corresponding value becomes `undefined`.
+>>>>>>> 8558fa8f5cfb16ef62aa537d323e34d9bef6b4de
 
 Par exemple, la fonction `showMessage(from, text)` mentionnée précédemment peut être appelée avec un seul argument :
 
 ```js
 showMessage("Ann");
 ```
 
+<<<<<<< HEAD
 Ce n’est pas une erreur. Un tel appel produirait `"*Annt*: undefined"`. Il n’y a pas de `text`, donc on suppose que `text === undefined`.
 
 Si nous voulons utiliser un `text` "par défaut" dans ce cas, nous pouvons le spécifier après `=` :
+=======
+That's not an error. Such a call would output `"*Ann*: undefined"`. As the value for `text` isn't passed, it becomes `undefined`.
+
+We can specify the so-called "default" (to use if omitted) value for a parameter in the function declaration, using `=`:
+>>>>>>> 8558fa8f5cfb16ef62aa537d323e34d9bef6b4de
 
 ```js run
 function showMessage(from, *!*text = "no text given"*/!*) {
@@ -212,19 +245,33 @@ function showMessage(from, text = anotherFunction()) {
 
 En JavaScript, un paramètre par défaut est évalué chaque fois que la fonction est appelée sans le paramètre correspondant.
 
+<<<<<<< HEAD
 Dans l'exemple ci-dessus, `anotherFunction()` est appelé à chaque fois que `showMessage()` est appelé sans le paramètre `text`.
+=======
+In the example above, `anotherFunction()` isn't called at all, if the `text` parameter is provided.
+
+On the other hand, it's independently called every time when `text` is missing.
+>>>>>>> 8558fa8f5cfb16ef62aa537d323e34d9bef6b4de
 ```
 
 ### Paramètres par défaut alternatifs
 
+<<<<<<< HEAD
 Il est parfois judicieux de définir des valeurs par défaut pour les paramètres non pas dans la déclaration de fonction, mais à un stade ultérieur, lors de son exécution.
 
 Pour vérifier un paramètre omis, nous pouvons le comparer avec `undefined` :
+=======
+Sometimes it makes sense to assign default values for parameters not in the function declaration, but at a later stage.
+
+We can check if the parameter is passed during the function execution, by comparing it with `undefined`:
+>>>>>>> 8558fa8f5cfb16ef62aa537d323e34d9bef6b4de
 
 ```js run
 function showMessage(text) {
+  // ...
+
 *!*
-  if (text === undefined) {
+  if (text === undefined) { // if the parameter is missing
     text = 'empty message';
   }
 */!*
@@ -238,18 +285,29 @@ showMessage(); // empty message
 ...Ou nous pourrions utiliser l'opérateur `||` :
 
 ```js
+<<<<<<< HEAD
 // si le paramètre de texte est omis ou "" est passé, définissez-le sur 'empty'
+=======
+>>>>>>> 8558fa8f5cfb16ef62aa537d323e34d9bef6b4de
 function showMessage(text) {
+  // if text is undefined or otherwise falsy, set it to 'empty'
   text = text || 'empty';
   ...
 }
 ```
 
+<<<<<<< HEAD
 Les moteurs JavaScript modernes prennent en charge [l'opérateur de coalescence des nuls](info:nullish-coalescing-operator) `??`, c'est mieux quand des valeurs fausses, telles que `0`, sont considérées comme régulières :
 
 ```js run
 // s'il n'y a pas de paramètre "count", afficher "unknown"
+=======
+Modern JavaScript engines support the [nullish coalescing operator](info:nullish-coalescing-operator) `??`, it's better when most falsy values, such as `0`, should be considered "normal":
+
+```js run
+>>>>>>> 8558fa8f5cfb16ef62aa537d323e34d9bef6b4de
 function showCount(count) {
+  // if count is undefined or null, show "unknown"
   alert(count ?? "unknown");
 }
 

1-js/03-code-quality/01-debugging-chrome/article.md

@@ -1,4 +1,8 @@
+<<<<<<< HEAD
 # Débogage dans Chrome
+=======
+# Debugging in the browser
+>>>>>>> 8558fa8f5cfb16ef62aa537d323e34d9bef6b4de
 
 Avant d’écrire un code plus complexe, parlons de débogage.
 

1-js/03-code-quality/06-polyfills/article.md

@@ -22,7 +22,11 @@ Ici, dans ce chapitre, notre objectif est de comprendre l'essentiel de leur fonc
 
 ## Les transpilers
 
+<<<<<<< HEAD
 Un [transpiler](https://en.wikipedia.org/wiki/Source-to-source_compiler) est un logiciel spécial qui peut analyser ("lire et comprendre") le code moderne et le réécrire en utilisant des constructions de syntaxe plus anciennes, de sorte que le résultat soit le même.
+=======
+A [transpiler](https://en.wikipedia.org/wiki/Source-to-source_compiler) is a special piece of software that translates source code to another source code. It can parse ("read and understand") modern code and rewrite it using older syntax constructs, so that it'll also work in outdated engines.
+>>>>>>> 8558fa8f5cfb16ef62aa537d323e34d9bef6b4de
 
 Par exemple, JavaScript avant l'année 2020 n'avait pas "l'opérateur de coalescence des nuls" `??`. Ainsi, si un visiteur utilise un navigateur obsolète, il peut ne pas comprendre le code tel que `height = height ?? 100`.
 

1-js/04-object-basics/06-constructor-new/article.md

@@ -64,13 +64,21 @@ Maintenant, si nous voulons créer d'autres utilisateurs, nous pouvons appeler `
 
 C’est l’objectif principal des constructeurs -- implémenter du code de création d’objet réutilisable.
 
+<<<<<<< HEAD
 Notons encore une fois - techniquement, toute fonction peut être utilisée en tant que constructeur. Autrement dit, toute fonction peut être exécutée avec `new`, et il exécutera l'algorithme ci-dessus. La "lettre majuscule d’abord" est une convention pour préciser qu’une fonction doit être exécutée avec `new`.
 
 ````smart header="new function() { ... }"
 Si nous avons beaucoup de lignes de code concernant la création d'un seul objet complexe, nous pouvons les envelopper dans une fonction constructeur, comme ceci :
+=======
+Let's note once again -- technically, any function (except arrow functions, as they don't have `this`) can be used as a constructor. It can be run with `new`, and it will execute the algorithm above. The "capital letter first" is a common agreement, to make it clear that a function is to be run with `new`.
+
+````smart header="new function() { ... }"
+If we have many lines of code all about creation of a single complex object, we can wrap them in an immediately called constructor function, like this:
+>>>>>>> 8558fa8f5cfb16ef62aa537d323e34d9bef6b4de
 
 ```js
-let user = new function() {
+// create a function and immediately call it with new
+let user = new function() { 
   this.name = "John";
   this.isAdmin = false;
 
@@ -80,7 +88,11 @@ let user = new function() {
 };
 ```
 
+<<<<<<< HEAD
 Le constructeur ne peut plus être appelé car il n’est sauvegardé nulle part, il est simplement créé et appelé. Donc, cette astuce vise à encapsuler le code qui construit l'objet unique, sans réutilisation ultérieure.
+=======
+This constructor can't be called again, because it is not saved anywhere, just created and called. So this trick aims to encapsulate the code that constructs the single object, without future reuse.
+>>>>>>> 8558fa8f5cfb16ef62aa537d323e34d9bef6b4de
 ````
 
 ## Constructeur mode test : new.target