Ответ 1

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

Ответ 2

Чтобы просто проверить, это самый быстрый способ, кажется:

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.

Неудачная попытка:

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 nothing there!");}
else{
  alert("Wow, that thing 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 nothing there!" + " " + number);}
else if (sign == -1){
  alert("Wow, that thing so small it might be negative!" + " " + number);}

Ответ 3

Я единственный, кто прочитал это и понял, что ни один из ответов не адресован "целочисленной" части вопроса?

Эта проблема

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 not an integer!

Решение

Чтобы гарантировать, что вы имеете дело с целым числом, вы хотите привести свое значение к целому числу, а затем сравнить его с самим собой.

if( parseInt( myInteger ) == myInteger && myInteger > 0 )
    // myInteger is an integer AND it 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 7 "123"s

На моем компьютере в консоли Chrome это выводит: 123123123123123130000

Причина этого заключается в том, что parseInt обрабатывает ввод как 64-битное значение IEEE с плавающей точкой. Это обеспечивает только 52 бита для мантиссы, что означает максимальное значение ~ 4.5e15 до начала округления

Ответ 4

Я думал, что вы хотите сделать действие, если оно положительное.

Тогда предложили бы:

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

Ответ 5

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

В простом сравнении javascript, например: значение > == 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;
}

2a Проверка числа, являющегося целым (в математическом смысле)

Чтобы проверить, что число является целым числом, мы можем использовать следующую функцию:

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

Ответ 6

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

Ответ 7

просто напишите:

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

Ответ 8

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

}

Ответ 9

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

Ответ 10

Для проверки числа положительный, отрицательный или отрицательный ноль. Проверьте его знак, используя метод Math.sign(), который предоставит вам -1, - 0,0 и 1 на основе положительного отрицательного и отрицательного нуля или нуля.

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

Ответ 11

Положительное число:

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

}

Ответ 12

Я использую в этом случае и работает:)

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

Ответ 13

Сначала вы должны проверить, является ли входное значение interger функцией isNumeric(). Затем добавьте условие или больше 0. Это код jQuery для него.

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

Ответ 14

Исходя из того, что полученное значение является числом, а не строкой, как насчет использования 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
}

Ответ 15

Я знаю, что это было какое-то время, но есть более элегантное решение. Из документации Mozilla:

Math.sign(parseInt(-3))

Это даст вам -1 для отрицательного, 0 для нуля и 1 для положительного.

Ответ 16

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

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