Merge pull request #460 from ArmandDelessert/patch-1-js-04-object-basics

Apporte plusieurs corrections au chapitre 1.4 (Object Basics)

Author: HachemiH

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

@@ -131,7 +131,7 @@ let key = "likes birds";
 user[key] = true;
 ```
 
-Ici, la variable `key` peut être calculée au moment de l'exécution ou dépendre de la saisie de l'utilisateur. Et ensuite, nous l'utilisons pour accéder à la propriété. Cela nous donne beaucoup de flexibilité. 
+Ici, la variable `key` peut être calculée au moment de l'exécution ou dépendre de la saisie de l'utilisateur. Et ensuite, nous l'utilisons pour accéder à la propriété. Cela nous donne beaucoup de flexibilité.
 
 Par exemple :
 
@@ -147,7 +147,7 @@ let key = prompt("What do you want to know about the user?", "name");
 alert( user[key] ); // John (si entré "name")
 ```
 
-The dot notation cannot be used in a similar way:
+La notation par points ne peut pas être utilisée de la même manière :
 
 ```js run
 let user = {
@@ -251,12 +251,12 @@ let user = {
 
 ## Limitations des noms de propriété
 
-Comme nous le savons déjà, une variable ne peut pas avoir un nom égal à l'un des mots réservés au language comme "for", "let", "return" etc.
+Comme nous le savons déjà, une variable ne peut pas avoir un nom égal à l'un des mots réservés au langage comme "for", "let", "return" etc.
 
 Mais pour une propriété d'objet, il n'y a pas de telle restriction :
 
 ```js run
-// these properties are all right
+// ces propriétés sont toutes correctes
 let obj = {
   for: 1,
   let: 2,
@@ -274,10 +274,10 @@ Par exemple, un nombre `0` devient une chaîne `"0"` lorsqu'il est utilisé comm
 
 ```js run
 let obj = {
-  0: "test" // same as "0": "test"
+  0: "test" // identique à "0": "test"
 };
 
-// both alerts access the same property (the number 0 is converted to string "0")
+// les 2 alertes accèdent à la même propriété (le chiffre 0 est converti en string "0")
 alert( obj["0"] ); // test
 alert( obj[0] ); // test (same property)
 ```
@@ -287,7 +287,7 @@ Il y a un problème mineur avec une propriété spéciale nommée `__proto__`. N
 
 ```js run
 let obj = {};
-obj.__proto__ = 5; // assign a number
+obj.__proto__ = 5; // assignation d'un nombre
 alert(obj.__proto__); // [object Object] - la valeur est un objet, n'a pas fonctionné comme prévu
 ```
 
@@ -336,7 +336,7 @@ alert( *!*key*/!* in user ); // true, la propriété "age" existe
 
 Pourquoi l'opérateur `in` existe-t-il ? N'est-ce pas suffisant de comparer avec `undefined` ?
 
-Eh bien, la plupart du temps, la comparaison avec `undefined` fonctionne bien. Mais il y a un cas particulier quand il échoue, mais `"in"`fonctionne correctement.
+Eh bien, la plupart du temps, la comparaison avec `undefined` fonctionne bien. Mais il y a un cas particulier quand il échoue, mais `in` fonctionne correctement.
 
 C’est lorsque une propriété d’objet existe, mais qu'elle stocke undefined :
 
@@ -363,7 +363,7 @@ Pour parcourir toutes les clés d'un objet, il existe une forme spéciale de bou
 La syntaxe :
 
 ```js
-for(key in object) {
+for (key in object) {
   // exécute le corps pour chaque clé parmi les propriétés de l'objet
 }
 ```
@@ -377,7 +377,7 @@ let user = {
   isAdmin: true
 };
 
-for(let key in user) {
+for (let key in user) {
   // keys
   alert( key );  // name, age, isAdmin
   // valeurs pour les clés
@@ -387,7 +387,7 @@ for(let key in user) {
 
 Notez que toutes les constructions "for" nous permettent de déclarer la variable en boucle à l'intérieur de la boucle, comme `let key` ici.
 
-En outre, nous pourrions utiliser un autre nom de variable ici au lieu de `key`. Par exemple, `"for(let prop in obj)"` est également largement utilisé.
+En outre, nous pourrions utiliser un autre nom de variable ici au lieu de `key`. Par exemple, `for(let prop in obj)` est également largement utilisé.
 
 
 ### Ordonné comme un objet
@@ -424,7 +424,7 @@ Mais si nous exécutons ce code, nous voyons une image totalement différente :
 Les indicatifs de téléphone sont classés par ordre croissant, car ce sont des entiers. Donc on voit `1, 41, 44, 49`.
 
 ````smart header="Propriétés entier (integer properties) ? Qu'est-ce que c'est ?"
-Le terme "propriété entier" (integer properties) désigne ici une chaîne de caractères pouvant être convertie en un entier à partir de-et-sans modification.
+Le terme "propriété entier" (integer properties) désigne ici une chaîne de caractères qui peut être convertie en un nombre entier ou inversement sans changement.
 
 Ainsi, `"49"` est un nom de propriété entier, parce que lorsqu'il est transformé en nombre entier et inversement, il reste identique. Mais `"+49"` et `"1.2"` ne le sont pas :
 
@@ -485,21 +485,21 @@ Ils stockent des propriétés (paires clé-valeur), où :
 
 Pour accéder à une propriété, nous pouvons utiliser :
 - La notation par points : `obj.property`.
-- Notation entre crochets `obj["property"]`. Les crochets permettent de prendre la clé d’une variable, comme `obj[varWithKey]`.
+- Notation entre crochets `obj["property"]`. Les crochets permettent de prendre la clé à partir d’une variable, comme `obj[varWithKey]`.
 
 Opérateurs supplémentaires :
 - Pour supprimer une propriété : `delete obj.prop`.
 - Pour vérifier si une propriété avec la clé donnée existe : `"key" in obj`.
 - Pour parcourir un objet : la boucle `for (let key in obj)`.
 
-Ce que nous avons étudié dans ce chapitre s’appelle un "objet simple" (plain object) ou juste `Object`.  
+Ce que nous avons étudié dans ce chapitre s’appelle un "objet simple" (plain object) ou juste `Object`.
 Il existe de nombreux autres types d'objets en JavaScript :
 
 - `Array` pour stocker des collections de données ordonnées,
 - `Date` pour stocker des informations sur la date et l'heure,
 - `Error` pour stocker des informations sur une erreur.
-- … Etc.
+- Etc.
 
-Ils ont leurs particularités que nous étudierons plus tard. Parfois, les gens disent quelque chose comme "Type de tableau" ou "Type de date", mais ils ne sont pas formellement propres, mais appartiennent à un seul type de données "objet". Et ils l'étendent de différentes manières.
+Ils ont leurs particularités que nous étudierons plus tard. Parfois, les gens disent quelque chose comme "type Tableau" ou "type Date", mais ils ne sont pas formellement propres, mais appartiennent à un seul type de données "objet". Et ils l'étendent de différentes manières.
 
 Les objets en JavaScript sont très puissants. Nous venons de gratter la surface d’un sujet vraiment énorme. Nous allons travailler étroitement avec les objets et en apprendre davantage à leur sujet dans d’autres parties du tutoriel.

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

@@ -39,7 +39,7 @@ L'objet est stocké quelque part dans la mémoire (du coté droit de l'image), t
 
 On peut imaginer la variable d'objet, ici `user`, comme une feuille de papier avec l'adresse de l'objet écrit dessus.
 
-Lorque l'on réalise une action avec l'objet, par exemple récupérer la propriété `user.name`, le moteur de Javascript regarde à l'adresse et réalise l'opération sur l'objet actuel.
+Lorque l'on réalise une action avec l'objet, par exemple récupérer la propriété `user.name`, le moteur de JavaScript regarde à l'adresse et réalise l'opération sur l'objet actuel.
 
 Et voilà pourquoi cela est important.
 
@@ -152,7 +152,7 @@ for (let key in user) {
 // 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é
+alert( user.name ); // c'est toujour John dans l'objet copié
 ```
 
 On peut aussi utiliser la méthode [Object.assign](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign) pour cela.
@@ -220,7 +220,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 `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à ?
+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
@@ -278,11 +278,11 @@ let user = {
 let clone = structuredClone(user);
 */!*
 
-alert( user.sizes === clone.sizes ); // false, different objects
+alert( user.sizes === clone.sizes ); // false, c'est un objet différent
 
-// user and clone are totally unrelated now
-user.sizes.width = 60;    // change a property from one place
-alert(clone.sizes.width); // 50, not related
+// user et clone n'ont plus aucun lien entre eux
+user.sizes.width = 60;    // changer une propriété d'un endroit
+alert(clone.sizes.width); // 50, sans lien
 ```
 
 La méthode `structuredClone` peut cloner la plupart des types de données, tels que des objets, des tableaux, des valeurs primitives.
@@ -316,7 +316,7 @@ structuredClone({
 
 Les propriétés de fonction ne sont pas prises en charge.
 
-Pour gérer des cas aussi complexes, nous devrons peut-être utiliser une combinaison de méthodes de clonage, écrire du code personnalisé ou, pour ne pas réinventer la roue, prendre une implémentation existante, par exemple [_.cloneDeep(obj)](https://lodash.com /docs#cloneDeep) de la bibliothèque JavaScript [lodash](https://lodash.com).
+Pour gérer des cas aussi complexes, nous devrons peut-être utiliser une combinaison de méthodes de clonage, écrire du code personnalisé ou, pour ne pas réinventer la roue, prendre une implémentation existante, par exemple [_.cloneDeep(obj)](https://lodash.com/docs#cloneDeep) de la bibliothèque JavaScript [lodash](https://lodash.com).
 
 ## Résumé
 

1-js/04-object-basics/04-object-methods/4-object-property-this/solution.md

@@ -18,7 +18,7 @@ C'est parce que les règles qui définissent `this` ne prennent pas en compte la
 
 Ici, la valeur de `this` à l'intérieur de `makeUser()` est `undefined`, car elle est appelée en tant que fonction et non en tant que méthode avec la syntaxe au "point".
 
-La valeur de `this` est un pour toute la fonction, les blocs de code et les littéraux d'objet ne l'affectent pas.
+La valeur de `this` est la même pour toute la fonction, les blocs de code et les littéraux d'objet ne l'affectent pas.
 
 Donc `ref: this` prend actuellement le `this` courant de la fonction.
 
@@ -53,4 +53,3 @@ alert( user.ref().name ); // John
 ```
 
 Maintenant cela fonctionne parce que `user.ref()` est une méthode. Et la valeur de `this` est définie pour l'objet avant le point `.`.
-

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

@@ -198,14 +198,14 @@ admin.f = sayHi;
 */!*
 
 // ces appels ont un this différent
-// "this" à l'intérieur de la fonction se trouve l'objet "avant le point"
+// "this" à l'intérieur de la fonction est l'objet "avant le point"
 user.f(); // John  (this == user)
 admin.f(); // Admin  (this == admin)
 
 admin['f'](); // Admin (le point ou les crochets accèdent à la méthode - peu importe)
 ```
 
-La règle est simple: si `obj.f()` est appelé, alors `this` est `obj` pendant l'appel de `f`. C'est donc l'`user` ou l'`admin` dans l'exemple ci-dessus.
+La règle est simple : si `obj.f()` est appelé, alors `this` est `obj` pendant l'appel de `f`. C'est donc l'`user` ou l'`admin` dans l'exemple ci-dessus.
 
 ````smart header="Appel sans objet : `this` == undefined"
 Nous pouvons même appeler la fonction sans objet du tout :
@@ -220,7 +220,7 @@ sayHi(); // undefined
 
 Dans ce cas, `this` est `undefined` en mode strict. Si nous essayons d'accéder à `this.name`, il y aura une erreur.
 
-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"`.
+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 que le mode strict corrige.
 
 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.
 ````

1-js/04-object-basics/06-constructor-new/article.md

@@ -2,11 +2,11 @@
 
 La syntaxe normale `{...}` permet de créer un seul objet. Mais souvent, nous devons créer de nombreux objets similaires, tels que plusieurs utilisateurs ou éléments de menu, etc.
 
-Cela peut être fait en utilisant les fonctions du constructeur et l'opérateur `"new"`.
+Cela peut être fait en utilisant les fonctions constructeur et l'opérateur `"new"`.
 
 ## La function constructeur
 
-Les fonctions du constructeur sont techniquement des fonctions habituelles. Il existe cependant deux conventions :
+Les fonctions constructeur sont techniquement des fonctions habituelles. Il existe cependant deux conventions :
 
 1. Elles  sont nommées avec une lettre majuscule en premier.
 2. Elles ne devraient être executées qu'avec l'opérateur `"new"`.
@@ -71,13 +71,13 @@ Si nous avons beaucoup de lignes de code concernant la création d'un seul objet
 
 ```js
 // create a function and immediately call it with new
-let user = new function() { 
+let user = new function() {
   this.name = "John";
   this.isAdmin = false;
 
   // ...autre code pour la création d'utilisateur
   // peut-être une logique complexe et des déclarations
-  // variables locales  etc
+  // de variables locales etc.
 };
 ```
 
@@ -117,7 +117,7 @@ Nous pouvons également faire des appels `new` et réguliers pour faire la même
 ```js run
 function User(name) {
   if (!new.target) { // si vous m'executer sans new
-    return new User(name); // ...J'ajouterai du new pour vous
+    return new User(name); // ...j'ajouterai un new pour vous
   }
 
   this.name = name;
@@ -152,7 +152,7 @@ function BigUser() {
   return { name: "Godzilla" };  // <-- retourne cet objet
 }
 
-alert( new BigUser().name );  // Godzilla, got that object
+alert( new BigUser().name );  // Godzilla, obtenu cet objet
 ```
 
 Et voici un exemple avec un `return` vide (ou nous pourrions placer une primitive après, peu importe) :
@@ -175,7 +175,7 @@ Généralement, les constructeurs n’ont pas d’instruction `return`. Nous men
 
 ```js
 let user = new User; // <-- pas de parenthèses
-// same as
+// identique à
 let user = new User();
 ```
 
@@ -213,12 +213,12 @@ john = {
 */
 ```
 
-Pour créer des objets complexes, il existe une syntaxe plus avancée, [classes](info:classes), que nous allons couvrir plus tard.
+Pour créer des objets complexes, il existe une syntaxe plus avancée, les [classes](info:classes), que nous allons couvrir plus tard.
 
 ## Résumé
 
 - Les fonctions constructeur ou, plus brièvement, les constructeurs, sont des fonctions normales, mais il est généralement convenu de les nommer avec une première lettre en majuscule.
-- Les fonctions constructeur ne doivent être appelées qu'avec `new`. Un tel appel implique la création d'un `this` vide au début et de le retourner complété à la fin.
+- Les fonctions constructeur ne doivent être appelées qu'avec `new`. Un tel appel implique la création d'un objet `this` vide au début de la fonction et le renvoi de l'objet complété à la fin.
 
 Nous pouvons utiliser des fonctions constructeurs pour créer plusieurs objets similaires.
 
@@ -227,5 +227,5 @@ JavaScript fournit des fonctions constructeur pour de nombreux objets intégrés
 ```smart header="Objets, nous reviendrons !"
 Dans ce chapitre, nous ne couvrons que les bases sur les objets et les constructeurs. Elles sont essentielles pour en savoir plus sur les types de données et les fonctions dans les chapitres suivants.
 
-Après avoir appris cela, dans le chapitre <info:object-oriented-programming> nous reviendrons aux objets et les couvrirons en profondeur, y compris l'héritage et les classes.
+Après avoir appris cela, nous reviendrons aux objets et les couvrirons en profondeur dans les chapitres <info:prototypes> et <info:classes>.
 ```