Merge pull request #354 from javascript-tutorial/sync-71da17e5

Sync with upstream @ 71da17e

Author: HachemiH

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

@@ -47,13 +47,25 @@ 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
 
 ```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.
@@ -213,6 +225,7 @@ 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`.
@@ -221,6 +234,9 @@ Il supporte deux formes de syntaxe :
 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"
@@ -254,8 +270,26 @@ Les trois dernières lignes peuvent nécessiter des explications supplémentaire
 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. 
 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`.
+
+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.
+
+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.
+
+Some people prefer `typeof(x)`, although the `typeof x` syntax is much more common.
+```
+
+## Summary
+>>>>>>> 71da17e5960f1c76aad0d04d21f10bc65318d3f6
 
 Il existe 8 types de données de base en JavaScript.
 
@@ -270,8 +304,14 @@ 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)`.
 - 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,6 +191,7 @@ 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 |
 |------------|-----------------|---------|
 | ...        | ...             | ...     |
@@ -206,10 +207,31 @@ Un extrait du [tableau de précédence](https://developer.mozilla.org/en-US/docs
 | ...        | ...             | ...     |
 
 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
 
 ## 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
 
 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,7 +107,11 @@ 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
 
 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,16 +12,38 @@ 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.
+
+For example:
+>>>>>>> 71da17e5960f1c76aad0d04d21f10bc65318d3f6
 
 ```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`.
 
+=======
+Here we can see a variable `sayHi` getting a value, the new function, created as `function() { alert("Hello"); }`.
+
+As the function creation happens in the context of the assignment expression (to the right side of `=`), this is a *Function Expression*.
+
+Please note, there's no name after the `function` keyword. Omitting a name is allowed for Function Expressions.
+
+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`".
+
+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.
+
+## 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
 
 La signification de ces exemples de code est la même : "créer une fonction et la placer dans la variable `sayHi`".
 
@@ -64,10 +86,14 @@ 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
 
 ```js
-let sayHi = function() {
+let sayHi = function() { // (1) create
   alert( "Hello" );
 };
 
@@ -92,9 +118,15 @@ 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.
+
+The semicolon would be there for a simpler assignment, such as `let sayHi = 5;`, and it's also there for a function assignment.
+>>>>>>> 71da17e5960f1c76aad0d04d21f10bc65318d3f6
 ````
 
 ## Fonctions callback (de rappel)

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

@@ -5,10 +5,14 @@ Il existe une syntaxe plus simple et concise pour créer des fonctions, c'est so
 Les "fonctions fléchées" sont appelées ainsi pour leur syntaxe :
 
 ```js
-let func = (arg1, arg2, ..., argN) => expression
+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
 
 C'est donc la version raccourcie de :
 
@@ -33,7 +37,11 @@ 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.
 
@@ -86,7 +94,11 @@ 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
 */!*
 };
 

1-js/04-object-basics/04-object-methods/8-chain-calls/_js.view/solution.js

@@ -11,5 +11,6 @@ let ladder = {
   },
   showStep: function() { 
     alert(this.step);
+    return this;
   }
 };

1-js/04-object-basics/04-object-methods/8-chain-calls/_js.view/test.js

@@ -32,6 +32,14 @@ describe('Ladder', function() {
   it('down().up().up().up() ', function() {
     assert.equal(ladder.down().up().up().up().step, 2);
   });
+
+  it('showStep() should return this', function() {
+    assert.equal(ladder.showStep(), ladder);
+  });
+ 
+  it('up().up().down().showStep().down().showStep()', function () {
+    assert.equal(ladder.up().up().down().showStep().down().showStep().step, 0)
+  });
 
   after(function() {
     ladder.step = 0;

1-js/04-object-basics/04-object-methods/8-chain-calls/solution.md

@@ -23,7 +23,7 @@ let ladder = {
   }
 };
 
-ladder.up().up().down().up().down().showStep(); // 1
+ladder.up().up().down().showStep().down().showStep(); // shows 1 then 0
 ```
 
 Nous pouvons également écrire un seul appel par ligne. Pour les longues chaînes, c'est plus lisible :
@@ -33,8 +33,8 @@ ladder
   .up()
   .up()
   .down()
-  .up()
+  .showStep() // 1
   .down()
-  .showStep(); // 1
+  .showStep(); // 0
 ```
 

1-js/04-object-basics/04-object-methods/8-chain-calls/task.md

@@ -28,12 +28,14 @@ ladder.up();
 ladder.up();
 ladder.down();
 ladder.showStep(); // 1
+ladder.down();
+ladder.showStep(); // 0
 ```
 
 Modifiez le code de `up` et `down` pour rendre les appels chaînables, comme ceci :
 
 ```js
-ladder.up().up().down().showStep(); // 1
+ladder.up().up().down().showStep().down().showStep(); // shows 1 then 0
 ```
 
 Cette approche est largement utilisée dans les bibliothèques JavaScript.

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

@@ -1,6 +1,10 @@
 # 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"`.