Miscellaneous minor fixes in 1-js/02-first-steps/16..18

Author: ArmandDelessert

1-js/02-first-steps/16-function-expressions/article.md

@@ -74,7 +74,7 @@ sayHi(); // Hello    //     cela fonctionne toujours aussi (pourquoi pas)
 Voici ce qui se passe ci-dessus en détail :
 
 1. La Déclaration de Fonction `(1)` crée la fonction et la place dans la variable nommée `sayHi`.
-2. La ligne `(2)` le copie dans la variable `func`. Veuillez noter à nouveau : il n'y a pas de parenthèses après `sayHi`. S'il y en avait, alors `func = sayHi()` écrirait *le résultat de l'appel* `sayHi()` dans `func`, et non *la fonction* `sayHi` elle-même.
+2. La ligne `(2)` la copie dans la variable `func`. Veuillez noter à nouveau : il n'y a pas de parenthèses après `sayHi`. S'il y en avait, alors `func = sayHi()` écrirait *le résultat de l'appel* `sayHi()` dans `func`, et non *la fonction* `sayHi` elle-même.
 3. Maintenant, la fonction peut être appelée à la fois en tant que `sayHi()` et `func()`.
 
 Nous aurions aussi pu utiliser une Fonction Expression pour déclarer `sayHi`, à la première ligne :
@@ -114,12 +114,12 @@ Le point-virgule serait là pour une affectation plus simple, telle que `let say
 
 Examinons plus d’exemples de fonctions passées en tant que valeurs et utilisant des expressions de fonction.
 
-Nous allons écrire une fonction `ask(question, oui, non)` avec trois paramètres :
+Nous allons écrire une fonction `ask(question, yes, no)` avec trois paramètres :
 
 `question`
 : Texte de la question
 
-`Yes`
+`yes`
 : Fonction à exécuter si la réponse est “Yes”
 
 `no`
@@ -130,7 +130,7 @@ La fonction doit poser la question et, en fonction de la réponse de l'utilisate
 ```js run
 *!*
 function ask(question, yes, no) {
-  if (confirm(question)) yes()
+  if (confirm(question)) yes();
   else no();
 }
 */!*
@@ -151,13 +151,13 @@ En pratique, ces fonctions sont très utiles. La principale différence entre un
 
 **Les arguments `showOk` et `showCancel` de `ask` s'appellent des *fonctions callback* (fonctions de rappel) ou simplement des *callbacks* (rappels).**
 
-L'idée est que nous passions une fonction et attendions qu'elle soit "rappelée" plus tard si nécessaire. Dans notre cas, `showOk` devient le rappel pour la réponse "oui" et `showCancel` pour la "non" réponse.
+L'idée est que nous passions une fonction et attendions qu'elle soit "rappelée" plus tard si nécessaire. Dans notre cas, `showOk` devient le rappel pour la réponse "oui" et `showCancel` pour la réponse "non".
 
 Nous pouvons utiliser les Fonctions Expressions pour écrire la même fonction mais plus courte :
 
 ```js run no-beautify
 function ask(question, yes, no) {
-  if (confirm(question)) yes()
+  if (confirm(question)) yes();
   else no();
 }
 
@@ -182,7 +182,6 @@ Une fonction peut être perçue comme une *action*.
 Nous pouvons tout aussi bien la passer en tant que variable ou l'exécuter si nous le voulons.
 ```
 
-
 ## Fonction Expression vs Fonction Déclaration
 
 Formulons les principales différences entre les déclarations de fonction et les expressions de fonctions.
@@ -214,7 +213,7 @@ Une fois que le flux d'exécution passe à droite de l'affectation, `let sum = f
 
 Les déclarations de fonction sont différentes.
 
-**Une fonction déclaration peut être appelée plus tôt que sa définition.**
+**Une Fonction Déclaration peut être appelée plus tôt que sa définition.**
 
 Par exemple, une fonction déclaration globale est visible dans tout le script, peu importe où elle se trouve.
 
@@ -250,7 +249,7 @@ let sayHi = function(name) {  // (*) plus de magie
 
 Les expressions de fonction sont créées lorsque l'exécution les atteint. Cela ne se produirait que dans la ligne `(*)`. Trop tard.
 
-Une autre particularité des Fonction Declaration est leur portée de bloc.
+Une autre particularité des Fonction Déclaration est leur portée de bloc.
 
 **En mode strict, quand une Fonction Déclaration se trouve dans un bloc de code, elle est visible partout dans ce bloc. Mais pas en dehors.**
 
@@ -295,7 +294,7 @@ if (age < 18) {
 */!*
                            //  |
   function welcome() {     //  |
-    alert("Hello!");      //  |  La déclaration de fonction est disponible
+    alert("Hello!");       //  |  La déclaration de fonction est disponible
   }                        //  |  partout dans le bloc où elle est déclarée
                            //  |
 *!*
@@ -373,7 +372,7 @@ C’est également meilleur pour la lisibilité, car il est plus facile de reche
 
 ## Résumé
 
-- Les fonctions sont des valeurs. Ils peuvent être attribués, copiés ou déclarés à n’importe quel endroit du code.
+- Les fonctions sont des valeurs. Elles peuvent être attribuées, copiées ou déclarées à n’importe quel endroit du code.
 - Si la fonction est déclarée comme une instruction distincte dans le flux de code principal, cela s'appelle une "déclaration de fonction".
 - Si la fonction est créée dans le cadre d’une expression, elle est appelée "expression de fonction".
 - Les déclarations de fonctions sont traitées avant l'exécution du bloc de code. Elles sont visibles partout dans le bloc.

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

@@ -37,7 +37,7 @@ Comme vous pouvez le voir `(a, b) => a + b` représente une fonction qui accepte
 
 - Pour un argument unique, alors les parenthèses autour du paramètre peuvent être omises, rendant la fonction encore plus courte.
 
-    For example:
+    Par exemple:
 
     ```js run
     *!*
@@ -64,7 +64,7 @@ Par exemple pour créer une fonction dynamiquement :
 let age = prompt("What is your age?", 18);
 
 let welcome = (age < 18) ?
-  () => alert('Hello!') :
+  () => alert("Hello!") :
   () => alert("Greetings!");
 
 welcome(); // ok now
@@ -76,7 +76,7 @@ Elles sont très utile pour des actions sur une ligne et que l'on est juste pare
 
 ## 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 eux.
+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.
 
@@ -94,11 +94,11 @@ alert( sum(1, 2) ); // 3
 ```
 
 ```smart header="Plus à venir"
-Ici nous nous arrêtons sur les fonctions fléchées pour leur syntaxe bréve mais ce n'est pas tout !
+Nous nous arrêtons ici sur les fonctions fléchées pour leur syntaxe brève mais ce n'est pas tout !
 
 Les fonctions fléchées ont d'autres particularités intéressantes.
 
-Pour les aprrendre en profondeur, nous devons d'abord voir d'autres aspects de Javascript, nous reviendrons donc aux fonctions fléchées plus tard dans le chapitre <info:arrow-functions>.
+Pour les apprendre en profondeur, nous devons d'abord voir d'autres aspects de JavaScript, nous reviendrons donc aux fonctions fléchées plus tard dans le chapitre <info:arrow-functions>.
 
 Pour l'instant, nous pouvons les utiliser pour des actions sur une ligne ou des callbacks (rappels).
 ```
@@ -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 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`.
 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.

1-js/02-first-steps/18-javascript-specials/article.md

@@ -43,7 +43,7 @@ for(;;) {
 
 Plus d'informations dans : <info:structure>.
 
-## Strict mode
+## Mode strict
 
 Pour activer pleinement toutes les fonctionnalités de JavaScript moderne, nous devrions commencer les scripts avec `"use strict"`.
 
@@ -70,6 +70,7 @@ Peut être déclaré en utilisant :
 - `var` (à l'ancienne, nous le verrons plus tard)
 
 Un nom de variable peut inclure :
+
 - Lettres et chiffres, mais le premier caractère ne peut pas être un chiffre.
 - Les caractères `$` et `_` sont normaux, à égalité avec les lettres.
 - Les alphabets et les hiéroglyphes non latins sont également autorisés, mais ils ne sont généralement pas utilisés.
@@ -85,13 +86,14 @@ Il y a 8 types de données :
 
 - `number` pour les nombres à virgule flottante et les nombres entiers,
 - `bigint` pour des nombres entiers de longueur arbitraire,
-- `string` pour les chaînes de caractères
+- `string` pour les chaînes de caractères,
 - `boolean` pour les valeurs logiques : `true/false`,
 - `null` -- un type avec une seule valeur `null`, signifiant "vide" ou "n'existe pas",
 - `undefined` -- un type avec une seule valeur `undefined`, signifiant "non assigné",
-- `object` et `symbol` -- Pour les structures de données complexes et les identifiants uniques, nous ne les avons pas encore appris.
+- `object` et `symbol` -- pour les structures de données complexes et les identifiants uniques, nous ne les avons pas encore appris.
 
 L'opérateur `typeof` renvoie le type d'une valeur, à deux exceptions près :
+
 ```js
 typeof null == "object" // erreur dans le langage
 typeof function(){} == "function" // les fonctions sont traitées spécialement
@@ -144,19 +146,19 @@ Affectations
 : Il y a une assignation simple : `a = b` et des combinés comme `a *= 2`.
 
 Bitwise
-: Les opérateurs au niveau du bit fonctionnent avec des entiers 32 bits au niveau du bit le plus bas : voir la [doc](mdn:/JavaScript/Guide/Expressions_and_Operators#bitwise_operators)) quand ils sont nécessaires.
+: Les opérateurs au niveau du bit fonctionnent avec des entiers 32 bits au niveau du bit le plus bas : voir la [doc](mdn:/JavaScript/Guide/Expressions_and_Operators#bitwise_operators) quand ils sont nécessaires.
 
 Conditionnel
 : Le seul opérateur avec trois paramètres : `cond ? resultA : resultB`. Si `cond` est vrai, retourne `resultA`, autrement `resultB`.
 
 Opérateurs logiques
-: ET logique `&&` et OU `||` effectuent une évaluation en circuit court puis renvoyent la valeur là où ils se sont arrêtés(pas nécessairement `true`/`false`). NOT logique `!` convertit l'opérande en type booléen et retourne la valeur inverse.
+: ET logique `&&` et OU `||` effectuent une évaluation en circuit court puis renvoyent la valeur là où ils se sont arrêtés (pas nécessairement `true`/`false`). NOT logique `!` convertit l'opérande en type booléen et retourne la valeur inverse.
 
 L'opérateur de coalescence des nuls
-: L'opérateur `??` permet de choisir une valeur définie dans une liste de variables. Le résultat de `a ?? b` est `a` sauf s'il est `null/undefined`, alors `b`.
+: L'opérateur `??` permet de choisir une valeur définie dans une liste de variables. Le résultat de `a ?? b` est `a` sauf s'il est `null`/`undefined`, alors `b`.
 
 Comparaisons
-: Le contrôle d’égalité `==` pour les valeurs de types différents les convertit en un nombre (sauf `null` et `undefined` égales entre elles et rien d’autre), elles sont donc égales :
+: Le contrôle d’égalité `==` pour les valeurs de types différents les convertit en un nombre (sauf `null` et `undefined`, égales entre elles et rien d’autre), elles sont donc égales :
 
     ```js run
     alert( 0 == false ); // true
@@ -280,4 +282,4 @@ Details : voir <info:function-basics>, <info:arrow-functions-basics>.
 
 ## Plus à venir
 
-C’était une brève liste de fonctionnalités JavaScript. Pour l’instant, nous n’avons étudié que les bases. Plus loin dans le tutoriel, vous trouverez plus de fonctionnalités spéciales et avancées de JavaScript.
+C’était une brève liste de fonctionnalités de JavaScript. Pour l’instant, nous n’avons étudié que les bases. Plus loin dans le tutoriel, vous trouverez plus de fonctionnalités spéciales et avancées de JavaScript.