Combien de types de types numériques javascript existe-t-il ?

Il n'existe qu'un seul type numérique en JavaScript : le type à virgule flottante. JavaScript stocke en interne les nombres sous forme de types à virgule flottante 64 bits, il n'y a donc pas de type entier en JavaScript. Selon le format numérique en JavaScript, la plage d'entiers pouvant être représentée est "[-2^53 ~ 2^53]", y compris les valeurs limites, mais il convient de noter que les index de tableau, les opérateurs de bits, etc. utilisent 32 ; entiers en bits.

L'environnement d'exploitation de ce tutoriel : système Windows 7, JavaScript version 1.8.5, ordinateur Dell G3.

En JavaScript, il n'existe qu'un seul type numérique, qui est représenté en interne sous la forme d'un nombre à virgule flottante de 64 bits. Il n’existe donc pas de type entier en JavaScript.

print(3/2); // 1.5

On peut voir que les valeurs​​sont traitées comme des nombres à virgule flottante.

Parce que JavaScript stocke en interne les nombres dans des types à virgule flottante 64 bits, quels que soient les nombres entiers ou décimaux. Ce qui est déroutant, c'est que certaines opérations sur bits doivent nécessiter des entiers pour s'exécuter, de sorte que les nombres à virgule flottante de 64 bits sont automatiquement convertis en entiers de 32 bits. Effectuez ensuite des opérations sur les bits. En JavaScript, 1 et 1.0 sont identiques

1 == 1.0 true
0.1+0.2 == 0.3 false
0.3/0.1 = 2.99999999996
(0.3-0.2) === (0.2-0.1) false

En bref, soyez prudent lorsque vous effectuez des opérations impliquant des décimales

Selon le format numérique en JavaScript (format à virgule flottante 64 bits défini par IEEE-754), la plage d'entiers qui peut être représenté par [- 2 ^ 53 ~ 2 ^ 53], y compris les valeurs limites. Cependant, il convient de noter que l'indexation de tableaux, les opérateurs au niveau du bit, etc. utilisent des entiers de 32 bits.

La plus haute précision des valeurs à virgule flottante est de 17 décimales, mais sa précision est bien inférieure à celle des nombres entiers lors de l'exécution de calculs arithmétiques. Par exemple, le résultat de l’ajout de 0,1 à 0,2 n’est pas 0,3, mais 0,30000000000000004. Cette petite erreur d’arrondi rend impossible le test de valeurs à virgule flottante spécifiques.

Parce que les nombres binaires à virgule flottante peuvent représenter avec précision 1/2, 1/8, etc., mais ne peuvent pas représenter avec précision 1/10, 1/100, etc. Des nombres simples comme 0,1 ne peuvent donc pas être représentés avec précision.

En raison de problèmes de précision avec les nombres à virgule flottante, vous pouvez obtenir des résultats inattendus lors de la comparaison :

print((0.1+0.2) == 0.3); // false
print(0.1+0.2);          // 0.30000000000000004
print(0.3);              // 0.3

print((10/3-3) == (1/3));// false
print(10/3-3);           // 0.3333333333333335
print(1/3);              // 0.3333333333333333

Pour les nombres entiers, tant que vous utilisez des nombres entiers compris entre 53 chiffres, il n'y aura aucun problème de précision et vous pourrez les utiliser en toute confiance.

En plus d'être représentés en décimal, les entiers peuvent également être représentés par des littéraux en octal (base 8) ou en hexadécimal (base 16). Parmi eux, le premier chiffre du littéral octal doit être zéro (0), suivi d'une séquence de chiffres octaux (0 à 7). Si la valeur du littéral dépasse la plage, les zéros non significatifs sont ignorés et la valeur suivante est interprétée comme une valeur décimale.

Les littéraux octaux ne sont pas valides en mode strict et entraîneront des erreurs dans les moteurs JavaScript prenant en charge ce mode.

Les deux premiers chiffres d'une valeur littérale hexadécimale doivent être 0x, suivis de n'importe quel chiffre hexadécimal (0~9 et A~F). Parmi elles, les lettres A à F peuvent être majuscules ou minuscules.

Étant donné que l'enregistrement des valeurs à virgule flottante nécessite deux fois plus d'espace mémoire que l'enregistrement des valeurs entières, ECMAScript ne perdra pas de temps à convertir les valeurs à virgule flottante en valeurs entières. Évidemment, si le point décimal n’est suivi d’aucun chiffre, la valeur peut alors être enregistrée sous forme de valeur entière. De même, si la valeur à virgule flottante elle-même représente un entier (tel que 1,0), alors la valeur sera également convertie en entier.

Objet numérique

Tout comme une valeur de chaîne correspond à un objet chaîne, une valeur numérique a également un objet numérique correspondant, à savoir Nombre.

Les valeurs numériques peuvent aussi appeler directement les propriétés correspondant à la valeur numérique :

print((6).toString()); // 6

Notez que dans cet exemple, la valeur numérique doit ajouter des parenthèses, sinon le point sera considéré comme un point décimal.

L'utilisation de Number est similaire à l'utilisation de String. Il peut effectuer une conversion de type, créer des objets numériques, etc.

Lors de la conversion de type, si la conversion échoue, c'est-à-dire que Number renvoie NaN. Il en va de même lors de l'utilisation d'objets numériques.

var a = Number('x');
print(typeof a, a);       // number NaN
var b = new Number('x'); 
print(typeof b, b);       // object [Number: NaN]

Number a 5 attributs spéciaux (lecture seule), à ​​savoir :

• MAX_VALUE : La valeur maximale d'un nombre positif, s'il est plus grand, il deviendra Infini

• MIN_VALUE : La valeur minimale d'un nombre positif, s'il est plus petit il deviendra Infini devient 0

• NaN : Pas un nombre

• NEGATIVE_INFINITY : Infini négatif, c'est-à-dire -Infini

• POSITIVE_INFINITY : Infini positif, c'est-à-dire Infini

print(Number.MAX_VALUE);         // 1.7976931348623157e+308
print(Number.MIN_VALUE);         // 5e-324
print(Number.NaN);               // NaN
print(Number.NEGATIVE_INFINITY); // -Infinity
print(Number.POSITIVE_INFINITY); // Infinity

Infinity

Lorsque le résultat de l'opération numérique Lorsque la limite supérieure du nombre que JavaScript peut représenter est dépassée, le résultat est une valeur infinie spéciale (Infini). que JavaScript peut représenter, le résultat est -Infinity.

Lorsque le résultat de l'opération est infiniment proche de zéro et inférieur à la valeur minimale que JavaScript peut représenter (sous-dépassement), le résultat est 0. Lorsqu'un nombre négatif dépasse, le résultat est -0. Lorsqu'un nombre positif dépasse, le résultat. est +0.

JavaScript prédéfinit les variables globales Infinity et NaN, qui sont toutes deux des variables en lecture seule.

由于内存的限制，ECMAScript并不能保存世界上所有的数值。ECMAScript能够表示的最小数值保存在Number.MIN_VALUE中——在大多数浏览器中，这个值是5e-324；能够表示的最大数值保存在Number.MAX_VALUE中——在大多数浏览器中，这个值是1.7976931348623157e+308。如果某次计算的结果得到了一个超出JavaScript数值范围的值，那么这个数值将被自动转换成特殊的Infinity值。具体来说，如果这个数值是负数，则会被转换成-Infinity（负无穷），如果这个数值是正数，则会被转换成Infinity（正无穷）。 

如果某次计算返回了正或负的Infinity值，那么该值将无法继续参与下一次的计算，因为Infinity不是能够参与计算的数值。要想确定一个数值是不是有穷的（换句话说，是不是位于最小和最大的数值之间），可以使用isFinite()函数。

NaN

NaN是一个特殊的数值，这个数值用于表示一个本来要返回数值的操作数未返回数值的情况（这样就不会抛出错误了）。

对于NaN，要记住的一点是，只要运算中出现NaN，结果就一定是NaN，就算是"NaN*0"这样的运算，也一样是NaN。只要对NaN运行比较运行，结果就一定是false，就算"NaN==NaN"/"NaN!=NaN"等，都是false。

要判断一个值是否为NaN，可以使用isNaN()函数：

print(isNaN(NaN));  // true
print(isNaN(0/0));  // true

在基于对象调用isNaN()函数时，会首先调用对象的valueOf()方法，然后确定该方法返回的值是否可以转换为数值。如果不能，则基于这个返回值再调用toString()方法，再测试返回值。

也可以使用x!==x来判断x是否为NaN，只有在x为NaN的时候，这个表达式的值才为true。

inFinite()

isFinite函数用于判断一个数是否为“正常”的数值：

print(isFinite(Number.NaN));               // false
print(isFinite(Number.NEGATIVE_INFINITY)); // false
print(isFinite(Number.POSITIVE_INFINITY)); // false

除了以上3个特殊值外，其他值的结果都为true

假如x是一个普通数值，则有：

x/0 = Infinity
x%0 = NaN
x/Infinity = 0
x%Infinity = x
0/0 = NaN
0%0 = NaN
Infinity/x = Infinity
Infinity%x = NaN
Infinity/Infinity = NaN
Infinity%Infinity = NaN

完整输出如下：

print(0 / 0);           // NaN
print(3 / 0);           // Infinity
print(Infinity / 0);    // Infinity
print(0 % 0);           // NaN
print(3 % 0);           // NaN
print(Infinity % 0);    // NaN
----------
print(0 / 4);           // 0
print(3 / 4);           // 0.75
print(Infinity / 4);    // Infinity
print(0 % 4);           // 0
print(3 % 4);           // 3
print(Infinity % 4);    // NaN
----------
print(0 / Infinity);           // 0
print(3 / Infinity);           // 0
print(Infinity / Infinity);    // NaN
print(0 % Infinity);           // 0
print(3 % Infinity);           // 3
print(Infinity % Infinity);    // NaN

负零与正零

负零与正零的值相等，不过毕竟带有符号，在一些运算中会有符号方面的差别，比如：

var zero = 0; 
var negz = -0;

此时，zero 等于 negz ， 但1/zero 却不等于 1/negz。

【相关推荐：javascript视频教程、编程基础视频】

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!