Merge pull request #392 from StephaneBullier/master

Update article.md

Author: HachemiH

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

@@ -157,7 +157,7 @@ alert(x); // 2
 
 ## Résumé
 
-- L'opérateur de coalescence des nuls `??` fournit un moyen court de choisir une valeur "définie" à pratir d'une liste.
+- L'opérateur de coalescence des nuls `??` fournit un moyen court de choisir une valeur "définie" à partir d'une liste.
 
     Il est utilisé pour attribuer des valeurs par défaut aux variables :
 

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

@@ -112,7 +112,7 @@ Le point-virgule serait là pour une affectation plus simple, telle que `let say
 
 ## Fonctions callback (de rappel)
 
-Examinons plus d’exemples de :fonctions passées en tant que valeurs et utilisant des expressions de fonction.
+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 :
 

1-js/03-code-quality/05-testing-mocha/article.md

@@ -52,8 +52,7 @@ describe("pow", function() {
 Une spécification a trois blocs de construction principaux que vous pouvez voir ci-dessus :
 
 `describe("title", function() { ... })`
-: Quelle fonctionnalité nous décrivons. Utilisations pour grouper les "workers" - le bloc `it`. Dans notre cas, nous décrivons la fonction `pow`.
-Quelle fonctionnalité nous décrivons. Dans notre cas, nous décrivons la fonction `pow`. Utilisée pour grouper les "workers" - le bloc `it`.
+: Quelle fonctionnalité nous décrivons. Dans notre cas, nous décrivons la fonction `pow`, utilisée pour grouper les "workers" - le bloc `it`.
 
 `it("use case description", function() { ... })`
 : Dans le titre de `it`, nous décrivons d'une *manière lisible par l'homme* le cas particulier d'utilisation, et le deuxième argument est une fonction qui le teste.
@@ -384,11 +383,11 @@ La spécification peut être utilisée de trois manières :
 
 1. En tant que **Tests** -- garantir que le code fonctionne correctement.
 2. En tant que **Docs** -- les titres de `describe` et `it` indiquent ce que fait la fonction.
-3. En tant que **Examples** -- les tests sont en fait d'exemples de travail montrant comment une fonction peut être utilisée.
+3. En tant que **Examples** -- les tests sont en fait des exemples de travail montrant comment une fonction peut être utilisée.
 
 Avec la spécification, nous pouvons sans risque améliorer, modifier, même réécrire la fonction à partir de zéro et nous assurer qu'elle fonctionne toujours correctement.
 
-C’est particulièrement important dans les grands projets quand une fonction est utilisée dans de nombreux endroits. Lorsque nous changeons une telle fonction, il n’ya aucun moyen de vérifier manuellement si chaque endroit qui l’utilise fonctionne toujours correctement.
+C’est particulièrement important dans les grands projets quand une fonction est utilisée dans de nombreux endroits. Lorsque nous changeons une telle fonction, il n’y a aucun moyen de vérifier manuellement si chaque endroit qui l’utilise fonctionne toujours correctement.
 
 Sans tests, les gens ont deux moyens :
 

1-js/04-object-basics/02-object-copy/article.md

@@ -2,7 +2,7 @@
 
 Une des différences fondamentale des objets avec les primitives est que ceux-ci sont stockés et copiés "par référence", en opposition des valeurs primitives : strings, numbers, booleans, etc. -- qui sont toujours copiés comme "valeur entière".
 
-On comprendra plus facilement en regardant "sous le capot" de ce qui se passe lorsque nous copions une valeure.
+On comprendra plus facilement en regardant "sous le capot" ce qui se passe lorsque nous copions une valeure.
 
 Commençons avec une primitive, comme une chaîne de caractères.
 
@@ -121,13 +121,13 @@ let user = {
 *!*
 let clone = {}; // le nouvel object vide
 
-// on copie toutes les propritété de user
+// on copie toutes les propritétés de user
 for (let key in user) {
   clone[key] = user[key];
 }
 */!*
 
-// maintenant clone est un objet complétemnet indépendant  avec le même contenu
+// maintenant clone est un objet complétemnet indépendant avec le même contenu
 clone.name = "Pete"; // On change les données de celui-ci
 
 alert( user.name ); // c'est toujour john dans l'objet copié
@@ -192,7 +192,7 @@ Il existe également d'autres méthodes de clonage d'un objet, par ex. en utilis
 
 ## Clonage imbriqué
 
-Jusqu'à maintenant on suppose que toutes les propriétés de `use` sont des primitives. Mais les propriétés peuvent être des références vers d'autres objets. Comment gèrer ces cas-là ?
+Jusqu'à maintenant on suppose que toutes les propriétés de `user` sont des primitives. Mais les propriétés peuvent être des références vers d'autres objets. Comment gèrer ces cas-là ?
 
 Comme ceci :
 ```js run

1-js/04-object-basics/04-object-methods/article.md

@@ -222,7 +222,7 @@ Dans ce cas, `this` est `undefined` en mode strict. Si nous essayons d'accéder
 
 En mode non strict (si on oublie `use strict`), la valeur de `this` dans ce cas sera l’*objet global* (la fenêtre d’un navigateur, nous y reviendrons plus tard). Ceci est un comportement historique qui corrige `"use strict"`.
 
-Cen genre d'appel est généralement une erreur de programmation. Si il y a un `this` dans une fonction, il s'attend à être appelée dans un contexte d'objet.
+Ce genre d'appel est généralement une erreur de programmation. Si il y a un `this` dans une fonction, il s'attend à être appelée dans un contexte d'objet.
 ````
 
 ```smart header="Les conséquences d'un `this` non lié"

1-js/04-object-basics/07-optional-chaining/article.md

@@ -221,7 +221,8 @@ delete user?.name; // supprime user.name si user existe
 Le chaînage optionnel `?.` n'a aucune utilité sur le côté gauche d'une affectation :
 
 
-For example:
+Par exemple :
+
 ```js run
 
 let user = null;
@@ -240,7 +241,7 @@ Le chaînage optionnel '?.' A trois formes :
 3. `obj?.method()` -- appel `obj.method()` si `obj.method` existe, sinon retourne `undefined`.
 
 
-Comme nous pouvons le voir, tous sont simples et simples à utiliser. Le `?.` vérifie la partie gauche pour `nul/undefined` et permet à l'évaluation de se poursuivre si ce n'est pas le cas.
+Comme nous pouvons le voir, tous sont simples et simples à utiliser. Le `?.` vérifie la partie gauche pour `null/undefined` et permet à l'évaluation de se poursuivre si ce n'est pas le cas.
 
 Une chaîne de `?.` permet d'accéder en toute sécurité aux propriétés imbriquées.
 

1-js/05-data-types/01-primitives-methods/article.md

@@ -122,7 +122,7 @@ alert(null.test); // error
 ```
 ````
 
-## Sommaire
+## Résumé
 
 - Les primitives sauf null et undefined fournissent de nombreuses méthodes utiles. Nous étudierons cela dans les prochains chapitres.
 - Officiellement, ces méthodes fonctionnent via des objets temporaires, mais les moteurs JavaScript sont bien ajustés pour optimiser cela en interne, elles ne sont donc pas coûteuses à appeler.

1-js/05-data-types/02-number/article.md

@@ -164,28 +164,28 @@ Il y a deux façons de le faire:
     alert( Math.round(num * 100) / 100 ); // 1.23456 -> 123.456 -> 123 -> 1.23
     ```
 
-2. La méthode [toFixed(n)](https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Objets_globaux/Number/toFixed) arrondit le nombre à `n` chiffres après le point et renvoie unechaîne de caractères du résultat.
+2. La méthode [toFixed(n)](https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Objets_globaux/Number/toFixed) arrondit le nombre à `n` chiffres après le point et renvoie une chaîne de caractères du résultat.
         
     ```js run
     let num = 12.34;
     alert( num.toFixed(1) ); // "12.3"
     ```
 
-    Ceci arrondit à la valeur la plus proche, similaire à `Math.round`:
+    Ceci arrondit à la valeur la plus proche, similaire à `Math.round` :
 
     ```js run
     let num = 12.36;
     alert( num.toFixed(1) ); // "12.4"
     ```
 
-    Veuillez noter que le résultat de `toFixed` est une chaîne de caractères. Si la partie décimale est plus courte qu'indiquée, des zéros sont ajoutés à la fin:
+    Veuillez noter que le résultat de `toFixed` est une chaîne de caractères. Si la partie décimale est plus courte qu'indiquée, des zéros sont ajoutés à la fin :
 
     ```js run
     let num = 12.34;
     alert( num.toFixed(5) ); // "12.34000", ajout de zéros pour faire exactement 5 chiffres
     ```
 
-    Nous pouvons le convertir en un nombre en utilisant le plus unaire `+` ou un appel `Number()`: `+num.toFixed(5)`.
+    Nous pouvons le convertir en un nombre en utilisant le plus unaire `+` ou un appel `Number()` : `+num.toFixed(5)`.
 
 ## Calculs imprécis
 
@@ -207,13 +207,13 @@ alert( 0.1 + 0.2 == 0.3 ); // *!*faux*/!*
 
 Si on vérifie si la somme de `0.1` et `0.2` est égale à `0.3` on obtient `faux`.
 
-Étrange! Qu'est-ce que c'est alors si ce n'est pas `0.3`?
+Étrange ! Qu'est-ce que c'est alors si ce n'est pas `0.3`?
 
 ```js run
 alert( 0.1 + 0.2 ); // 0.30000000000000004
 ```
 
-Aie! Imaginez que vous créiez un site d'e-commerce et que le visiteur mette des produits à `0,10 €` et `0,20 €` dans son panier. Le total de la commande sera de `0,30000000000000004 €`. Cela surprendrait n'importe qui.
+Aie ! Imaginez que vous créiez un site d'e-commerce et que le visiteur mette des produits à `0,10 €` et `0,20 €` dans son panier. Le total de la commande sera de `0,30000000000000004 €`. Cela surprendrait n'importe qui.
 
 Mais pourquoi cela se produit-il ?