Conflicts fixed on "Data types" page in french language

Author: HachemiH

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

@@ -47,25 +47,16 @@ Outre les nombres réguliers, il existe des "valeurs numériques spéciales" qui
     alert( "pas un nombre" / 2 ); // NaN, une telle division est erronée
     ```
 
-<<<<<<< HEAD
     `NaN` est contagieux. Toute autre opération sur `NaN` donnerait un `NaN` :
 
-    ```js run
-    alert( "pas un nombre" / 2 + 5 ); // NaN
-    ```
-
-    Donc, s'il y a `NaN` quelque part dans une expression mathématique, elle se propage à l'ensemble du résultat.
-=======
-    `NaN` is sticky. Any further mathematical operation on `NaN` returns `NaN`:
-
     ```js run
     alert( NaN + 1 ); // NaN
     alert( 3 * NaN ); // NaN
     alert( "not a number" / 2 - 1 ); // NaN
     ```
 
-    So, if there's a `NaN` somewhere in a mathematical expression, it propagates to the whole result (there's only one exception to that: `NaN ** 0` is `1`).
->>>>>>> 71da17e5960f1c76aad0d04d21f10bc65318d3f6
+    Donc, s'il y a `NaN` quelque part dans une expression mathématique, il se propage à l'ensemble du résultat (il n'y a qu'une seule exception : `NaN ** 0` vaut `1`).
+
 
 ```smart header="Les opérations mathématiques sont sûres"
 Faire des maths est sans danger en JavaScript. Nous pouvons faire n'importe quoi : diviser par zéro, traiter les chaînes non numériques comme des nombres, etc.
@@ -225,18 +216,8 @@ Le type `symbol` est utilisé pour créer des identificateurs uniques pour les o
 
 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.
 
-<<<<<<< HEAD
-Il supporte deux formes de syntaxe :
-
-1. Sous forme d'opérateur : `typeof x`.
-2. En style de fonction : `typeof(x)`.
-
-En d'autres termes, cela fonctionne à la fois avec ou sans parenthèses. Le résultat est le même.
 
 L'appel `typeof x` renvoie une chaîne de caractères avec le nom du type :
-=======
-A call to `typeof x` returns a string with the type name:
->>>>>>> 71da17e5960f1c76aad0d04d21f10bc65318d3f6
 
 ```js
 typeof undefined // "undefined"
@@ -267,29 +248,22 @@ typeof alert // "function"  (3)
 Les trois dernières lignes peuvent nécessiter des explications supplémentaires :
 
 1. `Math` est un objet interne au langage qui fournit des opérations mathématiques. Nous allons l'apprendre dans le chapitre <info:number>. Ici, il sert uniquement comme exemple d'un objet.
-2. Le résultat de `typeof null` est `"object"`. C'est une erreur officiellement reconnue dans `typeof`, conservée pour compatibilité. Bien sûr, `null` n'est pas un objet. C'est une valeur spéciale avec un type distinct qui lui est propre. 
+2. Le résultat de `typeof null` est `"object"`. C'est une erreur officiellement reconnue dans `typeof`, datant des premiers jours de JavaScript et conservée pour compatibilité. Bien sûr, `null` n'est pas un objet. C'est une valeur spéciale avec un type distinct qui lui est propre. Le comportement de `typeof` est incorrect ici.
 3. Le résultat de `typeof alert` est `"function"`, car `alert` est une fonction. Nous étudierons les fonctions dans les chapitres suivants, et nous verrons qu’il n’y a pas de type "fonction" en JavaScript. Les fonctions appartiennent au type `object`. Mais `typeof` les traite différemment, en retournant `"fonction"`. Cela vient également des débuts de JavaScript. Techniquement ce n’est pas tout à fait correct, mais très pratique à l'usage.
 
-<<<<<<< HEAD
 
-## Résumé
-=======
-1. `Math` is a built-in object that provides mathematical operations. We will learn it in the chapter <info:number>. Here, it serves just as an example of an object.
-2. The result of `typeof null` is `"object"`. That's an officially recognized error in `typeof`, coming from very early days of JavaScript and kept for compatibility. Definitely, `null` is not an object. It is a special value with a separate type of its own. The behavior of `typeof` is wrong here.
-3. The result of `typeof alert` is `"function"`, because `alert` is a function. We'll study functions in the next chapters where we'll also see that there's no special "function" type in JavaScript. Functions belong to the object type. But `typeof` treats them differently, returning `"function"`. That also comes from the early days of JavaScript. Technically, such behavior isn't correct, but can be convenient in practice.
 
-```smart header="The `typeof(x)` syntax"
-You may also come across another syntax: `typeof(x)`. It's the same as `typeof x`.
+```smart header="La syntaxe `typeof(x)`"
+Vous pouvez également rencontrer une autre syntaxe : `typeof(x)`. C'est la même chose que `typeof x`.
 
-To put it clear: `typeof` is an operator, not a function. The parentheses here aren't a part of `typeof`. It's the kind of parentheses used for mathematical grouping.
+Pour être clair : `typeof` est un opérateur, pas une fonction. Les parenthèses ici ne font pas partie de `typeof`. C'est le genre de parenthèses utilisées pour le regroupement mathématique.
 
-Usually, such parentheses contain a mathematical expression, such as `(2 + 2)`, but here they contain only one argument `(x)`. Syntactically, they allow to avoid a space between the `typeof` operator and its argument, and some people like it.
+Habituellement, ces parenthèses contiennent une expression mathématique, telle que `(2 + 2)`, mais ici elles ne contiennent qu'un seul argument `(x)`. Syntaxiqement, ils permettent d'éviter un espace entre l'opérateur `typeof` et son argument, et certains aiment ça.
 
-Some people prefer `typeof(x)`, although the `typeof x` syntax is much more common.
+Certaines personnes préfèrent `typeof(x)`, bien que la syntaxe `typeof x` soit beaucoup plus courante.
 ```
 
-## Summary
->>>>>>> 71da17e5960f1c76aad0d04d21f10bc65318d3f6
+## Résumé
 
 Il existe 8 types de données de base en JavaScript.
 
@@ -304,14 +278,8 @@ Il existe 8 types de données de base en JavaScript.
 
 L'opérateur `typeof` nous permet de voir quel type est stocké dans la variable.
 
-<<<<<<< HEAD
-- Deux formes : `typeof x` ou `typeof(x)`.
+- Généralement utilisé sous cette forme `typeof x`, mais `typeof(x)` est également possible.
 - Renvoie une chaîne de caractères avec le nom du type, comme `"string"`.
 - Pour `null` il renvoit `"object"` -- C’est une erreur dans le langage, ce n’est pas un objet en fait.
-=======
-- Usually used as `typeof x`, but `typeof(x)` is also possible.
-- Returns a string with the name of the type, like `"string"`.
-- For `null` returns `"object"` -- this is an error in the language, it's not actually an object.
->>>>>>> 71da17e5960f1c76aad0d04d21f10bc65318d3f6
 
 Dans les chapitres suivants, nous nous concentrerons sur les valeurs primitives et une fois que nous les connaîtrons, nous passerons aux objets.