Explication détaillée des propriétés et méthodes de l'objet Number des compétences natives JavaScript objects

Syntaxe de création d'objets Nombre :

Copier le code Le code est le suivant :

var monNum = nouveau Nombre(valeur);

var monNum = Nombre(valeur);

Lorsque Number() est utilisé comme constructeur avec l'opérateur new, il renvoie un objet Number nouvellement créé. Si vous n'utilisez pas l'opérateur new et n'appelez pas Number() en tant que fonction, il convertira son argument en un nombre primitif et renverra cette valeur (ou NaN si la conversion échoue).

MAX_VALUE

L'attribut MAX_VALUE est le plus grand nombre représentable en JavaScript. Sa valeur approximative est 1,7976931348623157 x 10308. Le plus grand nombre négatif est -MAX_VALUE.

Le nombre supérieur à MAX_VALUE est l'infini. MAX_VALUE est une propriété statique, la méthode appelante doit donc être Number.MAX_VALUE.

Copier le code Le code est le suivant :

console.log(Number.MAX_VALUE) //1.7976931348623157e 308

MIN_VALUE

L'attribut MIN_VALUE est le plus petit nombre représentable en JavaScript (proche de 0, mais pas négatif). Sa valeur approximative est de 5 x 10^-324.

Tous les nombres inférieurs à MIN_VALUE seront convertis en 0.

MIN_VALUE est une propriété statique, la méthode appelante doit donc être Number.MIN_VALUE.

NaN

L'attribut NaN est une valeur spéciale qui représente une valeur non numérique. Cet attribut est utilisé pour indiquer qu'une valeur n'est pas un nombre. Un objet Number peut être défini sur cette valeur pour indiquer qu'il ne s'agit pas d'une valeur numérique.

Vous pouvez utiliser la fonction globale isNaN() pour déterminer si une valeur est une valeur NaN.

Number.NaN est une valeur spéciale indiquant que le résultat de certaines opérations arithmétiques (comme trouver la racine carrée d'un nombre négatif) n'est pas un nombre. Les méthodes parseInt() et parseFloat() renvoient cette valeur lorsque la chaîne spécifiée ne peut pas être analysée. Pour certaines fonctions qui renvoient normalement des nombres valides, vous pouvez également utiliser cette méthode et utiliser Number.NaN pour indiquer ses conditions d'erreur.

JavaScript génère Number.NaN sous la forme NaN. Notez que NaN est toujours inégal par rapport à d’autres nombres, y compris lui-même. Par conséquent, vous ne pouvez pas comparer avec Number.NaN pour tester si une valeur est un nombre, mais vous pouvez uniquement appeler isNaN() à des fins de comparaison.

Remarque : La variable globale NaN est la même que Number. NaN est un attribut non configurable et non modifiable.

Copier le code Le code est le suivant :

console.log(parseInt("abc")); //NaN

console.log(NaN === NaN); //false

console.log(Number.NaN === NaN); //false

console.log(isNaN(NaN)); //true

console.log(isNaN(Number.NaN)); //true

NEGATIVE_INFINITY

L'attribut NEGATIVE_INFINITY représente une valeur inférieure à -Number.MAX_VALUE. Cette valeur représente l'infini négatif.

JavaScript utilise -Infinity lors de l'affichage de NEGATIVE_INFINITY. Le comportement arithmétique de cette valeur est très similaire à l'infini. Par exemple, tout nombre multiplié par l’infini donne toujours l’infini, et tout nombre divisé par l’infini donne toujours 0.

-L'infini est égal à Number.NEGATIVE_INFINITY.

Copier le code Le code est le suivant :

var x = (-Number.MAX_VALUE) * 2;

var y = Nombre.NEGATIVE_INFINITY;

console.log(x); //-Infini

console.log(y); //-Infini

console.log(x===y); //true

POSITIVE_INFINITY

L'attribut POSITIVE_INFINITY représente une valeur supérieure à Number.MAX_VALUE. Cette valeur représente l'infini positif.

JavaScript utilise Infinity lors de l'affichage de POSITIVE_INFINITY. Le comportement arithmétique de cette valeur est très similaire à l'infini. Par exemple, tout nombre multiplié par l’infini donne toujours l’infini, et tout nombre divisé par l’infini donne toujours 0.

L'infini est égal à Number.POSITIVE_INFINITY.

La méthode isFinite() peut déterminer si le paramètre est un nombre fini.

Copier le code Le code est le suivant :

var x = Nombre.NEGATIVE_INFINITY;
var y = Nombre.POSITIVE_INFINITY;
var z = Infini;
var a = "abc";
var b = 123;

console.log(isFinite(x)); //false
console.log(isFinite(y)); //false
console.log(isFinite(z)); //false
console.log(isFinite(a)); //false
console.log(isFinite(b)); //true

toString()

La méthode toString() convertit un objet Number en chaîne et renvoie le résultat.

NumberObject.toString(radix)

La base du paramètre est facultative. Spécifie la base dans laquelle le nombre est représenté, ce qui en fait un entier compris entre 2 et 36. Si ce paramètre est omis, la base 10 est utilisée. Il est recommandé de toujours porter ce paramètre pour éviter tout malentendu. Par exemple, lorsque la base est 2, le NumberObject est converti en une chaîne représentant la valeur binaire.

Une exception TypeError est levée lorsque l'objet appelant cette méthode n'est pas un Number.

Copier le code Le code est le suivant :

var a = 100;

console.log(a.toString()); //100
console.log(a.toString(10)); //100
console.log(a.toString(2)); //1100100
console.log(a.toString(8)); //144
console.log(a.toString(16)); //64

toLocaleString()

La méthode toLocaleString() peut convertir un objet Number en une chaîne de format local.

Représentation sous forme de chaîne d'un nombre, implémentation déterminée, formatée selon les spécifications locales, qui peut affecter la ponctuation utilisée pour les séparateurs décimaux ou millièmes.

Une exception TypeError est levée lorsque l'objet appelant cette méthode n'est pas un Number.

Copier le code Le code est le suivant :

var a = 123456;

console.log(a.toLocaleString()); //123 456
console.log(a.toLocaleString("zh-Hans-CN-u-nu-hanidec")); //Un, deux, trois, quatre, cinq, six

Pour plus de paramètres, veuillez vous référer à : MDN

àFixed()

La méthode toFixed() arrondit un nombre à un nombre avec un nombre spécifié de décimales.

NumberObject.toFixed(num)

Le paramètre num est obligatoire. Spécifie le nombre de décimales, qui est une valeur comprise entre 0 et 20 inclus. Certaines implémentations peuvent prendre en charge une plage de valeurs plus large. Si ce paramètre est omis, 0 sera utilisé à la place.

Renvoie la représentation sous forme de chaîne de NumberObject, qui n'utilise pas de comptage exponentiel et a un nombre fixe de chiffres après la virgule décimale. Le nombre est arrondi si nécessaire et complété par des zéros afin qu'il atteigne la longueur spécifiée. Si num est supérieur à 21, cette méthode appelle simplement NumberObject.toString(), renvoyant une chaîne en notation exponentielle.

RangeError est renvoyé lorsque num est trop petit ou trop grand. Les valeurs comprises entre 0 et 20 ne déclenchent pas cette exception. Certaines implémentations prennent en charge une plage de valeurs plus grande ou plus petite. Une exception TypeError est levée lorsque l'objet appelant cette méthode n'est pas un Number.

Copier le code Le code est le suivant :

var n = 12345.6789;

console.log(n.toFixed()); //12346
console.log(n.toFixed(2)); //12345.68
console.log(n.toFixed(6)); //12345.678900
console.log((1.23e 20).toFixed(2)); //123000000000000000000.00
console.log((1.23e-10).toFixed(2)); //0.00

Remarque : en raison du traitement des nombres à virgule flottante, le résultat affiché par la méthode toFixed() n'est pas ce qu'on appelle "l'arrondi" ou "l'arrondi de six à cinq en double", mais la performance d'arrondi, six et cinq. Très déroutant.

Copier le code Le code est le suivant :

//Chrome

console.log(( 0.035 ).toFixed( 2 )); //0.04

console.log(( 0.045 ).toFixed( 2 )); //0.04

Il est recommandé d'écrire votre propre méthode pour remplacer le comportement par défaut de toFixed(). Vous pouvez vous référer à : Discussion sur SO :

Copier le code Le code est le suivant :

Number.prototype.toFixed = function(len){
var temp = Math.pow(10,len);
var s = Math.ceil(this * temp)
Retour s/temp ;
>

console.log(( 0.035 ).toFixed( 2 )); //0.04
console.log(( 0.045 ).toFixed( 2 )); //0.05

àExponentiel()

La méthode toExponential() peut convertir la valeur de l'objet en notation exponentielle.

NumberObject.toExponential(num)

Le paramètre num est facultatif. Spécifie le nombre de décimales en notation exponentielle, qui est une valeur comprise entre 0 et 20 inclus. Certaines implémentations peuvent prendre en charge une plage de valeurs plus large. Si cet argument est omis, autant de nombres que possible seront utilisés.

Renvoie la représentation sous forme de chaîne de NumberObject, en utilisant la notation exponentielle, c'est-à-dire qu'il y a un chiffre avant la virgule décimale et des chiffres après la virgule. La partie décimale du nombre sera arrondie, complétée de zéros si nécessaire, afin qu'elle atteigne la longueur spécifiée.

Copier le code Le code est le suivant :

var num = 10000.1234;

console.log(num.toExponential()); //1.00001234e 4
console.log(num.toExponential(2)); //1.00e 4
console.log(num.toExponential(10)); //1.0000123400e 4

toPrecision()

La méthode toPrecision() formate une valeur numérique en une chaîne sous la forme d'un nombre décimal.

NumberObject.toPrecision(num)

Le paramètre num est facultatif. Utilisé pour contrôler la précision des nombres. Ce paramètre est une valeur comprise entre 1 et 21 inclus. Si ce paramètre est omis, la méthode toString() est appelée au lieu de convertir le nombre en valeur décimale.

Copier le code Le code est le suivant :

var num = 10000.1234;

console.log(num.toPrecision()); //10000.1234
console.log(num.toPrecision(2)); //1.0e 4
console.log(num.toPrecision(10)); //10000.12340