Applies many fixes from 'Javascript' to 'JavaScript' in all the tutorial

Author: ArmandDelessert

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/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 :
 

2-ui/2-events/04-default-browser-action/article.md

@@ -8,7 +8,7 @@ Par exemple:
 - Un clic sur un bouton d'envoi de formulaire -- initie son envoie vers le serveur.
 - Appuyer sur un bouton de la souris au-dessus d'un texte et la déplacer -- sélectionne le texte.
 
-Si nous gérons un évènement avec Javascript, nous pouvons ne pas avoir envie de déclencher l'action de navigateur associée, et déclencher un autre comportement à la place.
+Si nous gérons un évènement avec JavaScript, nous pouvons ne pas avoir envie de déclencher l'action de navigateur associée, et déclencher un autre comportement à la place.
 
 ## Empêcher les actions du navigateur
 
@@ -25,7 +25,7 @@ ou
 <a href="/" onclick="event.preventDefault()">ici</a>
 ```
 
-Dans le prochain exemple nous allons utiliser cette technique pour créer un menu avec Javascript.
+Dans le prochain exemple nous allons utiliser cette technique pour créer un menu avec JavaScript.
 
 ```warn header="Renvoyer `false` depuis un gestionnaire d'évènement est une exception"
 La valeur renvoyée par un gestionnaire d'évènement est généralement ignorée.
@@ -56,7 +56,7 @@ Les objets du menu sont implémentés comme des liens HTML `<a>`, pas des bouton
 - Beaucoup de gens aiment utiliser "clic droit" -- "ouvrir dans une nouvelle fenêtre". Si nous utilisons `<button>` ou `<span>`, cela ne fonctionne pas.
 - Les moteurs de recherche suivent les liens `<a href="...">` lors de l'indexation.
 
-Donc nous utilisons `<a>`. Mais normalement nous avons l'intention de gérer les clics avec Javascript. Donc nous devrions empêcher les actions par défaut du navigateur.
+Donc nous utilisons `<a>`. Mais normalement nous avons l'intention de gérer les clics avec JavaScript. Donc nous devrions empêcher les actions par défaut du navigateur.
 
 Comme ici:
 
@@ -225,7 +225,7 @@ Il y a plusieurs actions de navigateur par défaut:
 - `contextmenu` -- l'évènement se déclenche lors d'un clic droit, l'action est d'afficher le menu contextuel du navigateur.
 - ...il y en a plus...
 
-Toutes les actions par défaut peuvent être empêchées si nous voulons gérer l'évènement exclusivement avec Javascript.
+Toutes les actions par défaut peuvent être empêchées si nous voulons gérer l'évènement exclusivement avec JavaScript.
 
 Pour empêcher une action par défaut -- utilisez soit `event.preventDefault()`, soit `return false`. La seconde méthode ne fonctionne que pour les gestionnaires assignés avec `on<event>`.
 
@@ -234,11 +234,11 @@ L'option `passive: true` de `addEventListener` dis au navigateur que l'action ne
 Si l'action par défaut a été empêchée, la valeur de `event.defaultPrevented` devient `true`, sinon `false`.
 
 ```warn header="Restez sémantique, n'abusez pas"
-Techniquement, en empêchant les actions par défaut et en ajoutant du Javascript nous pouvons personnaliser le comportement de n'importe quel élément. Par exemple, nous pouvons faire fonctionner un lien `<a>` comme un bouton, et un bouton `<button>` se comporter comme un lien (rediriger vers une autre URL ou autre).
+Techniquement, en empêchant les actions par défaut et en ajoutant du JavaScript nous pouvons personnaliser le comportement de n'importe quel élément. Par exemple, nous pouvons faire fonctionner un lien `<a>` comme un bouton, et un bouton `<button>` se comporter comme un lien (rediriger vers une autre URL ou autre).
 
 Mais nous devrions généralement garder la signification sémantique des éléments HTML. Par exemple `<a>` devrait entrainer une navigation, pas un bouton.
 
 Ce n'est pas "juste une bonne chose", cela rend votre HTML meilleur en terme d'accessibilité.
 
-Aussi, si nous prenons l'exemple avec `<a>`, veuillez noter: un navigateur nous permet d'ouvrir de tels liens dans une nouvelle fenêtre (en faisant un clic droit dessus par exemple). Et les gens aiment ça. Mais si nous faisons un bouton qui se comporte comme un lien en utilisant Javascript et qui ressemble à un lien en utilisant CSS, les fonctionnalités de navigateur spécifiques à `<a>` ne fonctionneront toujours pas.
+Aussi, si nous prenons l'exemple avec `<a>`, veuillez noter: un navigateur nous permet d'ouvrir de tels liens dans une nouvelle fenêtre (en faisant un clic droit dessus par exemple). Et les gens aiment ça. Mais si nous faisons un bouton qui se comporte comme un lien en utilisant JavaScript et qui ressemble à un lien en utilisant CSS, les fonctionnalités de navigateur spécifiques à `<a>` ne fonctionneront toujours pas.
 ```