Merge pull request #469 from ArmandDelessert/patch-2023-06-28

Corrige le terme 'language' en 'langage'

Author: HachemiH

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

@@ -15,7 +15,7 @@ Les scripts sont fournis et exécutés en texte brut. Ils n'ont pas besoin d'une
 De par cet aspect, JavaScript est très différent d'un autre langage appelé [Java](<https://fr.wikipedia.org/wiki/Java_(langage)>).
 
 ```smart header="Pourquoi est-il appelé <u>Java</u>Script ?"
-Quand Javascript a été créé, il portait initialement un autre nom : "LiveScript". Mais à cette époque le langage Java était très populaire, il a donc été décidé que positionner un nouveau langage en tant que "petit frère" de Java pourrait aider.
+Quand JavaScript a été créé, il portait initialement un autre nom : "LiveScript". Mais à cette époque le langage Java était très populaire, il a donc été décidé que positionner un nouveau langage en tant que "petit frère" de Java pourrait aider.
 
 Mais au fur et à mesure de son évolution, JavaScript est devenu un langage totalement indépendant, avec ses propres spécifications appelées [ECMAScript](https://fr.wikipedia.org/wiki/ECMAScript), aujourd'hui il n'a aucun rapport avec Java.
 ```

1-js/01-getting-started/index.md

@@ -1,3 +1,3 @@
 # Une introduction
 
-A propos du langage Javascript et de l'environnement pour le développeur.
+A propos du langage JavaScript et de l'environnement pour le développeur.

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

@@ -1,15 +1,15 @@
 # Hello, world!
- 
+
 <iframe width="560" height="315" src="https://www.youtube.com/embed/0WS0zqhT5fM" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
 
-Cette partie du tutoriel est à propos du coeur de JavaScript, le langage lui même. 
+Cette partie du tutoriel est à propos du coeur de JavaScript, le langage lui même.
 
 Mais nous avons besoin d'un environnement de travail pour exécuter nos scripts et, étant donné que ce guide est en ligne, le navigateur est un bon choix. Nous allons nous efforcer d'utiliser les commandes spécifiques au navigateur (comme `alert`) au minimum afin de ne pas y consacrer du temps si vous prévoyez de vous concentrer sur un autre environnement tel que Node.JS. Par ailleurs, les détails du navigateur sont expliqués dans [la partie suivante](/ui) du didacticiel.
 
 Alors, voyons d'abord comment intégrer un script à une page Web. Pour les environnements côté serveur, vous pouvez simplement l'exécuter avec une commande comme `"node mon.js"` pour Node.JS.
 
 
-## La balise "script" 
+## La balise "script"
 
 Les programmes JavaScript peuvent être insérés dans n'importe quelle partie d'un document HTML à l'aide de la balise `<script>`.
 
@@ -50,9 +50,8 @@ La balise `<script>` a quelques attributs qui sont rarement utilisés de nos jou
  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'attribut `language` : <code>&lt;script <u>language</u>=...&gt;</code>
-: Cet attribut était destiné à afficher la langue du script. Pour l'instant, cet attribut n'a aucun sens, le langage est le JavaScript par défaut. Pas besoin de l'utiliser.
+: Cet attribut était destiné à afficher le langage du script. Pour l'instant, cet attribut n'a aucun sens, le langage est le JavaScript par défaut. Pas besoin de l'utiliser.
 
 Commentaires avant et après les scripts.
 : Dans des livres et des guides vraiment anciens, on peut trouver des commentaires dans `<script>`, comme ceci :

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

@@ -41,6 +41,7 @@ Outre les nombres réguliers, il existe des "valeurs numériques spéciales" qui
     ```js run
     alert( Infinity ); // Infinity
     ```
+
 - `NaN` représente une erreur de calcul. C'est le résultat d'une opération mathématique incorrecte ou non définie, par exemple :
 
     ```js run
@@ -57,7 +58,6 @@ Outre les nombres réguliers, il existe des "valeurs numériques spéciales" qui
 
     Donc, s'il y a `NaN` quelque part dans une expression mathématique, il se propage à l'ensemble du résultat (il n'y a qu'une seule exception : `NaN ** 0` vaut `1`).
 
-
 ```smart header="Les opérations mathématiques sont sûres"
 Faire des maths est sans danger en JavaScript. Nous pouvons faire n'importe quoi : diviser par zéro, traiter les chaînes non numériques comme des nombres, etc.
 
@@ -135,14 +135,15 @@ alert( `the result is *!*${1 + 2}*/!*` ); // le résultat est 3
 L'expression à l'intérieur de `${…}` est évaluée et le résultat devient une partie de la chaîne. On peut y mettre n'importe quoi : une variable comme `name` ou une expression arithmétique comme `1 + 2` ou quelque chose de plus complexe.
 
 Veuillez noter que cela ne peut être fait que dans les backticks. Les autres guillemets ne permettent pas une telle intégration !
+
 ```js run
 alert( "the result is ${1 + 2}" ); // le résultat est ${1 + 2} (les doubles quotes ne font rien)
 ```
 
 Nous couvrirons les chaînes de caractères plus en détails dans le chapitre <info:string>.
 
 ```smart header="Il n'y a pas de type *character*."
-Dans certaines langues, il existe un type spécial "character" pour un seul caractère. Par exemple, en langage C et en Java, il s'agit de "char".
+Dans certains langages, il existe un type spécial "character" pour un seul caractère. Par exemple, en langage C et en Java, il s'agit de "char".
 
 En JavaScript, ce type n'existe pas. Il n'y a qu'un seul type: `string`. Une chaîne de caractères peut être composée de zéro caractère (être vide), d'un caractère ou de plusieurs d'entre eux.
 ```
@@ -170,7 +171,7 @@ alert( isGreater ); // true (le résultat de la comparaison est "oui")
 
 Nous couvrirons plus profondément les booléens plus tard dans le chapitre <info:logical-operators>.
 
-## La valeur "null" 
+## La valeur "null"
 
 La valeur spéciale `null` n'appartient à aucun type de ceux décrits ci-dessus.
 
@@ -186,7 +187,7 @@ C’est juste une valeur spéciale qui a le sens de "rien", "vide" ou "valeur in
 
 Le code ci-dessus indique que l'`age` est inconnu.
 
-## La valeur "undefined" 
+## La valeur "undefined"
 
 La valeur spéciale `undefined` se distingue des autres. C'est un type à part entière, comme `null`.
 
@@ -217,7 +218,7 @@ alert(age); // "undefined"
 
 Le type `object` est spécial.
 
-Tous les autres types sont appelés "primitifs", car leurs valeurs ne peuvent contenir qu’une seule chose (que ce soit une chaîne de caractères, un nombre ou autre). À contrario, les objets servent à stocker des collections de données et des entités plus complexes. 
+Tous les autres types sont appelés "primitifs", car leurs valeurs ne peuvent contenir qu’une seule chose (que ce soit une chaîne de caractères, un nombre ou autre). À contrario, les objets servent à stocker des collections de données et des entités plus complexes.
 
 Étant aussi important, les objets méritent un traitement spécial. Nous les traiterons plus tard dans le chapitre <info:object>, après en savoir plus sur les primitifs.
 
@@ -227,7 +228,6 @@ Le type `symbol` est utilisé pour créer des identificateurs uniques pour les o
 
 L'opérateur `typeof` renvoie le type de l'argument. Il est utile lorsqu'on souhaite traiter différemment les valeurs de différents types ou de faire une vérification rapide.
 
-
 L'appel `typeof x` renvoie une chaîne de caractères avec le nom du type :
 
 ```js
@@ -262,8 +262,6 @@ Les trois dernières lignes peuvent nécessiter des explications supplémentaire
 2. Le résultat de `typeof null` est `"object"`. C'est une erreur officiellement reconnue dans `typeof`, datant des premiers jours de JavaScript et conservée pour compatibilité. Bien sûr, `null` n'est pas un objet. C'est une valeur spéciale avec un type distinct qui lui est propre. Le comportement de `typeof` est incorrect ici.
 3. Le résultat de `typeof alert` est `"function"`, car `alert` est une fonction. Nous étudierons les fonctions dans les chapitres suivants, et nous verrons qu’il n’y a pas de type "fonction" en JavaScript. Les fonctions appartiennent au type `object`. Mais `typeof` les traite différemment, en retournant `"fonction"`. Cela vient également des débuts de JavaScript. Techniquement ce n’est pas tout à fait correct, mais très pratique à l'usage.
 
-
-
 ```smart header="La syntaxe `typeof(x)`"
 Vous pouvez également rencontrer une autre syntaxe : `typeof(x)`. C'est la même chose que `typeof x`.
 

1-js/06-advanced-functions/03-closure/article.md

@@ -197,7 +197,7 @@ Tout semble simple pour l'instant, non ?
 - Travailler avec des variables, c'est travailler avec les propriétés de cet objet.
 
 ```smart header="L'environnement lexical est un objet de spécification"
-"L'environnement lexical" est un objet de spécification : il n'existe que "théoriquement" dans la [spécification du language](https://tc39.es/ecma262/#sec-lexical-environments) pour décrire comment les choses fonctionnent. nous ne pouvons pas obtenir cet objet dans notre code et le manipuler directement.
+"L'environnement lexical" est un objet de spécification : il n'existe que "théoriquement" dans la [spécification du langage](https://tc39.es/ecma262/#sec-lexical-environments) pour décrire comment les choses fonctionnent. nous ne pouvons pas obtenir cet objet dans notre code et le manipuler directement.
 
 Les moteurs JavaScript peuvent également l'optimiser, supprimer les variables inutilisées pour économiser de la mémoire et effectuer d'autres opérations internes, tant que le comportement visible reste conforme à la description.
 

1-js/11-async/02-promise-basics/article.md

@@ -10,10 +10,10 @@ C'est une analogie réelle à un problème courant de programmation :
 
 1. Un "producteur de code" qui réalise quelque chose mais nécessite du temps. Par exemple, un code qui charge des données à travers un réseau. C'est le "chanteur".
 2. Un "consommateur de code" qui attend un résultat du "producteur de code" quand il est prêt. Beaucoup de fonctions peuvent avoir besoin de ce résultat. Ces fonctions sont les "fans".
-3. Une *promesse* (promise) est un objet spécial en Javascript qui lie le "producteur de code" et le "consommateur de code" ensemble. En comparant à notre analogie c'est la "liste d'abonnement". Le "producteur de code" prend le temps nécessaire pour produire le résultat promis, et la "promesse" donne le résultat disponible pour le code abonné quand c'est prêt.
+3. Une *promesse* (promise) est un objet spécial en JavaScript qui lie le "producteur de code" et le "consommateur de code" ensemble. En comparant à notre analogie c'est la "liste d'abonnement". Le "producteur de code" prend le temps nécessaire pour produire le résultat promis, et la "promesse" donne le résultat disponible pour le code abonné quand c'est prêt.
 
 
-L'analogie n'est pas la plus correcte, car les promesses en Javascript sont un peu plus complexes qu'une simple liste d'abonnement : elles ont d'autres possibilités mais aussi certaines limitations. Toutefois c'est suffisant pour débuter.
+L'analogie n'est pas la plus correcte, car les promesses en JavaScript sont un peu plus complexes qu'une simple liste d'abonnement : elles ont d'autres possibilités mais aussi certaines limitations. Toutefois c'est suffisant pour débuter.
 
 
 La syntaxe du constructeur pour une promesse est :
@@ -26,7 +26,7 @@ let promise = new Promise(function(resolve, reject) {
 
 La fonction passée à `new Promise` est appelée l'*exécuteur*. Quand `new Promise` est créée, elle est lancée automatiquement. Elle contient le producteur de code, qui doit produire un résulat final. Dans l'analogie ci-dessus : l'exécuteur est le "chanteur".
 
-Ses arguments `resolve` (tenir) et `reject` (rompre) sont les fonctions de retour directement fournies par Javascript. Notre code est inclus seulement dans l'exécuteur.
+Ses arguments `resolve` (tenir) et `reject` (rompre) sont les fonctions de retour directement fournies par JavaScript. Notre code est inclus seulement dans l'exécuteur.
 
 Quand l'exécuteur obtient un résultat, qu'il soit rapide ou pas, cela n'a pas d'importance, il appellera une des deux fonctions de retour :
 
@@ -59,7 +59,7 @@ let promise = new Promise(function(resolve, reject) {
 On peut voir deux choses en lançant le code ci-dessus :
 
 1. L'exécuteur est appelé automatiquement et immédiatement (avec `new Promise`).
-2. L'exécuteur reçoit deux arguments : `resolve` et `reject` - ces deux fonctions sont pré-définies par le moteur Javascript, ainsi nous n'avons pas besoin de les créer. Nous devons seulement appeler l'une ou l'autre quand le résultat est prêt.
+2. L'exécuteur reçoit deux arguments : `resolve` et `reject` - ces deux fonctions sont pré-définies par le moteur JavaScript, ainsi nous n'avons pas besoin de les créer. Nous devons seulement appeler l'une ou l'autre quand le résultat est prêt.
 
     Après une seconde de "traitement" l'exécuteur appelle `resolve("done")` pour produire le résultat. Cela change l'état de l'objet `promise` :
 

1-js/11-async/07-microtask-queue/article.md

@@ -109,4 +109,4 @@ Ainsi, les gestionnaires `.then/catch/finally` sont toujours appelés une fois l
 
 Si nous devons garantir qu'un morceau de code est exécuté après `.then/catch/finally`, nous pouvons l'ajouter à un appel `.then` enchaîné.
 
-Dans la plupart des moteurs Javascript, y compris les navigateurs et Node.js, le concept de micro-tâches est étroitement lié à la "boucle d'événement" et aux "macrotaches". Comme elles n’ont pas de relation directe avec les promesses, elles sont décrites dans une autre partie du didacticiel, au chapitre <info:event-loop>.
+Dans la plupart des moteurs JavaScript, y compris les navigateurs et Node.js, le concept de micro-tâches est étroitement lié à la "boucle d'événement" et aux "macrotaches". Comme elles n’ont pas de relation directe avec les promesses, elles sont décrites dans une autre partie du didacticiel, au chapitre <info:event-loop>.

2-ui/1-document/04-searching-elements-dom/article.md

@@ -2,7 +2,7 @@
 
 Les outils de navigation du DOM sont très pratiques quand les éléments sont proches les uns des autres. Mais s'ils ne le sont pas ? Comment atteindre un élément arbitraire de la page ?
 
-Il existe d'autres méthodes de recherche pour cela. 
+Il existe d'autres méthodes de recherche pour cela.
 
 ## document.getElementById ou juste id
 
@@ -41,7 +41,7 @@ Il y a aussi une variable globale nommée selon l'`id` qui référence l'éléme
 </script>
 ```
 
-...A moins qu'on déclare une variable Javascript avec le même nom, auquel cas celle-ci obtient la priorité :
+...A moins qu'on déclare une variable JavaScript avec le même nom, auquel cas celle-ci obtient la priorité :
 
 ```html run untrusted height=0
 <div id="elem"></div>
@@ -144,9 +144,9 @@ Les *ancêtres* d'un élément sont : le parent, le parent du parent, son propre
 
 La méthode `elem.closest(css)` cherche l'ancêtre le plus proche qui correspond au sélecteur CSS. L'élément `elem` est lui-même inclus dans la recherche.
 
-En d'autres mots, la méthode `closest` part de l'élément et remonte en regardant chacun des parents. S'il correspond au sélecteur, la recherche s'arrête et l'ancêtre est renvoyé. 
+En d'autres mots, la méthode `closest` part de l'élément et remonte en regardant chacun des parents. S'il correspond au sélecteur, la recherche s'arrête et l'ancêtre est renvoyé.
 
-Par exemple : 
+Par exemple :
 
 ```html run
 <h1>Contenu</h1>
@@ -174,15 +174,15 @@ Il y a aussi d'autres méthodes pour rechercher des balises par tag, classe, etc
 
 Aujourd'hui, elles sont principalement de l'histoire ancienne, car `querySelector` est plus puissante et plus courte à écrire.
 
-Donc ici, on va surtout en parler dans le souci d'être complet, comme elles peuvent encore se retrouver dans des vieux scripts. 
+Donc ici, on va surtout en parler dans le souci d'être complet, comme elles peuvent encore se retrouver dans des vieux scripts.
 
 - `elem.getElementsByTagName(tag)` cherche les éléments avec le tag donné et renvoie l'ensemble de ces éléments. Le paramètre `tag` peut aussi être une étoile `"*"` pour signifier n'importe quel tag.
 - `elem.getElementsByClassName(className)` renvoie les éléments qui ont la classe CSS donnée.
 - `document.getElementsByName(name)` renvoie les éléments qui ont l'attribut `name`, dans tout le document. Très rarement utilisé.
 
 Par exemple:
 ```js
-// récupérer tous les divs du document. 
+// récupérer tous les divs du document.
 let divs = document.getElementsByTagName('div');
 ```
 
@@ -225,14 +225,14 @@ La lettre `"s"` letter n'apparait pas dans `getElementById`, car cette méthode
 ```
 
 ````warn header="Elle renvoie un ensemble, pas un élément !"
-Une autre erreur répandue parmi les débutants est d'écrire : 
+Une autre erreur répandue parmi les débutants est d'écrire :
 
 ```js
-// ne fonctionne pas : 
+// ne fonctionne pas :
 document.getElementsByTagName('input').value = 5;
 ```
 
-Cela ne va pas marcher, parce qu'on essaie d'affecter une valeur à un ensemble d'objets plutôt qu'à un élément de cet ensemble. 
+Cela ne va pas marcher, parce qu'on essaie d'affecter une valeur à un ensemble d'objets plutôt qu'à un élément de cet ensemble.
 On devrait plutôt itérer sur l'ensemble ou récupérer un élément par son index, et lui affecter la valeur, comme ceci :
 
 ```js
@@ -263,7 +263,7 @@ Recherche des éléments `.article` :
 
 Toutes les méthodes `"getElementsBy*"` renvoient l'ensemble *courant*. De tels ensembles montrent toujours l'état courant du document and se mettent à jour automatiquement quand celui-ci change.
 
-Dans l'exemple ci-dessous, il y a deux scripts : 
+Dans l'exemple ci-dessous, il y a deux scripts :
 
 1. Le premier crée une référence à l'ensemble des `<div>`. Maintenant, sa longueur est `1`.
 2. Le second se lance après que le navigateur aie rencontré un autre `<div>`, donc sa longueur est `2`.
@@ -311,7 +311,7 @@ Maintenant, on voit facilement la différence. L'ensemble statique ne s'est pas
 
 ## Résumé
 
-Il y a 6 principales méthodes pour rechercher des balises dans le DOM : 
+Il y a 6 principales méthodes pour rechercher des balises dans le DOM :
 
 <table>
 <thead>
@@ -362,7 +362,7 @@ Il y a 6 principales méthodes pour rechercher des balises dans le DOM :
 </tbody>
 </table>
 
-De loin, les plus utilisées sont `querySelector` et `querySelectorAll`, mais `getElement(s)By*` peut être de temps en temps utile ou rencontrée dans de vieux scripts. 
+De loin, les plus utilisées sont `querySelector` et `querySelectorAll`, mais `getElement(s)By*` peut être de temps en temps utile ou rencontrée dans de vieux scripts.
 
 A part ça :