내 코드를 소수점 이하 두 자리로 반올림합니다. 그러나 나는 10.8, 2.4 등의 숫자를 얻습니다. 이들은 소수점 이하 두 자리에 대한 아이디어가 아니므로 어떻게 다음을 개선 할 수 있습니까?

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

10.80, 2.40 등과 같은 숫자를 원합니다. jQuery를 사용하면 좋습니다.

고정 소수점 표기법을 사용하여 숫자를 포맷하려면 toFixed 메소드 를 사용하면 됩니다.

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

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

toFixed()문자열 을 반환합니다.

중요 : toFixed는 90 %의 시간을 반올림하지 않으며 반올림 된 값을 반환하지만 대부분의 경우 작동하지 않습니다.

예를 들어 :

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

최신 정보:

요즘에는 Intl.NumberFormat생성자를 사용할 수 있습니다 . ECMAScript 국제화 API 사양 (ECMA402) 의 일부입니다 . 그것은이 꽤 좋은 브라우저 지원 도 IE11을 포함, 그것은되어 완전히 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"

toLocaleString내부적으로 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는 또한 천 단위 구분 기호, 통화 기호 등과 같이 서식을 지정할 수있는 다양한 옵션을 제공합니다.

이 주제는 오래된 주제이지만 여전히 최상위 Google 결과이며 제공되는 솔루션은 동일한 부동 소수점 10 진수 문제를 공유합니다. 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));
}

우리가 볼 수 있듯이 다음과 같은 문제는 발생하지 않습니다.

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

이 일반성은 멋진 것들도 제공합니다.

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

이제 OP의 질문에 대답하려면 다음을 입력해야합니다.

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

또는보다 간결하고 덜 일반적인 기능의 경우 :

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

당신은 그것을 호출 할 수 있습니다 :

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

다양한 예제와 테스트 ( @ 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>

나는 보통 이것을 내 개인 라이브러리에 추가하고 @TIMINeutron 솔루션을 사용하고 몇 가지 길이를 사용하여 소수 길이에 적합하게 만들면 가장 적합합니다.

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

보고 된 예외에 대해 작동합니다.

이전 답변에 주석을 추가 할 수없는 이유를 모르겠지만 (아마도 나는 장님, 맹목적이지만) @Miguel의 답변을 사용하여 해결책을 찾았습니다.

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

그리고 @bighostkim과 @Imre의 두 가지 의견 :

• precise_round(1.275,2)1.28을 반환하지 않는 문제
• precise_round(6,2)6.00을 반환하지 않는 문제 (원하는대로).

나의 마지막 해결책은 다음과 같습니다.

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

보시다시피, 나는 약간의 "수정"을 추가해야했습니다. 그것은 그것이 아닙니다. 그러나 Math.round는 손실이 있기 때문에-당신은 jsfiddle.net에서 그것을 확인할 수 있습니다-이것이 "수정 방법을 아는 유일한 방법입니다" ")). 이미 채워진 숫자에 0.001을 더하므로 소수점 오른쪽에 13 0을 더합니다. 따라서 사용하는 것이 안전해야합니다.

그 후 나는 .toFixed(decimal)항상 올바른 형식으로 올바른 숫자를 출력하도록 추가 했습니다.

그래서 그것은 거의 다입니다. 잘 사용하십시오;)

편집 : 음수의 "수정"에 기능이 추가되었습니다.

100 % 확신하는 한 가지 방법은 소수점 이하 자릿수 2 개를 얻는 것입니다.

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

이로 인해 반올림 오류가 발생하면 James가 주석에서 설명한대로 다음을 사용할 수 있습니다.

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

toFixed (n)은 소수점 다음에 n 길이를 제공합니다. toPrecision (x)는 x 총 길이를 제공합니다.

아래이 방법을 사용하십시오

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

그리고 숫자를 고정 사용하려면

result = num.toFixed(2);

이 문제에 대한 정확한 해결책을 찾지 못했기 때문에 내 자신을 만들었습니다.

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

예 :

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와 jQuery에서 작은 함수를 만들었습니다.

다음에 시도해 볼 수 있습니다.

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

데모 온라인 :

http://jsfiddle.net/c4Wqn/

부동 소수점 값의 문제점은 고정 된 양의 비트로 무한한 (연속적인) 값을 나타내려고한다는 것입니다. 따라서 당연히 약간의 손실이 발생해야하며 일부 가치에 물릴 것입니다.

컴퓨터가 1.275를 부동 소수점 값으로 저장하면 실제로 1.275인지 1.27499999999999993인지 또는 1.27500000000000002인지 기억하지 않습니다. 이 값은 소수점 이하 두 자리로 반올림 한 후에 다른 결과를 제공해야하지만 컴퓨터의 경우 부동 소수점 값으로 저장 한 후 정확히 동일 하게 보이 므로 손실 된 데이터를 복원 할 방법이 없기 때문에 그렇지 않습니다 . 추가 계산은 이러한 부정확도 만 누적합니다.

따라서 정밀도가 중요한 경우 처음부터 부동 소수점 값을 피해야합니다. 가장 간단한 옵션은

• 용도 헌신적 인 라이브러리를
• 문자열을 사용하여 값을 저장하고 전달합니다 (문자열 연산과 함께 제공)
• 정수를 사용하십시오 (예 : 실제 값의 100 분의 1 정도를 전달할 수 있습니다 (예 : 달러 대신 금액을 센트로 표시))

예를 들어, 정수를 사용하여 100 분의 1을 저장하는 경우 실제 값을 찾는 기능은 매우 간단합니다.

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

문자열을 사용하면 반올림이 필요하지만 여전히 관리 가능합니다.

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

가까운이 기능 라운드, 참고 0에서 먼 관계가 , 동안 IEEE 754 , 가까운 반올림하는 것이 좋습니다 도에 관계 부동 소수점 연산뿐만 기본 동작. 이러한 수정은 독자의 연습으로 남습니다. :)

여기 간단한 것이 있습니다

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

처럼 사용 alert(roundFloat(1.79209243929,4));

JS 피들

10 진수 값을 반올림 한 다음 toFixed(x)예상 숫자에 사용 하십시오.

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

요구

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

반올림

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

모으다

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

가장 가까운 라운드

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

병합 된 https://stackoverflow.com/a/7641824/1889449 및 https://www.kirupa.com/html5/rounding_numbers_in_javascript.htm 감사합니다.

내 단선 솔루션은 다음과 같습니다. Number((yourNumericValueHere).toFixed(2));

다음과 같은 일이 발생합니다.

1) 먼저 .toFixed(2)소수점 이하 자릿수를 반올림하려는 숫자에 적용 합니다. 이렇게하면 값이 숫자에서 문자열로 변환됩니다. 따라서 Typescript를 사용하는 경우 다음과 같은 오류가 발생합니다.

" 'string'유형은 'number'유형에 지정할 수 없습니다."

2) 숫자 값을 되찾거나 문자열을 숫자 값으로 변환하려면 간단히 Number()'문자열'값에 함수를 적용하십시오 .

설명을 위해 아래 예를보십시오.

예 : 소수점 이하 자릿수는 최대 5 자리이며 소수점 이하 자릿수는 2 자리로 줄이려고합니다. 나는 그렇게한다 :

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

다음과 같은 일부 글로벌 범위에 배치 하십시오 .

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

그리고 다음 시도 :

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

최신 정보

주 toFixed()사이의 소수의 숫자 만 사용할 수 있습니다 0-20즉 a.getDecimals(25), 자바 스크립트 오류를 생성 할 수 있습니다 그래서 당신은 몇 가지 추가 검사의 예를 추가 할 수 있음을 수용하는

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

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

1에서 100까지의 소수점 이하 자릿수로 난수를 반환합니다.

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

이것은 나를 위해 일했다 : JavaScript의 반올림 십진법

이 응답을 참조로 사용 : https://stackoverflow.com/a/21029698/454827

동적 소수 자릿수를 얻는 함수를 작성합니다.

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

여기 작업 예제 : https://jsfiddle.net/wpxLduLc/

이 예제를 사용하면 숫자 1.005를 반올림 할 때 여전히 오류가 발생합니다. 해결책은 Math.js 또는이 함수와 같은 라이브러리를 사용하는 것입니다.

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

몇 달 전에이 게시물에서 몇 가지 아이디어를 얻었지만 여기에 대한 답변이나 다른 게시물 / 블로그의 답변은 모든 시나리오를 처리 할 수 ​​없습니다 (예 : 음수 및 테스터가 발견 한 "행운 수"). 결국 테스터는 아래 방법에서 문제를 찾지 못했습니다. 내 코드 스 니펫 붙여 넣기 :

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

또한 코드 주석이 있습니다 (미안하지만 이미 모든 세부 정보를 잊어 버렸습니다) ... 나중에 참조 할 수 있도록 여기에 답변을 게시하고 있습니다.

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

수정자를 수정했습니다. 소수점 2 자리 만 지원합니다.

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

그 결과는 다음과 같습니다. 10.20

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

그 결과는 다음과 같습니다. 0.05

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

그 결과는 다음과 같습니다. 4.04

기타

이것은 매우 간단하며 다른 것들과 마찬가지로 작동합니다.

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

toFixed ()는 숫자에서만 호출 할 수 있고 불행히도 문자열을 반환하므로 양방향으로 모든 구문 분석을 수행합니다. 문자열이나 숫자를 전달할 수 있으며 매번 숫자를 돌려받습니다! parseNumber (1.49)를 호출하면 1이, parseNumber (1.49,2)가 1.50을 제공합니다. 그들 중 최고처럼!

또한 .toPrecision()메소드와 일부 사용자 정의 코드를 사용할 수 있으며 int 부분의 길이에 관계없이 항상 n 번째 10 진수로 올림합니다.

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

더 나은 사용을 위해 플러그인으로 만들 수도 있습니다.

이처럼 간단합니다.

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

나는이 문제를 해결하고 사용하거나 조정할 수있는 매우 간단한 방법을 찾았습니다.

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

100 % 작동 !!! 시도 해봐

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