Numaralarımı iki ondalık basamağa yuvarlayan kodun bu satırı var. Ama bunun gibi sayılar alıyorum: 10.8, 2.4, vs. Bunlar iki ondalık basamak fikrim değil, aşağıdakileri nasıl geliştirebilirim?

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

10.80, 2.40 vb. Numaralar istiyorum. JQuery kullanımı benim için sorun değil.

Bir sayıyı sabit nokta notasyonunu kullanarak biçimlendirmek için toFixed yöntemini kullanabilirsiniz :

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

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

toFixed()Bir dize döndürdüğünü unutmayın .

ÖNEMLİ : toFixed'in zamanın% 90'ını yuvarlamadığını, yuvarlanan değeri döndüreceğini unutmayın, ancak çoğu durumda çalışmaz.

Örneğin:

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

GÜNCELLEME:

Günümüzde yapıcıyı kullanabilirsiniz Intl.NumberFormat. BT adlı parçası ECMAScript Uluslararasılaşma API Şartname (ECMA402). IE11 bile dahil olmak üzere oldukça iyi tarayıcı desteğine sahiptir ve Node.js'de tamamen desteklenir .

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"

Alternatif olarak toLocaleString, dahili olarak IntlAPI'yı kullanacak yöntemi kullanabilirsiniz :

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"

Bu API ayrıca, bin ayırıcı, para birimi simgesi vb. Gibi biçimlendirmek için çok çeşitli seçenekler sunar.

Bu eski bir konudur, ancak yine de en üst sıradaki Google sonuçlarıdır ve sunulan çözümler aynı kayan nokta ondalık sayıları sorununu paylaşmaktadır. MDN sayesinde kullandığım (çok genel) fonksiyon :

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

Gördüğümüz gibi, bu sorunları alamıyoruz:

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

Bu jeneriklik bazı harika şeyler de sağlar:

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

Şimdi, OP'nin sorusunu cevaplamak için aşağıdakileri yazmalısınız:

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

Veya daha kısa ve daha genel bir işlev için:

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

Şununla arayabilirsiniz:

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

Çeşitli örnekler ve testler ( @ tj-crowder sayesinde !):

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>

Bunu genellikle kişisel kütüphaneme ekliyorum ve bazı önerilerden sonra ve @TIMINeutron çözümünü kullanarak ve ondalık uzunluk için uyarlanabilir hale getirdikten sonra, bu en iyi uyuyor:

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

bildirilen istisnalar için çalışacaktır.

Neden önceki bir cevaba yorum ekleyemiyorum bilmiyorum (belki umutsuzca kör, dunno), ama @ Miguel'in cevabını kullanarak bir çözüm buldum:

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

Ve iki yorumu (@bighostkim ve @Imre'den):

• Geri dönmeme sorunu precise_round(1.275,2)1.28
• precise_round(6,2)(İstediği gibi) 6,00 döndürmüyor sorun .

Son çözümüm şöyledir:

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

Gördüğünüz gibi biraz "düzeltme" eklemek zorunda kaldım. " o). Zaten doldurulmuş sayıya 0.001 ekler, bu nedenle ondalık değerin sağına 1üç 0s ekler . Bu yüzden kullanmak güvenli olmalıdır.

Bundan sonra .toFixed(decimal)sayıyı her zaman doğru biçimde (doğru ondalık sayılarla) çıktıya ekledim .

Yani bu kadar. İyi kullan ;)

EDIT: negatif sayıların "düzeltilmesi" için işlevsellik eklendi.

2 ondalık sayı içeren bir sayı aldığınızdan% 100 emin olmanın bir yolu:

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

Bu yuvarlama hatalarına neden olursa, James'in yorumunda açıkladığı gibi aşağıdakileri kullanabilirsiniz:

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

toFixed (n), ondalık noktadan sonra n uzunluk sağlar; toPrecision (x), x toplam uzunluk sağlar.

Aşağıdaki yöntemi kullanın

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

VE eğer numaranın sabit olmasını istiyorsanız

result = num.toFixed(2);

Bu sorun için doğru bir çözüm bulamadım, bu yüzden kendi sorunumu yarattım:

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

Örnekler:

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 ve ben jQuery küçük bir işlev oluşturdu.

Şimdi deneyebilirsiniz:

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/

Kayan nokta değerlerindeki sorun, sabit miktarda bitle sonsuz miktarda (sürekli) değer göstermeye çalışmalarıdır. Doğal olarak, oyunda biraz kayıp olmalı ve bazı değerlerle ısırılmış olacaksınız.

Bir bilgisayar 1.275'i kayan nokta değeri olarak depoladığında, bunun 1.275 veya 1.27499999999999993, hatta 1.27500000000000002 olup olmadığını gerçekten hatırlamaz. Bu değerler iki ondalık sayıya yuvarlandıktan sonra farklı sonuçlar vermelidir, ancak bilgisayar için kayan nokta değerleri olarak saklandıktan sonra tam olarak aynı göründüklerinden ve kaybolan verileri geri yüklemenin bir yolu olmadığından, bu değerler farklı sonuçlar vermelidir . Başka hesaplamalar sadece böyle bir kesinsizlik biriktirecektir.

Dolayısıyla, hassasiyet önemliyse, başlangıçtan itibaren kayan nokta değerlerinden kaçınmanız gerekir. En basit seçenekler

• Bir kullanmak fedakar kütüphane
• değerlerin saklanması ve etrafından geçirilmesi için dizeleri kullanma (string işlemleri eşliğinde)
• tamsayılar kullanın (örneğin, gerçek değerin yüzde biri kadarını geçiyor olabilirsiniz, örneğin dolar cinsinden miktar yerine sent cinsinden tutar)

Örneğin, yüzde birlik sayısını saklamak için tamsayılar kullanırken, gerçek değeri bulma işlevi oldukça basittir:

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

Dizelerle yuvarlamaya ihtiyacınız olacak, ancak yine de yönetilebilir:

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

Bu işlevin en yakına yuvarlandığını , sıfırdan uzağa bağlandığını , IEEE 754 ise en yakın noktaya yuvarlamayı önerirken kayan nokta işlemleri için varsayılan davranış olarak bile . Bu tür değişiklikler okuyucu için bir egzersiz olarak bırakılır :)

İşte basit bir tane

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

Gibi kullanın alert(roundFloat(1.79209243929,4));

Jsfiddle

Ondalık değerinizi yuvarlayın, ardından toFixed(x)beklenen rakamlarınız için kullanın .

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

Aramak

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

Aşağı yuvarlama

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

Hesabı yuvarlamak

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

En yakın yuvarlak

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

Https://stackoverflow.com/a/7641824/1889449 ve https://www.kirupa.com/html5/rounding_numbers_in_javascript.htm Birleştirildi Teşekkürler.

İşte benim 1 satırlık çözüm: Number((yourNumericValueHere).toFixed(2));

İşte olanlar:

1) Öncelikle, .toFixed(2)ondalık basamaklarını yuvarlamak istediğiniz sayıya uygulanır . Bunun, değeri sayıdan bir dizeye dönüştüreceğini unutmayın. Eğer daktilo kullanıyorsanız, bu böyle bir hata atar:

"'String' tipi 'number' yazmak için atanamaz"

2) Sayısal değeri geri almak veya dizeyi sayısal değere dönüştürmek için Number() işlevi 'dize' değerine uygulayın.

Açıklama için aşağıdaki örneğe bakın:

ÖRNEK: Ondalık basamaklarda 5 basamağa kadar olan bir miktarım var ve 2 ondalık basamağa kadar kısaltmak istiyorum. Bunu şöyle yaparım:

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

Aşağıdakileri bazı küresel kapsamlara koyun :

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

ve sonra şunu deneyin :

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

Güncelleme

Not toFixed()arasındaki ondalık basamak sayısı için sadece çalışabilir 0-20yani a.getDecimals(25), bir javascript hata verebilir böylece bazı ek onay ie eklemek olabileceğini karşılamak için

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

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

bu 1'den 100'e yuvarlanmış ve 2 ondalık basamağa rastgele bir sayı döndürür.

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

Bu benim için çalıştı: JavaScript Decimals yuvarlama

Bu yanıtı referans olarak kullanarak: https://stackoverflow.com/a/21029698/454827

Dinamik ondalık sayıları almak için bir işlev oluşturmak:

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

burada çalışan örnek: https://jsfiddle.net/wpxLduLc/

Bu örneklerle, 1.005 sayısını yuvarlamaya çalışırken bir hata alırsınız, çözüm Math.js gibi bir kütüphane veya bu işlev kullanmaktır:

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

Birkaç ay önce bu gönderiden bazı fikirler aldım, ancak buradaki cevapların hiçbiri veya diğer gönderilerden / bloglardan gelen yanıtlar tüm senaryoları (örneğin negatif sayılar ve test cihazımızın bulduğu bazı "şanslı sayılar") ele alabilir. Sonunda, test cihazımız aşağıdaki bu yöntemle ilgili herhangi bir sorun bulamadı. Kodumun bir pasajını yapıştırma:

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

Ayrıca kod yorumları var (üzgünüm zaten tüm detayları unuttum) ... Gelecekteki referans için burada cevabımı gönderiyorum:

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).

Ben değiştirici sorunu düzeltmek. Yalnızca 2 ondalık basamak desteği.

$(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)

Bu aşağıdakileri vermelidir: 10.20

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

Bu aşağıdakileri vermelidir: 0.05

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

Bu aşağıdakileri vermelidir: 4.04

vb.

Bu çok basit ve diğerleri gibi iyi çalışıyor:

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

ToFixed () yalnızca sayılarda çağrılabildiğinden ve maalesef bir dize döndürdüğünden, bu her iki yönde de tüm ayrıştırma işlemlerini yapar. Bir dize veya sayı geçirebilirsiniz ve her seferinde bir sayı geri alırsınız! ParseNumber (1.49) çağrısı size 1, parseNumber (1.49,2) çağrısı size 1.50 verecektir. Tıpkı en iyileri gibi!

Ayrıca .toPrecision()yöntemi ve bazı özel kodları kullanabilir ve int bölümünün uzunluğuna bakılmaksızın her zaman n. Ondalık basamağa yuvarlayabilirsiniz.

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

Daha iyi bir kullanım için bir eklenti de yapabilirsiniz.

Bu kadar basit.

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

Bu sorunu benim için çözen ve kullanılabilen veya uyarlanabilen çok basit bir yol buldum:

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

% 100 çalışıyor !!! Dene

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