Vérifiez si un nombre a une décimale / est un nombre entier


284

Je cherche un moyen facile en JavaScript pour vérifier si un nombre a une décimale (afin de déterminer s'il s'agit d'un entier). Par exemple,

23 -> OK
5 -> OK
3.5 -> not OK
34.345 -> not OK
if(number is integer) {...}

Réponses:


822

L'utilisation du module fonctionnera:

num % 1 != 0
// 23 % 1 = 0
// 23.5 % 1 = 0.5

Notez que cela est basé sur la valeur numérique du nombre, quel que soit le format. Il traite les chaînes numériques contenant des nombres entiers avec un point décimal fixe de la même manière que les entiers:

'10.0' % 1; // returns 0
10 % 1; // returns 0
'10.5' % 1; // returns 0.5
10.5 % 1; // returns 0.5

10
Je n'ai pas voté contre mais je dirais que c'est quelque chose à voir avec 20,0, a toujours un point décimal et satisfait à ce qui précède. +1 de toute façon pour m'apprendre quelque chose de nouveau :)
Abe Petrillo

7
@Abe: c'est vrai, même si je pense que c'est peu probable. Il est impossible de dire si 20.0a un point décimal par programme, sauf s'il est exprimé sous forme de chaîne. De plus, aucune des autres solutions n'a obtenu un vote négatif pour ne pas avoir abordé cela ;-)
Andy E

1
@SREEP: voir les commentaires ci-dessus. 0,00 n'est pas 0,00 en JavaScript lorsqu'il est représenté par une valeur numérique. Il peut être représenté sous la forme d'une chaîne ("0,00"), auquel cas la question est "vérifier si une chaîne est un nombre entier" au lieu de "vérifier si un numéro est un nombre entier" .
Andy E

3
@Swanidhi: que voulez-vous dire? Qu'est-ce qui ne sera pas valable? "10."est un nombre entier et le résultat sera exactement le même que "10"ou 10.
Andy E

3
L'OP demande de vérifier si un NUMBER est un nombre entier. Il ne mentionne nulle part les cordes - à cet égard, la réponse d'Andy est juste.
Om Shankar

58
Number.isInteger(23);  // true
Number.isInteger(1.5); // false
Number.isInteger("x"); // false: 

Number.isInteger () fait partie de la norme ES6 et n'est pas pris en charge dans IE11.

Il retourne faux pour NaN, Infinityet les arguments non numériques tout en x % 1 != 0renvoie true.


2
solution échoue pour 12.0
Vikas Arora

@VikasArora Non, cela fonctionne comme prévu. Number.isInteger(12.0)retourne true.
le_m

Cela semble que ce devrait être la bonne réponse, mais malheureusement, il ne fonctionne pas pour la notation scientifique, par exemple , Number.isInteger('1e3')est false, même si Number.isInteger(1e3)est vrai. En supposant que l'intention de la question est de trouver des valeurs non entières (plutôt que la présence réelle d'un point décimal dans la représentation), la valeur de chaîne '12 .0 ' devrait passer car elle représente un entier, mais là encore, elle l' Number.isInteger('12.0')est false.
brianmearns

La question de @brianmearns OP est de savoir si a numberest entier ou non. Si votre entrée est une chaîne, vous devez la convertir en une numberpremière, par exemple via parseFloat(), bien sûr.
le_m

47

Ou vous pouvez simplement utiliser ceci pour savoir s'il ne s'agit PAS d'une décimale:

string.indexOf(".") == -1;

2
Je pense que celui-ci est la solution réelle car cela fonctionne même pour XX.0
Deepankar Sarkar

5
convertir en chaîne avant de continuer .. ie: yournumber.toString.indexOf(".")
Daniel Omine

1
francisco_ssb .. le symbole du point est universel ... représente la décimale dans le langage mathématique .. ceci est universel et devrait fonctionner dans n'importe quel pays. Si vous parlez de virgules (","), vous devez vous convertir au point (".") Avant l'indexOf ("."), Évidemment ..
Daniel Omine

1
Je pense que lorsqu'il voulait dire que cela ne fonctionne pas dans certains pays, il fait référence à la monnaie, car l'euro utilise une virgule au lieu d'un point décimal. Cependant, la question n'est pas spécifique à la monnaie, juste des décimales ... comme dans une fraction d'un nombre.
Tessa

1
Cela ne fonctionne pas si la décimale est de 1,00 et que vous voulez que ce soit un entier à moins que vous ne contraigniez la valeur
simon-pr

21

La solution la plus courante consiste à supprimer la partie entière du nombre et à la comparer à zéro comme suit:

function Test()
{
     var startVal = 123.456
     alert( (startVal - Math.floor(startVal)) != 0 )
}

31
Pourquoi pas juste startVal != Math.floor(startVal)?
Andy E

2
Agréable. Même concept, mais votre version est encore plus propre.
Thomas

1
@Andy E: Ceci n'est possible que pour les nombres positifs. Cela ne fonctionnera pas pour les nombres négatifs ..
Seeya K

3
@SeeyaK: bien sûr, cela fonctionnera pour les nombres négatifs. N'hésitez pas à l'essayer.
Andy E

1
@DeepakGoyal - C'est par conception. La Math.Floorfonction prend une valeur décimale et la plus grande valeur décimale autorisée en JavaScript est 2^53 - 1ou 9007199254740991. Étant donné qu'il 893144042145698745.3est supérieur à ce maximum, la fonction échouera.
Thomas

20

Simple mais efficace!

Math.floor(number) === number;

4
@OmShankar efficient! = Effective
Fiddles

Math.floor(3.0) == 3.0est vrai, Math.floor(3.3) == 3.3est faux
Rohmer

@Fiddles, oh c'est vrai, c'est ce que je voulais dire: pas efficace car c'est beaucoup plus lent dans les performances par rapport à la méthode% mod. Merci d'avoir corrigé
Om Shankar

19

// Qu'en est-il de l'octet?

Number.prototype.isInt= function(){
 return this== this>> 0;
}

Je me sens toujours un peu mal pour les opérateurs de bits en javascript-

ils ne font pratiquement pas d'exercice.


14
Cela échoue pour les entiers supérieurs à 2 ^ 31 - 1, car >>convertit la valeur en un entier 32 bits signé .
Matthew Crumley

1
@kennebec génial - c'est de loin la solution la plus amusante. Et c'est bien mieux qu'un RegEx.
Daniel B. Chapman

5
number = 20.5

if (number == Math.floor(number)) {

alert("Integer")

} else {

alert("Decimal")

}

Assez cool et fonctionne aussi pour des choses comme XX.0! Cela fonctionne parce que Math.floor () coupe toute décimale s'il en a une, donc si le plancher est différent du nombre d'origine, nous savons que c'est une décimale! Et pas de conversions de chaînes :)



4

Number.isInteger()est probablement le plus concis. Il renvoie vrai s'il s'agit d'un entier et faux s'il ne l'est pas.


1
Cela devrait être la réponse acceptée, car il est préférable d'utiliser le module en raison des problèmes de chaîne.
Ini

3
function isDecimal(n){
    if(n == "")
        return false;

    var strCheck = "0123456789";
    var i;

    for(i in n){
        if(strCheck.indexOf(n[i]) == -1)
            return false;
    }
    return true;
}

N'a pas besoin d'explication. C'est assez simple.
Grant Birchmeier

1
Si la chaîne contient l'une des valeurs de strCheck, c'est une décimale ... (il manque. Et, cependant ...
NicoJuicy

2
parseInt(num) === num

une fois passé un nombre, parseInt()renvoie simplement le nombre sous la forme int:

parseInt(3.3) === 3.3 // false because 3 !== 3.3
parseInt(3) === 3     // true

4
J'aime beaucoup celui-ci, mais cela dépend de ses besoins spécifiques. Malheureusement, j'ai besoin d'une fonction pour ÉCHOUER le testparseInt(3.0) === 3.0 // true
zipzit

2

convertir la chaîne numérique en tableau, divisé par un point décimal. Ensuite, si le tableau n'a qu'une seule valeur, cela signifie aucune décimale dans la chaîne.

if(!number.split(".")[1]){
    //do stuff
}

De cette façon, vous pouvez également connaître les nombres entiers et décimaux. un exemple plus avancé serait.

number_to_array = string.split(".");
inte = number_to_array[0];
dece = number_to_array[1]; 

if(!dece){
    //do stuff
}

1

Voici un extrait de ma bibliothèque de garde (inspiré par Effective JavaScript par David Herman):

var guard = {

    guard: function(x) {
        if (!this.test(x)) {
            throw new TypeError("expected " + this);
        }
    }

    // ...
};

// ...

var number = Object.create(guard);
number.test = function(x) {
    return typeof x === "number" || x instanceof Number;
};
number.toString = function() {
    return "number";
};


var uint32 = Object.create(guard);
uint32.test = function(x) {
    return typeof x === "number" && x === (x >>> 0);
};
uint32.toString = function() {
    return "uint32";
};


var decimal = Object.create(guard);
decimal.test = function(x) {
    return number.test(x) && !uint32.test(x);
};
decimal.toString = function() {
    return "decimal";
};


uint32.guard(1234);     // fine
uint32.guard(123.4);    // TypeError: expected uint32

decimal.guard(1234);    // TypeError: expected decimal
decimal.guard(123.4);   // fine

1

Vous pouvez le multiplier par 10 puis faire une opération / division " modulo " avec 10 , et vérifier si le résultat de ces deux opérations est nul. Le résultat de ces deux opérations vous donnera le premier chiffre après le point décimal. Si le résultat est égal à zéro, le nombre est un nombre entier.

if ( (int)(number * 10.0) % 10 == 0 ){
// your code
}


1

Vous pouvez utiliser les opérations au niveau du bit qui ne modifient pas la valeur ( ^ 0ou ~~) pour supprimer la partie décimale, qui peut être utilisée pour l'arrondi. Après avoir arrondi le nombre, il est comparé à la valeur d'origine:

function isDecimal(num) {
  return (num ^ 0) !== num;
}

console.log( isDecimal(1) ); // false
console.log( isDecimal(1.5) ); // true
console.log( isDecimal(-0.5) ); // true


1

Vous pouvez utiliser la fonction suivante pour vérifier si un nombre a des décimales:

function hasDecimal(num){
    return !!(num % 1);
}

console.log(hasDecimal(2)); //false
console.log(hasDecimal(2.32423)); //true

Donc, apparemment, certains utilisateurs veulent des explications. Je vais le décomposer: (num% 1)

Les parenthèses signifient effectuer ces opérations en premier. num - une variable transmise par la fonction. % - un symbole de module qui tente de diviser le nombre gauche par la droite. S'il y a un reste, il le renvoie sous forme décimale. S'il se divise également, il renvoie 0.

Donc, résumez ce que nous avons jusqu'à présent., (Num% 1) renverra:

0 lorsqu'il est divisé également OU #. ##### sinon

0 == faux.

[ANY_NUMBER_NOT_ZERO] == true.

Exemples: nouveau booléen (0) est faux nouveau booléen (12312.1231) est vrai

Autres alternatives: un utilisateur aurait pu essayer de renvoyer la valeur de (num% 1). Puisque return (0) est faux et return (1.213113) est vrai.

Mais je voulais retourner une valeur booléenne. Donc, comme raccourci pour forcer une valeur en booléen, j'ai ajouté un! symbole devant elle.

Autant que vous le savez.,! signifie NON. Mais il force également une valeur à un booléen.

Depuis le! symobol force la valeur dans un booléen et il inverse sa valeur. J'utilise !! pour forcer la valeur en booléen et inverser sa valeur à sa valeur booléenne d'origine.

entrez la description de l'image ici


Bien que ce code puisse répondre à la question, fournir un contexte supplémentaire concernant la manière et / ou la raison pour laquelle il résout le problème améliorerait la valeur à long terme de la réponse.
Nic3500

0

La fonction pour le numéro de chèque est le nombre décimal ou entier

function IsDecimalExist(p_decimalNumber) {
    var l_boolIsExist = true;

    if (p_decimalNumber % 1 == 0)
        l_boolIsExist = false;

    return l_boolIsExist;
}

0

Peut-être que cela fonctionne pour vous?

Il utilise l'expression régulière pour vérifier s'il y a une virgule dans le nombre, et s'il n'y en a pas, il ajoutera la virgule et la bande.

var myNumber = '50';
function addCommaStripe(text){
    if(/,/.test(text) == false){
        return text += ',-';
    } else {
        return text;
    }
}
myNumber = addCommaStripe(myNumber);

Bienvenue dans StackOverflow. Pourriez-vous expliquer ce que fait ce code et pourquoi vous pensez qu'il résoudra le problème.
quinz

@quinz Il utilise regex pour vérifier s'il y a une virgule dans le nombre, et s'il n'y en a pas, il ajoutera la virgule et la bande. Il fait donc ce que la question demande avec la fonctionnalité supplémentaire d'ajouter la mise en forme pour les étiquettes de prix arrondies.
user11608734

0

Utilisez ce qui suit si la valeur est une chaîne (par exemple de <input):

Math.floor(value).toString() !== value

J'ajoute .toString()à floor pour le faire fonctionner également pour les cas où value == "1."(se termine par un séparateur décimal ou une autre chaîne). Math.floorRetourne également toujours une valeur afin de .toString()ne jamais échouer.

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.