web-dev-qa-db-fra.com

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

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 réalisé?

javascriptjquery
58
Xavier
if (values > 0) {
    // Do Something
}
142
Peter Kelly

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 indique si le signe est positif (renvoie 1) , ou égal à zéro (renvoie 0) et sinon (renvoie -1) . C'est une bonne solution car 0 n'est pas positif, et ce n'est pas négatif, mais il peut s'agir de votre var. 

Tentative échouée:

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

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

Si vous essayez de définir des conditions, vous pouvez les ajuster en conséquence. Voici deux exemples analogues d'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);}
19
Wolfpack'08

Suis-je le seul à l'avoir lu et à me rendre compte qu'aucune des réponses ne traitait de 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 vous assurer que vous avez affaire à un entier, vous voulez convertir votre valeur en un entier, puis la comparer à 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 bonus, il existe quelques raccourcis pour convertir un float en entier en JavaScript . En JavaScript, tous les opérateurs au niveau des bits (|, ^, &, etc.) convertissent votre nombre en un entier avant de fonctionner. Je suppose que cela est dû au fait que 99% des développeurs ne connaissent pas la norme de la virgule flottante IEEE et seraient terriblement confus lorsque «200 | 2» serait évalué à 400 (ish). Ces raccourcis ont tendance à s'exécuter plus rapidement que Math.floor ou parseInt, et ils utilisent moins d'octets si vous essayez d'extraire 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 au niveau des bits travaillent 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 utiliser ceci pour vérifier le potentiel 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 ne parvenez pas à vous souvenir de ce numéro compliqué, vous pouvez également le calculer à l'avance en tant que tel:

var specialNumber = ~(1 << 31);

Vérification des négatifs

Selon le commentaire de @ Reinsbrain, un hack similaire au niveau des bits peut être utilisé pour rechercher un entier négatif. Dans un nombre négatif, nous do voulons que le bit le plus à gauche soit un 1; ainsi, en forçant ce bit à 1, le nombre restera inchangé s'il était négatif au début:

// 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, les opérateurs de bits au format JavaScript convertissant en entiers 32 bits, les nombres qui ne tiennent pas dans 32 bits (supérieurs à environ 2 milliards) échoueront

Vous pouvez avoir recours à la solution la plus longue pour ces problèmes:

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

Cependant, même cette solution échoue à un moment donné, car parseInt est limité en 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 génère: 123123123123123130000

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

15
stevendesu

Je pensais ici que vous vouliez faire l’action si c’était positif.

Alors suggérerais:

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

1 Vérification de la valeur positive

En javascript, une comparaison simple telle que: valeur> == 0 ne nous fournit pas de réponse en raison de l'existence de -0 et de +0 (Ce concept a pour origine des équations dérivées) 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

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

Pour vérifier que ce 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érifier qu'un nombre est un entier (en informatique)

Dans ce cas, nous vérifions que ce nombre ne comporte aucune partie exponentielle (veuillez noter que, dans JS, les nombres sont représentés au format à virgule flottante en double précision). "( http://people.mozilla.org/~jorendorff/es6-draft.html#sec-number.max_safe_integer ) - pour le dire simplement, cela signifie que nous pouvons ajouter/soustraire 1 à" safe integer " et assurez-vous que le résultat sera le même que celui attendu pour les cours de mathématiques ..__ Pour illustrer ce que je veux dire, résultat d'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 ce nombre est un entier sûr, nous pouvons utiliser Number.MAX_SAFE_INTEGER/Number.MIN_SAFE_INTEGER et parseInt pour s’assurer que ce nombre est un 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
6
Rafal Bartoszek
if ( values > 0 ) {
    // Yeah, it's positive
}
5
Gustav Barkefors

écrivez simplement:

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

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

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

 Math.sign(-3) // -1
 Math.sign(3) // 1
 Math.sign(-0) // -0
 Math.sign(0) // 0
2
Amitesh Maurya

Entier positif:

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

}
1
Ha Ja

En partant de la base que la valeur reçue est un nombre et non une chaîne, qu'en est-il de l'utilisation de Math.abs()? Cette fonction native JavaScript renvoie la valeur absolue d'un nombre:

Math.abs(-1) // 1

Vous pouvez donc l'utiliser de cette façon:

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

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

Je sais que cela fait longtemps, mais il existe une solution plus élégante. De la mozilla docs :

Math.sign(parseInt(-3))

Cela vous donnera -1 pour négatif, 0 pour zéro et 1 pour positif.

0
Marco

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

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++;
    }
}
0
Ezequiel García

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

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