Apply many changes in 1-js/01-05

Author: ArmandDelessert

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

@@ -79,7 +79,7 @@ Les exemples de telles restrictions sont:
 
 - JavaScript peut facilement communiquer sur le net avec le serveur d'où provient la page en cours. Mais sa capacité à recevoir des données d'autres sites / domaines est paralysée. Bien que possible, il nécessite un accord explicite (exprimé dans les en-têtes HTTP) du côté distant. Encore une fois, ce sont des limites de sécurité.
 
-![](limitations.svg)
+![Schéma des limitations du JavaScript dans un navigateur](limitations.svg)
 
 De telles limites n'existent pas si JavaScript est utilisé en dehors du navigateur, par exemple sur un serveur. Les navigateurs modernes permettent également l’installation de plug-ins / extensions susceptibles d’obtenir des autorisations étendues.
 

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

@@ -8,7 +8,7 @@ Dans ce chapitre, nous nous concentrons sur les aspects qui ne sont pas couverts
 
 Avant de continuer, saisissons la terminologie commune.
 
-- Un opérande est ce à quoi les opérateurs sont appliqués. Par exemple, dans la multiplication `5 * 2`, il y a deux opérandes: l'opérande gauche est `5` et l'opérande droit est `2`. Parfois, les gens disent "arguments" au lieu de "opérandes".
+- Un opérande est ce à quoi les opérateurs sont appliqués. Par exemple, dans la multiplication `5 * 2`, il y a deux opérandes : l'opérande gauche est `5` et l'opérande droit est `2`. Parfois, les gens disent "arguments" au lieu de "opérandes".
 - Un opérateur est unaire s'il a un seul opérande. Par exemple, la négation unaire `-` inverse le signe du nombre :
 
     ```js run
@@ -47,19 +47,20 @@ L'opérateur reste `%`, malgré son apparence, n'est pas lié aux pourcentages.
 
 Le résultat de `a % b` est le [reste](https://fr.wikipedia.org/wiki/Reste) de la division entière de `a` par `b`.
 
-Par exemple:
+Par exemple :
 
 ```js run
 alert( 5 % 2 ); // 1, le reste de 5 divisé par 2
 alert( 8 % 3 ); // 2, le reste de 8 divisé par 3
+alert( 8 % 2 ); // 0, le reste de 8 divisé par 2
 ```
 
 ### Exponentiation **
 
 L'opérateur d'exponentiation `a ** b` multiplie `a` par lui-même `b` fois.
 En mathématiques à l'école, nous écrivons cela a<sup>b</sup>.
 
-Par exemple:
+Par exemple :
 
 ```js run
 alert( 2 ** 2 ); // 2² = 4
@@ -118,7 +119,7 @@ Ici, le premier opérande est une chaîne de caractères, le compilateur traite
 
 Le binaire `+` est le seul opérateur qui prend en charge les chaînes de caractères de cette manière. D'autres opérateurs arithmétiques ne fonctionnent qu'avec des nombres et convertissent toujours leurs opérandes en nombres.
 
-Voici l'exemple pour la soustraction et la division:
+Voici l'exemple pour la soustraction et la division :
 ```js run
 alert( 6 - '2' ); // 4, convertit '2' en nombre
 alert( '6' / '2' ); // 3, convertit les deux opérandes en nombres
@@ -185,7 +186,7 @@ Si une expression a plusieurs opérateurs, l’ordre d’exécution est défini
 
 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`.
+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.
 
@@ -227,7 +228,7 @@ Tous les opérateurs en JavaScript renvoient une valeur. C'est évident pour `+`
 
 L'appel `x = valeur` écrit la` valeur` dans `x` *puis la renvoie*.
 
-Voici un exemple qui utilise une affectation dans le cadre d'une expression plus complexe:
+Voici un exemple qui utilise une affectation dans le cadre d'une expression plus complexe :
 
 ```js run
 let a = 1;
@@ -263,9 +264,9 @@ alert( b ); // 4
 alert( c ); // 4
 ```
 
-Les affectations en chaîne sont évaluées de droite à gauche. D'abord, l'expression la plus à droite `2 + 2` est évaluée puis assignée aux variables de gauche: `c`, `b` et `a`. À la fin, toutes les variables partagent une seule valeur.
+Les affectations en chaîne sont évaluées de droite à gauche. D'abord, l'expression la plus à droite `2 + 2` est évaluée puis assignée aux variables de gauche : `c`, `b` et `a`. À la fin, toutes les variables partagent une seule valeur.
 
-Encore une fois, pour des raisons de lisibilité, il est préférable de diviser ce code en quelques lignes:
+Encore une fois, pour des raisons de lisibilité, il est préférable de diviser ce code en quelques lignes :
 
 ```js
 c = 2 + 2;
@@ -296,14 +297,14 @@ n *= 2; // maintenant n = 14 (identique à n = n * 2)
 alert( n ); // 14
 ```
 
-Il existe de opérateurs de "modification et assignation" courts pour tous les opérateurs arithmétiques et binaires: `/=`, `-=` etc.
+Il existe des opérateurs de "modification et assignation" courts pour tous les opérateurs arithmétiques et binaires : `/=`, `-=` etc.
 
 Ces opérateurs ont la même précédence qu'une affectation normale. Ils s'exécutent donc après la plupart des autres calculs :
 
 ```js run
 let n = 2;
 
-n *= 3 + 5; // right part evaluated first, same as n *= 8
+n *= 3 + 5; // la partie de droite est évaluée en premier (identique à n *= 8)
 
 alert( n ); // 16  
 ```
@@ -320,14 +321,14 @@ Il y a donc des opérateurs spéciaux pour cela :
 
     ```js run no-beautify
     let counter = 2;
-    counter++;      // fonctionne de la même manière que counter = counter + 1, mais c'est plus court
+    counter++;        // fonctionne de la même manière que counter = counter + 1, mais c'est plus court
     alert( counter ); // 3
     ```
 - **Décrémentation** `--` diminue une variable de 1 :
 
     ```js run no-beautify
     let counter = 2;
-    counter--;      // fonctionne de la même manière que counter = counter - 1, mais c'est plus court
+    counter--;        // fonctionne de la même manière que counter = counter - 1, mais c'est plus court
     alert( counter ); // 1
     ```
 
@@ -338,7 +339,7 @@ L'incrémentation / décrémentation ne peut être appliquée qu'à une variable
 Les opérateurs `++` et `--` peuvent être placés à la fois après et avant la variable.
 
 - 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`.
+- 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`.
 

1-js/02-first-steps/09-comparison/article.md

@@ -45,6 +45,7 @@ Par exemple :
 alert( 'Z' > 'A' ); // true
 alert( 'Glow' > 'Glee' ); // true
 alert( 'Bee' > 'Be' ); // true
+alert( '9' > '10' ); // true
 ```
 
 L'algorithme pour comparer deux chaînes  de caractères est simple :
@@ -161,8 +162,8 @@ Pour un contrôle d'égalité non strict `==`
     alert( null == undefined ); // true
     ```
 
-Pour les maths et autres comparaisons `< > <= >=`
-: Les valeurs `null/undefined` sont converties en un nombre : `null` devient `0`, alors qu'`undefined` devient `NaN`.
+Pour les maths et autres comparaisons `<`, `>`, `<=`, `>=`
+: Les valeurs `null`/`undefined` sont converties en un nombre : `null` devient `0`, alors qu'`undefined` devient `NaN`.
 
 Voyons maintenant des choses amusantes qui se produisent lorsque nous appliquons ces règles. Et, ce qui est plus important, comment ne pas tomber dans un piège avec ces caractéristiques.
 
@@ -178,7 +179,7 @@ alert( null >= 0 ); // (3) *!*true*/!*
 
 Ouais, mathématiquement c'est étrange. Le dernier résultat indique que "`null` est supérieur ou égal à zéro". Alors que l'une des comparaisons au dessus devrait être correcte, mais les deux sont fausses.
 
-La raison est qu'une vérification d'égalité `==` et les comparaisons> `<> >= <=` fonctionnent différemment. Les comparaisons convertissent `null` en un nombre, donc le traitent comme `0`. C'est pourquoi (3) `null >= 0` est vrai et (1) `nul > 0` est faux.
+La raison est qu'une vérification d'égalité (`==`) et les comparaisons (`<`, `>`, `<=`, `>=`) fonctionnent différemment. Les comparaisons convertissent `null` en un nombre, donc le traitent comme `0`. C'est pourquoi (3) `null >= 0` est vrai et (1) `null > 0` est faux.
 
 D’un autre côté, la vérification de l’égalité `==` pour `undefined` et `null` est définie de telle sorte que, sans aucune conversion, ils sont égaux et ne correspondent à rien d’autre. C'est pourquoi (2) `null == 0` est faux.
 
@@ -187,8 +188,8 @@ D’un autre côté, la vérification de l’égalité `==` pour `undefined` et
 La valeur `undefined` ne doit pas du tout participer aux comparaisons :
 
 ```js run
-alert( undefined > 0 ); // false (1)
-alert( undefined < 0 ); // false (2)
+alert( undefined > 0 );  // false (1)
+alert( undefined < 0 );  // false (2)
 alert( undefined == 0 ); // false (3)
 ```
 
@@ -203,14 +204,14 @@ Nous avons ces résultats parce que :
 
 Pourquoi avons-nous observé ces exemples? Devrions-nous nous souvenir de ces particularités tout le temps ? Eh bien pas vraiment. En fait, ces notions délicates deviennent progressivement familières au fil du temps, mais il existe un moyen solide d’éviter tout problème avec elles.
 
-Il suffit de traiter toute comparaison avec `undefined/null` (à l'exception de la stricte égalité `===`) avec un soin exceptionnel.
+Il suffit de traiter toute comparaison avec `null`/`undefined` (à l'exception de la stricte égalité `===`) avec un soin exceptionnel.
 
-N'utilisez pas de comparaisons `=> > < <=` avec une variable qui peut être `null/undefined`, sauf si vous êtes vraiment sûr de ce que vous faites. Si une variable peut avoir de telles valeurs, vérifiez-les séparément.
+N'utilisez pas de comparaisons `=>`, `>`, `<`, `<=` avec une variable qui peut être `null`/`undefined`, sauf si vous êtes vraiment sûr de ce que vous faites. Si une variable peut avoir de telles valeurs, vérifiez-les séparément.
 
 ## Résumé
 
 - Les opérateurs de comparaison renvoient une valeur logique.
 - Les chaînes de caractères sont comparées lettre par lettre dans l'ordre "dictionnaire".
 - Lorsque des valeurs de différents types sont comparées, elles sont converties en nombres (à l'exclusion d'un contrôle d'égalité strict).
-- Les valeurs `null` et `undefined` sont égales `==` et ne correspondent à aucune autre valeur.
-- Soyez prudent lorsque vous utilisez des comparaisons telles que `>` ou `<` avec des variables pouvant parfois être `null/undefined`. Faire une vérification séparée pour `null/undefined` est une bonne idée.
+- Les valeurs `null` et `undefined` sont égales (`==`) et ne correspondent à aucune autre valeur.
+- Soyez prudent lorsque vous utilisez des comparaisons telles que `>` ou `<` avec des variables pouvant parfois être `null`/`undefined`. Faire une vérification séparée pour `null`/`undefined` est une bonne idée.

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

@@ -29,7 +29,7 @@ if (year == 2015) {
 }
 ```
 
-Il est recommandé d'entourer votre bloc de code avec des accolades `{}` à chaque fois avec `if`, même s’il n’ya qu’une seule instruction. Cela améliore la lisibilité.
+Il est recommandé d'entourer votre bloc de code avec des accolades `{}` à chaque fois avec `if`, même s’il n’y a qu’une seule instruction. Cela améliore la lisibilité.
 
 ## Conversion booléenne
 

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

@@ -21,9 +21,9 @@ En JavaScript, l'opérateur est un peu plus compliqué et puissant. Mais voyons
 Il existe quatre combinaisons logiques possibles :
 
 ```js run
-alert( true || true );   // true
-alert( false || true );  // true
-alert( true || false );  // true
+alert( true  || true  ); // true
+alert( false || true  ); // true
+alert( true  || false ); // true
 alert( false || false ); // false
 ```
 
@@ -53,7 +53,7 @@ if (hour < 10 || hour > 18) {
 }
 ```
 
-Nous pouvons passer plus de conditions : 
+Nous pouvons passer plus de conditions :
 
 ```js run
 let hour = 12;
@@ -84,7 +84,7 @@ L'opérateur OR `||` fait ce qui suit :
 
 Une valeur est renvoyée sous sa forme d'origine, sans conversion.
 
-En d'autres termes, une chaîne de OR `||` renvoie la première valeur vraie ou la dernière si aucune valeur vraie n'est trouvée.
+En d'autres termes, une chaîne de OR `||` renvoie la première valeur `true` ou la dernière valeur si aucune valeur `true` n'a été trouvée.
 
 Par exemple :
 
@@ -115,7 +115,7 @@ Cela conduit à des usages intéressants par rapport à un "OR pur, classique, b
     */!*
     ```
 
-    If all variables were falsy, `"Anonymous"` would show up.
+    Si toutes les variables étaient fausses, ce serait `"Anonymous"` qui apparaîtrait.
 
 2. **Évaluation des courts-circuits.**
 
@@ -147,9 +147,9 @@ result = a && b;
 En programmation classique, AND retourne `true` si les deux opérandes sont `true` et `false` dans les autres cas :
 
 ```js run
-alert( true && true );   // true
-alert( false && true );  // false
-alert( true && false );  // false
+alert( true  && true  ); // true
+alert( false && true  ); // false
+alert( true  && false ); // false
 alert( false && false ); // false
 ```
 
@@ -187,7 +187,7 @@ L'opérateur AND `&&` effectue les opérations suivantes :
 - 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.
 - 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, AND renvoie la première valeur `false` ou la dernière valeur si aucune n'a été trouvée.
+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.
 
 Les règles ci-dessus sont similaires à OR. La différence est que AND retourne la première valeur `false` tandis que OR renvoie la première valeur `true`.