소수점 이하 두 자리를 항상 표시하는 형식 번호

해당하는 경우 항상 반올림하여 소수점 이하 2 자리를 표시하도록 숫자 형식을 지정하고 싶습니다.

예 :

number     display
------     -------
1          1.00
1.341      1.34
1.345      1.35

나는 이것을 사용했다 :

parseFloat(num).toFixed(2);

그러나이 아닌으로 표시 1됩니다 .11.00

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

라이브 데모

var num1 = "1";
document.getElementById('num1').innerHTML = (Math.round(num1 * 100) / 100).toFixed(2);

var num2 = "1.341";
document.getElementById('num2').innerHTML = (Math.round(num2 * 100) / 100).toFixed(2);

var num3 = "1.345";
document.getElementById('num3').innerHTML = (Math.round(num3 * 100) / 100).toFixed(2);

span {
    border: 1px solid #000;
    margin: 5px;
    padding: 5px;
}

<span id="num1"></span>
<span id="num2"></span>
<span id="num3"></span>

이 점에 유의 반올림 입력이 때문에, 2 진수 곳으로 1.346돌아갑니다 1.35.

Number(1).toFixed(2);         // 1.00
Number(1.341).toFixed(2);     // 1.34
Number(1.345).toFixed(2);     // 1.34 NOTE: See andy's comment below.
Number(1.3450001).toFixed(2); // 1.35

document.getElementById('line1').innerHTML = Number(1).toFixed(2);
document.getElementById('line2').innerHTML = Number(1.341).toFixed(2);
document.getElementById('line3').innerHTML = Number(1.345).toFixed(2);
document.getElementById('line4').innerHTML = Number(1.3450001).toFixed(2);

<span id="line1"></span>
<br/>
<span id="line2"></span>
<br/>
<span id="line3"></span>
<br/>
<span id="line4"></span>

이 답변 은 실패합니다 value = 1.005.

더 나은 해결책으로 지수 표기법으로 표시된 숫자를 사용하여 반올림 문제를 피할 수 있습니다.

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

@Kon이 제안한 깔끔한 코드와 원저자 :

Number(Math.round(parseFloat(value + 'e' + decimalPlaces)) + 'e-' + decimalPlaces)

toFixed()소수점을 유지하기 위해 끝에 추가 할 수 있습니다 ( 예 :: 1.00문자열로 반환 됨).

Number(Math.round(parseFloat(value + 'e' + decimalPlaces)) + 'e-' + decimalPlaces).toFixed(decimalPlaces)

크레딧 : 반올림 십진수 자바 스크립트

var num = new Number(14.12);
console.log(num.toPrecision(2));//outputs 14
console.log(num.toPrecision(3));//outputs 14.1
console.log(num.toPrecision(4));//outputs 14.12
console.log(num.toPrecision(5));//outputs 14.120

가장 정확한 반올림을 위해 다음 함수를 작성하십시오.

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

소수점 이하 두 자리로 반올림하는 데 사용하십시오.

console.log("seeked to " + round(1.005, 2));
> 1.01

Razu , 이 기사 및 MDN의 Math.round 참조 덕분 입니다.

최신 브라우저의 경우 다음을 사용하십시오 toLocaleString.

var num = 1.345;
num.toLocaleString(undefined, { maximumFractionDigits: 2, minimumFractionDigits: 2 });

소수 구분 기호 를 제어하려면 로케일 태그를 첫 번째 매개 변수로 지정하십시오 . 도트의 경우 예를 들어 영어 미국 로캘을 사용하십시오.

num.toLocaleString("en-US", { maximumFractionDigits: 2, minimumFractionDigits: 2 });

이것은 다음을 제공합니다.

1.35

유럽의 대부분의 국가는 쉼표를 소수점 구분 기호로 사용하므로 스웨덴어 / 스웨덴 로케일을 사용하는 경우 :

num.toLocaleString("sv-SE", { maximumFractionDigits: 2, minimumFractionDigits: 2 });

그것은 줄 것이다 :

1,35

가장 간단한 답변 :

var num = 1.2353453;
num.toFixed(2); // 1.24

예 : http://jsfiddle.net/E2XU7/

N 자리로 반올림하는 훨씬 일반적인 솔루션

function roundN(num,n){
  return parseFloat(Math.round(num * Math.pow(10, n)) /Math.pow(10,n)).toFixed(n);
}


console.log(roundN(1,2))
console.log(roundN(1.34,2))
console.log(roundN(1.35,2))
console.log(roundN(1.344,2))
console.log(roundN(1.345,2))
console.log(roundN(1.344,3))
console.log(roundN(1.345,3))
console.log(roundN(1.3444,3))
console.log(roundN(1.3455,3))

Output

1.00
1.34
1.35
1.34
1.35
1.344
1.345
1.344
1.346

var number = 123456.789;


console.log(new Intl.NumberFormat('en-IN', { maximumFractionDigits: 2 }).format(number));

https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/NumberFormat

이미 jQuery를 사용하고 있다면 jQuery Number Format 플러그인 을 사용할 수 있습니다.

플러그인은 형식화 된 숫자를 문자열로 리턴 할 수 있으며 소수 및 천 단위 구분 기호를 설정할 수 있으며 표시 할 소수 자릿수를 선택할 수 있습니다.

$.number( 123, 2 ); // Returns '123.00'

GitHub에서 jQuery Number Format을 얻을 수도 있습니다 .

이게 네가 뜻한 바냐?

function showAsFloat(num, n){
      return !isNaN(+num) ? (+num).toFixed(n || 2) : num;
}

document.querySelector('#result').textContent = 
    [
     'command                      | result',
     '-----------------------------------------------',
     'showAsFloat(1);              | ' + showAsFloat(1),
     'showAsFloat(1.314);          | ' + showAsFloat(1.314),
     'showAsFloat(\'notanumber\')    | ' + showAsFloat('notanumber'),
     'showAsFloat(\'23.44567\', 3)   | ' + showAsFloat('23.44567', 3),
     'showAsFloat(2456198, 5)      | ' + showAsFloat('2456198', 5),
     'showAsFloat(0);              | ' + showAsFloat(0)
    ].join('\n');

<pre id="result"></pre>

소수점 이하 두 자리 만 유지하면서 숫자를 문자열로 변환합니다.

var num = 5.56789;
var n = num.toFixed(2);

n의 결과는 다음과 같습니다.

5.57

당신은 바닥을 찾고 있습니까?

var num = 1.42482;
var num2 = 1;
var fnum = Math.floor(num).toFixed(2);
var fnum2 = Math.floor(num2).toFixed(2);
alert(fnum + " and " + fnum2); //both values will be 1.00

function currencyFormat (num) {
    return "$" + num.toFixed(2).replace(/(\d)(?=(\d{3})+(?!\d))/g, "$1,")
}

console.info(currencyFormat(2665));   // $2,665.00
console.info(currencyFormat(102665)); // $102,665.00

소수점 이하 자릿수를 지정할 수있는 일반 함수도 있습니다.

function numberFormat(val, decimalPlaces) {

    var multiplier = Math.pow(10, decimalPlaces);
    return (Math.round(val * multiplier) / multiplier).toFixed(decimalPlaces);
}

특정 형식이 필요한 경우 고유 한 루틴을 작성하거나 필요한 기능을 수행하는 라이브러리 함수를 사용해야합니다. 기본 ECMAScript 기능은 일반적으로 형식이 지정된 숫자를 표시하기에 충분하지 않습니다.

반올림 및 서식에 대한 자세한 설명은 다음과 같습니다. http://www.merlyn.demon.co.uk/js-round.htm#RiJ

일반적으로 반올림 및 서식은 출력 전 마지막 단계로만 수행해야합니다. 더 일찍 그렇게하면 예기치 않은 큰 오류가 발생하여 서식이 손상 될 수 있습니다.

가장 긴 스레드 중 하나를 실행하십시오. 아래는 내 솔루션입니다.

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

누구나 구멍을 뚫을 수 있는지 알려주세요

당신은 우리에게 전체 그림을 제공하지 않습니다.

javascript:alert(parseFloat(1).toFixed(2))위치 표시 줄에 붙여 넣을 때 브라우저에 1.00이 표시됩니다. 그러나 나중에 무언가를하면 되돌릴 것입니다.

var num = 2
document.getElementById('spanId').innerHTML=(parseFloat(num).toFixed(2)-1)


shows 1 and not 1.00

var quantity = 12;

var import1 = 12.55;

var total = quantity * import1;

var answer = parseFloat(total).toFixed(2);

document.write(answer);

toFixed () 호출을 수행하기 전에 parseFloat () 및 Number () 변환을 결정해야했습니다. 다음은 숫자 캡처 후 캡처 사용자 입력의 예입니다.

HTML :

<input type="number" class="dec-number" min="0" step="0.01" />

이벤트 핸들러:

$('.dec-number').on('change', function () {
     const value = $(this).val();
     $(this).val(value.toFixed(2));
});

위의 코드는 TypeError 예외를 발생시킵니다. html 입력 유형이 "숫자"이지만 사용자 입력은 실제로 "문자열"데이터 유형입니다. 그러나 toFixed () 함수는 숫자 인 오브젝트에서만 호출 될 수 있습니다.

최종 코드는 다음과 같습니다.

$('.dec-number').on('change', function () {
     const value = Number($(this).val());
     $(this).val(value.toFixed(2));
});

Number () vs. parseFloat ()으로 캐스팅하는 것을 선호하는 이유는 빈 입력 문자열이나 NaN 값에 대해 추가 유효성 검사를 수행 할 필요가 없기 때문입니다. Number () 함수는 빈 문자열을 자동으로 처리하여 0으로 숨 깁니다.

나는 좋아한다 :

var num = 12.749;
parseFloat((Math.round(num * 100) / 100).toFixed(2)); // 123.75

소수점 이하 두 자릿수로 반올림 한 다음 parseFloat() 문자열 또는 숫자인지에 상관없이 문자열이 아닌 숫자를 반환 하도록 구문 분석해야합니다 .

정밀한 방법으로 Math 객체 확장

Object.defineProperty(Math, 'precision',{
   value: function (value,precision,type){
             var v = parseFloat(value),
                 p = Math.max(precision,0)||0,
                 t = type||'round';
              return (Math[t](v*Math.pow(10,p))/Math.pow(10,p)).toFixed(p);
          }
    });

console.log(
    Math.precision(3.1,3), // round 3 digits 
    Math.precision(0.12345,2,'ceil'), // ceil 2 digits
    Math.precision(1.1) // integer part
)

parseInt(number * 100) / 100; 나를 위해 일했다.

다음은 플로어 만 사용하여 반올림하는 또 다른 솔루션입니다. 즉, 계산 된 금액이 원래 금액 (거래에 필요한 경우)보다 크지 않아야합니다.

Math.floor(num* 100 )/100;

이 코드를 사용해보십시오 :

    function FormatNumber(number, numberOfDigits = 2) {
        try {
            return new Intl.NumberFormat('en-US').format(parseFloat(number).toFixed(2));
        } catch (error) {
            return 0;
        }
    }

    var test1 = FormatNumber('1000000.4444');
    alert(test1); // 1,000,000.44

    var test2 = FormatNumber(100000000000.55555555, 4);
    alert(test2); // 100,000,000,000.56

아래 코드를보십시오 :

function numberWithCommas(number) { 

   var newval = parseFloat(Math.round(number * 100) / 100).toFixed(2);

   return newval.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",");
}

(num + "").replace(/^([0-9]*)(\.[0-9]{1,2})?.*$/,"$1$2")

이것이 내 문제를 해결하는 방법입니다.

parseFloat(parseFloat(floatString).toFixed(2));