web-dev-qa-db-fra.com

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

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

23 -> OK
5 -> OK
3.5 -> not OK
34.345 -> not OK

if(number is integer) {...}
javascriptvalidationnumbersinteger
218
Hans

Utiliser module fonctionnera:

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

Notez que ceci est basé sur la valeur numérique valeur du nombre, quel que soit son format. Il traite les chaînes numériques contenant des nombres entiers avec une virgule décimale fixe identiques aux entiers:

'10.0' % 1; // returns 0
10 % 1; // returns 0
'10.5' % 1; // returns 0.5
10.5 % 1; // returns 0.5
662
Andy E

Ou vous pouvez simplement utiliser pour savoir si ce n'est PAS une décimale:

string.indexOf(".")==-1;
36
Ike
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 par IE11.

Il renvoie false pour les arguments NaN, Infinity et non numériques, tandis que x % 1 != 0 renvoie true.

26
le_m

La solution la plus courante consiste à effacer 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 )
}
20
Thomas

// Que dirais-tu de l'octer?

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

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

ils ne font presque pas d'exercice.

19
kennebec

Simple mais efficace!

Math.floor(number) == number;
16
dYale
var re=/^-?[0-9]+$/;
var num=10;
re.test(num);
4
ghostdog74
number = 20.5

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

alert("Integer")

} else {

alert("Decimal")

}

C'est plutôt cool et ça marche aussi avec des choses comme XX.0! Et pas de conversions de chaînes :)

4
CUZLOCKED

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

3
Christopher Connery
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;
}
2
Vitor Lins

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

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

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

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

La parenthèse signifie effectuer ces opérations en premier. num - une variable transmise par la fonction. % - un symbole de module qui tente de diviser le nombre de gauche par le droit. S'il y a un reste, il le retourne sous forme décimale. Si elle se divise de manière égale, elle retourne 0.

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

0 lorsqu'il est divisé uniformément OR #. ##### sinon

0 == faux. 

[ANY_NUMBER_NOT_ZERO] == true.

Exemples: new booléen (0) est false new booléen (12312.1231) est true

Autres alternatives: un utilisateur aurait pu essayer de renvoyer la valeur de (num% 1)., Ce qui permettrait essentiellement d'obtenir la même chose. 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 dans un booléen, j'ai ajouté un! symbole devant elle.

Autant que vous le savez peut-être. signifie NON. Mais cela force aussi une valeur dans un booléen. 

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

1
twalow

Voici un extrait de ma bibliothèque de garde (inspiré par Effective JavaScript de 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
schirrmacher
parseInt(num) === num

lorsque 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
1
Michael

Vous pouvez le multiplier par 10 puis faire une opération " modulo "/divison 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
BSevo
function isDecimal(num) {
  return (num !== parseInt(num, 10));
}
0
Steve Brush
function isWholeNumber(num) {
  return num === Math.round(num);
}
0
Dmitry Shashurov

Vous pouvez utiliser les opérations au niveau des bits qui ne modifient pas la valeur (^ 0 ou ~~) pour ignorer la partie décimale, qui peut être utilisée pour arrondir. 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
0
makovkastar

La fonction pour le numéro de contrôle est un 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
user3897934

Soyez prudent Number.isInteger(1000000000000000.01)

Retourne true

0
Gaëtan Mallet

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

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

De cette façon, vous pouvez également savoir quels sont les nombres entier et décimal. un exemple plus avancé serait.

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

if(!dece){
    //do stuff
}
0
Kareem

Peut-être que cela fonctionne pour vous?

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