Скажімо, у мене значення 10 присвоєно змінній;

var values = 10;

і я хочу запустити певну функцію, якщо значення позитивне

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

Як би цього досягти?

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

Просто перевірити, здається, це найшвидший спосіб:

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

Він повідомляє, чи є знак позитивним (повертає 1) або дорівнює нулю (повертає 0) , а в іншому випадку (повертає -1) . Це хороше рішення, оскільки 0 не є позитивним і не є негативним, але це може бути ваша змінна.

Невдала спроба:

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

... буде рахувати 0 як від’ємне ціле число , що неправильно.

Якщо ви намагаєтесь налаштувати умовні умови, ви можете налаштувати відповідне. Ось два аналогічних приклади оператора if / else-if:

Приклад 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!");}

Приклад 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);}

Я єдиний, хто прочитав це і зрозумів, що жодна з відповідей не стосується "цілочисельної" частини питання?

Проблема

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!

Рішення

Щоб гарантувати, що ви маєте справу з цілим числом, ви хочете передати своє значення цілому, а потім порівняти його із самим собою.

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

Деякі акуратні оптимізації

Як бонус, є кілька ярликів для перетворення з плаваючого в ціле число в JavaScript . В JavaScript все бітові операції ( |, ^, &і т.д.) будуть відкидати свій номер в ціле перед початком роботи. Я припускаю, що це тому, що 99% розробників не знають стандарту IEEE з плаваючою комою і можуть жахливо заплутатися, коли "200 | 2" оцінюється як 400 (ish). Ці ярлики , як правило, працюють швидше , ніж Math.floorабо parseInt, і вони займають менше байтів , якщо ви намагаєтеся тягнуть найменший можливий код:

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

Але почекайте, є ще!

Ці побітові оператори працюють над 32-розрядними цілими числами зі знаком. Це означає, що найвищим бітом є знаковий біт. Примусивши знаковий біт до нуля, ваше число залишиться незмінним, лише якщо воно було позитивним . Ви можете використовувати це для перевірки позитиву та цілісності одним ударом:

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

Якщо у вас виникають проблеми із запам’ятовуванням цього зв’язаного числа, ви також можете обчислити його заздалегідь як таке:

var specialNumber = ~(1 << 31);

Перевірка на наявність негативів

За коментарем @ Reinsbrain, подібний побітовий хак можна використовувати для перевірки від’ємного цілого числа. У негативному числі, ми дійсно хочемо , щоб лівий біт бути 1, тому, змушуючи цей біт в 1 , то число буде тільки залишатися незмінним , якщо воно було негативним , щоб почати з:

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

Це спеціальне число ще простіше розрахувати:

var specialNumber = 1 << 31;

Крайові футляри

Як вже згадувалося раніше, оскільки побітові оператори JavaScript перетворюють на 32-розрядні цілі числа, числа, які не вміщуються в 32 біти (більше ~ 2 млрд), зазнають невдачі

Ви можете повернутися до більш довгого рішення для таких:

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

Однак навіть це рішення в якийсь момент не вдається, оскільки parseIntйого точність обмежена для великої кількості. Спробуйте наступне і подивіться, що станеться:

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

На моєму комп’ютері в консолі Chrome це виводить: 123123123123123130000

Причиною цього є те, що parseInt обробляє вхідні дані як 64-розрядний плаваючий пристрій IEEE. Це забезпечує лише 52 біти для мантиси, тобто максимальне значення ~ 4,5e15 перед тим, як вона почне округлятися

Я думав, тут ви хочете зробити дію, якщо вона позитивна.

Тоді б запропонував:

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

1 Перевірка позитивного значення

У простому порівнянні javascript, наприклад: value> == 0 не дає нам відповіді через існування -0 та +0 (це поняття має коріння у похідних рівняннях) Нижче наведено приклад цих значень та його властивостей:

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

Маючи це на увазі, ми можемо написати функцію, як показано нижче, для перевірки знаку заданого числа:

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

2а Перевірка числа, яке є цілим числом (у математичному розумінні)

Щоб перевірити, що число є цілим числом, ми можемо використовувати функцію нижче:

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

2b Перевірка числа, яке є цілим числом (в інформатиці)

У цьому випадку ми перевіряємо, що число не має експоненціальної частини (зауважте, що в JS числа представлені у форматі з плаваючою комою з подвійною точністю) Однак у javascript корисніше перевірити, чи є значення "безпечним цілим числом" ( http : //people.mozilla.org/~jorendorff/es6-draft.html#sec-number.max_safe_integer ) - простіше кажучи, це означає, що ми можемо додати / відняти 1 до "безпечного цілого числа" і бути впевненими, що результат буде те саме, що очікувалося від уроків математики. Щоб проілюструвати, що я маю на увазі, результат деяких небезпечних операцій нижче:

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

Гаразд, щоб перевірити, чи число є безпечним цілим числом, ми можемо використовувати Number.MAX_SAFE_INTEGER / Number.MIN_SAFE_INTEGER і parseInt, щоб переконатися, що число взагалі є цілим числом.

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){
//positive
}
else{
//negative
}

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    
}

Для перевірки числа додатним, від’ємним або від’ємним нулем. Перевірте його знак, використовуючи метод Math.sign (), який надасть вам -1, -0,0 та 1 на основі додатних від’ємних та від’ємних нульових чи нульових чисел

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

Я знаю, що минув якийсь час, але є більш елегантне рішення. З документації mozilla :

Math.sign(parseInt(-3))

Це дасть вам -1 за мінус, 0 за нуль і 1 за позитив.

Позитивне ціле число:

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

}

Я використовую в цьому випадку, і це працює :)

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

Спочатку слід перевірити, чи вхідне значення є зв’язком з функцією isNumeric (). Потім додайте умову або більше 0. Це код jQuery для неї.

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

Починаючи з основи, що отримане значення - це число, а не рядок, а як щодо використання Math.abs()? Ця вбудована функція JavaScript повертає абсолютне значення числа:

Math.abs(-1) // 1

Тож ви можете використовувати це таким чином:

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

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

Ви можете використовувати оператор зсувного біта, але він хоче отримати різницю між -0і +0подібними Math.sign(x):

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

https://jsfiddle.net/obxptgze/

Для перевірки натурального цілого числа:

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