Métodos redondeando números en JavaScript. Reglas simples de redondeo en JavaScript. Estudiamos los métodos y aplicamos en la práctica ParsFloat JavaScript 2 signo decimal

JavaScript-Mathematics, redondeando hasta dos lugares decimales (9)

Tengo la siguiente sintaxis de JavaScript:

Var descuento \u003d matemath.round (100 - (Precio / List Pprice) * 100);

Esto se redondea a un entero. ¿Cómo puedo devolver el resultado con dos signos decimales?

Aquí hay un ejemplo de trabajo.

Var valor \u003d 200.2365455; Resultado \u003d matemáticas (valor * 100) / 100/100 // resultado será 200.24

Para procesar el redondeo a cualquier número de lugares decimales para la mayoría de las necesidades, habrá función suficiente con 2 líneas de código. Aquí hay un código de ejemplo para el juego.

Var testnum \u003d 134.9567654; Var decl \u003d 2; var testres \u003d ROUNDDEC (Testnum, Decpl); Alerta (Testnum + "redondeada a" + Decpl + "Los lugares decimales es" + TESTRES); Función ROUNDDEC (NBR, Dec_places) (VAR MULT \u003d MATH MATH.POW (10, Dec_places); devuelva matemath.round (NBR * MULT) / MULT;)

La mejor y la simple solución que encontré es

Función redonda (número de retorno (matemáticas (valor (valor + e "+ decimales) +" e - "+ decimales);) redondo (1.005, 2); // 1.01

Pequeña variación de la respuesta aceptada. Tofixed (2) Devuelve la cadena, y siempre obtendrá dos signos decimales. Puede ser cero. Si desea suprimir el (los) cero (s) final (s), solo hágalo:

Var descuento \u003d + ((Precio / List Pprice) .tofixed (2));

Editado: Acabo de encontrar que parece un error en Firefox 35.0.1, lo que significa que lo anterior puede dar algunos valores a NAN.
Cambié mi código en

Var descuento \u003d matemath.round (precio / listprice * 100) / 100;

Esto le da un número con una precisión de dos lugares decimales. Si necesita tres, multiplicará y dividirá 1000, y así sucesivamente.
OP quiere que siempre hay dos descargas decimales, pero si se rompe () se rompe en Firefox, primero debe solucionarlo.
Consulte https://bugzilla.mozilla.org/show_bug.cgi?id\u003d1134388.

Para obtener un resultado con dos signos decimales, puede hacer lo siguiente:

Var descuento \u003d math.round ((100 - (Precio / List Pprice) * 100) * 100) / 100;

El valor que debe redondearse se multiplica por 100 para guardar los dos primeros dígitos, luego dividimos a 100 para obtener el resultado real.

Creo que la mejor manera en que vi se multiplica por 10 por número de números, entonces haz matemáticas. Y finalmente divide 10 por número de números. Aquí hay una función simple que yo uso en textos escritos a máquina:

Función RoundtoxDIGITS (valor: número, dígitos: número) (valor \u003d valor * matemath.pow (10, dígitos); valor \u003d matemath.round (valor); valor \u003d valor / matemath.pow (10, dígitos); valor de retorno; )

O JavaScript simple:

Función redondexdigits (valor, dígitos) (si (! Dígitos) (dígitos \u003d 2;) valor \u003d valor * matemath.pow (10, dígitos); valor \u003d matemath.round (valor); valor \u003d valor / matemath.pow (10 , dígitos); valor de retorno;)

NOTA. - Ver Edición 4 Si la precisión de 3 dígitos es importante.

Var descuento \u003d (precio / aprendizaje) .tofixed (2);

tofixed se redondea hacia arriba o hacia abajo para usted, dependiendo de los valores que excedan los 2 signos decimales.

Cambio. Como lo mencionó, convierte el resultado en la cadena. Para evitar esto:

Var descuento \u003d + ((Precio / List Pprice) .tofixed (2));

Edición 2. - Como se mencionó en los comentarios, esta función no se realiza con cierta precisión, por ejemplo, en el caso de 1.005, devolverá 1.00 en lugar de 1.01. Si la precisión es importante para tal punto, encontré esta respuesta: https: //.com/a/32605063/1726511 Lo que parece funcionar bien con todas las pruebas que probé.

Una modificación menor requiere, pero la respuesta indicada anteriormente devuelve enteros cuando se redondea a uno, por lo tanto, por ejemplo, 99.004 devolverá 99 en lugar de 99.00, que no es perfecto para la visualización de precios.

Editar 3. - Parece que tocó el retorno real de algunos números todavía torcidos, es la edición final parece funcionar. ¡GEEZ TAN MUCHAS REPARACIONES!

Var descuento \u003d redondeo ((precio / aprendizaje), 2); Función RoundTo (n, dígitos) (si (dígitos \u003d\u003d\u003d indefinidos) (dígitos \u003d 0;) var multiplicador \u003d matemath.pow (10, dígitos); n \u003d parsefloat ((n * multiplicador) .tofixed (11)); var prueba \u003d (matemáticas (n) / multiplicador); devuelva + (test.tofixed (dígitos));)

Editar 4. "Ustedes me matan". La edición 3 falla en números negativos, sin excavar por qué es más fácil simplemente hacer un número negativo positivo antes de hacerlo redondeo, y luego devolverlo antes de devolver el resultado.

Función RoundTo (n, dígitos) (var negativo \u003d falso; si (dígitos \u003d\u003d\u003d indefinido) (dígitos \u003d 0;) si (n< 0) { negative = true; n = n * -1; } var multiplicator = Math.pow(10, digits); n = parseFloat((n * multiplicator).toFixed(11)); n = (Math.round(n) / multiplicator).toFixed(2); if(negative) { n = (n * -1).toFixed(2); } return n; }

La vía más rápida - Más rápido que Tofixed ():

Dos descaliles

x \u003d .123456 Resultado \u003d matemath.round (x * 100) / 100 / ed resultado .12

Tres decimalidades

x \u003d .123456 Resultado \u003d matemath.round (x * 1000) / 1000 // Resultado .123

Función redonda (NUM, DEC) (Num \u003d Math.Round (NUM + E "+ DIC) Número de retorno (NUM +" E - "+ DEC)) // Redondea a un decimal de su elección: Ronda (1.3453.2)

En este artículo, considere en detalle los números, los operadores matemáticos, los métodos de transformación del número en la cadena y viceversa, así como muchos otros puntos importantes.

Función isfinita

La función ISFINITE le permite verificar si el argumento es un número finito.

Como respuesta, esta función devuelve False si el argumento es infinito, -Infinity, NAN o se mostrará a uno de estos valores numéricos especiales. De lo contrario, esta función devolverá el valor de VERDADERO.

Isfinite (73); // VERDADERO ISFINITE (-1/0); // False isfinite (infinito); // FALSO ISFINITE (NAN); // falso isfinite ("texto"); // Falso

Además de la función global isfinite en JavaScript, hay otro método número. En contraste con Isfinite, no realiza un argumento forzado al número.

Isfinita ("73"); // true number.isfinite ("73"); // Falso

Característica de isnan

La función ISNAN está diseñada para determinar si el argumento es un número o se puede transformar. Si es así, la función ISNAN devuelve False. De lo contrario, devuelve VERDADERO.

Isnan (nan); // True Isnan ("25px"); // verdadero, porque 20px no es un número ISNAN (25.5); // False Isnan ("25.5"); // falso isnan (""); // falso, porque El espacio o no solo los espacios se convierten en 0 isnan (nulo); // falso, porque El valor nulo se convierte en 0 isnan (verdadero); // falso, porque El verdadero valor se convierte en 1 isnan (falso); // falso, porque El valor falso se convierte en 0

Si esta acción debe hacerse sin traer el tipo, luego use el método número.isnan. Este método se introdujo en el idioma, comenzando con ECMASCRIP 6.

¿Cómo convertir explícitamente una fila al número?

Es claramente traído por una fila al número por las siguientes maneras:

1. usar operador unario +.que debe colocarse antes del valor.

+ "7.35"; // 7.35 + "texto"; // nan.

Este método descuida los espacios al principio y al final de la cadena, así como \\ N (traducción de fila).

+ "7.35"; //7.35 + "7.35 \\ n"; //7.35

Usando este método, es necesario prestar atención al hecho de que una cadena vacía o una cadena que consiste en espacios y \\ n se traduce en el número 0. Además, también convierte el tipo de datos nulo y los valores lógicos a la número.

Nulo; // 0 + verdadero; // 1 + falso; // 0 + ""; // 0.

2. Función del parseint. Esta característica está destinada a la conversión. argumento para un entero. En contraste con el uso operador unario +.Este método le permite convertir una cadena a un número en el que no todos los personajes son digitales.. Comienza a convertir la cadena a partir del primer símbolo. Y tan pronto como se encuentra con un símbolo que no es digital, esta función detiene su funcionamiento y devuelve el número resultante.

Parseint ("18px"); // 18 parseint ("33.3%"); // 33.

Esta característica puede funcionar con diferentes sistemas numéricos (binario, octal, decimal, hexadecimal). NOTA La base del sistema numérico se realiza mediante 2 argumentos.

Parseint ("18px", 10); // 18 parseint ("33.3%", 10); // 33 parseint ("101", 2); // 5 parseint ("B5", 16); // 181.

Además de la función Parsint en JavaScript, hay un método de número. Este método no es diferente de la función Parsint y se introdujo en JavaScript con la especificación de ECMASCRIP 2015 (6).

3. Función de parsefloat. La característica de ParsFloat es similar al parseint, excepto la transformación del argumento al número fraccionado.

Parsefloat ("33.3%"); //33.3.

Además, la característica de ParsFloat, a diferencia de Parsint, no tiene 2 argumentos, y por lo tanto, siempre intenta considerar la cadena como un número en el sistema de números decimales.

Parsefloat ("3.14"); Parsefloat ("314E-2"); Parsefloat ("0.0314e + 2");

Además de la función ParsFloat en JavaScript, hay un método de número de pareja. Este método no es diferente de la función de Parsifloat y se introdujo en JavaScript con la especificación de ECMASCRIP 2015 (6).

Transformación del número en la cadena.

Puede girar el número en la cadena con el método TSIRTING.

(12.8) .Tostrando (); //"12.8 "

El método TOSTRING también le permite especificar la base del sistema numérico con el que es necesario llevar explícitamente el número a la fila:

(255) .Tostrando (16); // "ff"

Cómo comprobar si un número variable

Para determinar si la variable de valor puede ser variable utilizando uno de los siguientes métodos:

1. Utilizando funciones ISNAN y ISFINITE:

// myvar - variable si (! Isnan (ParsFloat (Myvar)) && isfinite (ParsFloat (MyVAR)) (// Myvar es un número o se puede dar);

En forma de una función:

// función isnumeric (devolución! Isnan (ParsFloat (Value)) && isfinite (Pursfloat (Value));) // usando var myvar \u003d "12px"; Console.log (isnumérico (myvar)); // Cierto.

Este método le permite determinar si el valor especificado está o se puede administrar. Esta opción no considera una cadena vacía, una cadena de espacios, un valor nulo, infinito, -infinity, verdadero y falso.

2. Usando el tipo de operador de OPERADOR y FUNCIONES ISFINITE, ISNAN:

// una función que comprueba si el valor es el número de funciones enumerar enumerar (valor) (Volver al tipo de valor \u003d\u003d\u003d "(! Lang: Número" && isFinite(value) && !isNaN(value); }; // использование функции isNumber isNumber(18); //true // использование функций для проверки текстовых значений isNumber(parseFloat("")); //false isNumber(parseFloat("Infinity")); //false isNumber(parseFloat("12px")); //true !}

Esta función determina si el valor especificado es el tipo de número, y si no pertenece a uno de los valores especiales infinito, -infinity y nan. Esley es así, entonces esta función devuelve verdadera.

3. Usando el método de ECMAScript 6 número.isinteger (valor). Este método le permite determinar si el valor especificado es un entero.

Número.isinteger ("20"); // falso, porque Este método no traduce la cadena a la cantidad de número .isinteger (20); // verdadero, porque Este valor es el número.

Números pares y impares

Compruebe si el número se usa o extraño por las siguientes funciones:

// Función para verificar el número a la función de lectura ISEEGE (N) (return n% 2 \u003d\u003d 0;) / Función para verificar el número a la función de enfermedad ISODD (N) (devolver matemath.abs (n% 2) \u003d\u003d 1;)

Pero antes de realizar dicho cheque, es recomendable asegurarse de que el valor especificado sea el número:

Valor \u003d 20; If (Number.isinteger (valor)) (si (ISEVEN (valor)) (Console.log ("Número" + Valor.Tostring () + "- delgado"))))

Números simples en JavaScript

Considere un ejemplo en el que se eliminan los números simples de 2 a 100 con JavaScript.

// Función que comprueba si el número es de función simple ISPRIME (valor) (IF (ISNAN (valor) || ISFINITE (valor) || Valor% 1 || Valor< 2) return false; var max=Math.floor(Math.sqrt(value)); for (var i = 2; i< = max; i++) { if (value%i==0) { return false; } } return true; } // создать массив, который будет содержать простые числа от 2 до 100 var primaryNumber = ; for (var i = 2; i <= 100; i++) { if(isPrime(i)) primaryNumber.push(i); } // вывести в консоль простые числа от 2 до 100 console.log(primaryNumber);

Número de redondeo en JavaScript

Redondear un número fraccional a todo el valor en JavaScript de varias maneras.

1. Utilizando MathS.Floor, Math.Ceil y Math. Métodos Sround diseñados específicamente para esto. Método de matemáticas. Método de flores redondea el número fraccional al entero más cercano, es decir, Simplemente deseche la parte fraccionada. Math.Ceil reduce un número fraccional al todo más cercano. Math.round redondea el número hacia arriba o hacia abajo dependiendo del valor de la parte fraccionaria. Si la parte fraccionaria es mayor o igual a 0.5, luego, luego, se lleva a cabo ajustes.

Console.log (matematica.floor (7.9)); // 7 console.log (math.ceil (7.2)); // 8 console.log (math.round (7.5)); //ocho

2. Usando el método tofizzado. Este método redondea la parte fraccionaria del número a una precisión dada. El resultado del redondeo vuelve como una cadena.

Console.log (7.987.tofixed (2)); //"7.99 "

Si los signos después de la coma para la formación de la precisión especificada del número carecen, se complementa con ceros.

Console.log (7.987.tofixed (5)); //"7.98700 "

3. A través del método TOPRECISIONE. Este método representa un número con la precisión indicada. Al mismo tiempo, puede redondearse no solo fraccional, sino también una parte entera del número. El número obtenido, este método se puede representar dependiendo del resultado con una coma fija o en forma exponencial.

Console.log ((1001) .toprecision (2)); //"1.0e+3 "console.log ((1001) .toprecision (5)); //"1001.0 "console.log ((12.4) .toprecision (1)); // "1e + 1" console.log ((12.4) .toprecision (2)); // "12" console.log ((12.4) .toprecision (3)); //"12.4 "console.log ((12.4) .toprecision (5)); // "12,400"

4. Uso de operadores lógicos no o o o o.

// por Doubical Denial Console.log (~~ 7.9); // 7 // a través del uso de lógico o con cero: console.log (7.9 ^ 0); // 7.

Parte entera y fraccionada del número.

Puede obtener una parte entera del número usando el método Math.floor () y Parsint ():

Console.log (matematica.floor (7.21)); // 7 console.log (Parsint (7.21)); // 7.

Puede obtener una parte fraccionada del número que puede usar el operador porcentual (%). Este operador devuelve el residuo que se obtendrá dividiendo el primer número al segundo. En este caso, es necesario usar 1 como 2 números.

Console.log (7,21% 1); // 0.20999999999999996 // con una precisión de 2 caracteres después de la consola de punto y comodidad ((7,21% 1) .tofixed (2)); // "0.21"

Además, la parte fraccionaria también se puede obtener mediante la computación:

Número VAR \u003d 7.21; var fractionnumber \u003d number - math.floor (math.abs (número)); Console.log (fractor number); // 0.20999999999999996.

Si el número está dividido por

Para determinar si se puede encontrar el número de objetivos utilizando el porcentaje del operador:

Número VAR \u003d 9; // Si el residuo de la división del número de número 3 es 0, entonces sí, de lo contrario, no hay si (número% 3 \u003d\u003d 0) (Console.log ("Número" + número + "se divide en 3" );) Otra cosa (consola. Registro ("el número" + número + "no se divide en 3");)

Números de formato

En JavaScript, formatee la salida de salida de acuerdo con las normas regionales (Configuración de idioma del sistema operativo) permite el método TOLOCALESTRING ().

Por ejemplo, realice el formato del número de acuerdo con las normas regionales que se instalan en el sistema predeterminado:

Número VAR \u003d 345.46; Console.log (número.tolocalstring ()); // "345.46"

Por ejemplo, realizaremos el formato del número de acuerdo con las normas regionales de Rusia (RU):

Console.log ((108.1) .tolocalessring ("ru-ru")); // "108.1"

Este método también se puede utilizar para formatear un número en forma de moneda:

Console.log ((2540.125) .TOLOCALESTRING ("RU-RU", (Estilo: "Moneda", Moneda: "RUB")); // "2 540,13 ₽" console.log ((89.3) .tolocalesstring ("ru-ru", (estilo: "moneda", moneda: "USD"))); // "$ 89.30" console.log ((2301.99) .tolocalessring ("ru-ru", (estilo: "moneda", moneda: "EUR")); // "2 301,99 €"

Pose de interés en forma de interés:

Console.log ((0.45) .tolocalessring ("ru-ru", (estilo: "porcentaje"))); // "45%"

Borre el número en la descarga (inmobiliaria de sujeción):

Console.log ((125452.32) .tolocalessring ("ru-ru", (Uso de grupo: verdadero))); // "125 452,32"

Pantalla con un cierto número de dígitos (2) después de la coma:

Console.log ((1240.4564) .tolocalessring ("ru-ru", (mínimo fracción de datos: 2, maximicefractiondigits: 2)); // "1 240.46"

Comparación de números

Para comparar los números en JavaScript, se utilizan los siguientes operadores: \u003d\u003d (igual),! \u003d (No igual),\u003e (más),< (меньше), >\u003d (más o igual),<= (меньше или равно).

Por ejemplo, comparamos dos números:

Console.log (2\u003e 3); // Falso Console.log (5\u003e \u003d 3); // Cierto.

Al comparar los números con una parte fraccionaria, es necesario considerar los errores que pueden ocurrir durante estos cálculos.

Por ejemplo, en JavaScript, la suma de números (0.2 + 0.4) no es igual a 0.6:

Console.log ((0.2 + 0.4) \u003d\u003d 0.6); // Falso

Los errores se producen porque todos los cálculos de la computadora u otro dispositivo electrónico producen en 2 números del sistema. Esos. Antes de realizar algunas acciones, la computadora primero debe convertir el número en la expresión en 2 del sistema numérico. Pero, no se puede representar ningún número decimal fraccional en 2 sistemas de números con seguridad.

Por ejemplo, el número 0.25 10 al sistema binario se convierte con precisión.

0.125 × 2 \u003d 0.25 | 0 0.25 × 2 \u003d 0.5 | 0 0.5 × 2 \u003d 1 | 1 0.125 10 \u003d 0.001 2

Por ejemplo, el número 0.2 10 se puede convertir a 2 sistemas solo con una precisión definitiva:

0.2 × 2 \u003d 0.4 | 0 0.4 × 2 \u003d 0.8 | 0 0.8 × 2 \u003d 1.6 | 1 0.6 × 2 \u003d 1.2 | 1 0.2 × 2 \u003d 0.4 | 0 0.4 × 2 \u003d 0.8 | 0 0.8 × 2 \u003d 1.6 | 1 0.6 × 2 \u003d 1.2 | 1 0.2 × 2 \u003d 0.4 | 0 0.4 × 2 \u003d 0.8 | 0 0.8 × 2 \u003d 1.6 | 1 0.6 × 2 \u003d 1.2 | 1 ... 0.2 10 \u003d 0.001100110011 ... 2

Como resultado, estos errores afectarán el cálculo de la suma de dos números y resultados de comparación. Esos. Resulta que en realidad JavaScript se verá esta entrada de la siguiente manera:

0.6000000000000001==0.6

Al calcular o asignar números con una parte fraccionaria, siempre debe indicar la precisión con la que debe hacerse.

Por ejemplo, comparar números hasta 2 puntos decimales usando métodos tofixed () y TOPRECISION ():

// Tofixed () Método Console.log ((0.2 + 0.4) .tofixed (2) \u003d\u003d (0.6) .tofixed (2)); // verdadero // Método TOPRECISION () Console.log ((0.2 + 0.4) .toprecision (2) \u003d\u003d (0.6) .toprecision (2)); // Cierto.

Operaciones matemáticas principales

Javascript existe los siguientes operadores matemáticos: + (adición), - (resta), * (multiplicación), / (división),% (residuo de la división), ++ (ZOOM a 1), - (Reducir el valor a 1).

6 + 3 // 9 6-3 // 3 6 * 3 // 18 6/3 // 2 6% 3 // 0, es decir, 6: 3 \u003d 2 \u003d\u003e 6-3 * 2 \u003d\u003e OST (0) 5% 2 // 1, es decir, 5: 2 \u003d 2 (.5) \u003d\u003e 5-2 * 2 \u003d\u003e OST (1) 7.3% 2 //1.3, es decir, 7.3: 2 \u003d 3 (.65) \u003d\u003e 7,3-2 * 3 \u003d\u003e OST (1.3) // El signo del resultado de la operación El% es igual al signo del primer valor -9% 2.5 /--1.5 , es decir 9: 2.5 \u003d 3 (.6) \u003d\u003e 9-2.5 * 3 \u003d\u003e OST (1.5) -9% -2.5 //-1.5, es decir, 9: 2.5 \u003d 3 (.6) \u003d\u003e 9-2.5 * 3 \u003d\u003e OST (1.5) -2% 5 // - 2, es decir. 2: 5 \u003d 0 (.4) \u003d\u003e 2-5 * 0 \u003d\u003e OST (2) x \u003d 3; Console.log (x ++); // Muestra 3, ya ya establece 4 console.log (x); // 4 x \u003d 3; Console.log (++ x); // se establece 4 y se muestra x \u003d 5; Console.log (x--); // Muestra 5, ya luego establece 4 console.log (x); // 4 x \u003d 5; Console.log (- x); // Establece 4 y muestra los operadores combinados en JavaScript además: x + \u003d y (x \u003d x + y), x- \u003d y (x \u003d xy), x * \u003d y (x \u003d x * y), x / \u003d y (x \u003d x / y), x% \u003d y (x \u003d x% y). x \u003d 3; y \u003d 6; x + \u003d y; Console.log (x); // 9 x \u003d 3; y \u003d 6; x- \u003d y; Console.log (x); // - 3 x \u003d 3; y \u003d 6; x * \u003d y; Console.log (x); // 18 x \u003d 3; y \u003d 6; x / \u003d y; Console.log (x); //0.5 x \u003d 3; y \u003d 6; x% \u003d y; Console.log (x); // 3.

Hola. Hoy en día, en la columna JavaScript, veremos cómo establecer en JavaScript el número de cosechas en los números de puntos flotantes. Por ejemplo, debe dejar 3 signos decimales al mostrar, o solo dos.

Tarea: JavaScript Número de punto y coma

Entonces, nos enfrentamos a la tarea: hay un resultado de los cálculos, en los que hay números antes de los punto y coma, y \u200b\u200bdespués de la coma. Decimal. Supongamos que el resultado resultó este 1538.9891200153. Pero cuando la salida debe ser el número que refleja la cantidad, donde la cantidad de billetes está a la altura de la coma, y \u200b\u200bdespués de: Kopecks.

Hay varias formas de resolver esta tarea.

Solución 1: JavaScript Número de punto y coma con el método tofizzado

tofixed es un método incrustado en JavaScript que se aplica a cualquier número, la precisión toma un redondeo de precisión (es decir, el número de caracteres de festividad).

Var num \u003d 1538.9891200153; num_str \u003d num.tofixed (); // NUM_STR \u003d 1538; num_str \u003d num.tofixed (2); //Num_str\u003d1538.98; num_str \u003d num.tofixed (5); //Num_str\u003d1538.98912;

El parámetro de precisión en esta función debe ser al menos 0 (no toma valores negativos), y no más de 20.

También puede hacer sin una variable, por ejemplo, como esta:

Num_str \u003d (1538.9891200153) .tofixed (2); //Num_str\u003d1538.98;

Solución 2: JavaScript Número de punto y coma con el método TOPRECISION

Esta solución se basa en el mismo método de JavaScript incorporado. Una característica distintiva de este método es que el parámetro llevado a la entrada indica que no se precisa (el número de punto y coma), sino el número total de caracteres (tanto a la coma como después de ella).

Var num \u003d 1538.9891200153; num_str \u003d num.toprecision (5); //Num_str\u003d1538.9; num_str \u003d num.toprecision (7); //Num_str\u003d1538.989;

Solución sin signos después de una coma: JavaScript Número de punto y coma

Si los signos decimales deben doblarse completamente, es decir, es necesario redondear el número fraccional al conjunto, entonces puede usar las funciones de la matemática: redondo, ceil y piso.
Redondas - redondas en un lado grande o más pequeño (dependiendo del número). Si el valor después de los punto y coma, se encuentra más de la mitad, las rondas a todo el lado, si es menor a menor. Es decir, si 0.51, será 1, si 0.49 - 0.

CEIL - DESDE EL INGLÉS. El techo siempre se redondea en el lado más grande.

Piso - desde el inglés. Paul rondas siempre en un lado más pequeño.

Var num \u003d 1538.9891200153; num_str \u003d math.round (num); // num_str \u003d 1539; num_str \u003d math.floor (NUM); // NUM_STR \u003d 1538; num_str \u003d math.ceil (num); // num_str \u003d 1539;

Eso es todo. Espero que esta nota te haya ayudado a resolver la tarea. Si algo falló, haz preguntas usando el botón verde "Haz una pregunta de un especialista", o en los comentarios.

Hola, amantes Javascript-a. Ya se ha dado cuenta de que este lenguaje es muy extraordinario y en cada sección destaca por sus peculiaridades y soluciones técnicas inusuales. Por lo tanto, la publicación de hoy está dedicada al tema: redondeo de JavaScript.

Después de leer el artículo actual, descubrirá por qué es necesario redondear los números, qué métodos y propiedades en JS realizan esta función, así como la división de 0. Sin cambiar sus principios, adjuntaré ejemplos a puntos clave de El material y escribe cada acción en detalle. Ahora vamos a empezar a aprender!

Notas importantes sobre los números

Para empezar, recuerde que en JS todo tipo de números (fraccional e entero) se refieren al tipo Número. Además, todos ellos son de 64 bits, ya que se almacenan en el formato "doble precisión", que también se conoce bajo la norma IEEE-754.

Creadas variables numéricas con la forma habitual:

var number \u003d 35; // número natural

var drob \u003d 0.93; // representación decimal

var numb16 \u003d 0xff; // Sistema de 16 riquezas

Soporta otras vistas numéricas. Por lo tanto, también puede crear números con un punto flotante (a veces se denominan números "en formato científico").

En aparato de apoyo para un método muy interesante. tOLOCALESTRING ()Los formatos todos los parámetros numéricos de acuerdo con las especificaciones prescritas en ECMA 402. Debido a estos números grandes, números de teléfono, monedas e incluso porcentajes se muestran en el cuadro de diálogo.

var num \u003d 714000.80;

alerta (num.tolocalesstring ());

Para trabajar con elementos de tipo de tipo, un objeto global completo con un montón de todo tipo de funciones matemáticas, cuyo nombre Matemáticas..

Además, hay otros métodos que realizan valores numéricos de redondeo a enteros, hasta décimas, centésimas, etc. Considerarlos a todos más.

Grandes y poderosas matemáticas

El objeto Matemáticas Global incluye una gran cantidad de diversas funciones matemáticas y trigonométricas. Este es un objeto muy necesario y, a menudo, reduce a los desarrolladores cuando se trabaja con datos digitales.

En otras plataformas, hay analogías matemáticas. Por ejemplo, en idiomas populares como Java y C #, Math es una clase que admite todas las mismas funciones estándar. Entonces, como ves esta herramienta es realmente genial y poderosa.

Ahora quiero pasar por los métodos específicos responsables del redondeo, y contar con ellos en detalle.

Matemáticas.floor ()

Comenzaré S. Matemáticas.suelo. Preste atención al nombre del método. Lógicamente, queda claro que, ya que estamos hablando de redondeo, y la traducción literal de la palabra "piso" significa "piso", entonces esta herramienta redondea los valores procesados \u200b\u200ben una recta más pequeña.

También es posible una opción cuando el número procesado utilizando esta función sigue siendo la misma. Todo porque la redondeo se lleva a cabo en desigualdad no neuronal (<=). Таким образом, при отработке этой строчки кода:

alerta (matemáticas.floor (4.5));

la respuesta será el número 4.

MATH.CEIL ()

Nuevamente, mire el nombre (en un método de este tipo, el material se absorbe rápidamente). Si alguien no lo sabe, "CEIL" significa "techo". Significa que el redondeo los datos numéricos se llevará a cabo en la mayor parte del lado, utilizando una no desigualdad (\u003e \u003d).

alerta (matemáticas.ceil (4.5));

Como ya adivinó, la respuesta será el número 5.

Matemáticas.round ()

Este método redondea el número fraccional al todo más cercano. Por lo tanto, si la parte fraccional está en el rango de 0 y a 0.5 no inclusive, la redondeo ocurre a un valor más pequeño. Y si la parte fraccional está en el rango de 0.5 inclusive y hasta el siguiente entero, se redondea a un todo más grande.

alerta (matemáticas.round (4.5));

Espero que todos pensaron o contaran la respuesta correcta - 5.

Algunos métodos más

Javascript también tiene otros 2 métodos que se dedican a redondear representaciones numéricas. Sin embargo, son algo diferentes.

Será sobre tales instrumentos como tofixed () y toprecisión (). Responden no solo por redondeo, sino por su precisión a ciertos signos. Vamos a luchar más profundo.

tofixed ()

Con este mecanismo, puede especificar, a cuántas señales después de que la coma necesite redondear el valor. El método devuelve el resultado como una cadena. A continuación, adjunto una opción con tres opciones diferentes. Analizar las respuestas recibidas.

var num \u003d 5656.9393;

document.writeln (num.tofixed ()); // 5657.

document.writeln (num.tofixed (2)); // 5656.94

document.writeln (num.tofixed (7)); // 5656.9393000

Como se puede ver, si no especifica el argumento, entonces Tofixed ()) redondea valor fraccional todo números. En la tercera línea completada redondeo hasta 2 caracteresy en el cuarto, debido al parámetro "7", se abordaron tres más 0.

toprecisión ()

Este método actúa de manera similar. En el lugar del argumento, puede dejar un lugar vacío y establecer el parámetro. Sin embargo, este último redondeará los números antes del número especificado de números, no prestará atención a la coma. Aquí están los resultados del programa reescrito del pasado del ejemplo:

var num \u003d 5656.9393;

document.writeln (num.toprecision ()); // 5656.9393

document.writeln (num.toprecision (2)); // 5.7E + 3

document.writeln (num.toprecision (7)); // 5656.939

Archivo de división en 0 en js

Como se conoce de las lecciones en matemáticas, es imposible dividir a cero. Esta regla tomó como base a la mayoría de los creadores de lenguajes de programación. Por lo tanto, al dividir a cero, todos los programas dan un error.

Sin embargo, Javascript se distinguió aquí. Entonces, durante la ejecución de tal operación, no surgen mensajes de error ... porque tal operación regresa "Infinito"!

¿Porque? Como se sabe de las mismas ciencias matemáticas, menor será el divisor, el resultado es un número mayor. Es por eso que los creadores de este lenguaje orientado a los prototipos decidieron abandonar las plantillas y seguir su propio camino.

Para aquellos que se enfrentan primero al valor del infinito, a continuación explicé sus características.

Infinito: significa infinito y coincide completamente con el signo matemático ∞.

Puede ser negativo. Todas las reglas estándar para trabajar con operadores aritméticos también se guardan.

alerta (12/0); // Infinito.

alerta (12.34 / 0); // Infinito

alerta (-3 / 0); // -INFINITO.

En esto, tal vez, y terminar. Si le gusta la publicación, asegúrate de suscribirse a mi blog. No hagas una referencia a artículos interesantes y compartirlos con amigos. ¡Adiós!

A menudo, los cálculos proporcionan resultados que no corresponden a los límites de los rangos deseados. Como resultado, necesitas hacer ejercicio. Redondeo de JavaScript hasta cierto valor.

¿Por qué números redondos?

JavaScript no almacena enteros, ya que sus valores se presentan en forma de números de puntos flotantes. Muchas fracciones no pueden ser representadas por un número con un cierto número finito de punto y coma, por lo que JavaScript puede generar resultados, como los siguientes:

0.1 * 0.2; > 0.020000000000000004

En la práctica, no tendrá ninguna importancia, ya que se trata del error en 2 Quinylonne. Pero esto puede afectar el resultado cuando se trabaja con números que representan valores de válvulas, porcentaje o tamaño de archivo. Por lo tanto, debe hacer o hasta un cierto signo decimal.

Redondeando números decimales

Para "recortar" se utilizan métodos de un número decimal, () o TOPRECISION (). Ambos toman un argumento que determina el número de marcas significativas después de la coma, que debe incluirse en el resultado:

• si para TOFIXED () el argumento no está definido, el valor predeterminado es 0, es decir, sin signos después de la coma; El valor máximo del argumento es 20;
• si para TOPRECISION () no se especifica el argumento, el número no cambia.

var randnum \u003d 6.25; randnum.tofixed (); \u003e "6" math.pi.toprecision (1); \u003e "3" var randnum \u003d 87.335; Randnum.tofixed (2); \u003e "87.33" var randnum \u003d 87.337; Randnum.toprecision (3); \u003e "87.3"

Nota

Y Tofixed (), y Toprecisión devuelve una representación en minúsculas redondeadas, y no un número. Esto significa que la adición de un enorme a Randnum resultará en una cadena de CONCONTINE, y no un número:

console.log (Randnum + redondeado); \u003e "6.256"

Si necesita obtener un redondeo de JavaScript a las centésimas, use ParsFloat ():

var randnum \u003d 6.25; var redondeado \u003d parsefloat (randnum.tofixed (1)); Console.log (redondeado); \u003e 6.3.

tofixed () y Toprecision () también son métodos útiles para truncar una gran cantidad de punto y coma. Es conveniente cuando se trabaja con números que representan unidades monetarias:

var wholenum \u003d 1 var dollares \u003d wholenum.tofixed (2); Console.log (Dollarscents); \u003e "1.00"

Tenga en cuenta que si hay más signos que el parámetro de precisión especificado, TOPRECISION emitirá un resultado en un formato científico:

var num \u003d 123.435 num.toprecision (2); \u003e "1.2e + 2"

Cómo evitar errores al redondear fracciones decimales

En algunos casos, se lleva a cabo tofixed y toprecisión. JavaScript redondeando 5 a un lado más pequeño, no hasta más:

var numustest \u003d 1.005; numestT.tofixed (2); \u003e 1;

El resultado del ejemplo anterior debe ser 1.01, y no 1. Si desea evitar este error, recomiendo usar números exponenciales:

función redonda (número de retorno (matemáticas (valor (valor + e "+ decimales) +" E - "+ decimales);)

Solicitud:

redondo (1.005.2); \u003e 1.01

Si necesita una solución aún más confiable que redondear, está disponible en MDN..

Redondeo con epsilon

Método alternativo JavaScript redondeando hasta décimas fue introducido en ES6 ( también conocido como JavaScript 2015.). « Máquina epsilon»Proporciona un límite de error razonable al comparar dos puntos y coma flotantes. Sin redondeo, las comparaciones pueden dar resultados como el siguiente:

0.1 + 0.2 \u003d\u003d\u003d 0.3\u003e FALSO

Math.Epsilon se puede utilizar en la función para obtener una comparación correcta:

ePEJO DE LA FUNCIÓN (X, Y) (Devuelve matemath.abs (x - y)< Number.EPSILON * Math.max(Math.abs(x), Math.abs(y)); }

La función toma dos argumentos: Uno contiene cálculos, el segundo resultado esperado (redondeado). Devuelve una comparación de estos dos parámetros:

equipo (0.1 + 0.2, 0.3)\u003e Verdadero

Todos los navegadores modernos apoyan las funciones matemáticas ES6. Pero si necesita brindar apoyo en los navegadores antiguos, debe usar Polyfilla.

Truncamiento de números decimales

Todos los métodos presentados anteriormente realizan. JavaScript redondeando hasta décimas. Para recortar un número positivo de hasta dos lugares después de la coma, multiplícela a 100, a través de la vista nuevamente, y luego el resultado obtenido está dividido por 100, necesita:

función truncada (NUM) (retorno math.trunc (NUM * 100) / 100;) truncado (3.1416)\u003e 3.14

Si se requiere algo más flexible, puede usar el operador roto:

función truncada (var numpowerconverter \u003d math.pow (10, decimalplaces); retorno ~~ (num * numpowerconverter) / numpowerconverter;)

Utilizando:

var randint \u003d 35.874993; Truncado (RANDINT, 3); \u003e 35.874.

Redondeando al número más cercano

Para implementar JavaScript redondeando a todo., Se usa matemath.round ():

Matemáticas (4.3)\u003e 4 matemath.round (4.5)\u003e 5

Tenga en cuenta que " mitad valores", Como .5, redondeado.

Redondeando hasta el entero más cercano

Si desea redondear en un lado más pequeño, use el método Math.floor ():

Matemáticas.floor (42.23); \u003e 42 math.floor (36.93); \u003e 36.

El redondeo "hacia abajo" tiene una dirección para todos los números, incluso por negativa. Esto se puede representar como un rascacielos con un número infinito de pisos, incluso por debajo del nivel de la Fundación ( representando números negativos). Si está en el ascensor entre los pisos del sótano 2 y 3 ( lo que coincide con el valor -2.5), Math.floor te entregará al piso -3:

Matemáticas.floor (-2.5); \u003e -3.

Si desea evitar esto, use el redondeo de matemáticas JavaScript usando Math.Trunc () admitido en todos los navegadores modernos (excepto IE / BORDE.):

Math.trunc (-41.43); \u003e -41

MDN también proporciona polyFill de tres líneas para proporcionar soporte de matemáticas en los navegadores antiguos e IE / Edge.

Redondeando hasta el entero más cercano

Si desea redondear los números decimales, use MATH.CEIL. La acción de este método también se puede representar como un ascensor sin fin: Math.Ceil siempre tiene la suerte "arriba", independientemente de si el número es negativo o positivo:

MATH.CEIL (42.23); \u003e 43 Math.Ceil (36.93); \u003e 37 Math.Ceil (-36.93); -36

Redondeo al número múltiple más cercano

Si necesita redondear el valor al número más cercano, varios 5, cree una función que divida el número 5, lo redondea, y luego multiplica el resultado al mismo valor:

función RoundTo5 (NUM) (return math.round (NUM / 5) * 5;)

Utilizando:

roundto5 (11); \u003e 10.

Si desea ejecutar JavaScript redondeando hasta dos caracteres, puede transmitir funciones como el número inicial y la multiplicidad:

función RoundTomultiple (NUM, múltiple) (devuelva matemath.round (NUM / múltiple) * múltiple;)

Para usar la función, encienda el número redondeado y la multiplicidad en su llamada:

var InitialNumber \u003d 11; var múltiple \u003d 10; RoundTomultiple (Initialnumnumn, múltiple); \u003e 10;

Para redondear los valores solo en una dirección grande o más pequeña, reemplácelo en la función redonda en ceil o piso.

Vinculación al rango

A veces necesitas obtener el valor X, que debería estar dentro de un cierto rango. Por ejemplo, necesita un valor de 1 a 100, pero obtenemos el valor 123. Para solucionarlo, puedes usar min () ( devuelve el más pequeño de los números.) y max ( devuelve el número máximo permitido).

Utilizando:

var lowbound \u003d 1; var highbound \u003d 100; var numinput \u003d 123; var pinked \u003d math.max (lowbound, math.min (numinput, highbound)); Console.log (sujetado); \u003e 100;

Puede crear una función o número de clase de extensión.