Ventanas.  virus  Cuadernos.  Internet.  oficina.  Utilidades.  Conductores

A menudo, el resultado de los cálculos es un número con una gran cantidad de decimales. Si este número se usa para cálculos adicionales, entonces se puede dejar en esta forma. Pero a veces necesita redondear el número, por ejemplo, para mostrarlo en la página. Hay varios métodos para redondear números en JavaScript.

El método Math.round() redondea el valor a un número entero.

Ronda de matemáticas (número)

El número se redondea según reglas matemáticas. Es decir, si después del punto decimal hay un número del 0 al 4, simplemente se descarta la parte fraccionaria. Y si después del punto decimal hay un número del 5 al 9, entonces se descarta la parte fraccionaria y se suma uno a la parte entera. ejemplo:

JavaScript:

Hay dos métodos más que redondean un número a un valor entero. El método Math.floor() redondea hacia abajo. Descarta la parte fraccionaria del número. Y el método Math.ceil() redondea hacia arriba. Descarta la parte fraccionaria y suma uno a la parte entera. Ejemplo:

Por supuesto, 5 - (-2) es 5+2. No olvides que no obtendrás el número 5 en esta fórmula. El máximo será 4,999999999. Los valores resultantes se pueden redondear a la precisión deseada.

Si solo se necesitan números enteros, los valores resultantes se pueden redondear al número entero más cercano. Se debe sumar uno al máximo para que este máximo también sea posible. La fórmula se ve así:

entero = Math.floor (min + Math.random() * (max + 1 - min)

Vamos a generar números del 10 al 15:

20
21
22
23
24

para (i=1; i= (mayor o igual que), 3); //falso consola.log(5>=3); //verdadero

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

Por ejemplo, en JavaScript, la suma de los números (0,2 + 0,4) no es igual a 0,6:

Consola.log((0.2+0.4)==0.6); //FALSO

Los errores ocurren porque todos los cálculos son computarizados u otros dispositivo electronico produce en sistema de 2 números. Aquellos. antes de realizar cualquier acción, la computadora primero debe convertir los números presentados en la expresión al sistema de 2 números. Pero, ningún número decimal fraccionario se puede representar exactamente en el segundo sistema numérico.

Por ejemplo, el número 0,25 10 se convierte exactamente a binario.

0,125 × 2 = 0,25 | 0 0,25 × 2 = 0,5 | 0 0,5 × 2 = 1 | 1 0,125 10 = 0,001 2

Por ejemplo, el número 0.2 10 se puede convertir al sistema 2 solo con cierta precisión:

0,2 × 2 = 0,4 | 0 0,4 × 2 = 0,8 | 0 0,8 × 2 = 1,6 | 1 0,6 × 2 = 1,2 | 1 0,2 × 2 = 0,4 | 0 0,4 × 2 = 0,8 | 0 0,8 × 2 = 1,6 | 1 0,6 × 2 = 1,2 | 1 0,2 × 2 = 0,4 | 0 0,4 × 2 = 0,8 | 0 0,8 × 2 = 1,6 | 1 0,6 × 2 = 1,2 | 1 ... 0,2 10 = 0,001100110011... 2

Como resultado, estos errores afectarán el cálculo de la suma de dos números y los resultados de la comparación. Aquellos. resulta que, de hecho, JavaScript verá esta entrada de la siguiente manera:

0.6000000000000001==0.6

Al calcular o mostrar números con una parte fraccionaria, siempre debe especificar la precisión con la que se debe hacer.

Por ejemplo, compare números con hasta 2 decimales utilizando los métodos toFixed() y toPrecision():

//método toFixed() console.log((0.2+0.4).toFixed(2)==(0.6).toFixed(2)); //verdadero //método toPrecision() console.log((0.2+0.4).toPrecision(2)==(0.6).toPrecision(2)); //verdadero

Operaciones matemáticas básicas

JavaScript tiene los siguientes operadores matemáticos: + (suma), - (resta), * (multiplicar), / (división), % (resto de la división), ++ (aumentar valor en 1), -- (reducir valor en 1 ).

6+3 //9 6-3 //3 6*3 //18 6/3 //2 6%3 //0, es decir 6:3=2 => 6-3*2 => rest(0) 5%2 //1, es decir 5:2=2(.5) => 5-2*2 => rest(1) 7.3%2 //1.3, es decir 7.3:2=3(.65) => 7.3-2*3 => rest(1.3) //el signo del resultado de la operación % es igual al signo del primer valor -9%2.5 //-1.5, es decir 9:2.5=3(.6) => 9-2.5*3 => rest(1.5) -9%-2.5 //-1.5, es decir 9:2.5=3(.6) => 9-2.5*3 => rest(1.5) -2%5 //-2, es decir 2:5=0(.4) => 2-5*0 => resto(2) x = 3; registro de consola(x++); //muestra 3, luego establece y en 4 console.log(x); //4 x = 3; registro de la consola(++x); //establece 4 y genera x = 5; registro de la consola (x--); //produce 5, y luego establece 4 console.log(x); //4 x = 5; registro de la consola (--x); //se establece en 4 y da salida Además, hay operadores combinados en JavaScript: x+=y (x=x+y), x-=y (x=x-y), x*=y (x=x*y), x/= y (x=x/y), x%=y (x=x%y). x=3; y=6; x+=y; registro de la consola (x); //9 x = 3; y=6; x-=y; registro de la consola (x); //-3 x = 3; y=6; x*=y; registro de la consola (x); //18 x = 3; y=6; x/=y; registro de la consola (x); //0.5x = 3; y=6; x%=y; registro de la consola (x); //3

Ahora considere el método del piso (en traducción - género), que funciona de manera opuesta al método ceil, es decir redondea el número fraccionario HACIA ABAJO.

var edad = 35,97 ;

edad = Matemáticas.piso(edad) ; /* Redondea hacia abajo el valor de la variable edad */

documento.escribir(edad);

Como puede ver, el método del piso redondeó el número 35.97 a 35. Aunque 0,97 es mayor que 0,5 (cm. ).

Esta lección analizó los métodos del objeto Math que le permiten redondear números decimales fraccionarios.

Ahora tienes que hacer tu tarea.

Tu tarea es escribir una función que tome dos parámetros.
1. Una matriz que consta de números con fracciones.
2. Método de redondeo "redondo", "techo" o "piso".

En la salida, la función debe generar la misma matriz, pero al mismo tiempo, todos los elementos de la matriz deben redondearse utilizando el método del objeto matemático especificado en el segundo parámetro.

matriz de origen:

varnumberArray = ;

Al principio, la solución a esta tarea puede parecer casi idéntica a las soluciones a los problemas de tarea de las primeras tres lecciones. este tema. Pero no todo es tan simple...

Decisión #1 - Atención

De acuerdo con la condición del problema, la función debe tomar dos parámetros: la matriz original y uno de los métodos: "round", "ceil" o "floor". Basado en esto, traté de hacer esto...

function decimal (anyArray ,method ) /* Crea una función con dos parámetros */
{

para (i = 0 ; yo< anyArray .length ; i ++ )

{
document.write(anyArray
" )

cualquierArray = Math.method(anyArray); /* Usa uno de los métodos del objeto Math para redondear el elemento actual de la matriz */

documento.escribir(cualquierArray + "

" )
}

decimal (numberArray, round ) /* Llamar a la función y darle dos parámetros. Pero NO especifique un NOMBRE de método como parámetro de función */

En esta solución, creamos una función con dos parámetros, y cuando la llamamos, tratamos de especificar la matriz original y el NOMBRE de un método como parámetros de la función:
decimal (numberArray, redondo) - en este caso redondo.

Pero no obtendremos el resultado, ya que es IMPOSIBLE especificar el NOMBRE del método como parámetro de la función.

Tenga en cuenta: no es casualidad que los nombres de los métodos "redondo", "techo" y "piso" estén entre comillas en el enunciado del problema.

decimal (numberArray, "round"), ¡pero esa notación tampoco será correcta!

Solución #2 - Corrección de la solución anterior

Puede resolver el problema especificando un parámetro para la función.

varnumberArray = ;

function decimal (anyArray) /* Crea una función con un parámetro */
{

para (i = 0 ; yo< anyArray .length ; i ++ ) /* Перебираем элементы массива */

{
documento.escribir(cualquierArray + "- elemento original formación
" ) /* Muestra el elemento actual de la matriz */

/* Usa el método de redondeo del objeto Math para redondear el elemento actual de la matriz */

document.write (anyArray + " - Elemento redondeado

" ) /* Muestra el elemento ROUNDED de la matriz */
}

decimal (numberArray) /* Llamar a la función y especificar un parámetro: la matriz original */


35 - Elemento redondeado


13 - Elemento redondeado


17 - Elemento redondeado


79 - Elemento redondeado

Logramos lograr el resultado deseado aquí: el método redondo redondeó todos los números por . Pero la condición no se cumple, porque la función toma solo un parámetro.

Solución #3 - Función con dos parámetros

Aquí el problema se resuelve correctamente. Para ello, era necesario recordar condiciones de asunto en javascript y aplicar múltiples condiciones simultáneamente.

varnumberArray = ;

función decimal (anyArray, método)
{
para (i = 0 ; yo< anyArray .length ; i ++ )
{
document.write (anyArray + " - el elemento original de la matriz
" );

si (método
{
cualquierArray = Math.round(anyArray);
document.write (anyArray + " - redondeo estándar

" )
}

De lo contrario, si (método
{

document.write (anyArray + " - redondear hacia arriba

" )
}

más si (método
{

document.write (anyArray + " - redondear hacia ABAJO

" )
}

}
}
decimal (numberArray, "ceil")/* El segundo parámetro de la función - entre comillas, especifique el nombre de uno de los métodos */

34.82 - elemento de matriz original
35 - redondear hacia arriba

12.9 - elemento de matriz original
13 - redondear

17.01 - el elemento original de la matriz
18 - redondear

78.51 - elemento de matriz fuente
79 - redondear hacia arriba

Esta es la solución correcta para la tarea. Aquí, se especifican dos parámetros para la función según la condición.

Prueba en la última línea de esta solución:
decimal (numberArray, "ceil") como segundo parámetro de la función, especifique los nombres de otros métodos "round" y "floor" del objeto Math.

Solución #4 - Función con dos parámetros + método rápido

Decidí optimizar un poco la solución anterior y agregué método rápido, que llama ventana modal que contiene un campo para ingresar información.

Ahora, gracias a esto, será posible ingresar el nombre de uno de los métodos redondo, piso o techo en el campo de entrada y obtener el resultado correspondiente.

varnumberArray = ;

función decimal (anyArray, método)
{
para (i = 0 ; yo< anyArray .length ; i ++ )
{
document.write (anyArray + " - el elemento original de la matriz
" );

if (método == "redondo") /* 1ra condición */
{
cualquierArray = Math.round(anyArray);
documento.escribir(cualquierArray + "

" )
}

Else if(método == "ceil" ) /* 2da condición */
{
cualquierArray = Math.ceil(anyArray );
documento.escribir(cualquierArray + "

" )
}

else if(método == "piso") /* 3ra condición */
{
cualquierArray = Matemáticas.piso(cualquierArray);
documento.escribir(cualquierArray + "

" )
}

/* Agregar método de solicitud */

var method = prompt("Ingrese uno de los métodos: round, ceil o floor" );

if (método == "piso") /* 1ra condición */
{
document.write ("Ha ingresado un método" + método + "que redondea los números HACIA ABAJO

" )
}

else if (método == "redondo") /* 2da condición */
{
document.write ("Ha ingresado el método" + método + ", que redondea los números de acuerdo con las reglas estándar

" )
}

else if (método == "ceil" ) /* 3ra condición */
{
document.write ("Ha ingresado el método " + método + " , que redondea los números hacia arriba

" )
}

si no /* si no... */
{
document.write("No ingresó o ingresó un método por error

" )
}

decimal (numberArray, método) /* Llamar a la función */

Así funcionan los métodos round , floor o ceil del objeto Math, que redondean números fraccionarios.

Si nota un error, seleccione un fragmento de texto y presione Ctrl + Enter
COMPARTIR: