Merge pull request #495 from HachemiH/master

Conflicts fixed after Sync with upstream @ 285083f

Author: HachemiH

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

@@ -150,21 +150,12 @@ 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
+Il peut être intéressant de savoir qu'il existe aussi des langages de [programmation purement fonctionelle](https://fr.wikipedia.org/wiki/Programmation_fonctionnelle), comme [Haskell](https://www.scala-lang.org/) qui interdisent de modifier une valeur de variable.
 
 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
+Bien que cela puisse paraître un peu étrange à première vue, ces langages sont tout à fait capables de développements sérieux. Plus que cela, il existe des domaines tels que les calculs parallèles où cette limitation confère certains avantages.
 ```
 
 ## Nom de variable [#variable-naming]

1-js/02-first-steps/05-types/article.md

@@ -226,11 +226,7 @@ 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'opérateur `typeof` renvoie le type de l'opérande. Il est utile lorsqu'on souhaite traiter différemment les valeurs de différents types ou de faire une vérification rapide.
 
 L'appel `typeof x` renvoie une chaîne de caractères avec le nom du type :
 

1-js/02-first-steps/07-type-conversions/article.md

@@ -34,11 +34,7 @@ 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
+La conversion numérique dans les fonctions et expressions mathématiques s'effectue automatiquement.
 
 Par exemple, lorsque la division `/` est appliqué à des non-numéros :
 

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

@@ -76,11 +76,7 @@ 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 `||`.
 

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

@@ -105,25 +105,14 @@ 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".
-
-[`confirm(question)`](mdn:api/Window/confirm)
-: Posez une `question` et suggérez de choisir entre Ok et Annuler. Le choix est retourné comme `true/false`.
-
-[`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".
+: Posez une question et retournez soit ce que le visiteur a entré, soit `null` s'il clique sur "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`.
+: Posez une `question` et suggérez de choisir entre Ok et Annuler. Le choix est retourné comme `true/false`.
 
 [`alert(message)`](https://developer.mozilla.org/en-US/docs/Web/API/Window/alert)
-: Output a `message`.
->>>>>>> 285083fc71ee3a7cf55fd8acac9c91ac6f62105c
+: Affiche un `message`.
 
 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.
 
@@ -157,11 +146,7 @@ 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
+: Les opérateurs au niveau du bit fonctionnent avec des entiers 32 bits au niveau du bit le plus bas : voir la [doc](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Expressions_and_Operators#bitwise_operators) quand ils sont nécessaires.
 
 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/09-object-toprimitive/article.md

@@ -228,14 +228,8 @@ 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 :
 

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

@@ -505,23 +505,13 @@ 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 `${…}`.
+- Il existe 3 types de quotes. Les backticks permettent à une chaîne de caractères 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 obtenir un substring, utilisez `slice` ou `substring`.
+- Pour mettre une chaîne de caractères en minuscule ou en majuscule, utilisez `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 :
 
@@ -531,8 +521,4 @@ 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

1-js/05-data-types/05-array-methods/article.md

@@ -255,11 +255,7 @@ 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
+Si nous voulons vérifier si `item` existe dans le tableau et n'avons pas besoin de l'index, alors `arr.includes` est préféré.
 
 La méthode [arr.lastIndexOf](mdn:js/Array/lastIndexOf) est la même que `indexOf`, mais recherche de droite à gauche.