Javascript'te 1 ondalık basamağa nasıl yersin?

Javascript'teki bir sayıyı ondalık noktadan sonra (düzgün yuvarlanmış) 1 karaktere yuvarlayabilir misiniz?

* 10, round, / 10'u denedim ama int sonunda iki ondalık sayı bıraktı.

Math.round(num * 10) / 10 İşte bir örnek ...

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

bir ondalık basamağa sahip olmasını istiyorsanız, bu 0 olsa bile, sonra ekleyin ...

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: Hassas fonksiyon ile yuvarlak ekleyin ...

Bu prensibi kullanarak, referans olarak, hassasiyet gerektiren kullanışlı küçük bir yuvarlak fonksiyon ...

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

... kullanım ...

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

... varsayılan olarak en yakın tam sayıya yuvarlanır (hassasiyet 0) ...

round(12345.6789) // 12346

... ve en yakın 10 veya 100'e yuvarlamak için kullanılabilir ...

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

... ve negatif sayıların doğru kullanımı ...

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

... ve sürekli olarak dize olarak biçimlendirmek için toFixed ile birleştirilebilir ...

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

var number = 123.456;

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

Eğer kullanırsanız yerine Math.round(5.01)alırsınız .55.0

Eğer kullanırsanız toFixediçine çalıştırmak yuvarlama konular .

Her iki dünyanın en iyisini istiyorsanız, ikisini birleştirin:

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

Bunun için bir işlev oluşturmak isteyebilirsiniz:

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

lodashbir roundyöntemi vardır:

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

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

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

Dokümanlar .

Kaynak .

Oy veriyorum toFixed(), ancak kayıt için, sayıyı bir int'e atmak için biraz kaydırma kullanan başka bir yol. Yani, her zaman sıfıra doğru yuvarlar (pozitif sayılar için aşağı, negatifler için yukarı).

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

Ama hey, fonksiyon çağrısı olmadığı için hızlı. :)

Ve işte dize eşleşmesini kullanan:

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

Ben dize varyantı kullanmanızı tavsiye etmiyorum, sadece sayin.

Şunu deneyin:

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

daha az karmaşık ve uygulaması daha kolay ...

bununla, aşağıdakileri yapmak için bir işlev oluşturabilirsiniz:

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 : YUVARLAK YARIM YUKARI kullanarak nasıl yuvarlanır bakın . Çoğumuzun ilkokulda öğretildiği yuvarlama modu

x = sayı, n = ondalık basamak:

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

Neden sadece

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

1. tamir edildi : sabit nokta gösterimini kullanarak belirli bir sayıyı temsil eden bir dize döndürür.
2. Unary plus (+) : Unary plus operatörü işleneninden önce gelir ve işlenişini değerlendirir, ancak henüz değilse bir sayıya dönüştürmeye çalışır.

var num = 34.7654;

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

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

En İyi Yanıtı tamamlamak için:

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

Girdi parametre numarası her zaman "olmayabilir", bu durumda .toFixed mevcut değildir.

ES 6 Kabul Edilen Cevap Sürümü:

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

ToPrecision yöntemini kullanma:

var a = 1.2345
a.toPrecision(2)

// result "1.2"

Yönteminiz işe yaramazsa, lütfen kodunuzu gönderin.

Ancak, yuvarlama görevini şu şekilde yapabilirsiniz:

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

234.56 verecek

benzer şekilde

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

234.5 verecek

Bu şekilde, yukarıda kullanılan sabitin yerine bir değişken kullanabilirsiniz.

Herkes isterse Küçük Açısal filtre:

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

eğer yoluyla kullanın:

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

:)

Genel olarak, yuvarlama ölçeklendirme ile yapılır: round(num / p) * p

Üstel gösterimi kullanmak, + ve sayılarının yuvarlanmasını doğru şekilde işler. Ancak, bu yöntem kenar kasaları doğru şekilde yuvarlayamaz.

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

Burada ayrıca aritmetik yuvarlama yapmak için yazdığım bir işlev, kendiniz test edebilirsiniz.

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

Bu, attığım her şeyde güvenilir bir şekilde çalışıyor gibi görünüyor:

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

Yuvarlar, bu nedenle kullanım durumuna göre değiştirmeniz gerekebilir. Bu çalışmalı:

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

Doğru yuvarlamayı önemsiyorsanız, o zaman:

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

Başka bir şey yoksa, zaten önceki yayınlardan bir cevabınız var

str.slice(0, -1)

Math.round( num * 10) / 10 çalışmıyor.

Örneğin, 1455581777.8-145558160.4size verir1310023617.3999999 .

Sadece kullanın num.toFixed(1)

Numara türünü döndüren ve yalnızca gerektiğinde ondalık basamak yerleştiren bir tane yaptım (0 dolgu yok).

Örnekler:

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

Kod:

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

Hassasiyet problemlerinden kaçınmanın bir yolunu buldum:

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

Teşekkürler