자바 스크립트에서 십진수 자르기 (반올림 아님)

십진수를 소수점 이하 자릿수로 자르려고합니다. 이 같은:

5.467   -> 5.46  
985.943 -> 985.94

toFixed(2)옳은 일을하지만 가치를 반올림합니다. 값을 반올림 할 필요가 없습니다. 이것이 자바 스크립트에서 가능하기를 바랍니다.

upd :

결국, 반올림 버그는 얼마나 열심히 보상하려고 노력하더라도 항상 당신을 괴롭힐 것입니다. 따라서 문제는 10 진수 표기법으로 정확하게 숫자를 표시하여 공격해야합니다.

Number.prototype.toFixedDown = function(digits) {
    var re = new RegExp("(\\d+\\.\\d{" + digits + "})(\\d)"),
        m = this.toString().match(re);
    return m ? parseFloat(m[1]) : this.valueOf();
};

[   5.467.toFixedDown(2),
    985.943.toFixedDown(2),
    17.56.toFixedDown(2),
    (0).toFixedDown(1),
    1.11.toFixedDown(1) + 22];

// [5.46, 985.94, 17.56, 0, 23.1]

다른 사람들의 컴파일을 기반으로 한 오래된 오류 발생 가능성이있는 솔루션 :

Number.prototype.toFixedDown = function(digits) {
  var n = this - Math.pow(10, -digits)/2;
  n += n / Math.pow(2, 53); // added 1360765523: 17.56.toFixedDown(2) === "17.56"
  return n.toFixed(digits);
}

Dogbert의 대답은 좋지만 코드가 음수를 처리해야 할 경우 Math.floor자체적으로 예기치 않은 결과를 초래할 수 있습니다.

예 Math.floor(4.3) = 4,하지만Math.floor(-4.3) = -5

일관된 결과를 얻으려면 대신 다음과 같은 도우미 함수를 사용하십시오.

truncateDecimals = function (number) {
    return Math[number < 0 ? 'ceil' : 'floor'](number);
};

// Applied to Dogbert's answer:
var a = 5.467;
var truncated = truncateDecimals(a * 100) / 100; // = 5.46

이 기능의 더 편리한 버전은 다음과 같습니다.

truncateDecimals = function (number, digits) {
    var multiplier = Math.pow(10, digits),
        adjustedNum = number * multiplier,
        truncatedNum = Math[adjustedNum < 0 ? 'ceil' : 'floor'](adjustedNum);

    return truncatedNum / multiplier;
};

// Usage:
var a = 5.467;
var truncated = truncateDecimals(a, 2); // = 5.46

// Negative digits:
var b = 4235.24;
var truncated = truncateDecimals(b, -2); // = 4200

원하는 동작이 아닌 경우 Math.abs첫 번째 줄에에 호출을 삽입합니다 .

var multiplier = Math.pow(10, Math.abs(digits)),

편집 : shendz a = 17.56는 이 솔루션을 사용하면 17.55. 이런 일이 발생하는 이유에 대한 자세한 내용은 모든 컴퓨터 과학자가 부동 소수점 산술에 대해 알아야 할 사항을 참조하십시오 . 불행히도, 모든 부동 소수점 오류 소스를 제거하는 솔루션을 작성하는 것은 자바 스크립트로 매우 까다 롭습니다. 다른 언어에서는 정수 또는 십진수 유형을 사용하지만 자바 스크립트를 사용하면 ...

이 솔루션 은 100 % 정확 해야 하지만 속도도 느려집니다.

function truncateDecimals (num, digits) {
    var numS = num.toString(),
        decPos = numS.indexOf('.'),
        substrLength = decPos == -1 ? numS.length : 1 + decPos + digits,
        trimmedResult = numS.substr(0, substrLength),
        finalResult = isNaN(trimmedResult) ? 0 : trimmedResult;

    return parseFloat(finalResult);
}

속도가 필요하지만 부동 소수점 오류를 피하고 싶다면 BigDecimal.js 와 같은 것을 시도하십시오 . 이 SO 질문에서 다른 javascript BigDecimal 라이브러리를 찾을 수 있습니다. "좋은 Javascript BigDecimal 라이브러리가 있습니까?" Javascript 용 수학 라이브러리에 대한 좋은 블로그 게시물이 있습니다.

var a = 5.467;
var truncated = Math.floor(a * 100) / 100; // = 5.46

toFixed에 대해 0.5를 빼서 반올림을 수정할 수 있습니다.

(f - 0.005).toFixed(2)

고려 이중 물결을 활용 :~~ .

번호를 받아보세요. 를 사용 하여 0 자리까지 자를 수 있도록 소수점 뒤의 유효 자릿수를 곱합니다 ~~. 그 승수를 다시 나눕니다. 이익.

function truncator(numToTruncate, intDecimalPlaces) {    
    var numPower = Math.pow(10, intDecimalPlaces); // "numPowerConverter" might be better
    return ~~(numToTruncate * numPower)/numPower;
}

나는 ~~전화를 괄호로 감싸지 않으려 고 노력하고있다 . 작업 순서가 올바르게 작동해야한다고 생각합니다.

alert(truncator(5.1231231, 1)); // is 5.1

alert(truncator(-5.73, 1)); // is -5.7

alert(truncator(-5.73, 0)); // is -5

JSFiddle 링크 .

편집 : 되돌아 보면, 실수로 소수점 왼쪽을 반올림하는 경우도 처리했습니다.

alert(truncator(4343.123, -2)); // gives 4300.

로직은 그 사용법을 찾는 것이 약간 이상하며 빠른 리팩터링의 이점을 누릴 수 있습니다. 하지만 여전히 작동합니다. 좋은 것보다 운이 좋습니다.

좋은 한 줄 솔루션 :

function truncate (num, places) {
  return Math.trunc(num * Math.pow(10, places)) / Math.pow(10, places);
}

그런 다음 다음과 같이 호출하십시오.

truncate(3.5636232, 2); // returns 3.56
truncate(5.4332312, 3); // returns 5.433
truncate(25.463214, 4); // returns 25.4632

|간단하고 잘 작동하기 때문에 사용하여 답변을 던질 것이라고 생각 했습니다.

truncate = function(number, places) {
  var shift = Math.pow(10, places);

  return ((number * shift) | 0) / shift;
};

비트 연산자를 사용하여 자르기 :

~~0.5 === 0
~~(-0.5) === 0
~~14.32794823 === 14
~~(-439.93) === -439

@Dogbert의 대답 Math.trunc은 반올림 대신 잘리는 으로 개선 될 수 있습니다 .

반올림과 자르기에는 차이가 있습니다. 잘림은 분명히이 질문이 추구하는 행동입니다. truncate (-3.14)를 호출하고 -4를 다시 받으면 분명히 바람직하지 않다고 할 것입니다. – @NickKnowlson

var a = 5.467;
var truncated = Math.trunc(a * 100) / 100; // = 5.46

var a = -5.467;
var truncated = Math.trunc(a * 100) / 100; // = -5.46

더 짧은 방법으로 답을 썼습니다. 여기 내가 생각 해낸 것입니다

function truncate(value, precision) {
    var step = Math.pow(10, precision || 0);
    var temp = Math.trunc(step * value);

    return temp / step;
}

방법은 이렇게 사용할 수 있습니다

truncate(132456.25456789, 5)); // Output: 132456.25456
truncate(132456.25456789, 3)); // Output: 132456.254
truncate(132456.25456789, 1)); // Output: 132456.2   
truncate(132456.25456789));    // Output: 132456

또는 더 짧은 구문을 원하는 경우 여기에

function truncate(v, p) {
    var s = Math.pow(10, p || 0);
    return Math.trunc(s * v) / s;
}

Number.prototype.trim = function(decimals) {
    var s = this.toString();
    var d = s.split(".");
    d[1] = d[1].substring(0, decimals);
    return parseFloat(d.join("."));
}

console.log((5.676).trim(2)); //logs 5.67

이 기능이 간단한 해결책이 될 수 있다고 생각합니다.

function trunc(decimal,n=2){
  let x = decimal + ''; // string 
  return x.lastIndexOf('.')>=0?parseFloat(x.substr(0,x.lastIndexOf('.')+(n+1))):decimal; // You can use indexOf() instead of lastIndexOf()
}

console.log(trunc(-241.31234,2));
console.log(trunc(241.312,5));
console.log(trunc(-241.233));
console.log(trunc(241.2,0));  
console.log(trunc(241));

문제를 발견했습니다. 다음 상황을 고려할 때 : 2.1 또는 1.2 또는 -6.4

항상 3 자리 또는 2 자리 또는 Wharever를 원하면 오른쪽에있는 선행 0을 완료해야합니다.

// 3 decimals numbers
0.5 => 0.500

// 6 decimals
0.1 => 0.10000

// 4 decimales
-2.1 => -2.1000

// truncate to 3 decimals
3.11568 => 3.115

이것은 Nick Knowlson의 고정 기능입니다.

function truncateDecimals (num, digits) 
{
    var numS = num.toString();
    var decPos = numS.indexOf('.');
    var substrLength = decPos == -1 ? numS.length : 1 + decPos + digits;
    var trimmedResult = numS.substr(0, substrLength);
    var finalResult = isNaN(trimmedResult) ? 0 : trimmedResult;

    // adds leading zeros to the right
    if (decPos != -1){
        var s = trimmedResult+"";
        decPos = s.indexOf('.');
        var decLength = s.length - decPos;

            while (decLength <= digits){
                s = s + "0";
                decPos = s.indexOf('.');
                decLength = s.length - decPos;
                substrLength = decPos == -1 ? s.length : 1 + decPos + digits;
            };
        finalResult = s;
    }
    return finalResult;
};

https://jsfiddle.net/huttn155/7/

function toFixed(number, digits) {
    var reg_ex = new RegExp("(\\d+\\.\\d{" + digits + "})(\\d)")
    var array = number.toString().match(reg_ex);
    return array ? parseFloat(array[1]) : number.valueOf()
}

var test = 10.123456789
var __fixed = toFixed(test, 6)
console.log(__fixed)
// => 10.123456

@kirilloid의 대답이 정답 인 것 같지만 기본 코드를 업데이트해야합니다. 그의 솔루션은 음수를 처리하지 않습니다 (누군가 주석 섹션에서 언급했지만 기본 코드에서 업데이트되지 않았습니다).

완전한 최종 테스트 솔루션으로 업데이트 :

Number.prototype.toFixedDown = function(digits) {
    var re = new RegExp("([-]*\\d+\\.\\d{" + digits + "})(\\d)"),
    m = this.toString().match(re);
    return m ? parseFloat(m[1]) : this.valueOf();
};

샘플 사용법 :

var x = 3.1415629;
Logger.log(x.toFixedDown(2)); //or use whatever you use to log

바이올린 : JS 번호 내림

PS : 해당 솔루션에 대해 언급 할 저장소가 충분하지 않습니다.

다음은 소수점 이하 2 자리까지 숫자를 자르는 간단하지만 작동하는 함수입니다.

           function truncateNumber(num) {
                var num1 = "";
                var num2 = "";
                var num1 = num.split('.')[0];
                num2 = num.split('.')[1];
                var decimalNum = num2.substring(0, 2);
                var strNum = num1 +"."+ decimalNum;
                var finalNum = parseFloat(strNum);
                return finalNum;
            }

결과 유형은 숫자로 유지됩니다.

/* Return the truncation of n wrt base */
var trunc = function(n, base) {
    n = (n / base) | 0;
    return base * n;
};
var t = trunc(5.467, 0.01);

Lodash에는 반올림 , 바닥 및 천장 이 가능한 몇 가지 수학 유틸리티 메서드가 있습니다. 주어진 소수점 정밀도 숫자입니다. 이것은 후행 0을 남깁니다.

그들은 숫자의 지수를 사용하여 흥미로운 접근 방식을 취합니다. 분명히 이것은 반올림 문제를 피합니다.

(참고 : func입니다 Math.round하거나 ceil또는 floor아래의 코드에서)

// Shift with exponential notation to avoid floating-point issues.
var pair = (toString(number) + 'e').split('e'),
    value = func(pair[0] + 'e' + (+pair[1] + precision));

pair = (toString(value) + 'e').split('e');
return +(pair[0] + 'e' + (+pair[1] - precision));

소스 코드에 연결

주제에 대한 나의 견해는 다음과 같습니다.

convert.truncate = function(value, decimals) {
  decimals = (decimals === undefined ? 0 : decimals);
  return parseFloat((value-(0.5/Math.pow(10, decimals))).toFixed(decimals),10);
};

약간 더 정교한 버전입니다.

(f - 0.005).toFixed(2)

해결책으로 표시된 것은 오늘까지 내가 찾은 더 나은 해결책이지만 0에 심각한 문제가 있습니다 (예 : 0.toFixedDown (2)는 -0.01을 제공합니다). 그래서 이것을 사용하는 것이 좋습니다.

Number.prototype.toFixedDown = function(digits) {
  if(this == 0) {
    return 0;
  }
  var n = this - Math.pow(10, -digits)/2;
  n += n / Math.pow(2, 53); // added 1360765523: 17.56.toFixedDown(2) === "17.56"
  return n.toFixed(digits);
}

내가 사용하는 것은 다음과 같습니다.

var t = 1;
for (var i = 0; i < decimalPrecision; i++)
    t = t * 10;

var f = parseFloat(value);
return (Math.floor(f * t)) / t;

const TO_FIXED_MAX = 100;

function truncate(number, decimalsPrecison) {
  // make it a string with precision 1e-100
  number = number.toFixed(TO_FIXED_MAX);

  // chop off uneccessary digits
  const dotIndex = number.indexOf('.');
  number = number.substring(0, dotIndex + decimalsPrecison + 1);

  // back to a number data type (app specific)
  return Number.parseFloat(number);
}

// example
truncate(0.00000001999, 8);
0.00000001

와 일하다:

• 음수
• 매우 작은 숫자 (Number.EPSILON 정밀도)

나를 위해 일한 간단한 해결책을 지적하기 위해

그것을 문자열로 변환 한 다음 정규식으로 변환하십시오 ...

var number = 123.45678;
var number_s = '' + number;
var number_truncated_s = number_s.match(/\d*\.\d{4}/)[0]
var number_truncated = parseFloat(number_truncated_s)

축약 될 수 있습니다.

var number_truncated = parseFloat(('' + 123.4568908).match(/\d*\.\d{4}/)[0])

다음은 원하는 작업을 수행하는 ES6 코드입니다.

const truncateTo = (unRouned, nrOfDecimals = 2) => {
      const parts = String(unRouned).split(".");

      if (parts.length !== 2) {
          // without any decimal part
        return unRouned;
      }

      const newDecimals = parts[1].slice(0, nrOfDecimals),
        newString = `${parts[0]}.${newDecimals}`;

      return Number(newString);
    };

// your examples 

 console.log(truncateTo(5.467)); // ---> 5.46

 console.log(truncateTo(985.943)); // ---> 985.94

// other examples 

 console.log(truncateTo(5)); // ---> 5

 console.log(truncateTo(-5)); // ---> -5

 console.log(truncateTo(-985.943)); // ---> -985.94

Number.prototype.truncate = function(places) {
  var shift = Math.pow(10, places);

  return Math.trunc(this * shift) / shift;
};

문자열로 작업 할 수 있습니다. '.'인지 확인합니다. 존재하고 문자열의 일부를 제거합니다.

자르기 (7.88, 1)-> 7.8

자르기 (7.889, 2)-> 7.89

자르기 (-7.88, 1)-> -7.88

function  truncate(number, decimals) {
    const tmp = number + '';
    if (tmp.indexOf('.') > -1) {
        return +tmp.substr(0 , tmp.indexOf('.') + decimals+1 );
    } else {
        return +number
    }
 }

나는 근본적으로 단순한 질문에 대해 왜 그렇게 많은 다른 대답이 있는지에 대해 약간 혼란 스럽습니다. 볼 가치가있는 것처럼 보이는 접근 방식은 두 가지뿐입니다. https://jsbench.me/를 사용하여 속도 차이를 확인하기 위해 빠른 벤치 마크를 수행했습니다. .

이것은 현재 (2020 년 9 월 26 일) 답변으로 표시된 솔루션입니다.

function truncate(n, digits) {
    var re = new RegExp("(\\d+\\.\\d{" + digits + "})(\\d)"),
        m = n.toString().match(re);
    return m ? parseFloat(m[1]) : n.valueOf();
};

[   truncate(5.467,2),
    truncate(985.943,2),
    truncate(17.56,2),
    truncate(0, 1),
    truncate(1.11, 1) + 22];

그러나 이것은 일반적으로 매우 효율적이지 않은 문자열 및 정규식 작업을 수행하며 정확하게 수행하는 Math.trunc 함수가 있습니다. 소수없이 OP가 원하는 것을 가 있습니다. 따라서 동일한 것을 얻기 위해 약간의 추가 산술과 함께 쉽게 사용할 수 있습니다.

다음은이 스레드에서 찾은 또 다른 솔루션입니다.

function truncate(n, digits) {
    var step = Math.pow(10, digits || 0);
    var temp = Math.trunc(step * n);

    return temp / step;
}

[   truncate(5.467,2),
    truncate(985.943,2),
    truncate(17.56,2),
    truncate(0, 1),
    truncate(1.11, 1) + 22];
    

첫 번째 방법은 두 번째 방법보다 "99.92 % 느리므로"두 번째 방법은 확실히 제가 권장하는 방법입니다.

좋아요, 일을 피할 수있는 다른 방법 찾기로 돌아가서 ...