Pour juste vérifier, c'est le moyen le plus rapide, il semble:

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

, Il vous dit si le signe est positif (retourne 1), ou égal à zéro (retourne 0), et sinon (retourne -1). C'est une bonne solution car 0 n'est pas positif, et il n'est pas négatif, mais il peut être votre var.

Tentative infructueuse:

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

...comptera 0 un entier négatif, ce qui est faux.

Si vous essayez de configurer des conditions, vous pouvez ajuster conséquent. Voici deux exemples analogues d'une instruction if/else-if:

Exemple 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!");}

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

Suis - je le seul à avoir lu ceci et réalisé qu'aucune des réponses ne traitait de la partie "entière" de la question?

Le problème

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!

La solution

Pour garantir que vous avez affaire à un entier, vous voulez convertir votre valeur en un entier, puis la comparer avec elle-même.

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

Quelques optimisations soignées

En prime, Il y a quelques raccourcis pour convertir d'un float en entier en JavaScript . En JavaScript, le tout opérateurs binaires(|, ^, &, etc) convertira votre nombre en entier avant d'opérer. Je suppose que c'est parce que 99% des développeurs ne connaissent pas la norme IEEE à virgule flottante et seraient horriblement confus quand "200 | 2" évalué à 400(ish). Ces raccourcis ont tendance à courir plus vite que Math.floor ou parseInt, et ils prennent moins d'octets si vous essayez d'obtenir le plus petit code possible:

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

Mais attendez, il y a plus!

Ces opérateurs binaires sont travailler sur des entiers signés 32 bits. Cela signifie que le bit le plus élevé est le bit de signe. En forçant le bit de signe à zéro, votre nombre restera inchangé seulement s'il était positif. Vous pouvez l'utiliser pour vérifier la positivité et l'integer en un seul coup:

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

Si vous avez du mal à vous souvenir de ce nombre alambiqué, vous pouvez également le calculer avant la main en tant que tel:

var specialNumber = ~(1 << 31);

Vérification des négatifs

Par le commentaire de @ Reinsbrain, un hack similaire peut être utilisé pour vérifier un négatif entier. Dans un nombre négatif, nous voulons que le bit le plus à gauche soit un 1, donc en forçant ce bit à 1, le nombre ne restera inchangé que s'il était négatif pour commencer:

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

Ce nombre spécial est encore plus facile à calculer:

var specialNumber = 1 << 31;

Cas de bord

Comme mentionné précédemment, puisque les opérateurs JavaScript convertissent en entiers 32 bits, les nombres qui ne correspondent pas à 32 bits (supérieurs à ~2 milliards) seront échec

Vous pouvez revenir à la solution plus longue pour ceux-ci:

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

Cependant, même cette solution échoue à un moment donné, car parseInt est limité dans sa précision pour les grands nombres. Essayez ce qui suit et voyez ce qui se passe:

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

Sur mon ordinateur, dans la console Chrome, cette sortie: 123123123123123130000

La raison en est que parseInt traite l'entrée comme un flotteur IEEE 64 bits. Cela ne fournit que 52 bits pour la mantisse, ce qui signifie une valeur maximale de ~4. 5e15 avant qu'il ne commence à arrondir

Je pensais ici que vous vouliez faire l'action si elle est positive.

Alors suggérerait:

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

1 Vérification de la valeur positive

En javascript simple comparaison: valeur >== 0 ne pas nous fournir de réponse grâce à l'existence de -0 et +0 (Ce concept a ses racines dans les équations dérivées) ci-dessous exemple de ces valeurs et de ses propriétés:

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

Ayant cela à l'esprit, nous pouvons écrire une fonction comme ci-dessous pour vérifier le signe d'un nombre donné:

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

2a vérification du nombre étant un entier (au sens mathématique)

Pour vérifier ce nombre est un entier que nous pouvons utiliser la fonction ci-dessous:

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

2b vérification du nombre étant un entier (en informatique)

Dans ce cas, nous vérifions que le nombre n'a pas de partie exponentielle (veuillez noter que dans JS, les nombres sont représentés au format à virgule flottante à double précision) Cependant, en javascript, il est plus utilisable pour vérifier que la valeur est "safe integer" (http://people.mozilla.org/~jorendorff / es6-draft.html#sec-number.max_safe_integer) - pour le mettre simple cela signifie que nous pouvons ajouter / soustraire 1 à "safe integer" et être sûr que le résultat sera le même que prévu des leçons de mathématiques. Pour illustrer ce que je veux dire, résultat de certaines opérations dangereuses ci-dessous:

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, donc pour vérifier que le nombre est entier sûr, nous pouvons utiliser le nombre.MAX_SAFE_INTEGER / nombre.MIN_SAFE_INTEGER et parseInt pour s'assurer que number Est entier.

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 ) {
    // Yeah, it's positive
}

Écrivez simplement:

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

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

}

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

Pour vérifier un nombre est positif, négatif ou négatif zéro. Vérifiez son signe en utilisant Mathématiques.sign () Méthode il vous fournira -1, -0,0 et 1 sur la base de nombres positifs négatifs et négatifs zéro ou zéro

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

J'utilise dans ce cas et ça fonctionne :)

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

Vous devez d'abord vérifier si la valeur d'entrée est interger avec la fonction isNumeric (). Ajoutez ensuite la condition ou supérieure à 0. C'est le code jQuery pour cela.

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

Pour vérifier l'entier positif:

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