Merge pull request #319 from javascript-tutorial/sync-4d01fc20

Sync with upstream @ 4d01fc2

Author: HachemiH

1-js/02-first-steps/04-variables/article.md

@@ -24,7 +24,11 @@ Maintenant, nous pouvons y mettre des données en utilisant l'opérateur d'affec
 let message;
 
 *!*
+<<<<<<< HEAD
 message = 'Hello'; // stocke la chaîne de caractères
+=======
+message = 'Hello'; // store the string 'Hello' in the variable named message
+>>>>>>> 4d01fc20d4d82358e61518a31efe80dec9bb2602
 */!*
 ```
 

1-js/02-first-steps/13-while-for/article.md

@@ -104,12 +104,21 @@ for (let i = 0; i < 3; i++) { // affiche 0, puis 1, puis 2
 
 Examinons la déclaration `for` partie par partie :
 
+<<<<<<< HEAD
 | partie    |            |                                                                                        |
 |-----------|------------|----------------------------------------------------------------------------------------|
 | début     | `i = 0`    | Exécute une fois en entrant dans la boucle.                                            |
 | condition | `i < 3`    | Vérifié avant chaque itération de la boucle, en cas d'échec, la boucle s'arrête.       |
 | corps     | `alert(i)` | Exécute encore et encore tant que la condition est vraie                               |
 | étape     | `i++`      | Exécute après le corps à chaque itération, mais avant la vérification de la condition. |
+=======
+| part  |          |                                                                            |
+|-------|----------|----------------------------------------------------------------------------|
+| begin | `let i = 0`    | Executes once upon entering the loop.                                      |
+| condition | `i < 3`| Checked before every loop iteration. If false, the loop stops.              |
+| body | `alert(i)`| Runs again and again while the condition is truthy.                         |
+| step| `i++`      | Executes after the body on each iteration. |
+>>>>>>> 4d01fc20d4d82358e61518a31efe80dec9bb2602
 
 
 L'algorithme de boucle général fonctionne comme ceci :
@@ -381,7 +390,11 @@ label: {
 }
 ```
 
+<<<<<<< HEAD
 ... Bien que 99,9% du temps les `break` utilisés sont à l'intérieur de boucles, comme nous l'avons vu dans les exemples ci-dessus.
+=======
+...Although, 99.9% of the time `break` is used inside loops, as we've seen in the examples above.
+>>>>>>> 4d01fc20d4d82358e61518a31efe80dec9bb2602
 
 Un `continue` n'est possible que depuis l'intérieur d'une boucle.
 ````

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

@@ -182,7 +182,11 @@ En d'autres termes, pour mettre ces termes au clair :
 
 Nous déclarons des fonctions en listant leurs paramètres, puis les appelons en passant des arguments.
 
+<<<<<<< HEAD
 Dans l'exemple ci-dessus, on pourrait dire : "la fonction `sayMessage` est déclarée avec deux paramètres, puis appelée avec deux arguments : `from` et `"Hello"`".
+=======
+In the example above, one might say: "the function `showMessage` is declared with two parameters, then called with two arguments: `from` and `"Hello"`".
+>>>>>>> 4d01fc20d4d82358e61518a31efe80dec9bb2602
 
 
 ## Les valeurs par défaut

1-js/04-object-basics/06-constructor-new/1-two-functions-one-object/task.md

@@ -4,7 +4,11 @@ importance: 2
 
 # Deux fonctions - un objet
 
+<<<<<<< HEAD
 Est-il possible de créer des fonctions `A` et `B` tel que `new A()==new B()` ?
+=======
+Is it possible to create functions `A` and `B` so that `new A() == new B()`?
+>>>>>>> 4d01fc20d4d82358e61518a31efe80dec9bb2602
 
 ```js no-beautify
 function A() { ... }

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

@@ -4,7 +4,11 @@ En JavaScript moderne, il existe deux types de nombres :
 
 1. Les nombres normaux en JavaScript sont stockés au format 64 bits [IEEE-754](https://en.wikipedia.org/wiki/IEEE_754-2008_revision), également connu sous le nom de "nombres à virgule flottante double précision". Ce sont des chiffres que nous utilisons le plus souvent, et nous en parlerons dans ce chapitre.
 
+<<<<<<< HEAD
 2. Les nombres BigInt pour représenter des entiers de longueur arbitraire. Ils sont parfois nécessaires, car un nombre régulier ne peut pas dépasser <code>2<sup>53</sup></code> ou être inférieur à <code>-2<sup>53</sup></code>. Comme les bigints sont utilisés dans quelques zones spéciales, nous leur consacrons un chapitre spécial <info:bigint>.
+=======
+2. BigInt numbers, to represent integers of arbitrary length. They are sometimes needed, because a regular number can't safely exceed <code>2<sup>53</sup></code> or be less than <code>-2<sup>53</sup></code>. As bigints are used in few special areas, we devote them a special chapter <info:bigint>.
+>>>>>>> 4d01fc20d4d82358e61518a31efe80dec9bb2602
 
 Donc, ici, nous allons parler de chiffres réguliers. Augmentons nos connaissances à leur sujet.
 
@@ -54,7 +58,11 @@ Comme avant, l'utilisation de `"e"` peut nous aider. Si nous voulons éviter d'
 let ms = 1e-6; // six zéros à gauche de 1
 ```
 
+<<<<<<< HEAD
 Si nous comptons les zéros dans `0.000001`, il y en a 6. Alors, logiquement, c'est `1e-6`.
+=======
+If we count the zeroes in `0.000001`, there are 6 of them. So naturally it's `1e-6`.
+>>>>>>> 4d01fc20d4d82358e61518a31efe80dec9bb2602
 
 En d'autres termes, un nombre négatif après `"e"` signifie une division par 1 avec le nombre donné de zéros:
 
@@ -331,7 +339,11 @@ let num = +prompt("Entrez un nombre", '');
 alert( isFinite(num) );
 ```
 
+<<<<<<< HEAD
 Veuillez noter qu'une chaîne de caractères vide ou une chaîne de caractères contenant seulement un espace est traitée comme `0` dans toutes les fonctions numérique, y compris `isFinite`.
+=======
+Please note that an empty or a space-only string is treated as `0` in all numeric functions including `isFinite`.
+>>>>>>> 4d01fc20d4d82358e61518a31efe80dec9bb2602
 
 ```smart header="Comparer avec Object.is"
 

1-js/05-data-types/05-array-methods/12-reduce-object/task.md

@@ -4,7 +4,7 @@ importance: 4
 
 # Create keyed object from array
 
-Let's say we received an array of users in the form `{id:..., name:..., age... }`.
+Let's say we received an array of users in the form `{id:..., name:..., age:... }`.
 
 Create a function `groupById(arr)` that creates an object from it, with `id` as the key, and array items as values.
 

1-js/05-data-types/09-keys-values-entries/article.md

@@ -75,9 +75,15 @@ Les objets manquent de nombreuses méthodes existantes pour les tableaux, par ex
 
 Si nous souhaitons leur appliquer ces méthodes, nous pouvons utiliser `Object.entries` suivis par `Object.fromEntries` :
 
+<<<<<<< HEAD
 1. Utilisons `Object.entries(obj)` pour obtenir un tableau de paires clé / valeur de `obj`.
 2. Utilisons des méthodes de tableau sur ce tableau, par exemple `map`.
 3. Utilisons `Object.fromEntries(array)` sur le tableau résultant pour le reconvertir en objet.
+=======
+1. Use `Object.entries(obj)` to get an array of key/value pairs from `obj`.
+2. Use array methods on that array, e.g. `map`, to transform these key/value pairs.
+3. Use `Object.fromEntries(array)` on the resulting array to turn it back into an object.
+>>>>>>> 4d01fc20d4d82358e61518a31efe80dec9bb2602
 
 Par exemple, nous avons un objet avec des prix et aimerions les doubler :
 
@@ -90,12 +96,22 @@ let prices = {
 
 *!*
 let doublePrices = Object.fromEntries(
+<<<<<<< HEAD
   // convertir en tableau, mapper, puis fromEntries restitue l'objet
   Object.entries(prices).map(([key, value]) => [key, value * 2])
+=======
+  // convert prices to array, map each key/value pair into another pair
+  // and then fromEntries gives back the object
+  Object.entries(prices).map(entry => [entry[0], entry[1] * 2])
+>>>>>>> 4d01fc20d4d82358e61518a31efe80dec9bb2602
 );
 */!*
 
 alert(doublePrices.meat); // 8
-```   
+```
 
+<<<<<<< HEAD
 Cela peut sembler difficile au premier abord, mais il devient facile à comprendre après l’avoir utilisé une ou deux fois. Nous pouvons faire de puissantes chaînes de transformations de cette façon.
+=======
+It may look difficult at first sight, but becomes easy to understand after you use it once or twice. We can make powerful chains of transforms this way.
+>>>>>>> 4d01fc20d4d82358e61518a31efe80dec9bb2602

1-js/06-advanced-functions/04-var/article.md

@@ -4,7 +4,11 @@
 ```smart header="Cet article est pour comprendre les anciens scripts"
 Les informations contenues dans cet article sont utiles pour comprendre les anciens scripts.
 
+<<<<<<< HEAD
 Ce n'est pas ainsi que nous écrivons un nouveau code.
+=======
+That's not how we write new code.
+>>>>>>> 4d01fc20d4d82358e61518a31efe80dec9bb2602
 ```
 
 Dans le tout premier chapitre qui parle des [variables](info:variables), nous avons mentionné trois façons pour déclarer une variable :

1-js/07-object-properties/01-property-descriptors/article.md

@@ -19,7 +19,11 @@ Nous ne les avons pas encore vues, car généralement elles ne se présentent pa
 
 Voyons d’abord comment obtenir ces "flags".
 
+<<<<<<< HEAD
 La methode [Object.getOwnPropertyDescriptor](https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object/getOwnPropertyDescriptor) permet d'interroger les informations *complètes* sur une propriété.
+=======
+The method [Object.getOwnPropertyDescriptor](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyDescriptor) allows to query the *full* information about a property.
+>>>>>>> 4d01fc20d4d82358e61518a31efe80dec9bb2602
 
 La syntaxe est la suivante:
 ```js
@@ -54,7 +58,11 @@ alert( JSON.stringify(descriptor, null, 2 ) );
 */
 ```
 
+<<<<<<< HEAD
 Pour changer les attributs, on peut utiliser [Object.defineProperty](https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object/defineProperty).
+=======
+To change the flags, we can use [Object.defineProperty](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty).
+>>>>>>> 4d01fc20d4d82358e61518a31efe80dec9bb2602
 
 La syntaxe est la suivante:
 
@@ -194,7 +202,11 @@ alert(Object.keys(user)); // name
 
 Le descripteur non configurable (`configurable: false`) est parfois prédéfini pour les objets et propriétés intégrés.
 
+<<<<<<< HEAD
 Une propriété non configurable ne peut pas être supprimée.
+=======
+A non-configurable property can't be deleted, its attributes can't be modified.
+>>>>>>> 4d01fc20d4d82358e61518a31efe80dec9bb2602
 
 Par exemple, `Math.PI` est en lecture seule, non énumérable et non configurable :
 
@@ -214,11 +226,12 @@ alert( JSON.stringify(descriptor, null, 2 ) );
 Ainsi, un programmeur est incapable de changer la valeur de `Math.PI` ou de le remplacer.
 
 ```js run
-Math.PI = 3; // Error
+Math.PI = 3; // Error, because it has writable: false
 
 // supprimer Math.PI ne fonctionnera pas non plus
 ```
 
+<<<<<<< HEAD
 Rendre une propriété non configurable est une route à sens unique. Nous ne pouvons pas la rétablir avec  `defineProperty`. 
 
 Pour être précis, la non-configurabilité impose plusieurs restrictions à `defineProperty` :
@@ -228,6 +241,20 @@ Pour être précis, la non-configurabilité impose plusieurs restrictions à `de
 4. Impossible de changer `get/set` pour une propriété d'accesseur (mais peut les affecter en cas d'absence).
 
 **L'idée de "configurable : false" est d'empêcher les changements d'indicateurs de propriété et sa suppression, tout en permettant de changer sa valeur.**
+=======
+We also can't change `Math.PI` to be `writable` again:
+
+```js run
+// Error, because of configurable: false
+Object.defineProperty(Math, "PI", { writable: true });
+```
+
+There's absolutely nothing we can do with `Math.PI`.
+
+Making a property non-configurable is a one-way road. We cannot change it back with `defineProperty`.
+
+**Please note: `configurable: false` prevents changes of property flags and its deletion, while allowing to change its value.**
+>>>>>>> 4d01fc20d4d82358e61518a31efe80dec9bb2602
 
 Ici, `user.name` n'est pas configurable, mais nous pouvons toujours le changer (car il est accessible en écriture) :
 
@@ -244,7 +271,7 @@ user.name = "Pete"; // works fine
 delete user.name; // Error
 ```
 
-And here we make `user.name` a "forever sealed" constant:
+And here we make `user.name` a "forever sealed" constant, just like the built-in `Math.PI`:
 
 ```js run
 let user = {
@@ -263,10 +290,19 @@ delete user.name;
 Object.defineProperty(user, "name", { value: "Pete" });
 ```
 
+```smart header="The only attribute change possible: writable true -> false"
+There's a minor exception about changing flags.
+
+We can change `writable: true` to `false` for a non-configurable property, thus preventing its value modification (to add another layer of protection). Not the other way around though.
+```
 
 ## Object.defineProperties
 
+<<<<<<< HEAD
 Il y a une méthode [Object.defineProperties(obj, descriptors)](https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object/defineProperties) qui permet de définir plusieurs propriétés à la fois.
+=======
+There's a method [Object.defineProperties(obj, descriptors)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperties) that allows to define many properties at once.
+>>>>>>> 4d01fc20d4d82358e61518a31efe80dec9bb2602
 
 La syntaxe est la suivante:
 
@@ -292,7 +328,11 @@ Nous pouvons donc définir plusieurs propriétés à la fois.
 
 ## Object.getOwnPropertyDescriptors
 
+<<<<<<< HEAD
 Pour obtenir tous les descripteurs de propriété à la fois, nous pouvons utiliser la méthode [Object.getOwnPropertyDescriptors(obj)](https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object/getOwnPropertyDescriptors).
+=======
+To get all property descriptors at once, we can use the method [Object.getOwnPropertyDescriptors(obj)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyDescriptors).
+>>>>>>> 4d01fc20d4d82358e61518a31efe80dec9bb2602
 
 Avec `Object.defineProperties`, elle peut être utilisé comme moyen de cloner un objet conscient des attributs:
 
@@ -318,6 +358,7 @@ Les descripteurs de propriété fonctionnent au niveau des propriétés individu
 
 Il existe également des méthodes qui limitent l'accès à l'objet *entier*:
 
+<<<<<<< HEAD
 [Object.preventExtensions(obj)](https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object/preventExtensions)
 : Interdit l'ajout de nouvelles propriétés à l'objet.
 
@@ -326,9 +367,20 @@ Il existe également des méthodes qui limitent l'accès à l'objet *entier*:
 
 [Object.freeze(obj)](https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object/freeze)
 : Interdit l'ajout/la suppression/la modification de propriétés. Définit `configurable: false, writeable: false` pour toutes les propriétés existantes.
+=======
+[Object.preventExtensions(obj)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/preventExtensions)
+: Forbids the addition of new properties to the object.
+
+[Object.seal(obj)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/seal)
+: Forbids adding/removing of properties. Sets `configurable: false` for all existing properties.
+
+[Object.freeze(obj)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/freeze)
+: Forbids adding/removing/changing of properties. Sets `configurable: false, writable: false` for all existing properties.
+>>>>>>> 4d01fc20d4d82358e61518a31efe80dec9bb2602
 
 Et aussi il y a des tests pour eux:
 
+<<<<<<< HEAD
 [Object.isExtensible(obj)](https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object/isExtensible)
 : Retourne `false` si l'ajout de propriétés est interdit, sinon `true`.
 
@@ -337,5 +389,15 @@ Et aussi il y a des tests pour eux:
 
 [Object.isFrozen(obj)](https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object/isFrozen)
 : Retourne `true` si l'ajout/la suppression/la modification de propriétés est interdite et si toutes les propriétés actuelles sont `configurable: false, writable: false`.
+=======
+[Object.isExtensible(obj)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/isExtensible)
+: Returns `false` if adding properties is forbidden, otherwise `true`.
+
+[Object.isSealed(obj)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/isSealed)
+: Returns `true` if adding/removing properties is forbidden, and all existing properties have `configurable: false`.
+
+[Object.isFrozen(obj)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/isFrozen)
+: Returns `true` if adding/removing/changing properties is forbidden, and all current properties are `configurable: false, writable: false`.
+>>>>>>> 4d01fc20d4d82358e61518a31efe80dec9bb2602
 
 Ces méthodes sont rarement utilisées dans la pratique.

1-js/10-error-handling/2-custom-errors/article.md

@@ -21,9 +21,15 @@ En interne, nous utiliserons `JSON.parse`. S'il reçoit un `json` malformé, il
 
 Notre fonction `readUser(json)` va non seulement lire JSON, mais aussi vérifier ("valider") les données. S'il n'y a pas de champs obligatoires ou si le format est incorrect, c'est une erreur. Et ce n’est pas une `SyntaxError`, car les données sont syntaxiquement correctes, mais un autre type d’erreur. Nous l'appellerons `ValidationError` et créerons une classe pour cela. Une erreur de ce type devrait également comporter des informations sur le champ fautif.
 
+<<<<<<< HEAD
 Notre classe `ValidationError` devrait hériter de la classe `Error` intégrée.
 
 Cette classe est intégrée, voici le code approximatif, pour que nous comprenions ce que nous étendons:
+=======
+Our `ValidationError` class should inherit from the `Error` class.
+
+The `Error` class is built-in, but here's its approximate code so we can understand what we're extending:
+>>>>>>> 4d01fc20d4d82358e61518a31efe80dec9bb2602
 
 ```js
 // Le "pseudocode" pour la classe d'erreur intégrée définie par JavaScript lui-même
@@ -117,15 +123,23 @@ Nous pourrions aussi regarder `err.name`, comme ceci:
 // au lieu de (err instanceof SyntaxError)
 } else if (err.name == "SyntaxError") { // (*)
 // ...
-```  
+```
 
 La version `instanceof` est bien meilleure, car dans le futur nous allons étendre `ValidationError`, en créer des sous-types, comme `PropertyRequiredError`. Et `instanceof` check continuera à fonctionner pour les nouvelles classes héritées. Donc, c'est à l'épreuve du futur.
 
+<<<<<<< HEAD
 De plus, il est important que si `catch` rencontre une erreur inconnue, il la propage, comme à la ligne `(**)`. Le bloc `catch` ne sait que gérer les erreurs de validation et de syntaxe, d'autres types (dus à une faute de frappe dans le code ou à d'autres inconnus) devraient "tomber".
+=======
+Also it's important that if `catch` meets an unknown error, then it rethrows it in the line `(**)`. The `catch` block only knows how to handle validation and syntax errors, other kinds (caused by a typo in the code or other unknown reasons) should fall through.
+>>>>>>> 4d01fc20d4d82358e61518a31efe80dec9bb2602
 
 ## Héritage complémentaire
 
+<<<<<<< HEAD
 La classe `ValidationError` est très générique. Beaucoup de choses peuvent mal se passer. La propriété peut être absente ou dans un format incorrect (comme une valeur de chaîne pour `age`). Faisons une classe plus concrète `PropertyRequiredError`, exactement pour les propriétés absentes. Il contiendra des informations supplémentaires sur la propriété qui manque.
+=======
+The `ValidationError` class is very generic. Many things may go wrong. The property may be absent or it may be in a wrong format (like a string value for `age` instead of a number). Let's make a more concrete class `PropertyRequiredError`, exactly for absent properties. It will carry additional information about the property that's missing.
+>>>>>>> 4d01fc20d4d82358e61518a31efe80dec9bb2602
 
 ```js run
 class ValidationError extends Error {