Réponses:
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
20.0
a 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 ;-)
"10."
est un nombre entier et le résultat sera exactement le même que "10"
ou 10
.
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
, Infinity
et les arguments non numériques tout en x % 1 != 0
renvoie true.
Number.isInteger(12.0)
retourne true
.
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
.
number
est entier ou non. Si votre entrée est une chaîne, vous devez la convertir en une number
première, par exemple via parseFloat()
, bien sûr.
Ou vous pouvez simplement utiliser ceci pour savoir s'il ne s'agit PAS d'une décimale:
string.indexOf(".") == -1;
yournumber.toString.indexOf(".")
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 )
}
startVal != Math.floor(startVal)
?
Math.Floor
fonction prend une valeur décimale et la plus grande valeur décimale autorisée en JavaScript est 2^53 - 1
ou 9007199254740991
. Étant donné qu'il 893144042145698745.3
est supérieur à ce maximum, la fonction échouera.
Simple mais efficace!
Math.floor(number) === number;
Math.floor(3.0) == 3.0
est vrai, Math.floor(3.3) == 3.3
est faux
// 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.
>>
convertit la valeur en un entier 32 bits signé .
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);
num= 999999999999999999999
.
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
parseInt(3.0) === 3.0 // 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 ( ^ 0
ou ~~
) 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.floor
Retourne également toujours une valeur afin de .toString()
ne jamais échouer.