내가 좋아하는 부동 소수점 숫자를 가지고 3.2와 1.6.

숫자를 정수와 소수로 분리해야합니다. 예를 들어, 값이 3.2두 숫자로 분할 할 것, 즉 3및0.2

정수 부분을 얻는 것은 쉽습니다.

n = Math.floor(n);

그러나 소수 부분을 얻는 데 문제가 있습니다. 나는 이것을 시도했다 :

remainer = n % 2; //obtem a parte decimal do rating

그러나 항상 올바르게 작동하지는 않습니다.

이전 코드에는 다음과 같은 출력이 있습니다.

n = 3.1 => remainer = 1.1

내가 여기서 무엇을 놓치고 있습니까?

사용 1하지 말고 사용하십시오 2.

js> 2.3 % 1
0.2999999999999998

var decimal = n - Math.floor(n)

마이너스 숫자에는 작동하지 않으므로해야 할 수도 있습니다.

n = Math.abs(n); // Change to positive
var decimal = n - Math.floor(n)

문자열로 변환 할 수 있습니까?

n = (n + "").split(".");

0.2999999999999998은 어떻게 받아 들일 수 있습니까? 내가 실수 한 사람이라면 나는 .3의 답을 원할 것입니다. 여기서 우리가 가진 것은 허위 정밀도이며, floor, % 등을 사용한 실험은 Javascript가 이러한 연산에 대해 허위 정밀도를 좋아한다는 것을 나타냅니다. 따라서 문자열 변환을 사용하는 답변이 올바른 방향에 있다고 생각합니다.

나는 이것을 할 것이다 :

var decPart = (n+"").split(".")[1];

특히 100233.1을 사용하고 있는데 ".1"이라는 답을 원했습니다.

내가하는 방법은 다음과 같습니다. 가장 쉬운 방법이라고 생각합니다.

var x = 3.2;
int_part = Math.trunc(x); // returns 3
float_part = Number((x-int_part).toFixed(2)); // return 0.2

이를 수행하는 간단한 방법은 다음과 같습니다.

var x = 3.2;
var decimals = x - Math.floor(x);
console.log(decimals); //Returns 0.20000000000000018

불행히도 정확한 값을 반환하지는 않습니다. 그러나 그것은 쉽게 수정됩니다.

var x = 3.2;
var decimals = x - Math.floor(x);
console.log(decimals.toFixed(1)); //Returns 0.2

소수점 이하 자릿수를 모르는 경우이를 사용할 수 있습니다.

var x = 3.2;
var decimals = x - Math.floor(x);

var decimalPlaces = x.toString().split('.')[1].length;
decimals = decimals.toFixed(decimalPlaces);

console.log(decimals); //Returns 0.2

언어 독립적 인 방법 :

var a = 3.2;
var fract = a * 10 % 10 /10; //0.2
var integr = a - fract; //3

fractioanal 길이가 하나 인 숫자에 대해서만 수정됨에 유의하십시오.)

parseInt()함수를 사용하여 소수 부분을 추출하는 것보다 정수 부분을 얻을 수 있습니다

var myNumber = 3.2;
var integerPart = parseInt(myNumber);
var decimalPart = myNumber - integerPart;

또는 다음과 같은 정규식을 사용할 수 있습니다.

splitFloat = function(n){
   const regex = /(\d*)[.,]{1}(\d*)/;
   var m;

   if ((m = regex.exec(n.toString())) !== null) {
       return {
          integer:parseInt(m[1]),
          decimal:parseFloat(`0.${m[2]}`)
       }
   }
}

다음은 구분 기호에 한 문자 만 사용되는 조건에서 소수점 구분 기호의 지역 설정에 관계없이 작동합니다.

var n = 2015.15;
var integer = Math.floor(n).toString();
var strungNumber = n.toString();
if (integer.length === strungNumber.length)
  return "0";
return strungNumber.substring(integer.length + 1);

예쁘지는 않지만 정확합니다.

정밀도가 중요하고 일관된 결과가 필요한 경우 선행 "0"을 포함하여 숫자의 소수 부분을 문자열로 반환하는 몇 가지 제안이 있습니다. 플로트로 필요 var f = parseFloat( result )하면 끝에 추가 하십시오.

소수 부분이 0이면 "0.0"이 반환됩니다. Null, NaN 및 정의되지 않은 숫자는 테스트되지 않습니다.

1. String.split

var nstring = (n + ""),
    narray  = nstring.split("."),
    result  = "0." + ( narray.length > 1 ? narray[1] : "0" );

2. String.substring, String.indexOf

var nstring = (n + ""),
    nindex  = nstring.indexOf("."),
    result  = "0." + (nindex > -1 ? nstring.substring(nindex + 1) : "0");

3. Math.floor, Number.toFixed, String.indexOf

var nstring = (n + ""),
    nindex  = nstring.indexOf("."),
    result  = ( nindex > -1 ? (n - Math.floor(n)).toFixed(nstring.length - nindex - 1) : "0.0");

4. Math.floor, Number.toFixed, String.split

var nstring = (n + ""),
    narray  = nstring.split("."),
    result  = (narray.length > 1 ? (n - Math.floor(n)).toFixed(narray[1].length) : "0.0");

다음은 jsPerf 링크입니다. https://jsperf.com/decpart-of-number/

제안 # 2가 가장 빠르다는 것을 알 수 있습니다.

문자열로 변환하고 replace메소드를 사용 하여 정수 부분을 0으로 바꾸고 결과를 다시 숫자로 변환 할 수 있습니다.

var number = 123.123812,
    decimals = +number.toString().replace(/^[^\.]+/,'0');

사용법에 따라 나중에 제공하지만이 간단한 솔루션도 도움이 될 수 있습니다.

좋은 해결책은 아니지만 구체적인 경우에는 효과가 있습니다.

var a = 10.2
var c = a.toString().split(".")
console.log(c[1] == 2) //True
console.log(c[1] === 2)  //False

그러나 @Brian M. Hunt가 제안한 솔루션보다 시간이 오래 걸립니다.

(2.3 % 1).toFixed(4)

나는 문제의 모든 숫자가 하나의 소수점 만 가질 것이라는 것을 알고 사례에 정수로 소수 부분을 얻고 싶기 때문에 이런 종류의 접근 방식을 사용했습니다.

var number = 3.1,
    decimalAsInt = Math.round((number - parseInt(number)) * 10); // returns 1

이것은 정수에서도 잘 작동하며 그 경우 0을 반환합니다.

나는 사용하고있다 :

var n = -556.123444444;
var str = n.toString();
var decimalOnly = 0;

if( str.indexOf('.') != -1 ){ //check if has decimal
    var decimalOnly = parseFloat(Math.abs(n).toString().split('.')[1]);
}

입력 : -556.123444444

결과 : 123444444

수학 함수는 빠르지 만 항상 기본 예상 값을 반환하지는 않습니다. 내가 찾은 가장 쉬운 방법은

(3.2+'').replace(/^[-\d]+\./, '')

좋은 옵션은 숫자를 문자열로 변환 한 다음 나누는 것입니다.

// Decimal number
let number = 3.2;

// Convert it into a string
let string = number.toString();

// Split the dot
let array = string.split('.');

// Get both numbers
// The '+' sign transforms the string into a number again
let firstNumber  = +array[0]; // 3
let secondNumber = +array[1]; // 2

한 줄의 코드에서

let [firstNumber, secondNumber] = [+number.toString().split('.')[0], +number.toString().split('.')[1]];

이 중 몇 가지를 본 후 지금 사용하고 있습니다 ...

var rtnValue = Number(7.23);
var tempDec = ((rtnValue / 1) - Math.floor(rtnValue)).toFixed(2);

n = Math.floor(x);
remainder = x % 1;

이 답변에 매우 늦었지만 코드를 살펴보십시오.

let floatValue = 3.267848;
let decimalDigits = floatValue.toString().split('.')[1];
let decimalPlaces = decimalDigits.length;
let decimalDivider = Math.pow(10, decimalPlaces);
let fractionValue = decimalDigits/decimalDivider;
let integerValue = floatValue - fractionValue;

console.log("Float value: "+floatValue);
console.log("Integer value: "+integerValue);
console.log("Fraction value: "+fractionValue)

부동 소수점 10 진수 기호 및 숫자 형식은 국가 ( .,)에 따라 달라질 수 있으므로 부동 소수점 부분을 보존하는 독립 솔루션은 다음과 같습니다.

getFloatDecimalPortion = function(x) {
    x = Math.abs(parseFloat(x));
    let n = parseInt(x);
    return Number((x - n).toFixed(Math.abs((""+x).length - (""+n).length - 1)));
}

– 위치에 의존하지 않고 국제화 된 솔루션입니다.

getFloatDecimalPortion = x => parseFloat("0." + ((x + "").split(".")[1]));

단계별 솔루션 설명 :

1. parseFloat() 입력 인식 보장
2. Math.abs() 음수 문제를 피하기 위해
3. n = parseInt(x) 소수 부분을 얻기 위해
4. x - n 소수점 이하 빼기
5. 우리는 이제 소수점 이하 0의 숫자를 가지지 만 JavaScript는 부동 소수점을 추가로 줄 수 있습니다.
6. 따라서 toFixed()원래 float number의 부동 부분에서 자릿수를 호출 하여 추가 자릿수를 제한하십시오 x. 개수는 문자열 표현에서 원래 숫자의 길이 x와 숫자 의 차이로 계산됩니다 n.

이것을 사용하십시오 :

function isNatural(n) {
    n = +n
    if (isNaN(n)) return 'NaN';
    return (n >= 0.0) && (Math.floor(n) === n) && n !== Infinity;
  }

Math.frac = function frac(x, m) {
    x = +x
    if (isNaN(x)) return NaN;
    if (isNatural(x) === true) return 0;
    m = +m || 1

      if (isNatural(x) === false && m === 1){
        var a = x.toString()
        var b = a.split('.')[1]
        var c = '0.' + b
        var d = +c
        return d;
      }

      if (isNatural(x) === false && m === 2){
        var a = x.toString()
        var b = a.split('.')[1]
        var c = +b
        return c;
      }

      if (isNatural(x) === false && m === 3){
        var a = x.toString()
        var b = a.split('.')[1]
        var c = '0.' + b
        var d = +c * 100
        return d;
      }    
  }

이 Math.frac기능에는 3 가지 모드가 있습니다.

Math.frac(11.635) //0.635
Math.frac(11.635, 1) //0.635 - default mode is 1
Math.frac(11.635, 2) //635
Math.frac(11.635, 3) //63,5 (%)

간단 해 :)

float a=3.2;
int b=(int)a; // you'll get output b=3 here;
int c=(int)a-b; // you'll get c=.2 value here