JS solo tiene un tipo de datos numéricos. Ya sea un número entero o un número de punto flotante, JS lo clasifica como un número.
typeOf 17; // "número"
typeof 98.6; // "número"
typeof 2.1; // "número"
Todos los números en JS son números de punto flotante de doble precisión. Es un número codificado de 64 bits formulado por el estándar IEEE754 (qué es esto, no sé, solo búscalo y échale un vistazo)
Entonces, ¿cómo expresa JS Integers? Los números de punto flotante de doble precisión pueden representar perfectamente enteros con una precisión de hasta 53 bits (sin concepto, no he procesado demasiados datos, no he usado!), Y todos los enteros de -9007199254740992 (-253) a 9007199254740992 (253) son válidos números de punto de punto de precisión.
La mayoría de los operadores aritméticos se pueden calcular utilizando enteros, números reales o una combinación de ambos.
0.1*1.9 //0.19
-99+100 // 1
21-12.3 //8.7
2.5/5 //0.5
21%8 // 5
Los operadores aritméticos son bastante especiales. JS no calcula directamente los operandos como números de puntos flotantes, pero los convierte implícitamente en enteros de 32 bits para realizar operaciones. (Para ser precisos, se convertirá en un entero que represente 2 de 32 bits Big-endian (para ser sincero, realmente no sé lo que significa aquí, busque la ciencia popular)) Use expresiones de bit a bit o operaciones como
ejemplo:
8 | 1; // 9
Proceso de cálculo
En primer lugar, 8 y 1 son números de puntos flotantes de doble precisión. Pero también puede representarse como un entero de 32 bits, es decir, una representación binaria de 32 bits.
Integer 8 se representa como binario de 32 bits como:
0000 0000 0000 0000 0000 0000 0000 1000
También puede ser
(8) .tostring (2); // "1000"
La tostración de parámetros es la base de conversión
(Lo siguiente es lo que intenté convertir con otra cardinalidad, y no tiene nada que ver con este artículo)
(8) .tostring (8); // "10"
(8) .tostring (16); // "8"
El número entero 1 se representa como binario de 32 bits como:
0000 0000 0000 0000 0000 0000 0000 0000 0001
Ejecutar bit a bit o
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
Lo mismo utiliza la verificación de la función de biblioteca estándar, y usa 2 como cardinalidad. El 0 líder no afecta el resultado del cálculo, que es innecesario.
parseint ('1001', 2) // 9
(Lo siguiente es lo que intenté convertir con otra cardinalidad, y no tiene nada que ver con este artículo)
parseint ('1001', 8) // 513
parseint ('1001', 16) // 4097
El proceso de resumir la operación aritmética es convertir los operandos en enteros, luego usar el modo de bits enteros para realizar operaciones y finalmente convertir el resultado en un número de punto flotante JS estándar.
Advertencia de los números de puntos flotantes: notoriamente inexactos. Por ejemplo
0.1+0.2; //0.3000000000000000000004
Razón: aunque la precisión de los números de punto flotante de 64 bits ya es muy alta, los números de punto flotante de doble precisión solo pueden representar un conjunto finito de números, pero no puede representar todos los conjuntos de números reales. Las operaciones de puntos flotantes solo pueden producir resultados aproximados, redondeando al número real representable más cercano. Cuando realiza una serie de operaciones, a medida que se acumula el error de redondeo, los resultados de la operación serán menos precisos. El redondeo también causa algunas desviaciones en las leyes de las operaciones aritméticas. Por ejemplo, la ley de la vinculación. Para cualquier número real
x, y, z siempre satisfará (x+y)+z = x+(y+z)
Los puntos flotantes no son necesariamente:
(0.1+0.2) +0.3; //0.6000000000000000000001
0.1+ (0.2+0.3); //0.6
Los números de puntos flotantes pesan la precisión y el rendimiento. Cuando le importe la precisión, tenga cuidado con las limitaciones de los números de puntos flotantes.
La solución es convertir las operaciones del punto flotante en operaciones enteras.
(10+20) +30; // 60
10+ (20+30); // 60
Luego divida el factor de aumento. Tenga en cuenta que el rango entero debe estar dentro de -253 ~ 253.
Resumir
1. Los números de JS son números de punto flotante de doble precisión
2. El entero de JS es solo un subconjunto de números de punto flotante de doble precisión, ni un solo tipo
3. La operación de bit trata los números como enteros firmados de 32 bits
4. Tenga cuidado con la precisión de las operaciones de puntos flotantes
La comprensión en profundidad del artículo anterior de los números de puntos flotantes en JavaScript es todo el contenido que he compartido con usted. Espero que pueda darle una referencia y espero que pueda apoyar más a Wulin.com.