Fix typos

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

@@ -6,7 +6,7 @@ Voyons ce qui est spécial à propos de JavaScript, ce qu'il nous permet de fair
 
 ## Qu'est-ce que JavaScript ?
 
-_JavaScript_ a été initiallement créé pour "rendre les pages web vivantes".
+_JavaScript_ a été initialement créé pour "rendre les pages web vivantes".
 
 Les programmes dans ce langage sont appelés _scripts_. Ils peuvent être écrits directement dans une page HTML et exécutés automatiquement au chargement des pages.
 

1-js/01-getting-started/3-code-editors/article.md

@@ -29,7 +29,7 @@ Ils sont principalement utilisés pour ouvrir et éditer instantanément un fich
 
 La principale différence entre un "éditeur léger" et un "IDE" réside dans le fait qu’un environnement de développement intégré fonctionne au niveau du projet. Il charge donc beaucoup plus de données au démarrage, analyse la structure du projet si nécessaire, etc. Un éditeur léger est beaucoup plus rapide si nous avons besoin d'un seul fichier.
 
-En pratique, les éditeurs légers peuvent avoir beaucoup de plug-ins, y compris des analyseurs de syntaxe au niveau des répertoires et des autocompléteurs. Il n’ya donc pas de frontière stricte entre un éditeur léger et un IDE.
+En pratique, les éditeurs légers peuvent avoir beaucoup de plug-ins, y compris des analyseurs de syntaxe au niveau des répertoires et des autocompléteurs. Il n’y a donc pas de frontière stricte entre un éditeur léger et un IDE.
 
 Il existe de nombreuses options, par exemple :
 

1-js/01-getting-started/4-devtools/article.md

@@ -62,7 +62,7 @@ Maintenant `key:Cmd+Opt+C` peut activer la console. Notez également que le nouv
 ## Résumé
 
 - Les outils de développement nous permettent de voir les erreurs, d'exécuter des commandes, d'examiner des variables et bien plus encore.
-- Ils peuvent être ouverts avec `key:F12` pour la plupart des navigateurs sous Windows. Chrome pour Mac necessite la combinaison `key:Cmd+Opt+J`, Safari: `key:Cmd+Opt+C` (doit être activé avant).
+- Ils peuvent être ouverts avec `key:F12` pour la plupart des navigateurs sous Windows. Chrome pour Mac nécessite la combinaison `key:Cmd+Opt+J`, Safari: `key:Cmd+Opt+C` (doit être activé avant).
 
 
 Nous avons maintenant notre environnement prêt. Dans la section suivante, nous passerons à JavaScript.

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

@@ -48,7 +48,7 @@ La balise `<script>` contient du code JavaScript qui est automatiquement exécut
 La balise `<script>` a quelques attributs qui sont rarement utilisés de nos jours, mais nous pouvons les trouver dans l'ancien code :
 
  L'attribut `type` : <code>&lt;script <u>type</u>=...&gt;</code>
-: L’ancien standard HTML4, nécessitait pour chaque script d'avoir un `type`. Habiutellement c'était `type="text/javascript"`. Dorénavant ce n’est plus nécessaire. De plus, le standard HTML moderne a totalement changé la signification de cet attribut. Maintenant, il peut être utilisé pour les modules JavaScript. Mais c’est un sujet avancé, nous parlerons de modules dans une autre partie du tutoriel.
+: L’ancien standard HTML4, nécessitait pour chaque script d'avoir un `type`. Habituellement c'était `type="text/javascript"`. Dorénavant ce n’est plus nécessaire. De plus, le standard HTML moderne a totalement changé la signification de cet attribut. Maintenant, il peut être utilisé pour les modules JavaScript. Mais c’est un sujet avancé, nous parlerons de modules dans une autre partie du tutoriel.
 
 
  L'attribut `language` : <code>&lt;script <u>language</u>=...&gt;</code>
@@ -76,7 +76,7 @@ Le fichier de script est attaché à HTML avec l'attribut `src` :
 <script src="/chemin/vers/script.js"></script>
 ```
 
-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.
+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 courant.
 
 Nous pouvons également donner une URL complète, par exemple :
 
@@ -97,7 +97,7 @@ En règle générale, seuls les scripts les plus simples sont mis en HTML. Les p
 
 L’avantage d’un fichier séparé est que le navigateur le télécharge puis le stocke dans son [cache](https://fr.wikipedia.org/wiki/Cache_web).
 
-Après cela, les autres pages qui veulent le même script le récupèreront à partir du cache au lieu de le télécharger à nouveau. Le fichier n'est donc téléchargé qu'une seule fois.
+Après cela, les autres pages qui veulent le même script le récupéreront à partir du cache au lieu de le télécharger à nouveau. Le fichier n'est donc téléchargé qu'une seule fois.
 
 Cela économise du trafic et rend les pages plus rapides.
 ```

1-js/02-first-steps/03-strict-mode/article.md

@@ -8,7 +8,7 @@ Il en avait été ainsi jusqu'en 2009 lorsque ECMAScript 5 (ES5) est apparu. Il
 
 ## "use strict"
 
-La directive ressemble à une chaînede caractères : `"use strict"` ou `'use strict'`. Lorsqu'il se trouve en haut du script, l'ensemble du script fonctionne de manière "moderne".
+La directive ressemble à une chaîne de caractères : `"use strict"` ou `'use strict'`. Lorsqu'il se trouve en haut du script, l'ensemble du script fonctionne de manière "moderne".
 
 Par exemple
 

1-js/02-first-steps/05-types/article.md

@@ -28,7 +28,7 @@ Il existe de nombreuses opérations pour les nombres, par ex. multiplication `*`
 
 Outre les nombres réguliers, il existe des "valeurs numériques spéciales" qui appartiennent également à ce type: `Infinity`, `-Infinity` et `NaN`.
 
-- `Infinity` répresente l'[Infini](https://fr.wikipedia.org/wiki/Infini) ∞ mathématique. C'est une valeur spéciale qui est plus grande que n'importe quel nombre.
+- `Infinity` représente l'[Infini](https://fr.wikipedia.org/wiki/Infini) ∞ mathématique. C'est une valeur spéciale qui est plus grande que n'importe quel nombre.
 
     Nous pouvons l'obtenir à la suite d'une division par zéro :
 
@@ -128,7 +128,7 @@ let name = "John";
 // une variable encapsulée
 alert( `Hello, *!*${name}*/!*!` ); // Hello, John!
 
-// une expression encapulée
+// une expression encapsulée
 alert( `the result is *!*${1 + 2}*/!*` ); // le résultat est 3
 ```
 
@@ -269,7 +269,7 @@ Vous pouvez également rencontrer une autre syntaxe : `typeof(x)`. C'est la mê
 
 Pour être clair : `typeof` est un opérateur, pas une fonction. Les parenthèses ici ne font pas partie de `typeof`. C'est le genre de parenthèses utilisées pour le regroupement mathématique.
 
-Habituellement, ces parenthèses contiennent une expression mathématique, telle que `(2 + 2)`, mais ici elles ne contiennent qu'un seul argument `(x)`. Syntaxiqement, ils permettent d'éviter un espace entre l'opérateur `typeof` et son argument, et certains aiment ça.
+Habituellement, ces parenthèses contiennent une expression mathématique, telle que `(2 + 2)`, mais ici elles ne contiennent qu'un seul argument `(x)`. Syntaxiquement, ils permettent d'éviter un espace entre l'opérateur `typeof` et son argument, et certains aiment ça.
 
 Certaines personnes préfèrent `typeof(x)`, bien que la syntaxe `typeof x` soit beaucoup plus courante.
 ```
@@ -293,6 +293,6 @@ L'opérateur `typeof` nous permet de voir quel type est stocké dans la variable
 
 - Généralement utilisé sous cette forme `typeof x`, mais `typeof(x)` est également possible.
 - Renvoie une chaîne de caractères avec le nom du type, comme `"string"`.
-- Pour `null` il renvoit `"object"` -- C’est une erreur dans le langage, ce n’est pas un objet en fait.
+- Pour `null` il renvoie `"object"` -- C’est une erreur dans le langage, ce n’est pas un objet en fait.
 
 Dans les chapitres suivants, nous nous concentrerons sur les valeurs primitives et une fois que nous les connaîtrons, nous passerons aux objets.

1-js/02-first-steps/08-operators/article.md

@@ -39,7 +39,7 @@ Les opérations mathématiques suivantes sont supportées :
 - Reste `%`,
 - Exponentiation `**`.
 
-Les quatre premières sont assez simples, tandis que `%` et `**` nécéssitent quelques explications.
+Les quatre premières sont assez simples, tandis que `%` et `**` nécessitent quelques explications.
 
 ### Reste % (Modulo)
 
@@ -129,7 +129,7 @@ alert( '6' / '2' ); // 3, convertit les deux opérandes en nombres
 
 Le plus `+` existe sous deux formes. La forme binaire que nous avons utilisée ci-dessus et la forme unaire.
 
-L’unaire plus ou, en d’autres termes, l’opérateur plus `+` appliqué à une seule valeur, ne fait rien avec les nombres, mais si l’opérande n’est pas un nombre, alors il est convertit en nombre.
+L’unaire plus ou, en d’autres termes, l’opérateur plus `+` appliqué à une seule valeur, ne fait rien avec les nombres, mais si l’opérande n’est pas un nombre, alors il est converti en nombre.
 
 Par exemple :
 
@@ -182,15 +182,15 @@ Pourquoi les plus unaires sont-ils appliqués aux valeurs avant les binaires ? C
 
 ## Précédence des opérateurs
 
-Si une expression a plusieurs opérateurs, l’ordre d’exécution est défini par leur *priorité* ou, en d’autres termes, il existe un ordre de priorité implicite entre les opérateurs.
+Si une expression à plusieurs opérateurs, l’ordre d’exécution est défini par leur *priorité* ou, en d’autres termes, il existe un ordre de priorité implicite entre les opérateurs.
 
 De l'école, nous savons tous que la multiplication dans l'expression `1 + 2 * 2` devrait être calculée avant l'addition. C’est exactement cela la précédence. La multiplication est dite avoir une *précédence supérieure* à l'addition.
 
 Les parenthèses outrepassent toute priorité, donc si nous ne sommes pas satisfaits de l'ordre par défaut, nous pouvons les utiliser, comme : `(1 + 2) * 2`.
 
 Il y a beaucoup d'opérateurs en JavaScript. Chaque opérateur a un numéro correspondant à sa priorité de précédence. Celui qui est plus haut sur le tableau s'exécute en premier. Si la priorité est la même, l'ordre d'exécution est de gauche à droite.
 
-Un extrait du [tableau de précédence](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence) (vous n'avez pas besoin de vous en souvenir, mais notez que les opérateurs unaires ont une prioritée plus élevée que les binaires correspondants) :
+Un extrait du [tableau de précédence](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence) (vous n'avez pas besoin de vous en souvenir, mais notez que les opérateurs unaires ont une priorité plus élevée que les binaires correspondants) :
 
 | Précédence | Nom             | Symbole |
 |------------|-----------------|---------|
@@ -341,7 +341,7 @@ Les opérateurs `++` et `--` peuvent être placés à la fois après et avant la
 - Lorsque l'opérateur va après la variable, cela s'appelle une "forme postfixe" : `counter++`.
 - La "forme préfixe" est celle où l'opérateur se place devant la variable : `++counter`.
 
-Ces deux operateurs font la même chose : augmenter le `counter` de `1`.
+Ces deux opérateurs font la même chose : augmenter le `counter` de `1`.
 
 Y a-t-il une différence ? Oui, mais nous ne pouvons le voir que si nous utilisons la valeur renvoyée de `++/--`.
 

1-js/02-first-steps/10-ifelse/article.md

@@ -181,9 +181,9 @@ alert( message );
 Il peut être difficile au début de comprendre ce qui se passe. Mais après un examen plus approfondi, nous constatons que ce n’est qu’une séquence de tests ordinaire.
 
 1. Le premier point d'interrogation vérifie si `age < 3`.
-2. Si vrai -- retourne `'Coucou bébé !'`, sinon il franchi les deux points `":"` et vérifie si `age < 18`.
-3. Si vrai -- retourne `'Salut !'`, sinon -- il franchi à nouveau les deux points suivants `":"` et vérifie si `age < 100`.
-4. Si vrai -- retourne `'Salutations !'`, sinon -- il franchi enfin les derniers deux points `":"` et retourne `'Quel âge inhabituel !'`.
+2. Si vrai -- retourne `'Coucou bébé !'`, sinon il franchit les deux points `":"` et vérifie si `age < 18`.
+3. Si vrai -- retourne `'Salut !'`, sinon -- il franchit à nouveau les deux points suivants `":"` et vérifie si `age < 100`.
+4. Si vrai -- retourne `'Salutations !'`, sinon -- il franchit enfin les derniers deux points `":"` et retourne `'Quel âge inhabituel !'`.
 
 La même logique utilisant `if..else` :
 

1-js/02-first-steps/11-logical-operators/article.md

@@ -70,7 +70,7 @@ La logique décrite ci-dessus est quelque peu classique. Maintenant, apportons l
 
 L'algorithme étendu fonctionne comme suit.
 
-En cas de mutiples valeurs liées par OR :
+En cas de multiples valeurs liées par OR :
 
 ```js
 result = value1 || value2 || value3;
@@ -79,7 +79,7 @@ result = value1 || value2 || value3;
 L'opérateur OR `||` fait ce qui suit :
 
 - Évaluez les opérandes de gauche à droite.
-- Pour chaque opérande, il le converti en booléen. Si le résultat est `true`, arrêtez et retournez la valeur d'origine de cet opérande.
+- Pour chaque opérande, il le convertit en booléen. Si le résultat est `true`, arrêtez et retournez la valeur d'origine de cet opérande.
 - Si tous les autres opérandes ont été évalués (c’est-à-dire que tous étaient `false`), renvoyez le dernier opérande.
 
 Une valeur est renvoyée sous sa forme d'origine, sans conversion.
@@ -184,7 +184,7 @@ result = value1 && value2 && value3;
 L'opérateur AND `&&` effectue les opérations suivantes :
 
 - Évalue les opérandes de gauche à droite.
-- Pour chaque opérande, il le converti en booléen. Si le résultat est `false`, arrêtez et retournez la valeur d'origine de cet opérande.
+- Pour chaque opérande, il le convertit en booléen. Si le résultat est `false`, arrêtez et retournez la valeur d'origine de cet opérande.
 - Si tous les autres opérandes ont été évalués (c’est-à-dire tous étaient vrais), retournez le dernier opérande.
 
 En d'autres termes, une chaîne de AND `&&` renvoie la première valeur `false` ou la dernière valeur si aucune valeur `false` n'a été trouvée.

1-js/02-first-steps/12-nullish-coalescing-operator/article.md

@@ -37,7 +37,7 @@ Voici l'exemple avec `user` attribué à un nom :
 ```js run
 let user = "John";
 
-alert(user ?? "Anonymous"); // John (user is not null/udefined)
+alert(user ?? "Anonymous"); // John (user is not null/undefined)
 ```
 
 Nous pouvons également utiliser une séquence de `??` pour sélectionner la première valeur dans une liste qui n'est pas `null`/`undefined`.

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

@@ -372,7 +372,7 @@ outer:
 for (let i = 0; i < 3; i++) { ... }
 ```
 
-La directive `continue` peut également être utilisée avec un label. Dans ce cas, l'exécution passe à l'itération suivante de la boucle labelisée.
+La directive `continue` peut également être utilisée avec un label. Dans ce cas, l'exécution passe à l'itération suivante de la boucle labellisée.
 
 ````warn header="Les labels ne permettent pas de \"sauter\" n'importe où"
 Les labels ne nous permettent pas de sauter dans un endroit arbitraire du code.

1-js/02-first-steps/14-switch/article.md

@@ -140,7 +140,7 @@ switch (a) {
 
 Maintenant, les `3` et `5` affichent le même message.
 
-La possibilité de "grouper" les `case` est un effet secondaire de la façon dont le `switch/case` fonctionne sans `break`. Ici, l’exécution du `case 3` commence à partir de la ligne `(*)` et passe par le `case 5`, car il n’ya pas de `break`.
+La possibilité de "grouper" les `case` est un effet secondaire de la façon dont le `switch/case` fonctionne sans `break`. Ici, l’exécution du `case 3` commence à partir de la ligne `(*)` et passe par le `case 5`, car il n’y a pas de `break`.
 
 ## Le type compte
 

1-js/02-first-steps/17-arrow-functions-basics/article.md

@@ -8,7 +8,7 @@ Les "fonctions fléchées" sont appelées ainsi pour leur syntaxe :
 let func = (arg1, arg2, ..., argN) => expression;
 ```
 
-Cela va créér une function `func` qui accepte les arguments `arg1...argN`, puis évalue l'`expression` sur le côté droit et retourne le résultat.
+Cela va créer une function `func` qui accepte les arguments `arg1...argN`, puis évalue l'`expression` sur le côté droit et retourne le résultat.
 
 C'est donc la version raccourcie de :
 
@@ -33,7 +33,7 @@ let sum = function(a, b) {
 alert( sum(1, 2) ); // 3
 ```
 
-Comme vous pouvez le voir `(a, b) => a + b` représente une fonction qui accepte 2 arguments nommés `a` et `b`. Lors de l'éxécution, elle évalue l'expression `a + b` et retourne le résultat.
+Comme vous pouvez le voir `(a, b) => a + b` représente une fonction qui accepte 2 arguments nommés `a` et `b`. Lors de l'exécution, elle évalue l'expression `a + b` et retourne le résultat.
 
 - Pour un argument unique, alors les parenthèses autour du paramètre peuvent être omises, rendant la fonction encore plus courte.
 
@@ -72,13 +72,13 @@ welcome(); // ok now
 
 Les fonctions fléchées peuvent paraître étranges et peu lisibles au début, mais cela change rapidement avec les yeux s'habituant à cette structure.
 
-Elles sont très utile pour des actions sur une ligne et que l'on est juste paresseux d'écrire d'autres mots.
+Elles sont très utiles pour des actions sur une ligne et que l'on est juste paresseux d'écrire d'autres mots.
 
 ## Les fonctions fléchées multiligne
 
 Les fonctions fléchées que nous avons vues jusqu'à présent étaient très simples. Elles ont pris des arguments à gauche de `=>`, les ont évalués et ont renvoyé l'expression de droite avec elles.
 
-Parfois nous avons besoin de plus de compléxité, comme des expressions multiples ou des déclarations. Cela est possible avec des accolades les délimitant. Il faut ensuite utiliser un `return` à l'intérieur de celles-ci.
+Parfois nous avons besoin de plus de complexité, comme des expressions multiples ou des déclarations. Cela est possible avec des accolades les délimitant. Il faut ensuite utiliser un `return` à l'intérieur de celles-ci.
 
 Comme cela :
 
@@ -107,5 +107,5 @@ Pour l'instant, nous pouvons les utiliser pour des actions sur une ligne ou des
 
 Les fonctions fléchées sont pratiques pour des actions simples, en particulier pour les one-liners. Ils se déclinent en deux variantes :
 
-1. Sans accolades : `(...args) => expression` -- le coté droit est une expression : la fonction l'évalue et retourne le résultat. Les parenthèses peuvent être omises s'il n'y a qu'un seul argument, par ex. `n => n*2`.
+1. Sans accolades : `(...args) => expression` -- le côté droit est une expression : la fonction l'évalue et retourne le résultat. Les parenthèses peuvent être omises s'il n'y a qu'un seul argument, par ex. `n => n*2`.
 2. Avec accolades : `(...args) => { body }` -- les accolades nous permet des déclarations multiples au sein de la fonction, mais nous devons ajouter un `return` explicite pour retourner quelque chose.

2-ui/1-document/01-browser-environment/article.md

@@ -63,7 +63,7 @@ CSSOM est utilisé avec DOM lorsque nous modifions les règles de style du docum
 
 ## BOM (Browser Object Model)
 
-Le modèle d'objet du navigateur (BOM en anglais) contient des objets supplémentaire fourni par le navigateur (l'environnement hôte) pour travailler avec tout à l'exception du document.
+Le modèle d'objet du navigateur (BOM en anglais) contient des objets supplémentaires fournis par le navigateur (l'environnement hôte) pour travailler avec tout à l'exception du document.
 
 Par exemple :
 
@@ -95,7 +95,7 @@ La spécification DOM
 : Décrit la structure du document, ses manipulations et événements, voir <https://dom.spec.whatwg.org>.
 
 La spécification CSSOM
-: Décrit les feuilles de style et les régles de style, les manipulations de style les impliquant et leur liaisons aux documents, voir <https://www.w3.org/TR/cssom-1/>.
+: Décrit les feuilles de style et les règles de style, les manipulations de style les impliquant et leur liaisons aux documents, voir <https://www.w3.org/TR/cssom-1/>.
 
 Spécification HTML
 : Décrit le langage HTML (c'est à dire les balises) mais également le BOM (modèle d'objet du navigateur) -- diverses fonctions du navigateur : `setTimeout`, `alert`, `location` etc, voir <https://html.spec.whatwg.org>. Il récupère la spécification DOM et l'étend avec de nombreuses propriétés et méthodes additionnelles.