Làm thế nào để bạn làm tròn đến 1 chữ số thập phân trong Javascript?

Bạn có thể làm tròn một số trong javascript thành 1 ký tự sau dấu thập phân (được làm tròn đúng) không?

Tôi đã thử * 10, tròn, / 10 nhưng nó để lại hai số thập phân ở cuối int.

Math.round(num * 10) / 10 hoạt động, đây là một ví dụ ...

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

nếu bạn muốn nó có một chữ số thập phân, ngay cả khi đó là 0, thì hãy thêm ...

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: Thêm vòng với chức năng chính xác ...

Sử dụng nguyên tắc này, để tham khảo, đây là một hàm tròn nhỏ tiện dụng có độ chính xác ...

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

... sử dụng ...

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

... mặc định làm tròn đến số nguyên gần nhất (độ chính xác 0) ...

round(12345.6789) // 12346

... và có thể được sử dụng để làm tròn đến 10 hoặc 100 gần nhất, v.v ...

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

... và xử lý chính xác các số âm ...

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

... và có thể được kết hợp với toFixed để định dạng nhất quán dưới dạng chuỗi ...

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

var number = 123.456;

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

Nếu bạn sử dụng, Math.round(5.01)bạn sẽ nhận được 5thay vì 5.0.

Nếu bạn sử dụng toFixedbạn chạy vào các vấn đề làm tròn .

Nếu bạn muốn tốt nhất của cả hai thế giới kết hợp cả hai:

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

Bạn có thể muốn tạo một chức năng cho việc này:

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

lodashcó một roundphương pháp:

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

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

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

Tài liệu .

Nguồn .

Tôi bỏ phiếu cho toFixed(), nhưng, đối với bản ghi, đây là một cách khác sử dụng dịch chuyển bit để chuyển số thành int. Vì vậy, nó luôn luôn làm tròn về số 0 (giảm cho số dương, tăng cho số âm).

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

Nhưng này, vì không có chức năng gọi, nên nó rất nhanh. :)

Và đây là một trong đó sử dụng khớp chuỗi:

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

Tôi không khuyên bạn nên sử dụng biến thể chuỗi, chỉ cần nói.

Hãy thử với điều này:

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

ít phức tạp hơn và dễ thực hiện hơn ...

với điều này, bạn có thể tạo một hàm để làm:

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));

EDIT : xem phần này Cách làm tròn bằng ROUND HALF UP. Chế độ làm tròn mà hầu hết chúng ta được dạy ở trường

x = số, n = số thập phân:

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

Tại sao không chỉ

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

1. toFixed : trả về một chuỗi biểu thị số đã cho bằng cách sử dụng ký hiệu điểm cố định.
2. Unary plus (+) : Toán tử unary plus có trước toán hạng của nó và đánh giá thành toán hạng của nó nhưng cố gắng chuyển đổi nó thành một số, nếu nó chưa có.

var num = 34.7654;

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

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

Để hoàn thành câu trả lời hay nhất:

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

Số tham số đầu vào có thể "không" luôn luôn là một số, trong trường hợp này .toFixed không tồn tại.

Phiên bản ES 6 của câu trả lời được chấp nhận:

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

Sử dụng phương pháp toPrecision:

var a = 1.2345
a.toPrecision(2)

// result "1.2"

Nếu phương pháp của bạn không hoạt động, xin vui lòng gửi mã của bạn.

Tuy nhiên, bạn có thể hoàn thành nhiệm vụ làm tròn như:

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

Sẽ cung cấp cho bạn 234,56

Tương tự

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

Sẽ cho 234,5

Theo cách này, bạn có thể sử dụng một biến ở vị trí của hằng số như được sử dụng ở trên.

Bộ lọc góc nhỏ nếu bất cứ ai muốn nó:

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

sử dụng nếu thông qua:

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

:)

Nói chung, làm tròn được thực hiện bằng cách chia tỷ lệ: round(num / p) * p

Sử dụng ký hiệu số mũ xử lý làm tròn số + ve, chính xác. Tuy nhiên, phương pháp này không thành công cho các trường hợp cạnh tròn chính xác.

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

Đây cũng là một hàm tôi đã viết để làm tròn số học, bạn có thể tự kiểm tra nó.

/**
 * 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

Điều này dường như hoạt động đáng tin cậy trên bất cứ điều gì tôi ném vào nó:

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));
}

Nó làm tròn lên, vì vậy bạn có thể cần phải sửa đổi nó theo trường hợp sử dụng. Điều này sẽ làm việc:

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

Nếu bạn quan tâm đến việc làm tròn thích hợp thì:

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

Khác nếu bạn không thì bạn đã có một trả lời từ các bài viết trước

str.slice(0, -1)

Math.round( num * 10) / 10 không hoạt động.

Ví dụ, 1455581777.8-145558160.4cung cấp cho bạn 1310023617.3999999.

Vì vậy, chỉ sử dụng num.toFixed(1)

Tôi đã thực hiện một kiểu trả về loại số và cũng chỉ đặt số thập phân nếu cần (không có phần đệm 0).

Ví dụ:

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

Mật mã:

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

Tôi tìm thấy một cách để tránh các vấn đề chính xác:

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

Cảm ơn