Merge pull request #246 from javascript-tutorial/sync-0599d07b

Sync with upstream @ 0599d07

Author: HachemiH

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

@@ -1,6 +1,10 @@
 # Une Introduction à JavaScript
 
+<<<<<<< HEAD
 Voyons ce qui est spécial à propos de JavaScript, ce qu'il nous permet de faire et avec quelles autres technologies il s'accorde bien.
+=======
+Let's see what's so special about JavaScript, what we can achieve with it, and what other technologies play well with it.
+>>>>>>> 0599d07b3c13ee25f583fc091cead3c17a7e7779
 
 ## Qu'est-ce que JavaScript?
 
@@ -67,7 +71,12 @@ Les exemples de telles restrictions sont:
 
     Les navigateurs modernes lui permettent de fonctionner avec des fichiers, mais l'accès est limité et n'est fourni que si l'utilisateur effectue certaines actions, comme «déposer» un fichier dans une fenêtre de navigateur ou le sélectionner via une balise `<input>`.
 
+<<<<<<< HEAD
     Il existe des moyens d’interagir avec une webcam / microphone et d’autres appareils, mais ils nécessitent une autorisation explicite de l’utilisateur. Ainsi, une page compatible avec JavaScript ne permet pas d'activer une caméra Web, d'observer l'environnement et d'envoyer les informations à la [NSA](https://fr.wikipedia.org/wiki/National_Security_Agency).
+=======
+    There are ways to interact with camera/microphone and other devices, but they require a user's explicit permission. So a JavaScript-enabled page may not sneakily enable a web-camera, observe the surroundings and send the information to the [NSA](https://en.wikipedia.org/wiki/National_Security_Agency).
+- Different tabs/windows generally do not know about each other. Sometimes they do; for example when one window uses JavaScript to open the other one. But even in this case, JavaScript from one page may not access the other if they come from different sites (from a different domain, protocol or port).
+>>>>>>> 0599d07b3c13ee25f583fc091cead3c17a7e7779
 
 - Différents onglets / fenêtres ne se connaissent généralement pas. Parfois, ils se croisent, par exemple lorsqu'une fenêtre utilise JavaScript pour ouvrir l'autre. Mais même dans ce cas, le JavaScript d'une page ne peut pas accéder à l'autre si elle provient de sites différents (provenant d'un autre domaine, protocole ou port).
 
@@ -119,6 +128,12 @@ Il en existe évidemment bien plus, cela dit, même si nous utilisons un de ces
 
 ## Résumé
 
+<<<<<<< HEAD
 - JavaScript a été initialement créé en tant que langage de navigateur uniquement, mais il est désormais également utilisé dans de nombreux autres environnements.
 - En ce moment, JavaScript occupe une position unique en tant que langage de navigateur le plus largement adopté avec une intégration complète avec HTML / CSS.
 - De nombreux langages sont "transpilés" en JavaScript et fournissent certaines fonctionnalités. Il est recommandé d'y jeter un coup d'œil, au moins brièvement, après avoir maîtrisé JavaScript.
+=======
+- JavaScript was initially created as a browser-only language, but it is now used in many other environments as well.
+- Today, JavaScript has a unique position as the most widely-adopted browser language with full integration in HTML/CSS.
+- There are many languages that get "transpiled" to JavaScript and provide certain features. It is recommended to take a look at them, at least briefly, after mastering JavaScript.
+>>>>>>> 0599d07b3c13ee25f583fc091cead3c17a7e7779

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

@@ -144,7 +144,11 @@ Affectations
 : Il y a une assignation simple : `a = b` et des combinés comme `a *= 2`.
 
 Bitwise
+<<<<<<< HEAD
 : Les opérateurs au niveau des bits fonctionnent avec des entiers de niveau binaire : voir la [doc](mdn:/JavaScript/Reference/Operators/Bitwise_Operators) quand ils sont nécessaires.
+=======
+: Bitwise operators work with 32-bit integers at the lowest, bit-level: see the [docs](mdn:/JavaScript/Guide/Expressions_and_Operators#Bitwise) when they are needed.
+>>>>>>> 0599d07b3c13ee25f583fc091cead3c17a7e7779
 
 Conditionnel
 : Le seul opérateur avec trois paramètres : `cond ? resultA : resultB`. Si `cond` est vrai, retourne `resultA`, autrement `resultB`.

1-js/04-object-basics/01-object/8-multiply-numeric/task.md

@@ -2,9 +2,15 @@ importance: 3
 
 ---
 
+<<<<<<< HEAD
 # Multipliez les propriétés numériques par 2
 
 Créez une fonction `multiplyNumeric(obj)` qui multiplie toutes les propriétés numériques de `obj` par `2`.
+=======
+# Multiply numeric property values by 2
+
+Create a function `multiplyNumeric(obj)` that multiplies all numeric property values of `obj` by `2`.
+>>>>>>> 0599d07b3c13ee25f583fc091cead3c17a7e7779
 
 Par exemple :
 

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

@@ -1,10 +1,12 @@
-# Object copying, references
+# Object references and copying
 
-One of the fundamental differences of objects vs primitives is that they are stored and copied "by reference".
+One of the fundamental differences of objects versus primitives is that objects are stored and copied "by reference", as opposed to primitive values: strings, numbers, booleans, etc -- that are always copied "as a whole value".
 
-Primitive values: strings, numbers, booleans -- are assigned/copied "as a whole value".
+That's easy to understand if we look a bit "under a cover" of what happens when we copy a value.
 
-For instance:
+Let's start with a primitive, such as a string.
+
+Here we put a copy of `message` into `phrase`:
 
 ```js
 let message = "Hello!";
@@ -15,21 +17,31 @@ As a result we have two independent variables, each one is storing the string `"
 
 ![](variable-copy-value.svg)
 
+Quite an obvious result, right?
+
 Objects are not like that.
 
-**A variable stores not the object itself, but its "address in memory", in other words "a reference" to it.**
+**A variable assigned to an object stores not the object itself, but its "address in memory", in other words "a reference" to it.**
 
-Here's the picture for the object:
+Let's look at an example of such variable:
 
 ```js
 let user = {
   name: "John"
 };
 ```
 
+And here's how it's actually stored in memory:
+
 ![](variable-contains-reference.svg)
 
-Here, the object is stored somewhere in memory. And the variable `user` has a "reference" to it.
+The object is stored somewhere in memory (at the right of the picture), while the `user` variable (at the left) has a "reference" to it.
+
+We may think of an object variable, such as `user`, as of a sheet of paper with the address.
+
+When we perform actions with the object, e.g. take a property `user.name`, JavaScript engine looks into that address and performs the operation on the actual object.
+
+Now here's why it's important.
 
 **When an object variable is copied -- the reference is copied, the object is not duplicated.**
 
@@ -45,6 +57,8 @@ Now we have two variables, each one with the reference to the same object:
 
 ![](variable-copy-reference.svg)
 
+As you can see, there's still one object, now with two variables that reference it.
+
 We can use any variable to access the object and modify its contents:
 
 ```js run
@@ -59,15 +73,14 @@ admin.name = 'Pete'; // changed by the "admin" reference
 alert(*!*user.name*/!*); // 'Pete', changes are seen from the "user" reference
 ```
 
-The example above demonstrates that there is only one object. As if we had a cabinet with two keys and used one of them (`admin`) to get into it. Then, if we later use another key (`user`) we can see changes.
 
-## Comparison by reference
+It's just as if we had a cabinet with two keys and used one of them (`admin`) to get into it. Then, if we later use another key (`user`) we can see changes.
 
-The equality `==` and strict equality `===` operators for objects work exactly the same.
+## Comparison by reference
 
-**Two objects are equal only if they are the same object.**
+Two objects are equal only if they are the same object.
 
-Here two variables reference the same object, thus they are equal:
+For instance, here `a` and `b` reference the same object, thus they are equal:
 
 ```js run
 let a = {};
@@ -77,7 +90,7 @@ alert( a == b ); // true, both variables reference the same object
 alert( a === b ); // true
 ```
 
-And here two independent objects are not equal, even though both are empty:
+And here two independent objects are not equal, even though they look alike (both are empty):
 
 ```js run
 let a = {};
@@ -86,7 +99,7 @@ let b = {}; // two independent objects
 alert( a == b ); // false
 ```
 
-For comparisons like `obj1 > obj2` or for a comparison against a primitive `obj == 5`, objects are converted to primitives. We'll study how object conversions work very soon, but to tell the truth, such comparisons occur very rarely, usually as a result of a coding mistake.
+For comparisons like `obj1 > obj2` or for a comparison against a primitive `obj == 5`, objects are converted to primitives. We'll study how object conversions work very soon, but to tell the truth, such comparisons are needed very rarely, usually they appear as a result of a programming mistake.
 
 ## Cloning and merging, Object.assign
 

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

@@ -32,11 +32,19 @@ user.sayHi = function() {
 user.sayHi(); // Hello!
 ```
 
+<<<<<<< HEAD
 Ici, nous venons d'utiliser une expression de fonction pour créer la fonction et l'affecter à la propriété `user.sayHi` de l'objet.
 
 Ensuite, nous pouvons l'appeler. L'utilisateur peut maintenant parler!
 
 Une fonction qui est la propriété d'un objet s'appelle sa *méthode*.
+=======
+Here we've just used a Function Expression to create a function and assign it to the property `user.sayHi` of the object.
+
+Then we can call it as `user.sayHi()`. The user can now speak!
+
+A function that is a property of an object is called its *method*.
+>>>>>>> 0599d07b3c13ee25f583fc091cead3c17a7e7779
 
 Nous avons donc ici une méthode `sayHi` de l’objet `user`.
 
@@ -160,14 +168,24 @@ let user = {
 let admin = user;
 user = null; // écraser pour rendre les choses évidentes
 
+<<<<<<< HEAD
 admin.sayHi(); // Oups ! Dans sayHi(), l'ancien nom est utilisé ! Erreur !
+=======
+*!*
+admin.sayHi(); // TypeError: Cannot read property 'name' of null
+*/!*
+>>>>>>> 0599d07b3c13ee25f583fc091cead3c17a7e7779
 ```
 
 Si nous utilisions `this.name` au lieu de `user.name` dans l'`alert`, le code fonctionnerait.
 
 ## "this" n'est pas lié
 
+<<<<<<< HEAD
 En JavaScript, le mot clé `this` se comporte différemment de la plupart des autres langages de programmation. Il peut être utilisé dans n'importe quelle fonction.
+=======
+In JavaScript, keyword `this` behaves unlike most other programming languages. It can be used in any function, even if it's not a method of an object.
+>>>>>>> 0599d07b3c13ee25f583fc091cead3c17a7e7779
 
 Il n’y a pas d’erreur de syntaxe dans le code suivant :
 

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

@@ -4,21 +4,30 @@
 
 [recent browser="new"]
 
-Le chaînage optionnel `?.` Est un moyen sans erreur d'accéder aux propriétés d'objet imbriquées, même si une propriété intermédiaire n'existe pas.
 
-## Le problème
+Le chaînage optionnel `?.` Est un moyen sécurisé d'accéder aux propriétés d'objet imbriquées, même si une propriété intermédiaire n'existe pas.
+
+## Le problème de la "propriété non existante"
+
 
 Si vous venez de commencer à lire le tutoriel et à apprendre JavaScript, peut-être que le problème ne vous a pas encore touché, mais c'est assez courant.
 
-Par exemple, certains de nos utilisateurs ont des adresses, mais peu ne les ont pas fournies. Ensuite, nous ne pouvons pas lire en toute sécurité `user.address.street` :
+
+À titre d'exemple, considérons les objets pour les données utilisateur. La plupart de nos utilisateurs ont des adresses dans la propriété `user.address`, avec la rue `user.address.street`, mais certains ne les ont pas fournies.
+Dans ce cas, lorsque nous tentons d'obtenir `user.address.street`, nous obtenons une erreur :
 
 ```js run
-let user = {}; // l'utilisateur se trouve être sans adresse
+let user = {}; // l'utilisateur sans propriété "address"
+
 
 alert(user.address.street); // Error!
 ```
 
-Ou, dans le développement Web, nous aimerions obtenir une information sur un élément de la page, mais il peut ne pas exister :
+
+C'est le résultat attendu, JavaScript fonctionne comme ça, mais dans de nombreux cas pratiques, nous préférerions obtenir `undefined` au lieu d'une erreur (signifiant "pas de rue").
+
+... Et un autre exemple. Dans le développement Web, nous pouvons avoir besoin d'obtenir une information sur un élément de la page, qui n'existe parfois pas:
+
 
 ```js run
 // Erreur si le résultat de querySelector(...) est null
@@ -35,7 +44,9 @@ let user = {}; // l'utilisateur n'a pas d'adresse
 alert( user && user.address && user.address.street ); // undefined (no error)
 ```
 
-ET le chemin d'accès complet à la propriété garantit que tous les composants existent, mais il est difficile à écrire.
+
+ET l'ensemble du chemin d'accès à la propriété garantit que tous les composants existent (sinon, l'évaluation s'arrête), mais est difficile à écrire.
+
 
 ## Chaînage optionnel
 
@@ -71,7 +82,9 @@ Nous ne devrions utiliser `?.` que là où il est normal que quelque chose n'exi
 
 Par exemple, si selon notre logique de codage, l'objet `user` doit être là, mais que `address` est facultatif, alors `user.address?.street` serait mieux.
 
-Donc, si `user` n'est pas défini à cause d'une erreur, nous le saurons et le réparerons. Sinon, les erreurs de codage peuvent être réduites au silence lorsqu'elles ne sont pas appropriées et devenir plus difficiles à déboguer.
+
+Donc, si `user` n'est pas défini en raison d'une erreur, nous verrons une erreur de programmation à ce sujet et la corrigerons. Sinon, les erreurs de codage peuvent être réduites au silence lorsqu'elles ne sont pas appropriées et devenir plus difficiles à déboguer.
+
 ```
 
 ````warn header="La variable avant `?.` doit être déclarée"
@@ -81,26 +94,33 @@ S'il n'y a pas du tout de variable `user`, alors `user?.anything` déclenche une
 // ReferenceError: user is not defined
 user?.address;
 ```
-Il doit y avoir `let/const/var user`. Le chaînage optionnel ne fonctionne que pour les variables déclarées.
+
+Il doit y avoir une déclaration (par exemple `let/const/var user`). Le chaînage optionnel ne fonctionne que pour les variables déclarées.
+
 ````
 
 ## Court-circuit
 
 Comme il a été dit précédemment, le `?.` arrête immédiatement ("court-circuite") l'évaluation si la partie gauche n'existe pas.
 
+
 Donc, s'il y a d'autres appels de fonction ou effets secondaires, ils ne se produisent pas :
 
+Par exemple :
+
 ```js run
 let user = null;
 let x = 0;
 
-user?.sayHi(x++); // rien ne se passe
+
+user?.sayHi(x++); // pas de "sayHi", donc l'exécution n'atteint pas x++
+
 
 alert(x); // 0, la valeur n'est pas incrémenté
 ```
 
 
-## Autres cas : ?.(), ?.[]
+## Autres variantes : ?.(), ?.[]
 
 `?.` n'est pas un opérateur, mais une construction syntaxique particulière qui fonctionne aussi avec les appels de fonction et les crochets.
 
@@ -123,9 +143,10 @@ user2.admin?.();
 */!*
 ```
 
-Ici, dans les deux lignes, nous utilisons d'abord le point `.` pour obtenir la propriété `admin`, car l'objet utilisateur doit exister, il peut donc être lu en toute sécurité.
 
-Puis `?.()` Vérifie la partie gauche : si la fonction admin existe, alors elle s'exécute (pour `user1`). Sinon (pour `user2`), l'évaluation s'arrête sans erreur.
+Ici, dans les deux lignes, nous utilisons d'abord le point (`user1.admin`) pour obtenir la propriété `admin`, car l'objet utilisateur doit exister, donc il peut être lu en toute sécurité.
+Puis `?.()` Vérifie la partie gauche : si la fonction admin existe, alors elle s'exécute (c'est le cas pour `user1`). Sinon (pour `user2`) l'évaluation s'arrête sans erreur.
+
 
 La syntaxe `?.[]` Fonctionne également, si nous voulons utiliser des crochets `[]` pour accéder aux propriétés au lieu du point `.`. Similaire aux cas précédents, il permet de lire en toute sécurité une propriété à partir d'un objet qui peut ne pas exister.
 
@@ -150,28 +171,34 @@ Nous pouvons également utiliser `?.` avec `delete` :
 delete user?.name; // supprime user.name si user existe
 ```
 
+
 ```warn header="Nous pouvons utiliser `?.` pour lire et supprimer en toute sécurité, mais pas pour écrire"
 Le chaînage optionnel `?.` n'a aucune utilité sur le côté gauche d'une affectation :
 
+
+For example:
 ```js run
-// l'idée du code ci-dessous est d'écrire user.name, si l'utilisateur existe
+
+let user = null;
 
 user?.name = "John"; // Erreur, ne fonctionne pas
 // car il évalue à undefined = "John"
 ```
+Ce n'est tout simplement pas si intelligent.
 
 ## Résumé
 
-La syntaxe `?.` A trois formes :
+Le chaînage optionnel '?.' A trois formes :
 
 1. `obj?.prop` -- retourne `obj.prop` si `obj` existe, sinon `undefined`.
 2. `obj?.[prop]` -- retourne `obj[prop]` si `obj` existe, sinon `undefined`.
-3. `obj?.method()` -- appel `obj.method()` si `obj` existe, sinon retourne `undefined`.
+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.
 
 Une chaîne de `?.` permet d'accéder en toute sécurité aux propriétés imbriquées.
 
-Néanmoins, nous devons appliquer `?.` Avec soin, uniquement là où il est normal que la partie gauche n'existe pas.
 
-Pour qu'il ne nous cache pas les erreurs de programmation, si elles se produisent.
+Néanmoins, nous devons appliquer «?.» Avec soin, uniquement s'il est acceptable que la partie gauche n'existe pas. Pour ne pas nous cacher les erreurs de programmation, si elles se produisent.
+

1-js/05-data-types/03-string/article.md

@@ -111,7 +111,11 @@ alert( 'I*!*\'*/!*m the Walrus!' ); // *!*I'm*/!* the Walrus!
 
 Comme vous pouvez le constater, nous devons précéder le simple quote intérieure du backslash `\'`, sinon, cela indiquerait la fin de la chaîne de caractères.
 
+<<<<<<< HEAD
 Bien sûr, il ne faut échapper que les guillemets identiques à ceux qui les entourent. Donc, comme solution plus élégante, nous pourrions passer aux guillemets doubles ou aux backticks :
+=======
+Of course, only the quotes that are the same as the enclosing ones need to be escaped. So, as a more elegant solution, we could switch to double quotes or backticks instead:
+>>>>>>> 0599d07b3c13ee25f583fc091cead3c17a7e7779
 
 ```js run
 alert( `I'm the Walrus!` ); // I'm the Walrus!
@@ -316,7 +320,11 @@ if (str.indexOf("Widget") != -1) {
 #### L'astuce du NON binaire
 L’un des vieux trucs utilisés ici est l'opérateur [NON binaire](https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateurs_binaires#(NON_binaire)) `~`. Il convertit le nombre en un entier de 32 bits (supprime la partie décimale, s'elle existe), puis inverse tous les bits de sa représentation binaire.
 
+<<<<<<< HEAD
 Pour les entiers 32 bits, l'appel `~n` signifie exactement la même chose que `-(n+1)` (en raison du format IEEE-754).
+=======
+One of the old tricks used here is the [bitwise NOT](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_NOT) `~` operator. It converts the number to a 32-bit integer (removes the decimal part if exists) and then reverses all bits in its binary representation.
+>>>>>>> 0599d07b3c13ee25f583fc091cead3c17a7e7779
 
 En pratique, cela signifie une chose simple: pour les entiers 32 bits, `~n` est égal à `-(n + 1)`.
 
@@ -349,7 +357,11 @@ Il n'est généralement pas recommandé d'utiliser les fonctionnalités du langa
 
 Rappelez-vous juste que : `if (~str.indexOf(...))` se lit "si trouvé".
 
+<<<<<<< HEAD
 Pour être précis cependant, les grands nombres sont tronqués à 32 bits par l'opérateur `~`. Il existe donc d'autres gros nombres qui donnent `0`, le plus petit correspondant à `~4294967295 = 0`. Cela rend cette vérification est correcte que si une chaîne n'est pas si longue.
+=======
+To be precise though, as big numbers are truncated to 32 bits by `~` operator, there exist other numbers that give `0`, the smallest is `~4294967295=0`. That makes such check correct only if a string is not that long.
+>>>>>>> 0599d07b3c13ee25f583fc091cead3c17a7e7779
 
 Pour le moment, nous ne voyons cette astuce que dans l'ancien code, car JavaScript fournit une méthode `.includes` (voir ci-dessous).