Saya memiliki baris kode ini yang membulatkan angka saya ke dua tempat desimal. Tetapi saya mendapatkan angka seperti ini: 10.8, 2.4, dll. Ini bukan ide saya tentang dua tempat desimal jadi bagaimana saya dapat meningkatkan yang berikut?

Math.round(price*Math.pow(10,2))/Math.pow(10,2);

Saya ingin angka seperti 10.80, 2.40, dll. Penggunaan jQuery tidak masalah bagi saya.

Untuk memformat angka menggunakan notasi titik tetap, Anda cukup menggunakan metode toFixed :

(10.8).toFixed(2); // "10.80"

var num = 2.4;
alert(num.toFixed(2)); // "2.40"

Perhatikan bahwa toFixed()mengembalikan string.

PENTING : Perhatikan bahwa toFixed tidak membulatkan 90% dari waktu, itu akan mengembalikan nilai bulat, tetapi untuk banyak kasus, itu tidak berfungsi.

Contohnya:

2.005.toFixed(2) === "2.00"

MEMPERBARUI:

Saat ini, Anda dapat menggunakan Intl.NumberFormatkonstruktor. Itu bagian dari Spesifikasi API Internasionalisasi Script ECMAS (ECMA402). Ini memiliki cukup dukungan yang baik peramban , bahkan termasuk IE11, dan itu didukung sepenuhnya di Node.js .

const formatter = new Intl.NumberFormat('en-US', {
   minimumFractionDigits: 2,      
   maximumFractionDigits: 2,
});

console.log(formatter.format(2.005)); // "2.01"
console.log(formatter.format(1.345)); // "1.35"

Anda juga dapat menggunakan toLocaleStringmetode ini, yang secara internal akan menggunakan IntlAPI:

const format = (num, decimals) => num.toLocaleString('en-US', {
   minimumFractionDigits: 2,      
   maximumFractionDigits: 2,
});


console.log(format(2.005)); // "2.01"
console.log(format(1.345)); // "1.35"

API ini juga memberi Anda beragam opsi untuk diformat, seperti ribuan pemisah, simbol mata uang, dll.

Ini adalah topik lama tetapi hasil Google masih peringkat teratas dan solusi yang ditawarkan berbagi masalah desimal titik mengambang yang sama. Ini adalah fungsi (sangat umum) yang saya gunakan, terima kasih kepada MDN :

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

Seperti yang bisa kita lihat, kita tidak mendapatkan masalah ini:

round(1.275, 2);   // Returns 1.28
round(1.27499, 2); // Returns 1.27

Kemurahan hati ini juga menyediakan beberapa hal keren:

round(1234.5678, -2);   // Returns 1200
round(1.2345678e+2, 2); // Returns 123.46
round("123.45");        // Returns 123

Sekarang, untuk menjawab pertanyaan OP, kita harus mengetik:

round(10.8034, 2).toFixed(2); // Returns "10.80"
round(10.8, 2).toFixed(2);    // Returns "10.80"

Atau, untuk fungsi yang lebih ringkas, kurang generik:

function round2Fixed(value) {
  value = +value;

  if (isNaN(value))
    return NaN;

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

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

Anda dapat menyebutnya dengan:

round2Fixed(10.8034); // Returns "10.80"
round2Fixed(10.8);    // Returns "10.80"

Berbagai contoh dan tes (terima kasih kepada @ tj-crowder !):

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));
}
function naive(value, exp) {
  if (!exp) {
    return Math.round(value);
  }
  var pow = Math.pow(10, exp);
  return Math.round(value * pow) / pow;
}
function test(val, places) {
  subtest(val, places);
  val = typeof val === "string" ? "-" + val : -val;
  subtest(val, places);
}
function subtest(val, places) {
  var placesOrZero = places || 0;
  var naiveResult = naive(val, places);
  var roundResult = round(val, places);
  if (placesOrZero >= 0) {
    naiveResult = naiveResult.toFixed(placesOrZero);
    roundResult = roundResult.toFixed(placesOrZero);
  } else {
    naiveResult = naiveResult.toString();
    roundResult = roundResult.toString();
  }
  $("<tr>")
    .append($("<td>").text(JSON.stringify(val)))
    .append($("<td>").text(placesOrZero))
    .append($("<td>").text(naiveResult))
    .append($("<td>").text(roundResult))
    .appendTo("#results");
}
test(0.565, 2);
test(0.575, 2);
test(0.585, 2);
test(1.275, 2);
test(1.27499, 2);
test(1234.5678, -2);
test(1.2345678e+2, 2);
test("123.45");
test(10.8034, 2);
test(10.8, 2);
test(1.005, 2);
test(1.0005, 2);

table {
  border-collapse: collapse;
}
table, td, th {
  border: 1px solid #ddd;
}
td, th {
  padding: 4px;
}
th {
  font-weight: normal;
  font-family: sans-serif;
}
td {
  font-family: monospace;
}

<table>
  <thead>
    <tr>
      <th>Input</th>
      <th>Places</th>
      <th>Naive</th>
      <th>Thorough</th>
    </tr>
  </thead>
  <tbody id="results">
  </tbody>
</table>
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>

Saya biasanya menambahkan ini ke perpustakaan pribadi saya, dan setelah beberapa saran dan menggunakan solusi @TIMINeutron juga, dan membuatnya dapat disesuaikan untuk panjang desimal, yang ini paling cocok:

function precise_round(num, decimals) {
   var t = Math.pow(10, decimals);   
   return (Math.round((num * t) + (decimals>0?1:0)*(Math.sign(num) * (10 / Math.pow(100, decimals)))) / t).toFixed(decimals);
}

akan bekerja untuk pengecualian yang dilaporkan.

Saya tidak tahu mengapa saya tidak dapat menambahkan komentar pada jawaban sebelumnya (mungkin saya buta tanpa harapan, tidak tahu), tetapi saya menemukan solusi menggunakan jawaban @ Miguel:

function precise_round(num,decimals) {
   return Math.round(num*Math.pow(10, decimals)) / Math.pow(10, decimals);
}

Dan dua komentarnya (dari @bighostkim dan @Imre):

• Masalah dengan precise_round(1.275,2) tidak mengembalikan 1.28
• Masalah dengan precise_round(6,2)tidak mengembalikan 6,00 (seperti yang dia inginkan).

Solusi terakhir saya adalah sebagai berikut:

function precise_round(num,decimals) {
    var sign = num >= 0 ? 1 : -1;
    return (Math.round((num*Math.pow(10,decimals)) + (sign*0.001)) / Math.pow(10,decimals)).toFixed(decimals);
}

Seperti yang Anda lihat saya harus menambahkan sedikit "koreksi" (bukan itu yang sebenarnya, tetapi karena Math.round adalah lossy - Anda dapat memeriksanya di jsfiddle.net - ini adalah satu-satunya cara saya tahu bagaimana "memperbaiki" " Itu). Itu menambahkan 0,001 ke angka yang sudah empuk, jadi itu menambahkan 1tiga 0s di sebelah kanan nilai desimal. Jadi harus aman digunakan.

Setelah itu saya menambahkan .toFixed(decimal)untuk selalu menampilkan angka dalam format yang benar (dengan jumlah desimal yang tepat).

Jadi cukup banyak. Gunakan dengan baik;)

EDIT: menambahkan fungsionalitas ke "koreksi" angka negatif.

Salah satu cara untuk menjadi 100% yakin bahwa Anda mendapatkan nomor dengan 2 desimal:

(Math.round(num*100)/100).toFixed(2)

Jika ini menyebabkan kesalahan pembulatan, Anda dapat menggunakan yang berikut seperti yang dijelaskan James dalam komentarnya:

(Math.round((num * 1000)/10)/100).toFixed(2)

toFixed (n) memberikan n panjang setelah titik desimal; toPrecision (x) memberikan x total panjang.

Gunakan metode ini di bawah ini

// Example: toPrecision(4) when the number has 7 digits (3 before, 4 after)
    // It will round to the tenths place
    num = 500.2349;
    result = num.toPrecision(4); // result will equal 500.2

DAN jika Anda ingin nomor diperbaiki, gunakan

result = num.toFixed(2);

Saya tidak menemukan solusi yang akurat untuk masalah ini, jadi saya buat sendiri:

function inprecise_round(value, decPlaces) {
  return Math.round(value*Math.pow(10,decPlaces))/Math.pow(10,decPlaces);
}

function precise_round(value, decPlaces){
    var val = value * Math.pow(10, decPlaces);
    var fraction = (Math.round((val-parseInt(val))*10)/10);

    //this line is for consistency with .NET Decimal.Round behavior
    // -342.055 => -342.06
    if(fraction == -0.5) fraction = -0.6;

    val = Math.round(parseInt(val) + fraction) / Math.pow(10, decPlaces);
    return val;
}

Contoh:

function inprecise_round(value, decPlaces) {
  return Math.round(value * Math.pow(10, decPlaces)) / Math.pow(10, decPlaces);
}

function precise_round(value, decPlaces) {
  var val = value * Math.pow(10, decPlaces);
  var fraction = (Math.round((val - parseInt(val)) * 10) / 10);

  //this line is for consistency with .NET Decimal.Round behavior
  // -342.055 => -342.06
  if (fraction == -0.5) fraction = -0.6;

  val = Math.round(parseInt(val) + fraction) / Math.pow(10, decPlaces);
  return val;
}

// This may produce different results depending on the browser environment
console.log("342.055.toFixed(2)         :", 342.055.toFixed(2)); // 342.06 on Chrome & IE10

console.log("inprecise_round(342.055, 2):", inprecise_round(342.055, 2)); // 342.05
console.log("precise_round(342.055, 2)  :", precise_round(342.055, 2));   // 342.06
console.log("precise_round(-342.055, 2) :", precise_round(-342.055, 2));  // -342.06

console.log("inprecise_round(0.565, 2)  :", inprecise_round(0.565, 2));   // 0.56
console.log("precise_round(0.565, 2)    :", precise_round(0.565, 2));     // 0.57

@heridev dan saya membuat fungsi kecil di jQuery.

Anda dapat mencoba selanjutnya:

HTML

<input type="text" name="one" class="two-digits"><br>
<input type="text" name="two" class="two-digits">​

jQuery

// apply the two-digits behaviour to elements with 'two-digits' as their class
$( function() {
    $('.two-digits').keyup(function(){
        if($(this).val().indexOf('.')!=-1){         
            if($(this).val().split(".")[1].length > 2){                
                if( isNaN( parseFloat( this.value ) ) ) return;
                this.value = parseFloat(this.value).toFixed(2);
            }  
         }            
         return this; //for chaining
    });
});

DEMO ONLINE:

http://jsfiddle.net/c4Wqn/

Masalahnya dengan nilai floating point adalah mereka mencoba untuk mewakili jumlah tak terhingga dari nilai (kontinu) dengan jumlah bit yang tetap. Jadi secara alami, pasti ada beberapa kerugian dalam permainan, dan Anda akan digigit dengan beberapa nilai.

Ketika komputer menyimpan 1.275 sebagai nilai floating point, itu tidak akan benar-benar mengingat apakah itu 1.275 atau 1.27499999999999993, atau bahkan 1.27500000000000002.0. Nilai-nilai ini harus memberikan hasil yang berbeda setelah membulatkan ke dua desimal, tetapi tidak akan, karena untuk komputer mereka terlihat sama persis setelah disimpan sebagai nilai floating point, dan tidak ada cara untuk mengembalikan data yang hilang. Setiap perhitungan lebih lanjut hanya akan mengakumulasi ketidaktepatan tersebut.

Jadi, jika presisi penting, Anda harus menghindari nilai floating point dari awal. Opsi yang paling sederhana adalah

• gunakan perpustakaan khusus
• gunakan string untuk menyimpan dan mengedarkan nilai-nilai (disertai dengan operasi string)
• gunakan bilangan bulat (mis. Anda bisa memberikan sekitar seperseratus dari nilai aktual Anda, mis. jumlah dalam sen, bukan jumlah dalam dolar)

Misalnya, ketika menggunakan bilangan bulat untuk menyimpan jumlah seratus, fungsi untuk menemukan nilai sebenarnya cukup sederhana:

function descale(num, decimals) {
    var hasMinus = num < 0;
    var numString = Math.abs(num).toString();
    var precedingZeroes = '';
    for (var i = numString.length; i <= decimals; i++) {
        precedingZeroes += '0';
    }
    numString = precedingZeroes + numString;
    return (hasMinus ? '-' : '') 
        + numString.substr(0, numString.length-decimals) 
        + '.' 
        + numString.substr(numString.length-decimals);
}

alert(descale(127, 2));

Dengan string, Anda perlu pembulatan, tetapi masih dapat dikelola:

function precise_round(num, decimals) {
    var parts = num.split('.');
    var hasMinus = parts.length > 0 && parts[0].length > 0 && parts[0].charAt(0) == '-';
    var integralPart = parts.length == 0 ? '0' : (hasMinus ? parts[0].substr(1) : parts[0]);
    var decimalPart = parts.length > 1 ? parts[1] : '';
    if (decimalPart.length > decimals) {
        var roundOffNumber = decimalPart.charAt(decimals);
        decimalPart = decimalPart.substr(0, decimals);
        if ('56789'.indexOf(roundOffNumber) > -1) {
            var numbers = integralPart + decimalPart;
            var i = numbers.length;
            var trailingZeroes = '';
            var justOneAndTrailingZeroes = true;
            do {
                i--;
                var roundedNumber = '1234567890'.charAt(parseInt(numbers.charAt(i)));
                if (roundedNumber === '0') {
                    trailingZeroes += '0';
                } else {
                    numbers = numbers.substr(0, i) + roundedNumber + trailingZeroes;
                    justOneAndTrailingZeroes = false;
                    break;
                }
            } while (i > 0);
            if (justOneAndTrailingZeroes) {
                numbers = '1' + trailingZeroes;
            }
            integralPart = numbers.substr(0, numbers.length - decimals);
            decimalPart = numbers.substr(numbers.length - decimals);
        }
    } else {
        for (var i = decimalPart.length; i < decimals; i++) {
            decimalPart += '0';
        }
    }
    return (hasMinus ? '-' : '') + integralPart + (decimals > 0 ? '.' + decimalPart : '');
}

alert(precise_round('1.275', 2));
alert(precise_round('1.27499999999999993', 2));

Perhatikan bahwa fungsi ini membulatkan ke terdekat, mengikat jauh dari nol , sementara IEEE 754 merekomendasikan pembulatan ke terdekat, mengikat bahkan sebagai perilaku default untuk operasi floating point. Modifikasi semacam itu dibiarkan sebagai latihan bagi pembaca :)

Ini yang sederhana

function roundFloat(num,dec){
    var d = 1;
    for (var i=0; i<dec; i++){
        d += "0";
    }
    return Math.round(num * d) / d;
}

Gunakan seperti alert(roundFloat(1.79209243929,4));

Jsfiddle

Bulatkan nilai desimal Anda, lalu gunakan toFixed(x)untuk angka yang Anda harapkan.

function parseDecimalRoundAndFixed(num,dec){
  var d =  Math.pow(10,dec);
  return (Math.round(num * d) / d).toFixed(dec);
}

Panggilan

parseDecimalRoundAndFixed (10.800243929,4) => 10.80 parseDecimalRoundAndFixed (10.807243929,2) => 10.81

Membulatkan ke bawah

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

Pembulatan

function round_up(value, decPlaces) {
    return Math.ceil(value * Math.pow(10, decPlaces)) / Math.pow(10, decPlaces);
}

Sekitar terdekat

function round_nearest(value, decPlaces) {
    return Math.round(value * Math.pow(10, decPlaces)) / Math.pow(10, decPlaces);
}

Digabung https://stackoverflow.com/a/7641824/1889449 dan https://www.kirupa.com/html5/rounding_numbers_in_javascript.htm Terima kasih mereka.

Inilah solusi 1-line saya: Number((yourNumericValueHere).toFixed(2));

Inilah yang terjadi:

1) Pertama, Anda menerapkan .toFixed(2)ke nomor yang Anda ingin membulatkan tempat desimal. Perhatikan bahwa ini akan mengubah nilai menjadi string dari angka. Jadi, jika Anda menggunakan TypeScript, itu akan menimbulkan kesalahan seperti ini:

"Ketik 'string' tidak dapat ditentukan untuk mengetik 'angka'"

2) Untuk mendapatkan kembali nilai numerik atau untuk mengubah string ke nilai numerik, cukup terapkan Number() fungsi pada apa yang disebut nilai 'string'.

Untuk klarifikasi, lihat contoh di bawah ini:

CONTOH: Saya memiliki jumlah yang memiliki hingga 5 digit di tempat desimal dan saya ingin mempersingkatnya menjadi hingga 2 tempat desimal. Saya melakukannya seperti ini:

var price = 0.26453;
var priceRounded = Number((price).toFixed(2));
console.log('Original Price: ' + price);
console.log('Price Rounded: ' + priceRounded);

Letakkan yang berikut ini di beberapa ruang lingkup global:

Number.prototype.getDecimals = function ( decDigCount ) {
   return this.toFixed(decDigCount);
}

dan kemudian coba :

var a = 56.23232323;
a.getDecimals(2); // will return 56.23

Memperbarui

Perhatikan bahwa toFixed()hanya dapat bekerja untuk jumlah desimal antara 0-20yaitu a.getDecimals(25)dapat menghasilkan kesalahan javascript, sehingga untuk mengakomodasi bahwa Anda dapat menambahkan beberapa pemeriksaan tambahan yaitu

Number.prototype.getDecimals = function ( decDigCount ) {
   return ( decDigCount > 20 ) ? this : this.toFixed(decDigCount);
}

Number(((Math.random() * 100) + 1).toFixed(2))

ini akan mengembalikan angka acak dari 1 hingga 100 dibulatkan ke 2 tempat desimal.

Number(Math.round(1.005+'e2')+'e-2'); // 1.01

Ini bekerja untuk saya: Membulatkan Desimal dalam JavaScript

Menggunakan respons ini dengan referensi: https://stackoverflow.com/a/21029698/454827

Saya membangun fungsi untuk mendapatkan angka desimal dinamis:

function toDec(num, dec)
{
        if(typeof dec=='undefined' || dec<0)
                dec = 2;

        var tmp = dec + 1;
        for(var i=1; i<=tmp; i++)
                num = num * 10;

        num = num / 10;
        num = Math.round(num);
        for(var i=1; i<=dec; i++)
                num = num / 10;

        num = num.toFixed(dec);

        return num;
}

di sini contoh kerja: https://jsfiddle.net/wpxLduLc/

Dengan contoh-contoh ini Anda masih akan mendapatkan kesalahan saat mencoba membulatkan angka 1,005 solusinya adalah dengan menggunakan perpustakaan seperti Math.js atau fungsi ini:

function round(value: number, decimals: number) {
    return Number(Math.round(value + 'e' + decimals) + 'e-' + decimals);
}

Saya mendapat beberapa gagasan dari posting ini beberapa bulan yang lalu, tetapi tidak ada jawaban di sini, maupun jawaban dari posting / blog lain yang dapat menangani semua skenario (mis. Angka negatif dan beberapa "angka keberuntungan" yang ditemukan oleh penguji kami). Pada akhirnya, penguji kami tidak menemukan masalah dengan metode ini di bawah ini. Menempelkan cuplikan kode saya:

fixPrecision: function (value) {
    var me = this,
        nan = isNaN(value),
        precision = me.decimalPrecision;

    if (nan || !value) {
        return nan ? '' : value;
    } else if (!me.allowDecimals || precision <= 0) {
        precision = 0;
    }

    //[1]
    //return parseFloat(Ext.Number.toFixed(parseFloat(value), precision));
    precision = precision || 0;
    var negMultiplier = value < 0 ? -1 : 1;

    //[2]
    var numWithExp = parseFloat(value + "e" + precision);
    var roundedNum = parseFloat(Math.round(Math.abs(numWithExp)) + 'e-' + precision) * negMultiplier;
    return parseFloat(roundedNum.toFixed(precision));
},

Saya juga punya komentar kode (maaf saya sudah lupa semua detailnya) ... Saya memposting jawaban saya di sini untuk referensi di masa mendatang:

9.995 * 100 = 999.4999999999999
Whereas 9.995e2 = 999.5
This discrepancy causes Math.round(9.995 * 100) = 999 instead of 1000.
Use e notation instead of multiplying /dividing by Math.Pow(10,precision).

Saya memperbaiki masalah pengubah. Hanya mendukung 2 desimal.

$(function(){
  //input number only.
  convertNumberFloatZero(22); // output : 22.00
  convertNumberFloatZero(22.5); // output : 22.50
  convertNumberFloatZero(22.55); // output : 22.55
  convertNumberFloatZero(22.556); // output : 22.56
  convertNumberFloatZero(22.555); // output : 22.55
  convertNumberFloatZero(22.5541); // output : 22.54
  convertNumberFloatZero(22222.5541); // output : 22,222.54

  function convertNumberFloatZero(number){
	if(!$.isNumeric(number)){
		return 'NaN';
	}
	var numberFloat = number.toFixed(3);
	var splitNumber = numberFloat.split(".");
	var cNumberFloat = number.toFixed(2);
	var cNsplitNumber = cNumberFloat.split(".");
	var lastChar = splitNumber[1].substr(splitNumber[1].length - 1);
	if(lastChar > 0 && lastChar < 5){
		cNsplitNumber[1]--;
	}
	return Number(splitNumber[0]).toLocaleString('en').concat('.').concat(cNsplitNumber[1]);
  };
});

<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.9.1/jquery.min.js"></script>

(Math.round((10.2)*100)/100).toFixed(2)

Itu harus menghasilkan: 10.20

(Math.round((.05)*100)/100).toFixed(2)

Itu harus menghasilkan: 0.05

(Math.round((4.04)*100)/100).toFixed(2)

Itu harus menghasilkan: 4.04

dll.

Ini sangat sederhana dan berfungsi sama baiknya dengan yang lain:

function parseNumber(val, decimalPlaces) {
    if (decimalPlaces == null) decimalPlaces = 0
    var ret = Number(val).toFixed(decimalPlaces)
    return Number(ret)
}

Karena toFixed () hanya dapat dipanggil pada angka, dan sayangnya mengembalikan sebuah string, ini membuat semua parsing untuk Anda di kedua arah. Anda dapat melewati string atau angka, dan Anda mendapatkan nomor kembali setiap kali! Memanggil parseNumber (1,49) akan memberi Anda 1, dan parseNumber (1,49,2) akan memberi Anda 1,50. Sama seperti yang terbaik dari mereka!

Anda juga bisa menggunakan .toPrecision()metode dan beberapa kode khusus, dan selalu membulatkan ke angka desimal ke-n terlepas dari panjang bagian int.

function glbfrmt (number, decimals, seperator) {
    return typeof number !== 'number' ? number : number.toPrecision( number.toString().split(seperator)[0].length + decimals);
}

Anda juga bisa menjadikannya plugin untuk penggunaan yang lebih baik.

Sesederhana ini.

var rounded_value=Math.round(value * 100) / 100;

Saya menemukan cara yang sangat sederhana yang memecahkan masalah ini untuk saya dan dapat digunakan atau diadaptasi:

td[row].innerHTML = price.toPrecision(price.toFixed(decimals).length

100% berfungsi !!! Cobalah

<html>
     <head>
      <script>
      function replacePonto(){
        var input = document.getElementById('qtd');
        var ponto = input.value.split('.').length;
        var slash = input.value.split('-').length;
        if (ponto > 2)
                input.value=input.value.substr(0,(input.value.length)-1);

        if(slash > 2)
                input.value=input.value.substr(0,(input.value.length)-1);

        input.value=input.value.replace(/[^0-9.-]/,'');

        if (ponto ==2)
	input.value=input.value.substr(0,(input.value.indexOf('.')+3));

if(input.value == '.')
	input.value = "";
              }
      </script>
      </head>
      <body>
         <input type="text" id="qtd" maxlength="10" style="width:140px" onkeyup="return replacePonto()">
      </body>
    </html>