Representación de números

Nueva notación para números binarios: prefijo 0b o 0B.

console.log(0b11 === 3); // true
console.log(0B11 === 3); // true

Nueva notación para números octales: prefijo 0o o 0O.

console.log(0o11 === 9); // true
console.log(0O11 === 9); // true

Constantes

Number.EPSILON

La propiedad Number.EPSILON representa la diferencia entre 1 y el número de coma flotante más pequeño mayor que 1.

Su valor es aproximadamente 2.2204460492503130808472633361816E-16, o 2-52.

Probar si un número está dentro del margen de error:

0.1 + 0.2 === 0.3; // false
// 在误差范围内即视为相等
equal = (Math.abs(0.1 - 0.3 + 0.2) < Number.EPSILON); // true

Atributos de propiedad

writable：false
enumerable：false
configurable：false

Enteros seguros máximo/mínimo

Entero seguro

Los enteros seguros son enteros que se pueden representar con precisión en JavaScript. El rango de enteros seguros está entre 2 elevado a -53 y 2 elevado a 53 (excluyendo ambos extremos). Los enteros fuera de este rango no se pueden representar con precisión.

Entero seguro máximo

El límite superior del rango de enteros seguros, es decir, 2 elevado a 53 menos 1.

Number.MAX_SAFE_INTEGER + 1 === Number.MAX_SAFE_INTEGER + 2; // true Number.MAX_SAFE_INTEGER === Number.MAX_SAFE_INTEGER + 1; // false Number.MAX_SAFE_INTEGER - 1 === Number.MAX_SAFE_INTEGER - 2; // false

Entero seguro mínimo

El límite inferior del rango de enteros seguros, es decir, el negativo de 2 elevado a 53 menos 1.

Number.MIN_SAFE_INTEGER + 1 === Number.MIN_SAFE_INTEGER + 2; // false Number.MIN_SAFE_INTEGER === Number.MIN_SAFE_INTEGER - 1; // false Number.MIN_SAFE_INTEGER - 1 === Number.MIN_SAFE_INTEGER - 2; // true

Atributos de propiedad

writable：false
enumerable：false
configurable：false

Métodos

Nuevos métodos del objeto Number

Number.isFinite()

Se utiliza para comprobar si un número es finito (finite), es decir, no es Infinity.

console.log( Number.isFinite(1)); // true console.log( Number.isFinite(0.1)); // true //NaN no es finito. console.log( Number.isFinite(NaN)); // false console.log( Number.isFinite(Infinity)); // false console.log( Number.isFinite(-Infinity)); // false //Number.isFinate no realiza conversión de tipo implícita con Number(), todos los valores no numéricos devuelven false. console.log( Number.isFinite('foo')); // false console.log( Number.isFinite('15')); // false console.log( Number.isFinite(true)); // false Number.isNaN()Se utiliza para comprobar si un valor esNaN 。 console.log(Number.isNaN(NaN)); // true console.log(Number.isNaN('true'/0)); // true //En la función global isNaN(), todo lo siguiente devuelve true, porque los valores no numéricos se convierten a números antes de la evaluación. //Mientras que Number.isNaN() no tiene conversión de tipo implícita con Number(), todos los que no son NaN devuelven false. Number.isNaN("NaN"); // false Number.isNaN(undefined); // false Number.isNaN({}); // false Number.isNaN("true"); // false

Métodos trasladados del ámbito global al objeto Number

Reducir gradualmente los métodos globales, para la modularización de las variables globales.

El comportamiento de los métodos no ha cambiado.

Number.parseInt()

Se utiliza para convertir la cadena dada en un entero de la base especificada.

//Cuando no se especifica la base, el valor predeterminado es base 10. Number.parseInt('12.34'); // 12 Number.parseInt(12.34); // 12 //Especificar la base Number.parseInt('0011',2); // 3 //Es la misma función que la función global parseInt(). Number.parseInt === parseInt; // true Number.parseFloat()Se utiliza para analizar una cadena como un número de coma flotante.Number.parseFloat('123.45') // 123.45 Number.parseFloat('123.45abc') // 123.45 //Si no se puede analizar como número de coma flotante, devuelve NaN. Number.parseFloat('abc') // NaN //Es el mismo método que el método global parseFloat(). Number.parseFloat === parseFloat // true Number.isInteger()Se utiliza para determinar si el parámetro dado es un entero.Number.isInteger(value) Number.isInteger(0); // true //Internamente, JavaScript utiliza el mismo método de almacenamiento para enteros y números de coma flotante, por lo tanto 1 y 1.0 se consideran el mismo valor. Number.isInteger(1); // true Number.isInteger(1.0); // true Number.isInteger(1.1); // false Number.isInteger(Math.PI); // false //NaN y los Infinity positivo y negativo no son enteros. Number.isInteger(NaN); // false Number.isInteger(Infinity); // false Number.isInteger(-Infinity); // false Number.isInteger("10"); // false Number.isInteger(true); // false Number.isInteger(false); // false Number.isInteger([1]); // false //Cuando la precisión de un número supera los 53 bits binarios, se produce un juicio erróneo porque los bits desde el 54 en adelante se descartan. Number.isInteger(1.0000000000000001) // true //Cuando el valor absoluto de un número es menor que Number.MIN_VALUE (5E-324), es decir, menor que lo que JavaScript puede distinguir, //el valor mínimo, se convierte automáticamente a 0, lo que también produce un juicio erróneo. Number.isInteger(5E-324); // false Number.isInteger(5E-325); // true Number.isSafeInteger()Se utiliza para determinar si un número está dentro del rango seguro.Number.isSafeInteger(Number.MIN_SAFE_INTEGER - 1); // false Number.isSafeInteger(Number.MAX_SAFE_INTEGER + 1); // false

Extensiones del objeto Math

ES6 añadió 17 métodos estáticos relacionados con las matemáticas al objeto Math; estos métodos solo se pueden invocar en Math.

Cálculo general

Math.cbrt

Se utiliza para calcular la raíz cúbica de un número.

Math.cbrt(1); // 1 Math.cbrt(0); // 0 Math.cbrt(-1); // -1 //Se realiza una conversión para valores no numéricos. Math.cbrt('1'); // 1 //Si no es un número y no se puede convertir a número, devuelve NaN. Math.cbrt('hhh'); // NaN
Math.imul

El resultado de multiplicar dos números como enteros con signo de 32 bits; el valor devuelto también es un entero con signo de 32 bits.

//En la mayoría de los casos, el resultado es el mismo que a * b. Math.imul(1, 2); // 2 //Se utiliza para devolver correctamente el valor de los bits bajos del resultado de la multiplicación de números grandes. Math.imul(0x7fffffff, 0x7fffffff); // 1
Math.hypot

Se utiliza para calcular la raíz cuadrada de la suma de los cuadrados de todos los parámetros.

Math.hypot(3, 4); // 5 //Los valores no numéricos se convierten primero a números y luego se calcula. Math.hypot(1, 2, '3'); // 3.741657386773941 Math.hypot(true); // 1 Math.hypot(false); // 0 //Los valores nulos se convierten a 0. Math.hypot(); // 0 Math.hypot([]); // 0 //Si el parámetro es Infinity o -Infinity, devuelve Infinity. Math.hypot(Infinity); // Infinity Math.hypot(-Infinity); // Infinity //Si alguno de los parámetros no se puede convertir a número, devuelve NaN. Math.hypot(NaN); // NaN Math.hypot(3, 4, 'foo'); // NaN Math.hypot({}); // NaN
Math.clz32

Se utiliza para devolver el número de ceros a la izquierda en la forma de entero sin signo de 32 bits de un número.

Math.clz32(0); // 32 Math.clz32(1); // 31 Math.clz32(0b01000000000100000000000000000000); // 1 //Cuando el parámetro es decimal, solo se considera la parte entera. Math.clz32(0.5); // 32 //Para valores nulos o no numéricos, se convierten a números y luego se calcula. Math.clz32('1'); // 31 Math.clz32(); // 32 Math.clz32([]); // 32 Math.clz32({}); // 32 Math.clz32(NaN); // 32 Math.clz32(Infinity); // 32 Math.clz32(-Infinity); // 32 Math.clz32(undefined); // 32 Math.clz32('hhh'); // 32

Procesamiento de números

Math.trunc

Se utiliza para devolver la parte entera de un número.

Math.trunc(12.3); // 12 Math.trunc(12); // 12 //Cuando la parte entera es 0, también se evalúa el signo. Math.trunc(-0.5); // -0 Math.trunc(0.5); // 0 //Math.trunc convierte los valores no numéricos a números antes de procesarlos. Math.trunc("12.3"); // 12 //Cuando es un valor nulo o no se puede convertir a número, devuelve NaN. Math.trunc(); // NaN Math.trunc(NaN); // NaN Math.trunc("hhh"); // NaN Math.trunc("123.2hhh"); // NaN
Math.fround

Se utiliza para obtener la forma de número de coma flotante de precisión simple de 32 bits de un número.

//Para enteros entre el negativo de 2 elevado a 24 y 2 elevado a 24 (excluyendo ambos extremos), el resultado devuelto es igual al propio parámetro. Math.fround(-(2**24)+1); // -16777215 Math.fround(2 ** 24 - 1); // 16777215 //Se utiliza para convertir un número de coma flotante de doble precisión de 64 bits a un número de coma flotante de precisión simple de 32 bits. Math.fround(1.234) // 1.125 //Cuando la precisión de un decimal supera los 24 bits binarios, se pierde precisión. Math.fround(0.3); // 0.30000001192092896 //Cuando el parámetro es NaN o Infinity, devuelve el mismo valor. Math.fround(NaN) // NaN Math.fround(Infinity) // Infinity //Cuando el parámetro es de otro tipo no numérico, se realiza una conversión del parámetro. Math.fround('5'); // 5 Math.fround(true); // 1 Math.fround(null); // 0 Math.fround([]); // 0 Math.fround({}); // NaN

Comprobación

Math.sign

Determina el signo de un número (positivo, negativo, 0).

Math.sign(1); // 1 Math.sign(-1); // -1 //Cuando el parámetro es 0, el valor devuelto es diferente según el signo. Math.sign(0); // 0 Math.sign(-0); // -0 //Antes de la evaluación, se convierten los valores no numéricos. Math.sign('1'); // 1 Math.sign('-1'); // -1 //Cuando el parámetro no es un número (y no se puede convertir a número), devuelve NaN. Math.sign(NaN); // NaN Math.sign('hhh'); // NaN

Métodos de logaritmos

Math.expm1()

Se utiliza para calcular el resultado de e elevado a x menos 1, es decir, Math.exp(x) - 1.

Math.expm1(1); // 1.718281828459045 Math.expm1(0); // 0 Math.expm1(-1); // -0.6321205588285577 //Se realizará una conversión de valores no numéricos. Math.expm1('0'); //0 //Si el parámetro no es un número y no se puede convertir a número, devuelve NaN. Math.expm1(NaN); // NaN
Math.log1p(x)

Se utiliza para calcular el logaritmo natural de 1 + x, es decir, Math.log(1 + x).

Math.log1p(1); // 0.6931471805599453 Math.log1p(0); // 0 Math.log1p(-1); // -Infinity //Cuando el parámetro es menor que -1, devuelve NaN. Math.log1p(-2); // NaN
Math.log10(x)

Se utiliza para calcular el logaritmo en base 10 de x.

Math.log10(1); // 0 //Convierte los valores no numéricos antes del cálculo. Math.log10('1'); // 0 //Cuando el parámetro es 0, devuelve -Infinity. Math.log10(0); // -Infinity //Cuando el parámetro es menor que 0 o no es un número (y no se puede convertir a número), devuelve NaN. Math.log10(-1); // NaN
Math.log2()

Se utiliza para calcular el logaritmo en base 2 de x.

Math.log2(1); // 0 //Convierte los valores no numéricos antes del cálculo. Math.log2('1'); // 0 //Cuando el parámetro es 0, devuelve -Infinity. Math.log2(0); // -Infinity //Cuando el parámetro es menor que 0 o no es un número (y no se puede convertir a número), devuelve NaN. Math.log2(-1); // NaN

Métodos de funciones hiperbólicas

  • Math.sinh(x): se utiliza para calcular el seno hiperbólico.
  • Math.cosh(x): se utiliza para calcular el coseno hiperbólico.
  • Math.tanh(x): se utiliza para calcular la tangente hiperbólica.
  • Math.asinh(x): se utiliza para calcular el arcoseno hiperbólico.
  • Math.acosh(x): se utiliza para calcular el arcocoseno hiperbólico.
  • Math.atanh(x): se utiliza para calcular la arcotangente hiperbólica.

Operador de exponenciación

1 ** 2; // 1 //Asociativo a la derecha, se calcula de derecha a izquierda. 2 ** 2 ** 3; // 256 // **= let exam = 2; exam ** = 2; // 4