Предположим, что у меня есть значение 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.
Неудачная попытка:
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);}
Я единственный, кто прочитал это и понял, что ни один из ответов не адресован "целочисленной" части вопроса?
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 до начала округления
Я думал, что вы хотите сделать действие, если оно положительное.
Тогда предложили бы:
if (Math.sign(number_to_test) === 1) {
function_to_run_when_positive();
}
В простом сравнении 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;
}
Чтобы проверить, что число является целым числом, мы можем использовать следующую функцию:
function isInteger (number) {
return parseInt(number) === number;
}
//* in ECMA Script 6 use Number.isInteger
В этом случае мы проверяем, что число не имеет экспоненциальной части (учтите, что в 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 ) {
// Yeah, it 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
}
Для проверки числа положительный, отрицательный или отрицательный ноль. Проверьте его знак, используя метод Math.sign(), который предоставит вам -1, - 0,0 и 1 на основе положительного отрицательного и отрицательного нуля или нуля.
Math.sign(-3) // -1
Math.sign(3) // 1
Math.sign(-0) // -0
Math.sign(0) // 0
Положительное число:
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++;
}
}
Сначала вы должны проверить, является ли входное значение interger функцией 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
}
Я знаю, что это было какое-то время, но есть более элегантное решение. Из документации Mozilla:
Math.sign(parseInt(-3))
Это даст вам -1 для отрицательного, 0 для нуля и 1 для положительного.
Для проверки положительного целого числа:
var isPositiveInteger = function(n) {
return ($.isNumeric(n)) && (Math.floor(n) == n) && (n > 0);
}