Représentation des nombres

Nouvelle notation pour les littéraux binaires : préfixe 0b ou 0B.

console.log(0b11 === 3); // true
console.log(0B11 === 3); // true

Nouvelle notation pour les littéraux octaux : préfixe 0o ou 0O.

console.log(0o11 === 9); // true
console.log(0O11 === 9); // true

Constantes

Number.EPSILON

La propriété Number.EPSILON représente la différence entre 1 et le plus petit nombre à virgule flottante supérieur à 1.

Sa valeur est approximativement 2.2204460492503130808472633361816E-16, ou 2^-52.

Tester si un nombre est dans la tolérance d'erreur :

0.1 + 0.2 === 0.3; // false
// 在误差范围内即视为相等
equal = (Math.abs(0.1 - 0.3 + 0.2) < Number.EPSILON); // true

Attributs de propriété

writable:false
enumerable:false
configurable:false

Entier sûr maximum / minimum

Entier sûr

Un entier sûr est un entier qui peut être représenté exactement en JavaScript. L'intervalle des entiers sûrs va de l'opposé de 2 puissance 53 à 2 puissance 53 (bornes exclues). Les entiers en dehors de cet intervalle ne peuvent pas être représentés exactement.

Entier sûr maximal

La limite supérieure de l'intervalle des entiers sûrs, c'est-à-dire 2 puissance 53 moins 1.

Number.MAX_SAFE_INTEGER + 1 === Number.MAX_SAFE_INTEGER + 2; // true Number.MAX_SAFE_INTEGER === Number.MAX_SAFE_INTEGER + 1; // false Number.MAX_SAFE_INTEGER - 1 === Number.MAX_SAFE_INTEGER - 2; // false

Entier sûr minimal

La limite inférieure de l'intervalle des entiers sûrs, c'est-à-dire l'opposé de 2 puissance 53 moins 1.

Number.MIN_SAFE_INTEGER + 1 === Number.MIN_SAFE_INTEGER + 2; // false Number.MIN_SAFE_INTEGER === Number.MIN_SAFE_INTEGER - 1; // false Number.MIN_SAFE_INTEGER - 1 === Number.MIN_SAFE_INTEGER - 2; // true

Attributs de propriété

writable:false
enumerable:false
configurable:false

Méthodes

Nouvelles méthodes de l'objet Number

Number.isFinite()

Utilisé pour vérifier si un nombre est fini, c'est-à-dire s'il n'est pas Infinity.

console.log( Number.isFinite(1)); // true console.log( Number.isFinite(0.1)); // true //NaN n'est pas fini. console.log( Number.isFinite(NaN)); // false console.log( Number.isFinite(Infinity)); // false console.log( Number.isFinite(-Infinity)); // false //Number.isFinate n'effectue pas de conversion implicite de type Number() ; il renvoie false pour toutes les valeurs qui ne sont pas des nombres. console.log( Number.isFinite('foo')); // false console.log( Number.isFinite('15')); // false console.log( Number.isFinite(true)); // false Number.isNaN()Sert à vérifier si une valeur estNaN 。 console.log(Number.isNaN(NaN)); // true console.log(Number.isNaN('true'/0)); // true //Dans la fonction isNaN() globale, les éléments suivants retournent tous true, car les valeurs non numériques sont converties en nombres avant la vérification. //Cependant, Number.isNaN() n'effectue pas de conversion de type Number() implicite ; toutes les valeurs qui ne sont pas NaN retournent false. Number.isNaN("NaN"); // false Number.isNaN(undefined); // false Number.isNaN({}); // false Number.isNaN("true"); // false

Méthodes transférées de l'objet global vers l'objet Number

Réduire progressivement les méthodes globales pour la modularisation des variables globales.

Le comportement des méthodes n'a pas changé.

Number.parseInt()

Utilisé pour convertir une chaîne donnée en un entier d'une base spécifiée.

//Lorsqu'aucune base n'est spécifiée, la base 10 est utilisée par défaut. Number.parseInt('12.34'); // 12 Number.parseInt(12.34); // 12 //Spécification d'une base Number.parseInt('0011',2); // 3 //C'est la même fonction que la fonction globale parseInt(). Number.parseInt === parseInt; // true Number.parseFloat()Utilisé pour analyser une chaîne en un nombre à virgule flottante.Number.parseFloat('123.45') // 123.45 Number.parseFloat('123.45abc') // 123.45 //Si l'analyse comme nombre à virgule flottante échoue, NaN est renvoyé. Number.parseFloat('abc') // NaN //Il s'agit de la même méthode que la méthode globale parseFloat(). Number.parseFloat === parseFloat // true Number.isInteger()Sert à déterminer si l'argument donné est un entier.Number.isInteger(value) Number.isInteger(0); // true //En interne, JavaScript utilise la même méthode de stockage pour les entiers et les nombres à virgule flottante, donc 1 et 1.0 sont traités comme la même valeur. Number.isInteger(1); // true Number.isInteger(1.0); // true Number.isInteger(1.1); // false Number.isInteger(Math.PI); // false //NaN et Infinity positif/négatif ne sont pas des entiers. Number.isInteger(NaN); // false Number.isInteger(Infinity); // false Number.isInteger(-Infinity); // false Number.isInteger("10"); // false Number.isInteger(true); // false Number.isInteger(false); // false Number.isInteger([1]); // false //Lorsque la précision d’un nombre dépasse 53 bits binaires, les bits à partir du 54e sont supprimés, ce qui peut entraîner un jugement erroné. Number.isInteger(1.0000000000000001) // true //Lorsque la valeur absolue d’un nombre est inférieure à Number.MIN_VALUE (5E-324), c’est-à-dire inférieure à la plus petite valeur que JavaScript peut distinguer, //il est automatiquement converti en 0, ce qui provoque également un jugement erroné. Number.isInteger(5E-324); // false Number.isInteger(5E-325); // true Number.isSafeInteger()Sert à déterminer si un nombre se trouve dans la plage de sécurité.Number.isSafeInteger(Number.MIN_SAFE_INTEGER - 1); // false Number.isSafeInteger(Number.MAX_SAFE_INTEGER + 1); // false

Extensions de l’objet Math

ES6 a ajouté 17 méthodes statiques liées aux mathématiques à l’objet Math ; ces méthodes ne peuvent être appelées que sur Math.

Calculs de base

Math.cbrt

Utilisé pour calculer la racine cubique d’un nombre.

Math.cbrt(1); // 1 Math.cbrt(0); // 0 Math.cbrt(-1); // -1 //Il convertira les valeurs non numériques. Math.cbrt('1'); // 1 //Renvoie NaN pour les valeurs non numériques qui ne peuvent pas être converties en nombres. Math.cbrt('hhh'); // NaN
Math.imul

Le résultat de la multiplication de deux nombres en tant qu’entiers signés sur 32 bits ; la valeur de retour est également un entier signé sur 32 bits.

//Dans la plupart des cas, le résultat est le même que a * b. Math.imul(1, 2); // 2 //Utilisé pour renvoyer correctement la valeur d’ordre inférieur dans le résultat de la multiplication de grands nombres. Math.imul(0x7fffffff, 0x7fffffff); // 1
Math.hypot

Utilisé pour calculer la racine carrée de la somme des carrés de tous les arguments.

Math.hypot(3, 4); // 5 //Les valeurs non numériques sont d’abord converties en nombres avant le calcul. Math.hypot(1, 2, '3'); // 3.741657386773941 Math.hypot(true); // 1 Math.hypot(false); // 0 //Les valeurs vides sont converties en 0. Math.hypot(); // 0 Math.hypot([]); // 0 //Renvoie Infinity si un argument est Infinity ou -Infinity. Math.hypot(Infinity); // Infinity Math.hypot(-Infinity); // Infinity //Renvoie NaN si un argument ne peut pas être converti en nombre. Math.hypot(NaN); // NaN Math.hypot(3, 4, 'foo'); // NaN Math.hypot({}); // NaN
Math.clz32

Utilisé pour renvoyer le nombre de bits zéro en tête dans la forme d'entier non signé sur 32 bits d'un nombre.

Math.clz32(0); // 32 Math.clz32(1); // 31 Math.clz32(0b01000000000100000000000000000000); // 1 //Lorsque l'argument est un décimal, seule la partie entière est prise en compte. Math.clz32(0.5); // 32 //Pour les valeurs vides ou non numériques, elles sont converties en nombres avant le calcul. Math.clz32('1'); // 31 Math.clz32(); // 32 Math.clz32([]); // 32 Math.clz32({}); // 32 Math.clz32(NaN); // 32 Math.clz32(Infinity); // 32 Math.clz32(-Infinity); // 32 Math.clz32(undefined); // 32 Math.clz32('hhh'); // 32

Traitement des nombres

Math.trunc

Utilisé pour renvoyer la partie entière d’un nombre.

Math.trunc(12.3); // 12 Math.trunc(12); // 12 //Même lorsque la partie entière est 0, le signe est tout de même déterminé. Math.trunc(-0.5); // -0 Math.trunc(0.5); // 0 //Math.trunc convertit les valeurs non numériques en nombres avant le traitement. Math.trunc("12.3"); // 12 //Renvoie NaN pour les valeurs vides ou lorsque la conversion en nombre est impossible. Math.trunc(); // NaN Math.trunc(NaN); // NaN Math.trunc("hhh"); // NaN Math.trunc("123.2hhh"); // NaN
Math.fround

Utilisé pour obtenir la représentation en virgule flottante à simple précision sur 32 bits d’un nombre.

//Pour les entiers compris entre l'opposé de 2 à la puissance 24 et 2 à la puissance 24 (en excluant les deux bornes), le résultat renvoyé est identique à l'argument. Math.fround(-(2**24)+1); // -16777215 Math.fround(2 ** 24 - 1); // 16777215 //Utilisé pour convertir un nombre à virgule flottante double précision 64 bits en un nombre à virgule flottante simple précision 32 bits. Math.fround(1.234) // 1.125 //Lorsque la précision d'un nombre décimal dépasse 24 bits binaires, la précision est perdue. Math.fround(0.3); // 0.30000001192092896 //Renvoie l'argument lui-même lorsqu'il vaut NaN ou Infinity. Math.fround(NaN) // NaN Math.fround(Infinity) // Infinity //Lorsque l'argument est d'un autre type non numérique, il est converti. Math.fround('5'); // 5 Math.fround(true); // 1 Math.fround(null); // 0 Math.fround([]); // 0 Math.fround({}); // NaN

Détermination du signe

Math.sign

Détermine le signe d'un nombre (positif, négatif ou zéro).

Math.sign(1); // 1 Math.sign(-1); // -1 //Lorsque l'argument est 0, des signes différents renvoient des résultats différents. Math.sign(0); // 0 Math.sign(-0); // -0 //Les valeurs non numériques sont converties avant la vérification. Math.sign('1'); // 1 Math.sign('-1'); // -1 //Renvoie NaN lorsque l'argument est une valeur non numérique (qui ne peut pas être convertie en nombre). Math.sign(NaN); // NaN Math.sign('hhh'); // NaN

Méthodes logarithmiques

Math.expm1()

Utilisé pour calculer e à la puissance x moins 1, c'est-à-dire Math.exp(x) - 1.

Math.expm1(1); // 1.718281828459045 Math.expm1(0); // 0 Math.expm1(-1); // -0.6321205588285577 //Il convertira les valeurs non numériques. Math.expm1('0'); //0 //Renvoie NaN lorsque l'argument n'est pas un nombre et ne peut pas être converti en nombre. Math.expm1(NaN); // NaN
Math.log1p(x)

Utilisé pour calculer le logarithme népérien de 1 + x, c'est-à-dire Math.log(1 + x).

Math.log1p(1); // 0.6931471805599453 Math.log1p(0); // 0 Math.log1p(-1); // -Infinity //Renvoie NaN lorsque l'argument est inférieur à -1. Math.log1p(-2); // NaN
Math.log10(x)

Utilisé pour calculer le logarithme de base 10 de x.

Math.log10(1); // 0 //Les valeurs non numériques sont converties avant le calcul. Math.log10('1'); // 0 //Renvoie -Infinity lorsque l'argument est 0. Math.log10(0); // -Infinity //Renvoie NaN lorsque l'argument est inférieur à 0 ou lorsque l'argument n'est pas un nombre (et ne peut pas être converti en nombre). Math.log10(-1); // NaN
Math.log2()

Utilisé pour calculer le logarithme de base 2 de x.

Math.log2(1); // 0 //Les valeurs non numériques sont converties avant le calcul. Math.log2('1'); // 0 //Renvoie -Infinity lorsque l'argument est 0. Math.log2(0); // -Infinity //Renvoie NaN lorsque l'argument est inférieur à 0 ou lorsque l'argument n'est pas un nombre (et ne peut pas être converti en nombre). Math.log2(-1); // NaN

Méthodes des fonctions hyperboliques

  • Math.sinh(x) : utilisé pour calculer le sinus hyperbolique.
  • Math.cosh(x) : utilisé pour calculer le cosinus hyperbolique.
  • Math.tanh(x) : utilisé pour calculer la tangente hyperbolique.
  • Math.asinh(x) : utilisé pour calculer le sinus hyperbolique inverse.
  • Math.acosh(x) : utilisé pour calculer le cosinus hyperbolique inverse.
  • Math.atanh(x) : utilisé pour calculer la tangente hyperbolique inverse.

Opérateur d'exponentiation

1 ** 2; // 1 //Associatif à droite, évalué de droite à gauche. 2 ** 2 ** 3; // 256 // **= let exam = 2; exam ** = 2; // 4