小开

最佳答案

使用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 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 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.indexOf

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

3.数学。地板上,号码。toFixed, String.indexOf

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

4. 数学。地板上,号码。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()用于保证输入校正
Math.abs()用于避免负数问题
n = parseInt(x)用于获取小数部分
x - n用于减去小数部分
我们现在有一个小数部分为零的数字，但JavaScript可以提供额外的浮动部分数字，这是我们不希望看到的
因此，通过使用原始浮点数x的浮动部分的数字计数调用toFixed()来限制额外的数字。Count被计算为原始数字x和数字n在它们的字符串表示中的长度之差。

小开

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

// 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格式:

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

小开

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

function splitNumber(num)
{
num = (""+num).match(/^(-?[0-9]+)([,.][0-9]+)?/)||[];
return [ ~~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:

function splitNumber(num)
{
num = (""+num).match(/^(-?[0-9]+)([,.][0-9]+)?/);
return [ 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,  null ]
console.log(splitNumber(-2.7));    // [ -2,   0.7 ]
console.log(splitNumber("test"));  // [ null, null ]

小开

我喜欢这个答案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()函数来帮助，例如:

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

小开

您还可以截断该数字

function decimals(val) {
const valStr = val.toString();
const valTruncLength = String(Math.trunc(val)).length;


const dec =
valStr.length != valTruncLength
? valStr.substring(valTruncLength + 1)
: "";


return dec;
}


console.log("decimals: ", decimals(123.654321));
console.log("no decimals: ", decimals(123));

小开

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

function splitNum(num) {
num = num.toString().split('.')
num[0] = Number(num[0])
if (num[1]) num[1] = Number('0.' + num[1])
else num[1] = 0
return num
}
//call this function like this
let num = splitNum(3.2)
console.log(`Integer part is ${num[0]}`)
console.log(`Decimal part is ${num[1]}`)
//or you can call it like this
let [int, deci] = splitNum(3.2)
console.log('Intiger part is ' + int)
console.log('Decimal part is ' + 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);
}