Merge pull request #283 from HachemiH/master

Conflicts fixed after sync with upstream @ 97ef862

Author: HachemiH

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

@@ -12,33 +12,18 @@ 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
+- **La référence MDN (Mozilla) JavaScript** est le principal 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.
 
     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,11 +105,7 @@ 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/03-code-quality/02-coding-style/article.md

@@ -121,11 +121,7 @@ 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,11 +11,7 @@ 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,17 +14,10 @@ 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 locales et paramètres de la fonction en cours d’exécution.
     - 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/06-constructor-new/article.md

@@ -91,11 +91,7 @@ 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
+Elle n'est pas définie pour les appels réguliers et équivaut à la fonction si elle est appelée avec `new` :
 
 ```js run
 function User() {

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

@@ -77,22 +77,10 @@ Comme vous pouvez le voir, les noms de propriétés sont toujours dupliqués dan
 
 C'est pourquoi le chaînage facultatif `?.` A été ajouté au langage. Pour résoudre ce problème une fois pour toutes !
 
-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
+Le chaînage optionnel `?.` arrête l'évaluation si la valeur avant `?.` est `undefined` ou `null` et renvoie `undefined`.
 
 **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".**
 
@@ -121,11 +109,7 @@ 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
+Par exemple. dans `user?.address.street.name` le `?.` permet à `user` d'être en toute sécurité `null/undefined` (et renvoie `undefined` dans ce cas), mais ce n'est que pour `user`. D'autres propriétés sont accessibles de manière régulière. Si nous voulons que certaines d'entre elles soient optionnelles, alors nous devrons remplacer plus de `.` par `?.`.
 
 ```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.
@@ -205,13 +189,7 @@ 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

1-js/05-data-types/02-number/article.md

@@ -16,46 +16,30 @@ Imaginez que nous ayons besoin d'écrire 1 milliard. Le moyen évident est:
 let milliard = 1000000000;
 ```
 
-<<<<<<< HEAD
-Mais dans la vie réelle, nous évitons généralement d'écrire une longue chaîne de caractères remplie de zéros car une erreur est si vite arrivée. De plus, nous sommes paresseux. Nous écrirons donc généralement quelque chose comme `"1bn"` pour un milliard ou `"7.3bn"` pour 7 milliards 300 millions. De même pour la plupart des grands nombres.
-
-En JavaScript, nous raccourcissons un nombre en ajoutant la lettre `"e"` au nombre et en précisant le nombre de zéros:
-=======
-We also can use underscore `_` as the separator:
+Nous pouvons également utiliser l’underscore `_` comme séparateur :
 
 ```js
 let billion = 1_000_000_000;
 ```
 
-Here the underscore `_` plays the role of the "syntactic sugar", it makes the number more readable. The JavaScript engine simply ignores `_` between digits, so it's exactly the same one billion as above.
+Ici l’underscore `_` joue le rôle de "sucre syntaxique", il rend le nombre plus lisible. Le moteur JavaScript ignore simplement `_` entre les chiffres, donc c'est exactement le même milliard que ci-dessus.
 
-In real life though, we try to avoid writing long sequences of zeroes. We're too lazy for that. We'll try to write something like `"1bn"` for a billion or `"7.3bn"` for 7 billion 300 million. The same is true for most large numbers.
+Dans la vraie vie cependant, nous essayons d'éviter d'écrire de longues séquences de zéros. Nous sommes trop paresseux pour ça. Nous essaierons d'écrire quelque chose comme "1 milliard" pour un milliard ou "7,3 milliards" pour 7 milliards 300 millions. La même chose est vraie pour la plupart des grands nombres.
 
-In JavaScript, we can shorten a number by appending the letter `"e"` to it and specifying the zeroes count:
->>>>>>> 97ef86242f9f236b13152e1baf52a55c4db8728a
+En JavaScript, nous pouvons raccourcir un nombre en y ajoutant la lettre `"e"` et en spécifiant le nombre de zéros :
 
 ```js run
 let milliards = 1e9;  // 1 milliard, littéralement: 1 et 9 zéros
 
-<<<<<<< HEAD
-alert( 7.3e9 );  // 7.3 milliards (7,300,000,000)
+alert( 7.3e9 );  // 7.3 milliards (pareil que 7,300,000,000 ou 7_300_000_000)
 ```
 
-En d'autres termes, `"e"` multiplie le nombre de `1` avec le nombre de zéros donné.
-
-```js
-1e3 = 1 * 1000
-1.23e6 = 1.23 * 1000000 
-=======
-alert( 7.3e9 );  // 7.3 billions (same as 7300000000 or 7_300_000_000)
-```
+En d'autres termes, `e` multiplie le nombre de `1` avec le nombre de zéros donné.
 
-In other words, `e` multiplies the number by `1` with the given zeroes count.
 
 ```js
-1e3 = 1 * 1000 // e3 means *1000
-1.23e6 = 1.23 * 1000000 // e6 means *1000000
->>>>>>> 97ef86242f9f236b13152e1baf52a55c4db8728a
+1e3 = 1 * 1000 // e3 signifie *1000
+1.23e6 = 1.23 * 1000000 // e6 signifie *1000000
 ```
 
 Maintenant, écrivons quelque chose de très petit. Disons, 1 microseconde (un millionième de seconde):
@@ -150,11 +134,7 @@ Il existe plusieurs fonctions intégrées pour arrondir:
 : Arrondis: `3.1` devient `4`, et `-1.1` devient `-1`.
 
 `Math.round`
-<<<<<<< HEAD
-: Arrondit à l'entier le plus proche: `3.1` devient `3`, `3.6` devient `4` et `-1.1` devient `-1`.
-=======
-: Rounds to the nearest integer: `3.1` becomes `3`, `3.6` becomes `4`, the middle case: `3.5` rounds up to `4` too.
->>>>>>> 97ef86242f9f236b13152e1baf52a55c4db8728a
+: Arrondit à l'entier le plus proche: `3,1` devient `3`, `3,6` devient `4`, le cas du milieu : `3,5` arrondit également à `4`.
 
 `Math.trunc` (non pris en charge par Internet Explorer)
 : Supprime tout ce qui suit le point décimal sans avoir arrondi: `3.1` devient `3`, `-1.1` devient `-1`.

1-js/05-data-types/04-array/article.md

@@ -437,15 +437,9 @@ Cet opérateur n'a pas de traitement spécial pour les tableaux, il fonctionne a
 
 Rappelons les règles :
 
-<<<<<<< HEAD
 - Deux objets sont égaux `==` uniquement s'ils font référence au même objet.
 - Si l'un des arguments de `==` est un objet, et l'autre est une primitive, alors l'objet est converti en primitif, comme expliqué dans le chapitre <info:object-toprimitive>.
 - ...À l'exception de `null` et `undefined ` qui s'égalent `==` l'un l'autre et rien d'autre.
-=======
-- Two objects are equal `==` only if they're references to the same object.
-- If one of the arguments of `==` is an object, and the other one is a primitive, then the object gets converted to primitive, as explained in the chapter <info:object-toprimitive>.
-- ...With an exception of `null` and `undefined` that equal `==` each other and nothing else.
->>>>>>> 97ef86242f9f236b13152e1baf52a55c4db8728a
 
 La comparaison stricte `===` est encore plus simple, car elle ne convertit pas les types.
 

1-js/09-classes/01-class/article.md

@@ -49,15 +49,9 @@ let user = new User("John");
 user.sayHi();
 ```
 
-<<<<<<< HEAD
-Lorsque `new User("John")` est appelé:
+Lorsque `new User("John")` est appelé :
 1. Un nouvel objet est créé.
 2. Le `constructor` s'exécute avec les arguments qui lui sont passés et assigne `this.name` a l'objet.
-=======
-When `new User("John")` is called:
-1. A new object is created.
-2. The `constructor` runs with the given argument and assigns it to `this.name`.
->>>>>>> 97ef86242f9f236b13152e1baf52a55c4db8728a
 
 ...ensuite nous pouvons appeler les méthodes de l'objet, tel que `user.sayHi()`.