En fazla 2 ondal─▒k basama─ča yuvarla (yaln─▒zca gerekirse)


Al─▒nan cevaba git


En fazla 2 ondal─▒k basama─ča yuvarlamak istiyorum, ancak yaln─▒zca gerekirse .

Giri┼č:

 10
1.7777777
9.1
 

Çıktı:

 10
1.78
9.1
 

Bunu JavaScript'te nas─▒l yapabilirim?


2424









Cevap say─▒s─▒n─▒ say: 30






kullan─▒m Math.round(num * 100) / 100


3062







De─čer bir metin t├╝r├╝yse:

 parseFloat("123.456").toFixed(2);
 

De─čer bir say─▒ ise:

 var numb = 123.23454;
numb = numb.toFixed(2);
 

1.5 gibi de─čerlerin ├ž─▒kt─▒ olarak "1.50" verece─či bir dezavantaj vard─▒r. @Minitech taraf─▒ndan ├Ânerilen bir d├╝zeltme:

 var numb = 1.5;
numb = +numb.toFixed(2);
// Note the plus sign that drops any "extra" zeroes at the end.
// It changes the result (which is a string) into a number again (think "0 + foo"),
// which means that it uses only as many digits as necessary.
 

Daha Math.round iyi bir ├ž├Âz├╝m gibi g├Âr├╝n├╝yor . Ama ├Âyle de─čil! Baz─▒ durumlarda olacak DE─×─░L yuvarlak d├╝zg├╝n:

 Math.round(1.005 * 1000)/1000 // Returns 1 instead of expected 1.01!
 

toFixed () da olacakt─▒r DE─×─░L yuvarlak do─čru baz─▒ durumlarda (Krom v.55.0.2883.87 test)!

├ľrnekler:

 parseFloat("1.555").toFixed(2); // Returns 1.55 instead of 1.56.
parseFloat("1.5550").toFixed(2); // Returns 1.55 instead of 1.56.
// However, it will return correct result if you round 1.5551.
parseFloat("1.5551").toFixed(2); // Returns 1.56 as expected.

1.3555.toFixed(3) // Returns 1.355 instead of expected 1.356.
// However, it will return correct result if you round 1.35551.
1.35551.toFixed(2); // Returns 1.36 as expected.
 

San─▒r─▒m, 1.555 asl─▒nda perde arkas─▒ndaki 1.55499994 numaral─▒ bir ┼čamand─▒ra gibi bir ┼čey.

├ç├Âz├╝m 1 , gerekli yuvarlama algoritmas─▒na sahip bir komut dosyas─▒ kullanmakt─▒r, ├Ârne─čin:

 function roundNumber(num, scale) {
  if(!("" + num).includes("e")) {
    return +(Math.round(num + "e+" + scale)  + "e-" + scale);
  } else {
    var arr = ("" + num).split("e");
    var sig = ""
    if(+arr[1] + scale > 0) {
      sig = "+";
    }
    return +(Math.round(+arr[0] + "e" + sig + (+arr[1] + scale)) + "e-" + scale);
  }
}
 

https://plnkr.co/edit/uau8BlS1cqbvWPCHJeOy?p=preview

2. ├ç├Âz├╝m , ├Ân u├ž hesaplamalar─▒n─▒ ├Ânlemek ve arka u├ž sunucusundan yuvarlanm─▒┼č de─čerleri almakt─▒r.


2828







Kullanabilirsiniz

 function roundToTwo(num) {    
    return +(Math.round(num + "e+2")  + "e-2");
}
 

Bunu MDN'de buldum . Onlar─▒n yolu, belirtilen 1.005 ile sorunu ├Ânler .

 roundToTwo(1.005)
1.01
roundToTwo(10)
10
roundToTwo(1.7777777)
1.78
roundToTwo(9.1)
9.1
roundToTwo(1234.5678)
1234.57
 

421







MarkG'nin cevab─▒ do─čru. ─░┼čte herhangi bir say─▒da ondal─▒k basamak i├žin genel bir uzant─▒.

 Number.prototype.round = function(places) {
  return +(Math.round(this + "e+" + places)  + "e-" + places);
}
 

Kullan─▒m─▒:

 var n = 1.7777;    
n.round(2); // 1.78
 

├ťnite testi:

 it.only('should round floats to 2 places', function() {

  var cases = [
    { n: 10,      e: 10,    p:2 },
    { n: 1.7777,  e: 1.78,  p:2 },
    { n: 1.005,   e: 1.01,  p:2 },
    { n: 1.005,   e: 1,     p:0 },
    { n: 1.77777, e: 1.8,   p:1 }
  ]

  cases.forEach(function(testCase) {
    var r = testCase.n.round(testCase.p);
    assert.equal(r, testCase.e, 'didn\'t get right number');
  });
})
 

139







Bir kullanabilirsiniz .toFixed(NumberOfDecimalPlaces) .

 var str = 10.234.toFixed(2); // => '10.23'
var number = Number(str); // => 10.23
 

79







Kullanmal─▒s─▒n:

 Math.round( num * 100 + Number.EPSILON ) / 100
 

Kimse fark─▒nda gibi g├Âz├╝km├╝yor Number.EPSILON .

Ayr─▒ca, bunun baz─▒ insanlar taraf─▒ndan belirtildi─či gibi bir JavaScript garipli─či olmad─▒─č─▒n─▒ kaydetmeye de─čer .

Bu sadece kayan nokta say─▒lar─▒n─▒n bilgisayarda ├žal─▒┼čt─▒─č─▒ yoldur. Programlama dillerinin% 99 gibi, JavaScript de ev yap─▒m─▒ kayan nokta say─▒lar─▒na sahip de─čildir ; bunun i├žin CPU / FPU'ya dayan─▒r. Bir bilgisayar ikili kullan─▒r ve ikili olarak, bunun gibi herhangi bir say─▒ yoktur 0.1 , sadece ikili bir yakla┼č─▒m vard─▒r. Niye ya? Ayn─▒ nedenden dolay─▒ 1/3 ile ondal─▒k yazamazs─▒n─▒z: de─čeri 0.33333333't├╝r ... ├╝├žl├╝ler sonsuz.

─░┼čte gel Number.EPSILON . Bu say─▒, ├žift ÔÇőÔÇőduyarl─▒kl─▒ kayan nokta say─▒lar─▒nda 1 ile bir sonraki say─▒ aras─▒ndaki farkt─▒r . ─░┼čte bu: 1 ve + aras─▒nda bir say─▒ yok Number.EPSILON .

D├ťZENLE:

Yorumlarda belirtildi─či gibi, bir ┼čeyi a├ž─▒kl─▒─ča kavu┼čtural─▒m: ekleme Number.EPSILON yaln─▒zca yuvarlanacak de─čer bir aritmetik i┼člemin sonucu oldu─čunda ge├žerlidir, ├ž├╝nk├╝ baz─▒ kayar nokta hata deltalar─▒n─▒ yutabilir.

De─čer do─črudan bir kaynaktan geldi─činde kullan─▒┼čl─▒ de─čildir (├Ârne─čin: de─či┼čmez, kullan─▒c─▒ giri┼či veya sens├Âr).

EDIT (2019):

@Maganap ve baz─▒ insanlar─▒n i┼čaret etti─či gibi, ├žarpmadan Number.EPSILON ├Ânce eklemek en iyisidir :

 Math.round( ( num + Number.EPSILON ) * 100 ) / 100
 

75







D├╝┼č├╝n├╝n .toFixed() ve .toPrecision() :

http://www.javascriptkit.com/javatutors/formatnumber.shtml


68







Bu soru karma┼č─▒k.

De─či┼čkenleri roundTo2DP(num) bir de─či┼čken olarak alan ve 2 ondal─▒k basama─ča yuvarlanan bir de─čer d├Ând├╝ren bir i┼čleve sahip oldu─čumuzu varsayal─▒m . Bu ifadelerin her biri neyi de─čerlendirmelidir?

  • roundTo2DP(0.014999999999999999)
  • roundTo2DP(0.0150000000000000001)
  • roundTo2DP(0.015)

'A├ž─▒k' cevap, ilk ├Ârne─čin 0,01'e yuvarlanmas─▒ gerekti─čidir (├ž├╝nk├╝ 0,02'den 0,02'ye yak─▒nd─▒r), di─čer ikisinin de 0,02'ye yuvarlanmas─▒ gerekir (├ž├╝nk├╝ 0,015000000000000000001 0,01'den 0,02'ye yak─▒nd─▒r ve 0,015 tam olarak yar─▒ yar─▒yad─▒r) onlar ve bu say─▒lar─▒n yuvarlanmas─▒na dair matematiksel bir s├Âzle┼čme var.

Tahmin edebilece─činiz gibi, bu a├ž─▒k cevaplar─▒ vermek i├žin roundTo2DP muhtemelen uygulanamayaca─č─▒, ├ž├╝nk├╝ kendisine iletilen her ├╝├ž say─▒ ayn─▒ say─▒d─▒r . IEEE 754 ikili kayan nokta say─▒lar─▒ (JavaScript taraf─▒ndan kullan─▒lan t├╝r) tam say─▒ olmayan say─▒lar─▒n ├žo─čunu tam olarak temsil edemez ve bu nedenle yukar─▒daki ├╝├ž say─▒sal de─či┼čmezin t├╝m├╝ yak─▒ndaki ge├žerli bir kayan nokta say─▒s─▒na yuvarlan─▒r. Bu say─▒, oldu─ču gibi, tam olarak

0,01499999999999999944488848768742172978818416595458984375

0,01'den 0,02'ye daha yak─▒nd─▒r.

Her ├╝├ž say─▒n─▒n da taray─▒c─▒ konsolunuzda, D├╝─č├╝m kabu─ču'nda veya di─čer JavaScript yorumlay─▒c─▒s─▒nda ayn─▒ oldu─čunu g├Ârebilirsiniz. Sadece onlar─▒ kar┼č─▒la┼čt─▒r─▒n:

 > 0.014999999999999999 === 0.0150000000000000001
true 

Ben yazd─▒─č─▒n─▒zda m = 0.0150000000000000001 , kesin de─čeri m ben ile sonuna kadar daha yak─▒n 0.01 o kadar olandan 0.02 . Ve yine m de bir String'e d├Ân├╝┼čt├╝r├╝rsem ...

 > var m = 0.0150000000000000001;
> console.log(String(m));
0.015
> var m = 0.014999999999999999;
> console.log(String(m));
0.015 

... 0.015'i al─▒r─▒m, bu da 0.02'ye yuvarlamal─▒d─▒r ve hangisinin daha ├Ânce 56 basamakl─▒ say─▒ olmad─▒─č─▒n─▒ fark ettim ki, bu say─▒lar─▒n hepsine tamamen e┼čit oldu─čunu s├Âylemi┼čtim. Peki bu ne karanl─▒k sihir?

Cevap, ECMAScript ┼čartnamesinde, 7.1.12.1: Numara tipine uygulanan ToString b├Âl├╝m├╝nde bulunabilir . Burada, Number m'nin bir String'e d├Ân├╝┼čt├╝r├╝lmesine ili┼čkin kurallar belirlenmi┼čtir. ├ľnemli bir par├žas─▒ aras─▒nda bir tamsay─▒d─▒r ki burada noktas─▒ 5, bir s olan basamak String temsil kullan─▒lacak olu┼čturulur m :

izin n , k , ve s tamsay─▒lar─▒ ├Âyle ki k Ôëą 1, 10 k -1 ÔëĄ s <10 k i├žin say─▒ de─čeri S * 10 N - k olan m ve k m├╝mk├╝n oldu─ču kadar k├╝├ž├╝k oldu─ču gibi. K ondal─▒k temsil hane say─▒s─▒ oldu─ču Not s , s , 10 taraf─▒ndan b├Âl├╝nebilir de─čildir, ve en ├Ânemli rakam o s mutlaka e┼čsiz bu kriterlere g├Âre belirlenir de─čildir.

Buradaki kilit k─▒s─▒m " k'nin m├╝mk├╝n oldu─ču kadar k├╝├ž├╝k olmas─▒" gereklili─čidir . Bu gereksinimin ne kadar ├Ânemli oldu─ču, bir Say─▒ verildi─činde m , hala bu gereklili─či yerine getirirken en d├╝┼č├╝k basamak say─▒s─▒na String(m) sahip olmas─▒ gereken bir gerekliliktir . Bunu zaten bildi─čimiz i├žin , neden do─čru olmas─▒ gerekti─či art─▒k belli . Number(String(m)) === m 0.015 === 0.0150000000000000001 String(0.0150000000000000001) === '0.015'

Tabii ki, bu tart─▒┼čmalar─▒n hi├žbiri neyin d├Ânmesi roundTo2DP(m) gerekti─čine do─črudan cevap vermedi. E─čer m 'bireyin tam de─čer 0,01499999999999999944488848768742172978818416595458984375, ama onun dize temsilidir' 0.015, o zaman ne oldu─čunu do─čru matematiksel, pratik olarak, felsefi olarak, ya da her t├╝rl├╝ - - cevap tekrar iki ondal─▒k basama─ča o yuvarlak zaman?

Bunun tek bir do─čru cevab─▒ yoktur. Kullan─▒m durumunuza g├Âre de─či┼čir. Muhtemelen String sunumuna sayg─▒ duymak ve a┼ča─č─▒daki durumlarda yukar─▒ yuvarlamak istersiniz:

  • Temsil edilen de─čer do─čas─▒ gere─či ayr─▒d─▒r, ├Ârne─čin dinarlar gibi 3 basamakl─▒ bir para biriminde bir para birimi. Bu durumda, ger├žek 0,015 gibi bir say─▒ de─čeri olan 0.015 ve ikili kayan noktas─▒nda ald─▒─č─▒n─▒ ,0149999999 ... temsil yuvarlama hatad─▒r. (Tabii ki, pek ├žo─ču, makul bir ┼čekilde, bu t├╝r de─čerleri ele almak i├žin ondal─▒k bir k├╝t├╝phane kullanman─▒z ve bunlar─▒ asla ilk ├Ânce ikili kayan nokta Say─▒lar─▒ olarak g├Âstermemelisiniz.
  • De─čer bir kullan─▒c─▒ taraf─▒ndan yaz─▒lm─▒┼čt─▒r. Bu durumda, tekrar girilen tam ondal─▒k say─▒, en yak─▒n ikili kayan nokta g├Âsteriminden daha 'do─čru' olur.

├ľte yandan, ikili kayan nokta de─čerine sayg─▒ duymak ve de─čeriniz do─čal olarak s├╝rekli bir skalada oldu─čunda, ├Ârne─čin bir sens├Ârden bir okuma ise, a┼ča─č─▒ do─čru yuvarlamak isteyebilirsiniz.

Bu iki yakla┼č─▒m farkl─▒ kod gerektirir. Say─▒'n─▒n String g├Âstergesine sayg─▒ g├Âstermek i├žin (olduk├ža makul bir ┼čekilde ince kodla), siz okula giderken kulland─▒─č─▒n─▒z algoritmay─▒ kullanarak, do─črudan String g├Âstergesine g├Âre hareket eden kendi rakamlar─▒m─▒z─▒ uygulayabiliriz. say─▒lar─▒n nas─▒l yuvarlanaca─č─▒ ├Â─čretildi. A┼ča─č─▒da, OP'nin, ondal─▒k noktadan sonraki son s─▒f─▒rlar─▒ s─▒yr─▒larak "yaln─▒zca gerekti─činde" say─▒y─▒ 2 ondal─▒k basama─ča temsil etme gereklili─čine sayg─▒ g├Âsteren bir ├Ârnek verilmi┼čtir; Elbette kesin ihtiya├žlar─▒n─▒z i├žin ince ayar yapman─▒z gerekebilir.

 /**
 * Converts num to a decimal string (if it isn't one already) and then rounds it
 * to at most dp decimal places.
 *
 * For explanation of why you'd want to perform rounding operations on a String
 * rather than a Number, see http://stackoverflow.com/a/38676273/1709587
 *
 * @param {(number|string)} num
 * @param {number} dp
 * @return {string}
 */
function roundStringNumberWithoutTrailingZeroes (num, dp) {
    if (arguments.length != 2) throw new Error("2 arguments required");

    num = String(num);
    if (num.indexOf('e+') != -1) {
        // Can't round numbers this large because their string representation
        // contains an exponent, like 9.99e+37
        throw new Error("num too large");
    }
    if (num.indexOf('.') == -1) {
        // Nothing to do
        return num;
    }

    var parts = num.split('.'),
        beforePoint = parts[0],
        afterPoint = parts[1],
        shouldRoundUp = afterPoint[dp] >= 5,
        finalNumber;

    afterPoint = afterPoint.slice(0, dp);
    if (!shouldRoundUp) {
        finalNumber = beforePoint + '.' + afterPoint;
    } else if (/^9+$/.test(afterPoint)) {
        // If we need to round up a number like 1.9999, increment the integer
        // before the decimal point and discard the fractional part.
        finalNumber = Number(beforePoint)+1;
    } else {
        // Starting from the last digit, increment digits until we find one
        // that is not 9, then stop
        var i = dp-1;
        while (true) {
            if (afterPoint[i] == '9') {
                afterPoint = afterPoint.substr(0, i) +
                             '0' +
                             afterPoint.substr(i+1);
                i--;
            } else {
                afterPoint = afterPoint.substr(0, i) +
                             (Number(afterPoint[i]) + 1) +
                             afterPoint.substr(i+1);
                break;
            }
        }

        finalNumber = beforePoint + '.' + afterPoint;
    }

    // Remove trailing zeroes from fractional part before returning
    return finalNumber.replace(/0+$/, '')
}
 

├ľrnek kullan─▒m:

 > roundStringNumberWithoutTrailingZeroes(1.6, 2)
'1.6'
> roundStringNumberWithoutTrailingZeroes(10000, 2)
'10000'
> roundStringNumberWithoutTrailingZeroes(0.015, 2)
'0.02'
> roundStringNumberWithoutTrailingZeroes('0.015000', 2)
'0.02'
> roundStringNumberWithoutTrailingZeroes(1, 1)
'1'
> roundStringNumberWithoutTrailingZeroes('0.015', 2)
'0.02'
> roundStringNumberWithoutTrailingZeroes(0.01499999999999999944488848768742172978818416595458984375, 2)
'0.02'
> roundStringNumberWithoutTrailingZeroes('0.01499999999999999944488848768742172978818416595458984375', 2)
'0.01' 

Yukar─▒daki i┼člev muhtemelen kullan─▒c─▒lar─▒n girdikleri say─▒lara yanl─▒┼č yuvarlanmalar─▒na ┼čahit olmalar─▒n─▒ ├Ânlemek i├žin kullanmak istedi─činiz ┼čeydir.

(Alternatif olarak, ├ž─▒lg─▒nca farkl─▒ bir uygulamayla benzer davran─▒┼č g├Âsteren bir i┼člev sunan round10 kitapl─▒─č─▒n─▒ da deneyebilirsiniz .)

Peki ya ikinci t├╝r Say─▒ya sahipseniz - s├╝rekli ├Âl├žeklerden al─▒nan bir de─čer, daha az ondal─▒k basama─ča sahip yakla┼č─▒k ondal─▒k g├Âsterimlerin daha fazla olandan daha do─čru oldu─čunu d├╝┼č├╝nmek i├žin hi├žbir neden yoktur ? Bu durumda, biz yok bu temsili (spec a├ž─▒kland─▒─č─▒ gibi) zaten, ├ž├╝nk├╝ dize temsilini sayg─▒ istiyoruz sort-of-yuvarlak; "0.014999999 ... 375, 0.015'e yuvarlar, bu da 0.02'ye, yani 0.014999999 ... 375, 0.02'ye yuvarlar" derken hata yapmak istemiyoruz.

Burada sadece yerle┼čik toFixed y├Ântemi kullanabiliriz. Number() D├Ând├╝r├╝len String'i ├ža─č─▒rmak suretiyle toFixed , String temsilinde izleri s─▒f─▒r olan bir say─▒ elde etti─čimizi unutmay─▒n (JavaScript, bu cevab─▒n ba┼člar─▒nda tart─▒┼č─▒lan bir Say─▒'n─▒n String g├Âsterimini hesaplama bi├žimi sayesinde).

 /**
 * Takes a float and rounds it to at most dp decimal places. For example
 *
 *     roundFloatNumberWithoutTrailingZeroes(1.2345, 3)
 *
 * returns 1.234
 *
 * Note that since this treats the value passed to it as a floating point
 * number, it will have counterintuitive results in some cases. For instance,
 * 
 *     roundFloatNumberWithoutTrailingZeroes(0.015, 2)
 *
 * gives 0.01 where 0.02 might be expected. For an explanation of why, see
 * http://stackoverflow.com/a/38676273/1709587. You may want to consider using the
 * roundStringNumberWithoutTrailingZeroes function there instead.
 *
 * @param {number} num
 * @param {number} dp
 * @return {number}
 */
function roundFloatNumberWithoutTrailingZeroes (num, dp) {
    var numToFixedDp = Number(num).toFixed(dp);
    return Number(numToFixedDp);
}
 

67







Kesin bir yuvarlama y├Ântemi. Kaynak: Mozilla

 (function(){

    /**
     * Decimal adjustment of a number.
     *
     * @param   {String}    type    The type of adjustment.
     * @param   {Number}    value   The number.
     * @param   {Integer}   exp     The exponent (the 10 logarithm of the adjustment base).
     * @returns {Number}            The adjusted value.
     */
    function decimalAdjust(type, value, exp) {
        // If the exp is undefined or zero...
        if (typeof exp === 'undefined' || +exp === 0) {
            return Math[type](value);
        }
        value = +value;
        exp = +exp;
        // If the value is not a number or the exp is not an integer...
        if (isNaN(value) || !(typeof exp === 'number' && exp % 1 === 0)) {
            return NaN;
        }
        // Shift
        value = value.toString().split('e');
        value = Math[type](+(value[0] + 'e' + (value[1] ? (+value[1] - exp) : -exp)));
        // Shift back
        value = value.toString().split('e');
        return +(value[0] + 'e' + (value[1] ? (+value[1] + exp) : exp));
    }

    // Decimal round
    if (!Math.round10) {
        Math.round10 = function(value, exp) {
            return decimalAdjust('round', value, exp);
        };
    }
    // Decimal floor
    if (!Math.floor10) {
        Math.floor10 = function(value, exp) {
            return decimalAdjust('floor', value, exp);
        };
    }
    // Decimal ceil
    if (!Math.ceil10) {
        Math.ceil10 = function(value, exp) {
            return decimalAdjust('ceil', value, exp);
        };
    }
})();
 

├ľrnekler:

 // Round
Math.round10(55.55, -1); // 55.6
Math.round10(55.549, -1); // 55.5
Math.round10(55, 1); // 60
Math.round10(54.9, 1); // 50
Math.round10(-55.55, -1); // -55.5
Math.round10(-55.551, -1); // -55.6
Math.round10(-55, 1); // -50
Math.round10(-55.1, 1); // -60
Math.round10(1.005, -2); // 1.01 -- compare this with Math.round(1.005*100)/100 above
// Floor
Math.floor10(55.59, -1); // 55.5
Math.floor10(59, 1); // 50
Math.floor10(-55.51, -1); // -55.6
Math.floor10(-51, 1); // -60
// Ceil
Math.ceil10(55.51, -1); // 55.6
Math.ceil10(51, 1); // 60
Math.ceil10(-55.59, -1); // -55.5
Math.ceil10(-59, 1); // -50
 

62


2014-08-01





Burada bulunan cevaplar─▒n hi├žbiri do─čru de─čil . @stinkycheeseman istedi kadar yuvarlak t├╝m numaray─▒ yuvarlak.

Yuvarlamak i├žin ┼čunu kullan─▒n:

 Math.ceil(num * 100)/100;
 

59







─░┼čte bunu yapman─▒n basit bir yolu:

 Math.round(value * 100) / 100
 

Devam etmek ve sizin i├žin yapmak i├žin ayr─▒ bir i┼člev yapmak isteyebilirsiniz:

 function roundToTwo(value) {
    return(Math.round(value * 100) / 100);
}
 

O zaman basit├že de─čeri ge├žersiniz.

─░kinci bir parametre ekleyerek herhangi bir say─▒da ondal─▒k basama─ča yuvarlamak i├žin geli┼čtirebilirsiniz.

 function myRound(value, places) {
    var multiplier = Math.pow(10, places);

    return (Math.round(value * multiplier) / multiplier);
}
 

45







 +(10).toFixed(2); // = 10
+(10.12345).toFixed(2); // = 10.12

(10).toFixed(2); // = 10.00
(10.12345).toFixed(2); // = 10.12
 

36







Benim i├žin Math.round () do─čru cevap vermiyordu. ToFixed (2) 'in daha iyi ├žal─▒┼čt─▒─č─▒n─▒ g├Ârd├╝m . A┼ča─č─▒da her ikisine de ├Ârnekler:

 console.log(Math.round(43000 / 80000) * 100); // wrong answer

console.log(((43000 / 80000) * 100).toFixed(2)); // correct answer 


36







Bu i┼člevi kullan Number(x).toFixed(2);


34







Bu hafif ├ž├Âz├╝m├╝ deneyin :

 function round(x, digits){
  return parseFloat(x.toFixed(digits))
}

 round(1.222,  2) ;
 // 1.22
 round(1.222, 10) ;
 // 1.222
 

32







2017
Sadece yerel kodu kullan .toFixed()

 number = 1.2345;
number.toFixed(2) // "1.23"
 

E─čer s─▒k─▒ olman─▒z gerekiyorsa ve sadece gerekirse gerekirse basamak ekleyebiliyorsan─▒z replace

 number = 1; // "1"
number.toFixed(5).replace(/\.?0*$/g,'');
 

32







Bunu yapman─▒n birka├ž yolu vard─▒r. Benim gibi insanlar i├žin, Lodash'─▒n ├že┼čidi

 function round(number, precision) {
    var pair = (number + 'e').split('e')
    var value = Math.round(pair[0] + 'e' + (+pair[1] + precision))
    pair = (value + 'e').split('e')
    return +(pair[0] + 'e' + (+pair[1] - precision))
}
 

Kullan─▒m─▒:

 round(0.015, 2) // 0.02
round(1.005, 2) // 1.01
 

Projeniz jQuery veya lodash kullan─▒yorsa round , k├╝t├╝phanelerde uygun y├Ântemi de bulabilirsiniz .

G├╝ncelleme 1

Varyant─▒ kald─▒rd─▒m n.toFixed(2) , ├ž├╝nk├╝ do─čru de─čil. Te┼čekk├╝rler @ avalanche1


28







MarkG ve Lavamantis, kabul edilenden ├žok daha iyi bir ├ž├Âz├╝m sundu. Daha fazla kazanamad─▒klar─▒ i├žin utan├ž verici!

─░┼čte kayan nokta ondal─▒k say─▒lar─▒n─▒ ├ž├Âzmek i├žin kulland─▒─č─▒m fonksiyon da MDN'ye dayan─▒yor . Lavamantis'in ├ž├Âz├╝m├╝nden daha genel (ama daha az ├Âzl├╝):

 function round(value, exp) {
  if (typeof exp === 'undefined' || +exp === 0)
    return Math.round(value);

  value = +value;
  exp  = +exp;

  if (isNaN(value) || !(typeof exp === 'number' && exp % 1 === 0))
    return NaN;

  // Shift
  value = value.toString().split('e');
  value = Math.round(+(value[0] + 'e' + (value[1] ? (+value[1] + exp) : exp)));

  // Shift back
  value = value.toString().split('e');
  return +(value[0] + 'e' + (value[1] ? (+value[1] - exp) : -exp));
}
 

┼×ununla kullan─▒n:

 round(10.8034, 2);      // Returns 10.8
round(1.275, 2);        // Returns 1.28
round(1.27499, 2);      // Returns 1.27
round(1.2345678e+2, 2); // Returns 123.46
 

Lavamantis'in ├ž├Âz├╝m├╝yle kar┼č─▒la┼čt─▒r─▒ld─▒─č─▒nda, yapabiliriz ...

 round(1234.5678, -2); // Returns 1200
round("123.45");      // Returns 123
 

22







Lodash kitapl─▒─č─▒ kullan─▒yorsan─▒z, a┼ča─č─▒daki gibi lodash'─▒n yuvarlak y├Ântemini kullanabilirsiniz.

 _.round(number, precision)
 

├ľrne─čin:

 _.round(1.7777777, 2) = 1.78
 

22







ES6'dan beri, toPrecision kullanarak bunu yapman─▒n 'uygun' bir yolu (statik stati─či ge├žersiz k─▒lmadan ve ge├žici ├ž├Âz├╝mler olu┼čturmadan) vard─▒r.https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_objects/Number/toPrecision

 var x = 1.49999999999;
console.log(x.toPrecision(4));
console.log(x.toPrecision(3));
console.log(x.toPrecision(2));

var y = Math.PI;
console.log(y.toPrecision(6));
console.log(y.toPrecision(5));
console.log(y.toPrecision(4));

var z = 222.987654
console.log(z.toPrecision(6));
console.log(z.toPrecision(5));
console.log(z.toPrecision(4)); 

O zaman yapabilirsin parseFloat ve s─▒f─▒rlar 'gider'.

 console.log(parseFloat((1.4999).toPrecision(3)));
console.log(parseFloat((1.005).toPrecision(3)));
console.log(parseFloat((1.0051).toPrecision(3))); 


20







Bu size yard─▒mc─▒ olabilir:

 var result = (Math.round(input*100)/100);
 

Daha fazla bilgi i├žin bu linke g├Âz atabilirsiniz.

Math.round (num) vs num.toFixed (0) ve taray─▒c─▒ tutars─▒zl─▒klar─▒


18







 var roundUpto = function(number, upto){
    return Number(number.toFixed(upto));
}
roundUpto(0.1464676, 2);
 

toFixed(2) burada 2, bu say─▒y─▒ yuvarlamak istedi─čimiz basamak say─▒s─▒d─▒r.


16







─░┼če yarayabilir

 Math.round(num * 100)/100;
 

toFixed ve round aras─▒ndaki fark─▒ bilmek. Sen bir g├Âz olabilir num.toFixed (0) ve taray─▒c─▒ tutars─▒zl─▒klar vs Math.round (num) .


15







En kolay yol:

+num.toFixed(2)

Onu bir dizgeye d├Ân├╝┼čt├╝r├╝r ve sonra tamsay─▒ / kayan noktaya geri d├Ând├╝r├╝r.


13







Bunun gibi bir ┼čey kullan─▒n "parseFloat (parseFloat (value) .toFixed (2))"

 parseFloat(parseFloat("1.7777777").toFixed(2))-->1.78 
parseFloat(parseFloat("10").toFixed(2))-->10 
parseFloat(parseFloat("9.1").toFixed(2))-->9.1
 

13







─░┼čte bir prototip y├Ântemi:

 Number.prototype.round = function(places){
    places = Math.pow(10, places); 
    return Math.round(this * places)/places;
}

var yournum = 10.55555;
yournum = yournum.round(2);
 

12







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 yapar. Ancak, bu y├Ântem yuvarlak kenarl─▒ kasalar─▒ do─čru ┼čekilde alam─▒yor.

 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 da do─čru aritmetik yuvarlama yapmak i├žin yazd─▒─č─▒m bir fonksiyon. Kendin test edebilirsin.

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


11







Pek ├žok 0 ile ba┼ča ├ž─▒kmamak i├žin bu de─či┼čkeni kullan─▒n:

 Math.round(num * 1e2) / 1e2
 

10







D3 k├╝t├╝phanesini zaten kullan─▒yorsan─▒z, g├╝├žl├╝ bir say─▒ bi├žimlendirme k├╝t├╝phanesine sahiptir: https://github.com/mbostock/d3/wiki/Formatting

Yuvarlama ├Âzellikle burada: https://github.com/mbostock/d3/wiki/Formatting#d3_round

Senin durumunda, cevap:

 > d3.round(1.777777, 2)
1.78
> d3.round(1.7, 2)
1.7
> d3.round(1, 2)
1
 

9







B├Âyle bir yuvarlamay─▒ yaln─▒zca gerekliyse elde etmenin bir yolu, Number.prototype.toLocaleString () y├Ântemini kullanmakt─▒r :

 myNumber.toLocaleString('en', {maximumFractionDigits:2, useGrouping:false})
 

Bu, tam olarak bekledi─činiz ├ž─▒kt─▒y─▒ ancak dizge olarak sa─člayacakt─▒r. Bekledi─činiz veri t├╝r├╝ de─čilse, bunlar─▒ tekrar say─▒lara d├Ân├╝┼čt├╝rebilirsiniz.


9



─░lgili yay─▒nlar


Bir say─▒y─▒ Java'da n ondal─▒k basama─ča yuvarlama

Ondal─▒k bir de─čeri 2 ondal─▒k basama─ča nas─▒l yuvarlayabilirim (sayfadaki ├ž─▒kt─▒ i├žin)

C# iki ondal─▒k basamakta yuvarlak ├žift?

PostgreSQL'de ortalama 2 ondal─▒k basama─ča nas─▒l yuvarlan─▒r?

Kar─▒nca g├Ârevi sadece bir dosya varsa bir kar─▒nca hedefi ├žal─▒┼čt─▒rmak i├žin mi?

Kayan nokta say─▒s─▒n─▒ belirli bir ondal─▒k basama─ča kadar yuvarlama nas─▒l yap─▒l─▒r?

Ant ├Âzelli─či yaln─▒zca ayarlanmam─▒┼čsa nas─▒l ayarlan─▒r

Raylar 3. D├╝zenleme bi├žiminde iki ondal─▒k basamak nas─▒l g├Âsterilir?

Docker pip needs.txt komutunu nas─▒l ├žal─▒┼čt─▒rabiliriz?

Bash komutu yaln─▒zca belirli bir ada sahip bir Docker kab─▒ yoksa nas─▒l ├žal─▒┼čt─▒r─▒l─▒r?

Etiketle ilgili di─čer sorular [javascript]


Bash'deki bir dizi dizgiyi kullanarak dola┼čmak.

GitHub'ta bar─▒nd─▒r─▒lan harici JavaScript dosyas─▒n─▒ ba─člay─▒n ve y├╝r├╝t├╝n

Node.js nedir? [kapal─▒]

De─či┼čmez ile ne kastedilmektedir?

Dosya t├╝rlerini bir iPhone uygulamas─▒yla nas─▒l ili┼čkilendirebilirim?

WebView'da geri d├╝─čmesine bas─▒ld─▒─č─▒nda ├Ânceki sayfaya nas─▒l geri d├Ân├╝l├╝r?

DISPLAY tan─▒mlanmad─▒─č─▒nda matplotlib ile PNG olu┼čturma

Bir koleksiyon i├žin hashCode y├Ânteminin en iyi uygulamas─▒

Hangi .NET Framework s├╝r├╝mlerinin ve hizmet paketlerinin y├╝kl├╝ oldu─čunu nas─▒l saptayabilirim?

Python i┼člevi k├╝resel de─či┼čkenler?