javascript에서 플로트를 포맷하는 방법은?

javascript에서 플로트를 포맷하는 방법은?

JavaScript에서는 부동에서 문자열로 변환할 때 소수점 뒤에 어떻게 두 자리만 얻을 수 있나요?예를 들어 0.3445434가 아닌 0.34입니다.

숫자를 반올림하는 기능이 있습니다.예를 들어 다음과 같습니다.

var x = 5.0364342423;
print(x.toFixed(2));

5.04 가 인쇄됩니다.

편집: 만지작거리다

var result = Math.round(original*100)/100;

암호가 명확하지 않은 경우를 대비해서 구체적인 사항들이요

: "..."를 합니다.또는 그냥 사용toFixedTim Büthe의 제안대로.그것을 잊어버렸습니다.리마인더 감사합니다(및 업투표).

해서 하세요.toFixed():

첫째, 반올림은 숫자의 바이너리 표현을 사용하여 이루어지며, 이로 인해 예기치 않은 동작이 발생할 수 있습니다.예를들면

(0.595).toFixed(2) === '0.59'

'0.6'.

번째는 , IE 버그가 toFixed()IE(최소 버전7까지 IE8을 체크하지 않음)에서는 다음 사항이 충족됩니다.

(0.9).toFixed(0) === '0'

Kkyy의 수 .toFixed():

function toFixed(value, precision) {
    var power = Math.pow(10, precision || 0);
    return String(Math.round(value * power) / power);
}

해야 할 .toFixed()는 숫자의 끝에 불필요한0 을 생성할 수 있습니다.예를 들어 다음과 같습니다.

var x=(23-7.37)
x
15.629999999999999
x.toFixed(6)
"15.630000"

는 '을 정리하다'를 입니다.RegExp:

function humanize(x){
  return x.toFixed(6).replace(/\.?0*$/,'');
}

RegExp는 후행 제로(및 옵션으로 소수점)와 일치하여 정수에도 적합하도록 합니다.

humanize(23-7.37)
"15.63"
humanize(1200)
"1200"
humanize(1200.03)
"1200.03"
humanize(3/4)
"0.75"
humanize(4/3)
"1.333333"

var x = 0.3445434
x = Math.round (x*100) / 100 // this will make nice rounding

승수를 사용하여 떠도는 모든 솔루션에는 문제가 있습니다.불행하게도 Kkyy와 Christoph의 해결책은 둘 다 틀렸다.

코드 번호 551.175를 소수점 2자리까지 테스트해 주세요.- 551.17로 반올림합니다.- 551.18로 반올림합니다.- 하지만 451.17로 테스트하면 괜찮습니다.- 451.18로 테스트합니다.따라서 이 오류를 언뜻 발견하기는 어렵습니다.

곱셈에 문제가 있습니다.551.175 * 100 = 55117.4999999999(업!)를 시도합니다.

그래서 Math.round()를 사용하기 전에 toFixed()로 처리하는 것이 제 생각입니다.

function roundFix(number, precision)
{
    var multi = Math.pow(10, precision);
    return Math.round( (number * multi).toFixed(precision + 1) ) / multi;
}

여기서 중요한 것은 먼저 올바르게 반올림한 다음 String으로 변환할 수 있다는 것입니다.

function roundOf(n, p) {
    const n1 = n * Math.pow(10, p + 1);
    const n2 = Math.floor(n1 / 10);
    if (n1 >= (n2 * 10 + 5)) {
        return (n2 + 1) / Math.pow(10, p);
    }
    return n2 / Math.pow(10, p);
}

// All edge cases listed in this thread
roundOf(95.345, 2); // 95.35
roundOf(95.344, 2); // 95.34
roundOf(5.0364342423, 2); // 5.04
roundOf(0.595, 2); // 0.60
roundOf(0.335, 2); // 0.34
roundOf(0.345, 2); // 0.35
roundOf(551.175, 2); // 551.18
roundOf(0.3445434, 2); // 0.34

이제 이 값의 형식을 toFixed(p)로 안전하게 지정할 수 있습니다.구체적인 경우:

roundOf(0.3445434, 2).toFixed(2); // 0.34

반올림 없는 문자열이 필요한 경우 이 ReGEx를 사용할 수 있습니다(가장 효율적인 방법은 아닐 수 있습니다).하지만 정말 쉽다)

(2.34567778).toString().match(/\d+\.\d{2}/)[0]
// '2.34'

function trimNumber(num, len) {
  const modulu_one = 1;
  const start_numbers_float=2;
  var int_part = Math.trunc(num);
  var float_part = String(num % modulu_one);
      float_part = float_part.slice(start_numbers_float, start_numbers_float+len);
  return int_part+'.'+float_part;
}

소수점 구분 기호도 원하십니까?방금 만든 기능은 다음과 같습니다.

function formatFloat(num,casasDec,sepDecimal,sepMilhar) {
    if (num < 0)
    {
        num = -num;
        sinal = -1;
    } else
        sinal = 1;
    var resposta = "";
    var part = "";
    if (num != Math.floor(num)) // decimal values present
    {
        part = Math.round((num-Math.floor(num))*Math.pow(10,casasDec)).toString(); // transforms decimal part into integer (rounded)
        while (part.length < casasDec)
            part = '0'+part;
        if (casasDec > 0)
        {
            resposta = sepDecimal+part;
            num = Math.floor(num);
        } else
            num = Math.round(num);
    } // end of decimal part
    while (num > 0) // integer part
    {
        part = (num - Math.floor(num/1000)*1000).toString(); // part = three less significant digits
        num = Math.floor(num/1000);
        if (num > 0)
            while (part.length < 3) // 123.023.123  if sepMilhar = '.'
                part = '0'+part; // 023
        resposta = part+resposta;
        if (num > 0)
            resposta = sepMilhar+resposta;
    }
    if (sinal < 0)
        resposta = '-'+resposta;
    return resposta;
}

곱셈 또는 나눗셈을 사용하여 x.xx5를 실제 값으로 하는 가격에 대해 일관되지 않은 반올림을 피할 수 있는 방법은 없습니다.고객 측에서 정확한 가격을 계산해야 한다면 모든 금액을 센트로 유지해야 합니다.이는 JavaScript의 수치 내부 표현 특성 때문입니다.Excel도 같은 문제를 겪고 있기 때문에 대부분의 사람들은 이 현상으로 인한 작은 오류를 알아차리지 못합니다.그러나 계산된 값을 많이 합산할 때마다 오차가 누적될 수 있지만 최종 결과의 오차를 최소화하기 위한 계산 순서 및 기타 방법을 포함하는 전체 이론이 있습니다.10진수치의 문제를 강조하기 위해 0.1+0.2는 JavaScript에서는 0.3과 정확하게 동일하지 않지만 1+2는 3과 동일하다는 점에 유의하시기 바랍니다.

/** don't spend 5 minutes, use my code **/
function prettyFloat(x,nbDec) { 
    if (!nbDec) nbDec = 100;
    var a = Math.abs(x);
    var e = Math.floor(a);
    var d = Math.round((a-e)*nbDec); if (d == nbDec) { d=0; e++; }
    var signStr = (x<0) ? "-" : " ";
    var decStr = d.toString(); var tmp = 10; while(tmp<nbDec && d*tmp < nbDec) {decStr = "0"+decStr; tmp*=10;}
    var eStr = e.toString();
    return signStr+eStr+"."+decStr;
}

prettyFloat(0);      //  "0.00"
prettyFloat(-1);     // "-1.00"
prettyFloat(-0.999); // "-1.00"
prettyFloat(0.5);    //  "0.50"

이 코드를 사용하여 플로트를 포맷합니다.에 근거하고 있습니다.toPrecision()불필요한 0을 제거합니다.정규식을 간소화하는 방법에 대한 제안을 환영합니다.

function round(x, n) {
    var exp = Math.pow(10, n);
    return Math.floor(x*exp + 0.5)/exp;
}

사용 예:

function test(x, n, d) {
    var rounded = rnd(x, d);
    var result = rounded.toPrecision(n);
    result = result.replace(/\.?0*$/, '');
    result = result.replace(/\.?0*e/, 'e');
    result = result.replace('e+', 'e');
    return result;  
}

document.write(test(1.2000e45, 3, 2) + '=' + '1.2e45' + '<br>');
document.write(test(1.2000e+45, 3, 2) + '=' + '1.2e45' + '<br>');
document.write(test(1.2340e45, 3, 2) + '=' + '1.23e45' + '<br>');
document.write(test(1.2350e45, 3, 2) + '=' + '1.24e45' + '<br>');
document.write(test(1.0000, 3, 2) + '=' + '1' + '<br>');
document.write(test(1.0100, 3, 2) + '=' + '1.01' + '<br>');
document.write(test(1.2340, 4, 2) + '=' + '1.23' + '<br>');
document.write(test(1.2350, 4, 2) + '=' + '1.24' + '<br>');

countDecimals = value => {
    if (Math.floor(value) === value) return 0;
    let stringValue = value.toString().split(".")[1];
    if (stringValue) {
      return value.toString().split(".")[1].length
        ? value.toString().split(".")[1].length
        : 0;
    } else {
      return 0;
    }
  };
  
formatNumber=(ans)=>{
    let decimalPlaces = this.countDecimals(ans);
    ans = 1 * ans;
    if (decimalPlaces !== 0) {
      let onePlusAns = ans + 1;
      let decimalOnePlus = this.countDecimals(onePlusAns);
      if (decimalOnePlus < decimalPlaces) {
        ans = ans.toFixed(decimalPlaces - 1).replace(/\.?0*$/, "");
      } else {
        let tenMulAns = ans * 10;
        let decimalTenMul = this.countDecimals(tenMulAns);
        if (decimalTenMul + 1 < decimalPlaces) {
          ans = ans.toFixed(decimalPlaces - 1).replace(/\.?0*$/, "");
        }
      }
    }
}

값에 1을 더하고 원래 값과 가산 값에 있는 소수 자릿수를 세면 됩니다.원래 10진수보다 1 작은 숫자를 추가한 후 10진수를 찾으면 (원래 10진수 - 1)를 사용하여 toFixed()를 호출합니다.또한 원래 값에 10을 곱해서 확인하고, 1을 더해도 중복 소수 자릿수가 줄어들지 않는 경우를 대비해 같은 논리를 따릅니다.JS에서 부동소수점 번호 반올림을 처리하는 간단한 회피책입니다.내가 시도했던 대부분의 경우에 효과가 있었다.

언급URL : https://stackoverflow.com/questions/661562/how-to-format-a-float-in-javascript