Nehmen wir an, ich habe einer Variablen den Wert 10 zugewiesen;

var values = 10;

und ich möchte eine bestimmte Funktion ausführen, wenn der Wert positiv ist

if(values = +integer){ 
    //do something with positive 
} else { 
    //do something with negative values 
}

Wie würde dies erreicht werden?

if (values > 0) {
    // Do Something
}

Bin ich der einzige, der dies gelesen und festgestellt hat, dass keine der Antworten den “ganzzahligen” Teil der Frage angesprochen hat?

Das Problem

var myInteger = 6;
var myFloat = 6.2;
if( myInteger > 0 )
    // Cool, we correctly identified this as a positive integer
if( myFloat > 0 )
    // Oh, no! That's not an integer!

Die Lösung

Um sicherzustellen, dass Sie es mit einer Ganzzahl zu tun haben, möchten Sie Ihren Wert in eine Ganzzahl umwandeln und ihn dann mit sich selbst vergleichen.

if( parseInt( myInteger ) == myInteger && myInteger > 0 )
    // myInteger is an integer AND it's positive
if( parseInt( myFloat ) == myFloat && myFloat > 0 )
    // myFloat is NOT an integer, so parseInt(myFloat) != myFloat

Einige nette Optimierungen

Als Prämie Es gibt einige Abkürzungen zum Konvertieren von einem Float in eine Ganzzahl in JavaScript. In JavaScript sind alle bitweisen Operatoren (|, ^, &, usw.) wird Ihre Zahl vor dem Ausführen in eine ganze Zahl umwandeln. Ich nehme an, das liegt daran, dass 99% der Entwickler den IEEE-Gleitkommastandard nicht kennen und schrecklich verwirrt wären, wenn “200 | 2” auf 400 (ish) ausgewertet würde. Diese Abkürzungen neigen dazu schneller laufen als Math.floor oder parseIntund sie nehmen weniger Bytes in Anspruch, wenn Sie versuchen, den kleinstmöglichen Code herauszuholen:

if( myInteger | 0 == myInteger && myInteger > 0 )
    // Woot!
if( myFloat | 0 == myFloat && myFloat > 0 )
    // Woot, again!

Aber warte, es gibt noch mehr!

Diese bitweisen Operatoren arbeiten mit 32-Bit-Ganzzahlen mit Vorzeichen. Das höchste Bit ist also das Vorzeichenbit. Indem Sie das Vorzeichenbit auf Null setzen, bleibt Ihre Zahl unverändert nur wenn es positiv war. Sie können dies verwenden, um in einem einzigen Schlag auf Positivität UND Ganzzahligkeit zu prüfen:

// Where 2147483647 = 01111111111111111111111111111111 in binary
if( (myInteger & 2147483647) == myInteger )
    // myInteger is BOTH positive and an integer
if( (myFloat & 2147483647) == myFloat )
    // Won't happen
* note bit AND operation is wrapped with parenthesis to make it work in chrome (console)

Wenn Sie sich diese verschlungene Zahl nicht merken können, können Sie sie auch vorher so berechnen:

var specialNumber = ~(1 << 31);

Überprüfung auf Negative

Laut dem Kommentar von @Reinsbrain kann ein ähnlicher bitweiser Hack verwendet werden, um nach a zu suchen Negativ ganze Zahl. In einer negativen Zahl, wir tun möchten, dass das Bit ganz links eine 1 ist. Wenn Sie also dieses Bit auf 1 setzen, bleibt die Zahl nur dann unverändert, wenn sie von Anfang an negativ war:

// Where -2147483648 = 10000000000000000000000000000000 in binary
if( (myInteger | -2147483648) == myInteger )
    // myInteger is BOTH negative and an integer
if( (myFloat | -2147483648) == myFloat )
    // Won't happen

Diese spezielle Zahl ist noch einfacher zu berechnen:

var specialNumber = 1 << 31;

Edge-Fälle

Da, wie bereits erwähnt, bitweise JavaScript-Operatoren in 32-Bit-Ganzzahlen konvertiert werden, schlagen Zahlen fehl, die nicht in 32 Bit passen (größer als ~2 Milliarden).

Für diese können Sie auf die längere Lösung zurückgreifen:

if( parseInt(123456789000) == 123456789000 && 123456789000 > 0 )

Aber auch diese Lösung scheitert irgendwann, denn parseInt ist in seiner Genauigkeit für große Zahlen begrenzt. Versuchen Sie Folgendes und sehen Sie, was passiert:

parseInt(123123123123123123123); // That's 7 "123"s

Auf meinem Computer in der Chrome-Konsole wird Folgendes ausgegeben: 123123123123123130000

Der Grund dafür ist, dass parseInt die Eingabe wie ein 64-Bit-IEEE-Float behandelt. Dies stellt nur 52 Bit für die Mantisse bereit, was einen Maximalwert von ~4,5e15 bedeutet, bevor es mit dem Runden beginnt

Um es nur zu überprüfen, scheint dies der schnellste Weg zu sein:

var sign = number > 0 ? 1 : number == 0 ? 0 : -1; 
//Is "number": greater than zero? Yes? Return 1 to "sign".
//Otherwise, does "number" equal zero?  Yes?  Return 0 to "sign".  
//Otherwise, return -1 to "sign".

Es sagt dir wenn das Vorzeichen positiv ist (gibt 1 zurück)oder gleich Null (gibt 0 zurück)und andernfalls (gibt -1 zurück). Dies ist eine gute Lösung, da 0 nicht positiv und nicht negativ ist, aber es kann Ihre Variable sein.

Misslungener Versuch:

var sign = number > 0 ? 1 : -1;

…zählt 0 als negative Ganzzahlwas falsch ist.

Wenn Sie versuchen, Bedingungen einzurichten, können Sie diese entsprechend anpassen. Hier sind zwei analoge Beispiele für eine if/else-if-Anweisung:

Beispiel 1:

number = prompt("Pick a number?");
if (number > 0){
  alert("Oh baby, your number is so big!");}
else if (number == 0){
  alert("Hey, there's nothing there!");}
else{
  alert("Wow, that thing's so small it might be negative!");}

Beispiel 2:

number = prompt("Pick a number?");

var sign = number > 0 ? 1 : number == 0 ? 0 : -1;

if (sign == 1){
  alert("Oh baby, your number is so big!" + " " + number);}
else if (sign == 0){
  alert("Hey, there's nothing there!" + " " + number);}
else if (sign == -1){
  alert("Wow, that thing's so small it might be negative!" + " " + number);}

Ich dachte hier wollte man die Aktion machen wenn es positiv ist.

Dann würde vorschlagen:

if (Math.sign(number_to_test) === 1) {
     function_to_run_when_positive();
}

1 Prüfung auf positiven Wert

In Javascript einfacher Vergleich wie: Wert >== 0 liefert uns keine Antwort aufgrund der Existenz von -0 und +0 (Dieses Konzept hat seine Wurzeln in Ableitungsgleichungen) Nachfolgendes Beispiel für diese Werte und ihre Eigenschaften:

var negativeZero = -0;
var negativeZero = -1 / Number.POSITIVE_INFINITY;
var negativeZero = -Number.MIN_VALUE / Number.POSITIVE_INFINITY;

var positiveZero = 0;
var positiveZero = 1 / Number.POSITIVE_INFINITY;
var positiveZero = Number.MIN_VALUE / Number.POSITIVE_INFINITY;

-0 === +0                     // true
1 / -0                        // -Infinity
+0 / -0                       // NaN
-0 * Number.POSITIVE_INFINITY // NaN

In Anbetracht dessen können wir eine Funktion wie die folgende schreiben, um das Vorzeichen der angegebenen Zahl zu überprüfen:

function isPositive (number) {
    if ( number > 0 ) { 
        return true;
    }
    if (number < 0) {
        return false;
    }
    if ( 1 / number === Number.POSITIVE_INFINITY ) {
        return true;
    }
    return false;
}

2a Prüfen, ob die Zahl eine ganze Zahl ist (im mathematischen Sinne)

Um zu überprüfen, ob die Zahl eine ganze Zahl ist, können wir die folgende Funktion verwenden:

function isInteger (number) {
    return parseInt(number) === number;
}
//* in ECMA Script 6 use Number.isInteger

2b Prüfen, ob die Zahl eine ganze Zahl ist (in der Informatik)

In diesem Fall überprüfen wir, ob die Zahl keinen Exponentialteil hat (bitte beachten Sie, dass Zahlen in JS im Gleitkommaformat mit doppelter Genauigkeit dargestellt werden). In Javascript ist es jedoch sinnvoller zu prüfen, ob der Wert “sichere Ganzzahl” ist (http://people.mozilla.org/~jorendorff/es6-draft.html#sec-number.max_safe_integer) – Um es einfach auszudrücken, bedeutet dies, dass wir 1 zu “sicherer Ganzzahl” addieren/subtrahieren können und sicher sein können, dass das Ergebnis dasselbe ist, wie es aus dem Mathematikunterricht erwartet wird. Um zu veranschaulichen, was ich meine, das Ergebnis einiger unsicherer Operationen unten:

Number.MAX_SAFE_INTEGER + 1 === Number.MAX_SAFE_INTEGER + 2;          // true
Number.MAX_SAFE_INTEGER * 2 + 1 === Number.MAX_SAFE_INTEGER * 2 + 4;  // true

Ok, um zu überprüfen, ob die Zahl eine sichere Ganzzahl ist, können wir Number.MAX_SAFE_INTEGER / Number.MIN_SAFE_INTEGER und parseInt verwenden, um sicherzustellen, dass die Zahl überhaupt eine Ganzzahl ist.

function isSafeInteger (number) {
    return parseInt(number) === number
    && number <== Number.MAX_SAFE_INTEGER
    && number >== Number.MIN_SAFE_INTEGER
}
//* in ECMA Script 6 use Number.isSafeInteger

einfach schreiben:

if(values > 0){
//positive
}
else{
//negative
}

if(values >= 0) {
 // as zero is more likely positive than negative
} else {

}