使用JavaScript获取数字的小数部分

时间:2010-12-22 18:20:09

标签: javascript floating-point numbers decimal rounding

我有3.21.6等浮点数。

我需要将数字分成整数和小数部分。例如,3.2的值将分为两个数字,即30.2

获取整数部分很简单:

n = Math.floor(n);

但是我无法获得小数部分。 我试过这个:

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

但它并不总能正常运作。

前面的代码有以下输出:

n = 3.1 => remainer = 1.1

我在这里缺少什么?

27 个答案:

答案 0 :(得分:303)

使用1,而不是2

js> 2.3 % 1
0.2999999999999998

答案 1 :(得分:80)

var decimal = n - Math.floor(n)

虽然这不适用于减号,但我们可能不得不这样做

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

答案 2 :(得分:67)

您可以转换为字符串,对吗?

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

答案 3 :(得分:29)

0.2999999999999998如何是可接受的答案?如果我是提问者,我会想要答案.3。我们在这里得到的是错误的精确度,我对floor,%等的实验表明,Javascript喜欢这些操作的错误精度。所以我认为使用转换为字符串的答案是正确的。

我会这样做:

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

具体来说,我使用的是100233.1,我想要答案" .1"。

答案 4 :(得分:11)

以下是我的工作方式,我认为这是最简单的方法:

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

答案 5 :(得分:11)

一种简单的方法是:

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

答案 6 :(得分:5)

以下情况无论小数分隔符的区域设置如何...条件只有一个字符用于分隔符。

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);

它很漂亮,但它很准确。

答案 7 :(得分:4)

您可以将其转换为字符串并使用replace方法将整数部分替换为零,然后将结果转换回数字:

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

答案 8 :(得分:4)

根据您之后会给出的用法,但这个简单的解决方案也可以帮助您。

我不是说它是一个很好的解决方案,但对于一些具体案例来说

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)

答案 9 :(得分:4)

语言无关的方式:

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

请注意,它仅适用于具有一个fractioanal lenght的数字)

答案 10 :(得分:3)

如果精度很重要并且您需要一致的结果,这里有一些命题会将任何数字的小数部分作为字符串返回,包括前导" 0。"。如果您需要它作为浮点数,最后只需添加var f = parseFloat( result )

如果小数部分等于零," 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是最快的。

答案 11 :(得分:3)

一个不错的选择是将数字转换为字符串,然后将其分割。

// 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]];

答案 12 :(得分:2)

您可以使用parseInt()函数获取整数部分,而不是使用它来提取小数部分

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

答案 13 :(得分:1)

我有一个案例,我知道所有相关的数字只有一个小数,并希望将小数部分作为整数,所以我最终使用这种方法:

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

这也适用于整数,在这些情况下返回0。

答案 14 :(得分:1)

我正在使用:

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

答案 15 :(得分:0)

在查看其中几个之后,我现在正在使用......

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

答案 16 :(得分:0)

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

答案 17 :(得分:0)

数学函数更快,但始终不返回本机期望值。 我发现的最简单的方法是

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

答案 18 :(得分:0)

尽管我回答这个问题很晚,但是请看一下代码。

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)

答案 19 :(得分:0)

浮点十进制符号和数字格式可以取决于国家(.,),因此保留浮点部分的独立解决方案是:

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. 现在我们的数字的小数部分为零,但是JavaScript可以为我们提供额外的浮动部分数字,这是我们不希望的
  6. 因此,通过使用原始浮点数toFixed()的浮点部分中的位数来调用x来限制其他位数。计算方式为原始数字x的长度和字符串表示形式中数字n的长度之差。

答案 20 :(得分:0)

避免数学不精确的最佳方法是将其转换为字符串,但要使用toLocaleString来确保其为您期望的“点”格式:

function getDecimals(n) {
  // Note that maximumSignificantDigits defaults to 3 so your decimals will be rounded if not changed.
  const parts = n.toLocaleString('en-US', { maximumSignificantDigits: 18 }).split('.')
  return parts.length > 1 ? Number('0.' + parts[1]) : 0
}

console.log(getDecimals(10.58))

答案 21 :(得分:0)

此函数将浮点数拆分为整数,并以数组形式返回它:

function splitNumber(num)
{
  num = ("0" + num).match(/([0-9]+)([^0-9]([0-9]+))?/);
  return [ ~~num[1], ~~num[3] ];
}

console.log(splitNumber(3.2));     // [ 3, 2 ]
console.log(splitNumber(123.456)); // [ 123, 456 ]
console.log(splitNumber(789));     // [ 789, 0 ]
console.log(splitNumber("test"));  // [ 0, 0 ]

您可以将其扩展为仅返回现有数字,如果没有数字,则返回null

function splitNumber(num)
{
  num = ("" + num).match(/([0-9]+)([^0-9]([0-9]+))?/);
  return [num ? ~~num[1] : null, num && num[3] !== undefined ? ~~num[3] : null];
}

console.log(splitNumber(3.2));     // [ 3, 2 ]
console.log(splitNumber(123.456)); // [ 123, 456 ]
console.log(splitNumber(789));     // [ 789, null ]
console.log(splitNumber("test"));  // [ null, null ]

答案 22 :(得分:0)

我喜欢这个答案https://stackoverflow.com/a/4512317/1818723,只需应用浮点修复程序

function fpFix(n) {
  return Math.round(n * 100000000) / 100000000;
}

let decimalPart = 2.3 % 1; //0.2999999999999998
let correct = fpFix(decimalPart); //0.3

完成功能处理正负

function getDecimalPart(decNum) {
  return Math.round((decNum % 1) * 100000000) / 100000000;
}

console.log(getDecimalPart(2.3)); // 0.3
console.log(getDecimalPart(-2.3)); // -0.3
console.log(getDecimalPart(2.17247436)); // 0.17247436

P.S。如果您是加密货币交易平台开发人员或银行系统开发人员或任何JS开发人员;),请在各处应用fpFix。谢谢!

答案 23 :(得分:0)

2021 更新

解决精度问题(或不解决问题)的优化版本。

// Global variables.
const DEFAULT_PRECISION = 16;
const MAX_CACHED_PRECISION = 20;

// Helper function to avoid numerical imprecision from Math.pow(10, x).
const _pow10 = p => parseFloat(`1e+${p}`);

// Cache precision coefficients, up to a precision of 20 decimal digits.
const PRECISION_COEFS = new Array(MAX_CACHED_PRECISION);
for (let i = 0; i !== MAX_CACHED_PRECISION; ++i) {
  PRECISION_COEFS[i] = _pow10(i);
}

// Function to get a power of 10 coefficient,
// optimized for both speed and precision.
const pow10 = p => PRECISION_COEFS[p] || _pow10(p);

// Function to trunc a positive number, optimized for speed.
// See: https://stackoverflow.com/questions/38702724/math-floor-vs-math-trunc-javascript
const trunc = v => (v < 1e8 && ~~v) || Math.trunc(v);

// Helper function to get the decimal part when the number is positive,
// optimized for speed.
// Note: caching 1 / c or 1e-precision still leads to numerical errors.
// So we have to pay the price of the division by c.  
const _getDecimals = (v = 0, precision = DEFAULT_PRECISION) => {
  const c = pow10(precision); // Get precision coef.
  const i = trunc(v); // Get integer.
  const d = v - i; // Get decimal.
  return Math.round(d * c) / c;
}

// Augmenting Number proto.
Number.prototype.getDecimals = function(precision) {
  return (isFinite(this) && (precision ? (
    (this < 0 && -_getDecimals(-this, precision))
      || _getDecimals(this, precision)
  ) : this % 1)) || 0;
}

// Independent function.
const getDecimals = (input, precision) => (isFinite(input) && (
  precision ? (
    (this < 0 && -_getDecimals(-this, precision))
      || _getDecimals(this, precision)
  ) : this % 1
)) || 0;

// Tests:
const test = (value, precision) => (
  console.log(value, '|', precision, '-->', value.getDecimals(precision))
);

test(1.001 % 1); // --> 0.0009999999999998899
test(1.001 % 1, 16); // --> 0.000999999999999
test(1.001 % 1, 15); // --> 0.001
test(1.001 % 1, 3); // --> 0.001
test(1.001 % 1, 2); // --> 0
test(-1.001 % 1, 16); // --> -0.000999999999999
test(-1.001 % 1, 15); // --> -0.001
test(-1.001 % 1, 3); // --> -0.001
test(-1.001 % 1, 2); // --> 0

答案 24 :(得分:0)

您可以简单地使用 parseInt() 函数来提供帮助,例如:

let decimal = 3.2;
let remainder = decimal - parseInt(decimal);
document.write(remainder)

(十进制);

答案 25 :(得分:-1)

使用这个:

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 (isNatural(x) === 'NaN') 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 (%)

很简单:)

答案 26 :(得分:-9)

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