Javascript a la función fija

Question

Tengo una pregunta con respecto a la función Fijo(). Si tengo un flotador, p. - 3.123123423 y . ¿Cómo puedo enviarlo a la casilla de entrada con a Fijo (2) para que los valores de la casilla de entrada sean 3.12 y . Es decir, si el valor es un número entero que quiero sin salida detrás 0,00 :)

Answer 1

Como no hay diferencia entre números enteros y flota en JavaScript, aquí está mi enfoque quick'n'dirty:

theNumber.toFixed(2).replace(".00", ""); 

O algo genérico:

myToFixed = function (n, digits) { 
    digits = digits || 0; 
    return n.toFixed(digits).replace(new RegExp("\\.0{" + digits + "}"), ""); 
} 

myToFixed(32.1212, 2) --> "32.12" 
myToFixed(32.1212, 0) --> "32" 
myToFixed(32, 2) --> "32" 
myToFixed(32.1, 2) --> "32.10" 

Answer 2

function toFixed0d(x, d) 
{ 
    if(Math.round(x) == x) 
    { 
     return x.toString(); 
    }else 
    { 
     return x.toFixed(d); 
    } 
} 

toFixed0d(3.123123423, 2) = "3.12" 
toFixed0d(0, 2) = "0" 

Answer 3

no es necesario Math.round():

var toFixed = function(val, n) { 
    var result = val.toFixed(n); 
    if (result == val) 
    return val.toString(); 
    return result; 
} 

toFixed(3.123, 2) --> "3.12" 
toFixed(3, 2) --> "3" 

Answer 4

Tenga en cuenta que toFixed() es broken in IE y generalmente no es confiable. Funciones de reemplazo molestas pero redondeadas dadas allí.

Answer 5

Los resultados pueden variar en el caso de otros navegadores. Así que por favor consulte este enlace How to write a prototype for Number.toFixed in JavaScript?

Answer 6

Aquí es una función que se me ocurrió después de pensar en este mismo problema por un rato:

function toFixed (number, n) { 
    return parseFloat(number.toFixed(n)); 
} 

De acuerdo con esta pregunta, esta función devolverá la siguiente manera:

toFixed(3.123123423, 2); 
> 3.12 
toFixed(0, 2); 
> 0 
toFixed(3.1, 2); 
> 3.1 
toFixed(3.005, 2); 
> 3 
toFixed(3.005, 3); 
> 3.005 
toFixed(3.0500, 4); 
> 3.05 

Tenga en cuenta que el método de Number objeto del Javascript toFixed vuelve realidad un String. La función toFixed anterior devolverá un Number. Si prefieres tener un String a continuación, utilizar el siguiente lugar:

function toFixed (number, n) { 
    return parseFloat(number.toFixed(n)).toString(); 
} 

Answer 7

Number.toFixed produce algunos resultados matemáticamente extraños y le da los dígitos fraccionarios que solicitó, ya sea que los necesite o no.

Math.round es matemáticamente correcto, pero no le permite especificar una precisión.

Esta es una función que es matemáticamente correcta (sin tener en cuenta los errores de coma flotante) y que le proporciona lo que desea.

var roundToPlusInfinity = function(n, fd) { 
    var scale = Math.pow(10, fd), 
     rounded = fd ? Math.floor((n * scale + 0.5))/scale : 
     Math.round(n); 
    return rounded.toString(); 
}; 

El algoritmo es: Escala de modo que los dígitos que desea están a la izquierda del punto decimal, agregar 0.5 (de modo que> = 0.5 en el primer lugar insignificante provoca un incremento de la parte entera), truncar (¡no es redondo!) Y reducir la escala hacia abajo. Existe la posibilidad de que los errores de coma flotante entren sigilosamente, pero es una vista mejor que la miserable a la función Fijo.

prueba a cabo:

roundToPlusInfinity(5.53335, 4); // "5.3334" 
roundToPlusInfinity(-9999.95, 1); // "-9999.9" 
roundToPlusInfinity(3.00015, 3); // "3" 

Debido a la posibilidad de error de punto flotante, el mínimo de escala podría dar un resultado como "3.00000000001", lo cual es molesto. Algo como esto debería ocuparse de eso.

var trimFraction = function(s, fd) { 
    var splitPoint = s.indexOf('.'); 
    if (splitPoint === -1) { 
     return s; 
    } 

    var f = s.substring(splitPoint + 1, s.length), 
     i = s.substring(0, splitPoint); 
    if (f.length > fd) { 
     f = f.substring(0, fd).replace(/0+$/, ""); 
    } 
    if (f) { 
     return i + '.' + f; 
    } 
    return i; 
}; 

trimFraction("3.1000000001", 2); // "3.1" 

No ha dejado en claro el algoritmo de redondeo que desea. Redondear hacia el infinito más es el redondeo que aprendió en la escuela donde redondea> = .5 hasta (es decir, hacia el infinito positivo). Creo que en la contabilidad, el algoritmo de redondeo correcto (al menos fuera de Suiza y Argentina) está lejos de cero. Simple:

var roundAwayFromZero = function(n, fd) { 
    var ret = roundToPlusInfinity(Math.abs(n), fd); 
    return (n < 0) ? '-' + ret : ret; 
}; 

roundAwayFromZero(-9999.95, 1); // "-10000" 

Si los resultados son para la presentación humano, Intl.NumberFormat es una posibilidad, ya que se puede especificar tanto el número mínimo y máximo de dígitos fraccionarios. En el momento de escribir esto, no es exactamente compatible y, suponiendo que Chrome implemente la especificación correctamente, utiliza el mismo algoritmo de truncado impenetrable e incorrecto que Fiixed. Curiosamente, el estilo de "moneda" usa roundAwayFromZero (o redondea a la mitad si el código de moneda es "CHF", que es un buen toque).