recursal/MDN huggingface dataset:
Math.asinh()
============

La fonction **`Math.asinh()`** renvoie l'arc sinus hyperbolique d'un nombre :



Math.asinh
(
x
)

=
arsinh
(
x
)
=
 le seul 

y

tel que

sinh
(
y
)
=
x

\mathtt{\operatorname{Math.asinh}(x)} = \operatorname{arsinh}(x) = \text{ the unique } ; y ; \text{such that} ; \sinh(y) = x

Exemple interactif
------------------

Syntaxe
-------


```js
Math.asinh(x);
```

### Paramètres

`x`

Un nombre.

### Valeur de retour

L'arc sinus hyperbolique du nombre passé en argument.

Description
-----------

`asinh()` étant une méthode statique de `Math`, elle doit toujours être utilisée avec la syntaxe `Math.asinh()` et ne doit pas être appelée depuis un autre objet qui aurait été créé (Math n'est pas un constructeur).

Exemple
-------

### Utiliser `Math.asinh()`


```js
Math.asinh =
  Math.asinh ||
  function (x) {
    if (x === -Infinity) {
      return x;
    } else {
      return Math.log(x + Math.sqrt(x \* x + 1));
    }
  };
```

Spécifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.asinh |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* `Math.acosh()`
* `Math.atanh()`
* `Math.cosh()`
* `Math.sinh()`
* `Math.tanh()`
Math.E
======

La propriété **`Math.E`** représente la base du logarithme naturel, e, et vaut environ 2.718.


Math.E

=
e
≈
2.718

\mathtt{\mi{Math.E}} = e \approx 2.718

Exemple interactif
------------------

| Attributs de `Math.E` |
| --- |
| Écrivable | Non |
| Énumérable | Non |
| Configurable | Non |

Description
-----------

`E` étant une propriété statique de `Math`, il doit toujours être utilisé avec la syntaxe `Math.E`, et non pas être appelé comme propriété d'un autre objet `Math` qui aurait été créé (`Math` n'est pas un constructeur).

Exemples
--------

### Utiliser `Math.E`

La fonction suivante renvoie la valeur de e :


```js
function getNapier() {
  return Math.E;
}

getNapier(); // 2.718281828459045
```

Spécifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.e |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* `Math.exp()`
* `Math.log()`
* `Math.log1p()`
Math.SQRT2
==========

La propriété **`Math.SQRT2`** représente la racine carrée de 2 et vaut environ 1.414 :


Math.SQRT2

=

2

≈
1.414

\mathtt{\mi{Math.SQRT2}} = \sqrt{2} \approx 1.414

Exemple interactif
------------------

| Attributs de `Math.SQRT2` |
| --- |
| Écrivable | Non |
| Énumérable | Non |
| Configurable | Non |

Description
-----------

`SQRT2` est une propriété statique de `Math` et doit toujours être utilisée avec la syntaxe `Math.SQRT2`, elle ne doit pas être appelée comme propriété d'un autre objet qui aurait été créé (`Math` n'est pas un constructeur).

Exemples
--------

La fonction suivante renvoie la valeur de la racine carrée de 2 :


```js
function getRoot2() {
  return Math.SQRT2;
}

getRoot2(); // 1.4142135623730951
```

Spécifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.sqrt2 |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* `Math.pow()`
* `Math.sqrt()`
Math.LN10
=========

La propriété **`Math.LN10`** représente la valeur du logarithme naturel de 10, environ 2.302 :


Math.LN10

=
ln
(
10
)
≈
2.302

\mathtt{\mi{Math.LN10}} = \ln(10) \approx 2.302

Exemple interactif
------------------

| Attributs de `Math.LN10` |
| --- |
| Écrivable | Non |
| Énumérable | Non |
| Configurable | Non |

Description
-----------

`LN10` est une propriété statique de `Math`, elle doit toujours être utilisée avec la syntaxe `Math.LN10`, et ne pas être appelée comme propriété d'un autre objet qui aurait été créé (`Math` n'est pas un constructeur).

Exemples
--------

### Utiliser `Math.LN10`

La fonction suivante renvoie le logarithme naturel de 10 :


```js
function getNatLog10() {
  return Math.LN10;
}

getNatLog10(); // 2.302585092994046
```

Spécifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.ln10 |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* `Math.exp()`
* `Math.log()`
* `Math.log10()`
Math.hypot()
============

La fonction **`Math.hypot()`** renvoie la racine carrée de la somme des carrés de ses arguments. On peut également la définir avec la formule suivante :



Math.hypot
(

v
1

,

v
2

,
…
,

v
n

)

=

∑

i
=
1

n

v
i
2

=

v
1
2

+

v
2
2

+
…
+

v
n
2

\mathtt{\operatorname{Math.hypot}(v

*1, v\_2, \dots, v\_n)} = \sqrt{\sum*{i=1}^n v\_i^2} = \sqrt{v\_1^2 + v\_2^2 + \dots + v\_n^2}

Exemple interactif
------------------

Syntaxe
-------


```js
Math.hypot([valeur1[,valeur2, ...]])
```

### Paramètres

`valeur1, valeur2, ...`

Des nombres.

### Valeur de retour

La racine carrée de la somme des carrés des arguments. S'il existe un des arguments qui ne peut pas être converti en un nombre, c'est la valeur `NaN` qui sera renvoyée.

Description
-----------

`hypot()` étant une méthode statique de `Math`, il faut utiliser `Math.hypot()` et non pas la méthode d'un autre objet qui aurait été créé (`Math` n'est pas un constructeur).

Si aucun argument n'est donné, le résultat sera +0.Si, parmi les arguments, au moins un ne peut pas être converti en un nombre, le résultat sera `NaN`.Si cette fonction est utilisée avec un argument : `Math.hypot(x)` sera équivalente à `Math.abs(x)`.

Cette fonction permet entre autres de gérer certains cas où, pour les grands nombres, l'utilisation de `Math.sqrt()` aurait renvoyé `Infinity` à cause des calculs intermédiaires.

Exemples
--------

### Utiliser `Math.hypot()`


```js
Math.hypot(3, 4); // 5
Math.hypot(3, 4, 5); // 7.0710678118654755
Math.hypot(); // 0
Math.hypot(NaN); // NaN
Math.hypot(3, 4, "toto"); // NaN, +"toto" => NaN
Math.hypot(3, 4, "5"); // 7.0710678118654755, +"5" => 5
Math.hypot(-3); // 3, the same as Math.abs(-3)
```

Prothèse d'émulation (*polyfill*)
---------------------------------

Si elle n'est pas disponible, cette fonction peut être émulée de la façon suivante :


```js
Math.hypot =
  Math.hypot ||
  function () {
    var y = 0;
    var length = arguments.length;

    for (var i = 0; i < length; i++) {
      if (arguments[i] === Infinity || arguments[i] === -Infinity) {
        return Infinity;
      }
      y += arguments[i] \* arguments[i];
    }
    return Math.sqrt(y);
  };
```


Voici une seconde version qui évite les dépassements :


```js
Math.hypot = function (x, y) {
  // https://bugzilla.mozilla.org/show\_bug.cgi?id=896264#c28
  var max = 0;
  var s = 0;
  for (var i = 0; i < arguments.length; i += 1) {
    var arg = Math.abs(Number(arguments[i]));
    if (arg > max) {
      s \*= (max / arg) \* (max / arg);
      max = arg;
    }
    s += arg === 0 && max === 0 ? 0 : (arg / max) \* (arg / max);
  }
  return max === 1 / 0 ? 1 / 0 : max \* Math.sqrt(s);
};
```

Spécifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.hypot |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* `Math.abs()`
* `Math.pow()`
* `Math.sqrt()`
Math.log()
==========

La fonction **`Math.log()`** renvoie le logarithme naturel (aussi appelé logarithme népérien) d'un nombre, défini par :



∀
x
>
0
,

Math.log
(
x
)

=
ln
(
x
)
=
le seul 

y

tel que

e
y

=
x

\forall x > 0, \mathtt{\operatorname{Math.log}(x)} = \ln(x) = \text{the unique} ; y ; \text{such that} ; e^y = x

Exemple interactif
------------------

Syntaxe
-------


```js
Math.log(x);
```

### Paramètres

`x`

Un nombre.

### Valeur de retour

Le logarithme naturelle de la valeur passée en argument. Si cette valeur est négative, c'est `NaN` qui est renvoyé.

Description
-----------

Si la valeur de l'argument est négative, la valeur renvoyée sera `NaN`. Si la valeur de l'argument est `0`, la valeur de retour sera `-Infinity`.

`log()` est une méthode statique de `Math`, elle doit toujours être utilisée avec la syntaxe `Math.log()`, elle ne doit pas être utilisée à partir d'un autre objet qui aurait été créé (`Math` n'est pas un constructeur). Si on veut utiliser les constantes données par les logarithmes naturels de 2 ou 10, on pourra utiliser les constantes `Math.LN2` ou `Math.LN10`. De même pour les logarithmes en base 2 ou en base 10, on pourra utiliser `Math.log2()` or `Math.log10()`.

Exemples
--------

### Utiliser `Math.log()`


```js
Math.log(-1); // NaN, valeur en dehors de l'intervalle de définition
Math.log(0); // -Infinity
Math.log(1); // 0
Math.log(10); // 2.302585092994046
```

### Utiliser `Math.log` pour construire un logarithme sur une autre base

La fonction suivante renvoie le logarithme de `y` en base `x` (c'est-à-dire logx y):


```js
function getBaseLog(x, y) {
  return Math.log(y) / Math.log(x);
}
```


Si on exécute `getBaseLog(10, 1000)`, on obtiendra `2.9999999999999996` en raison de l'arrondi du à la représentation en nombre flottant (le résultat exact étant 3).

Spécifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.log |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* `Math.exp()`
* `Math.log1p()`
* `Math.log10()`
* `Math.log2()`
* `Math.pow()`
Math.sin()
==========

La fonction **`Math.sin()`** renvoie le sinus d'un nombre.

Exemple interactif
------------------

Syntaxe
-------


```js
Math.sin(x);
```

### Paramètres

`x`

Un nombre (qui exprime un angle en radians).

### Valeur de retour

Le sinus de la valeur passée en argument (qui correspond à un angle en radians).

Description
-----------

La méthode `sin()` renvoie une valeur numérique comprise (au sens large) entre 1 et -1 et qui représente le sinus d'un angle donné en radians.

`sin()` est une méthode statique de `Math`, elle doit être utilisée avec la syntaxe `Math.sin()`, elle ne doit pas être utilisée comme une méthode d'un objet qui aurait été créé (`Math` n'est pas un constructeur).

Exemples
--------


```js
Math.sin(0); // 0
Math.sin(1); // 0.8414709848078965

Math.sin(Math.PI / 2); // 1
```

Spécifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.sin |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* `Math.acos()`
* `Math.asin()`
* `Math.atan()`
* `Math.atan2()`
* `Math.cos()`
* `Math.tan()`
Math.fround()
=============

La fonction **`Math.fround()`** renvoie le nombre flottant à précision simple sur 32 bits qui est le plus proche du nombre fourni.

Exemple interactif
------------------

Syntaxe
-------


```js
Math.fround(x);
```

### Paramètres

`x`

Un nombre.

### Valeur de retour

Le nombre flottant à précision simple sur 32 bits qui est le plus proche de la valeur fournie en argument.

Description
-----------

Un moteur JavaScript utilise des nombres flottant à précision simple sur 64 bits. Cela permet d'obtenir une précision fine. Toutefois, lorsqu'on manipule des valeurs représentées sur 32 bits (par exemple des valeurs extraites d'un `Float32Array`) et qu'on souhaite comparer celles-ci avec des valeurs sur 32 bits, on peut obtenir des inégalités alors que les valeurs semblent identiques.

Pour résoudre ce problème, on peut utiliser `Math.fround()` afin de transformer un nombre représenté sur 64 bits en un nombre représenté sur 32 bits. Pour le moteur JavaScript, la valeur sera toujours représentée sur 64 bits mais elle aura été « arrondie » à partir du 23e bit de la mantisse. Si le nombre passé en argument se situe en dehors de l'intervalle représentable sur 32 bits, la méthode renverra `Infinity` ou `-Infinity`.

`fround` étant une méthode statique de `Math`, il faut utiliser `Math.fround()` et non pas la méthode d'un autre objet qui aurait été créé (`Math` n'est pas un constructeur).

Exemples
--------

### Utiliser `Math.fround()`


```js
Math.fround(0); // 0
Math.fround(1); // 1

// 1.337 ne peut pas être représenté correctement
// sur 32 bits
Math.fround(1.337); // 1.3370000123977661

Math.fround(1.5); // 1.5
Math.fround(NaN); // NaN
```

Spécifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.fround |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* `Math.round()`
Math.sign()
===========

La fonction **`Math.sign()`** renvoie le signe d'un nombre et permet de savoir si un nombre est positif, négatif ou nul.

Exemple interactif
------------------

Syntaxe
-------


```js
Math.sign(x);
```

### Paramètres

`x`

Un nombre.

### Valeur de retour

Un nombre qui représente le signe de l'argument. Si l'argument est un nombre positif, négatif, un zéro positif ou un zéro négatif, la fonction renverra respectivement `1`, `-1`, `0`, `-0`. Sinon, ce sera `NaN` qui sera renvoyé.

Description
-----------

`sign()` étant une méthode statique de `Math`, il faut utiliser `Math.sign()` et non pas la méthode d'un autre objet qui aurait été créé (`Math` n'est pas un constructeur).

Cette fonction peut renvoyer 5 valeurs : `1, -1, 0, -0, NaN,` qui indiquent respectivement que `x` est un nombre positif, un nombre négatif, zéro, la limite négative de zéro, et n'est pas un nombre pour `NaN`.

L'argument passé à cette fonction sera implicitement converti au type `number`.

Exemples
--------


```js
Math.sign(3); // 1
Math.sign(-3); // -1
Math.sign("-3"); // -1
Math.sign(0); // 0
Math.sign(-0); // -0
Math.sign(NaN); // NaN
Math.sign("foo"); // NaN
Math.sign(); // NaN
```

Spécifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.sign |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* `Math.abs()`
* `Math.ceil()`
* `Math.floor()`
* `Math.round()`
* `Math.trunc()`
Math.tan()
==========

La fonction **`Math.tan()`** renvoie la tangente d'un nombre exprimant un angle en radians.

Exemple interactif
------------------

Syntaxe
-------


```js
Math.tan(x);
```

### Paramètres

`x`

Un nombre qui représente un angle en radians.

### Valeur de retour

La tangente de l'angle fourni en argument (exprimé en radians).

Description
-----------

La méthode `Math.tan()` renvoie une valeur numérique qui représente la tangente d'un angle.

`tan()` est une méthode statique de `Math` et doit toujours être utilisée avec la syntaxe `Math.tan()`, elle ne doit pas être utilisée comme méthode d'un autre objet qui aurait été créé (`Math` n'est pas un constructeur).

Exemples
--------

### Utiliser `Math.tan()`


```js
Math.tan(1); // 1.5574077246549023
```


`Math.tan()` considère un argument exprimé en radians. Cependant, on peut vouloir travailler avec des valeurs en degrés. Pour cela, on pourra utiliser la fonction suivante qui calcule la tangente après avoir converti l'argument en radians :


```js
function getTanDeg(deg) {
  var rad = (deg \* Math.PI) / 180;
  return Math.tan(rad);
}
```

Spécifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.tan |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* `Math.acos()`
* `Math.asin()`
* `Math.atan()`
* `Math.atan2()`
* `Math.cos()`
* `Math.sin()`
Math.LOG10E
===========

La propriété **`Math.LOG10E`** fournit la valeur du logarithme en base 10 de e, environ 0.434 :


Math.LOG10E

=

log
10

(
e
)
≈
0.434

\mathtt{\mi{Math.LOG10E}} = \log\_10(e) \approx 0.434

Exemple interactif
------------------

| Attributs de `Math.LOG10E` |
| --- |
| Écrivable | Non |
| Énumérable | Non |
| Configurable | Non |

Description
-----------

`LOG10E` étant une propriété statique de `Math`, elle doit toujours être utilisée avec la syntaxe `Math.LOG10E` et ne pas être appelée comme propriété d'un autre objet qui aurait été créé (`Math` n'est pas un constructeur).

Exemples
--------

### Utiliser `Math.LOG10E`

La fonction suivante renvoie le logarithme en base 10 de e :


```js
function getLog10e() {
  return Math.LOG10E;
}

getLog10e(); // 0.4342944819032518
```

Spécifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.log10e |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* `Math.exp()`
* `Math.log()`
* `Math.log10()`
Math.expm1()
============

La fonction **`Math.expm1()`** renvoie `e^x` - 1, avec `x` l'argument donné et `e` la base du logarithme nepérien.

Exemple interactif
------------------

Syntaxe
-------


```js
Math.expm1(x);
```

### Paramètres

`x`

Un nombre.

### Valeur de retour

Un nombre qui représente `e^x- 1` où `x` est la valeur passée en argument et `e^x` l'exponentielle du nombre.

Description
-----------

`expm1()` étant une méthode statique de `Math`, il faut utiliser `Math.expm1()` et non pas la méthode d'un autre objet qui aurait été créé sur mesure (`Math` n'est pas un constructeur).

Exemple
-------

### Utiliser `Math.expm1()`


```js
Math.expm1(-1); // -0.6321205588285577
Math.expm1(0); // 0
Math.expm1(1); // 1.718281828459045
```

Prothèse d'émulation (*polyfill*)
---------------------------------

Cette fonction peut être émulée en utilisant la fonction `Math.exp()` :


```js
Math.expm1 =
  Math.expm1 ||
  function (x) {
    return Math.exp(x) - 1;
  };
```

Spécifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.expm1 |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* `Math.E`
* `Math.exp()`
* `Math.log()`
* `Math.log10()`
* `Math.log1p()`
* `Math.log2()`
* `Math.pow()`
Math.pow()
==========

La fonction **`Math.pow()`** renvoie un nombre à une certaine puissance, c'est-à-dire `base^exposant`.

Exemple interactif
------------------

Syntaxe
-------


```js
Math.pow(base, exposant);
```

### Paramètres

`base`

Le nombre correspondant à la base.

`exponent`

L'exposant auquel on élève le paramètre précédent.

### Valeur de retour

Un nombre qui représente un nombre (premier argument) élevé à une puissance donné (second argument).

Description
-----------

`pow()` est une méthode statique de `Math` et doit toujours être utilisée avec la syntaxe `Math.pow()`, elle ne doit pas être utilisée comme une méthode d'un autre objet qui aurait été créé (`Math` n'est pas un constructeur).

Exemple
-------

### Utiliser `Math.pow()`


```js
// Utilisation simple
Math.pow(7, 2); // 49

// Exposants négatifs
Math.pow(7, -2); // 0.02040816326530612 (1/49)

// Exposants fractionnaires
Math.pow(2, 1 / 2); // 1.4142135623730951 (racine carrée de 2)

// Cas aux limites
Math.pow(-7, 0.5); // NaN
// (les nombres négatifs n'ont pas de racine carrée)
Math.pow(-7, 1 / 3); // NaN
// Nombre négatif avec une base décimale
```

Spécifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.pow |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* `Math.cbrt()`
* `Math.exp()`
* `Math.log()`
* `Math.sqrt()`
* Opérateur d'exponentiation 
Expérimental
Math.atanh()
============

La fonction **`Math.atanh()`** renvoie l'arc tangente hyperbolique d'un nombre :



∀
x
∊

(

-
1
,
1

)

,

Math.atanh
(
x
)

=
arctanh
(
x
)
=
 le seul 

y
 tel que

tanh
(
y
)
=
x

\forall x \in \left( -1, 1 \right), \mathtt{\operatorname{Math.atanh}(x)} = \operatorname{arctanh}(x) = \text{ the unique } ; y ; \text{such that} ; \tanh(y) = x

Exemple interactif
------------------

Syntaxe
-------


```js
Math.atanh(x);
```

### Paramètres

`x`

Un nombre.

### Valeur de retour

L'arc tangente hyperbolique du nombre passé en argument.

Description
-----------

`atanh()` est une méthode statique de `Math`, il faut utiliser la syntaxe `Math.atanh()`, et non pas une méthode d'un objet `Math` créé sur mesure (`Math` n'est pas un constructeur).

Exemple
-------

### Utiliser `Math.atanh()`


```js
Math.atanh(-2); // NaN
Math.atanh(-1); // -Infinity
Math.atanh(0); // 0
Math.atanh(0.5); // 0.5493061443340548
Math.atanh(1); // Infinity
Math.atanh(2); // NaN
```


Pour les valeurs strictement inférieures à -1 ou strictement supérieures à 1, `NaN` sera renvoyé.

Prothèse d'émulation (*polyfill*)
---------------------------------

Pour 


|
x
|

<
1

\left|x\right| < 1

, on a la formule suivante : 


artanh
(
x
)
=

1
2

ln

(

1
+
x

1
-
x

)

\operatorname {artanh} (x) = \frac{1}{2}\ln \left( \frac{1 + x}{1 - x} \right)

et on peut donc émuler la fonction avec :


```js
Math.atanh =
  Math.atanh ||
  function (x) {
    return Math.log((1 + x) / (1 - x)) / 2;
  };
```

Spécifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.atanh |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* `Math.acosh()`
* `Math.asinh()`
* `Math.cosh()`
* `Math.sinh()`
* `Math.tanh()`
Math.trunc()
============

La fonction **`Math.trunc()`** retourne la troncature entière d'un nombre en retirant sa partie décimale.



Math.trunc
(
x
)

=

{

⌊
x
⌋

si

x
≥
0


⌈
x
⌉

si

x
<
0


\mathtt{\operatorname{Math.trunc}(x)} = \begin{cases} \left\lfloor x \right\rfloor & \text{if} & x \geq 0 \ \left\lceil x \right\rceil & \text{if} &x < 0 \end{cases}

Exemple interactif
------------------

Syntaxe
-------


```js
Math.trunc(x);
```

### Paramètres

`x`

Un nombre.

### Valeur de retour

La partie entière du nombre passé en argument.

Description
-----------

Contrairement aux autres méthodes `Math.floor()`, `Math.ceil()` et `Math.round()`, `Math.trunc()` fonctionne de façon très simple : la partie décimale du nombre est retirée et on conserve la partie entière (que le nombre soit positif ou négatif).

Ainsi, si l'argument est un nombre positif, `Math.trunc()` sera équivalent à `Math.floor()`, sinon `Math.trunc()` sera équivalent à `Math.ceil()`.

On notera que l'argument passé à la méthode est converti en nombre de façon implicite.

`trunc()` est une méthode statique de `Math`, elle doit toujours être utilisée avec la syntaxe `Math.trunc()`, elle ne doit pas être utilisée comme la méthode d'un objet qui aurait été instancié (`Math` n'est pas un constructeur).

Exemples
--------

### Utiliser `Math.trunc()`


```js
Math.trunc(13.37); // 13
Math.trunc(42.84); // 42
Math.trunc(0.123); // 0
Math.trunc(-0.123); // -0
Math.trunc("-1.123"); // -1
Math.trunc(NaN); // NaN
Math.trunc("toto"); // NaN
Math.trunc(); // NaN
```

Spécifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.trunc |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* `Math.abs()`
* `Math.ceil()`
* `Math.floor()`
* `Math.round()`
* `Math.sign()`