Misalkan saya memiliki nilai 15.7784514, saya ingin menampilkannya 15.77 tanpa pembulatan.

var num = parseFloat(15.7784514);
document.write(num.toFixed(1)+"<br />");
document.write(num.toFixed(2)+"<br />");
document.write(num.toFixed(3)+"<br />");
document.write(num.toFixed(10));

Hasil dalam -

15.8
15.78
15.778
15.7784514000 

Bagaimana cara menampilkan 15.77?

Ubah nomor menjadi string, cocokkan angka hingga desimal kedua:

function calc(theform) {
    var num = theform.original.value, rounded = theform.rounded
    var with2Decimals = num.toString().match(/^-?\d+(?:\.\d{0,2})?/)[0]
    rounded.value = with2Decimals
}

<form onsubmit="return calc(this)">
Original number: <input name="original" type="text" onkeyup="calc(form)" onchange="calc(form)" />
<br />"Rounded" number: <input name="rounded" type="text" placeholder="readonly" readonly>
</form>

The toFixedMetode gagal dalam beberapa kasus seperti toString, jadi sangat berhati-hati dengan itu.

Perbarui 5 Nov 2016

Jawaban baru, selalu akurat

function toFixed(num, fixed) {
    var re = new RegExp('^-?\\d+(?:\.\\d{0,' + (fixed || -1) + '})?');
    return num.toString().match(re)[0];
}

Karena floating point matematika dalam javascript akan selalu memiliki kasus tepi, solusi sebelumnya akan akurat sebagian besar waktu yang tidak cukup baik. Ada beberapa solusi untuk ini seperti num.toPrecision, BigDecimal.js , dan accounting.js . Namun, saya percaya bahwa hanya mengurai string akan menjadi yang paling sederhana dan selalu akurat.

Mendasarkan pembaruan pada regex yang ditulis dengan baik dari jawaban yang diterima oleh @Gumbo, fungsi toFixed baru ini akan selalu berfungsi seperti yang diharapkan.

Jawaban lama, tidak selalu akurat.

Roll fungsi toFixed Anda sendiri:

function toFixed(num, fixed) {
    fixed = fixed || 0;
    fixed = Math.pow(10, fixed);
    return Math.floor(num * fixed) / fixed;
}

Saya memilih untuk menulis ini sebagai gantinya untuk menghapus sisanya dengan string jadi saya tidak harus berurusan dengan masalah matematika yang datang dengan angka:

num = num.toString(); //If it's not already a String
num = num.slice(0, (num.indexOf("."))+3); //With 3 exposing the hundredths place
Number(num); //If you need it back as a Number

Ini akan memberi Anda "15,77" dengan num = 15,7784514;

Oktober 2017

Solusi umum untuk memotong (tanpa pembulatan) angka ke digit desimal ke-n dan mengubahnya menjadi string dengan tepat digit n desimal, untuk setiap n≥0.

function toFixedTrunc(x, n) {
  const v = (typeof x === 'string' ? x : x.toString()).split('.');
  if (n <= 0) return v[0];
  let f = v[1] || '';
  if (f.length > n) return `${v[0]}.${f.substr(0,n)}`;
  while (f.length < n) f += '0';
  return `${v[0]}.${f}`
}

di mana x dapat berupa angka (yang akan dikonversi menjadi string) atau string.

Berikut adalah beberapa tes untuk n = 2 (termasuk yang diminta oleh OP):

0           => 0.00
0.01        => 0.01
0.5839      => 0.58
0.999       => 0.99
1.01        => 1.01
2           => 2.00
2.551       => 2.55
2.99999     => 2.99
4.27        => 4.27
15.7784514  => 15.77
123.5999    => 123.59
0.000000199 => 1.99 *

* Seperti disebutkan dalam catatan, itu karena konversi implisit javascript menjadi eksponensial untuk "1.99e-7" Dan untuk beberapa nilai lain dari n:

15.001097   => 15.0010 (n=4)
0.000003298 => 0.0000032 (n=7)
0.000003298257899 => 0.000003298257 (n=12)

parseInt lebih cepat dari Math.floor

function floorFigure(figure, decimals){
    if (!decimals) decimals = 2;
    var d = Math.pow(10,decimals);
    return (parseInt(figure*d)/d).toFixed(decimals);
};

floorFigure(123.5999)    =>   "123.59"
floorFigure(123.5999, 3) =>   "123.599"

num = 19.66752
f = num.toFixed(3).slice(0,-1)
alert(f)

Ini akan mengembalikan 19,66

Sederhana lakukan ini

number = parseInt(number * 100)/100;

Solusi ini berhasil, tetapi bagi saya tampaknya tidak perlu rumit. Saya pribadi suka menggunakan operator modulus untuk mendapatkan sisa operasi divisi, dan menghapusnya. Dengan asumsi bahwa num = 15.7784514:

num-=num%.01;

Ini sama dengan mengatakan num = num - (num% .01).

Jawaban di sini tidak membantu saya, itu terus mengumpulkan atau memberi saya desimal yang salah.

solusi saya mengubah desimal Anda menjadi string, mengekstraksi karakter dan kemudian mengembalikan semuanya sebagai angka.

function Dec2(num) {
  num = String(num);
  if(num.indexOf('.') !== -1) {
    var numarr = num.split(".");
    if (numarr.length == 1) {
      return Number(num);
    }
    else {
      return Number(numarr[0]+"."+numarr[1].charAt(0)+numarr[1].charAt(1));
    }
  }
  else {
    return Number(num);
  }  
}

Dec2(99); // 99
Dec2(99.9999999); // 99.99
Dec2(99.35154); // 99.35
Dec2(99.8); // 99.8
Dec2(10265.985475); // 10265.98

Versi saya untuk angka positif:

function toFixed_norounding(n,p)
{
    var result = n.toFixed(p);
    return result <= n ? result: (result - Math.pow(0.1,p)).toFixed(p);
}

Cepat, cantik, jelas. (versi untuk angka positif)

Kode berikut berfungsi sangat baik untuk saya:

num.toString().match(/.\*\\..{0,2}|.\*/)[0];

Saya tetap menggunakan cara sederhana berikut-

var num = 15.7784514;
Math.floor(num*100)/100;

Hasilnya akan menjadi 15,77

Potong saja digit:

function truncDigits(inputNumber, digits) {
  const fact = 10 ** digits;
  return Math.floor(inputNumber * fact) / fact;
}

Solusi single-line lain:

number = Math.trunc(number*100)/100

Saya menggunakan 100 karena Anda ingin memotong ke digit kedua, tetapi solusi yang lebih fleksibel adalah:

number = Math.trunc(number*Math.pow(10, digits))/Math.pow(10, digits)

di mana digit adalah jumlah digit desimal yang harus disimpan.

Lihat spesifikasi Math.trunc untuk detail dan kompatibilitas browser.

Ini dia. Jawaban yang menunjukkan cara lain untuk menyelesaikan masalah:

// For the sake of simplicity, here is a complete function:
function truncate(numToBeTruncated, numOfDecimals) {
    var theNumber = numToBeTruncated.toString();
    var pointIndex = theNumber.indexOf('.');
    return +(theNumber.slice(0, pointIndex > -1 ? ++numOfDecimals + pointIndex : undefined));
}

Perhatikan penggunaan + sebelum ekspresi akhir. Yaitu untuk mengubah string terpotong kami yang terpotong kembali ke tipe angka.

Semoga ini bisa membantu!

terpotong tanpa nol

function toTrunc(value,n){  
    return Math.floor(value*Math.pow(10,n))/(Math.pow(10,n));
}

atau

function toTrunc(value,n){
    x=(value.toString()+".0").split(".");
    return parseFloat(x[0]+"."+x[1].substr(0,n));
}

uji:

toTrunc(17.4532,2)  //17.45
toTrunc(177.4532,1) //177.4
toTrunc(1.4532,1)   //1.4
toTrunc(.4,2)       //0.4

terpotong dengan nol

function toTruncFixed(value,n){
    return toTrunc(value,n).toFixed(n);
}

uji:

toTrunc(17.4532,2)  //17.45
toTrunc(177.4532,1) //177.4
toTrunc(1.4532,1)   //1.4
toTrunc(.4,2)       //0.40

Ini bekerja dengan baik untuk saya. Saya harap ini akan memperbaiki masalah Anda juga.

function toFixedNumber(number) {
    const spitedValues = String(number.toLocaleString()).split('.');
    let decimalValue = spitedValues.length > 1 ? spitedValues[1] : '';
    decimalValue = decimalValue.concat('00').substr(0,2);

    return '$'+spitedValues[0] + '.' + decimalValue;
}

// 5.56789      ---->  $5.56
// 0.342        ---->  $0.34
// -10.3484534  ---->  $-10.34 
// 600          ---->  $600.00

function convertNumber(){
  var result = toFixedNumber(document.getElementById("valueText").value);
  document.getElementById("resultText").value = result;
}


function toFixedNumber(number) {
        const spitedValues = String(number.toLocaleString()).split('.');
        let decimalValue = spitedValues.length > 1 ? spitedValues[1] : '';
        decimalValue = decimalValue.concat('00').substr(0,2);

        return '$'+spitedValues[0] + '.' + decimalValue;
}

<div>
  <input type="text" id="valueText" placeholder="Input value here..">
  <br>
  <button onclick="convertNumber()" >Convert</button>
  <br><hr>
  <input type="text" id="resultText" placeholder="result" readonly="true">
</div>

Cara mudah untuk melakukannya adalah yang berikutnya tetapi perlu memastikan bahwa parameter jumlah diberikan sebagai string.

function truncate(amountAsString, decimals = 2){
  var dotIndex = amountAsString.indexOf('.');
  var toTruncate = dotIndex !== -1  && ( amountAsString.length > dotIndex + decimals + 1);
  var approach = Math.pow(10, decimals);
  var amountToTruncate = toTruncate ? amountAsString.slice(0, dotIndex + decimals +1) : amountAsString;  
  return toTruncate
    ?  Math.floor(parseFloat(amountToTruncate) * approach ) / approach
    :  parseFloat(amountAsString);

}

console.log(truncate("7.99999")); //OUTPUT ==> 7.99
console.log(truncate("7.99999", 3)); //OUTPUT ==> 7.999
console.log(truncate("12.799999999999999")); //OUTPUT ==> 7.99

Saya menggunakan (num-0.05).toFixed(1)desimal kedua.

Solusi saya dalam naskah (dapat dengan mudah porting ke JS):

/**
 * Returns the price with correct precision as a string
 *
 * @param   price The price in decimal to be formatted.
 * @param   decimalPlaces The number of decimal places to use
 * @return  string The price in Decimal formatting.
 */
type toDecimal = (price: number, decimalPlaces?: number) => string;
const toDecimalOdds: toDecimal = (
  price: number,
  decimalPlaces: number = 2,
): string => {
  const priceString: string = price.toString();
  const pointIndex: number = priceString.indexOf('.');

  // Return the integer part if decimalPlaces is 0
  if (decimalPlaces === 0) {
    return priceString.substr(0, pointIndex);
  }

  // Return value with 0s appended after decimal if the price is an integer
  if (pointIndex === -1) {
    const padZeroString: string = '0'.repeat(decimalPlaces);

    return `${priceString}.${padZeroString}`;
  }

  // If numbers after decimal are less than decimalPlaces, append with 0s
  const padZeroLen: number = priceString.length - pointIndex - 1;
  if (padZeroLen > 0 && padZeroLen < decimalPlaces) {
    const padZeroString: string = '0'.repeat(padZeroLen);

    return `${priceString}${padZeroString}`;
  }

  return priceString.substr(0, pointIndex + decimalPlaces + 1);
};

Kasus uji:

  expect(filters.toDecimalOdds(3.14159)).toBe('3.14');
  expect(filters.toDecimalOdds(3.14159, 2)).toBe('3.14');
  expect(filters.toDecimalOdds(3.14159, 0)).toBe('3');
  expect(filters.toDecimalOdds(3.14159, 10)).toBe('3.1415900000');
  expect(filters.toDecimalOdds(8.2)).toBe('8.20');

Adakah perbaikan?

Gulung toFixedfungsi Anda sendiri : agar nilai positif Math.floorberfungsi dengan baik.

function toFixed(num, fixed) {
    fixed = fixed || 0;
    fixed = Math.pow(10, fixed);
    return Math.floor(num * fixed) / fixed;
}

Untuk nilai negatif Math.flooradalah nilai bulat. Jadi Anda bisa menggunakannya Math.ceil.

Contoh,

Math.ceil(-15.778665 * 10000) / 10000 = -15.7786
Math.floor(-15.778665 * 10000) / 10000 = -15.7787 // wrong.

Solusi kedua Gumbo, dengan ekspresi reguler, berfungsi tetapi lambat karena ekspresi reguler. Solusi pertama Gumbo gagal dalam situasi tertentu karena ketidaktepatan dalam angka floating point. Lihat JSFiddle untuk demonstrasi dan tolok ukur. Solusi kedua membutuhkan sekitar 1636 nanodetik per panggilan pada sistem saya saat ini, Intel Core i5-2500 CPU pada 3,30 GHz.

Solusi yang saya tulis melibatkan penambahan kompensasi kecil untuk menjaga ketidaktepatan floating point. Ini pada dasarnya instan, yaitu pada urutan nanodetik. Saya mencatat 2 nanodetik per panggilan tetapi pengatur waktu JavaScript tidak terlalu tepat atau terperinci. Ini JS Fiddle dan kodenya.

function toFixedWithoutRounding (value, precision)
{
    var factorError = Math.pow(10, 14);
    var factorTruncate = Math.pow(10, 14 - precision);
    var factorDecimal = Math.pow(10, precision);
    return Math.floor(Math.floor(value * factorError + 1) / factorTruncate) / factorDecimal;
}

var values = [1.1299999999, 1.13, 1.139999999, 1.14, 1.14000000001, 1.13 * 100];

for (var i = 0; i < values.length; i++)
{
    var value = values[i];
    console.log(value + " --> " + toFixedWithoutRounding(value, 2));
}

for (var i = 0; i < values.length; i++)
{
    var value = values[i];
    console.log(value + " --> " + toFixedWithoutRounding(value, 4));
}

console.log("type of result is " + typeof toFixedWithoutRounding(1.13 * 100 / 100, 2));

// Benchmark
var value = 1.13 * 100;
var startTime = new Date();
var numRun = 1000000;
var nanosecondsPerMilliseconds = 1000000;

for (var run = 0; run < numRun; run++)
    toFixedWithoutRounding(value, 2);

var endTime = new Date();
var timeDiffNs = nanosecondsPerMilliseconds * (endTime - startTime);
var timePerCallNs = timeDiffNs / numRun;
console.log("Time per call (nanoseconds): " + timePerCallNs);

Membangun jawaban David D :

function NumberFormat(num,n) {
  var num = (arguments[0] != null) ? arguments[0] : 0;
  var n = (arguments[1] != null) ? arguments[1] : 2;
  if(num > 0){
    num = String(num);
    if(num.indexOf('.') !== -1) {
      var numarr = num.split(".");
      if (numarr.length > 1) {
        if(n > 0){
          var temp = numarr[0] + ".";
          for(var i = 0; i < n; i++){
            if(i < numarr[1].length){
              temp += numarr[1].charAt(i);
            }
          }
          num = Number(temp);
        }
      }
    }
  }
  return Number(num);
}

console.log('NumberFormat(123.85,2)',NumberFormat(123.85,2));
console.log('NumberFormat(123.851,2)',NumberFormat(123.851,2));
console.log('NumberFormat(0.85,2)',NumberFormat(0.85,2));
console.log('NumberFormat(0.851,2)',NumberFormat(0.851,2));
console.log('NumberFormat(0.85156,2)',NumberFormat(0.85156,2));
console.log('NumberFormat(0.85156,4)',NumberFormat(0.85156,4));
console.log('NumberFormat(0.85156,8)',NumberFormat(0.85156,8));
console.log('NumberFormat(".85156",2)',NumberFormat(".85156",2));
console.log('NumberFormat("0.85156",2)',NumberFormat("0.85156",2));
console.log('NumberFormat("1005.85156",2)',NumberFormat("1005.85156",2));
console.log('NumberFormat("0",2)',NumberFormat("0",2));
console.log('NumberFormat("",2)',NumberFormat("",2));
console.log('NumberFormat(85156,8)',NumberFormat(85156,8));
console.log('NumberFormat("85156",2)',NumberFormat("85156",2));
console.log('NumberFormat("85156.",2)',NumberFormat("85156.",2));

// NumberFormat(123.85,2) 123.85
// NumberFormat(123.851,2) 123.85
// NumberFormat(0.85,2) 0.85
// NumberFormat(0.851,2) 0.85
// NumberFormat(0.85156,2) 0.85
// NumberFormat(0.85156,4) 0.8515
// NumberFormat(0.85156,8) 0.85156
// NumberFormat(".85156",2) 0.85
// NumberFormat("0.85156",2) 0.85
// NumberFormat("1005.85156",2) 1005.85
// NumberFormat("0",2) 0
// NumberFormat("",2) 0
// NumberFormat(85156,8) 85156
// NumberFormat("85156",2) 85156
// NumberFormat("85156.",2) 85156

Lebih dapat diandalkan untuk mendapatkan dua poin mengambang tanpa pembulatan.

Jawaban Referensi

var number = 10.5859;
var fixed2FloatPoints = parseInt(number * 100) / 100;
console.log(fixed2FloatPoints);

Terima kasih !

Sudah ada beberapa jawaban yang cocok dengan ekspresi reguler dan perhitungan aritmatika, Anda juga dapat mencoba ini

function myFunction() {
    var str = 12.234556; 
    str = str.toString().split('.');
    var res = str[1].slice(0, 2);
    document.getElementById("demo").innerHTML = str[0]+'.'+res;
}

// output: 12.23

Inilah yang dilakukan dengan string

export function withoutRange(number) {
  const str = String(number);
  const dotPosition = str.indexOf('.');
  if (dotPosition > 0) {
    const length = str.substring().length;
    const end = length > 3 ? 3 : length;
    return str.substring(0, dotPosition + end);
  }
  return str;
}

Semua jawaban ini agak rumit. Saya hanya akan mengurangi 0,5 dari nomor Anda dan gunakan toFixed ().

Solusi paling efisien (untuk 2 digit pecahan) adalah dengan mengurangi 0,005 sebelum menelepon toFixed()

function toFixed2( num ) { return (num-0.005).toFixed(2) }

Angka negatif juga akan dibulatkan ke bawah (jauh dari nol). OP tidak memberi tahu apa-apa tentang angka negatif.

Saya tahu sudah ada beberapa contoh kerja, tapi saya pikir layak untuk mengusulkan setara String.toFixed saya, beberapa mungkin merasa bermanfaat.

Itu alternatif toFixed saya, yang tidak membulatkan angka, hanya memotongnya atau menambahkan nol sesuai dengan presisi yang diberikan. Untuk angka ekstra panjang ia menggunakan pembulatan bawaan JS saat presisi terlalu panjang. Fungsi berfungsi untuk semua nomor bermasalah yang saya temukan di tumpukan.

function toFixedFixed(value, precision = 0) {
    let stringValue = isNaN(+value) ? '0' : String(+value);

    if (stringValue.indexOf('e') > -1 || stringValue === 'Infinity' || stringValue === '-Infinity') {
        throw new Error('To large number to be processed');
    }

    let [ beforePoint, afterPoint ] = stringValue.indexOf('.') > -1 ? stringValue.split('.') : [ stringValue, ''];

    // Force automatic rounding for some long real numbers that ends with 99X, by converting it to string, cutting off last digit, then adding extra nines and casting it on number again
    // e.g. 2.0199999999999996: +('2.019999999999999' + '9999') will give 2.02
    if (stringValue.length >= 17 && afterPoint.length > 2 && +afterPoint.substr(afterPoint.length - 3) > 995) {
        stringValue = String(+(stringValue.substr(0, afterPoint.length - 1) + '9'.repeat(stringValue.split('.').shift().length + 4)));
        [ beforePoint, afterPoint ] = String(stringValue).indexOf('.') > -1 ? stringValue.split('.') : [ stringValue, ''];
    }

    if (precision === 0) {
        return beforePoint;
    } else if (afterPoint.length > precision) {
        return `${beforePoint}.${afterPoint.substr(0, precision)}`;
    } else {
        return `${beforePoint}.${afterPoint}${'0'.repeat(precision - afterPoint.length)}`;
    }
}

Ingatlah bahwa presisi mungkin tidak ditangani dengan benar untuk jumlah panjang 18 dan lebih besar, misalnya Chrome 64-bit akan membulatkannya atau menambahkan "e +" / "e-" untuk menjaga panjang angka pada 18.

Jika Anda ingin melakukan operasi pada bilangan real, lebih aman untuk melipatgandakannya Math.sqrt(10, precision)terlebih dahulu, membuat perhitungan, lalu menyelam hasilnya dengan nilai pengganda.

Contoh:

0.06 + 0.01adalah 0.06999999999999999, dan setiap fungsi pemformatan yang tidak pembulatan akan memotongnya 0.06untuk presisi 2.

Tetapi jika Anda akan melakukan operasi yang sama dengan pengganda & pembagi:, (0.06 * 100 + 0.01 * 100) / 100Anda akan mendapatkannya 0.07.

Itulah mengapa sangat penting untuk menggunakan pengganda / pembagi seperti itu ketika berhadapan dengan bilangan real dalam javascript, terutama ketika Anda sedang menghitung uang ...