Nehmen wir an, ich habe den Wert 10 einer Variablen 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
}

Um nur zu überprüfen, dies ist anscheinend der schnellste Weg:

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

Hier erfahren Sie, ob das Vorzeichen positiv ist (Rückgabe 1) oder gleich Null ist (Rückgabe 0) , andernfalls (Rückgabe -1) . Dies ist eine gute Lösung, da 0 nicht positiv und nicht negativ ist, aber es kann Ihre Variable sein.

Fehlversuch:

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

... zählt 0 als negative ganze Zahl , was 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);}

Bin ich der einzige, der dies gelesen hat und festgestellt hat, dass keine der Antworten den "ganzzahligen" Teil der Frage betrifft?

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 es sich um eine Ganzzahl handelt, möchten Sie Ihren Wert in eine Ganzzahl umwandeln und 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 Bonus gibt es einige Verknüpfungen zum Konvertieren von einem Float in eine Ganzzahl in JavaScript . In JavaScript sind alle Bit - Operatoren ( |, ^, &, usw.) Ihre Zahl auf eine ganze Zahl gegossen vor dem Betrieb. Ich gehe davon aus, dass 99% der Entwickler den IEEE-Gleitkomma-Standard nicht kennen und schrecklich verwirrt wären, wenn "200 | 2" auf 400 (ish) ausgewertet würde. Diese Verknüpfungen werden in der Regel schneller als Math.flooroder ausgeführt parseIntund benötigen weniger Byte, 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, da ist noch mehr!

Diese bitweisen Operatoren arbeiten mit 32-Bit-Ganzzahlen mit Vorzeichen. Dies bedeutet, dass das höchste Bit das Vorzeichenbit ist. Wenn Sie das Vorzeichenbit auf Null setzen, bleibt Ihre Zahl nur dann unverändert , wenn sie positiv war . Sie können dies verwenden, um mit einem einzigen Schlag die Positivität UND Integrität zu überprü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 Probleme haben, sich an diese verschlungene Zahl zu erinnern, können Sie sie auch vorher als solche berechnen:

var specialNumber = ~(1 << 31);

Auf Negative prüfen

Gemäß dem Kommentar von @ Reinsbrain kann ein ähnlicher bitweiser Hack verwendet werden, um nach einer negativen Ganzzahl zu suchen . In einer negativen Zahl, wir tun wollen , dass die am weitesten links gelegene Bit a 1, um so durch diesen Bit auf 1 zwingen die Zahl bleibt nur unverändert , wenn sie negativ zu beginnen sind:

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

Randfälle

Wie bereits erwähnt, schlagen Zahlen, die nicht in 32-Bit (mehr als ~ 2 Milliarden) passen, fehl, da bitweise JavaScript-Operatoren in 32-Bit-Ganzzahlen konvertieren

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

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

Selbst diese Lösung schlägt jedoch irgendwann fehl, da parseIntihre Genauigkeit für große Zahlen begrenzt ist. 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 einen 64-Bit-IEEE-Float behandelt. Dies liefert nur 52 Bits für die Mantisse, was einen Maximalwert von ~ 4,5e15 bedeutet, bevor sie mit dem Runden beginnt

Ich dachte hier, du wolltest die Aktion machen, wenn sie positiv ist.

Dann würde vorschlagen:

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

schreibe einfach:

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

1 Auf positiven Wert prüfen

In Javascript gibt uns ein einfacher Vergleich wie: Wert> == 0 aufgrund der Existenz von -0 und +0 keine Antwort. (Dieses Konzept hat seine Wurzeln in abgeleiteten Gleichungen.) 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 diesem Sinne können wir eine Funktion wie unten schreiben, um das Vorzeichen der angegebenen Nummer 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 Überprüfen, ob die Zahl eine Ganzzahl ist (im mathematischen Sinne)

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

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

2b Überprüfen, ob die Zahl eine Ganzzahl ist (in der Informatik)

In diesem Fall überprüfen wir, ob die Zahl keinen exponentiellen Teil hat (bitte beachten Sie, dass in JS Zahlen im Gleitkommaformat mit doppelter Genauigkeit dargestellt werden). In Javascript ist es jedoch sinnvoller zu überprüfen, ob der Wert "sichere Ganzzahl" ( http) ist : //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 sein wird das gleiche wie vom Mathematikunterricht erwartet. Um zu veranschaulichen, was ich meine, 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

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

}

if ( values > 0 ) {
    // Yeah, it's positive
}

if ( values > 0 ) {
    //you got a positive value
}else{
    //you got a negative or zero value    
}

Eine Zahl zu überprüfen ist positiv, negativ oder negativ Null. Überprüfen Sie das Vorzeichen mit der Math.sign () -Methode. Sie erhalten -1, -0,0 und 1 auf der Grundlage positiver negativer und negativer Null- oder Nullzahlen

 Math.sign(-3) // -1
 Math.sign(3) // 1
 Math.sign(-0) // -0
 Math.sign(0) // 0

Ich weiß, es ist einige Zeit her, aber es gibt eine elegantere Lösung. Aus den Mozilla- Dokumenten :

Math.sign(parseInt(-3))

Sie erhalten -1 für negativ, 0 für null und 1 für positiv.

Positive ganze Zahl:

if (parseInt(values, 10) > 0) {

}

Ich benutze in diesem Fall und es funktioniert :)

var pos = 0; 
var sign = 0;
var zero = 0;
var neg = 0;
for( var i in arr ) {
    sign = arr[i] > 0 ? 1 : arr[i] == 0 ? 0 : -1;
    if (sign === 0) {
        zero++; 
    } else if (sign === 1 ) {
        pos++;
    } else {
        neg++;
    }
}

Sie sollten zuerst überprüfen, ob der Eingabewert mit der Funktion isNumeric () zusammenfällt. Fügen Sie dann die Bedingung oder größer als 0 hinzu. Dies ist der jQuery-Code dafür.

function isPositiveInteger(n) {
        return ($.isNumeric(n) && (n > 0));
}

Ausgehend von der Basis, dass der empfangene Wert eine Zahl und keine Zeichenfolge ist, was ist mit der Verwendung Math.abs()? Diese native JavaScript-Funktion gibt den absoluten Wert einer Zahl zurück:

Math.abs(-1) // 1

Sie können es also folgendermaßen verwenden:

var a = -1;
if(a == Math.abs(a)){
    // false 
}

var b = 1;   
if(b == Math.abs(b)){
    // true
}

Sie können den Shifting-Bit-Operator verwenden, aber er möchte den Unterschied zwischen -0und +0ähnlichem feststellen Math.sign(x):

let num = -45;
if(num >> 31 === -1)
    alert('Negative number');
else
    alert('Positive number');

https://jsfiddle.net/obxptgze/

Zum Überprüfen der positiven Ganzzahl:

var isPositiveInteger = function(n) {
        return ($.isNumeric(n)) && (Math.floor(n) == n) && (n > 0); 
}