Periksa apakah suatu bilangan memiliki tempat desimal / bilangan bulat

Saya mencari cara mudah dalam JavaScript untuk memeriksa apakah angka memiliki tempat desimal di dalamnya (untuk menentukan apakah itu bilangan bulat). Misalnya,

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

if(number is integer) {...}

Menggunakan modulus akan bekerja:

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

Catatan bahwa ini didasarkan pada numerik nilai dari nomor tersebut, terlepas dari format. Ini memperlakukan string numerik yang berisi bilangan bulat dengan titik desimal tetap sama dengan bilangan bulat:

'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 () adalah bagian dari standar ES6 dan tidak didukung di IE11.

Itu mengembalikan false untuk NaN, Infinitydan argumen non-numerik sementara x % 1 != 0mengembalikan true.

Atau Anda bisa menggunakan ini untuk mengetahui apakah BUKAN desimal:

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

Solusi yang paling umum adalah dengan memotong bagian bilangan bulat dari angka dan membandingkannya dengan nol seperti ini:

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

Sederhana tetapi efektif!

Math.floor(number) === number;

// Bagaimana dengan byte-ing itu?

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

Saya selalu merasa agak buruk untuk operator bit di javascript-

mereka jarang berolahraga.

number = 20.5

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

alert("Integer")

} else {

alert("Decimal")

}

Cukup keren dan berfungsi untuk hal-hal seperti XX.0 juga! Ini bekerja karena Math.floor () memenggal desimal apa pun jika memiliki desimal sehingga jika lantai berbeda dari angka semula, kita tahu itu desimal! Dan tidak ada konversi string :)

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

Number.isInteger()mungkin yang paling ringkas. Ini mengembalikan true jika itu adalah bilangan bulat, dan false jika tidak.

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

ketika melewati nomor, parseInt()cukup kembalikan nomor itu sebagai int:

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

mengkonversi string angka menjadi array, dibagi dengan titik desimal. Kemudian, jika array hanya memiliki satu nilai, itu berarti tidak ada desimal dalam string.

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

Dengan cara ini Anda juga bisa tahu apa bilangan bulat dan desimal sebenarnya. contoh yang lebih maju adalah.

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

if(!dece){
    //do stuff
}

Berikut kutipan dari perpustakaan penjaga saya (terinspirasi oleh JavaScript Efektif oleh 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

Anda dapat mengalikannya dengan 10 dan kemudian melakukan " modulo " operasi / divisi dengan 10 , dan periksa apakah hasil dari dua operasi itu nol. Hasil dari dua operasi itu akan memberi Anda digit pertama setelah titik desimal. Jika hasilnya sama dengan nol maka jumlahnya adalah bilangan bulat.

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

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

Anda dapat menggunakan operasi bitwise yang tidak mengubah nilai ( ^ 0atau ~~) untuk membuang bagian desimal, yang dapat digunakan untuk pembulatan. Setelah membulatkan angka, itu dibandingkan dengan nilai aslinya:

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

Anda dapat menggunakan fungsi berikut untuk memeriksa apakah suatu angka memiliki tempat desimal:

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

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

Jadi ternyata beberapa pengguna menginginkan penjelasan. Saya akan memecahnya menjadi potongan-potongan: (num% 1)

Parenthesis berarti melakukan operasi tersebut terlebih dahulu. num - variabel yang diteruskan oleh fungsi. % - simbol modulus yang mencoba membagi angka kiri dengan kanan. Jika ada sisa itu mengembalikannya sebagai desimal. Jika dibagi secara merata, mengembalikan 0.

Jadi, jumlahkan apa yang kita miliki sejauh ini., (Num% 1) akan kembali:

0 bila dibagi secara merata ATAU #. ##### jika tidak

0 == salah.

[ANY_NUMBER_NOT_ZERO] == true.

Contoh: Boolean baru (0) salah Boolean baru palsu (12312.1231) benar

Alternatif lain: Seorang pengguna dapat mencoba mengembalikan nilai (num% 1)., Yang pada dasarnya akan mencapai hal yang sama. Karena return (0) salah dan return (1.213113) benar.

Tetapi saya ingin mengembalikan nilai boolean. Jadi sebagai jalan pintas untuk memaksa nilai menjadi boolean saya menambahkan! simbol sebelum itu.

Sebanyak mungkin yang tahu.,! berarti TIDAK. Tapi itu juga memaksa nilai menjadi boolean.

Sejak! symobol memaksa nilai menjadi boolean dan nilai itu terbalik. Saya menggunakan !! untuk memaksa nilai menjadi boolean dan membalikkan nilainya kembali ke nilai boolean aslinya.

Fungsi untuk memeriksa nomor adalah Desimal atau bilangan bulat

function IsDecimalExist(p_decimalNumber) {
    var l_boolIsExist = true;

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

    return l_boolIsExist;
}

Mungkin ini bekerja untukmu?

Menggunakan regex untuk memeriksa apakah ada koma di nomor tersebut, dan jika tidak ada, maka itu akan menambahkan koma dan garis.

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

Gunakan berikut ini jika nilainya string (misalnya dari <input):

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

Saya menambahkan .toString()ke lantai untuk membuatnya berfungsi juga untuk kasus-kasus ketika value == "1."(diakhiri dengan pemisah desimal atau string lain). Juga Math.floorselalu mengembalikan beberapa nilai sehingga .toString()tidak pernah gagal.