Comment vérifier que la valeur donnée est un nombre entier positif ou négatif ?

Question

Disons que j'ai la valeur 10 assignée à une variable ;

var values = 10;

et je veux exécuter une fonction spécifique si la valeur est positive.

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

Comment cela serait-il possible ?

Answer 1

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

Answer 2

Suis-je le seul à avoir lu cette question et à avoir réalisé qu'aucune des réponses n'abordait la partie "entier" 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 nombre entier, vous devez convertir votre valeur en un nombre entier, puis le comparer à lui-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 intéressantes

En prime, il existe des raccourcis pour convertir un flottant en entier en JavaScript. . En JavaScript, tous les opérateurs binaires ( | , ^ , & etc) transformeront votre nombre en un entier avant de l'utiliser. Je suppose que c'est parce que 99% des développeurs ne connaissent pas la norme IEEE de virgule flottante et seraient terriblement confus si "200 | 2" était évalué à 400(ish). Ces raccourcis ont tendance à courir plus vite que Math.floor o parseInt et ils occupent 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 bit à bit fonctionnent sur des entiers signés de 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 si c'était positif . Vous pouvez l'utiliser pour vérifier la positivité ET l'intégrité 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 chiffre alambiqué, vous pouvez aussi le calculer à l'avance comme tel :

var specialNumber = ~(1 << 31);

Vérification des négatifs

Conformément au commentaire de @Reinsbrain, un piratage bit à bit similaire peut être utilisé pour vérifier la présence d'un négatif entier. Dans un nombre négatif, on faire veulent 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 au départ :

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

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

var specialNumber = 1 << 31;

Cas limites

Comme nous l'avons mentionné précédemment, puisque les opérateurs bitwise JavaScript sont convertis en nombres entiers 32 bits, les nombres qui ne tiennent pas sur 32 bits (supérieurs à ~2 milliards) échoueront.

Vous pouvez vous rabattre sur la solution longue pour ces derniers :

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

Cependant, même cette solution échoue à un moment donné, car parseInt est limitée 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, cela sort : 123123123123123130000

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

Answer 3

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

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 (renvoie 1) o égal à zéro (renvoie 0) y sinon (renvoie -1) . C'est une bonne solution car 0 n'est pas positif, et il n'est pas négatif, mais c'est peut-être votre var.

Tentative échouée :

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

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

Si vous essayez de mettre en place des conditionnels, vous pouvez ajuster en conséquence. 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);}

Answer 4

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

Alors je suggère :

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

Answer 5

1 Vérification de la valeur positive

En javascript, une simple comparaison comme : valeur >== 0 ne nous fournit pas de réponse en raison de l'existence de -0 et +0 (Ce concept a ses racines dans les équations dérivées). Voici un exemple de ces valeurs et de leurs 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

En gardant cela à l'esprit, nous pouvons écrire une fonction comme la suivante 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 que le nombre est un nombre entier (au sens mathématique)

Pour vérifier que le nombre est un entier, 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 caractère entier d'un nombre (en informatique)

Dans ce cas, nous vérifions que le nombre n'a pas de partie exponentielle (veuillez noter qu'en JS les nombres sont représentés en format flottant à double précision). Cependant, en javascript, il est plus facile de vérifier que la valeur est un "safe integer" ( http://people.mozilla.org/~jorendorff/es6-draft.html#sec-number.max_safe_integer ) - pour faire simple, cela signifie que nous pouvons ajouter/soustraire 1 à un "entier sûr" et être sûrs que le résultat sera le même que celui attendu dans les leçons de mathématiques. Pour illustrer ce que je veux dire, voici le résultat de quelques opérations non sécurisées :

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 un nombre entier sûr, nous pouvons utiliser Number.MAX_SAFE_INTEGER / Number.MIN_SAFE_INTEGER et parseInt pour nous assurer que le nombre est bien un nombre 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