Merge pull request #342 from HachemiH/master

Conflicts fixed after sync with upstream @ 4541b7a

Author: HachemiH

1-js/01-getting-started/1-intro/article.md

@@ -61,13 +61,9 @@ Par exemple, JavaScript dans le navigateur est capable de :
 
 ## Qu'est-ce que JavaScript ne peut pas faire dans le navigateur ?
 
-Les capacités de JavaScript dans le navigateur sont limitées pour la sécurité de l'utilisateur. L'objectif est d'empêcher une page Web malfaisante d'accéder à des informations privées ou de nuire aux données de l'utilisateur.
+Les capacités de JavaScript dans le navigateur sont limitées pour la sécurité de l'utilisateur. L'objectif est d'empêcher une page Web malveillante d'accéder à des informations privées ou de nuire aux données de l'utilisateur.
 
-<<<<<<< HEAD
 Les exemples de telles restrictions sont:
-=======
-JavaScript's abilities in the browser are limited for the sake of a user's safety. The aim is to prevent an evil webpage from accessing private information or harming the user's data.
->>>>>>> 4541b7af7584014a676da731f6e8774da5e059f6
 
 - JavaScript sur une page Web ne peut pas lire/écrire des fichiers arbitrairement sur le disque dur, les copier ou exécuter des programmes. Il n'a pas d'accès direct aux fonctions du système d'exploitation.
 
@@ -92,15 +88,9 @@ De telles limites n'existent pas si JavaScript est utilisé en dehors du navigat
 Il y a au moins trois bonnes choses à propos de JavaScript:
 
 ```compare
-<<<<<<< HEAD
 + Intégration complète avec HTML / CSS.
 + Les choses simples sont faites simplement.
 + Pris en charge par tous les principaux navigateurs et activé par défaut.
-=======
-+ Full integration with HTML/CSS.
-+ Simple things are done simply.
-+ Supported by all major browsers and enabled by default.
->>>>>>> 4541b7af7584014a676da731f6e8774da5e059f6
 ```
 
 JavaScript est la seule technologie de navigateur qui combine ces trois éléments.
@@ -132,12 +122,6 @@ Il en existe évidemment bien plus, cela dit, même si nous utilisons un de ces
 
 ## Résumé
 
-<<<<<<< HEAD
 - JavaScript a été initialement créé en tant que langage de navigateur uniquement, mais il est désormais également utilisé dans de nombreux autres environnements.
 - En ce moment, JavaScript occupe une position unique en tant que langage de navigateur le plus largement adopté avec une intégration complète avec HTML/CSS.
 - De nombreux langages sont "transpilés" en JavaScript et fournissent certaines fonctionnalités. Il est recommandé d'y jeter un coup d'œil, au moins brièvement, après avoir maîtrisé JavaScript.
-=======
-- JavaScript was initially created as a browser-only language, but it is now used in many other environments as well.
-- Today, JavaScript has a unique position as the most widely-adopted browser language, fully integrated with HTML/CSS.
-- There are many languages that get "transpiled" to JavaScript and provide certain features. It is recommended to take a look at them, at least briefly, after mastering JavaScript.
->>>>>>> 4541b7af7584014a676da731f6e8774da5e059f6

1-js/02-first-steps/01-hello-world/article.md

@@ -76,11 +76,7 @@ Le fichier de script est attaché à HTML avec l'attribut `src` :
 <script src="/chemin/vers/script.js"></script>
 ```
 
-<<<<<<< HEAD
 Ici, `/chemin/vers/script.js` est un chemin absolu du script depuis la racine du site. On peut également fournir un chemin relatif à partir de la page en cours. Par exemple `src="script.js"` signifierait un fichier `"script.js"` dans le dossier courrant.
-=======
-Here, `/path/to/script.js` is an absolute path to the script from the site root. One can also provide a relative path from the current page. For instance, `src="script.js"`, just like `src="./script.js"`, would mean a file `"script.js"` in the current folder.
->>>>>>> 4541b7af7584014a676da731f6e8774da5e059f6
 
 Nous pouvons également donner une URL complète, par exemple :
 

1-js/05-data-types/03-string/article.md

@@ -79,31 +79,17 @@ Il existe d'autres caractères "spéciaux" moins courants.
 
 Voici la liste complète :
 
-<<<<<<< HEAD
 | Caractère                                          | Description                                                                                                                                                                                      |
 |----------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
 | `\n`                                               | Nouvelle ligne                                                                                                                                                                                   |
-| `\r`                                               | Retour chariot: non utilisé seul. Les fichiers texte Windows utilisent une combinaison de deux caractères `\r\n` pour représenter un saut de ligne.                                              |
+| `\r`                                               | Dans les fichiers texte Windows, une combinaison de deux caractères `\r\n` représente une nouvelle pause, tandis que sur un système d'exploitation non Windows, il s'agit simplement de `\n`. C'est pour des raisons historiques, la plupart des logiciels Windows comprennent également `\n`. |
 | `\'`, `\"`                                         | Quotes                                                                                                                                                                                           |
 | `\\`                                               | Backslash                                                                                                                                                                                        |
 | `\t`                                               | Tab                                                                                                                                                                                              |
 | `\b`, `\f`, `\v`                                   | Backspace, Form Feed, Vertical Tab -- conservés pour compatibilité, non utilisés de nos jours.                                                                                                   |
 | `\xXX`                                             | Caractère Unicode avec l'unicode hexadécimal donné `XX`, par exemple `'\x7A'` est le même que `'z'`.                                                                                             |
 | `\uXXXX`                                           | Un symbole Unicode avec le code hexadécimal `XXXX` en encodage UTF-16, par exemple `\u00A9` -- est un unicode pour le symbole de copyright `©`. Ce doit être exactement 4 chiffres hexadécimaux. |
 | `\u{X…XXXXXX}` (de 1 à 6 caractères hexadécimaux ) | Un symbole Unicode avec l'encodage UTF-32. Certains caractères rares sont encodés avec deux symboles Unicode, prenant 4 octets. De cette façon, nous pouvons insérer des codes longs.           |
-=======
-| Character | Description |
-|-----------|-------------|
-|`\n`|New line|
-|`\r`|In Windows text files a combination of two characters `\r\n` represents a new break, while on non-Windows OS it's just `\n`. That's for historical reasons, most Windows software also understands `\n`. |
-|`\'`, `\"`|Quotes|
-|`\\`|Backslash|
-|`\t`|Tab|
-|`\b`, `\f`, `\v`| Backspace, Form Feed, Vertical Tab -- kept for compatibility, not used nowadays. |
-|`\xXX`|Unicode character with the given hexadecimal Unicode `XX`, e.g. `'\x7A'` is the same as `'z'`.|
-|`\uXXXX`|A Unicode symbol with the hex code `XXXX` in UTF-16 encoding, for instance `\u00A9` -- is a Unicode for the copyright symbol `©`. It must be exactly 4 hex digits. |
-|`\u{X…XXXXXX}` (1 to 6 hex characters)|A Unicode symbol with the given UTF-32 encoding. Some rare characters are encoded with two Unicode symbols, taking 4 bytes. This way we can insert long codes. |
->>>>>>> 4541b7af7584014a676da731f6e8774da5e059f6
 
 Exemples avec unicode :
 

1-js/09-classes/06-instanceof/article.md

@@ -93,19 +93,11 @@ let rabbit = new Rabbit();
 alert(rabbit instanceof Animal); // true
 */!*
 
-<<<<<<< HEAD
-// rabbit.__proto__ === Rabbit.prototype
+// rabbit.__proto__ === Animal.prototype (no match)
 *!*
 // rabbit.__proto__.__proto__ === Animal.prototype (match!)
 */!*
 ```
-=======
-    // rabbit.__proto__ === Animal.prototype (no match)
-    *!*
-    // rabbit.__proto__.__proto__ === Animal.prototype (match!)
-    */!*
-    ```
->>>>>>> 4541b7af7584014a676da731f6e8774da5e059f6
 
 Voici l'illustration de ce que `rabbit instanceof Animal` compare avec `Animal.prototype`:
 

1-js/11-async/03-promise-chaining/article.md

@@ -34,19 +34,11 @@ new Promise(function(resolve, reject) {
 
 L'idée est que le résultat est transmis à travers la chaîne de gestionnaires `.then`.
 
-<<<<<<< HEAD
 Ici, le flux est :
 1. La promesse initiale est résolue en 1 seconde `(*)`,
 2. Ensuite, le gestionnaire `.then` est appelé `(**)`, qui à son tour crée une nouvelle promesse (résolue avec la valeur `2`).
-3. Le `then` suivant `(***)` obtient le résultat du précédent, le traite (double) et passe le gestionnaire suivant.
+3. Le `then` suivant `(***)` obtient le résultat du précédent, le traite (double) et le passe au gestionnaire suivant.
 4. ...et ainsi de suite.
-=======
-Here the flow is:
-1. The initial promise resolves in 1 second `(*)`,
-2. Then the `.then` handler is called `(**)`, which in turn creates a new promise (resolved with `2` value).
-3. The next `then` `(***)` gets the result of the previous one, processes it (doubles) and passes it to the next handler.
-4. ...and so on.
->>>>>>> 4541b7af7584014a676da731f6e8774da5e059f6
 
 Lorsque le résultat est transmis le long de la chaîne de gestionnaires, nous pouvons voir une séquence d'appels `alert`: `1` -> `2` -> `4`.
 

1-js/11-async/08-async-await/article.md

@@ -303,13 +303,8 @@ Le mot-clé `async` devant une fonction a deux effets:
 
 Le mot-clé `await` devant une promesse fait en sorte que JavaScript attende jusqu'à ce que cette promesse se règle, puis:
 
-<<<<<<< HEAD
 1. Si c'est une erreur, l'exception est générée - comme si `throw error` était appelé à cet endroit précis.
 2. Sinon, il renvoie le résultat.
-=======
-1. If it's an error, an exception is generated — same as if `throw error` were called at that very place.
-2. Otherwise, it returns the result.
->>>>>>> 4541b7af7584014a676da731f6e8774da5e059f6
 
 Ensemble, ils fournissent un cadre idéal pour écrire du code asynchrone facile à lire et à écrire.
 

1-js/13-modules/01-modules-intro/article.md

@@ -261,11 +261,7 @@ Comparez-le à des scripts sans module, là où il est un object global:
 
 Il existe également plusieurs différences de scripts spécifiques au navigateur avec `type="module"` par rapport aux scripts classiques.
 
-<<<<<<< HEAD
 Vous devriez peut-être ignorer cette section pour l'instant si vous lisez pour la première fois ou si vous n'utilisez pas JavaScript dans un navigateur.
-=======
-You may want to skip this section for now if you're reading for the first time, or if you don't use JavaScript in a browser.
->>>>>>> 4541b7af7584014a676da731f6e8774da5e059f6
 
 ### Les modules sont différés
 

2-ui/1-document/05-basic-dom-node-properties/article.md

@@ -18,27 +18,16 @@ Voici l'image, les explications à suivre :
 
 Les classes sont :
 
-<<<<<<< HEAD
 - [EventTarget](https://dom.spec.whatwg.org/#eventtarget) -- est la classe racine "abstraite". Les objets de cette classe ne sont jamais créés. Il sert de base, de sorte que tous les nœuds DOM prennent en charge les soi-disant "événements", nous les étudierons plus tard.
 - [Node](http://dom.spec.whatwg.org/#interface-node) -- est également une classe "abstraite", servant de base aux nœuds DOM. Elle fournit la fonctionnalité d'arborescence de base : `parentNode`, `nextSibling`, `childNodes` et ainsi de suite (ce sont des getters). Les objets de la classe `Node` ne sont jamais créés. Mais il existe des classes de nœuds concrets qui en héritent, à savoir: `Text` pour les nœuds texte, `Element` pour les nœuds élément et plus exotiques comme `Comment` pour les nœuds commentaire.
 - [Element](http://dom.spec.whatwg.org/#interface-element) -- est une classe de base pour les éléments DOM. Elle fournit une navigation au niveau des éléments comme `nextElementSibling`, `children` et des méthodes de recherche comme `getElementsByTagName`, `querySelector`. Un navigateur prend en charge non seulement HTML, mais aussi XML et SVG. La classe `Element` sert de base à des classes plus spécifiques : `SVGElement`, `XMLElement` et `HTMLElement`.
 - [HTMLElement](https://html.spec.whatwg.org/multipage/dom.html#htmlelement) -- est enfin la classe de base pour tous les éléments HTML. Elle est héritée d'éléments concrets HTML :
     - [HTMLInputElement](https://html.spec.whatwg.org/multipage/forms.html#htmlinputelement) -- la classe pour les éléments `<input>`,
     - [HTMLBodyElement](https://html.spec.whatwg.org/multipage/semantics.html#htmlbodyelement) -- la classe pour les éléments `<body>`,
     - [HTMLAnchorElement](https://html.spec.whatwg.org/multipage/semantics.html#htmlanchorelement) -- la classe pour les éléments `<a>`,
-    - ...et ainsi de suite, chaque balise a sa propre classe qui peut fournir des propriétés et des méthodes spécifiques.
-=======
-- [EventTarget](https://dom.spec.whatwg.org/#eventtarget) -- is the root "abstract" class. Objects of that class are never created. It serves as a base, so that all DOM nodes support so-called "events", we'll study them later.
-- [Node](http://dom.spec.whatwg.org/#interface-node) -- is also an "abstract" class, serving as a base  for DOM nodes. It provides the core tree functionality: `parentNode`, `nextSibling`, `childNodes` and so on (they are getters). Objects of `Node` class are never created. But there are concrete node classes that inherit from it, namely: `Text` for text nodes, `Element` for element nodes and more exotic ones like `Comment` for comment nodes.
-- [Element](http://dom.spec.whatwg.org/#interface-element) -- is a base class for DOM elements. It provides element-level navigation like `nextElementSibling`, `children` and searching methods like `getElementsByTagName`, `querySelector`. A browser supports not only HTML, but also XML and SVG. The `Element` class serves as a base for more specific classes: `SVGElement`, `XMLElement` and `HTMLElement`.
-- [HTMLElement](https://html.spec.whatwg.org/multipage/dom.html#htmlelement) -- is finally the basic class for all HTML elements. It is inherited by concrete HTML elements:
-    - [HTMLInputElement](https://html.spec.whatwg.org/multipage/forms.html#htmlinputelement) -- the class for `<input>` elements,
-    - [HTMLBodyElement](https://html.spec.whatwg.org/multipage/semantics.html#htmlbodyelement) -- the class for `<body>` elements,
-    - [HTMLAnchorElement](https://html.spec.whatwg.org/multipage/semantics.html#htmlanchorelement) -- the class for `<a>` elements,
-    - ...and so on.
-
-There are many other tags with their own classes that may specific properties and methods, while some elements, such as `<span>`, `<section>`, `<article>` do not have any specific properties, so they are instances of `HTMLElement` class.
->>>>>>> 4541b7af7584014a676da731f6e8774da5e059f6
+    - ...et ainsi de suite.
+
+Il existe de nombreuses autres balises avec leurs propres classes qui peuvent des propriétés et des méthodes spécifiques, tandis que certains éléments, tels que `<span>`, `<section>`, `<article>` n'ont pas de propriétés spécifiques, ce sont donc des instances de la classe `HTMLElement`.
 
 Ainsi, l'ensemble complet des propriétés et des méthodes d'un nœud donné est le résultat de l'héritage.
 

2-ui/1-document/09-size-and-scroll/article.md

@@ -116,11 +116,7 @@ function isHidden(elem) {
 }
 ```
 
-<<<<<<< HEAD
 Veuillez noter qu'un `isHidden` renvoie `true` pour les éléments qui sont à l'écran, mais qui ont des tailles nulles (comme une `<div>` vide).
-=======
-Please note that such `isHidden` returns `true` for elements that are on-screen, but have zero sizes.
->>>>>>> 4541b7af7584014a676da731f6e8774da5e059f6
 ````
 
 ## clientTop/Left

2-ui/5-loading/02-script-async-defer/article.md

@@ -120,9 +120,9 @@ Donc, si nous avons plusieurs scripts `async`, ils peuvent s'exécuter dans n'im
 <p>...content after scripts...</p>
 ```
 
-1. Le contenu de la page apparaît immédiatement: `async` ne la bloque pas.
-2. `DOMContentLoaded` peut arriver soit avant ou après `async`, aucune garantie ici.
-3. Les scripts asynchrones n'attendent pas les uns les autres. Un script plus petit `small.js` passe en second, mais se charge probablement avant `long.js`, donc s'exécute en premier. C'est ce qu'on appelle une commande "load-first".
+- Le contenu de la page apparaît immédiatement: `async` ne la bloque pas.
+- `DOMContentLoaded` peut arriver soit avant ou après `async`, aucune garantie ici.
+- Les scripts asynchrones n'attendent pas les uns les autres. Un script plus petit `small.js` passe en second, mais se charge probablement avant `long.js`, donc s'exécute en premier. C'est ce qu'on appelle une commande "load-first".
 
 Les scripts asynchrones sont parfaits lorsque nous intégrons un script tiers indépendant dans la page: compteurs, publicités, etc., car ils ne dépendent pas de nos scripts et nos scripts ne doivent pas les attendre:
 
@@ -131,19 +131,14 @@ Les scripts asynchrones sont parfaits lorsque nous intégrons un script tiers in
 <script async src="https://google-analytics.com/analytics.js"></script>
 ```
 
-<<<<<<< HEAD
-=======
-```smart header="The `async` attribute is only for external scripts"
-Just like `defer`, the `async` attribute is ignored if the `<script>` tag has no `src`.
+```smart header="L'attribut `async` est uniquement pour les scripts externes"
+Tout comme `defer`, l'attribut `async` est ignoré si la balise `<script>` n'a pas de `src`.
 ```
 
-## Dynamic scripts
-
-There's one more important way of adding a script to the page.
->>>>>>> 4541b7af7584014a676da731f6e8774da5e059f6
-
 ## Les scripts dynamiques
 
+Il existe un autre moyen important d'ajouter un script à la page.
+
 Nous pouvons également ajouter un script dynamiquement en utilisant JavaScript:
 
 ```js run
@@ -197,17 +192,11 @@ Mais il existe également des différences essentielles entre eux:
 
 |         | L'ordre | `DOMContentLoaded` |
 |---------|---------|---------|
-<<<<<<< HEAD
 | `async` | *Load-first*. Leur ordre dans le document n'a pas d'importance -- premier chargé, premier exécuté |  Sans importance. Peut se charger et s'exécuter alors que le document n'a pas encore été entièrement téléchargé. Cela se produit si les scripts sont petits ou mis en cache et que le document est suffisamment long. |
-| `defer` | *L'ordre du Document*. |  Exécute après le chargement et l'analyse du document (ils attendent si nécessaire), juste avant `DOMContentLoaded`. |
-=======
-| `async` | *Load-first order*. Their document order doesn't matter -- which loads first runs first |  Irrelevant. May load and execute while the document has not yet been fully downloaded. That happens if scripts are small or cached, and the document is long enough. |
-| `defer` | *Document order* (as they go in the document). |  Execute after the document is loaded and parsed (they wait if needed), right before `DOMContentLoaded`. |
-
-In practice, `defer` is used for scripts that need the whole DOM and/or their relative execution order is important.
->>>>>>> 4541b7af7584014a676da731f6e8774da5e059f6
+| `defer` | *Ordre de document* (tel qu'il apparaît dans le document).|  Exécute après le chargement et l'analyse du document (ils attendent si nécessaire), juste avant `DOMContentLoaded`. |
 
 En pratique, `defer` est utilisé pour les scripts qui ont besoin de tout le DOM et/ou leur ordre d'exécution relatif est important.
+
 Et `async` est utilisé pour des scripts indépendants, comme des compteurs ou des publicités. Et leur ordre d'exécution relatif n'a pas d'importance.
 
 ```warn header="La page sans scripts devrait être utilisable"