JS n'a qu'un seul type de données numériques. Qu'il s'agisse d'un entier ou d'un numéro de point flottant, JS le classe comme un nombre.
typeof 17; // "nombre"
typeof 98.6; // "nombre"
typeof 2.1; // "nombre"
Tous les nombres en JS sont des nombres de points flottants à double précision. Il s'agit d'un numéro codé 64 bits formulé par la norme IEEE754 (quelle est ce truc, je ne sais pas, il suffit de le voir et de le vérifier)
Alors, comment JS exprime-t-il les entiers? Les nombres de points flottants à double précision peuvent représenter parfaitement des entiers avec une précision allant jusqu'à 53 bits (aucun concept, je n'ai pas traité trop de données, je n'ai pas utilisé!), Et tous les entiers de -9007199254740992 (-253) à 9007199254740992 (253) sont des numéros de points de flottement double de précision valides.
La plupart des opérateurs arithmétiques peuvent être calculés à l'aide d'entiers, de nombres réels ou d'une combinaison des deux.
0,1 * 1,9 //0.19
-99 + 100 // 1
21-12.3 //8.7
2.5 / 5 //0.5
21% 8 // 5
Les opérateurs arithmétiques sont assez spéciaux. JS ne calcule pas directement les opérandes en tant que nombres de points flottants, mais les convertit implicitement en entiers 32 bits pour effectuer des opérations. (Pour être précis, il sera converti en un entier représentant 2 de Big-endian 32 bits (pour être honnête, je ne sais vraiment pas ce que cela signifie ici, veuillez rechercher des sciences populaires)) Utilisez les expressions bit
exemple:
8 | 1; // 9
Processus de calcul
Tout d'abord, 8 et 1 sont des numéros de points flottants à double précision. Mais il peut également être représenté comme un entier 32 bits, c'est-à-dire une représentation binaire 32 bits.
Integer 8 est représenté comme un binaire 32 bits comme:
0000 0000 0000 0000 0000 0000 0000 1000
Il peut aussi être
(8) .Tostring (2); // "1000"
Le paramètre tostring est la base de conversion
(Ce qui suit est ce que j'ai essayé de convertir avec une autre cardinalité, et cela n'a rien à voir avec cet article)
(8) .Tostring (8); // "10"
(8) .Tostring (16); // "8"
Integer 1 est représenté comme un binaire 32 bits comme:
0000 0000 0000 0000 0000 0000 0000 0000 0001
Exécuter le bit ou
0000 0000 0000 0000 0000 0000 0000 1000
0000 0000 0000 0000 0000 0000 0000 0000 0001
--------------------------------------------------------------------------------------------------------------------------------
0000 0000 0000 0000 0000 0000 0000 1001
Il en va de même pour la vérification de la fonction de bibliothèque standard et utilise 2 comme cardinalité. Le 0 principal n'affecte pas le résultat de calcul, ce qui n'est pas nécessaire.
Parseint ('1001', 2) // 9
(Ce qui suit est ce que j'ai essayé de convertir avec une autre cardinalité, et cela n'a rien à voir avec cet article)
Parseint ('1001', 8) // 513
Parseint ('1001', 16) // 4097
Le processus de résumé de l'opération arithmétique consiste à convertir les opérandes en entiers, puis à utiliser le mode bit entier pour effectuer des opérations, et enfin de convertir le résultat en un numéro de point flottant JS standard.
Avertissement des nombres de points flottants: notoirement inexacts. Par exemple
0,1 + 0,2; //0.30000000000000000004
Raison: Bien que la précision des nombres à virgule flottante 64 bits soit déjà très élevée, les nombres à virgule flottante à double précision ne peuvent représenter qu'un ensemble fini de nombres, mais ne peuvent pas représenter tous les ensembles de nombres réels. Les opérations de points flottants ne peuvent produire que des résultats approximatifs, en arrondissant le nombre réel représentable le plus proche. Lorsque vous effectuez une série d'opérations, à mesure que l'erreur d'arrondi s'accumule, les résultats de l'opération deviendront moins précis. L'arrondi provoque également des écarts dans les lois des opérations arithmétiques. Par exemple, la loi du cautionnement. Pour tout nombre réel
x, y, z satisfaire toujours (x + y) + z = x + (y + z)
Les points flottants ne sont pas nécessairement:
(0,1 + 0,2) +0,3; //0.60000000000000000001
0,1+ (0,2 + 0,3); //0.6
Les numéros de points flottants pèsent la précision et les performances. Lorsque vous vous souciez de la précision, faites attention aux limites des nombres de points flottants.
La solution consiste à convertir les opérations de points flottants en opérations entières.
(10 + 20) +30; // 60
10+ (20 + 30); // 60
Divisez ensuite le facteur d'agrandissement. Notez que la plage entière doit être à -253 ~ 253.
Résumer
1. Les nombres de JS sont des numéros de points flottants à double précision
2. L'entier de JS n'est qu'un sous-ensemble de nombres à virgule flottante à double précision, pas un seul type
3. L'opération de bits traite les nombres comme des entiers signés de 32 bits
4. Méfiez-vous de la précision des opérations de points flottants
La compréhension approfondie de l'article ci-dessus des numéros de points flottants en JavaScript est tout le contenu que j'ai partagé avec vous. J'espère que cela pourra vous donner une référence et j'espère que vous pourrez soutenir Wulin.com plus.