Як округлити до 1 десяткового знака у Javascript?

Чи можете ви округлити число в javascript до 1 символу після десяткової крапки (правильно округленої)?

Я спробував * 10, круглий / 10, але він залишає два десяткові дна в кінці int.

Math.round(num * 10) / 10 працює, ось приклад ...

var number = 12.3456789
var rounded = Math.round(number * 10) / 10
// rounded is 12.3

якщо ви хочете, щоб він мав один десятковий знак, навіть коли це буде 0, додайте ...

var fixed = rounded.toFixed(1)
// fixed is always to 1 d.p.
// NOTE: .toFixed() returns a string!

// To convert back to number format
parseFloat(number.toFixed(2))
// 12.34
// but that will not retain any trailing zeros

// So, just make sure it is the last step before output,
// and use a number format during calculations!

EDIT: Додайте круглий з функцією точності ...

Використовуючи цей принцип, для довідки, ось зручна маленька кругла функція, яка вимагає точності ...

function round(value, precision) {
    var multiplier = Math.pow(10, precision || 0);
    return Math.round(value * multiplier) / multiplier;
}

... використання ...

round(12345.6789, 2) // 12345.68
round(12345.6789, 1) // 12345.7

... за замовчуванням для округлення до найближчого цілого числа (точність 0) ...

round(12345.6789) // 12346

... і може бути використаний для округлення до найближчого 10 або 100 тощо ...

round(12345.6789, -1) // 12350
round(12345.6789, -2) // 12300

... і правильне поводження з від'ємними числами ...

round(-123.45, 1) // -123.4
round(123.45, 1) // 123.5

... і може поєднуватися з toFixed, щоб форматувати послідовно як рядок ...

round(456.7, 2).toFixed(2) // "456.70"

var number = 123.456;

console.log(number.toFixed(1)); // should round to 123.5

Якщо ви використовуєте, Math.round(5.01)ви отримаєте 5замість 5.0.

Якщо ви використовуєте, toFixedви стикаєтеся з проблемами округлення .

Якщо ви хочете найкращого з обох світів, комбінуйте два:

(Math.round(5.01 * 10) / 10).toFixed(1)

Ви можете створити для цього функцію:

function roundedToFixed(_float, _digits){
  var rounded = Math.pow(10, _digits);
  return (Math.round(_float * rounded) / rounded).toFixed(_digits);
}

lodashмає roundметод:

_.round(4.006);
// => 4

_.round(4.006, 2);
// => 4.01

_.round(4060, -2);
// => 4100

Docs .

Джерело .

Я голосую за toFixed(), але, для запису, ось ще один спосіб, який використовує зміщення бітів для передачі числа до int. Отже, він завжди кругообіг до нуля (вниз для позитивних чисел, вгору за негативів).

var rounded = ((num * 10) << 0) * 0.1;

Але ей, оскільки функціональних викликів немає, це нечестиво швидко. :)

І ось такий, який використовує відповідність рядків:

var rounded = (num + '').replace(/(^.*?\d+)(\.\d)?.*/, '$1$2');

Я не рекомендую використовувати варіант рядка, просто скажіть.

Спробуйте з цим:

var original=28.453

// 1.- round "original" to two decimals
var result = Math.round (original * 100) / 100  //returns 28.45

// 2.- round "original" to 1 decimal
var result = Math.round (original * 10) / 10  //returns 28.5

// 3.- round 8.111111 to 3 decimals
var result = Math.round (8.111111 * 1000) / 1000  //returns 8.111

менш складний і простіший у виконанні ...

за допомогою цього ви можете створити функцію:

function RoundAndFix (n, d) {
    var m = Math.pow (10, d);
    return Math.round (n * m) / m;
}

function RoundAndFix (n, d) {
    var m = Math.pow (10, d);
    return Math.round (n * m) / m;
}
console.log (RoundAndFix(8.111111, 3));

РЕДАКТУВАННЯ : див. Як "Закруглення" за допомогою КРУГОЇ ПОЛОВИНИ Вгору. Режим заокруглення, якого більшість із нас навчали в школі

x = число, n = десяткові місця:

function round(x, n) {
    return Math.round(x * Math.pow(10, n)) / Math.pow(10, n)
}

Чому б не просто

let myNumber = 213.27321;
+myNumber.toFixed(1); // => 213.3

1. toFixed : повертає рядок, що представляє задане число, використовуючи позначення з фіксованою точкою.
2. Unary plus (+) : Оператор unary plus передує своєму операнду і оцінює його операнд, але намагається перетворити його в число, якщо його ще немає.

var num = 34.7654;

num = Math.round(num * 10) / 10;

console.log(num); // Logs: 34.8

Щоб заповнити найкращу відповідь:

var round = function ( number, precision )
{
    precision = precision || 0;
    return parseFloat( parseFloat( number ).toFixed( precision ) );
}

Номер вхідного параметра "може" не завжди бути числом, в цьому випадку .toFixed не існує.

ES 6 Версія прийнятого відповіді:

function round(value, precision) {
    const multiplier = 10 ** (precision || 0);
    return Math.round(value * multiplier) / multiplier;
}

Використовуючи метод точності:

var a = 1.2345
a.toPrecision(2)

// result "1.2"

Якщо ваш метод не працює, опублікуйте код, який у вас є.

Однак ви можете виконати завдання округлення як:

var value = Math.round(234.567*100)/100

Дасть вам 234,56

Аналогічно

 var value = Math.round(234.567*10)/10

Дасть 234,5

Таким чином ви можете використовувати змінну замість константи, як було використано вище.

Маленький кутовий фільтр, якщо хто хоче цього:

angular.module('filters').filter('decimalPlace', function() {
    return function(num, precision) {
        var multiplier = Math.pow(10, precision || 0);
        return Math.round(num * multiplier) / multiplier;
    };
});

використовувати якщо через:

{{model.value| decimalPlace}}
{{model.value| decimalPlace:1}}
{{model.value| decimalPlace:2}}

:)

Загалом, округлення проводиться шляхом масштабування: round(num / p) * p

Використовуючи експоненціальні позначення, правильно обробляє округлення + ve чисел. Однак цей метод не зможе правильно закруглювати крайові корпуси.

function round(num, precision = 2) {
	var scaled = Math.round(num + "e" + precision);
	return Number(scaled + "e" + -precision);
}

// testing some edge cases
console.log( round(1.005, 2) );  // 1.01 correct
console.log( round(2.175, 2) );  // 2.18 correct
console.log( round(5.015, 2) );  // 5.02 correct

console.log( round(-1.005, 2) );  // -1    wrong
console.log( round(-2.175, 2) );  // -2.17 wrong
console.log( round(-5.015, 2) );  // -5.01 wrong

Тут також є одна функція, яку я написав, щоб робити арифметичне округлення, ви можете перевірити її самостійно.

/**
 * MidpointRounding away from zero ('arithmetic' rounding)
 * Uses a half-epsilon for correction. (This offsets IEEE-754
 * half-to-even rounding that was applied at the edge cases).
 */

function RoundCorrect(num, precision = 2) {
	// half epsilon to correct edge cases.
	var c = 0.5 * Number.EPSILON * num;
//	var p = Math.pow(10, precision); //slow
	var p = 1; while (precision--> 0) p *= 10;
	if (num < 0)
		p *= -1;
	return Math.round((num + c) * p) / p;
}

// testing some edge cases
console.log(RoundCorrect(1.005, 2));  // 1.01 correct
console.log(RoundCorrect(2.175, 2));  // 2.18 correct
console.log(RoundCorrect(5.015, 2));  // 5.02 correct

console.log(RoundCorrect(-1.005, 2));  // -1.01 correct
console.log(RoundCorrect(-2.175, 2));  // -2.18 correct
console.log(RoundCorrect(-5.015, 2));  // -5.02 correct

Здається, це надійно працює над усім, що я на це кидаю:

function round(val, multiplesOf) {
  var s = 1 / multiplesOf;
  var res = Math.ceil(val*s)/s;
  res = res < val ? res + multiplesOf: res;
  var afterZero = multiplesOf.toString().split(".")[1];
  return parseFloat(res.toFixed(afterZero ? afterZero.length : 0));
}

Він округляється, тому вам може знадобитися змінити його відповідно до регістру використання. Це має працювати:

console.log(round(10.01, 1)); //outputs 11
console.log(round(10.01, 0.1)); //outputs 10.1

Якщо ви дбаєте про правильне округлення, виконайте такі дії:

function roundNumericStrings(str , numOfDecPlacesRequired){ 
     var roundFactor = Math.pow(10, numOfDecPlacesRequired);  
     return (Math.round(parseFloat(str)*roundFactor)/roundFactor).toString();  }

Ще якщо ви цього не зробите, у вас уже є відповідь з попередніх дописів

str.slice(0, -1)

Math.round( num * 10) / 10 не працює.

Наприклад, 1455581777.8-145558160.4дає вам 1310023617.3999999.

Тож використовуйте тільки num.toFixed(1)

Я зробив такий, який повертає числовий тип, а також розміщує десяткові знаки лише за потреби (немає 0 прокладки).

Приклади:

roundWithMaxPrecision(11.234, 2); //11.23
roundWithMaxPrecision(11.234, 1); //11.2
roundWithMaxPrecision(11.234, 4); //11.23
roundWithMaxPrecision(11.234, -1); //10

roundWithMaxPrecision(4.2, 2); //4.2
roundWithMaxPrecision(4.88, 1); //4.9

Код:

function roundWithMaxPrecision (n, precision) {
    return Math.round(n * Math.pow(10, precision)) / Math.pow(10, precision);
}

Я знайшов спосіб уникнути проблем із точністю:

function badRound (num, precision) {
    const x = 10 ** precision;
    return Math.round(num * x) / x
}
// badRound(1.005, 2) --> 1

function round (num, precision) {
    const x = 10 ** (precision + 1);
    const y = 10 ** precision;
    return Math.round(Math.round(num * x) / 10) / y
}
// round(1.005, 2) --> 1.01

Math.round( mul/count * 10 ) / 10

Math.round(Math.sqrt(sqD/y) * 10 ) / 10

Дякую