merging all conflicts

Author: iliakan

1-js/01-getting-started/2-manuals-specifications/article.md

@@ -12,21 +12,33 @@ Une nouvelle version de la spécification est publiée chaque année. La derniè
 
 Pour en savoir plus sur les fonctionnalités à venir, y compris celles qui sont "presque standards" (appelées aussi "stage 3"), vous pouvez consulter les propositions à cette adresse : <https://github.com/tc39/proposals>.
 
+<<<<<<< HEAD
 Si vous développez spécifiquement pour le navigateur, il existe d’autres spécifications couvertes dans la [seconde partie](info:browser-environment) du tutoriel.
+=======
+Also, if you're in developing for the browser, then there are other specifications covered in the [second part](info:browser-environment) of the tutorial.
+>>>>>>> 97ef86242f9f236b13152e1baf52a55c4db8728a
 
 ## Manuels
 
+<<<<<<< HEAD
 - **La référence MDN (Mozilla) JavaScript** est un manuel avec des exemples et d’autres informations. C’est une excellente source pour obtenir des informations détaillées sur les fonctions linguistiques, les méthodes, etc.
+=======
+- **MDN (Mozilla) JavaScript Reference** is the main manual with examples and other information. It's great to get in-depth information about individual language functions, methods etc.
+>>>>>>> 97ef86242f9f236b13152e1baf52a55c4db8728a
 
     On peut la trouver à cette adresse : <https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference>.
 
+<<<<<<< HEAD
   Cependant, il est souvent préférable d’utiliser une recherche sur Internet. Utilisez simplement "MDN [terme]" dans la requête, par exemple <https://google.com/search?q=MDN+parseInt> pour rechercher la fonction `parseInt`.
 
 - **MSDN** – Manuel Microsoft contenant de nombreuses informations, y compris sur JavaScript (souvent appelé JScript). Si vous avez besoin de quelque chose de spécifique à Internet Explorer, c'est l'endroit qu'il vous faut : <http://msdn.microsoft.com/>.
 
     Nous pouvons également utiliser une recherche sur Internet avec des expressions telles que "RegExp MSDN" ou encore "RegExp MSDN jscript".
 
 ## Tableaux de compatibilité
+=======
+Although, it's often best to use an internet search instead. Just use "MDN [term]" in the query, e.g. <https://google.com/search?q=MDN+parseInt> to search for `parseInt` function.
+>>>>>>> 97ef86242f9f236b13152e1baf52a55c4db8728a
 
 JavaScript est un langage en développement, de nouvelles fonctionnalités sont ajoutées régulièrement.
 

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

@@ -105,7 +105,11 @@ Cependant, notez que les opérations se déroulent de gauche à droite. S'il y a
 alert(2 + 2 + '1' ); // "41" et non "221"
 ```
 
+<<<<<<< HEAD
 Ici, les opérateurs travaillent les uns après les autres. Le premier `+` additionne deux nombres, donc il renvoie `4`, puis le `+` suivant ajoute la chaîne de caractères `1`, donc c'est comme `4 + '1' = 41`.
+=======
+Here, operators work one after another. The first `+` sums two numbers, so it returns `4`, then the next `+` adds the string `1` to it, so it's like `4 + '1' = '41'`.
+>>>>>>> 97ef86242f9f236b13152e1baf52a55c4db8728a
 
 ```js run
 alert('1' + 2 + 2); // "122" and not "14"

1-js/02-first-steps/14-switch/article.md

@@ -47,7 +47,7 @@ switch (a) {
     break;
 */!*
   case 5:
-    alert( 'Too large' );
+    alert( 'Too big' );
     break;
   default:
     alert( "I don't know such values" );

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

@@ -121,7 +121,11 @@ Il existe deux types d'indentations :
 
     Un des avantages des espaces sur les tabulations est qu’ils permettent des configurations de retrait plus flexibles que le symbole tabulation.
 
+<<<<<<< HEAD
     Par exemple, nous pouvons aligner les arguments avec le crochet d’ouverture, comme ceci :
+=======
+    For instance, we can align the parameters with the opening bracket, like this:
+>>>>>>> 97ef86242f9f236b13152e1baf52a55c4db8728a
 
     ```js no-beautify
     show(parameters,

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

@@ -11,7 +11,11 @@ Une bonne page pour voir l’état actuel de la prise en charge des fonctionnali
 
 As programmers, we'd like to use most recent features. The more good stuff - the better!
 
+<<<<<<< HEAD
 D'un autre côté, comment faire fonctionner le code moderne sur des moteurs plus anciens qui ne comprennent pas encore les fonctionnalités récentes ?
+=======
+On the other hand, how to make our modern code work on older engines that don't understand recent features yet?
+>>>>>>> 97ef86242f9f236b13152e1baf52a55c4db8728a
 
 Il existe deux outils pour cela :
 

1-js/04-object-basics/03-garbage-collection/article.md

@@ -14,10 +14,17 @@ En termes simples, les valeurs "accessibles" sont celles qui sont accessibles ou
 
     Par exemple :
 
+<<<<<<< HEAD
     - Variables locales et paramètres de la fonction en cours.
     - Variables et paramètres pour d'autres fonctions sur la chaîne d'appels imbriqués en cours.
     - Variables globales.
     - (il y en a d'autres, internes aussi)
+=======
+    - The currently executing function, its local variables and parameters.
+    - Other functions on the current chain of nested calls, their local variables and parameters.
+    - Global variables.
+    - (there are some other, internal ones as well)
+>>>>>>> 97ef86242f9f236b13152e1baf52a55c4db8728a
 
     Ces valeurs s'appellent des racines (*roots*).
 

1-js/04-object-basics/04-object-methods/7-calculator/_js.view/test.js

@@ -15,6 +15,11 @@ describe("calculator", function() {
     afterEach(function() {
       prompt.restore();
     });
+    
+    it('the read get two values and saves them as object properties', function () {
+      assert.equal(calculator.a, 2);
+      assert.equal(calculator.b, 3);
+    });
 
     it("the sum is 5", function() {
       assert.equal(calculator.sum(), 5);

1-js/04-object-basics/06-constructor-new/2-calculator-constructor/_js.view/test.js

@@ -10,6 +10,11 @@ describe("calculator", function() {
     calculator = new Calculator();
     calculator.read();
   });
+  
+  it("the read method asks for two values using prompt and remembers them in object properties", function() {
+    assert.equal(calculator.a, 2);
+    assert.equal(calculator.b, 3);
+  });
 
   it("when 2 and 3 are entered, the sum is 5", function() {
     assert.equal(calculator.sum(), 5);

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

@@ -91,7 +91,11 @@ La syntaxe de cette section est rarement utilisée, sautez-la à moins de vouloi
 
 Dans une fonction, nous pouvons vérifier si elle a été appelée avec `new` ou sans, en utilisant la propriété spéciale `new.target`.
 
+<<<<<<< HEAD
 Elle est vide pour les appels normaux et égale à la fonction si elle est appelée avec `new`:
+=======
+It is undefined for regular calls and equals the function if called with `new`:
+>>>>>>> 97ef86242f9f236b13152e1baf52a55c4db8728a
 
 ```js run
 function User() {

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

@@ -79,10 +79,20 @@ C'est pourquoi le chaînage facultatif `?.` A été ajouté au langage. Pour ré
 
 ET l'ensemble du chemin d'accès à la propriété garantit que tous les composants existent (sinon, l'évaluation s'arrête), mais est difficile à écrire.
 
+<<<<<<< HEAD
+=======
+The optional chaining `?.` stops the evaluation if the value before `?.` is `undefined` or `null` and returns `undefined`.
+>>>>>>> 97ef86242f9f236b13152e1baf52a55c4db8728a
 
 ## Chaînage optionnel
 
+<<<<<<< HEAD
 Le chaînage facultatif `?.` arrête l'évaluation et renvoie `undefined` si la partie avant `?.` est `undefined` ou `null` et renvoie cette partie.
+=======
+In other words, `value?.prop`:
+- works as `value.prop`, if `value` exists,
+- otherwise (when `value` is `undefined/null`) it returns `undefined`.
+>>>>>>> 97ef86242f9f236b13152e1baf52a55c4db8728a
 
 **Plus loin dans cet article, par souci de brièveté, nous dirons que quelque chose "existe" si ce n'est pas "null" et non "undefined".**
 
@@ -111,7 +121,11 @@ alert( user?.address.street ); // undefined
 
 Remarque: la syntaxe `?.` Rend facultative la valeur qui la précède, mais pas plus.
 
+<<<<<<< HEAD
 Par exemple. dans `user?.address.street.name` le `?.` permet à `user` d'être `null/undefined`, mais c'est tout ce qu'il fait. D'autres propriétés sont accessibles de manière régulière. Si nous voulons que certains d'entre eux soient optionnels, alors nous devrons remplacer plus de `.` par `?.`.
+=======
+E.g. in `user?.address.street.name` the `?.` allows `user` to safely be `null/undefined` (and returns `undefined` in that case), but that's only for `user`. Further properties are accessed in a regular way. If we want some of them to be optional, then we'll need to replace more `.` with `?.`.
+>>>>>>> 97ef86242f9f236b13152e1baf52a55c4db8728a
 
 ```warn header="N'abusez pas du chaînage optionnel"
 Nous ne devrions utiliser `?.` que là où il est normal que quelque chose n'existe pas.
@@ -185,18 +199,22 @@ Puis `?.()` Vérifie la partie gauche : si la fonction admin existe, alors elle
 La syntaxe `?.[]` Fonctionne également, si nous voulons utiliser des crochets `[]` pour accéder aux propriétés au lieu du point `.`. Similaire aux cas précédents, il permet de lire en toute sécurité une propriété à partir d'un objet qui peut ne pas exister.
 
 ```js run
+let key = "firstName";
+
 let user1 = {
   firstName: "John"
 };
 
+<<<<<<< HEAD
 let user2 = null; // Imaginez, nous ne pouvons pas autoriser l'utilisateur
 
 let key = "firstName";
+=======
+let user2 = null; 
+>>>>>>> 97ef86242f9f236b13152e1baf52a55c4db8728a
 
 alert( user1?.[key] ); // John
 alert( user2?.[key] ); // undefined
-
-alert( user1?.[key]?.something?.not?.existing); // undefined
 ```
 
 Nous pouvons également utiliser `?.` avec `delete` :