Kiểm tra xem một số có vị trí thập phân / là một số nguyên

Tôi đang tìm kiếm một cách dễ dàng trong JavaScript để kiểm tra xem một số có vị trí thập phân trong đó hay không (để xác định xem đó có phải là số nguyên không). Ví dụ,

23 -> OK
5 -> OK
3.5 -> not OK
34.345 -> not OK

if(number is integer) {...}

Sử dụng mô-đun sẽ hoạt động:

num % 1 != 0
// 23 % 1 = 0
// 23.5 % 1 = 0.5

Lưu ý rằng điều này dựa trên giá trị số của số, bất kể định dạng. Nó xử lý các chuỗi số chứa toàn bộ số có dấu thập phân cố định giống như số nguyên:

'10.0' % 1; // returns 0
10 % 1; // returns 0
'10.5' % 1; // returns 0.5
10.5 % 1; // returns 0.5

Number.isInteger(23);  // true
Number.isInteger(1.5); // false
Number.isInteger("x"); // false: 

Number.isInteger () là một phần của tiêu chuẩn ES6 và không được hỗ trợ trong IE11.

Nó trả về false cho NaN, Infinitylý lẽ và không phải số trong khi x % 1 != 0trả về true.

Hoặc bạn chỉ có thể sử dụng điều này để tìm hiểu xem nó KHÔNG phải là số thập phân:

string.indexOf(".") == -1;

Giải pháp phổ biến nhất là tước phần nguyên của số và so sánh nó với số 0 như vậy:

function Test()
{
     var startVal = 123.456
     alert( (startVal - Math.floor(startVal)) != 0 )
}

Đơn giản mà hiệu quả!

Math.floor(number) === number;

// Làm thế nào về byte-ing nó?

Number.prototype.isInt= function(){
 return this== this>> 0;
}

Tôi luôn cảm thấy tệ cho các nhà khai thác bit trong javascript-

họ hầu như không tập thể dục

number = 20.5

if (number == Math.floor(number)) {

alert("Integer")

} else {

alert("Decimal")

}

Khá tuyệt và cũng hoạt động cho những thứ như XX.0! Nó hoạt động vì Math.floor () loại bỏ bất kỳ số thập phân nào nếu có một số thập phân vì vậy nếu sàn khác với số ban đầu, chúng tôi biết đó là số thập phân! Và không có chuyển đổi chuỗi :)

var re=/^-?[0-9]+$/;
var num=10;
re.test(num);

Number.isInteger()có lẽ là ngắn gọn nhất Nó trả về true nếu nó là số nguyên và false nếu không.

function isDecimal(n){
    if(n == "")
        return false;

    var strCheck = "0123456789";
    var i;

    for(i in n){
        if(strCheck.indexOf(n[i]) == -1)
            return false;
    }
    return true;
}

parseInt(num) === num

khi truyền một số, parseInt()chỉ trả về số đó là int:

parseInt(3.3) === 3.3 // false because 3 !== 3.3
parseInt(3) === 3     // true

chuyển chuỗi số thành mảng, chia theo dấu thập phân. Sau đó, nếu mảng chỉ có một giá trị, điều đó có nghĩa là không có số thập phân trong chuỗi.

if(!number.split(".")[1]){
    //do stuff
}

Bằng cách này bạn cũng có thể biết số nguyên và số thập phân thực sự là gì. một ví dụ nâng cao hơn sẽ là.

number_to_array = string.split(".");
inte = number_to_array[0];
dece = number_to_array[1]; 

if(!dece){
    //do stuff
}

Đây là một đoạn trích từ thư viện bảo vệ của tôi (lấy cảm hứng từ JavaScript hiệu quả của David Herman):

var guard = {

    guard: function(x) {
        if (!this.test(x)) {
            throw new TypeError("expected " + this);
        }
    }

    // ...
};

// ...

var number = Object.create(guard);
number.test = function(x) {
    return typeof x === "number" || x instanceof Number;
};
number.toString = function() {
    return "number";
};


var uint32 = Object.create(guard);
uint32.test = function(x) {
    return typeof x === "number" && x === (x >>> 0);
};
uint32.toString = function() {
    return "uint32";
};


var decimal = Object.create(guard);
decimal.test = function(x) {
    return number.test(x) && !uint32.test(x);
};
decimal.toString = function() {
    return "decimal";
};


uint32.guard(1234);     // fine
uint32.guard(123.4);    // TypeError: expected uint32

decimal.guard(1234);    // TypeError: expected decimal
decimal.guard(123.4);   // fine

Bạn có thể nhân nó với 10 và sau đó thực hiện thao tác / modison " modulo " với 10 và kiểm tra xem kết quả của hai thao tác đó có bằng không. Kết quả của hai thao tác đó sẽ cung cấp cho bạn chữ số đầu tiên sau dấu thập phân. Nếu kết quả bằng 0 thì số đó là một số nguyên.

if ( (int)(number * 10.0) % 10 == 0 ){
// your code
}

function isDecimal(num) {
  return (num !== parseInt(num, 10));
}

Bạn có thể sử dụng các thao tác bitwise không thay đổi giá trị ( ^ 0hoặc ~~) để loại bỏ phần thập phân, có thể được sử dụng để làm tròn. Sau khi làm tròn số, nó được so sánh với giá trị ban đầu:

function isDecimal(num) {
  return (num ^ 0) !== num;
}

console.log( isDecimal(1) ); // false
console.log( isDecimal(1.5) ); // true
console.log( isDecimal(-0.5) ); // true

function isWholeNumber(num) {
  return num === Math.round(num);
}

Bạn có thể sử dụng chức năng sau để kiểm tra xem một số có vị trí thập phân hay không:

function hasDecimal(num){
    return !!(num % 1);
}

console.log(hasDecimal(2)); //false
console.log(hasDecimal(2.32423)); //true

Vì vậy, rõ ràng một số người dùng muốn giải thích. Tôi sẽ chia nó thành từng mảnh: (num% 1)

Dấu ngoặc có nghĩa là thực hiện các hoạt động đầu tiên. num - một biến được truyền vào bởi hàm. % - một ký hiệu mô đun cố gắng chia số bên trái cho bên phải. Nếu có phần còn lại, nó trả về dưới dạng thập phân. Nếu nó chia đều, nó trả về 0.

Vì vậy, tổng hợp những gì chúng ta có cho đến nay., (Num% 1) sẽ trả về:

0 khi chia đều HOẶC #. ##### nếu không

0 == sai.

[ANY_NUMBER_NOT_ZERO] == đúng.

Ví dụ: Boolean mới (0) là sai Boolean mới (12312.1231) là đúng

Các lựa chọn thay thế khác: Một người dùng có thể đã cố gắng trả về giá trị của (num% 1)., Về cơ bản sẽ đạt được điều tương tự. Vì return (0) là false và return (1.213113) là true.

Nhưng tôi muốn trả về một giá trị boolean. Vì vậy, như là một phím tắt để buộc một giá trị vào một boolean tôi đã thêm một! biểu tượng trước nó.

Nhiều như có thể biết.,! có nghĩa là KHÔNG. Nhưng nó cũng buộc một giá trị vào một boolean.

Kể từ khi! symobol buộc giá trị thành boolean và nó đảo ngược giá trị của nó. Tôi sử dụng !! để buộc giá trị thành một boolean và đảo ngược giá trị của nó trở lại giá trị boolean ban đầu của nó.

Hàm cho số kiểm tra là số thập phân hoặc toàn bộ

function IsDecimalExist(p_decimalNumber) {
    var l_boolIsExist = true;

    if (p_decimalNumber % 1 == 0)
        l_boolIsExist = false;

    return l_boolIsExist;
}

Có lẽ điều này làm việc cho bạn?

Nó sử dụng regex để kiểm tra xem có dấu phẩy nào trong số không và nếu không có thì nó sẽ thêm dấu phẩy và sọc.

var myNumber = '50';
function addCommaStripe(text){
    if(/,/.test(text) == false){
        return text += ',-';
    } else {
        return text;
    }
}
myNumber = addCommaStripe(myNumber);

Sử dụng sau nếu giá trị là chuỗi (ví dụ từ <input):

Math.floor(value).toString() !== value

Tôi thêm .toString()vào sàn để làm cho nó hoạt động cũng cho các trường hợp khi value == "1."(kết thúc bằng dấu tách thập phân hoặc chuỗi khác). Cũng Math.floorluôn trả về một số giá trị để .toString()không bao giờ thất bại.