Sintaxis para crear un objeto número:
La copia del código es la siguiente:
var mynum = nuevo número (valor);
var mynum = número (valor);
Cuando el número () y el operador nuevo se usan juntos como constructores, devuelve un objeto de número recién creado. Si no usa el nuevo operador, llame al número () como una función, convertirá su propio parámetro en un valor primitivo y devolverá este valor (devuelve NAN si la conversión falla).
Max_value
La propiedad Max_Value es el número más grande que se puede representar en JavaScript. Su aproximación es 1.7976931348623157 x 10308. El número negativo más grande es -max_value.
Un número mayor que max_value es infinito. Max_Value es una propiedad estática, por lo que el método de llamada debe ser numinada.max_value.
La copia del código es la siguiente:
console.log (number.max_value) //1.7976931348623157e+308
Min_value
La propiedad min_value es el número más pequeño que puede representarse en JavaScript (casi 0, pero no negativo). Su aproximación es de 5 x 10-324.
Todos los números más pequeños que Min_Value se convertirán a 0.
Min_Value es una propiedad estática, por lo que el método de llamada debe ser numinada.min_value.
Yaya
El atributo NAN es un valor especial que representa un valor no numérico. Esta propiedad se utiliza para indicar que un valor no es un número. El objeto número se puede establecer en este valor para indicar que no es un valor numérico.
Puede usar la función global isnan () para determinar si un valor es un valor nan.
Number.nan es un valor especial que indica que el resultado de algunas operaciones aritméticas (como encontrar la raíz cuadrada de un número negativo) no es un número. Los métodos parseInt () y parsefloat () devuelven este valor cuando la cadena especificada no se puede analizar. Para algunas funciones que devuelven un número significativo en casos convencionales, este método también se puede usar, utilizando number.nan para ilustrar su situación de error.
Salidas de JavaScript Number.nan como nan. Tenga en cuenta que los resultados de comparar NAN con otros valores siempre son desiguales, incluido sí mismo. Por lo tanto, no se puede comparar con Number.nan para detectar si un valor es un número, pero solo se puede llamar isnan () para comparar.
NOTA: La variable global NAN es la misma que number.nan. NAN es una propiedad poco configial y no modificada.
La copia del código es la siguiente:
console.log (parseInt ("ABC")); //Yaya
console.log (nan === nan); //FALSO
console.log (number.nan === nan); //FALSO
console.log (isnan (nan)); //verdadero
console.log (isnan (number.nan)); //verdadero
Negativo_infinidad
El atributo negativo_infinity indica un valor inferior a -number.max_value. Este valor representa un infinito negativo.
JavaScript usa -infinity al mostrar negativo_infinity. El comportamiento aritmético de este valor es muy similar al infinito. Por ejemplo, el resultado de la multiplicación del infinito sigue siendo infinito, y el resultado de dividir el infinito por cualquier número es cero.
-Infinity y number.negative_infinity son iguales.
La copia del código es la siguiente:
var x = (-number.max_value) * 2;
var y = número.negative_infinity;
console.log (x); //-Infinidad
console.log (y); //-Infinidad
console.log (x === y); //verdadero
Positivo_infinidad
El atributo positivo_infinity indica un valor mayor que el número.max_value. Este valor representa un infinito positivo.
JavaScript usa Infinity cuando se muestra positivo_infinity. El comportamiento aritmético de este valor es muy similar al infinito. Por ejemplo, el resultado de la multiplicación del infinito sigue siendo infinito, y el resultado de dividir el infinito por cualquier número es cero.
Infinity y Number.Positive_Infinity son iguales.
El método isFinite () puede determinar si los parámetros son números finitos.
La copia del código es la siguiente:
var x = number.negative_infinity;
var y = number.positivo_infinity;
var z = infinito;
var a = "ABC";
var b = 123;
console.log (isfinite (x)); //FALSO
console.log (isfinite (y)); //FALSO
console.log (isfinite (z)); //FALSO
console.log (isfinite (a)); //FALSO
console.log (isfinite (b)); //verdadero
toString ()
El método toString () convierte un objeto número en una cadena y devuelve el resultado.
NumberObject.ToString (Radix)
El parámetro Radix es opcional. Especifique la cardinalidad del número, haciendo un entero entre 2 y 36. Si se omite este parámetro, use la cardinalidad 10. Se recomienda tomar siempre este parámetro para evitar malentendidos. Por ejemplo, cuando Radix es 2, NumberObject se convierte en una cadena representada por un valor binario.
Se lanza una excepción de typeError cuando el objeto que llama al método no es número.
La copia del código es la siguiente:
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
TOLOCALECRING ()
El método TOLOCALECRING () convierte un objeto número en una cadena en formato local.
La representación de la cadena de un número, determinada por la implementación, se formatea de acuerdo con las especificaciones locales, puede afectar los signos de puntuación utilizados por el punto decimal o el separador de milésimo participio.
Se lanza una excepción de typeError cuando el objeto que llama al método no es número.
La copia del código es la siguiente:
var a = 123456;
console.log (a.tolocaleString ()); // 123,456
console.log (a.tolocalEstring ("zh-hans-cn-u-nu-hanidec")); // uno, dos, tres, cuatro, cinco, seis
Para obtener más parámetros, consulte: MDN
tofixed ()
El método tofixed () redondea un número con un número decimal especificado.
NumberObject.tofixed (num)
Se requiere el num de parámetro. El número de dígitos especificados en el decimal es un valor entre 0 y 20, incluidos 0 y 20, y algunas implementaciones pueden admitir un mayor rango de valores. Si se omite este parámetro, se reemplazará 0.
Devuelve la representación de cadena de NumberObject, sin un conteo exponencial, hay dígitos NUM fijos después del punto decimal. Si es necesario, el número se redondeará y también se puede llenar con 0 para que alcance la longitud especificada. Si NUM es mayor que LE+21, el método solo llama a NumberObject.ToString () y devuelve una cadena representada por conteo exponencial.
Se lanza una excepción de RangeError cuando el NUM es demasiado pequeño o demasiado grande. Los valores entre 0 y 20 no aumentarán esta excepción. Algunas implementaciones admiten valores en un rango más grande o más pequeño. Se lanza una excepción de typeError cuando el objeto que llama al método no es número.
La copia del código es la siguiente:
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)); // 123000000000000000000000000000000000000000000000000000000000000000000000
console.log ((1.23e-10) .tofixed (2)); //0.00
Nota: Debido al procesamiento de los números de puntos flotantes, el resultado mostrado por el método tofixed () no es el llamado "redondeo" o "redondeando seis en cinco dobles", sino el rendimiento de redondear cuatro, seis en cinco y cinco es muy confuso.
La copia del código es la siguiente:
// en Chrome
console.log ((0.035) .tofijo (2)); //0.04
console.log ((0.045) .tofijo (2)); //0.04
Se recomienda escribir su propio método para reemplazar el comportamiento predeterminado de ToFixed (). Puede referirse a la discusión sobre So:
La copia del código es la siguiente:
Número.prototype.tofixed = function (len) {
var temp = Math.Pow (10, len);
var s = math.ceil (esta * temp)
return s/temp;
}
console.log ((0.035) .tofijo (2)); //0.04
console.log ((0.045) .tofijo (2)); //0.05
ToExponential ()
El método ToExPonential () convierte el valor de un objeto en un método de conteo exponencial.
NumberObject.ToExPonential (NUM)
El parámetro num es opcional. El número de lugares decimales en el método de conteo exponencial es un valor entre 0 y 20, incluidos 0 y 20, y algunas implementaciones pueden soportar un rango de valores más amplio. Si se omite este parámetro, se utilizarán tantos números como sea posible.
Devuelve la representación de cadena de NumberObject, utilizando el método de conteo exponencial, es decir, hay un dígito antes del punto decimal y el dígito NUM después del punto decimal. La parte decimal del número se redondeará y se llenará con 0 si es necesario para que alcance la longitud especificada.
Se lanza una excepción de RangeError cuando el NUM es demasiado pequeño o demasiado grande. Los valores entre 0 y 20 no aumentarán esta excepción. Algunas implementaciones admiten valores en un rango más grande o más pequeño. Se lanza una excepción de typeError cuando el objeto que llama al método no es número.
La copia del código es la siguiente:
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 ()
El método Toprecision () formatea el valor en una cadena en forma de un número decimal.
NumberObject.TopRecision (NUM)
El parámetro num es opcional. Utilizado para controlar la precisión de los números. Este parámetro es un valor entre 1 y 21 (e incluye 1 e 21). Si se omite este parámetro, el método toString () se llama en lugar de convertir el número a un valor decimal.
La copia del código es la siguiente:
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