Bagaimana Anda membulatkan ke 1 tempat desimal di Javascript?

Bisakah Anda membulatkan angka dalam javascript ke 1 karakter setelah titik desimal (dibulatkan dengan benar)?

Saya mencoba * 10, round, / 10 tetapi ia meninggalkan dua desimal di ujung int.

Math.round(num * 10) / 10 berfungsi, berikut adalah contohnya ...

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

jika Anda ingin memiliki satu tempat desimal, bahkan ketika itu akan menjadi 0, maka tambahkan ...

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: Tambahkan putaran dengan fungsi presisi ...

Menggunakan prinsip ini, untuk referensi, berikut adalah fungsi bundar kecil praktis yang membutuhkan ketelitian ...

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

... penggunaan ...

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

... default untuk membulatkan ke bilangan bulat terdekat (presisi 0) ...

round(12345.6789) // 12346

... dan dapat digunakan untuk membulatkan ke 10 atau 100 dll terdekat ...

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

... dan penanganan yang benar dari angka negatif ...

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

... dan dapat dikombinasikan dengan toFixed untuk memformat secara konsisten sebagai string ...

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

var number = 123.456;

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

Jika Anda menggunakan Math.round(5.01)Anda akan mendapatkan 5bukan 5.0.

Jika Anda menggunakan toFixedAnda mengalami masalah pembulatan .

Jika Anda menginginkan yang terbaik dari kedua dunia, kombinasikan keduanya:

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

Anda mungkin ingin membuat fungsi untuk ini:

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

lodashmemiliki roundmetode:

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

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

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

Documents .

Sumber .

Saya memilih toFixed(), tetapi, untuk catatan, inilah cara lain yang menggunakan sedikit pergeseran untuk melemparkan nomor ke int. Jadi, selalu membulatkan ke nol (turun untuk angka positif, naik untuk negatif).

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

Tapi hei, karena tidak ada panggilan fungsi, itu cepat jahat. :)

Dan inilah yang menggunakan pencocokan string:

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

Saya tidak merekomendasikan menggunakan varian string, katakan saja.

Coba dengan ini:

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

kurang rumit dan lebih mudah diimplementasikan ...

dengan ini, Anda dapat membuat fungsi untuk dilakukan:

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 : lihat ini Cara membulatkan menggunakan ROUND HALF UP. Mode pembulatan yang sebagian besar dari kita diajarkan di sekolah dasar

x = angka, n = tempat desimal:

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

Kenapa tidak adil?

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

1. toFixed : mengembalikan string yang mewakili nomor yang diberikan menggunakan notasi titik tetap.
2. Unary plus (+) : Operator unary plus mendahului operandnya dan mengevaluasi operandnya tetapi mencoba mengubahnya menjadi angka, jika belum.

var num = 34.7654;

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

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

Untuk melengkapi Jawaban Terbaik:

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

Nomor parameter input mungkin "tidak" selalu berupa angka, dalam hal ini .toFixed tidak ada.

ES 6 Versi dari Jawaban yang Diterima:

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

Menggunakan metode toPrecision:

var a = 1.2345
a.toPrecision(2)

// result "1.2"

Jika metode Anda tidak berhasil, harap kirim kode Anda.

Namun, Anda bisa menyelesaikan tugas pembulatan sebagai:

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

Akan memberimu 234.56

Demikian pula

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

Akan memberi 234.5

Dengan cara ini Anda bisa menggunakan variabel menggantikan konstanta seperti yang digunakan di atas.

Filter Little Angular jika ada yang menginginkannya:

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

gunakan jika melalui:

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

:)

Secara umum, pembulatan dilakukan dengan penskalaan: round(num / p) * p

Menggunakan notasi eksponensial menangani pembulatan + ve angka, dengan benar. Namun, metode ini gagal membulatkan tepi-kasus dengan benar.

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

Di sini, juga merupakan salah satu fungsi yang saya tulis untuk melakukan pembulatan aritmatika, Anda dapat mengujinya sendiri.

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

Ini tampaknya bekerja dengan andal di semua yang saya lemparkan:

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

Itu bulat, jadi Anda mungkin perlu memodifikasinya sesuai dengan kasus penggunaan. Ini seharusnya bekerja:

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

Jika Anda peduli tentang pembulatan yang tepat maka:

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

Jika tidak, maka Anda sudah mendapat balasan dari posting sebelumnya

str.slice(0, -1)

Math.round( num * 10) / 10 tidak bekerja

Misalnya, 1455581777.8-145558160.4memberi Anda1310023617.3999999 .

Jadi hanya gunakan num.toFixed(1)

Saya membuat satu yang mengembalikan tipe angka dan juga menempatkan desimal hanya jika diperlukan (no 0 padding).

Contoh:

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

Kode:

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

Saya menemukan cara untuk menghindari masalah presisi:

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

Terima kasih