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

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) {...}

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

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.

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

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

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

Simple mais efficace!

Math.floor(number) === number;

// 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.

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

var re=/^-?[0-9]+$/;
var num=10;
re.test(num);

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.

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

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

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
}

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

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
}

function isDecimal(num) {
  return (num !== parseInt(num, 10));
}

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

function isWholeNumber(num) {
  return num === Math.round(num);
}

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.

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

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

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.