Merge pull request #320 from HachemiH/master

Conflicts fixed after sync with upstream @ 4d01fc2

Author: HachemiH

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

@@ -24,11 +24,7 @@ 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
+message = 'Hello'; // stocke la chaîne de caractères 'Hello' dans la variable nommée message
 */!*
 ```
 

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

@@ -104,21 +104,12 @@ 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.                                            |
+| début     | `let 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
+| étape     | `i++`      | Exécute après le corps à chaque itération |
 
 
 L'algorithme de boucle général fonctionne comme ceci :
@@ -390,11 +381,7 @@ 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,11 +182,7 @@ 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
+Dans l'exemple ci-dessus, on pourrait dire : "la fonction `showMessage` est déclarée avec deux paramètres, puis appelée avec deux arguments : `from` et `"Hello"`".
 
 
 ## Les valeurs par défaut

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

@@ -4,11 +4,7 @@ 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
+Est-il possible de créer des fonctions `A` et `B` tel que `new A() == new B()` ?
 
 ```js no-beautify
 function A() { ... }

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

@@ -4,11 +4,7 @@ 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
+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 de manière précise <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>.
 
 Donc, ici, nous allons parler de chiffres réguliers. Augmentons nos connaissances à leur sujet.
 
@@ -58,11 +54,7 @@ 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
+Si nous comptons les zéros dans `0.000001`, il y en a 6. Donc logiquement, c'est `1e-6`.
 
 En d'autres termes, un nombre négatif après `"e"` signifie une division par 1 avec le nombre donné de zéros:
 
@@ -339,11 +331,7 @@ 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/09-keys-values-entries/article.md

@@ -75,15 +75,9 @@ 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`.
+2. Utilisons des méthodes de tableau sur ce tableau, par exemple `map`, pour transformer ces paires clé / valeur.
 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 :
 
@@ -96,22 +90,13 @@ 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
+  // convertir les prix en tableau, mapper chaque paire clé / valeur dans une autre paire
+  // puis fromEntries restitue l'objet
   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
+Cela peut sembler difficile au premier abord, mais cela 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.

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

@@ -4,11 +4,7 @@
 ```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
+Ce n'est pas ainsi que nous écrivons du nouveau code.
 ```
 
 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,11 +19,7 @@ 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 methode [Object.getOwnPropertyDescriptor](https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object/getOwnPropertyDescriptor) permet d'interroger les informations *complètes* à propos d'une propriété.
 
 La syntaxe est la suivante:
 ```js
@@ -58,11 +54,7 @@ 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:
 
@@ -202,11 +194,7 @@ 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
+Une propriété non configurable ne peut pas être supprimée, ses attributs ne peuvent pas être modifiés.
 
 Par exemple, `Math.PI` est en lecture seule, non énumérable et non configurable :
 
@@ -231,30 +219,18 @@ 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` :
-1. Impossible de changer le flag `configurable`.
-2. Impossible de changer le drapeau `enumerable`.
-3. Impossible de changer `writable: false` à `true` (l'inverse fonctionne).
-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:
+Nous ne pouvons pas non plus changer `Math.PI` pour qu'il soit à nouveau `writable` (éditable) :
 
 ```js run
-// Error, because of configurable: false
+// Error, parce que configurable: false
 Object.defineProperty(Math, "PI", { writable: true });
 ```
 
-There's absolutely nothing we can do with `Math.PI`.
+Il n'y a absolument rien que nous puissions faire avec `Math.PI`.
 
-Making a property non-configurable is a one-way road. We cannot change it back with `defineProperty`.
+Rendre une propriété non configurable est une voie à sens unique. Nous ne pouvons pas le modifier avec `defineProperty`.
 
-**Please note: `configurable: false` prevents changes of property flags and its deletion, while allowing to change its value.**
->>>>>>> 4d01fc20d4d82358e61518a31efe80dec9bb2602
+**Veuillez noter : `configurable: false` empêche les changements d'indicateurs de propriété et sa suppression, tout en permettant de changer sa valeur.**
 
 Ici, `user.name` n'est pas configurable, mais nous pouvons toujours le changer (car il est accessible en écriture) :
 
@@ -298,11 +274,7 @@ We can change `writable: true` to `false` for a non-configurable property, thus
 
 ## 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:
 
@@ -328,11 +300,7 @@ 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:
 
@@ -358,7 +326,6 @@ 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.
 
@@ -367,20 +334,9 @@ 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`.
 
@@ -389,15 +345,5 @@ 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.