Merge pull request #357 from HachemiH/master

Conflicts fixed after sync with upstream @ 71da17e

Author: HachemiH

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

@@ -47,25 +47,16 @@ Outre les nombres réguliers, il existe des "valeurs numériques spéciales" qui
     alert( "pas un nombre" / 2 ); // NaN, une telle division est erronée
     ```
 
-<<<<<<< HEAD
     `NaN` est contagieux. Toute autre opération sur `NaN` donnerait un `NaN` :
 
-    ```js run
-    alert( "pas un nombre" / 2 + 5 ); // NaN
-    ```
-
-    Donc, s'il y a `NaN` quelque part dans une expression mathématique, elle se propage à l'ensemble du résultat.
-=======
-    `NaN` is sticky. Any further mathematical operation on `NaN` returns `NaN`:
-
     ```js run
     alert( NaN + 1 ); // NaN
     alert( 3 * NaN ); // NaN
     alert( "not a number" / 2 - 1 ); // NaN
     ```
 
-    So, if there's a `NaN` somewhere in a mathematical expression, it propagates to the whole result (there's only one exception to that: `NaN ** 0` is `1`).
->>>>>>> 71da17e5960f1c76aad0d04d21f10bc65318d3f6
+    Donc, s'il y a `NaN` quelque part dans une expression mathématique, il se propage à l'ensemble du résultat (il n'y a qu'une seule exception : `NaN ** 0` vaut `1`).
+
 
 ```smart header="Les opérations mathématiques sont sûres"
 Faire des maths est sans danger en JavaScript. Nous pouvons faire n'importe quoi : diviser par zéro, traiter les chaînes non numériques comme des nombres, etc.
@@ -225,18 +216,8 @@ Le type `symbol` est utilisé pour créer des identificateurs uniques pour les o
 
 L'opérateur `typeof` renvoie le type de l'argument. Il est utile lorsqu'on souhaite traiter différemment les valeurs de différents types ou de faire une vérification rapide.
 
-<<<<<<< HEAD
-Il supporte deux formes de syntaxe :
-
-1. Sous forme d'opérateur : `typeof x`.
-2. En style de fonction : `typeof(x)`.
-
-En d'autres termes, cela fonctionne à la fois avec ou sans parenthèses. Le résultat est le même.
 
 L'appel `typeof x` renvoie une chaîne de caractères avec le nom du type :
-=======
-A call to `typeof x` returns a string with the type name:
->>>>>>> 71da17e5960f1c76aad0d04d21f10bc65318d3f6
 
 ```js
 typeof undefined // "undefined"
@@ -267,29 +248,22 @@ typeof alert // "function"  (3)
 Les trois dernières lignes peuvent nécessiter des explications supplémentaires :
 
 1. `Math` est un objet interne au langage qui fournit des opérations mathématiques. Nous allons l'apprendre dans le chapitre <info:number>. Ici, il sert uniquement comme exemple d'un objet.
-2. Le résultat de `typeof null` est `"object"`. C'est une erreur officiellement reconnue dans `typeof`, conservée pour compatibilité. Bien sûr, `null` n'est pas un objet. C'est une valeur spéciale avec un type distinct qui lui est propre. 
+2. Le résultat de `typeof null` est `"object"`. C'est une erreur officiellement reconnue dans `typeof`, datant des premiers jours de JavaScript et conservée pour compatibilité. Bien sûr, `null` n'est pas un objet. C'est une valeur spéciale avec un type distinct qui lui est propre. Le comportement de `typeof` est incorrect ici.
 3. Le résultat de `typeof alert` est `"function"`, car `alert` est une fonction. Nous étudierons les fonctions dans les chapitres suivants, et nous verrons qu’il n’y a pas de type "fonction" en JavaScript. Les fonctions appartiennent au type `object`. Mais `typeof` les traite différemment, en retournant `"fonction"`. Cela vient également des débuts de JavaScript. Techniquement ce n’est pas tout à fait correct, mais très pratique à l'usage.
 
-<<<<<<< HEAD
 
-## Résumé
-=======
-1. `Math` is a built-in object that provides mathematical operations. We will learn it in the chapter <info:number>. Here, it serves just as an example of an object.
-2. The result of `typeof null` is `"object"`. That's an officially recognized error in `typeof`, coming from very early days of JavaScript and kept for compatibility. Definitely, `null` is not an object. It is a special value with a separate type of its own. The behavior of `typeof` is wrong here.
-3. The result of `typeof alert` is `"function"`, because `alert` is a function. We'll study functions in the next chapters where we'll also see that there's no special "function" type in JavaScript. Functions belong to the object type. But `typeof` treats them differently, returning `"function"`. That also comes from the early days of JavaScript. Technically, such behavior isn't correct, but can be convenient in practice.
 
-```smart header="The `typeof(x)` syntax"
-You may also come across another syntax: `typeof(x)`. It's the same as `typeof x`.
+```smart header="La syntaxe `typeof(x)`"
+Vous pouvez également rencontrer une autre syntaxe : `typeof(x)`. C'est la même chose que `typeof x`.
 
-To put it clear: `typeof` is an operator, not a function. The parentheses here aren't a part of `typeof`. It's the kind of parentheses used for mathematical grouping.
+Pour être clair : `typeof` est un opérateur, pas une fonction. Les parenthèses ici ne font pas partie de `typeof`. C'est le genre de parenthèses utilisées pour le regroupement mathématique.
 
-Usually, such parentheses contain a mathematical expression, such as `(2 + 2)`, but here they contain only one argument `(x)`. Syntactically, they allow to avoid a space between the `typeof` operator and its argument, and some people like it.
+Habituellement, ces parenthèses contiennent une expression mathématique, telle que `(2 + 2)`, mais ici elles ne contiennent qu'un seul argument `(x)`. Syntaxiqement, ils permettent d'éviter un espace entre l'opérateur `typeof` et son argument, et certains aiment ça.
 
-Some people prefer `typeof(x)`, although the `typeof x` syntax is much more common.
+Certaines personnes préfèrent `typeof(x)`, bien que la syntaxe `typeof x` soit beaucoup plus courante.
 ```
 
-## Summary
->>>>>>> 71da17e5960f1c76aad0d04d21f10bc65318d3f6
+## Résumé
 
 Il existe 8 types de données de base en JavaScript.
 
@@ -304,14 +278,8 @@ Il existe 8 types de données de base en JavaScript.
 
 L'opérateur `typeof` nous permet de voir quel type est stocké dans la variable.
 
-<<<<<<< HEAD
-- Deux formes : `typeof x` ou `typeof(x)`.
+- Généralement utilisé sous cette forme `typeof x`, mais `typeof(x)` est également possible.
 - Renvoie une chaîne de caractères avec le nom du type, comme `"string"`.
 - Pour `null` il renvoit `"object"` -- C’est une erreur dans le langage, ce n’est pas un objet en fait.
-=======
-- Usually used as `typeof x`, but `typeof(x)` is also possible.
-- Returns a string with the name of the type, like `"string"`.
-- For `null` returns `"object"` -- this is an error in the language, it's not actually an object.
->>>>>>> 71da17e5960f1c76aad0d04d21f10bc65318d3f6
 
 Dans les chapitres suivants, nous nous concentrerons sur les valeurs primitives et une fois que nous les connaîtrons, nous passerons aux objets.

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

@@ -191,47 +191,25 @@ Il y a beaucoup d'opérateurs en JavaScript. Chaque opérateur a un numéro corr
 
 Un extrait du [tableau de précédence](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence) (vous n'avez pas besoin de vous en souvenir, mais notez que les opérateurs unaires ont une prioritée plus élevée que les binaires correspondants) :
 
-<<<<<<< HEAD
 | Précédence | Nom             | Symbole |
 |------------|-----------------|---------|
 | ...        | ...             | ...     |
-| 17         | plus unaire     | `+`     |
-| 17         | négation unaire | `-`     |
-| 16         | exponentiation  | `**`    |
-| 15         | multiplication  | `*`     |
-| 15         | division        | `/`     |
-| 13         | addition        | `+`     |
-| 13         | soustraction    | `-`     |
+| 15         | plus unaire     | `+`     |
+| 15         | négation unaire | `-`     |
+| 14         | exponentiation  | `**`    |
+| 13         | multiplication  | `*`     |
+| 13         | division        | `/`     |
+| 12         | addition        | `+`     |
+| 12         | soustraction    | `-`     |
 | ...        | ...             | ...     |
-| 3          | affectation     | `=`     |
+| 2          | affectation     | `=`     |
 | ...        | ...             | ...     |
 
-Comme on peut le voir, le "plus unaire" a une priorité de `17`, ce qui est supérieur à `13` pour "l'addition" (plus binaire). C’est pourquoi, dans l’expression `"+apples + +oranges"`, les plus unaires fonctionnent en premier, puis l’addition.
-=======
-| Precedence | Name | Sign |
-|------------|------|------|
-| ... | ... | ... |
-| 15 | unary plus | `+` |
-| 15 | unary negation | `-` |
-| 14 | exponentiation | `**` |
-| 13 | multiplication | `*` |
-| 13 | division | `/` |
-| 12 | addition | `+` |
-| 12 | subtraction | `-` |
-| ... | ... | ... |
-| 2 | assignment | `=` |
-| ... | ... | ... |
-
-As we can see, the "unary plus" has a priority of `15` which is higher than the `13` of "addition" (binary plus). That's why, in the expression `"+apples + +oranges"`, unary pluses work before the addition.
->>>>>>> 71da17e5960f1c76aad0d04d21f10bc65318d3f6
+Comme on peut le voir, le "plus unaire" a une priorité de `15`, ce qui est supérieur à `12` pour "l'addition" (plus binaire). C’est pourquoi, dans l’expression `"+apples + +oranges"`, les plus unaires fonctionnent en premier, puis l’addition.
 
 ## Affectation
 
-<<<<<<< HEAD
-Notons qu’une affectation `=` est aussi un opérateur. Il est répertorié dans le tableau de priorité des précédences avec la très faible priorité de `3`.
-=======
-Let's note that an assignment `=` is also an operator. It is listed in the precedence table with the very low priority of `2`.
->>>>>>> 71da17e5960f1c76aad0d04d21f10bc65318d3f6
+Notons qu’une affectation `=` est aussi un opérateur. Il est répertorié dans le tableau des précédences avec la très faible priorité de `2`.
 
 C’est pourquoi lorsque nous assignons une variable, comme `x = 2 * 2 + 1`, les calculs sont effectués en premier, puis le `=` est évalué, stockant le résultat dans `x`.
 

1-js/02-first-steps/12-nullish-coalescing-operator/article.md

@@ -107,11 +107,7 @@ En pratique, la hauteur zéro est souvent une valeur valide, qui ne doit pas êt
 
 ## Priorité
 
-<<<<<<< HEAD
-La priorité de l'opérateur `??` est à peu près la même que celle de `||`, juste un peu plus basse. Il est égal à `5` dans le [tableau MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence#Table), tandis que `||` est `6`.
-=======
-The precedence of the `??` operator is the same as `||`. They both equal `4` in the [MDN table](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence#Table).
->>>>>>> 71da17e5960f1c76aad0d04d21f10bc65318d3f6
+La priorité de l'opérateur `??` est la même que celle de `||`. Elle est égale à `4` dans le [tableau MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence#Table).
 
 Cela signifie que, tout comme `||`, l'opérateur de coalescence des nuls `??` est évalué avant `=` et `?`, Mais après la plupart des autres opérations, telles que `+`, `*`.
 

1-js/02-first-steps/16-function-expressions/article.md

@@ -12,38 +12,29 @@ function sayHi() {
 
 Il existe une autre syntaxe pour créer une fonction appelée *Expression de Fonction*.
 
-<<<<<<< HEAD
-Cela ressemble à ceci :
-=======
-It allows us to create a new function in the middle of any expression.
+Cela nous permet de créer une nouvelle fonction au milieu de n'importe quelle expression.
 
-For example:
->>>>>>> 71da17e5960f1c76aad0d04d21f10bc65318d3f6
+Par exemple :
 
 ```js
 let sayHi = function() {
   alert( "Hello" );
 };
 ```
 
-<<<<<<< HEAD
-Ici, la fonction est créée et attribuée explicitement à la variable, comme toute autre valeur. Quelle que soit la définition de la fonction, il ne s’agit que d’une valeur stockée dans la variable `sayHi`.
+Ici, nous pouvons voir une variable `sayHi` obtenir une valeur, la nouvelle fonction, créée en tant que `function() { alert("Hello"); }`.
 
-=======
-Here we can see a variable `sayHi` getting a value, the new function, created as `function() { alert("Hello"); }`.
+Comme la création de la fonction se produit dans le contexte de l'expression d'affectation (à droite de `=`), il s'agit d'une *Fonction Expression*.
 
-As the function creation happens in the context of the assignment expression (to the right side of `=`), this is a *Function Expression*.
+Veuillez noter qu'il n'y a pas de nom après le mot clé `function`. L'omission d'un nom est autorisée pour les fonctions expressions.
 
-Please note, there's no name after the `function` keyword. Omitting a name is allowed for Function Expressions.
+Ici, nous l'assignons immédiatement à la variable, donc la signification de ces exemples de code est la même : "créer une fonction et la mettre dans la variable `sayHi`".
 
-Here we immediately assign it to the variable, so the meaning of these code samples is the same: "create a function and put it into the variable `sayHi`".
+Dans des situations plus avancées, que nous verrons plus tard, une fonction peut être créée et immédiatement appelée ou planifiée pour une exécution ultérieure, non stockée nulle part, restant ainsi anonyme.
 
-In more advanced situations, that we'll come across later, a function may be created and immediately called or scheduled for a later execution, not stored anywhere, thus remaining anonymous.
+## La fonction est une valeur
 
-## Function is a value
-
-Let's reiterate: no matter how the function is created, a function is a value. Both examples above store a function in the `sayHi` variable.
->>>>>>> 71da17e5960f1c76aad0d04d21f10bc65318d3f6
+Répétons-le : quelle que soit la manière dont la fonction est créée, une fonction est une valeur. Les deux exemples ci-dessus stockent une fonction dans la variable `sayHi`.
 
 La signification de ces exemples de code est la même : "créer une fonction et la placer dans la variable `sayHi`".
 
@@ -86,11 +77,7 @@ Voici ce qui se passe ci-dessus en détail :
 2. La ligne `(2)` le copie dans la variable `func`. Veuillez noter à nouveau : il n'y a pas de parenthèses après `sayHi`. S'il y en avait, alors `func = sayHi()` écrirait *le résultat de l'appel* `sayHi()` dans `func`, et non *la fonction* `sayHi` elle-même.
 3. Maintenant, la fonction peut être appelée à la fois en tant que `sayHi()` et `func()`.
 
-<<<<<<< HEAD
-Notez que nous aurions aussi pu utiliser une Expression de Fonction pour déclarer `sayHi`, à la première ligne :
-=======
-We could also have used a Function Expression to declare `sayHi`, in the first line:
->>>>>>> 71da17e5960f1c76aad0d04d21f10bc65318d3f6
+Nous aurions aussi pu utiliser une Fonction Expression pour déclarer `sayHi`, à la première ligne :
 
 ```js
 let sayHi = function() { // (1) create
@@ -105,7 +92,7 @@ Tout fonctionnerait de la même manière.
 
 
 ````smart header="Pourquoi y a-t-il un point-virgule à la fin ?"
-Il peut y avoir une question, pourquoi l'Expression de Fonction a un point-virgule `;` à la fin, et la Déclaration de Fonction non :
+Il peut y avoir une question, pourquoi la Fonction Expression a un point-virgule `;` à la fin, et la Fonction Déclaration non :
 
 
 ```js
@@ -118,15 +105,9 @@ let sayHi = function() {
 }*!*;*/!*
 ```
 
-<<<<<<< HEAD
-La réponse est simple :
-- Il n’ya pas besoin de `;` à la fin des blocs de code et des structures de syntaxe qui les utilisent comme `if { ... }`, `for {  }`, `function f {  }` etc.
-- Une Fonction Expression est utilisée dans la déclaration : `let sayHi = …;`, en tant que valeur. Ce n’est pas un bloc de code, mais plutôt une affectation. Le point-virgule `;` est recommandé à la fin des déclarations, quelle que soit la valeur. Donc, le point-virgule ici n'est en aucun cas lié à la Fonction Expression elle même, il termine simplement l'instruction.
-=======
-The answer is simple: a Function Expression is created here as `function(…) {…}` inside the assignment statement: `let sayHi = …;`. The semicolon `;` is recommended at the end of the statement, it's not a part of the function syntax.
+La réponse est simple : une expression de fonction est créée ici en tant que `function(…) {…}` à l'intérieur de l'instruction d'affectation : `let sayHi = …;`. Le point-virgule `;` est recommandé à la fin de l'instruction, il ne fait pas partie de la syntaxe de la fonction.
 
-The semicolon would be there for a simpler assignment, such as `let sayHi = 5;`, and it's also there for a function assignment.
->>>>>>> 71da17e5960f1c76aad0d04d21f10bc65318d3f6
+Le point-virgule serait là pour une affectation plus simple, telle que `let sayHi = 5;`, et il est également là pour une affectation de fonction.
 ````
 
 ## Fonctions callback (de rappel)

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

@@ -8,11 +8,7 @@ Les "fonctions fléchées" sont appelées ainsi pour leur syntaxe :
 let func = (arg1, arg2, ..., argN) => expression;
 ```
 
-<<<<<<< HEAD
-...Cela va créér une function `func` qui accepte les arguments `arg1...argN`, puis évalue l'`expression` sur le côté droit et retourne le résultat.
-=======
-This creates a function `func` that accepts arguments `arg1..argN`, then evaluates the `expression` on the right side with their use and returns its result.
->>>>>>> 71da17e5960f1c76aad0d04d21f10bc65318d3f6
+Cela va créér une function `func` qui accepte les arguments `arg1...argN`, puis évalue l'`expression` sur le côté droit et retourne le résultat.
 
 C'est donc la version raccourcie de :
 
@@ -37,11 +33,7 @@ let sum = function(a, b) {
 alert( sum(1, 2) ); // 3
 ```
 
-<<<<<<< HEAD
 Comme vous pouvez le voir `(a, b) => a + b` représente une fonction qui accepte 2 arguments nommés `a` et `b`. Lors de l'éxécution, elle évalue l'expression `a + b` et retourne le résultat.
-=======
-As you can see, `(a, b) => a + b` means a function that accepts two arguments named `a` and `b`. Upon the execution, it evaluates the expression `a + b` and returns the result.
->>>>>>> 71da17e5960f1c76aad0d04d21f10bc65318d3f6
 
 - Pour un argument unique, alors les parenthèses autour du paramètre peuvent être omises, rendant la fonction encore plus courte.
 
@@ -94,11 +86,7 @@ Comme cela :
 let sum = (a, b) => {  // Les accolades ouvre une fonction multiligne
   let result = a + b;
 *!*
-<<<<<<< HEAD
-  return result; // Si nous utilisons des accolades le "return" est nécessaire
-=======
-  return result; // if we use curly braces, then we need an explicit "return"
->>>>>>> 71da17e5960f1c76aad0d04d21f10bc65318d3f6
+  return result; // si nous utilisons des accolades, nous avons besoin d'un "return" explicite
 */!*
 };
 

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

@@ -1,10 +1,6 @@
 # Le constructeur, l'opérateur "new"
 
-<<<<<<< HEAD
 La syntaxe normale `{...}` permet de créer un seul objet. Mais souvent, nous devons créer de nombreux objets similaires, tels que plusieurs utilisateurs ou éléments de menu, etc.
-=======
-The regular `{...}` syntax allows us to create one object. But often we need to create many similar objects, like multiple users or menu items and so on.
->>>>>>> 71da17e5960f1c76aad0d04d21f10bc65318d3f6
 
 Cela peut être fait en utilisant les fonctions du constructeur et l'opérateur `"new"`.
 

1-js/04-object-basics/07-optional-chaining/article.md

@@ -30,11 +30,7 @@ C'est le résultat attendu. JavaScript fonctionne comme cela. Comme `user.addres
 
 Dans de nombreux cas pratiques, nous préférerions obtenir `undefined` au lieu d'une erreur ici (signifiant "pas de rue").
 
-<<<<<<< HEAD
 ... Et un autre exemple. Dans le développement Web, nous pouvons obtenir un objet qui correspond à un élément de page Web à l'aide d'un appel de méthode spécial, tel que `document.querySelector('.elem')`, et il renvoie `null` lorsqu'il n'y a pas ce type d'élément.
-=======
-...and another example. In Web development, we can get an object that corresponds to a web page element using a special method call, such as `document.querySelector('.elem')`, and it returns `null` when there's no such element.
->>>>>>> 71da17e5960f1c76aad0d04d21f10bc65318d3f6
 
 ```js run
 // document.querySelector('.elem') est nul s'il n'y a pas d'élément