[javascript] 소수점 이하 2 자리까지 반올림 (필요한 경우에만)

이 질문은 복잡합니다.

roundTo2DP(num)float을 인수로 사용하고 소수점 이하 2 자리로 반올림 한 값을 반환 하는 함수가 있다고 가정 합니다. 이러한 각 표현은 무엇을 평가해야합니까?

• roundTo2DP(0.014999999999999999)
• roundTo2DP(0.0150000000000000001)
• roundTo2DP(0.015)

‘명백한’답변은 첫 번째 예제는 0.01로 반올림해야하고 (0.02보다 0.01에 가깝기 때문에) 다른 두 개는 0.02로 반올림해야합니다 (0.0150000000000000001은 0.01보다 0.02에 가깝기 때문에 0.015는 정확히 중간에 있기 때문에) 그들과 같은 숫자가 반올림되는 수학적 규칙이 있습니다).

당신이 짐작 할 수있다 캐치는 점이다 roundTo2DP 가능하게 할 수 그것을 전달되는 모든 세 개의 숫자이기 때문에, 그 명백한 해답을 제공하도록 구현 될 같은 번호 . IEEE 754 이진 부동 소수점 숫자 (JavaScript에서 사용되는 종류)는 대부분의 정수가 아닌 숫자를 정확하게 나타낼 수 없으므로 위의 세 숫자 리터럴은 모두 근처의 유효한 부동 소수점 숫자로 반올림됩니다. 이 숫자는 발생하는 대로 정확하게

0.01499999999999999944488848768742172978818416595458984375

0.02보다 0.01에 가깝습니다.

브라우저 콘솔, 노드 셸 또는 기타 JavaScript 인터프리터에서 세 숫자가 모두 같은 것을 알 수 있습니다. 그냥 그들을 비교하십시오 :

> 0.014999999999999999 === 0.0150000000000000001
true

제가 글을 쓸 때 m = 0.0150000000000000001, 그로m 끝나는 정확한 가치 는 실제0.01 보다 더 가깝습니다 0.02. 그러나 mString으로 변환 하면 …

> var m = 0.0150000000000000001;
> console.log(String(m));
0.015
> var m = 0.014999999999999999;
> console.log(String(m));
0.015

… 0.015를 얻습니다. 0.02로 반올림해야합니다. 이것은 이전 에이 모든 숫자가 정확히 같았다고 말한 56 세 자리 수 는 아닙니다 . 이게 무슨 마법입니까?

답변은 ECMAScript 사양, 7.1.12.1 : ToString이 Number 유형에 적용됨 섹션에 있습니다. 여기에 일부 숫자 m 을 문자열 로 변환하는 규칙 이 정리되어 있습니다. 핵심 부분은 포인트 5이며, m 의 문자열 표현에 숫자가 사용될 정수 s 가 생성됩니다 .

있도록 N , K를 , 및 s의 정수가되도록 수행 K ≥ 1, 10 ^{K -1} ≤ S <10 ^K 에 대한 숫자 값 S × 10 ^{N – K는} 인 m 과 k는 가능한 한 작게한다. 이 K의 소수 표현 자리수 유의 S , S를 10로 나누어 아니고, 최하위 디지트 것을 들 반드시 고유 이러한 기준에 의해 결정되지 않는다.

여기서 중요한 부분은 ” k 는 가능한 한 작아야 “한다는 요구 사항입니다 . 그 요구 사항 m의 가치 는 Number가 주어지면 의 요구 사항을 충족하면서도 가능한 최소 자릿수 를 String(m)가져야 한다는 요구 사항입니다 . 우리는 이미 그것을 알고 있기 때문에 , 왜 사실이어야 하는지 분명 합니다.Number(String(m)) === m0.015 === 0.0150000000000000001String(0.0150000000000000001) === '0.015'

물론,이 토론의 아무도는 직접 어떤 대답하지 않았다 roundTo2DP(m) 해야 돌아갑니다. 경우 m‘의 정확한 값이 0.01499999999999999944488848768742172978818416595458984375이지만, 그것의 String 표현은’0.015, 그 다음 무엇이며 올바른 수학적, 실제적으로, 철학적으로, 또는 무엇 이건 – – 대답은 우리는 두 개의 소수 자릿수로 반올림 할 때?

이에 대한 올바른 정답은 없습니다. 사용 사례에 따라 다릅니다. 다음과 같은 경우 문자열 표현을 존중하고 위쪽으로 반올림하려고합니다.

• 표현되는 가치는 본질적으로 이산 적입니다. 예를 들어 디나르와 같은 3 자리 통화의 통화 금액입니다. 이 경우 0.015와 같은 Number 의 실제 값 은 0.015이며, 이진 부동 소수점으로 얻는 0.0149999999 … 표현은 반올림 오류입니다. (물론, 많은 사람들은 그러한 값을 처리하기 위해 10 진수 라이브러리를 사용해야하며 처음에는 이진 부동 소수점 숫자로 나타내지 않아야한다고 합리적으로 주장합니다.)
• 사용자가 값을 입력했습니다. 이 경우에도 입력 한 정확한 십진수는 가장 가까운 이진 부동 소수점 표현보다 ‘참’입니다.

반면에, 이진 부동 소수점 값을 존중하고 값이 본질적으로 연속적인 스케일 (예 : 센서에서 읽은 값) 인 경우 아래쪽으로 반올림합니다.

이 두 가지 접근 방식에는 다른 코드가 필요합니다. 숫자의 문자열 표현을 존중하기 위해 (합리적으로 약간의 미묘한 코드를 사용하여) 학교에서 사용했을 때와 동일한 알고리즘을 사용하여 숫자로 숫자로 문자열 표현에 직접 작용하는 자체 반올림을 구현할 수 있습니다 숫자를 반올림하는 방법을 배웠습니다. 다음은 소수점 이하의 후행 0을 제거하여 “필요한 경우에만”소수점 이하 2 자리까지 숫자를 나타내는 OP의 요구 사항을 준수하는 예입니다. 물론 정확한 요구에 맞게 조정해야 할 수도 있습니다.

/**
 * Converts num to a decimal string (if it isn't one already) and then rounds it
 * to at most dp decimal places.
 *
 * For explanation of why you'd want to perform rounding operations on a String
 * rather than a Number, see http://stackoverflow.com/a/38676273/1709587
 *
 * @param {(number|string)} num
 * @param {number} dp
 * @return {string}
 */
function roundStringNumberWithoutTrailingZeroes (num, dp) {
    if (arguments.length != 2) throw new Error("2 arguments required");

    num = String(num);
    if (num.indexOf('e+') != -1) {
        // Can't round numbers this large because their string representation
        // contains an exponent, like 9.99e+37
        throw new Error("num too large");
    }
    if (num.indexOf('.') == -1) {
        // Nothing to do
        return num;
    }

    var parts = num.split('.'),
        beforePoint = parts[0],
        afterPoint = parts[1],
        shouldRoundUp = afterPoint[dp] >= 5,
        finalNumber;

    afterPoint = afterPoint.slice(0, dp);
    if (!shouldRoundUp) {
        finalNumber = beforePoint + '.' + afterPoint;
    } else if (/^9+$/.test(afterPoint)) {
        // If we need to round up a number like 1.9999, increment the integer
        // before the decimal point and discard the fractional part.
        finalNumber = Number(beforePoint)+1;
    } else {
        // Starting from the last digit, increment digits until we find one
        // that is not 9, then stop
        var i = dp-1;
        while (true) {
            if (afterPoint[i] == '9') {
                afterPoint = afterPoint.substr(0, i) +
                             '0' +
                             afterPoint.substr(i+1);
                i--;
            } else {
                afterPoint = afterPoint.substr(0, i) +
                             (Number(afterPoint[i]) + 1) +
                             afterPoint.substr(i+1);
                break;
            }
        }

        finalNumber = beforePoint + '.' + afterPoint;
    }

    // Remove trailing zeroes from fractional part before returning
    return finalNumber.replace(/0+$/, '')
}

사용법 예 :

> roundStringNumberWithoutTrailingZeroes(1.6, 2)
'1.6'
> roundStringNumberWithoutTrailingZeroes(10000, 2)
'10000'
> roundStringNumberWithoutTrailingZeroes(0.015, 2)
'0.02'
> roundStringNumberWithoutTrailingZeroes('0.015000', 2)
'0.02'
> roundStringNumberWithoutTrailingZeroes(1, 1)
'1'
> roundStringNumberWithoutTrailingZeroes('0.015', 2)
'0.02'
> roundStringNumberWithoutTrailingZeroes(0.01499999999999999944488848768742172978818416595458984375, 2)
'0.02'
> roundStringNumberWithoutTrailingZeroes('0.01499999999999999944488848768742172978818416595458984375', 2)
'0.01'

위의 기능은 사용자가 입력 한 숫자가 잘못 반올림되는 것을 방지하기 위해 사용하려는 것일 수 있습니다.

(대안으로, 다른 구현으로 비슷하게 동작하는 기능을 제공하는 round10 라이브러리를 사용해 볼 수도 있습니다 .)

그러나 두 번째 종류의 숫자-연속 스케일에서 가져온 값을 사용하면 소수점 이하 자릿수가 적은 근사 소수를 더 많이 나타내는 것보다 더 정확 하다고 생각할 이유가 없습니다 . 이 경우, 우리 는 String 표현을 존중하고 싶지 않습니다. 그 표현은 (사양에서 설명 된 바와 같이) 이미 반올림 되었기 때문입니다. “0.014999999 … 375는 0.015로 반올림하여 0.02로 반올림하므로 0.014999999 … 375는 0.02로 반올림”하는 실수를 저지르고 싶지 않습니다.

여기서 우리는 단순히 내장 toFixed방법을 사용할 수 있습니다 . 에 의해 Number()반환 된 String 을 호출 하면 String toFixed표현에 후행 0이없는 Number를 얻습니다 (JavaScript 가이 답변의 앞부분에서 설명한 Number의 String 표현을 계산하는 방식 덕분입니다).

/**
 * Takes a float and rounds it to at most dp decimal places. For example
 *
 *     roundFloatNumberWithoutTrailingZeroes(1.2345, 3)
 *
 * returns 1.234
 *
 * Note that since this treats the value passed to it as a floating point
 * number, it will have counterintuitive results in some cases. For instance,
 *
 *     roundFloatNumberWithoutTrailingZeroes(0.015, 2)
 *
 * gives 0.01 where 0.02 might be expected. For an explanation of why, see
 * http://stackoverflow.com/a/38676273/1709587. You may want to consider using the
 * roundStringNumberWithoutTrailingZeroes function there instead.
 *
 * @param {number} num
 * @param {number} dp
 * @return {number}
 */
function roundFloatNumberWithoutTrailingZeroes (num, dp) {
    var numToFixedDp = Number(num).toFixed(dp);
    return Number(numToFixedDp);
}

---