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

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'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

некоторые аккуратные оптимизации

в качестве бонуса, есть несколько ярлыков для преобразования из float в an целое число в 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, аналогичный побитовый хак может быть использован для проверки отрицательный целое число. В отрицательном числе мы do хотите, чтобы самый левый бит был 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 консоли, это выходы: 123123123123130000

причина этого заключается в том, что parseInt обрабатывает вход как 64-разрядный IEEE float. Это обеспечивает только 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;
}

2a проверка на то, что число является целым числом (in математический смысл)

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

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

хорошо, поэтому, чтобы проверить, что число является безопасным целым числом, мы можем использовать число.MAX_SAFE_INTEGER / количество.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 ) {
    // Yeah, it's positive
}

просто написать:

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    
}

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

 Math.sign(-3) // -1
 Math.sign(3) // 1
 Math.sign(-0) // -0
 Math.sign(0) // 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++;
    }
}

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

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

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

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