使用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(".");

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

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

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

为什么0.2999999999999998是一个可以接受的答案?如果我是提问者，我希望答案是。3。我们在这里得到的是错误的精度，我对floor、%等的实验表明，Javascript对这些操作喜欢错误的精度。所以我认为使用字符串转换的答案是正确的。

我会这样做:

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

具体来说，我使用100233.1，我想要答案“.1”。

这取决于你以后的用法，但这个简单的解决方案也可以帮助你。

我不是说这是一个很好的解决方案，但在一些具体的情况下是可行的

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

但这比布莱恩·m·亨特提出的解决方案需要更长的时间

(2.3 % 1).toFixed(4)

以下工作不考虑十进制分隔符的区域设置…在此条件下，仅使用一个字符作为分隔符。

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

虽然不漂亮，但很准确。

语言独立方式:

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

注意，它只对分数长度为一个的数字正确)

我有一个案例，我知道所有的数字都只有一个小数，想要得到小数部分作为整数，所以我最终使用这种方法:

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

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

看了几个之后，我现在用的是……

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

一个简单的方法是:

Var x = 3.2; var decimal = x - Math.floor(x); console.log(小数);/ /返回0.20000000000000018

不幸的是，这并没有返回准确的值。然而，这很容易解决:

Var x = 3.2; var decimal = x - Math.floor(x); console.log (decimals.toFixed (1));/ /返回0.2

如果你不知道小数位数，你可以用这个:

Var x = 3.2; var decimal = x - Math.floor(x); var decimalPlaces = x.toString().split('.')[1].length; decimals = decimal . tofixed (decimalPlaces); console.log(小数);/ /返回0.2

以下是我的做法，我认为这是最直接的方法:

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

如果精度很重要，并且您需要一致的结果，这里有一些命题，它们将以字符串形式返回任何数字的小数部分，包括前导的“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是最快的。

我正在使用:

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

您可以使用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]}`)
       }
   }
}

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

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

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

虽然我很晚才回答这个问题，但请看看代码。

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)

浮点小数点符号和数字格式可以依赖于国家(.，)，因此保留浮点部分的独立解为:

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

方案描述一步步:

parseFloat() for guaranteeing input cocrrection Math.abs() for avoiding problems with negative numbers n = parseInt(x) for getting decimal part x - n for substracting decimal part We have now number with zero decimal part, but JavaScript could give us additional floating part digits, which we do not want So, limit additional digits by calling toFixed() with count of digits in floating part of original float number x. Count is calculated as difference between length of original number x and number n in their string representation.

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

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

避免数学不精确的最好方法是转换为字符串，但要确保它是你期望的“点”格式，使用toLocaleString:

函数getDecimals(n) { //注意，maximumSignificantDigits默认为3，所以如果不更改，您的小数将被四舍五入。 const parts = n.toLocaleString('en-US'， {maximumSignificantDigits: 18}).split('.') 返回的部分。长度> 1 ?数量(' 0。' +部分[1]):0 ｝ console.log (getDecimals (10.58))

这个函数将浮点数拆分为整数，并以数组形式返回:

函数拆分数（数） { num = （“”+num）.match（/^（-？[0-9]+)([,.][0-9]+）？/）||[]; 返回 [ ~~num[1]， +（0+num[2]）||0 ]; } console.log（splitNumber（3.02））; [ 3, 0.2 ] console.log（splitNumber（123.456））;[ 123, 0.456 ] console.log（splitNumber（789））; [ 789, 0 ] console.log（splitNumber（-2.7））; [ -2, 0.7 ] console.log（splitNumber（“test”））; [ 0, 0 ]

你可以将它扩展为只返回现有的数字，如果不存在数字则返回null:

函数拆分数（数） { num = （“”+num）.match（/^（-？[0-9]+)([,.][0-9]+)?/); 返回 [ num ？ ~~num[1] ： null， num && num[2] ？ +（0 + num[2]） ： null ]; } console.log（splitNumber（3.02））; [ 3, 0.02 ] console.log（splitNumber（123.456））;[ 123, 0.456 ] console.log（splitNumber（789））; [ 789 空 ] console.log（splitNumber（-2.7））; [ -2, 0.7 ] console.log（splitNumber（“test”））; [ 空，空 ]

我喜欢这个答案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。谢谢!

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

你可以简单地使用parseInt()函数来帮助，例如: 令decimal = 3.2; let remainder = decimal - parseInt(decimal); document . write(剩余部分);

您还可以截断该数字

函数小数(val) { const valStr = val.toString(); const valTruncLength = String(Math.trunc(val)).length; Const dec = valStr。= valTruncLength . length ？ valStr。substring(valTruncLength + 1) :“”; 返回12月; ｝ Console.log ("decimals: "， decimals(123.654321)); Console.log ("no decimal: "， decimal (123));

下面的函数将返回一个包含2个元素的数组。第一个元素是整数部分，第二个元素是小数部分。

函数splitNum(num) { num = num. tostring ().split('.') num[0] = Number(num[0]) if (num[1]) num[1] = Number('0. ')' + num[1]) 否则num[1] = 0 返回num ｝ //像这样调用这个函数 let num = splitNum(3.2) console.log('整数部分是${num[0]} ') console.log('小数部分为${num[1]} ') //或者你可以这样调用它 let [int, deci] = splitNum(3.2) console.log(' int部分是' + int) console.log('小数部分是' + deci)

例如，两个数字相加

function add(number1, number2) {
let decimal1 = String(number1).substring(String(number1).indexOf(".") + 1).length;
let decimal2 = String(number2).substring(String(number2).indexOf(".") + 1).length;

let z = Math.max(decimal1, decimal2);
return (number1 * Math.pow(10, z) + number2 * Math.pow(10, z)) / Math.pow(10, z);
}