¿Cómo redondear un número con una precisión de décimas en Javascript?

Quiero usar Javascript para redondear un número. Dado que el número es moneda, quiero que se redondee como en estos ejemplos (2 puntos decimales):

• 192.168 => 192.20
• 192.11 => 192.20
• 192.21 => 192.30
• 192.26 => 192.30
• 192.20 => 192.20

¿Cómo lograr esto usando Javascript? La función incorporada de Javascript redondeará el número según la lógica estándar (menos y más de 5 para redondear).

/**
 * @param num The number to round
 * @param precision The number of decimal places to preserve
 */
function roundUp(num, precision) {
  precision = Math.pow(10, precision)
  return Math.ceil(num * precision) / precision
}

roundUp(192.168, 1) //=> 192.2

El redondeo normal funcionará con un pequeño ajuste:

Math.round(price * 10)/10

y si desea mantener un formato de moneda, puede usar el método Número .toFixed()

(Math.round(price * 10)/10).toFixed(2)

Aunque esto lo convertirá en una cadena =)

Un poco tarde, pero puede crear una función javascript reutilizable para este propósito:

// Arguments: number to round, number of decimal places
function roundNumber(rnum, rlength) { 
    var newnumber = Math.round(rnum * Math.pow(10, rlength)) / Math.pow(10, rlength);
    return newnumber;
}

Llame a la función como

alert(roundNumber(192.168,2));

muy cerca de El ojo respuesta, pero cambio una pequeña cosa para que funcione:

var num = 192.16;
    
console.log(    Math.ceil(num * 10) / 10    );

El OP espera dos cosas:
A. para redondear a los décimos superiores, y
B. para mostrar un cero en el lugar de las centésimas (una necesidad típica con la moneda).

El cumplimiento de ambos requisitos parece requerir un método separado para cada uno de los anteriores. Aquí hay un enfoque que se basa en la respuesta sugerida por suryakiran:

//Arguments: number to round, number of decimal places.

function roundPrice(rnum, rlength) {
    var newnumber = Math.ceil(rnum * Math.pow(10, rlength-1)) / Math.pow(10, rlength-1);
    var toTenths = newnumber.toFixed(rlength);
    return toTenths;
}

alert(roundPrice(678.91011,2)); // returns 679.00
alert(roundPrice(876.54321,2)); // returns 876.60

Nota importante: esta solución produce un resultado muy diferente con números negativos y exponenciales.

En aras de la comparación entre esta respuesta y dos que son muy similares, consulte los siguientes 2 enfoques. El primero simplemente redondea a la centésima más cercana como de costumbre, y el segundo simplemente redondea a la centésima más cercana (más grande).

function roundNumber(rnum, rlength) { 
    var newnumber = Math.round(rnum * Math.pow(10, rlength)) / Math.pow(10, rlength);
    return newnumber;
}

alert(roundNumber(678.91011,2)); // returns 678.91

function ceilNumber(rnum, rlength) { 
    var newnumber = Math.ceil(rnum * Math.pow(10, rlength)) / Math.pow(10, rlength);
    return newnumber;
}

alert(ceilNumber(678.91011,2)); // returns 678.92

ok, esto ha sido respondido, pero pensé que te gustaría ver mi respuesta que llama al math.pow() funcionar una vez. Supongo que me gusta mantener las cosas SECA.

function roundIt(num, precision) {
    var rounder = Math.pow(10, precision);
    return (Math.round(num * rounder) / rounder).toFixed(precision)
};

De alguna manera lo pone todo junto. Reemplazar Math.round() con Math.ceil() para redondear en lugar de redondear, que es lo que quería el OP.

esta función limita decimal sin número redondo

function limitDecimal(num,decimal){
     return num.toString().substring(0, num.toString().indexOf('.')) + (num.toString().substr(num.toString().indexOf('.'), decimal+1));
}