Javascript에서 소수점 1자리를 어떻게 반올림합니까?

Javascript에서 소수점 1자리를 어떻게 반올림합니까?

javascript의 숫자를 소수점 이후 1자로 반올림할 수 있습니까?

*10, 라운드, /10을 써봤는데 입력 끝에 소수점 두 개가 남아요.

Math.round(num * 10) / 10과가있있 있있있다다여기 예가 있습니다.

var number = 12.3456789
var rounded = Math.round(number * 10) / 10
// rounded is 12.3

소수점 이하 한 자리만 쓰려면 0이 되더라도...

var fixed = rounded.toFixed(1)
// fixed is always to 1 d.p.
// NOTE: .toFixed() returns a string!

// To convert back to number format
parseFloat(number.toFixed(2))
// 12.34
// but that will not retain any trailing zeros

// So, just make sure it is the last step before output,
// and use a number format during calculations!

EDIT: 정밀함수로 라운드 추가...

예를 들어 이 원리를 사용하여 정밀도가 필요한 작고 둥근 함수를 소개합니다.

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

...사용방법...

round(12345.6789, 2) // 12345.68
round(12345.6789, 1) // 12345.7

... 디폴트에서는, 가장 가까운 정수로 반올림 합니다(소수 0).

round(12345.6789) // 12346

...가장 가까운 10이나 100 등으로 반올림할 수 있습니다...

round(12345.6789, -1) // 12350
round(12345.6789, -2) // 12300

...그리고 음수들의 정확한 처리...

round(-123.45, 1) // -123.4
round(123.45, 1) // 123.5

toFixed와 조합하여 문자열로 일관되게 포맷할 수 있습니다.

round(456.7, 2).toFixed(2) // "456.70"

var number = 123.456;

console.log(number.toFixed(1)); // should round to 123.5

「 」를 사용하고 Math.round(5.01) 얻을 수 있다55.0.

「 」를 사용하고 toFixed 라운딩 이슈에 부딪히게 됩니다.

두 가지 장점을 모두 누리려면 다음 두 가지를 결합해야 합니다.

(Math.round(5.01 * 10) / 10).toFixed(1)

다음과 같은 기능을 만들 수 있습니다.

function roundedToFixed(input, digits){
  var rounded = Math.pow(10, digits);
  return (Math.round(input * rounded) / rounded).toFixed(digits);
}

lodash 가지고 있다round★★★★

_.round(4.006);
// => 4

_.round(4.006, 2);
// => 4.01

_.round(4060, -2);
// => 4100

문서

출처.

는 저저에 toFixed()하지만 참고로 비트 시프트를 사용하여 int에 번호를 캐스팅하는 다른 방법이 있습니다.따라서 항상 0으로 반올림합니다(양수일 경우 하강, 음수일 경우 상승).

var rounded = ((num * 10) << 0) * 0.1;

근데 함수 호출이 없으니까 너무 빨라요.:)

스트링 매칭을 사용하는 것은 다음과 같습니다.

var rounded = (num + '').replace(/(^.*?\d+)(\.\d)?.*/, '$1$2');

현악기 변형은 추천하지 않습니다.그냥 말해 주세요.

다음의 조작을 간단하게 실시할 수 있습니다.

let n = 1.25
let result = Number(n).toFixed(1)
// output string: 1.3

다음을 사용해 보십시오.

var original=28.453

// 1.- round "original" to two decimals
var result = Math.round (original * 100) / 100  //returns 28.45

// 2.- round "original" to 1 decimal
var result = Math.round (original * 10) / 10  //returns 28.5

// 3.- round 8.111111 to 3 decimals
var result = Math.round (8.111111 * 1000) / 1000  //returns 8.111

덜 복잡하고 쉽게 구현할 수 있습니다.

이를 통해 다음 작업을 수행하는 함수를 만들 수 있습니다.

function RoundAndFix (n, d) {
    var m = Math.pow (10, d);
    return Math.round (n * m) / m;
}

function RoundAndFix (n, d) {
    var m = Math.pow (10, d);
    return Math.round (n * m) / m;
}
console.log (RoundAndFix(8.111111, 3));

편집: 'ROUND HALF UP'을 사용하여 반올림하는 방법'을 참조하십시오. 대부분 초등학교 때 배운 반올림 모드

왜 그냥 하지 않는 거야?

let myNumber = 213.27321;
+myNumber.toFixed(1); // => 213.3

1. toFixed: 고정 소수점 표기법을 사용하여 지정된 숫자를 나타내는 문자열을 반환합니다.
2. 단항 플러스(+):단항 더하기 연산자는 피연산자 앞에 나와 피연산자로 평가되지만 아직 숫자로 변환되지 않은 경우 숫자로 변환하려고 시도합니다.

toPrecision 메서드 사용:

var a = 1.2345
a.toPrecision(2)

// result "1.2"

스케일링으로 .round(num * p) / p

간단한 구현

중간값과 함께 다음 함수를 사용하면 예상대로 반올림된 상한 값 또는 입력에 따라 반올림된 하한 값을 얻을 수 있습니다.

★★★★★★★★★★★★★★★★★.inconsistency반올림 시 클라이언트 코드의 버그를 검출하기 어려운 경우가 있습니다.

function naiveRound(num, decimalPlaces) {
    var p = Math.pow(10, decimalPlaces);
    return Math.round(num * p) / p;
}

console.log( naiveRound(1.245, 2) );  // 1.25 correct (rounded as expected)
console.log( naiveRound(1.255, 2) );  // 1.25 incorrect (should be 1.26)

구현의 향상

이 수를 지수 표기 문자열로 변환하면 양의 숫자는 예상대로 반올림됩니다.단, 음수는 양수와 다르게 반올림한다는 점에 유의하시기 바랍니다.

실제로 기본적으로 "반올림"과 동등한 기능을 수행합니다.round(-1.005, 2)-1round(1.005, 2)1.01. lodash _.round 메서드는 이 기술을 사용합니다.

/**
 * Round half up ('round half towards positive infinity')
 * Uses exponential notation to avoid floating-point issues.
 * Negative numbers round differently than positive numbers.
 */
function round(num, decimalPlaces) {
    num = Math.round(num + "e" + decimalPlaces);
    return Number(num + "e" + -decimalPlaces);
}

// test rounding of half
console.log( round(0.5, 0) );  // 1
console.log( round(-0.5, 0) ); // 0

// testing edge cases
console.log( round(1.005, 2) );   // 1.01
console.log( round(2.175, 2) );   // 2.18
console.log( round(5.015, 2) );   // 5.02

console.log( round(-1.005, 2) );  // -1
console.log( round(-2.175, 2) );  // -2.17
console.log( round(-5.015, 2) );  // -5.01

음수를 반올림할 때 일반적인 동작을 원할 경우 Math.round()를 호출하기 전에 음수를 양수로 변환한 다음 반환하기 전에 음수로 다시 변환해야 합니다.

// Round half away from zero
function round(num, decimalPlaces) {
    num = Math.round(Math.abs(num) + "e" + decimalPlaces) * Math.sign(num);
    return Number(num + "e" + -decimalPlaces);
}

반올림 함수를 호출하기 전에 엡실론 보정이 적용되는 라운드 투 근접('0에서 반올림 반' 사용)을 수행하는 다른 순수 수학 기법이 있습니다.

반올림 전 수에 가능한 최소 부동값(= 1.0 ulp, 꼴찌 단위)을 더하면 됩니다.이 값은 숫자 뒤에 0이 아닌 다음 표시 가능한 값으로 이동합니다.

/**
 * Round half away from zero ('commercial' rounding)
 * Uses correction to offset floating-point inaccuracies.
 * Works symmetrically for positive and negative numbers.
 */
function round(num, decimalPlaces) {
    var p = Math.pow(10, decimalPlaces);
    var e = Number.EPSILON * num * p;
    return Math.round((num * p) + e) / p;
}

// test rounding of half
console.log( round(0.5, 0) );  // 1
console.log( round(-0.5, 0) ); // -1

// testing edge cases
console.log( round(1.005, 2) );  // 1.01
console.log( round(2.175, 2) );  // 2.18
console.log( round(5.015, 2) );  // 5.02

console.log( round(-1.005, 2) ); // -1.01
console.log( round(-2.175, 2) ); // -2.18
console.log( round(-5.015, 2) ); // -5.02

이는 특히 1.005, 2.675 및 16.235와 같이 마지막 소수점 위치에 "5"가 있는 10진수 부호화 중에 발생할 수 있는 암묵적인 반올림 오류를 상쇄하기 위해 필요합니다.정말로.1.005으로 10진법으로 1.0049999999999999 플로트, 64비트 바이너리 플로트,1234567.005으로 10진법으로 1234567.004999999888241364번

바이너리수 「」는 가 있습니다.round-off error는 (1)와 (2) 머신 엡실론(2^-52)의 크기에 따라 .

var num = 34.7654;

num = Math.round(num * 10) / 10;

console.log(num); // Logs: 34.8

최적의 답변을 작성하려면:

var round = function ( number, precision )
{
    precision = precision || 0;
    return parseFloat( parseFloat( number ).toFixed( precision ) );
}

입력 파라미터 번호는 항상 숫자가 될 수 없습니다.이 경우 toFixed는 존재하지 않습니다.

ES 6 버전 승인된 답변:

function round(value, precision) {
    const multiplier = 10 ** (precision || 0);
    return Math.round(value * multiplier) / multiplier;
}

방법이 작동하지 않으면 코드를 게시하십시오.

단, 다음과 같이 반올림 작업을 수행할 수 있습니다.

var value = Math.round(234.567*100)/100

234.56을 드립니다.

유사하게

 var value = Math.round(234.567*10)/10

234.5를 드립니다.

이렇게 하면 위에서 사용한 상수 대신 변수를 사용할 수 있습니다.

숫자 타입을 반환하고 필요한 경우에만 소수점을 넣을 수 있는 것을 만들었습니다(0 패딩 없음).

예:

roundWithMaxPrecision(11.234, 2); //11.23
roundWithMaxPrecision(11.234, 1); //11.2
roundWithMaxPrecision(11.234, 4); //11.23
roundWithMaxPrecision(11.234, -1); //10

roundWithMaxPrecision(4.2, 2); //4.2
roundWithMaxPrecision(4.88, 1); //4.9

코드:

function roundWithMaxPrecision (n, precision) {
    const precisionWithPow10 = Math.pow(10, precision);
    return Math.round(n * precisionWithPow10) / precisionWithPow10;
}

원하는 경우 Little Angular 필터:

angular.module('filters').filter('decimalPlace', function() {
    return function(num, precision) {
        var multiplier = Math.pow(10, precision || 0);
        return Math.round(num * multiplier) / multiplier;
    };
});

다음을 통해 사용:

{{model.value| decimalPlace}}
{{model.value| decimalPlace:1}}
{{model.value| decimalPlace:2}}

:)

이것은, 내가 던지는 모든 것에 대해서, 확실히 기능하는 것 같습니다.

function round(val, multiplesOf) {
  var s = 1 / multiplesOf;
  var res = Math.ceil(val*s)/s;
  res = res < val ? res + multiplesOf: res;
  var afterZero = multiplesOf.toString().split(".")[1];
  return parseFloat(res.toFixed(afterZero ? afterZero.length : 0));
}

반올림되므로 사용 사례에 따라 수정해야 할 수 있습니다.이 조작은 유효합니다.

console.log(round(10.01, 1)); //outputs 11
console.log(round(10.01, 0.1)); //outputs 10.1

적절한 반올림에 관심이 있는 경우:

function roundNumericStrings(str , numOfDecPlacesRequired){ 
     var roundFactor = Math.pow(10, numOfDecPlacesRequired);  
     return (Math.round(parseFloat(str)*roundFactor)/roundFactor).toString();  }

---

그렇지 않으면 이전 투고에서 이미 회신을 받았습니다.

str.slice(0, -1)

Math.round( num * 10) / 10동작하지 않습니다.

예를들면,1455581777.8-145558160.4주다1310023617.3999999.

따라서 사용만num.toFixed(1)

정밀도 문제를 피할 수 있는 방법을 찾았습니다.

function badRound (num, precision) {
    const x = 10 ** precision;
    return Math.round(num * x) / x
}
// badRound(1.005, 2) --> 1

function round (num, precision) {
    const x = 10 ** (precision + 1);
    const y = 10 ** precision;
    return Math.round(Math.round(num * x) / 10) / y
}
// round(1.005, 2) --> 1.01

Math.round( mul/count * 10 ) / 10

Math.round(Math.sqrt(sqD/y) * 10 ) / 10

감사합니다.

function rnd(v,n=2) {
    return Math.round((v+Number.EPSILON)*Math.pow(10,n))/Math.pow(10,n)
}

이것은 코너 케이스에 잘 들어맞는다

소스 코드가 타이프스크립트인 경우 다음과 같은 함수를 사용할 수 있습니다.

public static ToFixedRounded(decimalNumber: number, fractionDigits: number): number {
    var rounded = Math.pow(10, fractionDigits);
    return (Math.round(decimalNumber * rounded) / rounded).toFixed(fractionDigits) as unknown as number;
}

const solds = 136780000000; 
const number = (solds >= 1000000000 && solds < 1000000000000) ? { divisor: 1000000000, postfix: "B" }: (solds >= 1000000 && solds < 1000000000) ? { divisor: 1000000, postfix: "M" }: (solds >= 1000 && solds < 1000000) ? { divisor: 1000, postfix: "K" }: { divisor: 1, postfix: null }; 
const floor = Math.floor(solds / number.divisor).toLocaleString(); 
const firstDecimalIndex = solds.toLocaleString().charAt(floor.length+1); 
const final =firstDecimalIndex.match("0")? floor + number.postfix: floor + "." + firstDecimalIndex + number.postfix; 
console.log(final);

136780000000 --> 136.7b

1367800 --> 1.3m

1342 --> 1.3k

언급URL : https://stackoverflow.com/questions/7342957/how-do-you-round-to-1-decimal-place-in-javascript