Überprüfen Sie, ob eine Zahl eine Dezimalstelle hat / eine ganze Zahl ist

Ich suche nach einer einfachen Möglichkeit in JavaScript zu überprüfen, ob eine Zahl eine Dezimalstelle enthält (um festzustellen, ob es sich um eine Ganzzahl handelt). Zum Beispiel,

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

if(number is integer) {...}

Die Verwendung des Moduls funktioniert:

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

Beachten Sie, dass dies unabhängig vom Format auf dem numerischen Wert der Zahl basiert . Es behandelt numerische Zeichenfolgen, die ganze Zahlen mit einem festen Dezimalpunkt enthalten, wie Ganzzahlen:

'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 () ist Teil des ES6-Standards und wird in IE11 nicht unterstützt.

Es gibt false zurück , für NaN, Infinityund nicht-numerische Argumente während x % 1 != 0gibt true zurück.

Oder Sie können dies einfach verwenden, um herauszufinden, ob es sich NICHT um eine Dezimalstelle handelt:

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

Die gebräuchlichste Lösung besteht darin, den ganzzahligen Teil der Zahl zu entfernen und ihn wie folgt mit Null zu vergleichen:

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

Einfach aber effektiv!

Math.floor(number) === number;

// Wie wäre es damit, es zu byten?

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

Ich fühle mich immer schlecht für Bitoperatoren in Javascript-

Sie bekommen kaum Bewegung.

number = 20.5

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

alert("Integer")

} else {

alert("Decimal")

}

Ziemlich cool und funktioniert auch für Dinge wie XX.0! Es funktioniert, weil Math.floor () jede Dezimalstelle abschneidet, wenn es eine hat. Wenn sich also der Boden von der ursprünglichen Zahl unterscheidet, wissen wir, dass es sich um eine Dezimalzahl handelt! Und keine String-Konvertierungen :)

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

Number.isInteger()ist wahrscheinlich die prägnanteste. Es gibt true zurück, wenn es sich um eine Ganzzahl handelt, und false, wenn dies nicht der Fall ist.

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

Wenn eine Nummer übergeben wird, wird parseInt()die Nummer einfach als int zurückgegeben:

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

Konvertieren Sie die Zeichenfolge in ein Array, geteilt durch den Dezimalpunkt. Wenn das Array nur einen Wert hat, bedeutet dies, dass die Zeichenfolge keine Dezimalstelle enthält.

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

Auf diese Weise können Sie auch die Ganzzahl und die Dezimalzahl ermitteln. Ein fortgeschritteneres Beispiel wäre.

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

if(!dece){
    //do stuff
}

Hier ist ein Auszug aus meiner Wachbibliothek (inspiriert von Effective JavaScript von 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

Sie können es mit 10 multiplizieren und dann eine " Modulo " -Operation / Division mit 10 durchführen und prüfen, ob das Ergebnis dieser beiden Operationen Null ist. Das Ergebnis dieser beiden Operationen gibt Ihnen die erste Ziffer nach dem Dezimalpunkt. Wenn das Ergebnis gleich Null ist, ist die Zahl eine ganze Zahl.

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

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

Sie können die bitweisen Operationen verwenden, die den Wert ( ^ 0oder ~~) nicht ändern , um den Dezimalteil zu verwerfen, der zum Runden verwendet werden kann. Nach dem Runden der Zahl wird sie mit dem ursprünglichen Wert verglichen:

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

Mit der folgenden Funktion können Sie überprüfen, ob eine Zahl Dezimalstellen hat:

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

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

Anscheinend wollen einige Benutzer Erklärungen. Ich werde es in Stücke zerbrechen: (num% 1)

Klammern bedeuten, dass diese Operationen zuerst ausgeführt werden. num - eine von der Funktion übergebene Variable. % - ein Modul-Symbol, das versucht, die linke Zahl durch die rechte zu teilen. Wenn es einen Rest gibt, wird dieser als Dezimalzahl zurückgegeben. Wenn es sich gleichmäßig teilt, gibt es 0 zurück.

Fassen Sie also zusammen, was wir bisher haben. (Num% 1) wird zurückkehren:

0 bei gleichmäßiger Aufteilung ODER #. ##### wenn nicht

0 == false.

[ANY_NUMBER_NOT_ZERO] == true.

Beispiele: new Boolean (0) ist false new boolean (12312.1231) ist true

Andere Alternativen: Ein Benutzer hätte versuchen können, den Wert von (num% 1) zurückzugeben, wodurch im Grunde dasselbe erreicht würde. Da return (0) falsch ist und return (1.213113) wahr ist.

Aber ich wollte einen booleschen Wert zurückgeben. Als Verknüpfung zum Erzwingen eines Werts in einen Booleschen Wert habe ich ein! Symbol davor.

So viele wie wissen.! bedeutet NICHT. Es erzwingt aber auch einen Wert in einen Booleschen Wert.

Seit der ! symobol erzwingt den Wert in einen Booleschen Wert und kehrt seinen Wert um. Ich benutze !! um den Wert in einen Booleschen Wert zu zwingen und seinen Wert wieder in seinen ursprünglichen Booleschen Wert umzukehren.

Funktion für Schecknummer ist Dezimalzahl oder ganze Zahl

function IsDecimalExist(p_decimalNumber) {
    var l_boolIsExist = true;

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

    return l_boolIsExist;
}

Vielleicht funktioniert das bei Ihnen?

Es verwendet Regex, um zu überprüfen, ob die Zahl ein Komma enthält. Wenn dies nicht der Fall ist, werden Komma und Streifen hinzugefügt.

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

Verwenden Sie Folgendes, wenn der Wert Zeichenfolge ist (z. B. von <input):

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

Ich füge .toString()dem Boden hinzu, damit es auch in Fällen funktioniert, in denen value == "1."(mit einem Dezimaltrennzeichen oder einer anderen Zeichenfolge endet). Gibt auch Math.floorimmer einen Wert zurück, .toString()schlägt also nie fehl.