Giả sử tôi có giá trị 10 được gán cho một biến;
var values = 10;
và tôi muốn chạy một hàm cụ thể nếu giá trị là dương
if(values = +integer){
//do something with positive
} else {
//do something with negative values
}
Làm thế nào điều này sẽ đạt được?
if (values > 0) {
// Do Something
}
Để chỉ kiểm tra, đây là cách nhanh nhất, có vẻ như:
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".
Nó nói với bạn nếu ký hiệu là dương (trả về 1), hoặc là bằng không (trả về 0)và nếu không (trả về -1). Đây là một giải pháp tốt bởi vì 0 không phải là tích cực, và nó không phải là tiêu cực, nhưng nó có thể là var của bạn.
Không thành công:
var sign = number > 0 ? 1 : -1;
...sẽ tính 0 là số nguyên âm, sai chỗ nào.
Nếu bạn đang cố gắng thiết lập điều kiện, bạn có thể điều chỉnh cho phù hợp. Dưới đây là hai ví dụ tương tự của câu lệnh if / else-if:
Ví dụ 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!");}
Ví dụ 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);}
Tôi có phải là người duy nhất đọc điều này và nhận ra rằng không có câu trả lời nào giải quyết phần "số nguyên" của câu hỏi?
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!
Để đảm bảo rằng bạn đang xử lý một số nguyên, bạn muốn truyền giá trị của mình thành một số nguyên, sau đó so sánh nó với chính nó.
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
Như một phần thưởng, có một số phím tắt để chuyển đổi từ một phao sang một số nguyên trong JavaScript. Trong JavaScript, tất cả các toán tử bitwise (|, ^, &, vv) sẽ truyền số của bạn đến một số nguyên trước khi hoạt động. Tôi cho rằng điều này là do 99% nhà phát triển không biết tiêu chuẩn điểm nổi IEEE và sẽ bị nhầm lẫn khủng khiếp khi "200 | 2" được đánh giá là 400 (ish). Các phím tắt này có xu hướng chạy nhanh hơn hơn Math.floor hoặc là parseIntvà chúng chiếm ít byte hơn nếu bạn đang cố gắng loại bỏ mã nhỏ nhất có thể:
if( myInteger | 0 == myInteger && myInteger > 0 )
// Woot!
if( myFloat | 0 == myFloat && myFloat > 0 )
// Woot, again!
Nhưng xin chờ chút nữa!
Các toán tử bitwise này đang làm việc trên các số nguyên đã ký 32 bit. Điều này có nghĩa bit cao nhất là bit dấu. Bằng cách buộc bit dấu bằng không, số của bạn sẽ không thay đổi chỉ khi nó dương. Bạn có thể sử dụng điều này để kiểm tra tính tích cực và tích hợp trong một cú đánh duy nhất:
// 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)
Nếu bạn gặp khó khăn khi nhớ số phức tạp này, bạn cũng có thể tính toán số đó trước khi thực hiện như sau:
var specialNumber = ~(1 << 31);
Per @ Reinsbrain bình luận, một hack bit tương tự có thể được sử dụng để kiểm tra tiêu cực số nguyên. Trong một số âm, chúng tôi làm muốn bit ngoài cùng bên trái là 1, do đó, bằng cách buộc bit này thành 1 số sẽ chỉ không thay đổi nếu nó là số âm để bắt đầu với:
// Where -2147483648 = 10000000000000000000000000000000 in binary
if( (myInteger | -2147483648) == myInteger )
// myInteger is BOTH negative and an integer
if( (myFloat | -2147483648) == myFloat )
// Won't happen
Con số đặc biệt này thậm chí còn dễ dàng hơn để tính toán:
var specialNumber = 1 << 31;
Như đã đề cập trước đó, vì các toán tử bitwise của JavaScript chuyển đổi thành các số nguyên 32 bit, các số không phù hợp với 32 bit (lớn hơn ~ 2 tỷ) sẽ thất bại
Bạn có thể quay trở lại giải pháp dài hơn cho các giải pháp sau:
if( parseInt(123456789000) == 123456789000 && 123456789000 > 0 )
Tuy nhiên ngay cả giải pháp này không thành công tại một số điểm, bởi vì parseInt bị giới hạn về độ chính xác của nó đối với số lượng lớn. Hãy thử những điều sau và xem điều gì sẽ xảy ra:
parseInt(123123123123123123123); // That's 7 "123"s
Trên máy tính của tôi, trong bảng điều khiển Chrome, kết quả đầu ra này: 123123123123123130000
Lý do cho điều này là parseInt xử lý đầu vào như một phao IEEE 64 bit. Điều này chỉ cung cấp 52 bit cho mantissa, có nghĩa là giá trị cực đại của ~ 4.5e15 trước khi nó bắt đầu làm tròn
Tôi nghĩ ở đây bạn muốn thực hiện hành động nếu nó là tích cực.
Sau đó, sẽ đề nghị:
if (Math.sign(number_to_test) === 1) {
function_to_run_when_positive();
}
Trong javascript so sánh đơn giản như: giá trị> == 0 không cung cấp cho chúng tôi câu trả lời do sự tồn tại của -0 và +0 (Đây là khái niệm có nguồn gốc trong phương trình phái sinh) Dưới đây là ví dụ về các giá trị và tính chất của nó:
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
Có điều đó trong tâm trí chúng ta có thể viết chức năng như dưới đây để kiểm tra các dấu hiệu của số lượng nhất định:
function isPositive (number) {
if ( number > 0 ) {
return true;
}
if (number < 0) {
return false;
}
if ( 1 / number === Number.POSITIVE_INFINITY ) {
return true;
}
return false;
}
Để kiểm tra số đó là một số nguyên, chúng ta có thể sử dụng hàm dưới đây:
function isInteger (number) {
return parseInt(number) === number;
}
//* in ECMA Script 6 use Number.isInteger
Trong trường hợp này, chúng tôi đang kiểm tra con số đó không có bất kỳ phần mũ nào (xin lưu ý rằng trong các số JS được thể hiện bằng định dạng dấu phẩy động kép chính xác) Tuy nhiên trong javascript nó có thể sử dụng nhiều hơn để kiểm tra giá trị đó là "số nguyên an toàn" (http://people.mozilla.org/~jorendorff/es6-draft.html#sec-number.max_safe_integer) - để đặt nó đơn giản nó có nghĩa là chúng ta có thể thêm / trừ 1 đến "số nguyên an toàn" và chắc chắn rằng kết quả sẽ giống như mong đợi từ các bài học toán học. Để minh họa ý tôi, kết quả của một số hoạt động không an toàn dưới đây:
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, do đó, để kiểm tra số đó là số nguyên an toàn, chúng tôi có thể sử dụng Number.MAX_SAFE_INTEGER / Number.MIN_SAFE_INTEGER và parseInt để đảm bảo số đó là số nguyên.
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
}
chỉ cần viết:
if(values > 0){
//positive
}
else{
//negative
}
if(values >= 0) {
// as zero is more likely positive than negative
} else {
}