Merge pull request #107 from HachemiH/master

Conflicts fixed after sync with upstream @ 71ff8f8

Author: HachemiH

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

@@ -153,19 +153,11 @@ L'algorithme de base de la récupération de place (garbage collection) s'appell
 
 Les étapes suivantes du "ramasse-miettes" (garbage collection) sont régulièrement effectuées :
 
-<<<<<<< HEAD
-- Le ramasse-miettes prend des racines et les "marque" (se souvient).
+- Le ramasse-miettes prend les racines et les "marque" (se souvient).
 - Ensuite, il visite et "marque" toutes les références.
 - Ensuite, il visite les objets marqués et marque *leurs* références. Tous les objets visités sont mémorisés afin de ne pas visiter le même objet deux fois dans le futur.
 - … Et ainsi de suite tant qu'il y a des références non consultées (accessibles depuis les racines).
 - Tous les objets sont supprimés sauf ceux qui sont marqués.
-=======
-- The garbage collector takes roots and "marks" (remembers) them.
-- Then it visits and "marks" all references from them.
-- Then it visits marked objects and marks *their* references. All visited objects are remembered, so as not to visit the same object twice in the future.
-- ...And so on until every reachable (from the roots) references are visited.
-- All objects except marked ones are removed.
->>>>>>> 71ff8f81b05e2438a3c56507888e06c528a71182
 
 Par exemple, imaginons notre structure d'objet ressembler à ceci :
 
@@ -189,27 +181,17 @@ Désormais, les objets qui n'ont pas pu être visités sont considérés comme i
 
 ![](garbage-collection-5.svg)
 
-<<<<<<< HEAD
-C’est le concept de la façon dont le garbage collector fonctionne.
+Nous pouvons également imaginer que le processus consiste à renverser un énorme seau de peinture à la racine, qui traverse toutes les références et marque tous les objets accessibles. Les non marqués sont ensuite supprimés.
 
-Les moteurs JavaScript appliquent de nombreuses optimisations pour accélérer l’exécution et ne pas affecter l’exécution.
-=======
-We can also imagine the process as spilling a huge bucket of paint from the roots, that flows through all references and marks all reachable objects. The unmarked ones are then removed.
-
-That's the concept of how garbage collection works. JavaScript engines apply many optimizations to make it run faster and not affect the execution.
->>>>>>> 71ff8f81b05e2438a3c56507888e06c528a71182
+C'est le concept de la façon dont la garbage collection fonctionne. Les moteurs JavaScript appliquent de nombreuses optimisations pour accélérer l’exécution et ne pas affecter l’exécution.
 
 Certaines des optimisations :
 
 - **Collection générationnelle** -- les objets sont divisés en deux ensembles : les "nouveaux" et les "anciens". De nombreux objets apparaissent, font leur travail et meurent rapidement, ils peuvent être nettoyés de manière agressive. Ceux qui survivent assez longtemps deviennent "vieux" et sont examinés moins souvent.
 - **Collection incrémentale** -- s'il y a beaucoup d'objets et que nous essayons de circuler et de marquer le jeu d'objets entier en même temps, cela peut prendre un certain temps et introduire des retards visibles dans l'exécution. Le moteur essaie donc de scinder le garbage collection (ramassage de miettes) en morceaux. Ensuite, ces parties sont exécutées une par une, séparément. Cela nécessite une comptabilité supplémentaire entre elles pour suivre les changements, mais nous avons beaucoup de petits retards au lieu d'un gros.
 - **Collection par inactivité** -- le garbage collector tente de s'exécuter uniquement lorsque le processeur (CPU) est inactif, afin de réduire les conséquences sur l'exécution.
 
-<<<<<<< HEAD
 Il existe d'autres optimisations et variantes d'algorithmes de récupération de place. Même si je souhaite les décrire ici, je dois m'abstenir, car différents moteurs implémentent différentes techniques et ajustements. Et, ce qui est encore plus important, les choses changent à mesure que les moteurs se développent. Donc aller plus loin de manière plus poussée, sans réel besoin, n’en vaut probablement pas la peine. À moins, bien sûr, que ce soit une question qui vous intéresse vraiment, vous trouverez quelques liens pour vous ci-dessous.
-=======
-There exist other optimizations and flavours of garbage collection algorithms. As much as I'd like to describe them here, I have to hold off, because different engines implement different tweaks and techniques. And, what's even more important, things change as engines develop, so studying deeper "in advance", without a real need is probably not worth that. Unless, of course, it is a matter of pure interest, then there will be some links for you below.
->>>>>>> 71ff8f81b05e2438a3c56507888e06c528a71182
 
 ## Résumé
 

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

@@ -98,10 +98,4 @@ let doublePrices = Object.fromEntries(
 alert(doublePrices.meat); // 8
 ```   
 
-<<<<<<< HEAD
-Cela peut sembler difficile au premier abord, mais cela devient facile à comprendre après l’avoir utilisé une ou deux fois.
-
-De cette façon, nous pouvons créer de puissants one-liners pour des transformations plus complexes. Il est important de préserver l’équilibre pour que le code reste assez simple à comprendre.
-=======
-It may look difficult from the first sight, but becomes easy to understand after you use it once or twice. We can make powerful chains of transforms this way. 
->>>>>>> 71ff8f81b05e2438a3c56507888e06c528a71182
+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.

1-js/05-data-types/10-destructuring-assignment/article.md

@@ -356,11 +356,7 @@ Le problème est que JavaScript traite `{...}` dans le flux de code principal (p
 }
 ```
 
-<<<<<<< HEAD
-Donc ici, JavaScript suppose que nous avons un bloc de code, c'est pourquoi il y a une erreur. Nous avons la déstructuration à la place.
-=======
-So here JavaScript assumes that we have a code block, that's why there's an error. We want destructuring instead.
->>>>>>> 71ff8f81b05e2438a3c56507888e06c528a71182
+Donc ici, JavaScript suppose que nous avons un bloc de code, c'est pourquoi il y a une erreur. Nous voulons plutôt la déstructuration.
 
 Pour montrer à JavaScript qu'il ne s'agit pas d'un bloc de code, nous pouvons envelopper l'expression entre parenthèses `(...)` :
 

1-js/06-advanced-functions/01-recursion/article.md

@@ -185,17 +185,13 @@ Voici la pile de contexte lorsque nous sommes entrés dans le sous-appel `pow(2,
 
 Le nouveau contexte d'exécution actuel est en haut (et en gras) et les contextes précédemment mémorisés sont en dessous.
 
-<<<<<<< HEAD
-Quand on termine le sous-appel -- il est facile de reprendre le contexte précédent, car il conserve les deux variables et l'emplacement exact du code où il s'est arrêté. Ici, sur la photo, nous utilisons le mot "line", mais bien sûr, il est plus précis.
-=======
-When we finish the subcall -- it is easy to resume the previous context, because it keeps both variables and the exact place of the code where it stopped.
+Quand on termine le sous-appel -- il est facile de reprendre le contexte précédent, car il conserve les deux variables et l'emplacement exact du code où il s'est arrêté. 
 
 ```smart
-Here in the picture we use the word "line", as our example there's only one subcall in line, but generally a single line of code may contain multiple subcalls, like `pow(…) + pow(…) + somethingElse(…)`.
+Ici, dans l'image, nous utilisons le mot "ligne", comme dans notre exemple, il n'y a qu'un seul sous-appel en ligne, mais généralement une seule ligne de code peut contenir plusieurs sous-appels, comme `pow(…) + pow(…) + somethingElse(…)`.
 
-So it would be more precise to say that the execution resumes "immediately after the subcall".
+Il serait donc plus précis de dire que l'exécution reprend "immédiatement après le sous-appel".
 ```
->>>>>>> 71ff8f81b05e2438a3c56507888e06c528a71182
 
 ### pow(2, 1)
 

1-js/08-prototypes/03-native-prototypes/article.md

@@ -189,16 +189,8 @@ L'emprunt des méthodes est flexible, cela permet de mélanger la fonctionnalit
 
 ## Résumé
 
-<<<<<<< HEAD
 - Tous les objets intégrés suivent le même schéma:
     - Les méthodes sont stockées dans le prototype (`Array.prototype`, `Object.prototype`, `Date.prototype`, etc.).
     - L'objet lui-même ne stocke que les données (éléments de tableau, propriétés de l'objet, date).
 - Les primitives stockent également des méthodes dans des prototypes d'objets wrapper: `Number.prototype`, `String.prototype`, `Boolean.prototype`. Seuls `undefined` et `null` n'ont pas d'objets wrapper.
 - Les prototypes intégrés peuvent être modifiés ou remplis avec de nouvelles méthodes. Mais il n'est pas recommandé de les changer. La seule cause possible est probablement l’ajout d’un nouveau standard, mais pas encore pris en charge par la méthode JavaScript du moteur.
-=======
-- All built-in objects follow the same pattern:
-    - The methods are stored in the prototype (`Array.prototype`, `Object.prototype`, `Date.prototype` etc).
-    - The object itself stores only the data (array items, object properties, the date).
-- Primitives also store methods in prototypes of wrapper objects: `Number.prototype`, `String.prototype`, `Boolean.prototype`. Only `undefined` and `null` do not have wrapper objects.
-- Built-in prototypes can be modified or populated with new methods. But it's not recommended to change them. Probably the only allowable case is when we add-in a new standard, but not yet supported by the engine JavaScript method.
->>>>>>> 71ff8f81b05e2438a3c56507888e06c528a71182

1-js/08-prototypes/04-prototype-methods/article.md

@@ -28,11 +28,7 @@ let rabbit = Object.create(animal);
 alert(rabbit.eats); // true
 
 *!*
-<<<<<<< HEAD
-alert(Object.getPrototypeOf(rabbit) === animal); // obtenir le prototype de rabbit
-=======
 alert(Object.getPrototypeOf(rabbit) === animal); // true
->>>>>>> 71ff8f81b05e2438a3c56507888e06c528a71182
 */!*
 
 *!*
@@ -75,15 +71,9 @@ Pourquoi?
 
 C'est pour des raisons historiques.
 
-<<<<<<< HEAD
 - La propriété `"prototype"` d'une fonction constructeur fonctionne depuis très longtemps.
 - Plus tard dans l'année 2012 : `Object.create` est apparu dans le standard. Cela permettait de créer des objets avec le prototype donné, mais ne permettait pas d'y accéder/muter. Les navigateurs ont donc implémenté un accesseur non standard `__proto__` qui permettait d'accéder/muter un prototype à tout moment.
 - Plus tard, dans l'année 2015 : `Object.setPrototypeOf` et `Object.getPrototypeOf` ont été ajoutés dans le standard pour exécuter la même fonctionnalité que `__proto__`. Comme `__proto__` était implémenté de facto partout, il était en quelque sorte obsolète et passait à l'Annexe B de la norme, qui est facultative pour les environnements autres que les navigateurs.
-=======
-- The `"prototype"` property of a constructor function has worked since very ancient times.
-- Later, in the year 2012, `Object.create` appeared in the standard. It gave the ability to create objects with a given prototype, but did not provide the ability to get/set it. So browsers implemented the non-standard `__proto__` accessor that allowed the user to get/set a prototype at any time.
-- Later, in the year 2015, `Object.setPrototypeOf` and `Object.getPrototypeOf` were added to the standard, to perform the same functionality as `__proto__`. As `__proto__` was de-facto implemented everywhere, it was kind-of deprecated and made its way to the Annex B of the standard, that is: optional for non-browser environments.
->>>>>>> 71ff8f81b05e2438a3c56507888e06c528a71182
 
 Pour l'instant, nous avons tous ces moyens à notre disposition.
 

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

@@ -89,13 +89,9 @@ Ce que `class User {...}` la construction fait en réalité est de:
 1. Créer une fonction nommée `User`,  qui devient le résultat de la déclaration de la classe. Le code  de la fonction est tirée de la méthode `constructor` (considérée comme étant vide au cas ou cette méthode n'est pas écrite).
 2. Garde les méthodes de la classe, telle que `sayHi`, dans `User.prototype`.
 
-<<<<<<< HEAD
-Apres cela, pour les nouveaux objets  `new User`, lorsqu'on appelle une méthode, elle est prise à partir du prototype, ainsi qu'on vient juste de décrire dans le chapitre <info:function-prototype>. Ainsi l'objet a accès aux méthodes de la classe.
-=======
-After `new User` object is created, when we call its method, it's taken from the prototype, just as described in the chapter <info:function-prototype>. So the object has access to class methods.
+Après la création de `new User`, lorsque nous appelons sa méthode, elle est extraite du prototype, comme décrit dans le chapitre <info:function-prototype>. Donc, l'objet a accès aux méthodes de classe.
 
-We can illustrate the result of `class User` declaration as:
->>>>>>> 71ff8f81b05e2438a3c56507888e06c528a71182
+Nous pouvons illustrer le résultat de la déclaration de `class User` par :
 
 Nous pouvons illustrer le résultat de la déclaration de `class User` ainsi:
 ![](class-user.svg)
@@ -147,19 +143,11 @@ user.sayHi();
 
 Le résultat de cette définition est à peu près la même chose. Donc, il y a bien raison de vouloir considérer `class` comme pouvant être un sucre syntaxique pour définir un constructeur ensemble avec ses méthodes de prototype.
 
-<<<<<<< HEAD
-Bien qu’il y ait des différences importantes.
-=======
-Still, there are important differences.
->>>>>>> 71ff8f81b05e2438a3c56507888e06c528a71182
+Cependant, il existe des différences importantes.
 
 1. Tout d'abord, une fonction crée par une `classe` est labélisé par une propriété interne spéciale nommée `[[FunctionKind]]:"classConstructor"`. Donc ce n'est pas tout à fait la même chose que de la créer manuellement.
 
-<<<<<<< HEAD
-    Contrairement à une fonction normale, un constructeur de class doit être invoquée avec `new`:
-=======
-    And unlike a regular function, a class constructor must be called with `new`:
->>>>>>> 71ff8f81b05e2438a3c56507888e06c528a71182
+    Contrairement à une fonction normale, un constructeur de class doit être invoquée avec `new` :
 
     ```js run
     class User {

1-js/09-classes/02-class-inheritance/article.md

@@ -131,11 +131,7 @@ class Rabbit extends Animal {
 }
 ```
 
-<<<<<<< HEAD
 ...Mais en général, nous ne voulons pas remplacer totalement une méthode parente, mais plutôt construire dessus, modifier ou étendre ses fonctionnalités. Nous faisons quelque chose dans notre méthode, mais appelons la méthode parente avant / après ou dans le processus.
-=======
-...But usually we don't want to totally replace a parent method, but rather to build on top of it to tweak or extend its functionality. We do something in our method, but call the parent method before/after it or in the process.
->>>>>>> 71ff8f81b05e2438a3c56507888e06c528a71182
 
 Les classes fournissent le mot clé `"super"` pour cela.
 

1-js/09-classes/03-static-properties-methods/article.md

@@ -191,13 +191,8 @@ class Rabbit extends Animal {}
 // pour les méthodes statiques
 alert(Rabbit.__proto__ === Animal); // true
 
-<<<<<<< HEAD
 // pour les méthodes régulières
-alert(Rabbit.prototype.__proto__ === Animal.prototype);
-=======
-// for regular methods
 alert(Rabbit.prototype.__proto__ === Animal.prototype); // true
->>>>>>> 71ff8f81b05e2438a3c56507888e06c528a71182
 ```
 
 ## Résumé

1-js/09-classes/05-extend-natives/article.md

@@ -21,11 +21,7 @@ alert(filteredArr); // 10, 50
 alert(filteredArr.isEmpty()); // false
 ```
 
-<<<<<<< HEAD
-Noter une chose très intéressante. Les méthodes intégrées telles que `filter`, `map` et autres renvoient des nouveaux objets exactement du type hérité `PowerArray`. Leur implémentation interne utilise la propriété d'objet `constructor` pour cela.
-=======
-Please note a very interesting thing. Built-in methods like `filter`, `map` and others -- return new objects of exactly the inherited type `PowerArray`. Their internal implementation uses the object's `constructor` property for that.
->>>>>>> 71ff8f81b05e2438a3c56507888e06c528a71182
+Notez une chose très intéressante. Les méthodes intégrées telles que `filter`, `map` et autres renvoient des nouveaux objets exactement du type hérité `PowerArray`. Leur implémentation interne utilise la propriété d'objet `constructor` pour cela.
 
 Dans l'exemple ci-dessus,
 ```js
@@ -78,11 +74,7 @@ Les objets intégrés ont leurs propres méthodes statiques, par exemple `Object
 
 Comme nous le savons déjà, les classes natives s'étendent les uns des autres. Par exemple, `Array` extends `Object`.
 
-<<<<<<< HEAD
 Normalement, lorsqu'une classe en étend une autre, les méthodes statiques et non statiques sont héritées. Cela a été expliqué en détail dans le chapitre [](info:static-properties-methods#statics-and-inheritance).
-=======
-Normally, when one class extends another, both static and non-static methods are inherited. That was thoroughly explained in the article [](info:static-properties-methods#statics-and-inheritance).
->>>>>>> 71ff8f81b05e2438a3c56507888e06c528a71182
 
 Mais les classes intégrées sont une exception. Ils n'héritent pas les méthodes statiques les uns des autres.