javascript-tutorial · HachemiH · Oct 19, 2023 · Oct 3, 2022 · Oct 5, 2022 · Oct 5, 2022
diff --git a/1-js/02-first-steps/04-variables/article.md b/1-js/02-first-steps/04-variables/article.md
@@ -150,12 +150,21 @@ 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](https://www.scala-lang.org/) ou [Erlang](https://www.erlang.org/) qui interdisent de modifier une valeur de variable.
+=======
+```smart header="Functional languages"
+It's interesting to note that there exist so-called [pure functional](https://en.wikipedia.org/wiki/Purely_functional_programming) programming languages, such as [Haskell](https://en.wikipedia.org/wiki/Haskell), that forbid changing variable values.
+>>>>>>> 285083fc71ee3a7cf55fd8acac9c91ac6f62105c
 
 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.
 
+<<<<<<< HEAD
 Bien que cela puisse paraître un peu étrange à première vue, ces langages sont tout à fait capables de se développer sérieusement. Plus que cela, il existe des domaines tels que les calculs parallèles où cette limitation confère certains avantages. Étudier un tel langage (même si on ne prévoit pas de l'utiliser rapidement) est recommandé pour élargir son horizon.
+=======
+Though it may seem a little odd at first sight, these languages are quite capable of serious development. More than that, there are areas like parallel computations where this limitation confers certain benefits.
+>>>>>>> 285083fc71ee3a7cf55fd8acac9c91ac6f62105c
 ```
 
 ## Nom de variable [#variable-naming]

diff --git a/1-js/02-first-steps/05-types/article.md b/1-js/02-first-steps/05-types/article.md
@@ -226,7 +226,11 @@ Le type `symbol` est utilisé pour créer des identificateurs uniques pour les o
 
 ## L'opérateur typeof [#type-typeof]
 
+<<<<<<< HEAD
 L'opérateur `typeof` renvoie le type de l'argument. Il est utile lorsqu'on souhaite traiter différemment les valeurs de différents types ou de faire une vérification rapide.
+=======
+The `typeof` operator returns the type of the operand. It's useful when we want to process values of different types differently or just want to do a quick check.
+>>>>>>> 285083fc71ee3a7cf55fd8acac9c91ac6f62105c
 
 L'appel `typeof x` renvoie une chaîne de caractères avec le nom du type :
 

diff --git a/1-js/02-first-steps/07-type-conversions/article.md b/1-js/02-first-steps/07-type-conversions/article.md
@@ -34,7 +34,11 @@ La conversion `String` est assez évidente. Un `false` devient `"false"`, `null`
 
 ## Numeric Conversion
 
+<<<<<<< HEAD
 La conversion numérique se produit automatiquement dans les fonctions et les expressions mathématiques.
+=======
+Numeric conversion in mathematical functions and expressions happens automatically.
+>>>>>>> 285083fc71ee3a7cf55fd8acac9c91ac6f62105c
 
 Par exemple, lorsque la division `/` est appliqué à des non-numéros :
 

diff --git a/1-js/02-first-steps/08-operators/article.md b/1-js/02-first-steps/08-operators/article.md
@@ -50,9 +50,11 @@ Le résultat de `a % b` est le [reste](https://fr.wikipedia.org/wiki/Reste) de l
 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
+alert( 8 % 4 ); // 0, le reste de 8 divisé par 4
+
 ```
 
 ### Exponentiation **
@@ -68,7 +70,7 @@ alert( 2 ** 3 ); // 2³ = 8
 alert( 2 ** 4 ); // 2⁴ = 16
 ```
 
-Mathématiquement, l'exponentiation est également définie pour les nombres non entiers.
+Tout comme en mathématiques, l'opérateur d'exponentiation est également défini pour les nombres non entiers.
 
 Par exemple, une racine carrée est une exponentiation de `½` :
 

diff --git a/1-js/02-first-steps/10-ifelse/article.md b/1-js/02-first-steps/10-ifelse/article.md
@@ -68,7 +68,8 @@ if (cond) {
 
 ## La clause "else"
 
-L'instruction `if` peut contenir un bloc optionnel "else". Il s'exécute lorsque la condition est fausse.
+
+L'instruction `if` peut contenir un bloc optionnel `else`. Il s'exécute lorsque la condition est fausse.
 
 Par exemple :
 ```js run
@@ -180,10 +181,12 @@ alert( message );
 
 Il peut être difficile au début de comprendre ce qui se passe. Mais après un examen plus approfondi, nous constatons que ce n’est qu’une séquence de tests ordinaire.
 
+
 1. Le premier point d'interrogation vérifie si `age < 3`.
-2. Si vrai -- retourne `'Coucou bébé !'`, sinon il franchit les deux points `":"` et vérifie si `age < 18`.
-3. Si vrai -- retourne `'Salut !'`, sinon -- il franchit à nouveau les deux points suivants `":"` et vérifie si `age < 100`.
-4. Si vrai -- retourne `'Salutations !'`, sinon -- il franchit enfin les derniers deux points `":"` et retourne `'Quel âge inhabituel !'`.
+
+2. Si vrai -- retourne `'Hi, baby!'`, Sinon, il continue avec l'expression après les deux points ":" suivants et vérifie si `age < 18`.
+3. Si vrai -- retourne `'Hello!'`, Sinon, il continue avec l'expression après les deux points ":" suivants et vérifie si `age < 100`.
+4. Si vrai -- retourne `'Greetings!'`, Sinon, l'expression continue après les derniers deux-points et retourne `'What an unusual age!'`.
 
 La même logique utilisant `if..else` :
 

diff --git a/1-js/02-first-steps/12-nullish-coalescing-operator/article.md b/1-js/02-first-steps/12-nullish-coalescing-operator/article.md
@@ -76,7 +76,11 @@ alert(firstName || lastName || nickName || "Anonymous"); // Supercoder
 */!*
 ```
 
+<<<<<<< HEAD
 Historiquement, l'opérateur OR `||` était là en premier. Il existe depuis le début de JavaScript, donc les développeurs l'utilisaient à de telles fins depuis longtemps.
+=======
+Historically, the OR `||` operator was there first. It's been there since the beginning of JavaScript, so developers were using it for such purposes for a long time.
+>>>>>>> 285083fc71ee3a7cf55fd8acac9c91ac6f62105c
 
 D'un autre côté, l'opérateur de coalescence des nuls `??` n'a été ajouté à JavaScript que récemment, et la raison en était que les gens n'étaient pas tout à fait satisfaits de `||`.
 

diff --git a/1-js/02-first-steps/18-javascript-specials/article.md b/1-js/02-first-steps/18-javascript-specials/article.md
@@ -105,6 +105,7 @@ Plus d’informations dans : <info:variables> et <info:types>.
 
 Nous utilisons un navigateur comme environnement de travail. Les fonctions de base de l'interface utilisateur sont les suivantes :
 
+<<<<<<< HEAD
 [`prompt(question[, default])`](mdn:api/Window/prompt)
 : Posez une question et retournez soit ce que le visiteur a entré, soit `null` s'il clique sur "cancel".
 
@@ -113,6 +114,16 @@ Nous utilisons un navigateur comme environnement de travail. Les fonctions de ba
 
 [`alert(message)`](mdn:api/Window/alert)
 : Affiche un `message`.
+=======
+[`prompt(question, [default])`](https://developer.mozilla.org/en-US/docs/Web/API/Window/prompt)
+: Ask a `question`, and return either what the visitor entered or `null` if they clicked "cancel".
+
+[`confirm(question)`](https://developer.mozilla.org/en-US/docs/Web/API/Window/confirm)
+: Ask a `question` and suggest to choose between Ok and Cancel. The choice is returned as `true/false`.
+
+[`alert(message)`](https://developer.mozilla.org/en-US/docs/Web/API/Window/alert)
+: Output a `message`.
+>>>>>>> 285083fc71ee3a7cf55fd8acac9c91ac6f62105c
 
 Toutes ces fonctions sont *modales*, elles suspendent l'exécution du code et empêchent le visiteur d'interagir avec la page tant qu'il n'a pas répondu.
 
@@ -146,7 +157,11 @@ Affectations
 : Il y a une assignation simple : `a = b` et des combinés comme `a *= 2`.
 
 Bitwise
+<<<<<<< HEAD
 : Les opérateurs au niveau du bit fonctionnent avec des entiers 32 bits au niveau du bit le plus bas : voir la [doc](mdn:/JavaScript/Guide/Expressions_and_Operators#bitwise_operators) quand ils sont nécessaires.
+=======
+: Bitwise operators work with 32-bit integers at the lowest, bit-level: see the [docs](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Expressions_and_Operators#bitwise_operators) when they are needed.
+>>>>>>> 285083fc71ee3a7cf55fd8acac9c91ac6f62105c
 
 Conditionnel
 : Le seul opérateur avec trois paramètres : `cond ? resultA : resultB`. Si `cond` est vrai, retourne `resultA`, autrement `resultB`.

diff --git a/1-js/04-object-basics/09-object-toprimitive/article.md b/1-js/04-object-basics/09-object-toprimitive/article.md
@@ -228,8 +228,14 @@ Comme nous le savons déjà, de nombreux opérateurs et fonctions effectuent des
 
 Si nous passons un objet en argument, il y a deux étapes de  calcul :
 
+<<<<<<< HEAD
 1. L'objet est converti en primitive (en utilisant les règles décrites ci-dessus).
 2. Si cela est nécessaire pour d'autres calculs, la primitive résultante est également convertie.
+=======
+If we pass an object as an argument, then there are two stages of calculations:
+1. The object is converted to a primitive (using the rules described above).
+2. If necessary for further calculations, the resulting primitive is also converted.
+>>>>>>> 285083fc71ee3a7cf55fd8acac9c91ac6f62105c
 
 Par exemple :
 

diff --git a/1-js/05-data-types/03-string/article.md b/1-js/05-data-types/03-string/article.md
@@ -505,13 +505,23 @@ Cette méthode a en fait deux arguments supplémentaires spécifiés dans [la do
 
 ## Résumé
 
+<<<<<<< HEAD
 - Il existe 3 types de quotes : simples (`'`), doubles (`"`) et les backticks (`` ` ``). Les backticks permettent à une chaîne de s'étendre sur plusieurs lignes et d'intégrer des expressions `${…}`.
 - Nous pouvons utiliser des caractères spéciaux, comme un saut de ligne `\n`.
 - Pour obtenir un caractère d'une string, utilisez `[]` ou la méthode `at`.
 - Pour obtenir un substring, utilisez les méthodes `slice` ou `substring`.
 - Pour mettre une chaîne de caractères en minuscule ou en majuscule, utilisez les méthodes `toLowerCase` ou `toUpperCase`.
 - Pour rechercher un substring, utilisez `indexOf`, ou `includes` / `startsWith` / `endsWith` pour de simple vérifications.
 - Pour comparer les chaînes de caractères en fonction de la langue, utilisez la méthode `localeCompare`, si non ils sont comparés par les codes de caractères.
+=======
+- There are 3 types of quotes. Backticks allow a string to span multiple lines and embed expressions `${…}`.
+- We can use special characters, such as a line break `\n`.
+- To get a character, use: `[]` or `at` method.
+- To get a substring, use: `slice` or `substring`.
+- To lowercase/uppercase a string, use: `toLowerCase/toUpperCase`.
+- To look for a substring, use: `indexOf`, or `includes/startsWith/endsWith` for simple checks.
+- To compare strings according to the language, use: `localeCompare`, otherwise they are compared by character codes.
+>>>>>>> 285083fc71ee3a7cf55fd8acac9c91ac6f62105c
 
 Il existe plusieurs autres méthodes utiles dans les strings :
 
@@ -521,4 +531,8 @@ Il existe plusieurs autres méthodes utiles dans les strings :
 
 Les strings ont aussi des méthodes pour rechercher / remplacer avec des expressions régulières. Mais c’est un sujet important, il est donc expliqué dans une autre section de ce tutoriel <info:regular-expressions>.
 
+<<<<<<< HEAD
 De plus, à partir de maintenant, il est important de savoir que les chaînes de caractères sont basées sur l'encodage Unicode, et donc il y a des problèmes avec les comparaisons. Il y a plus d'informations sur Unicode dans le chapitre <info:unicode>.
+=======
+Also, as of now it's important to know that strings are based on Unicode encoding, and hence there're issues with comparisons. There's more about Unicode in the chapter <info:unicode>.
+>>>>>>> 285083fc71ee3a7cf55fd8acac9c91ac6f62105c
diff --git a/1-js/05-data-types/04-array/article.md b/1-js/05-data-types/04-array/article.md
@@ -97,7 +97,7 @@ Le style "virgule de fin" facilite l'insertion et la suppression d'éléments, c
 
 Let's say we want the last element of the array.
 
-Some programming languages allow to use negative indexes for the same purpose, like `fruits[-1]`.
+Some programming languages allow the use of negative indexes for the same purpose, like `fruits[-1]`.
 
 Although, in JavaScript it won't work. The result will be `undefined`, because the index in square brackets is treated literally.
 

diff --git a/1-js/05-data-types/05-array-methods/article.md b/1-js/05-data-types/05-array-methods/article.md
@@ -255,7 +255,11 @@ alert( arr.includes(1) ); // true
 
 Veuillez noter que `indexOf` utilise l'égalité stricte `===` pour la comparaison. Donc, si nous cherchons "faux", il trouve exactement "faux" et non le zéro.
 
+<<<<<<< HEAD
 Si nous voulons vérifier si `item` existe dans le tableau et n'avons pas besoin de l'index exact, alors `arr.includes` est préféré.
+=======
+If we want to check if `item` exists in the array, and don't need the index, then `arr.includes` is preferred.
+>>>>>>> 285083fc71ee3a7cf55fd8acac9c91ac6f62105c
 
 La méthode [arr.lastIndexOf](mdn:js/Array/lastIndexOf) est la même que `indexOf`, mais recherche de droite à gauche.