Home / Questions / 48958
Accepted
Rubén
Asked: 2020-02-12 05:26:33 +0800 CST 2020-02-12 05:26:33 +0800 CST

При необходимости округлить до двух знаков после запятой

  • 772

Я хотел бы округлить до двух знаков после запятой, только когда это необходимо . Вот примеры входов и выходов

Вход:

10
1.7777777
9.1

Вылет из:

10
1.78
9.1

Как я могу сделать это в JavaScript?

Фрагмент

var valor = [
  10,
  1.77777777,
  9.1
];
var resultado = valor.map(Math.round);
console.log(resultado);

Вопрос, вдохновленный Округлением не более чем до 2 знаков после запятой

javascript

8 Answers

  1. Вы также можете использовать метод toFixed() , хотя он преобразует число в строку, и вам придется использовать функцию Number() :

    var numero = 1.77777777;
numero = Number(numero.toFixed(2));
console.log(numero); // Muestra 1.78

    Недостатком является то, что он оставляет 0, если число не содержит десятичных знаков или меньше, чем параметр, переданный toFixed(). Эта небольшая функция устраняет эту проблему:

    function redondearDecimales(numero, decimales) {
    numeroRegexp = new RegExp('\\d\\.(\\d){' + decimales + ',}');   // Expresion regular para numeros con un cierto numero de decimales o mas
    if (numeroRegexp.test(numero)) {         // Ya que el numero tiene el numero de decimales requeridos o mas, se realiza el redondeo
        return Number(numero.toFixed(decimales));
    } else {
        return Number(numero.toFixed(decimales)) === 0 ? 0 : numero;  // En valores muy bajos, se comprueba si el numero es 0 (con el redondeo deseado), si no lo es se devuelve el numero otra vez.
    }
}



console.log(redondearDecimales(1.777, 2));       // Devuelve 1.78
console.log(redondearDecimales(1, 2));           // Devuelve 1
console.log(redondearDecimales(1.7777, 3));      // Devuelve 1.778
console.log(redondearDecimales(0.0000007, 2));   // Devuelve 0
console.log(redondearDecimales(0.0000007, 7));   // Devuelve 7e-7
console.log(redondearDecimales(-1.3456, 2));     // Devuelve -1.35

    • 8
  2. Best Answer

    Эти две функции соответствуют всем проведенным испытаниям.

    1. Адаптировано из MDN ( рекомендуемое решение )

    Взяв код из Decimal Rounding , я адаптировал решение так, чтобы оно выполняло симметричное арифметическое округление с отрицательными числами. То есть округлить -1,5 ≈ -2.

    function round(num, decimales = 2) {
    var signo = (num >= 0 ? 1 : -1);
    num = num * signo;
    if (decimales === 0) //con 0 decimales
        return signo * Math.round(num);
    // round(x * 10 ^ decimales)
    num = num.toString().split('e');
    num = Math.round(+(num[0] + 'e' + (num[1] ? (+num[1] + decimales) : decimales)));
    // x * 10 ^ (-decimales)
    num = num.toString().split('e');
    return signo * (num[0] + 'e' + (num[1] ? (+num[1] - decimales) : -decimales));
}


    2. Использование Intl.NumberFormat()

    Функция Intl.NumberFormat([locales[, options]])позволяет правильно округлить число с помощью собственного кода. Однако, как будет видно позже, эта функция принимает параметры, зависящие от языка, что значительно замедляет ее работу.

    function intlRound(numero, decimales = 2, usarComa = false) {
    var opciones = {
        maximumFractionDigits: decimales, 
        useGrouping: false
    };
    usarComa = usarComa ? "es" : "en";
    return new Intl.NumberFormat(usarComa, opciones).format(numero);
}

    Возвращает строку с представлением числа, округленного до максимального установленного числа десятичных знаков. Если вы хотите обратно преобразовать в число, примените parseFloat()к результату.


    Обсуждение

    При манипулировании числами путем выполнения операций с плавающей запятой существует ограничение на их точное представление. JavaScript использует 64-битное представление с плавающей запятой с соответствующими ограничениями. Дополнительные сведения см. в статье Почему мои программы не могут правильно выполнять арифметические операции? .

    Это означает, что существуют числа, для которых их представление создает проблемы для правильного округления . Однако методы, используемые в этом ответе, решают эти проблемы.

    Кроме того, есть еще одно специфическое поведение, которого избегают: Math.round() округляет 5 в первой незначащей позиции отрицательного значения до 0 .

    Math.round( 1.5); // ==  2
Math.round(-1.5); // == -1   -problema!
Math.round(-1.6); // == -2
Math.round( 0.5); // ==  1
Math.round(-0.5); // == -0   -sí, "-0"

    В следующем тесте было исправлено округление отрицательных чисел, Math.round()и сравниваются случаи, в которых каждое из них может дать сбой.


    Результаты каждого ответа:

    /* -----------------------------------------------------------
 *            Funciones de cada respuesta
 * ----------------------------------------------------------- */
function roundNumber (number, max = 2) {
  //Respuesta de Guz
  let fractionalPart = number.toString().split('.')[1];
  
  if (!fractionalPart || fractionalPart.length <= 2) {
    return number;
  }
  
  return Number(number.toFixed(max));
}

function mathRound (num) {
  //Respuesta de Rubén
  return Math.round(num * 100) / 100 ;
}

function mathRound2 (num, decimales = 2) {
  //Respuesta de Rubén modificada por mí para el caso general y números negativos
  var exponente = Math.pow(10, decimales);
  return (num >= 0 || -1) * Math.round(Math.abs(num) * exponente) / exponente;
}

function redondearDecimales (numero, decimales = 2) {
    //Respuesta de Enrique B.
    numeroRegexp = new RegExp('\\d\\.(\\d){' + decimales + ',}');
    if (numeroRegexp.test(numero)) {
        return Number(numero.toFixed(decimales));
    } else {
        return Number(numero.toFixed(decimales)) === 0 ? 0 : numero;
    }
}

function redondear(x, decimales = 2)
{   //Respuesta de ArtEze
	var texto=x+""
	var poco=texto.search("e-")
	if(poco>=0)
	{
		var decimales_salida=texto.slice(poco+2)*1
		return decimales<decimales_salida?0:x
	}
	var mucho=texto.search("e+")
	if(mucho>=0)
	{
		return x
	}
	var punto=texto.search("\\.")
	var cortado=texto.slice(0,punto+decimales+2)
	var longitud=cortado.length
	var decimales_ingresado=longitud-punto-1
	for(var i=decimales_ingresado;i<=decimales;i++)
	{
		cortado+="0"
	}
	longitud=cortado.length
	var último=cortado.slice(longitud-1)
	var anteúltimo=cortado.slice(longitud-2,longitud-1)
	if(último*1>=5)
	{
		anteúltimo=(anteúltimo*1)+1
	}
	cortado=cortado.slice(0,longitud-2)+""+anteúltimo
	return cortado*1
}

function intlRound (numero, decimales = 2, usarComa = false) {
    //Esta respuesta
    var opciones = {
        maximumFractionDigits: decimales, 
        useGrouping: false
    };
    return new Intl.NumberFormat((usarComa ? "es" : "en"), opciones).format(numero);
}

function round(num, decimales = 2) {
    var signo = (num >= 0 ? 1 : -1);
    num = num * signo;
    if (decimales === 0) //con 0 decimales
        return signo * Math.round(num);
    // round(x * 10 ^ decimales)
    num = num.toString().split('e');
    num = Math.round(+(num[0] + 'e' + (num[1] ? (+num[1] + decimales) : decimales)));
    // x * 10 ^ (-decimales)
    num = num.toString().split('e');
    return signo * (num[0] + 'e' + (num[1] ? (+num[1] - decimales) : -decimales));
}




/* -----------------------------------------------------------
 *            PRUEBAS
 * ----------------------------------------------------------- */
 
let funciones = [roundNumber, mathRound, mathRound2, redondearDecimales, redondear, intlRound, round],
    pruebas = [
     	["Básica", 1.445, 1.45],
        ["Negativo", -1.445, -1.45],
        ["Nueves", 1.997, 2],
        ["Número grande", 1.1e+21, 1.1e+21],
        ["Número chico", 0.0000007, 0],
        ["Número chico != 0", [9e-8,7], 1e-7],
        ["Problema con coma flotante", 1.005, 1.01]
    ],
    resultado = [];

pruebas.forEach(function(prueba){
    let numero    = prueba[1],
        esperado  = prueba[2],
        resPrueba = [prueba[0]+" ("+numero+" ⟶ "+esperado+")"];
    funciones.forEach(function(funcion){
        let devuelto = (typeof numero == 'number' ? funcion(numero) : funcion(...numero));
        if (devuelto == esperado) {
            resPrueba.push("✔ "+funcion.name);
        } else {
            resPrueba.push("❌ "+funcion.name+" ("+devuelto+")");
        }
    });
    resultado.push(resPrueba.join("\n\t"));
});

document.getElementById("resultado")
    .innerText = resultado.join("\n");
    <pre id="resultado"></pre>


    Однако эффективность имеет свой компромисс с производительностью (см. тест ).

    +--------------------+-----------+
|      Función       |  Ops/seg  |
+--------------------+-----------+
| mathRound          | 2,387,155 |
| mathRound2         | 1,531,698 |
| roundNumber        |   114,499 |
| redondear2         |   180,980 |
| redondearDecimales |    83,631 |
| round              |    50,800 |
| intlRound          |     2,243 |
+--------------------+-----------+
                      *Chrome 55


    В заключение:

    • Решение с Math.round()является самым быстрым, но оно не работает с отрицательными значениями и имеет проблемы с точностью с плавающей запятой.
    • Изменение его как mathRound2()(в этом же ответе) расширило его до общего случая и устранило ошибку с отрицательными значениями. Он по-прежнему быстрее остальных, но по-прежнему не устраняет ошибку точности .
    • Решение с Intl.NumberFormat()этим ответом возвращает правильный результат во всех случаях, но значительно медленнее, чем другие.
    • Решение round()десятичного округления — это то, которое, пройдя все тесты, работает лучше всего . Он значительно медленнее, чем mathRound2(), но по-прежнему выполняет 50 тыс. операций в секунду, что более чем приемлемо для многих сценариев, поэтому его рекомендуется использовать в общем случае, когда требуется точный ответ без ошибок округления.
    • 6

  3. Короткий ответ

    ИспользованиеMath.round(valor * 100) / 100

    Объяснение

    Этот ответ включен в качестве популярного решения, однако он вносит ошибку округления, которая может быть или не быть актуальной. Чтобы углубиться в это, см. Math.round()

    Фрагмент

    var valor = [
  10,
  1.77777777,
  9.1
];
var resultado = valor.map(function(num){
  return Math.round(num * 100) / 100 ;
});
console.log(resultado);

    Ответ, вдохновленный ответом на Округление не более чем до 2 знаков после запятой

    • 4

  4. Чтобы решить эту проблему, я подумал о том, чтобы преобразовать число в строку и после его обработки преобразовать обратно в число. Процесс заключается в разделении числа только тогда, когда появляется точка.ee-e+

    e+Если ни один из них не существует e-, находит точку, разрывает текст в позиции, которая является суммой места точки и количества десятичных знаков. Это также оставляет дополнительное пространство, которое будет иметь решающее значение при приближении числа. Этот последний символ, если он равен или больше 5, увеличивается на 1, предпоследний десятичный знак.

    Иногда то, что вводится, имеет несколько знаков после запятой, и мы хотим выполнить аппроксимацию с большим количеством знаков после запятой, но это не проблема, так как мы можем дополнить число нулями справа и продолжить обработку в обычном режиме.

    Код:

    function redondear(x,decimales)
{
	var texto=x+""
	var poco=texto.search("e-")
	if(poco>=0)
	{
		var decimales_salida=texto.slice(poco+2)*1
		return decimales<decimales_salida?0:x
	}
	var mucho=texto.search("e+")
	if(mucho>=0)
	{
		return x
	}
	var punto=texto.search("\\.")
	var cortado=texto.slice(0,punto+decimales+2)
	var longitud=cortado.length
	var decimales_ingresado=longitud-punto-1
	for(var i=decimales_ingresado;i<=decimales;i++)
	{
		cortado+="0"
	}
	longitud=cortado.length
	var último=cortado.slice(longitud-1)
	var anteúltimo=cortado.slice(longitud-2,longitud-1)
	if(último*1>=5)
	{
		anteúltimo=(anteúltimo*1)+1
	}
	cortado=cortado.slice(0,longitud-2)+""+anteúltimo
	return cortado*1
}
var lista=[1.445, -1.445, 1.1e+21, 0.0000007, 1.005]
for(var i=0;i<lista.length;i++)
{
	var actual=redondear(lista[i],2)
	console.log(lista[i],actual)
}

    • 4

  5. Существует множество способов округления числа, а также различные формы округления. Классическое округление (увеличение на одну единицу, когда дробная часть >= 5) может быть выполнено с помощью Math.roundили, если округляется только дробная часть, вы можете использовать toFixed.

    Пример

    /**
 * Redondea la parte fraccionaria de un número
 * solo cuando ésta es mayor a 2 dígitos.
 *
 * @param {number} number: número a redondear
 * @param {number} max: máximo de dígitos fraccionales
 */
function roundNumber (number, max = 2) {
  if (typeof number !== 'number' || isNaN(number)) {
    throw new TypeError('Número inválido: ' + number);  
  }
  
  if (typeof max !== 'number' || isNaN(max)) {
    throw new TypeError('Máximo de dígitos inválido: ' + max); 
  }
  
  let fractionalPart = number.toString().split('.')[1];
  
  if (!fractionalPart || fractionalPart.length <= 2) {
    return number;
  }
  
  return Number(number.toFixed(max));
}

/* Pruebas */
try {
  console.log(roundNumber(3.4589));
  console.log(roundNumber(0));
  console.log(roundNumber(2.42498, 3));
  console.log(roundNumber(NaN, 2));
  console.log(roundNumber(5.38024, null));
} catch (e) {
   console.error('Ups, ha ocurrido un error: ', e.message); 
}

    • 2

  6. Просто, понятно, красиво и точно.

    function redondear(valor, digitos){
    const base = 10**digitos;
    const precioxBase = valor*base;

    const rPrecioxBase = Math.round(precioxBase);

    const precioFinal = rPrecioxBase/base;
    return precioFinal;   
}
    • 0

  7. Пожалуйста, взгляните на этот простой пример и убедитесь, что это то, что вам нужно.

    // b contiene un float
var b= 1.7777777;
// con toFixed delimitamos a 2 decimales pero 
//tambien hace el redondeo, es decir lo deja en 1,78
b= b.toFixed(2);
console.log(b); //lo hace bien pero es un string
console.log(typeof b); //comprobamos que es un string

b= parseFloat(b);//lo pasamos a float
console.log(b);//comprobamos
console.log(typeof b);//verificamos que es un float

    • -1

  8. Вы просто умножаете на 100, делаете Math.round и делите на 100

    let numero = 5.55555555 
numeroRedondeado = Math.round(numero*100)/100
console.log(numeroRedondeado)//5.56
    • -1