Merge pull request #417 from javascript-tutorial/sync-5dff42ba

Sync with upstream @ 5dff42b

Author: HachemiH

1-js/01-getting-started/3-code-editors/article.md

@@ -33,15 +33,32 @@ En pratique, les éditeurs légers peuvent avoir beaucoup de plug-ins, y compris
 
 Les options suivantes méritent votre attention :
 
+<<<<<<< HEAD
 - [Sublime Text](http://www.sublimetext.com) (multiplateforme, payant).
 - [Notepad++](https://notepad-plus-plus.org/) (Windows, gratuit).
 - [Vim](http://www.vim.org/) et [Emacs](https://www.gnu.org/software/emacs/) sont également cool, si vous savez comment les utiliser.
 
+=======
+There are many options, for instance:
+
+- [Sublime Text](https://www.sublimetext.com/) (cross-platform, shareware).
+- [Notepad++](https://notepad-plus-plus.org/) (Windows, free).
+- [Vim](https://www.vim.org/) and [Emacs](https://www.gnu.org/software/emacs/) are also cool if you know how to use them.
+>>>>>>> 5dff42ba283bce883428c383c080fa9392b71df8
 
 ## Ne discutons pas
 
 Les éditeurs des listes ci-dessus sont ceux que moi-même ou mes amis, que je considère comme de bons développeurs, utilisent depuis longtemps et en sont satisfaits.
 
 Il y a d'autres grands éditeurs dans notre vaste monde. Veuillez choisir celui que vous aimez le plus.
 
+<<<<<<< HEAD
 Le choix d'un éditeur, comme tout autre outil, est individuel et dépend de vos projets, de vos habitudes, de vos préférences personnelles.
+=======
+The choice of an editor, like any other tool, is individual and depends on your projects, habits, and personal preferences.
+
+The author's personal opinion:
+
+- I'd use [Visual Studio Code](https://code.visualstudio.com/) if I develop mostly frontend.
+- Otherwise, if it's mostly another language/platform and partially frontend, then consider other editors, such as XCode (Mac), Visual Studio (Windows) or Jetbrains family (Webstorm, PHPStorm, RubyMine etc, depending on the language).
+>>>>>>> 5dff42ba283bce883428c383c080fa9392b71df8

1-js/02-first-steps/04-variables/article.md

@@ -150,8 +150,13 @@ let message = "That"; // SyntaxError: 'message' has already been declared
 Donc, nous devrions déclarer une variable une fois et y faire référence sans `let`.
 ````
 
+<<<<<<< HEAD
 ```smart header="Langages fonctionnels"
 Il peut être intéressant de savoir qu'il existe aussi des langages de [programmation fonctionelle](https://fr.wikipedia.org/wiki/Programmation_fonctionnelle), comme [Scala](http://www.scala-lang.org/) ou [Erlang](http://www.erlang.org/) qui interdisent de modifier une valeur de variable.
+=======
+```smart header="Functional languages"
+It's interesting to note that there exist [functional](https://en.wikipedia.org/wiki/Functional_programming) programming languages, like [Scala](https://www.scala-lang.org/) or [Erlang](https://www.erlang.org/) that forbid changing variable values.
+>>>>>>> 5dff42ba283bce883428c383c080fa9392b71df8
 
 Dans ce genre de langage, une fois la valeur stockée dans la boîte, elle est là pour toujours. Si nous devons stocker autre chose, le langage nous oblige à créer une nouvelle boîte (déclarer une nouvelle variable). Nous ne pouvons pas réutiliser l’ancienne.
 
@@ -197,8 +202,13 @@ let mon-nom; // un trait d'union '-' n'est pas autorisé dans le nom
 Des variables nommées `apple` et `APPLE` sont deux variables différentes.
 ```
 
+<<<<<<< HEAD
 ````smart header="Les lettres non latines sont autorisées mais non recommandées"
 Il est possible d'utiliser n'importe quel langage, y compris les lettres cyrilliques ou même les hiéroglyphes, comme ceci :
+=======
+````smart header="Non-Latin letters are allowed, but not recommended"
+It is possible to use any language, including cyrillic letters, Chinese logograms and so on, like this:
+>>>>>>> 5dff42ba283bce883428c383c080fa9392b71df8
 
 ```js
 let имя = '...';

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

@@ -79,7 +79,11 @@ alert( 8 ** (1/3) ); // 2 (la puissance de 1/3 équivaut à une racine cubique)
 
 ## Concaténation de chaînes de caractères, binaire `+`
 
+<<<<<<< HEAD
 Voyons maintenant les caractéristiques spéciales des opérateurs JavaScript qui sont au-delà de l’arithmétique scolaire.
+=======
+Let's meet the features of JavaScript operators that are beyond school arithmetics.
+>>>>>>> 5dff42ba283bce883428c383c080fa9392b71df8
 
 Habituellement, l'opérateur `+` additionne des chiffres.
 

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

@@ -31,15 +31,15 @@ Par exemple, nous affichons ici `user` si sa valeur n'est pas `null/undefined`,
 ```js run
 let user;
 
-alert(user ?? "Anonymous"); // Anonymous (user not defined)
+alert(user ?? "Anonymous"); // Anonymous (user is undefined)
 ```
 
 Voici l'exemple avec `user` attribué à un nom :
 
 ```js run
 let user = "John";
 
-alert(user ?? "Anonymous"); // John (user defined)
+alert(user ?? "Anonymous"); // John (user is not null/udefined)
 ```
 
 Nous pouvons également utiliser une séquence de `??` pour sélectionner la première valeur dans une liste qui n'est pas `null/undefined`.

1-js/02-first-steps/15-function-basics/article.md

@@ -461,7 +461,11 @@ Ces exemples supposent des significations communes de préfixes. Vous et votre 
 ```smart header="Noms de fonction ultra-courts"
 Les fonctions utilisées *très souvent* portent parfois des noms ultra-courts.
 
+<<<<<<< HEAD
 Par exemple le framework [jQuery](http://jquery.com) définit une fonction avec `$`. La librairie [LoDash](http://lodash.com/) a nommé sa fonction principale `_`.
+=======
+For example, the [jQuery](https://jquery.com/) framework defines a function with `$`. The [Lodash](https://lodash.com/) library has its core function named `_`.
+>>>>>>> 5dff42ba283bce883428c383c080fa9392b71df8
 
 Ce sont des exceptions. En règle générale, les noms de fonctions doivent être concis et descriptifs.
 ```

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

@@ -68,13 +68,23 @@ La spécification peut être exécutée et le test spécifié dans le bloc `it`
 
 Le flux de développement ressemble généralement à ceci :
 
+<<<<<<< HEAD
 1. Une spécification initiale est écrite, avec des tests pour les fonctionnalités les plus élémentaires.
 2. Une implémentation initiale est créée.
 3. Pour vérifier si cela fonctionne, nous exécutons le framework de test [Mocha](http://mochajs.org/) (plus de détails bientôt) qui exécute la spécification. Tant que la fonctionnalité n'est pas complète, des erreurs sont affichées. Nous apportons des corrections jusqu'à ce que tout fonctionne.
 4. Nous avons maintenant une implémentation initiale de travail avec des tests.
 5. Nous ajoutons d'autres cas d'utilisation à la spécification, probablement pas encore pris en charge par les implémentations. Les tests commencent à échouer.
 6. Passez à l'étape 3, mettez à jour l'implémentation jusqu'à ce que les tests ne génèrent aucune erreur.
 7. Répétez les étapes 3 à 6 jusqu'à ce que la fonctionnalité soit prête.
+=======
+1. An initial spec is written, with tests for the most basic functionality.
+2. An initial implementation is created.
+3. To check whether it works, we run the testing framework [Mocha](https://mochajs.org/) (more details soon) that runs the spec. While the functionality is not complete, errors are displayed. We make corrections until everything works.
+4. Now we have a working initial implementation with tests.
+5. We add more use cases to the spec, probably not yet supported by the implementations. Tests start to fail.
+6. Go to 3, update the implementation till tests give no errors.
+7. Repeat steps 3-6 till the functionality is ready.
+>>>>>>> 5dff42ba283bce883428c383c080fa9392b71df8
 
 Donc, le développement est *itératif*. Nous écrivons la spécification, la mettons en œuvre, nous nous assurons que les tests réussissent, puis rédigeons d'autres tests, nous nous assurons qu'ils fonctionnent, etc. À la fin, nous avons une implémentation qui fonctionne et des tests.
 
@@ -86,9 +96,15 @@ La première étape est déjà terminée : nous avons une spécification initial
 
 Dans ce tutoriel, nous utiliserons les bibliothèques JavaScript suivantes pour les tests :
 
+<<<<<<< HEAD
 - [Mocha](http://mochajs.org/) -- le framework central : il fournit des fonctions de test communes, y compris `describe`, et `it` ainsi que la fonction principale qui exécute les tests.
 - [Chai](http://chaijs.com) -- la bibliothèque avec de nombreuses affirmations. Elle permet d’utiliser beaucoup d’affirmations différentes, pour le moment nous n’avons besoin que de `assert.equal`.
 - [Sinon](http://sinonjs.org/) -- une bibliothèque pour espionner des fonctions, émuler des fonctions intégrées et plus encore, nous en aurons besoin beaucoup plus tard.
+=======
+- [Mocha](https://mochajs.org/) -- the core framework: it provides common testing functions including `describe` and `it` and the main function that runs tests.
+- [Chai](https://www.chaijs.com/) -- the library with many assertions. It allows to use a lot of different assertions, for now we need only `assert.equal`.
+- [Sinon](https://sinonjs.org/) -- a library to spy over functions, emulate built-in functions and more, we'll need it much later.
+>>>>>>> 5dff42ba283bce883428c383c080fa9392b71df8
 
 Ces bibliothèques conviennent aux tests sur le navigateur et sur le serveur. Ici, nous allons considérer la variante du navigateur.
 
@@ -340,6 +356,7 @@ Les tests récemment ajoutés échouent car notre implémentation ne les prend p
 
 Veuillez noter l'affirmation `assert.isNaN` : elle vérifie `NaN`.
 
+<<<<<<< HEAD
 Il y a aussi d'autres affirmations dans [Chai](http://chaijs.com), par exemple :
 
 - `assert.equal(value1, value2)` -- vérifie l'égalité `value1 == value2`.
@@ -348,6 +365,16 @@ Il y a aussi d'autres affirmations dans [Chai](http://chaijs.com), par exemple :
 - `assert.isTrue(value)` -- vérifie que `value === true`
 - `assert.isFalse(value)` -- vérifie que `value === false`
 - … la liste complète est dans la [doc](http://chaijs.com/api/assert/)
+=======
+There are other assertions in [Chai](https://www.chaijs.com/) as well, for instance:
+
+- `assert.equal(value1, value2)` -- checks the equality  `value1 == value2`.
+- `assert.strictEqual(value1, value2)` -- checks the strict equality `value1 === value2`.
+- `assert.notEqual`, `assert.notStrictEqual` -- inverse checks to the ones above.
+- `assert.isTrue(value)` -- checks that `value === true`
+- `assert.isFalse(value)` -- checks that `value === false`
+- ...the full list is in the [docs](https://www.chaijs.com/api/assert/)
+>>>>>>> 5dff42ba283bce883428c383c080fa9392b71df8
 ```
 
 Donc, nous devrions ajouter quelques lignes à `pow`:

1-js/03-code-quality/06-polyfills/article.md

@@ -1,7 +1,11 @@
 
 # Polyfills et transpilers
 
+<<<<<<< HEAD
 Le langage JavaScript évolue régulièrement. De nouvelles propositions pour le langage apparaissent régulièrement, elles sont analysées et, si elles sont jugées utiles, elles sont ajoutées à la liste dans <https://tc39.github.io/ecma262/> et ensuite progressent vers la [specification officielle](http://www.ecma-international.org/publications/standards/Ecma-262.htm).
+=======
+The JavaScript language steadily evolves. New proposals to the language appear regularly, they are analyzed and, if considered worthy, are appended to the list at <https://tc39.github.io/ecma262/> and then progress to the [specification](https://www.ecma-international.org/publications-and-standards/standards/ecma-262/).
+>>>>>>> 5dff42ba283bce883428c383c080fa9392b71df8
 
 Les équipes derrière les moteurs JavaScript ont leurs propres idées sur ce qu'il faut d'abord mettre en œuvre. Elles peuvent décider de mettre en œuvre des propositions qui sont en projet et reporter des éléments qui figurent déjà dans les spécifications, car ils sont moins intéressants ou tout simplement plus difficiles à faire.
 
@@ -71,9 +75,15 @@ if (!Math.trunc) { // si une telle fonction n'existe pas
 
 JavaScript est un langage très dynamique, les scripts peuvent ajouter/modifier toutes les fonctions, y compris celles intégrées.
 
+<<<<<<< HEAD
 Deux librairies intéressantes de polyfills sont :
 - [core js](https://github.com/zloirock/core-js) qui prend en charge beaucoup, permet d'inclure uniquement les fonctionnalités nécessaires.
 - [polyfill.io](http://polyfill.io) est un service qui fournit un script avec des polyfills, en fonction des fonctionnalités et du navigateur de l'utilisateur.
+=======
+Two interesting polyfill libraries are:
+- [core js](https://github.com/zloirock/core-js) that supports a lot, allows to include only needed features.
+- [polyfill.io](https://polyfill.io/) service that provides a script with polyfills, depending on the features and user's browser.
+>>>>>>> 5dff42ba283bce883428c383c080fa9392b71df8
 
 
 ## Résumé

1-js/04-object-basics/03-garbage-collection/article.md

@@ -205,8 +205,14 @@ Les moteurs modernes implémentent des algorithmes avancés de récupération de
 
 Un livre général intitulé "The Garbage Collection Handbook: The Art of Automatic Memory Management" (R. Jones et al.) En parle.
 
+<<<<<<< HEAD
 Si vous êtes familiarisé avec la programmation de bas niveau, les informations plus détaillées sur le garbage collecor V8 se trouvent dans l'article [A tour of V8: Garbage Collection](http://jayconrod.com/posts/55/a-tour-of-v8-garbage-collection).
 
 [V8 blog](https://v8.dev) publie également des articles sur les modifications de la gestion de la mémoire de temps à autre. Naturellement, pour apprendre la récupération de place, vous feriez mieux de vous préparer en vous renseignant sur les éléments internes de V8 en général et en lisant le blog de [Vyacheslav Egorov](http://mrale.ph) qui a travaillé comme l'un des ingénieurs V8. Je dis: «V8», car c'est le plus couvert d'articles sur Internet. Pour d'autres moteurs, de nombreuses approches sont similaires, mais la récupération de place diffère à de nombreux égards.
+=======
+If you are familiar with low-level programming, more detailed information about V8's garbage collector is in the article [A tour of V8: Garbage Collection](https://jayconrod.com/posts/55/a-tour-of-v8-garbage-collection).
+
+The [V8 blog](https://v8.dev/) also publishes articles about changes in memory management from time to time. Naturally, to learn more about garbage collection, you'd better prepare by learning about V8 internals in general and read the blog of [Vyacheslav Egorov](https://mrale.ph) who worked as one of the V8 engineers. I'm saying: "V8", because it is best covered by articles on the internet. For other engines, many approaches are similar, but garbage collection differs in many aspects.
+>>>>>>> 5dff42ba283bce883428c383c080fa9392b71df8
 
 Une connaissance approfondie des moteurs est utile lorsque vous avez besoin d'optimisations de bas niveau. Il serait sage de planifier cela comme prochaine étape après la connaissance du langage.

1-js/05-data-types/11-date/article.md

@@ -382,7 +382,11 @@ for (let i = 0; i < 10; i++) {
 ```warn header="Faites attention au micro-benchmarking"
 Les moteurs JavaScript modernes effectuent de nombreuses optimisations. Ils peuvent modifier les résultats des «tests artificiels» par rapport à «l'utilisation normale», en particulier lorsque nous comparons quelque chose de très petit. Donc, si vous voulez sérieusement comprendre les performances, alors étudiez le fonctionnement du moteur JavaScript. Et puis vous n’aurez probablement pas besoin de micro-points de repère.
 
+<<<<<<< HEAD
 Un bon paquet d'article a propos de V8 se trouve ici <http://mrale.ph>.
+=======
+The great pack of articles about V8 can be found at <https://mrale.ph>.
+>>>>>>> 5dff42ba283bce883428c383c080fa9392b71df8
 ```
 
 ## Date.parse d'une chaîne de caractère

1-js/05-data-types/12-json/article.md

@@ -451,7 +451,11 @@ let json = `{
 
 En outre, JSON ne prend pas en charge les commentaires. L'ajout d'un commentaire à JSON le rend invalide.
 
+<<<<<<< HEAD
 Il y a un autre format nommé [JSON5](http://json5.org/),qui autorise les clés non commentées, les commentaires, etc. Mais il s’agit d’une bibliothèque autonome, pas dans la spécification du langage.
+=======
+There's another format named [JSON5](https://json5.org/), which allows unquoted keys, comments etc. But this is a standalone library, not in the specification of the language.
+>>>>>>> 5dff42ba283bce883428c383c080fa9392b71df8
 
 Le JSON standard est très strict, non pas parce que ses développeurs sont paresseux, mais pour permettre une implémentation facile, fiable et très rapide de l'algorithme de conversion.