값이 15.7784514라고 가정하고 반올림하지 않고 15.77을 표시하려고합니다.

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

결과-

15.8
15.78
15.778
15.7784514000 

15.77을 어떻게 표시합니까?

숫자를 문자열로 변환하고 숫자를 소수점 둘째 자리까지 일치시킵니다.

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>

이 toFixed방법은 경우와 달리 실패 toString하므로 매우주의하십시오.

2016 년 11 월 5 일 업데이트

항상 정확한 새로운 답변

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

으로 자바 스크립트에서 부동 소수점 연산을하는 것은 항상 가장자리 케이스를해야합니다, 이전 솔루션은 좋은 것만으로는 충분하지 않습니다 대부분의 시간을 정확합니다. 이와 같은 솔루션 num.toPrecision에는 BigDecimal.js 및 accounting.js가 있습니다. 그러나 문자열을 파싱하는 것이 가장 간단하고 항상 정확하다고 생각합니다.

@Gumbo의 승인 된 답변에서 잘 작성된 정규식을 기반으로 한이 새로운 고정 기능은 항상 예상대로 작동합니다.

항상 정확한 답변은 아닙니다.

고정 된 기능으로 롤업 :

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

대신 문자열로 나머지를 수동으로 제거하기 위해 이것을 작성하기로 결정 했으므로 숫자와 함께 제공되는 수학 문제를 처리 할 필요가 없습니다.

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

그러면 숫자 = 15.7784514 인 "15.77"이 표시됩니다.

2017 년 10 월

숫자를 n 번째 10 진수로 자르고 (반올림하지 않음) n≥0 인 경우 정확히 n 개의 10 진수가있는 문자열로 변환하는 일반적인 솔루션입니다.

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

여기서 x는 숫자 (문자열로 변환 됨) 또는 문자열 일 수 있습니다.

다음은 n = 2에 대한 몇 가지 테스트입니다 (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 *

참고에 언급 된 바와 같이, 이는 "1.99e-7"및 다른 n 값에 대한 지수로의 자바 스크립트 암시 적 변환 때문입니다.

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

parseInt가 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)

이것은 19.66을 반환합니다

간단 해

number = parseInt(number * 100)/100;

이 솔루션은 작동하지만 불필요하게 복잡해 보입니다. 나는 개인적으로 모듈러스 연산자를 사용하여 나머지 나눗셈 연산을 얻고 제거합니다. 그 숫자가 15.7784514라고 가정하면 :

num-=num%.01;

이것은 num = num-(num % .01)을 말하는 것과 같습니다.

여기의 대답은 도움이되지 않았습니다. 반올림하거나 계속 잘못된 소수점을 제공했습니다.

내 솔루션은 십진수를 문자열로 변환하고 문자를 추출 한 다음 모든 것을 숫자로 반환합니다.

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

양수에 대한 내 버전 :

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

빠르고 예쁘고 명백합니다. (양수 버전)

다음 코드는 매우 효과적입니다.

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

나는 다음과 같은 간단한 방법으로 고정했다.

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

결과는 15.77입니다

숫자를 자르십시오.

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

또 다른 한 줄 솔루션 :

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

두 번째 숫자로 자르고 싶기 때문에 100을 사용했지만보다 유연한 솔루션은 다음과 같습니다.

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

여기서 자리수는 유지할 소수 자릿수입니다.

자세한 내용과 브라우저 호환성에 대해서는 Math.trunc 사양 을 참조하십시오 .

여기 있어요. 문제를 해결하는 또 다른 방법을 보여주는 답변 :

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

최종 표현식 앞에 +를 사용하십시오. 그것은 잘린 슬라이스 문자열을 다시 숫자 타입으로 변환하는 것입니다.

그것이 도움이되기를 바랍니다!

0없이 자르기

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

또는

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

테스트:

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

0으로 자르기

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

테스트:

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

이것은 나를 위해 잘 작동했습니다. 문제가 해결되기를 바랍니다.

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>

이를 수행하는 쉬운 방법은 다음이지만 amount 매개 변수가 문자열로 제공되는지 확인해야합니다.

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

나는 (num-0.05).toFixed(1)두 번째 소수점을 얻는 데 사용 했습니다.

typescript 내 솔루션 (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);
};

테스트 사례 :

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

개선 사항이 있습니까?

자신의 toFixed기능을 굴리십시오 Math.floor. 양수 값 은 잘 작동합니다.

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

음수 값 Math.floor은 값의 반올림입니다. Math.ceil대신 사용할 수 있습니다 .

예,

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

정규식을 사용하는 Gumbo의 두 번째 솔루션은 작동하지만 정규식으로 인해 느립니다. 부동 소수점 숫자의 부정확성으로 인해 특정 상황에서 Gumbo의 첫 번째 솔루션이 실패합니다. 참고 항목 JSFiddle을데모 및 벤치 마크 을 . 두 번째 솔루션은 현재 시스템 인 Intel Core i5-2500 CPU (3.30 GHz)에서 호출 당 약 1636 나노초가 소요됩니다.

내가 작성한 솔루션에는 부동 소수점 부정확성을 처리하기 위해 작은 보상을 추가하는 것이 포함됩니다. 기본적으로 순간, 즉 나노초 단위입니다. 통화 당 2 나노초 (nanoseconds)의 시간을 기록했지만 JavaScript 타이머는 매우 정확하거나 세분화되지 않았습니다. 다음은 JS Fiddle 과 코드입니다.

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

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

반올림하지 않고 두 개의 부동 소수점을 얻는 것이 더 안정적입니다.

참조 답변

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

감사합니다 !

이미 정규 표현식과 산술 계산에 대한 적절한 대답이 있습니다.

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

여기 문자열로 무엇을 했습니까?

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

이 모든 대답은 약간 복잡해 보입니다. 나는 당신의 숫자에서 0.5를 빼고 toFixed ()를 사용합니다.

가장 효율적인 솔루션 (2 소수 자릿수)은 전화하기 전에 0.005를 빼는 것입니다 toFixed()

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

음수도 반올림됩니다 (0에서 멀어짐). OP는 음수에 대해서는 아무것도 말하지 않았습니다.

나는 이미 예제가 거의 없다는 것을 알고 있지만 String.toFixed와 동등한 것을 제안하는 것이 가치가 있다고 생각합니다. 일부는 도움이 될 수 있습니다.

그것은 내 toFixed 대안이며, 숫자를 반올림하지 않고, 자르거나 주어진 정밀도에 따라 0을 추가합니다. 여분의 긴 숫자의 경우 정밀도가 길 때 JS 내장 반올림을 사용합니다. 함수는 스택에서 찾은 모든 문제가있는 숫자에 작동합니다.

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

길이가 18 이상인 숫자의 경우 정밀도가 제대로 처리되지 않을 수 있습니다. 예를 들어 64 비트 Chrome은 숫자를 반올림하거나 "e +"/ "e-"를 추가하여 숫자의 길이를 18로 유지합니다.

실수로 연산을 수행하려면 Math.sqrt(10, precision)먼저 곱하고 계산 한 다음 곱셈기 값으로 다이빙하는 것이 더 안전 합니다.

예:

0.06 + 0.01이며 0.06999999999999999반올림하지 않는 모든 서식 함수는 0.06정밀도 를 위해 잘립니다 2.

그러나 multiplier & divider :와 동일한 작업을 수행하면을 (0.06 * 100 + 0.01 * 100) / 100얻을 수 0.07있습니다.

그래서 자바 스크립트에서 실수를 처리 할 때, 특히 돈을 계산할 때 이러한 승수 / 분배기를 사용하는 것이 중요합니다 ...