var decimal = n - Math.floor(n)

Bien que cela ne fonctionnera pas pour les nombres moins donc nous pourrions avoir à faire

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

Vous pouvez convertir en chaîne, non?

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

En quoi 0.2999999999999998 est-il une réponse acceptable? Si j'étais le demandeur, je voudrais une réponse de .3. Ce que nous avons ici est une fausse précision, et mes expériences avec floor,%, etc indiquent que Javascript aime la fausse précision pour ces opérations. Donc, je pense que les réponses qui utilisent la conversion en chaîne sont sur la bonne voie.

Je ferais ceci:

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

Plus précisément, j'utilisais 100233.1 et je voulais la réponse".1".

Une façon simple de le faire est:

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

Malheureusement, cela ne renvoie pas la valeur exacte. Cependant, cela est facilement corrigé:

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

, Vous pouvez l'utiliser si vous ne savez pas le nombre de décimales:

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

Voici comment je le fais, ce qui, je pense, est le moyen le plus simple de le faire:

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

Ce qui suit fonctionne indépendamment des paramètres régionaux pour le séparateur décimal... à la condition qu'un seul caractère soit utilisé pour un séparateur.

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

Ce n'est pas joli, mais c'est exact.

Vous pouvez le convertir en une chaîne et utiliser la méthode replace pour remplacer la partie entière par zéro, puis convertir le résultat en un nombre:

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

En fonction de l'utilisation que vous donnerez par la suite, mais cette solution simple pourrait également vous aider.

Je ne dis pas que c'est une bonne solution, mais pour certains cas concrets fonctionne

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

Mais cela prendra plus de temps que la solution proposée par @ Brian M. Hunt

(2.3 % 1).toFixed(4)

Manière indépendante de la langue:

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

Notez qu'il corrige uniquement pour les nombres avec une longueur fractioanale)

Si la précision est importante et que vous avez besoin de résultats cohérents, voici quelques propositions qui retourneront la partie décimale de n'importe quel nombre sous forme de chaîne, y compris le PREMIER "0.". Si vous en avez besoin en tant que flottant, ajoutez simplement var f = parseFloat( result ) à la fin.

Si la partie décimale est égale à zéro, "0.0" sera retourné. Les nombres Null, NaN et undefined ne sont pas testés.

1. Tableau.split

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

2. Chaîne.sous-chaîne, Chaîne.indexOf

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

3. Mathématique.étage, Nombre.toFixed, Chaîne.indexOf

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

4. Mathématique.étage, Nombre.toFixed, chaîne.split

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

Voici un lien jsPerf: https://jsperf.com/decpart-of-number/

Nous pouvons voir que la proposition #2 est la plus rapide.

Vous pouvez utiliser parseInt() function pour obtenir la partie entière de l'utiliser pour extraire la partie décimale

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

J'ai eu un cas où je savais que tous les nombres en question n'auraient qu'une décimale et je voulais obtenir la partie décimale comme un entier, donc j'ai fini par utiliser ce genre d'approche:

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

Cela fonctionne bien aussi avec des entiers, renvoyant 0 dans ces cas.

J'utilise:

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

Entrée: -556.123444444

Résultat: 123444444

Après avoir regardé plusieurs d'entre eux, j'utilise maintenant...

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

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