Dans ce didacticiel, vous en apprendrez davantage sur JavaScript Number à l'aide d'exemples.
En JavaScript, les nombres sont des types de données primitifs. Par exemple,
const a = 3; const b = 3.13;
Contrairement à certains autres langages de programmation, vous n'avez pas à déclarer spécifiquement les valeurs entières ou flottantes en utilisant int , float , etc.
Vous pouvez utiliser la notation exponentielle e pour inclure des nombres trop grands ou trop petits. Par exemple,
const a1 = 5e9; console.log(a1); //5000000000 const a2 = 5e-5; console.log(a2); // 0.00005
Les nombres peuvent également être indiqués en notation hexadécimale. Par exemple,
const a = 0xff; console.log(a); // 255 const b = 0x00 ; console.log(b); // 0
+ Opérateur avec numéros
Lorsqu'il +est utilisé avec des nombres, il est utilisé pour additionner les nombres. Par exemple,
const a = 4 + 9; console.log(a); // 13
Quand +est utilisé avec des nombres et des chaînes, il est utilisé pour les concaténer. Par exemple,
const a = '4' + 9; console.log(a); // 49
Lorsqu'une chaîne numérique est utilisée avec d'autres opérations numériques, la chaîne numérique est convertie en nombre. Par exemple,
const a = '4' - 2; console.log(a); // 2 const a = '4' / 2; console.log(a); // 2 const a = '4' * 2; console.log(a); // 8
JavaScript NaN
En JavaScript, NaN(Not a Number) est un mot-clé qui indique que la valeur n'est pas un nombre.
Effectuer des opérations arithmétiques (sauf +) sur une valeur numérique avec une chaîne entraîne des résultats NaN. Par exemple,
const a = 4 - 'hello'; console.log(a); // NaN
La fonction intégrée isNaN()peut être utilisée pour déterminer si une valeur est un nombre. Par exemple,
const a = isNaN(9); console.log(a); // false const a = isNaN(4 - 'hello'); console.log(a); // true
Lorsque l' typeofopérateur est utilisé pour la NaNvaleur, il donne une sortie numérique. Par exemple,
const a = 4 - 'hello'; console.log(a); // NaN console.log(typeof a); // "number"
JavaScript Infinity
En JavaScript, lorsque le calcul dépasse le plus grand (ou le plus petit) nombre possible, Infinity (ou -Infinity) est renvoyé. Par exemple,
const a = 2 / 0; console.log(a); // Infinity const a = -2 / 0; console.log(a); // -Infinity
JavaScript BigInt
En JavaScript, le type Number ne peut représenter que des nombres inférieurs à (2 53 - 1) et supérieurs à - (2 53 - 1) . Cependant, si vous devez utiliser un nombre plus grand que cela, vous pouvez utiliser le type de données BigInt.
Un nombre BigInt est créé en ajoutant n à la fin d'un entier. Par exemple,
// BigInt value const value = 900719925124740998n; // Adding two big integers const value1 = value + 1n; console.log(value1); // returns "900719925124740999n"
Remarque: BigInt a été introduit dans la nouvelle version de JavaScript et n'est pas pris en charge par de nombreux navigateurs. Visitez le support JavaScript BigInt pour en savoir plus.
Les numéros JavaScript sont stockés en 64 bits
En JavaScript, les nombres sont stockés au format 64 bits IEEE-754, également appelé «nombres à virgule flottante double précision».
Les nombres sont stockés dans 64 bits (le nombre est stocké dans des positions de 0 à 51 bits, l'exposant dans des positions de 52 à 62 bits et le signe dans la position de 63 bits).
| Nombres | Exposant | Signe |
|---|---|---|
| 52 bits (0 à 51) | 11 bits (52 à 62) | 1 bit (63) |
Problèmes de précision
Les opérations sur les nombres à virgule flottante donnent des résultats inattendus. Par exemple,
const a = 0.1 + 0.2; console.log(a); // 0.30000000000000004
Le résultat devrait être 0,3 au lieu de 0,30000000000000004 . Cette erreur se produit car dans JavaScript, les nombres sont stockés sous forme binaire pour représenter les chiffres décimaux en interne. Et les nombres décimaux ne peuvent pas être représentés exactement sous forme binaire.
Pour résoudre le problème ci-dessus, vous pouvez faire quelque chose comme ceci:
const a = (0.1 * 10 + 0.2 * 10) / 10; console.log(a); // 0.3
Vous pouvez également utiliser la toFixed()méthode.
const a = 0.1 + 0.2; console.log(a.toFixed(2)); // 0.30
toFixed(2) arrondit le nombre décimal à deux valeurs décimales.
const a = 9999999999999999 console.log(a); // 10000000000000000
Remarque : les nombres entiers sont précis jusqu'à 15 chiffres.
Objets numériques
Vous pouvez également créer des nombres à l'aide du newmot - clé. Par exemple,
const a = 45; // creating a number object const b = new Number(45); console.log(a); // 45 console.log(b); // 45 console.log(typeof a); // "number" console.log(typeof b); // "object"
Remarque : il est recommandé d'éviter d'utiliser des objets numériques. L'utilisation d'objets numériques ralentit le programme.
Méthodes de numérotation JavaScript
Voici une liste de méthodes numériques intégrées en JavaScript.
| Méthode | La description |
|---|---|
| isNaN () | détermine si la valeur transmise est NaN |
| isFinite () | détermine si la valeur passée est un nombre fini |
| isInteger () | détermine si la valeur transmise est un entier |
| isSafeInteger () | détermine si la valeur transmise est un entier sûr |
| parseFloat (chaîne) | convertit la chaîne flottante numérique en nombre à virgule flottante |
| parseInt (chaîne, (base)) | convertit la chaîne numérique en entier |
| toExponential (fractionDigits) | returns a string value for a number in exponential notation |
| toFixed(digits) | returns a string value for a number in fixed-point notation |
| toPrecision() | returns a string value for a number to a specified precision |
| toString((radix)) | returns a string value in a specified radix(base) |
| valueof() | returns the numbers value |
| toLocaleString() | returns a string with a language sensitive representation of a number |
For example,
// check if a is integer const a = 12; console.log(Number.isInteger(a)); // true // check if b is NaN const b = NaN; console.log(Number.isNaN(b)); // true // display upto two decimal point const d = 5.1234; console.log(d.toFixed(2)); // 5.12
JavaScript Number Properties
Here is a list of Number properties in JavaScript.
| Property | Description |
|---|---|
| EPSILON | returns the smallest interval between two representable numbers |
| MAX_SAFE_INTEGER | returns the maximum safe integer |
| MAX_VALUE | returns the largest possible value |
| MIN_SAFE_INTEGER | returns the minimum safe integer |
| MIN_VALUE | returns the smallest possible value |
| NaN | represents 'Not-a-Number' value |
| NEGATIVE_INFINITY | represents negative infinity |
| POSITIVE_INFINITY | représente l'infini positif |
| prototype | permet l'ajout de propriétés aux objets Number |
Par exemple,
// largest possible value const a = Number.MAX_VALUE; console.log(a); // 1.7976931348623157e+308 // maximum safe integer const a = Number.MAX_SAFE_INTEGER; console.log(a); // 9007199254740991
Fonction JavaScript Number ()
La Number()fonction est utilisée pour convertir divers types de données en nombres. Par exemple,
const a = '23'; // string const b = true; // boolean //converting to number const result1 = Number(a); const result2 = Number(b); console.log(result1); // 23 console.log(result2); // 1
Si vous souhaitez en savoir plus sur la conversion numérique, consultez la page Conversion de type JavaScript.
