Obtenir partie décimale d'un nombre avec JavaScript

J'ai les nombres réels comme 3.2 et 1.6.

J'ai besoin de séparer le nombre, dans l'entier et la partie décimale. Par exemple, une valeur de 3.2 serait scindé en deux numéros, c'est à dire 3 et 0.2

Obtenir la partie entière est facile:

n = Math.floor(n);

Mais je vais avoir du mal à obtenir la partie décimale.
J'ai essayé ceci:

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

Mais il ne fonctionne pas toujours correctement.

Le code précédent a la sortie suivante:

n = 3.1 => remainer = 1.1

Ce que je suis en manque ici?

Notez que n = Math.floor(n); est seulement le retour de votre résultat souhaité (la partie entière) pour les nombres négatifs
Simplfy utilisation % 1 pas % 2

InformationsquelleAutor Oscar | 2010-12-22

310

Utilisation 1, pas 2.
```
js> 2.3 % 1
0.2999999999999998
```
- Dans un monde où 0.2999999999999998 est égale à 0,3 cela peut être acceptable. Pour moi, il n'est pas... Donc, pour résoudre ce problème j'aimerais éviter de l'utiliser Math.* ou % opérations.
- Pour éviter la virgule flottante problèmes d'arrondi noté, en utilisant toFixed peut aider dans certaines situations, par exemple (2.3 % 1).toFixed(4) == "0.3000".
- (2.3 % 1).toFixed(4).substring(2) = "3000" si vous en avez besoin sans la 0.
- Dans un monde où le nombre 2.3 a surgi, et pas 2 ou 3, le nombre 0.2999999999999998 est parfaitement acceptable, malgré la façon dont insultant, il semble aux yeux des humains.
InformationsquelleAutor Ignacio Vazquez-Abrams
81
```
var decimal = n - Math.floor(n)
```
Bien que cela ne fonctionne pas pour moins de numéros, de sorte que nous pourrions avoir à faire
```
n = Math.abs(n); //Change to positive
var decimal = n - Math.floor(n)
```
- Si vous disposez déjà de la partie entière, il n'y a pas besoin d'appeler Math.floor() nouveau -- d'utiliser seulement la partie entière que vous avez calculé.
- var n = 3.2, integr = Math.floor(n), decimal = n - integr; utiliser Math.floor() juste une fois. integr = 3; decimal = 0.20000000000000018;
- Afin de travailler avec un nombre négatif, il suffit de remplacer Math.floor avec Math.trunc.
InformationsquelleAutor greenimpala
67

Vous pouvez convertir en string, non?
```
n = (n + "").split(".");
```
- Cela fonctionne bien partout, sauf en Europe continentale où une virgule est le séparateur décimal. Si vous prévoyez sur l'utilisation de cela, n'oubliez pas de le prendre en compte si vous êtes en multi-nationale et de la cible l'europe, que cette solution ne vais pas faire un bon travail pour eux.
- Je suis de l'Europe continentale avec un français Firefox et ça fonctionne. Normalement, nous devrions utiliser la virgule comme séparateur décimal en France. La raison étant qu'en JavaScript il n'y a pas de culture impliqués lors de la conversion d'un Nombre en chaîne, même si je préfère utiliser n.toString() au lieu de n + "" parce que c'est plus lisible.
- Si la vitesse est critique alors n + "" est en effet mieux (voir la section jsperf.com/number-vs-number-tostring-vs-string-number)
- JS utilise . comme séparateur décimal, donc vous êtes bien partout si votre variable d'entrée est de type float. Vous avez seulement à cette question si votre entrée est une chaîne. J'ai aussi de noter que cette réponse renvoie une chaîne dans un tableau. Une solution plus complète est parseFloat('0.' + (n + '').split('.')[1])
InformationsquelleAutor sdleihssirhc
29

Comment est 0.2999999999999998 une réponse acceptable? Si je le sens je voudrais une réponse de .3. Ce que nous avons ici est faux de précision, et de mes expériences avec le plancher, %, etc indiquent que Javascript est amoureux de la fausse précision pour ces opérations. Donc, je pense que les réponses qui sont à l'aide de la conversion en chaîne sont sur la bonne voie.

Je voudrais faire cela:
```
var decPart = (n+"").split(".")[1];
```
Plus précisément, j'ai été en utilisant 100233.1 et je voulais la réponse ".1".
- Je suis généralement d'accord, mais vous ne pouvez pas compter sur les". " la regex que le séparateur décimal est un i18n caractère.
- Je me rends compte que je tiens à souligner l'évidence: ma "réponse" est juste une très légère reprise de sdleihssirhc réponse
- En fait, certains pourraient vouloir le non arrondi de la valeur. Je ne me souviens pas l'OP de poser pour une valeur arrondie, juste diviser les valeurs.
- oui, certains pourraient vouloir le non arrondi de la valeur. Mais juste parce que vous pouvez de précision à 9 décimales ne signifie pas que votre entrée de données prend en charge. C'est pourquoi il est appelé "fausse précision". Si votre entrée est de 3,1, plus la précision de votre réponse peut avoir de dixièmes, c'est à dire, .1. Si vous répondez .09 il implique que vous avez effectivement calculées et mesurées vers le bas pour 100e de précision, alors qu'en fait l'entrée d'origine a été fidèle à la 10ème précision.
- qui peuvent être facilement manipulés: var decPart = (n.toLocaleString("fr")).split(".")[1];
- Je me sens comme si votre réponse est le meilleur jusqu'à présent, mais encore incomplète. De toute façon, beaucoup mieux que la accepté de répondre. Le résultat doit sûrement être un nombre, AKA un flotteur dans ce cas? Donc, peut-être juste l'emballer dans un parseFloat: var decPart = parseFloat( (n+"").split(".")[1] );
InformationsquelleAutor jomofrodo

Une façon simple de le faire est:

JS:

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

Malheureusement, qui ne retourne pas la valeur exacte. Cependant, qui est facilement résolu:

JS:

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:

JS:

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

InformationsquelleAutor Ethan

Voici comment je le fais, je pense que c'est la façon la 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

InformationsquelleAutor Zantafio

5

Les ouvrages suivants, quel que soit les paramètres régionaux pour le séparateur décimal... à la condition qu'un seul caractère est utilisé pour le 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.
- C'est bien sûr une chaîne, de sorte que vous mayneed à parseInt() tout d'abord si vous voulez comme un nombre. Vous ne devriez pas avoir à parseFloat()... à moins qu'il y a quelque chose qui me manque ici avec la base de 8 pas de base de 10 numéros de... quelque chose que je me souviens vaguement d'années
InformationsquelleAutor cdmdotnet
5

Si la précision des questions et vous avez besoin des résultats cohérents, voici quelques propositions qui sera de retour la partie décimale d'un nombre sous forme de chaîne, y compris le "0.". Si vous en avez besoin comme un float, il suffit d'ajouter var f = parseFloat( result ) à la fin.

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

1. Chaîne de caractères.split
```
var nstring = (n + ""),
    narray  = nstring.split("."),
    result  = "0." + ( narray.length > 1 ? narray[1] : "0" );
```
2. Chaîne de caractères.sous-chaîne, Chaîne.indexOf
```
var nstring = (n + ""),
    nindex  = nstring.indexOf("."),
    result  = "0." + (nindex > -1 ? nstring.substring(nindex + 1) : "0");
```
3. Les mathématiques.é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. Les mathématiques.é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");
```
Ici est un jsPerf lien: https://jsperf.com/decpart-of-number/

Nous pouvons voir que la proposition n ° 2 est la plus rapide.
- ne pas utiliser l'un de ces. qu'ils se cassent dès que le nombre de rendu des commutateurs à l'ingénierie. ils ne sont pas sensibles aux paramètres régionaux.
- Pourriez-vous expliquer "nombre de rendu des commutateurs de génie"? Aussi, la localisation n'est pas pertinent parce que nous voulons juste la partie décimale d'un nombre, pas une chaîne localisée représentant un nombre.
InformationsquelleAutor Gabriel Hautclocq
4

Vous pouvez convertir en une chaîne et d'utiliser le replace méthode pour remplacer la partie entière par zéro, puis de convertir le résultat en nombre :
```
var number = 123.123812,
    decimals = +number.toString().replace(/^[^\.]+/,'0');
```
- Cette solution fonctionne pas en europe continentale, où la virgule est le séparateur décimal??
- Vous pouvez remplacer le point dans la regex avec tout autre caractère séparateur que vous aimez (comme /^[^,]/), mais ensuite, vous devez laisser le résultat sous forme de chaîne (suppression de la + opérateur) afin d'éviter NaN résultats.
InformationsquelleAutor gion_13
4

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

Im ne dis pas c'est une bonne solution, mais pour quelques cas concrets de travaux
```
var a = 10.2
var c = a.toString().split(".")
console.log(c[1] == 2) //True
console.log(c[1] === 2)  //False
```
Mais il faudra plus que la solution proposée par @Brian M. Hunt
```
(2.3 % 1).toFixed(4)
```
- Cela fonctionne bien partout, sauf en Europe continentale où une virgule est le séparateur décimal. Si vous prévoyez sur l'utilisation de cela, n'oubliez pas de le prendre en compte si vous êtes en multi-nationale et de la cible l'europe, que cette solution ne vais pas faire un bon travail pour eux.
InformationsquelleAutor David Sánchez
4

Langue de manière indépendante:
```
var a = 3.2;
var fract = a * 10 % 10 /10; //0.2
var integr = a - fract; //3
```
noter qu'il ne corriger que pour les nombres avec un fractioanal longueur )
- Pouvez-vous expliquer pourquoi vous pensez que ce est indépendante de la langue? Il est en JavaScript.
- il n'y a pas de langage spécifique de la fonction
- Elle est indépendante de la langue en raison de ceci 😉
InformationsquelleAutor Nurlan
2

Vous pouvez utiliser parseInt() fonction 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;
```
InformationsquelleAutor Sheki
1

J'ai eu un cas où je savais que tous les chiffres en question aurait qu'une seule décimale, et a voulu obtenir de la partie décimale comme un entier, donc j'ai fini par utiliser ce type d'approche:
```
var number = 3.1,
    decimalAsInt = Math.round((number - parseInt(number)) * 10); //returns 1
```
Cela fonctionne très bien aussi avec des entiers, retourne 0 dans ces cas.

InformationsquelleAutor walpek

Je suis en utilisant:

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

D'entrée: -556.123444444

Résultat: 123444444

InformationsquelleAutor DavidDunham

0

Après avoir regardé plusieurs de ceux-ci, je suis maintenant en utilisant...
```
var rtnValue = Number(7.23);
var tempDec = ((rtnValue / 1) - Math.floor(rtnValue)).toFixed(2);
```
InformationsquelleAutor Patrick
0
```
n = Math.floor(x);
remainder = x % 1;
```
InformationsquelleAutor masterxilo
0

Fonctions mathématiques sont plus rapides, mais il revient toujours pas natif valeurs attendues.
Façon la plus simple que j'ai trouvé est
```
(3.2+'').replace(/^[-\d]+\./, '')
```
InformationsquelleAutor Vasilii Suricov

Bien que je suis très en retard pour répondre à cette question, veuillez consulter le code.

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)

InformationsquelleAutor Hifzur Rahman

-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
```
- qui ne ressemble pas à du javascript pour moi!
- -1. Pas de javascript voici, d'ailleurs, c = 0
- Ce n'est pas java script
- En JS il devrait ressembler à: var a = 3.2; var b = parseInt(a, 10); var c = a - b;
InformationsquelleAutor user2381223

Vous devez vous connecter pour publier un commentaire.

1. Chaîne de caractères.split

2. Chaîne de caractères.sous-chaîne, Chaîne.indexOf

3. Les mathématiques.étage, Nombre.toFixed, Chaîne.indexOf

4. Les mathématiques.étage, Nombre.toFixed, Chaîne.split