Este artículo analizará más de cerca los números, los operadores matemáticos, las formas de convertir un número en una cadena y viceversa, así como muchos otros puntos importantes.
Función IsFinite
La función isFinite le permite verificar si un argumento es finito.
En respuesta, esta función devuelve falso si el argumento es Infinity, -Infinity, NaN o se convertirá en uno de estos valores numéricos especiales. De lo contrario, esta función devolverá verdadero.
IsFinite (73); // verdadero esFinito (-1/0); // falso isFinite (Infinity); // falso isFinite (NaN); // false isFinite ("Texto"); // falso
Además de la función global isFinite, JavaScript también tiene un método Number.isFinite. A diferencia de isFinite, no fuerza el argumento a un número.
IsFinite ("73"); // verdadero Number.isFinite ("73"); // falso
Función IsNaN
La función isNaN está diseñada para determinar si un argumento es un número o si se puede convertir a él. Si es así, la función isNaN devuelve falso. De lo contrario, devuelve verdadero.
IsNaN (NaN); // verdadero esNaN ("25px"); // cierto, porque 20px no es un número isNaN (25,5); // falso isNaN ("25.5"); // falso isNaN (""); // falso, porque el espacio o varios espacios se convierten en 0 isNaN (nulo); // falso, porque nulo se convierte en 0 isNaN (verdadero); // falso, porque verdadero se convierte en 1 isNaN (falso); // falso, porque falso se convierte en 0
Si esta acción debe realizarse sin conversión de tipos, utilice el método Number.isNaN. Este método se ha introducido en el lenguaje desde ECMAScript 6.
¿Cómo puedo convertir explícitamente una cadena en un número?
Puede convertir explícitamente una cadena en un número utilizando los siguientes métodos:
1. Utilizar operador + unariopara ser colocado antes del valor.
+ "7,35"; // 7.35 + "texto"; // NaN
Este método ignora los espacios en blanco iniciales y finales y \\ n (salto de línea).
+ "7,35"; //7.35 + "7.35 \\ n"; //7.35
Con este método, debe prestar atención al hecho de que una cadena vacía o una cadena que consta de espacios y \\ n se traduce al número 0. Además, también convierte el tipo de datos nulo y los valores booleanos en un número.
Nulo; // 0 + verdadero; // 1 + falso; // 0 + ""; // 0
2. La función parseInt. Esta función está diseñada para convertir argumento a un entero... A diferencia de usar operador unario +, este método le permite convertir una cadena en un número en el que no todos los caracteres son numéricos... Comienza a convertir la cadena comenzando por el primer carácter. Y en cuanto encuentra un carácter que no es digital, esta función detiene su trabajo y devuelve el número resultante.
ParseInt ("18px"); // 18 parseInt ("33,3%"); // 33
Esta función puede trabajar con diferentes sistemas numéricos (binario, octal, decimal, hexadecimal). La base se especifica 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 parseInt, JavaScript tiene un método Number.parseInt. Este método no es diferente de la función parseInt y se introdujo en JavaScript con la especificación ECMASCRIPT 2015 (6).
3. La función parseFloat. ParseFloat es similar a parseInt, excepto que convierte el argumento en una fracción.
ParseFloat ("33,3%"); //33.3
Además, la función parseFloat, a diferencia de parseInt, no tiene 2 argumentos y, por lo tanto, siempre intenta tratar la cadena como un número en notación decimal.
ParseFloat ("3,14"); parseFloat ("314e-2"); parseFloat ("0.0314E + 2");
Además de la función parseFloat, JavaScript tiene un método Number.parseFloat. Este método no es diferente de la función parseFloat y se introdujo en JavaScript con la especificación ECMASCRIPT 2015 (6).
Convertir número en cadena
Puede convertir un número en una cadena utilizando el método toString.
(12.8) .toString (); //"12.8 "
El método toString también le permite especificar la base del sistema numérico, teniendo en cuenta que es necesario convertir explícitamente el número en una cadena:
(255) .toString (16); // "ff"
Cómo comprobar si una variable es un número
Puede determinar si el valor de una variable es un número utilizando uno de los siguientes métodos:
1.Utilizando las funciones isNaN e isFinite:
// myVar es una variable if (! isNaN (parseFloat (myVar)) && isFinite (parseFloat (myVar))) (// myVar es un número o se puede convertir en él);
Como una función:
// function function isNumeric (value) (return! isNaN (parseFloat (value)) && isFinite (parseFloat (value));) // use var myVar \u003d "12px"; console.log (isNumeric (myVar)); // cierto
Este método le permite determinar si el valor especificado es un número o se puede convertir a él. Esta opción no trata una cadena vacía, una cadena de espacios, nulo, Infinito, -Infinito, verdadero o falso como un número.
2.Utilizando el operador typeof y isFinite, funciones isNaN:
// función que comprueba si el valor es un número function isNumber (value) (return typeof value \u003d\u003d\u003d "(! LANG: number" && 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 de tipo Número y uno de los valores especiales Infinity, -Infinity y NaN. Si es así, esta función devuelve verdadero.
3.Utilizando el método ECMAScript 6 Number.isInteger (value). Este método determina si el valor especificado es un número entero.
Number.isInteger ("20"); // falso, porque este método no realiza un salto de línea a Number.isInteger (20); // cierto, porque el valor dado es un número
Números pares e impares
Puede comprobar si un número es par o impar utilizando las siguientes funciones:
// Función para verificar la uniformidad del número isEven (n) (return n% 2 \u003d\u003d 0;) // Función para verificar la función de imparidad del número isOdd (n) (return Math.abs (n% 2) \u003d\u003d 1; )
Pero antes de hacer tal verificación, es recomendable asegurarse de que el valor especificado sea un número:
Valor \u003d 20; if (Number.isInteger (value)) (if (isEven (value)) (console.log ("Number" + value.toString () + "- even");))
Números primos de JavaScript
Consideremos un ejemplo en el que mostramos números primos de 2 a 100 usando Javascript.
// Una función que verifica si el número es primo function isPrime (value) (if (isNaN (value) ||! IsFinite (value) || value% 1 || value< 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);
Redondear un número en Javascript
Hay varias formas de redondear un número fraccionario a un valor entero en JavaScript.
1. Usando métodos especialmente diseñados para Math.floor, Math.ceil y Math.round. El método Math.floor redondea el número fraccionario al entero más cercano, es decir, simplemente descarta la parte fraccionaria. Math.ceil redondea un número fraccionario al entero más cercano. Math.round redondea un número hacia arriba o hacia abajo según el valor de la parte fraccionaria. Si la parte fraccionaria es mayor o igual a 0.5, entonces hacia arriba, de lo contrario el rizo es hacia abajo.
Console.log (Math.floor (7.9)); // 7 console.log (Math.ceil (7.2)); // 8 console.log (Math.round (7.5)); // 8
2. Usando el método toFixed (precisión). Este método redondea la parte fraccionaria de un número a la precisión especificada. El resultado del redondeo se devuelve como una cadena.
Console.log (7.987.toFixed (2)); //"7,99 "
Si no hay suficientes lugares decimales para formar la precisión especificada del número, se rellena con ceros.
Console.log (7.987.toFixed (5)); //"7.98700 "
3. Mediante el método toPrecision. Este método representa un número con la precisión especificada. Además, puede redondear no solo la fracción, sino también la parte entera del número. Este método puede representar el número resultante, dependiendo del resultado, con un punto fijo 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. Usar operadores lógicos NOT u OR.
// vía doble negación lógica console.log (~~ 7.9); // 7 // usando OR lógico con cero: console.log (7.9 ^ 0); // 7
Entero y parte fraccionaria de un número
Puede obtener la parte entera de un número usando el método Math.floor () y parseInt ():
Console.log (Math.floor (7.21)); // 7 console.log (parseInt (7.21)); // 7
Puede obtener la parte fraccionaria de un número utilizando el operador de porcentaje (%). Este operador devuelve el resto que se obtendrá dividiendo el primer número por el segundo. En este caso, se debe utilizar 1 como número 2.
Console.log (7.21% 1); // 0.20999999999999996 // con precisión de 2 decimales console.log ((7.21% 1) .toFixed (2)); // "0.21"
Además, la parte fraccionaria también se puede obtener mediante cálculos:
Número de var \u003d 7,21; var FractionNumber \u003d number - Math.floor (Math.abs (número)); console.log (número de fracción); // 0,20999999999999996
¿Es el número par divisible?
Puede determinar si un número es divisible uniformemente mediante el operador de porcentaje:
Var número \u003d 9; // si el resto de dividir el número entre 3 es 0, entonces sí, de lo contrario no si (número% 3 \u003d\u003d 0) (console.log ("Número" + número + "es divisible por 3");) else (consola. log ("Número" + número + "no es divisible por 3");)
Formatear números
En JavaScript, el método toLocaleString () le permite formatear la salida de un número para que coincida con la configuración de idioma regional (sistema operativo).
Por ejemplo, formateemos el número de acuerdo con los estándares regionales que están instalados en el sistema de forma predeterminada:
Var número \u003d 345,46; console.log (number.toLocaleString ()); // "345,46"
Por ejemplo, formateemos el número de acuerdo con los estándares regionales de Rusia (ru):
Console.log ((108.1) .toLocaleString ("ru-RU")); // "108,1"
Este método también se puede utilizar para formatear un número como moneda:
Console.log ((2540.125) .toLocaleString ("ru-RU", (estilo: "moneda", moneda: "RUB"))); // "2 540.13 ₽" console.log ((89.3) .toLocaleString ("ru-RU", (estilo: "moneda", moneda: "USD"))); // "89.30 $" console.log ((2301.99) .toLocaleString ("ru-RU", (estilo: "moneda", moneda: "EUR"))); // "2.301,99 €"
Representación de un número como porcentaje:
Console.log ((0.45) .toLocaleString ("ru-RU", (estilo: "porcentaje"))); // "45%"
Divida el número en dígitos (propiedad useGrouping):
Console.log ((125452.32) .toLocaleString ("ru-RU", (useGrouping: true))); // "125 452,32"
Imprima un número con un cierto número de dígitos (2) después del punto decimal:
Console.log ((1240.4564) .toLocaleString ("ru-RU", (minimumFractionDigits: 2, maximumFractionDigits: 2))); // "1240,46"
Comparación de números
JavaScript utiliza los siguientes operadores para comparar números: \u003d\u003d (igual),! \u003d (No igual),\u003e (mayor que),< (меньше), >\u003d (mayor o igual que),<= (меньше или равно).
Por ejemplo, comparemos dos números:
Console.log (2\u003e 3); // falso console.log (5\u003e \u003d 3); // cierto
Al comparar números con partes fraccionarias, es necesario tener en cuenta los errores que pueden surgir durante estos cálculos.
Por ejemplo, en JavaScript, la suma de números (0,2 + 0,4) no es 0,6:
Console.log ((0.2 + 0.4) \u003d\u003d 0.6); // falso
Los errores ocurren porque todos los cálculos son realizados por una computadora u otro dispositivo electrónico en el segundo sistema numérico. Aquellos. antes de realizar cualquier acción, la computadora primero debe convertir los números representados en la expresión en un sistema de 2 números. Pero, ningún número decimal fraccionario se puede representar exactamente en el sistema de 2 números.
Por ejemplo, el número 0.25 10 se convierte exactamente al sistema binario.
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 al sistema 2 solo con cierta precisión:
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 los resultados de la comparación. Aquellos. resulta que, de hecho, JavaScript verá este registro de la siguiente manera:
0.6000000000000001==0.6
Al calcular o visualizar números con parte fraccionaria, siempre debe indicar la precisión con la que se debe realizar.
Por ejemplo, compare números de hasta 2 lugares decimales utilizando los métodos toFixed () y toPrecision ():
// método toFixed () 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 básicas
Los siguientes operadores matemáticos existen en JavaScript: + (suma), - (resta), * (multiplicación), / (división),% (módulo), ++ (aumentar en 1), - (disminuir en 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 resto (0) 5% 2 // 1, es decir 5: 2 \u003d 2 (.5) \u003d\u003e 5-2 * 2 \u003d\u003e resto (1) 7.3% 2 //1.3, es decir 7.3: 2 \u003d 3 (.65) \u003d\u003e 7.3-2 * 3 \u003d\u003e 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 \u003d 3 (.6) \u003d\u003e 9-2.5 * 3 \u003d\u003e resto (1.5) -9% -2.5 //-1.5, es decir 9: 2.5 \u003d 3 (.6) \u003d\u003e 9-2.5 * 3 \u003d\u003e resto (1.5) -2% 5 // - 2, es decir 2: 5 \u003d 0 (.4) \u003d\u003e 2-5 * 0 \u003d\u003e descanso (2) x \u003d 3; console.log (x ++); // imprime 3, y establece 4 posteriores console.log (x); // 4 x \u003d 3; console.log (++ x); // establece 4 e imprime x \u003d 5; console.log (x--); // imprime 5, y establece 4 posteriores console.log (x); // 4 x \u003d 5; console.log (- x); // establece 4 y salidas Además, JavaScript tiene operadores combinados: 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
A menudo, los cálculos en JavaScript no dan exactamente los resultados que queremos. Por supuesto, podemos hacer cualquier cosa con los números: redondear hacia arriba o hacia abajo, establecer rangos, cortar números innecesarios a un cierto número de decimales, todo depende de lo que quieras hacer con este número en el futuro.¿Por qué es necesario el redondeo?
Uno de los aspectos curiosos de JavaScript es que en realidad no almacena enteros, estamos trabajando inmediatamente con números de punto flotante. Esto, combinado con el hecho de que muchos valores fraccionarios no se pueden expresar en números finitos de lugares decimales, en JavaScript podemos obtener resultados como este:0.1 * 0.2;
> 0.020000000000000004
0.3 - 0.1
> 0.19999999999999998
A efectos prácticos esta inexactitud no importa en absoluto, en nuestro caso estamos hablando de un error en trillones de partes, sin embargo, esto puede decepcionar a alguien. Podemos obtener un resultado un poco extraño cuando trabajamos con números que representan valores de monedas, porcentajes o tamaños de archivo. Para corregir estas inexactitudes, solo necesitamos poder redondear los resultados, mientras que es suficiente establecer la precisión decimal.
Redondear números tiene una aplicación práctica, podemos manipular un número en un rango determinado, por ejemplo, queremos redondear el valor al entero más cercano, y no trabajar solo con la parte decimal.
Redondeo de números decimales
Para quitar un número decimal, use toFixed o el método toPrecision. Ambos toman un solo argumento, que determina, respectivamente, cuántos dígitos significativos (es decir, el número total de dígitos usados \u200b\u200ben el número) o lugares decimales (el número después del punto decimal) el resultado debe incluir:- Si el argumento no está definido para toFixed (), entonces por defecto será cero, lo que significa 0 posiciones decimales, el argumento tiene un valor máximo de 20.
- Si no se da ningún argumento para toPrecision, el número se deja intacto
Tanto toFixed () como toPrecision () devuelven una representación de cadena del resultado, no un número. Esto significa que cuando el valor redondeado se suma con randNum, las cadenas se concatenarán, no la suma de los números:
Sea randNum \u003d 6.25; dejar redondeado \u003d randNum.toFixed (); // "6" console.log (randNum + redondeado); \u003e "6.256"
Si desea que el resultado tenga un tipo de datos numérico, deberá usar parseFloat:
Sea randNum \u003d 6.25; dejar redondeado \u003d parseFloat (randNum.toFixed (1)); console.log (redondeado); \u003e 6,3
Tenga en cuenta que 5 valores se redondean excepto en casos excepcionales.
Los métodos toFixed () y toPrecision () son útiles porque no solo pueden eliminar la parte fraccionaria, sino también complementar los lugares decimales, lo cual es conveniente cuando se trabaja con moneda:
Deje WholeNum \u003d 1 deje dólaresCents \u003d WholeNum.toFixed (2); console.log (DollarCents); \u003e "1,00"
Tenga en cuenta que toPrecision dará el resultado en notación exponencial si el número de enteros es mayor que la precisión en sí:
Let num \u003d 123.435 num.toPrecision (2); \u003e "1.2e + 2"
Cómo evitar errores de redondeo con números decimales
En algunos casos, toFixed y toPrecision redondea 5 hacia abajo y hacia arriba:Sea numTest \u003d 1.005; numTest.toFixed (2); \u003e "1,00"
El resultado del cálculo anterior debería haber sido 1.01, no 1. Si desea evitar este error, podemos usar la solución sugerida por Jack L Moore, que usa números exponenciales para calcular:
Función round (valor, decimales) (devuelve Número (Math.round (valor + "e" + decimales) + "e -" + decimales);)
Ahora:
Ronda (1.005.2); \u003e 1.01
Si desea una solución más sólida que la que se muestra arriba, puede dirigirse a MDN.
Redondeo de epsilon de la máquina
En ES6 se introdujo un método alternativo para redondear números decimales. El redondeo de épsilon automático proporciona un margen de error razonable al comparar dos números de coma flotante. Sin redondeo, las comparaciones pueden producir resultados similares a los siguientes:0.1 + 0.2 \u003d\u003d\u003d 0.3\u003e falso
Usamos Math.EPSILON en nuestra función para obtener la comparación correcta:
Función epsEqu (x, y) (return Math.abs (x - y)< Number.EPSILON * Math.max(Math.abs(x), Math.abs(y));
}
La función toma dos argumentos: el primero es el cálculo actual, el segundo es el resultado esperado. Devuelve una comparación de los dos:
EpsEqu (0,1 + 0,2, 0,3)\u003e verdadero
Todos los navegadores modernos ya son compatibles con las funciones matemáticas de ES6, pero si desea compatibilidad con navegadores como IE 11, utilice polyfills.
Recorte fraccional
Todos los métodos presentados anteriormente saben cómo redondear a números decimales. Para simplemente cortar el número a dos lugares decimales, primero debe multiplicarlo por 100 y luego dividir el resultado por 100:Función truncada (num) (return Math.trunc (num * 100) / 100;) truncada (3.1416)\u003e 3.14
Si desea acomodar cualquier número de lugares decimales, puede usar la negación doble bit a bit:
Función truncada (num, decimalPlaces) (let numPowerConverter \u003d Math.pow (10, decimalPlaces); return ~~ (num * numPowerConverter) / numPowerConverter;)
Ahora:
Sea randInt \u003d 35,874993; truncado (randInt, 3); \u003e 35.874
Redondea al número más cercano
Para redondear un decimal hacia arriba o hacia abajo al número más cercano, al que estemos más cerca, use Math.round ():Ronda matemática (4.3)\u003e 4 Ronda matemática (4.5)\u003e 5
Tenga en cuenta que "la mitad del valor", 0,5 se redondea de acuerdo con las reglas de las matemáticas.
Redondea al número entero más cercano
Si desea redondear siempre hacia abajo, use Math.floor:Math.floor (42,23); \u003e 42 Piso matemático (36,93); \u003e 36
Tenga en cuenta que el redondeo hacia abajo funciona para todos los números, incluidos los negativos. Imagine un rascacielos con un número infinito de pisos, incluidos los del nivel inferior (que representan números negativos). Si está en el elevador en el nivel inferior entre 2 y 3 (que es un valor de -2.5), Math.floor lo llevará a -3:
Math.floor (-2,5); \u003e -3
Pero si desea evitar esta situación, use Math.trunc, que es compatible con todos los navegadores modernos (excepto IE / Edge):
Math.trunc (-41,43); \u003e -41
En MDN encontrará un polyfill que brindará soporte para Math.trunc en navegadores e IE / Edge.
Redondea al número entero más cercano
Por otro lado, si siempre necesita redondear, use Math.ceil. Nuevamente, recordando la elevación infinita: Math.ceil siempre aumentará, independientemente de si el número es negativo o no:Math.ceil (42,23); \u003e 43 Math.ceil (36,93); \u003e 37 Math.ceil (-36,93); \u003e -36
Redondeo hacia arriba / hacia abajo según sea necesario
Si queremos redondear al múltiplo más cercano de 5, la forma más sencilla es crear una función que divida un número por 5, lo redondea y luego lo multiplique por la misma cantidad:Función roundTo5 (num) (return Math.round (num / 5) * 5;)
Ahora:
RoundTo5 (11); \u003e 10
Si desea redondear a múltiplos de su valor, usamos una función más general, pasando un valor inicial y un múltiplo:
Función roundToMultiple (num, multiple) (return Math.round (num / multiple) * multiple;)
Ahora:
Let initialNumber \u003d 11; sea \u200b\u200bmultiple \u003d 10; roundToMultiple (initialNumber, multiple); \u003e 10;
Fijar un número en un rango
Hay muchos casos en los que queremos obtener un valor de x que esté dentro de un rango. Por ejemplo, podríamos querer un valor entre 1 y 100, pero obtenemos un valor de 123. Para solucionar esto, podemos usar min (devuelve el más pequeño de un conjunto de números) y max (devuelve el mayor de cualquier conjunto de números). En nuestro ejemplo, el rango es de 1 a 100:Deje lowBound \u003d 1; deje highBound \u003d 100; let numInput \u003d 123; let clamped \u003d Math.max (lowBound, Math.min (numInput, highBound)); console.log (sujeto); \u003e 100;
Nuevamente, podemos reutilizar la operación y envolverlo todo en una función, usemos la solución sugerida por Daniel X. Moore:
Number.prototype.clamp \u003d function (min, max) (return Math.min (Math.max (this, min), max););
Ahora:
NumInput.clamp (límite bajo, límite alto); \u003e 100;
Redondeo gaussiano
El redondeo gaussiano, también conocido como redondeo de banco, es donde se produce el redondeo al par más cercano. Este método de redondeo funciona sin errores estadísticos. Tim Down sugirió la mejor solución:Función gaussRound (num, decimalPlaces) (let d \u003d decimalPlaces || 0, m \u003d Math.pow (10, d), n \u003d + (d? Num * m: num) .toFixed (8), i \u003d Math.floor (n), f \u003d norte - yo, e \u003d 1e-8, r \u003d (f\u003e 0.5 - e && f< 0.5 + e) ?
((i % 2 == 0) ? i: i + 1) : Math.round(n);
return d ? r / m: r;
}
Ahora:
Gauss Redondo (2.5)\u003e 2 gauss Redondo (3.5)\u003e 4 gauss Redondo (2.57,1)\u003e 2.6
Punto decimal en CSS:
Dado que JavaScript se usa a menudo para generar transformaciones posicionales en elementos HTML, es posible que se pregunte qué sucede si generamos valores decimales para nuestros elementos:
#box (ancho: 63.667731993px;)
La buena noticia es que los navegadores modernos considerarán valores decimales en el modelo de caja, incluso en porcentaje o unidades de píxeles.
Clasificación
Muy a menudo tenemos que ordenar algunos elementos, por ejemplo, tenemos una serie de registros de juego, y deben estar organizados en orden descendente del rango de los jugadores. Desafortunadamente, el método estándar sort () tiene algunas limitaciones sorprendentes: funciona bien con palabras en inglés de uso común, pero se interrumpe inmediatamente cuando se enfrenta a números, caracteres únicos o palabras en mayúscula.Ordenar alfabéticamente
Parecería que ordenar alfabéticamente una matriz debería ser la tarea más sencilla:Let fruit \u003d ["calabaza", "albaricoque", "melón"]; fruit.sort (); \u003e "albaricoque", "calabaza", "melón"]
Sin embargo, nos encontramos con un problema tan pronto como uno de los elementos está en mayúsculas:
Let fruit \u003d ["calabaza", "albaricoque", "Cantalope"]; fruit.sort (); \u003e "Melón", "albaricoque", "calabaza"]
Esto se debe a que, de forma predeterminada, el clasificador compara el primer carácter representado en Unicode. Unicode es un código único para cualquier personaje, independientemente de la plataforma, independientemente del programa, independientemente del idioma. Por ejemplo, si observa la tabla de códigos, el carácter "a" tiene el valor U + 0061 (en el sistema hexadecimal 0x61), mientras que el carácter "C" tiene el código U + 0043 (0x43), que aparece antes en la tabla Unicode que el carácter "UNA".
Para ordenar una matriz, que puede contener mayúsculas y minúsculas de las primeras letras, necesitamos convertir todos los elementos temporalmente a minúsculas o definir nuestro propio orden de clasificación utilizando el método localeCompare () con algunos argumentos. Como regla general, para tal caso, es mejor crear inmediatamente una función para uso repetido:
Función alphaSort (arr) (arr.sort (function (a, b) (return a.localeCompare (b, "en", ("sensibilidad": "base"));));) let fruit \u003d ["butternut squash "," albaricoque "," Melón "]; alphaSort (fruta)\u003e
Si desea obtener una matriz ordenada en orden alfabético inverso, simplemente intercambie las posiciones de ayb en la función:
Función alphaSort (arr) (arr.sort (function (a, b) (return b.localeCompare (a, "en", ("sensibilidad": "base"));));) let fruit \u003d ["butternut squash "," albaricoque "," Melón "]; alphaSort (fruta)\u003e ["Melón", "calabaza", "albaricoque"]
Aquí vale la pena señalar que localeCompare se usa con argumentos, también debe recordar que es compatible con IE11 +, para versiones anteriores de IE, podemos usarlo sin argumentos y en minúsculas:
Función caseSort (arr) (arr.sort (function (a, b) (return a.toLowerCase (). LocaleCompare (b.toLowerCase ());));) let fruit \u003d ["butternut squash", "apricot", "Cantalupo"]; caseSort (fruta)\u003e ["albaricoque", "calabaza", "Melón"]
Orden numérico
Todo esto no se aplica al ejemplo del que hablamos anteriormente sobre la matriz de registros del juego. Con algunas matrices numéricas, la clasificación funciona bien, pero en algún momento el resultado puede ser impredecible:Deje highScores \u003d; highScores.sort (); \u003e
El hecho es que el método sort () realiza una comparación lexicográfica: lo que significa que los números se convertirán en una cadena y las comparaciones se realizarán nuevamente al hacer coincidir el primer carácter de esta cadena en el orden de caracteres de la tabla Unicode. Por lo tanto, nuevamente necesitamos definir nuestro orden de clasificación:
Deje highScores \u003d; highScores.sort (función (a, b) (devolver a - b;)); \u003e
Nuevamente, para ordenar los números en orden inverso, intercambie las posiciones de ayb en la función.
Ordenar una estructura similar a JSON
Finalmente, si tenemos una estructura de datos similar a JSON, representada como una matriz de registros del juego:Sea score \u003d [("name": "Daniel", "score": 21768), ("name": "Michael", "score": 33579), ("name": "Alison", "score": 38395 )];
En ES6 +, puede utilizar las funciones de flecha:
Scores.sort ((a, b) \u003d\u003e b.score - a.score));
Para navegadores más antiguos que no tienen este soporte:
Scores.sort (función (a, b) (devuelve a.score - b.score));
Como puede ver, ordenar en JavaScript no es algo obvio, espero que estos ejemplos hagan la vida más fácil de alguna manera.
Trabajar con funciones de potencia
La exponenciación es una operación originalmente definida como el resultado de la multiplicación múltiple de un número natural por sí mismo, la raíz cuadrada de a es el número que da a cuando se eleva al cuadrado. Podríamos usar estas funciones todo el tiempo en la vida cotidiana en las lecciones de matemáticas, incluso al calcular áreas, volúmenes o incluso en modelos físicos.En JavaScript, la función exponencial se representa como Math.pow (), en el nuevo estándar ES7, se introduce un nuevo operador de exponenciación: "* *".
Exponenciación
Para elevar un número a la enésima potencia, use la función Math.pow (), donde el primer argumento es el número que se elevará a la potencia, el segundo argumento es el exponente:Math.pow (3,2)\u003e 9
Esta forma de notación significa 3 al cuadrado, o 3 × 3, lo que lleva al resultado 9. Por supuesto, puedes dar otro ejemplo:
Math.pow (5.3); \u003e 125
Es decir, 5 al cubo, o 5 × 5 × 5, es igual a 125.
ECMAScript 7 es la próxima versión de JavaScript, en principio, podemos usar el nuevo operador de exponenciación propuesto - * *, esta notación puede ser más descriptiva:
3 ** 2
> 9
Actualmente, el soporte para este operador es bastante limitado, por lo que no se recomienda su uso.
La función de encendido puede resultar útil en una variedad de situaciones. Un ejemplo simple, calculando el número de segundos en una hora: Math.pow (60,2).
Raíz cuadrada y cúbica
Math.sqrt () y Math.cbrt () son lo opuesto a la función Math.pow (). Recuerda que la raíz cuadrada de a es el número que da a cuando se eleva al cuadrado.Math.sqrt (9)\u003e 3
Al mismo tiempo, la raíz cúbica del número a es el número que da a cuando se eleva a un cubo.
Math.cbrt (125)\u003e 5
Math.cbrt () se introdujo en la especificación de JavaScript muy recientemente y, por lo tanto, solo es compatible con los navegadores modernos: Chrome 38+, Firefox y Opera 25+ y Safari 7.1+. Notará que Internet Explorer no está en esta lista, sin embargo, encontrará un polyfill en MDN.
Ejemplos de
Por supuesto, también podemos usar valores no enteros en una de estas funciones:Math.pow (1,25, 2); \u003e 1.5625 Math.cbrt (56.57)\u003e 3.8387991760286138
Tenga en cuenta que esto también funciona bien para valores de argumentos negativos:
Math.pow (-5,2)\u003e 25 Math.pow (10, -2)\u003e 0.01
Sin embargo, para una raíz cuadrada, esto no funcionará:
Math.sqrt (-9)\u003e NaN
Sabemos por análisis matemático que un número imaginario se entiende como las raíces cuadradas de números negativos. Y esto puede llevarnos a otra técnica para trabajar con números complejos, pero esa es otra historia.
Puede usar valores fraccionarios en Math.pow () para encontrar las raíces cuadradas y cúbicas de números. La raíz cuadrada usa un exponente de 0.5:
Math.pow (5, 0.5); // \u003d Math.sqrt (5) \u003d 5 ** (1/2)\u003e 2.23606797749979
Sin embargo, debido a los caprichos del punto flotante, no puede adivinar con precisión el resultado correcto:
Math.pow (2.23606797749979.2)\u003e 5.000000000000001
En tales situaciones, tendrá que recurrir a truncar los signos del número o redondear a algún valor.
Algunos, por alguna razón desconocida en JavaScript, confunden la función Math.pow () con Math.exp (), que es una función exponencial para números en general. Nota: en inglés, "exponent" se traduce como "exponent", por lo que es más probable que se refiera a hablantes de inglés, aunque existen nombres alternativos para el exponente, como índice, potencia.
Constantes matemáticas
Trabajar con matemáticas en JavaScript es más fácil gracias a una serie de constantes integradas. Estas constantes son propiedades del objeto Math. Tenga en cuenta que las constantes se escriben en mayúsculas, no en notación CamelCase.Math.abs, parseInt, parseFloat
Trabajar con números en JavaScript puede ser mucho más complicado de lo que parece. Los valores obtenidos no siempre caen dentro de los rangos esperados, a veces el resultado puede no ser el esperado.Math.abs ()
El método Math.abs () devuelve el valor absoluto de un número, lo que nos recuerda la función matemática análoga para el módulo de un número.Deje newVal \u003d -57.64; Math.abs (newVal); \u003e 57,64
Math.abs (0) siempre devuelve cero, pero si ponemos un signo menos delante de la función -Math.abs (NUM), siempre seremos negativos.
Math.abs (0); \u003e -0
parseInt ()
Sabemos que JavaScript entiende que "15" es una cadena, no un número y, por ejemplo, al analizar las propiedades de CSS usando JavaScript, o al obtener algún valor de una matriz no preparada, nuestros resultados pueden ser impredecibles. Podríamos obtener una cadena representada como "17px" como entrada, y esto no es raro para nosotros. La pregunta es cómo convertir esta cadena en un valor real y usarla en cálculos posteriores.Sintaxis: parseInt (cadena, base);
La función parseInt convierte el primer argumento que se le pasa en una cadena, lo interpreta y devuelve un valor entero o NaN. El resultado (si no es NaN) es un número entero y es el primer argumento (cadena), tratado como un número en el sistema numérico especificado (base). Por ejemplo, la base 10 indica una conversión de decimal, 8 a octal, 16 a hexadecimal, etc. Si la base es mayor que 10, entonces se usan letras para denotar números mayores que 9. Por ejemplo, los números hexadecimales (base 16) usan las letras de la A a la F.
Consideremos un ejemplo de trabajo con propiedades CSS, donde, relativamente hablando, podemos obtener ese valor:
Deje elem \u003d document.body; let centerPoint \u003d window.getComputedStyle (elem) .transformOrigin; \u003e "454px 2087.19px"
Podemos dividir valores por espacios:
Sea centros \u003d centerPoint.split (""); \u003e ["454px", "2087.19px"]
Sin embargo, cada elemento sigue siendo una cadena, podemos deshacernos de esto aplicando nuestra función:
Deje centerX \u003d parseInt (centros, 10); \u003e 454 let centerY \u003d parseInt (centros, 10); \u003e 2087
Como puedes ver, como segundo argumento, te indicamos el sistema numérico al que se convertirá el número, este parámetro es opcional, pero se recomienda usarlo en caso de que no sepas qué cadena vendrá a la entrada.
parseFloat ()
En el ejemplo anterior, es posible que haya notado que parseInt descarta la parte fraccionaria. En nuestro caso, parseFloat puede trabajar con números de punto flotante. Nuevamente, esto puede ser útil al analizar CSS y otras tareas, especialmente cuando se trata de porcentajes de coma flotante.Sintaxis: parseFloat (cadena)
Sea FP \u003d "33.33333%"; console.log (parseFloat (FP)); \u003e 33,33333
Tenga en cuenta que no hay un segundo argumento en la sintaxis parseFloat.
Entendemos que parseInt () y parseFloat () son funciones sumamente útiles, es importante tener en cuenta que no puede estar exento de errores, por lo que es necesario verificar el rango de valores esperados y finalmente analizar el resultado para asegurar que los valores obtenidos sean correctos.
Enviar de forma anónima
Los cálculos a menudo producen resultados que caen fuera de los rangos deseados. Como resultado, debe implementar Redondeo de JavaScript a un cierto valor.
¿Por qué redondear números?
JavaScript no almacena enteros porque sus valores se representan como números de punto flotante. Muchas fracciones no se pueden representar con un número finito de decimales, por lo que JavaScript puede generar resultados como el siguiente:
0.1 * 0.2; > 0.020000000000000004
En la práctica, esto no supondrá ninguna diferencia, ya que estamos hablando de un error de 2 quintillones. Sin embargo, esto puede afectar el resultado al trabajar con números que representan valores de moneda, porcentajes o tamaño de archivo. Por lo tanto, debe hacerlo o con un cierto decimal.
Redondeo de números decimales
Para "recortar" un número decimal, utilice los métodos toFixed () o toPrecision (). Ambos toman un argumento, que especifica el número de lugares decimales y significativos que se incluirán en el resultado:
- si no se define ningún argumento para toFixed (), el valor predeterminado es 0, es decir, no hay decimales; el valor máximo del argumento es 20;
- si no se especifica ningún argumento para toPrecision (), 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
Tanto toFixed () como toPrecision devuelven una representación de cadena redondeada del resultado, no un número. Esto significa que agregar redondeado a randNum resultará en una concatenación de cadenas en lugar de un solo número:
console.log (randNum + redondeado); \u003e "6.256"
Si desea que JavaScript se redondee a la centésima más cercana, use parseFloat ():
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 un gran número de decimales. Esto es útil cuando se trabaja con números que representan unidades monetarias:
var WholeNum \u003d 1 var dólaresCents \u003d wholeNum.toFixed (2); console.log (DollarCents); \u003e "1,00"
Tenga en cuenta que si hay más dígitos en el número que los especificados por el parámetro de precisión, toPrecision devolverá el resultado en formato científico:
var num \u003d 123.435 num.toPrecision (2); \u003e "1.2e + 2"
Cómo evitar errores al redondear decimales
En algunos casos toFixed y toPrecision implementan JavaScript redondeando 5 hacia abajo, y no a más:
var numTest \u003d 1,005; numTest.toFixed (2); \u003e 1;
El ejemplo anterior debería dar como resultado 1.01, no 1. Si desea evitar este error, le recomiendo usar números exponenciales:
función round (valor, decimales) (return Number (Math.round (valor + "e" + decimales) + "e -" + decimales);)
Solicitud:
redondo (1.005.2); \u003e 1.01
Si necesita una solución aún más confiable que el redondeo, está disponible en MDN.
Redondeo de épsilon
Método alternativo Redondeo de JavaScript a décimas fue introducido en ES6 ( también conocido como JavaScript 2015). « Epsilon de la máquina»Proporciona un margen de error razonable al comparar dos números de coma flotante. Sin redondeo, las comparaciones pueden producir resultados similares a los siguientes:
0.1 + 0.2 \u003d\u003d\u003d 0.3\u003e falso
Math.EPSILON se puede utilizar en una función para obtener una comparación correcta:
función epsEqu (x, y) (devuelve Math.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 es el resultado esperado (redondeado). Devuelve una comparación de estos dos parámetros:
epsEqu (0.1 + 0.2, 0.3)\u003e verdadero
Todos los navegadores modernos admiten funciones matemáticas ES6. Pero si necesita brindar soporte en navegadores más antiguos, entonces debe usar polyfills.
Truncar números decimales
Todos los métodos presentados anteriormente realizan Redondeo de JavaScript a décimas... Para truncar un número positivo a dos lugares decimales, multiplíquelo por 100, vuelva a truncarlo y luego divida el resultado por 100, necesita:
función truncada (num) (return Math.trunc (num * 100) / 100;) truncada (3.1416)\u003e 3.14
Si necesita algo más flexible, puede usar el operador bit a bit:
function truncated (num, decimalPlaces) (var numPowerConverter \u003d Math.pow (10, decimalPlaces); return ~~ (num * numPowerConverter) / numPowerConverter;)
Utilizando:
var randInt \u003d 35,874993; truncado (randInt, 3); \u003e 35.874
Redondea al número más cercano
Llevar a cabo Redondeo de JavaScript a entero, utilizado por Math.round ():
Ronda matemática (4.3)\u003e 4 Ronda matemática (4.5)\u003e 5
Tenga en cuenta que " valores medios“Por ejemplo, .5 se redondean.
Redondea al número entero más cercano
Si desea redondear hacia abajo, use el método Math.floor ():
Math.floor (42,23); \u003e 42 Piso matemático (36,93); \u003e 36
El redondeo hacia abajo tiene una dirección para todos los números, incluidos los negativos. Esto se puede imaginar como un rascacielos con un número infinito de pisos, incluso por debajo del nivel de los cimientos ( representando números negativos). Si está en el ascensor entre los pisos 2 y 3 del sótano ( que corresponde a un valor de -2,5), Math.floor lo llevará al piso -3:
Math.floor (-2,5); \u003e -3
Si necesita evitar esto, utilice el redondeo matemático de JavaScript con Math.trunc (), que es compatible con todos los navegadores modernos (excepto IE / Edge):
Math.trunc (-41,43); \u003e -41
MDN también proporciona polyfill de 3 líneas para proporcionar compatibilidad con Math.trunc en navegadores antiguos e IE / Edge.
Redondea al número entero más cercano
Si desea redondear números decimales, use Math.ceil. Este método también se puede considerar como un impulso sin fin: Math.ceil siempre lo lleva, 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
Redondea al múltiplo más cercano
Si necesita redondear un valor al múltiplo de 5 más cercano, cree una función que divida el número por 5, lo redondea y luego multiplique el resultado por el mismo valor:
función roundTo5 (num) (return Math.round (num / 5) * 5;)
Utilizando:
roundTo5 (11); \u003e 10
Si necesita JavaScript para redondear a dos dígitos, puede pasar tanto la semilla como la multiplicidad a la función:
función roundToMultiple (num, multiple) (return Math.round (num / multiple) * multiple;)
Para usar la función, incluya el número a redondear y la multiplicidad en su llamada:
var initialNumber \u003d 11; var multiple \u003d 10; roundToMultiple (initialNumber, multiple); \u003e 10;
Para redondear valores solo hacia arriba o hacia abajo, reemplace round con techo o piso en la función.
Ajuste de rango
A veces es necesario obtener el valor de x, que debe estar dentro de un cierto rango. Por ejemplo, necesitamos un valor entre 1 y 100, pero obtenemos un valor de 123. Para arreglar esto, uno puede 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 clamped \u003d Math.max (lowBound, Math.min (numInput, highBound)); console.log (sujeto); \u003e 100;
Puede crear una función o extensión de la clase Número.
los Math.round () La función devuelve el valor de un número redondeado al entero más cercano.
La fuente de este ejemplo interactivo se almacena en un repositorio de GitHub. Si desea contribuir al proyecto de ejemplos interactivos, clone https://github.com/mdn/interactive-examples y envíenos una solicitud de extracción.
Sintaxis
Ronda matemática (x)Parámetros
x Un número.Valor devuelto
El valor del número dado redondeado al entero más cercano.
Descripción
Si la parte fraccionaria del argumento es mayor que 0,5, el argumento se redondea al número entero con el siguiente valor absoluto más alto. Si es menor que 0.5, el argumento se redondea al número entero con el valor absoluto más bajo. Si la porción fraccionaria es exactamente 0.5, el argumento se redondea al siguiente entero en la dirección de + ∞. Tenga en cuenta que esto difiere de las funciones round () de muchos idiomas, que a menudo redondean este caso al siguiente entero lejos de cero , en lugar de dar un resultado diferente en el caso de números negativos con una parte fraccionaria de exactamente 0,5.
Debido a que round () es un método estático de Math, siempre lo usa como Math.round (), en lugar de como un método de un objeto Math que creó (Math no tiene constructor).
Ejemplos
Ronda de matemáticas (20,49); // 20 Ronda matemática (20.5); // 21 Ronda matemática (42); // 42 Math.round (-20.5); // -20 Math.round (-20.51); // -21Implementación demostrativa
A continuación se muestra un fragmento de código que es funcionalmente equivalente a math.round, excepto que el fragmento de código a continuación es más lento que Math.round. El propósito del fragmento de código a continuación es demostrar cómo funciona Math.round.
Función vanilla_round (x) (var y \u003d Math.abs (x) + 0.5; // de modo que menos de 1/2 redondea hacia abajo; mayor redondea hacia arriba return Math.floor (x + 0.5))
El operador de módulo anterior obtiene la parte decimal de x. Además, el fragmento de código anterior podría modificarse para redondear a una cierta precisión en un número:
Función round_to_precision (x, precisión) (var y \u003d + x + (precisión \u003d\u003d\u003d indefinido? 0.5: precisión / 2); return y - (y% (precisión \u003d\u003d\u003d indefinido? 1: + precisión));)
Ronda_a_precisión (11, 2); // genera 12 round_to_precision (11, 3); // genera 12 round_to_precision (11, 4); // genera 12 round_to_precision (11, 5); // genera 10 round_to_precision (11, 6); // genera 12 round_to_precision (11, 7); // genera 14 round_to_precision (11, 8); // genera 8 round_to_precision (3.7, 0.5); // genera 3.5 round_to_precision (3.75, 0.5); // genera 4 round_to_precision (3.8, 0.5); // salidas 4
Especificaciones
| Especificación | Estado | Comentario |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Estándar | Definición inicial. Implementado en JavaScript 1.0. |
| ECMAScript 5.1 (ECMA-262) |
Estándar | |
| ECMAScript 2015 (6.a edición, ECMA-262) La definición de "Math.round" en esa especificación. |
Estándar | |
| Borrador más reciente de ECMAScript (ECMA-262) La definición de "Math.round" en esa especificación. |
Sequía |
Compatibilidad del navegador
La tabla de compatibilidad de esta página se genera a partir de datos estructurados. Si desea contribuir con los datos, consulte https://github.com/mdn/browser-compat-data y envíenos una solicitud de extracción.
Actualizar datos de compatibilidad en GitHub
| Escritorio | Móvil | Servidor | |||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| Cromo | Borde | Firefox | explorador de Internet | Ópera | Safari | Vista web de Android | Chrome para Android | Firefox para Android | Opera para Android | Safari en iOS | Internet de Samsung | Node.js | |
| redondo | Soporte completo de Chrome 1 | Soporte completo de Edge 12 | Soporte completo de Firefox 1 | IE Soporte completo 3 | Opera Soporte completo Sí | Safari Soporte completo Sí | WebView Android Soporte completo 1 | Compatibilidad total con Chrome Android 18 | Soporte completo de Firefox Android 4 | Opera Android Soporte completo Sí | Safari iOS Soporte completo Sí | Samsung Internet Android Soporte completo 1.0 | nodejs Soporte completo Sí |
Ahora veamos el método del piso. (traducido como género)que funciona al contrario del método ceil, es decir él redondea un número fraccionario.
Como puede ver, el método del piso redondeó 35,97 hacia abajo a 35, que es hacia abajo. Aunque 0.97 es mayor que 0.5 (cm. ).
Esta lección cubrió los métodos del objeto Math, permitiendo redondear números decimales fraccionarios.
Ahora tienes que hacer tu tarea.
Su 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 "suelo".
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 especificado en el segundo parámetro del objeto Math.
Matriz de origen:
var numberArray \u003d;
Al principio, la solución a este problema puede parecer casi idéntica a las soluciones a los problemas domésticos de las tres primeras lecciones de este tema. Pero no todo es tan sencillo ...
Solución # 1 - Atención
Por la condición del problema la función debe tomar dos parámetros - la matriz original y uno de los métodos: "redondo", "techo" o "piso". Basado en esto, yo traté de hacerlo...
En esta solución, creamos una función con dos parámetros, y cuando la llamamos, intentamos especificar la matriz original y el NOMBRE de un método como parámetros de la función:
decimal (numberArray, round) - en este caso round.
Pero no obtendremos el resultado, ya que NO especifique un método NAME como parámetro de función.
Preste atención: no es casualidad que los nombres de los métodos "redondo", "techo" y "piso" entre comillas.
decimal (numberArray, "round") - ¡¡¡pero esto tampoco será correcto !!!
Solución # 2 - Corrija la solución anterior
Puede resolver el problema especificando un parámetro para la función.
35 - Elemento redondeado
13 - Elemento redondeado
17 - Elemento redondeado
79 - Elemento redondeado
Aquí logramos el resultado deseado: el método redondo redondeó todos los números en. Pero la condición no se cumpleya que la función solo toma un parámetro.
Solución n. ° 3: función con dos parámetros
Aquí el problema se resuelve correctamente. Para hacer esto, tenía que recordar el tema de las condiciones en javascript y aplicar varias condiciones al mismo tiempo.
34.82 - el elemento original de la matriz
35 - redondear
12.9 - el elemento original de la matriz
13 - redondear
17.01 - el elemento original de la matriz
18 - redondear
78.51 - el elemento original de la matriz
79 - redondear
eso solución correcta Deberes. Aquí, se especifican dos parámetros para la función según la condición.
Pruebe 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 de solicitud
Decidí modificar un poco la solución anterior y agregué un método de solicitud que invoca una 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 round, floor o ceil en el campo de entrada y obtener el resultado correspondiente.
Así es como funcionan los métodos round, floor o ceil del objeto Math, que redondean los números decimales.
