it-swarm.com.de

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

Ich suche in JavaScript nach einer einfachen Möglichkeit, um 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) {...}
218
Hans

Die Verwendung von modulus funktioniert:

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

Beachten Sie, dass dies auf dem numerischen Wert value der Zahl unabhängig vom Format 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
662
Andy E

Oder Sie können einfach herausfinden, ob es KEINE Dezimalzahl ist:

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

Für NaN, Infinity und nicht numerische Argumente wird false zurückgegeben, während x % 1 != 0 true zurückgibt.

26
le_m

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

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

// Wie wäre es damit zu umgehen?

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

Ich fühle mich immer etwas schlecht für Bitoperatoren in Javascript. 

sie bekommen kaum Übung.

19
kennebec

Einfach aber effektiv!

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

}

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

4
CUZLOCKED

Number.isInteger() ist wahrscheinlich das prägnanteste. Wenn es eine ganze Zahl ist, wird true zurückgegeben, andernfalls false.

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

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

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

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

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

In Klammern bedeutet, diese Operationen zuerst auszuführen. num - eine von der Funktion übergebene Variable. % - Ein Modulsymbol, das versucht, die linke Zahl durch die rechte zu teilen. Wenn es einen Rest gibt, wird es 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 wenn gleichmäßig geteilt OR #. ##### falls nicht

0 == falsch. 

[ANY_NUMBER_NOT_ZERO] == wahr.

Beispiele: new Boolean (0) ist falsch new Boolean (12312.1231) ist wahr

Andere Alternativen: Ein Benutzer könnte versucht haben, den Wert von (Anzahl% 1) zurückzugeben, was im Grunde dasselbe bewirken würde. Da return (0) falsch ist und return (1.213113) wahr ist.

Aber ich wollte einen booleschen Wert zurückgeben. Als Abkürzung, um einen Wert in einen booleschen Wert zu zwingen, habe ich ein! Symbol vor ihm.

So viele wie Sie vielleicht wissen! bedeutet NICHT. Es zwingt aber auch einen Wert in einen Boolean. 

Seit der ! symobol zwingt den Wert in einen Booleschen Wert und er invertiert seinen Wert. Ich benutze !! um den Wert in einen booleschen Wert zu zwingen und seinen Wert auf seinen ursprünglichen booleschen Wert zurückzusetzen.

1
twalow

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
1
schirrmacher
parseInt(num) === num

wenn eine Zahl übergeben wird, gibt parseInt() die Zahl einfach als int zurück:

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

Sie können mit 10 multiplizieren und dann eine Operation " modulo "/divison mit 10 ausfü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
}
1
BSevo
function isDecimal(num) {
  return (num !== parseInt(num, 10));
}
0
Steve Brush
function isWholeNumber(num) {
  return num === Math.round(num);
}
0

Sie können die bitweisen Operationen verwenden, bei denen der Wert (^ 0 oder ~~) nicht geändert wird, um den Dezimalteil zu löschen, der zum Runden verwendet werden kann. Nachdem die Zahl gerundet wurde, 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
0
makovkastar

Die Funktion für die Prüfnummer ist Dezimal oder eine ganze Zahl

function IsDecimalExist(p_decimalNumber) {
    var l_boolIsExist = true;

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

    return l_boolIsExist;
}
0
user3897934

Seien Sie vorsichtig Number.isInteger(1000000000000000.01)

Gibt true zurück

0
Gaëtan Mallet

zahlstring in Array umwandeln, nach Dezimalpunkt aufteilen. Wenn das Array nur einen Wert hat, bedeutet dies keine Dezimalzahl in Zeichenfolge.

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

Auf diese Weise können Sie auch wissen, was die Ganzzahl und die Dezimalzahl tatsächlich sind. Ein fortgeschritteneres Beispiel wäre.

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

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

Vielleicht funktioniert das bei Ihnen?

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