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

使用1，而不是2。

js> 2.3 % 1
0.2999999999999998

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

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)

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

函数拆分数（数） { 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”））; [ 空，空 ]

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

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.

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