Bagaimana cara saya memeriksa bahwa angka itu mengambang atau bilangan bulat?

Bagaimana menemukan nomor itu floatatau integer?

1.25 --> float  
1 --> integer  
0 --> integer  
0.25 --> float

periksa sisa ketika membaginya dengan 1:

function isInt(n) {
   return n % 1 === 0;
}

Jika Anda tidak tahu bahwa argumennya adalah angka, Anda perlu dua tes:

function isInt(n){
    return Number(n) === n && n % 1 === 0;
}

function isFloat(n){
    return Number(n) === n && n % 1 !== 0;
}

Pembaruan 2019 5 tahun setelah jawaban ini ditulis, sebuah solusi distandarisasi dalam ECMA Script 2015. Solusi itu tercakup dalam jawaban ini .

Coba fungsi-fungsi ini untuk menguji apakah suatu nilai merupakan angka primitif angka yang tidak memiliki bagian fraksional dan berada dalam batas ukuran dari apa yang dapat direpresentasikan sebagai integer yang tepat.

function isFloat(n) {
    return n === +n && n !== (n|0);
}

function isInteger(n) {
    return n === +n && n === (n|0);
}

Kenapa tidak seperti ini:

var isInt = function(n) { return parseInt(n) === n };

Ada metode yang disebut Number.isInteger()yang saat ini diimplementasikan dalam segala hal kecuali IE. MDN juga menyediakan polyfill untuk browser lain:

Number.isInteger = Number.isInteger || function(value) {
  return typeof value === 'number' && 
    isFinite(value) && 
    Math.floor(value) === value;
};

Namun, untuk sebagian besar kasus penggunaan, Anda lebih baik menggunakan Number.isSafeInteger yang juga memeriksa apakah nilainya sangat tinggi / rendah sehingga tempat desimal akan hilang pula. MDN memiliki polyfil untuk ini juga. (Anda juga memerlukan isIntegerpollyfill di atas.)

if (!Number.MAX_SAFE_INTEGER) {
    Number.MAX_SAFE_INTEGER = 9007199254740991; // Math.pow(2, 53) - 1;
}
Number.isSafeInteger = Number.isSafeInteger || function (value) {
   return Number.isInteger(value) && Math.abs(value) <= Number.MAX_SAFE_INTEGER;
};

Anda dapat menggunakan ekspresi reguler sederhana:

function isInt(value) {

    var er = /^-?[0-9]+$/;

    return er.test(value);
}

Atau Anda dapat menggunakan fungsi di bawah ini juga, sesuai dengan kebutuhan Anda. Mereka dikembangkan oleh Proyek PHPJS .

is_int() => Periksa apakah tipe variabel bilangan bulat dan apakah isinya bilangan bulat

is_float() => Periksa apakah tipe variabel float dan apakah isinya float

ctype_digit() => Periksa apakah tipe variabel adalah string dan jika kontennya hanya memiliki angka desimal

Perbarui 1

Sekarang ia memeriksa angka negatif juga, terima kasih atas komentar @ChrisBartley !

Berikut adalah fungsi-fungsi efisien yang memeriksa apakah nilainya angka atau dapat dikonversi dengan aman ke angka:

function isNumber(value) {
    if ((undefined === value) || (null === value)) {
        return false;
    }
    if (typeof value == 'number') {
        return true;
    }
    return !isNaN(value - 0);
}

Dan untuk bilangan bulat (akan mengembalikan false jika nilainya float):

function isInteger(value) {
    if ((undefined === value) || (null === value)) {
        return false;
    }
    return value % 1 == 0;
}

Efisiensi di sini adalah parseInt (atau parseNumber) dihindari ketika nilainya sudah berupa angka. Kedua fungsi parsing selalu mengkonversi ke string terlebih dahulu dan kemudian mencoba untuk mengurai string itu, yang akan sia-sia jika nilainya sudah berupa angka.

Terima kasih untuk posting lain di sini untuk memberikan ide lebih lanjut untuk optimasi!

function isInteger(x) { return typeof x === "number" && isFinite(x) && Math.floor(x) === x; }
function isFloat(x) { return !!(x % 1); }

// give it a spin

isInteger(1.0);        // true
isFloat(1.0);          // false
isFloat(1.2);          // true
isInteger(1.2);        // false
isFloat(1);            // false
isInteger(1);          // true    
isFloat(2e+2);         // false
isInteger(2e+2);       // true
isFloat('1');          // false
isInteger('1');        // false
isFloat(NaN);          // false
isInteger(NaN);        // false
isFloat(null);         // false
isInteger(null);       // false
isFloat(undefined);    // false
isInteger(undefined);  // false

function isInt(n) 
{
    return n != "" && !isNaN(n) && Math.round(n) == n;
}
function isFloat(n){
    return n != "" && !isNaN(n) && Math.round(n) != n;
}

berfungsi untuk semua kasus.

Seperti yang disebutkan lainnya, Anda hanya memiliki ganda di JS. Jadi, bagaimana Anda mendefinisikan angka menjadi bilangan bulat? Cukup periksa apakah angka yang dibulatkan sama dengan dirinya sendiri:

function isInteger(f) {
    return typeof(f)==="number" && Math.round(f) == f;
}
function isFloat(f) { return typeof(f)==="number" && !isInteger(f); }

Bagaimana dengan yang ini?

isFloat(num) {
    return typeof num === "number" && !Number.isInteger(num);
}

Inilah yang saya gunakan untuk bilangan bulat:

Math.ceil(parseFloat(val)) === val

Pendek, bagus :) Berfungsi sepanjang waktu. Inilah yang disarankan David Flanagan jika saya tidak salah.

Itu sangat tergantung pada apa yang ingin Anda capai. Jika Anda ingin "meniru" bahasa yang sangat diketik maka saya sarankan Anda untuk tidak mencoba. Seperti yang lain disebutkan semua angka memiliki representasi yang sama (tipe yang sama).

Menggunakan sesuatu seperti Claudiu disediakan:

isInteger( 1.0 ) -> benar

yang terlihat bagus untuk akal sehat, tetapi dalam sesuatu seperti C Anda akan dapatkan false

Setiap angka Float dengan bagian desimal nol (mis. 1.0, 12.00, 0.0) secara implisit dilemparkan ke Integer, jadi tidak mungkin untuk memeriksa apakah angka itu Float atau tidak.

!!(24%1) // false
!!(24.2%1) // true

Itu benar-benar tidak harus terlalu rumit. Nilai numerik dari ekuivalen parseFloat () dan parseInt () akan sama. Dengan demikian Anda dapat melakukannya seperti ini:

function isInt(value){ 
    return (parseFloat(value) == parseInt(value)) && !isNaN(value);
}

Kemudian

if (isInt(x)) // do work

Ini juga akan memungkinkan untuk pemeriksaan string dan karenanya tidak ketat. Jika ingin solusi tipe yang kuat (alias, tidak akan bekerja dengan string):

function is_int(value){ return !isNaN(parseInt(value * 1) }

var isInt = function (n) { return n === (n | 0); };

Belum ada kasus di mana ini tidak berhasil.

INI ADALAH KODE FINAL UNTUK MEMERIKSA KEDUA INT DAN FLOAT

function isInt(n) { 
   if(typeof n == 'number' && Math.Round(n) % 1 == 0) {
       return true;
   } else {
       return false;
   }
} 

ATAU

function isInt(n) {   
   return typeof n == 'number' && Math.Round(n) % 1 == 0;   
}   

function isInteger(n) {
   return ((typeof n==='number')&&(n%1===0));
}

function isFloat(n) {
   return ((typeof n==='number')&&(n%1!==0));
}

function isNumber(n) {
   return (typeof n==='number');
}

Sederhana seperti:

if( n === parseInt(n) ) ...

Coba ini di konsol:

x=1;
x===parseInt(x); // true
x="1";
x===parseInt(x); // false
x=1.1;
x===parseInt(x); // false, obviously

// BUT!

x=1.0;
x===parseInt(x); // true, because 1.0 is NOT a float!

Ini membingungkan banyak orang. Kapan pun ada sesuatu .0, itu bukan pelampung lagi. Itu bilangan bulat. Atau Anda bisa menyebutnya "hal numerik" karena tidak ada perbedaan yang ketat seperti dulu di C. Masa lalu yang baik.

Jadi pada dasarnya, yang dapat Anda lakukan adalah memeriksa bilangan bulat menerima kenyataan bahwa 1.000 adalah bilangan bulat.

Catatan pinggir yang menarik

Ada komentar tentang jumlah besar. Angka besar berarti TIDAK masalah untuk pendekatan ini; setiap kali parseInt tidak dapat menangani angka (karena terlalu besar) itu akan mengembalikan sesuatu yang lain dari nilai aktual sehingga tes akan mengembalikan SALAH. Ini adalah hal yang baik karena jika Anda menganggap sesuatu sebagai "angka", Anda biasanya mengharapkan JS untuk dapat menghitungnya - jadi ya, jumlahnya terbatas dan parseInt akan mempertimbangkan ini , dengan kata lain.

Coba ini:

<script>

var a = 99999999999999999999;
var b = 999999999999999999999; // just one more 9 will kill the show!
var aIsInteger = (a===parseInt(a))?"a is ok":"a fails";
var bIsInteger = (b===parseInt(b))?"b is ok":"b fails";
alert(aIsInteger+"; "+bIsInteger);

</script>

Di browser saya (IE8) ini mengembalikan "a is ok; b gagal" yang persis karena jumlah besar di b. Batasnya mungkin bervariasi tetapi saya kira 20 digit "seharusnya cukup untuk siapa saja", mengutip klasik :)

Solusi ini berhasil untuk saya.

<html>
<body>
  <form method="post" action="#">
    <input type="text" id="number_id"/>
    <input type="submit" value="send"/>
  </form>
  <p id="message"></p>
  <script>
    var flt=document.getElementById("number_id").value;
    if(isNaN(flt)==false && Number.isInteger(flt)==false)
    {
     document.getElementById("message").innerHTML="the number_id is a float ";
    }
   else 
   {
     document.getElementById("message").innerHTML="the number_id is a Integer";
   }
  </script>
</body>
</html>

Untuk bilangan bulat saya menggunakan ini

function integer_or_null(value) {
    if ((undefined === value) || (null === value)) {
        return null;
    }
    if(value % 1 != 0) {
        return null;
    }
    return value;
}

Dalam skrip java semua angka internally 64 bit floating pointsama dengan ganda di java. Tidak ada tipe berbeda dalam javascript, semua diwakili oleh tipe number. Karenanya kamu tidak akan bisa melakukan instanceofcek. Namun Anda dapat menggunakan solusi di atas yang diberikan untuk mencari tahu apakah itu angka pecahan. perancang skrip java merasa dengan satu tipe mereka dapat menghindari berbagai jenis kesalahan cor.

Beberapa kali Objek angka tidak memungkinkan Anda untuk menggunakan langsung operator mod (%), jika Anda menghadapi kasing itu, Anda dapat menggunakan solusi ini.

if(object instanceof Number ){
   if( ((Number) object).doubleValue() % 1 == 0 ){
      //your object is an integer
   }
   else{
      //your object is a double
   }
}

Mencoba beberapa jawaban di sini saya akhirnya menulis solusi ini. Ini juga berfungsi dengan angka di dalam string.

function isInt(number) {
    if(!/^["|']{0,1}[-]{0,1}\d{0,}(\.{0,1}\d+)["|']{0,1}$/.test(number)) return false;
    return !(number - parseInt(number));
}

function isFloat(number) {
    if(!/^["|']{0,1}[-]{0,1}\d{0,}(\.{0,1}\d+)["|']{0,1}$/.test(number)) return false;
    return number - parseInt(number) ? true : false;
}

    var tests = {
        'integer' : 1,
        'float' : 1.1,
        'integerInString' : '5',
        'floatInString' : '5.5',
        'negativeInt' : -345,
        'negativeFloat' : -34.98,
        'negativeIntString' : '-45',
        'negativeFloatString' : '-23.09',
        'notValidFalse' : false,
        'notValidTrue' : true,
        'notValidString' : '45lorem',
        'notValidStringFloat' : '4.5lorem',
        'notValidNan' : NaN,
        'notValidObj' : {},
        'notValidArr' : [1,2],
    };

    function isInt(number) {
        if(!/^["|']{0,1}[-]{0,1}\d{0,}(\.{0,1}\d+)["|']{0,1}$/.test(number)) return false;
        return !(number - parseInt(number));
    }
    
    function isFloat(number) {
        if(!/^["|']{0,1}[-]{0,1}\d{0,}(\.{0,1}\d+)["|']{0,1}$/.test(number)) return false;
        return number - parseInt(number) ? true : false;
    }

    function testFunctions(obj) {
        var keys = Object.keys(obj);
        var values = Object.values(obj);

        values.forEach(function(element, index){
            console.log(`Is ${keys[index]} (${element}) var an integer? ${isInt(element)}`);
            console.log(`Is ${keys[index]} (${element}) var a float? ${isFloat(element)}`);
        });
    }

    testFunctions(tests);

Ini mungkin tidak sebagus% jawaban, yang mencegah Anda dari harus mengonversi ke string terlebih dahulu, tetapi saya belum melihat orang mempostingnya, jadi inilah opsi lain yang seharusnya berfungsi:

function isInteger(num) {
    return num.toString().indexOf('.') === -1;
}

Bagi mereka yang penasaran, menggunakan Benchmark.js Saya menguji jawaban yang paling banyak dipilih (dan yang diposting hari ini) pada posting ini, berikut adalah hasil saya:

var n = -10.4375892034758293405790;
var suite = new Benchmark.Suite;
suite
    // kennebec
    .add('0', function() {
        return n % 1 == 0;
    })
    // kennebec
    .add('1', function() {
        return typeof n === 'number' && n % 1 == 0;
    })
    // kennebec
    .add('2', function() {
        return typeof n === 'number' && parseFloat(n) == parseInt(n, 10) && !isNaN(n);
    })

    // Axle
    .add('3', function() {
        return n.toString().indexOf('.') === -1;
    })

    // Dagg Nabbit
    .add('4', function() {
        return n === +n && n === (n|0);
    })

    // warfares
    .add('5', function() {
        return parseInt(n) === n;
    })

    // Marcio Simao
    .add('6', function() {
        return /^-?[0-9]+$/.test(n.toString());
    })

    // Tal Liron
    .add('7', function() {
        if ((undefined === n) || (null === n)) {
            return false;
        }
        if (typeof n == 'number') {
            return true;
        }
        return !isNaN(n - 0);
    });

// Define logs and Run
suite.on('cycle', function(event) {
    console.log(String(event.target));
}).on('complete', function() {
    console.log('Fastest is ' + this.filter('fastest').pluck('name'));
}).run({ 'async': true });

0 x 12,832,357 ops/sec ±0.65% (90 runs sampled)
1 x 12,916,439 ops/sec ±0.62% (95 runs sampled)
2 x 2,776,583 ops/sec ±0.93% (92 runs sampled)
3 x 10,345,379 ops/sec ±0.49% (97 runs sampled)
4 x 53,766,106 ops/sec ±0.66% (93 runs sampled)
5 x 26,514,109 ops/sec ±2.72% (93 runs sampled)
6 x 10,146,270 ops/sec ±2.54% (90 runs sampled)
7 x 60,353,419 ops/sec ±0.35% (97 runs sampled)

Fastest is 7 Tal Liron

Ini kode saya. Ia memeriksa untuk memastikan itu bukan string kosong (yang jika tidak akan lulus) dan kemudian mengubahnya menjadi format numerik. Sekarang, tergantung pada apakah Anda ingin '1,1' sama dengan 1,1, ini mungkin atau tidak yang Anda cari.

var isFloat = function(n) {
    n = n.length > 0 ? Number(n) : false;
    return (n === parseFloat(n));
};
var isInteger = function(n) {
    n = n.length > 0 ? Number(n) : false;
    return (n === parseInt(n));
};

var isNumeric = function(n){

   if(isInteger(n) || isFloat(n)){
        return true;
   }
   return false;

};

Saya suka fungsi kecil ini, yang akan mengembalikan true untuk bilangan bulat positif dan negatif:

function isInt(val) {
    return ["string","number"].indexOf(typeof(val)) > -1 && val !== '' && !isNaN(val+".0");
}

Ini berfungsi karena 1 atau "1" menjadi "1.0", yang isNaN () mengembalikan false on (yang kemudian kita negasikan dan kembali), tetapi 1.0 atau "1.0" menjadi "1.0.0", sedangkan "string" menjadi "string. 0 ", keduanya bukan angka, jadi isNaN () mengembalikan false (dan, sekali lagi, dinegasikan).

Jika Anda hanya ingin bilangan bulat positif, ada varian ini:

function isPositiveInt(val) {
    return ["string","number"].indexOf(typeof(val)) > -1 && val !== '' && !isNaN("0"+val);
}

atau, untuk bilangan bulat negatif:

function isNegativeInt(val) {
    return `["string","number"].indexOf(typeof(val)) > -1` && val !== '' && isNaN("0"+val);
}

isPositiveInt () bekerja dengan menggerakkan string numerik mendahului nilai yang akan diuji. Sebagai contoh, isPositiveInt (1) menghasilkan isNaN () mengevaluasi "01", yang mengevaluasi false. Sementara itu, isPositiveInt (-1) menghasilkan isNaN () mengevaluasi "0-1", yang mengevaluasi true. Kami meniadakan nilai kembali dan itu memberi kami apa yang kami inginkan. isNegativeInt () bekerja dengan cara yang sama, tetapi tanpa meniadakan nilai kembali isNaN ().

Edit:

Implementasi asli saya juga akan mengembalikan true pada array dan string kosong. Implementasi ini tidak memiliki cacat itu. Ini juga memiliki keuntungan untuk kembali lebih awal jika val bukan string atau angka, atau jika string kosong, membuatnya lebih cepat dalam kasus ini. Anda dapat memodifikasinya lebih lanjut dengan mengganti dua klausa pertama dengan

typeof(val) != "number"

jika Anda hanya ingin mencocokkan angka literal (dan bukan string)

Edit:

Saya belum dapat memposting komentar, jadi saya menambahkan ini ke jawaban saya. Patokan yang diposting oleh @ Asok sangat informatif; Namun, fungsi tercepat tidak sesuai dengan persyaratan, karena ia juga mengembalikan TRUE untuk float, array, booleans, dan string kosong.

Saya membuat suite tes berikut untuk menguji setiap fungsi, menambahkan jawaban saya ke daftar, juga (fungsi 8, yang mem-parsing string, dan fungsi 9, yang tidak):

funcs = [
    function(n) {
        return n % 1 == 0;
    },
    function(n) {
        return typeof n === 'number' && n % 1 == 0;
    },
    function(n) {
        return typeof n === 'number' && parseFloat(n) == parseInt(n, 10) && !isNaN(n);
    },
    function(n) {
        return n.toString().indexOf('.') === -1;
    },
    function(n) {
        return n === +n && n === (n|0);
    },
    function(n) {
        return parseInt(n) === n;
    },
    function(n) {
        return /^-?[0-9]+$/.test(n.toString());
    },
    function(n) {
        if ((undefined === n) || (null === n)) {
            return false;
        }
        if (typeof n == 'number') {
            return true;
        }
        return !isNaN(n - 0);
    },
    function(n) {
        return ["string","number"].indexOf(typeof(n)) > -1 && n !== '' && !isNaN(n+".0");
    }
];
vals = [
    [1,true],
    [-1,true],
    [1.1,false],
    [-1.1,false],
    [[],false],
    [{},false],
    [true,false],
    [false,false],
    [null,false],
    ["",false],
    ["a",false],
    ["1",null],
    ["-1",null],
    ["1.1",null],
    ["-1.1",null]
];

for (var i in funcs) {
    var pass = true;
    console.log("Testing function "+i);
    for (var ii in vals) {
        var n = vals[ii][0];
        var ns;
        if (n === null) {
            ns = n+"";
        } else {
            switch (typeof(n)) {
                case "string":
                    ns = "'" + n + "'";
                    break;
                case "object":
                    ns = Object.prototype.toString.call(n);
                    break;
                default:
                    ns = n;
            }
            ns = "("+typeof(n)+") "+ns;
        }

        var x = vals[ii][1];
        var xs;
        if (x === null) {
            xs = "(ANY)";
        } else {
            switch (typeof(x)) {
                case "string":
                    xs = "'" + n + "'";
                    break;
                case "object":
                    xs = Object.prototype.toString.call(x);
                    break;
                default:
                    xs = x;
            }
            xs = "("+typeof(x)+") "+xs;
        }

        var rms;
        try {
            var r = funcs[i](n);
            var rs;
            if (r === null) {
                rs = r+"";
            } else {
                switch (typeof(r)) {
                    case "string":
                        rs = "'" + r + "'";
                        break;
                    case "object":
                        rs = Object.prototype.toString.call(r);
                        break;
                    default:
                        rs = r;
                }
                rs = "("+typeof(r)+") "+rs;
            }

            var m;
            var ms;
            if (x === null) {
                m = true;
                ms = "N/A";
            } else if (typeof(x) == 'object') {
                m = (xs === rs);
                ms = m;
            } else {
                m = (x === r);
                ms = m;
            }
            if (!m) {
                pass = false;
            }
            rms = "Result: "+rs+", Match: "+ms;
        } catch (e) {
            rms = "Test skipped; function threw exception!"
        }

        console.log("    Value: "+ns+", Expect: "+xs+", "+rms);
    }
    console.log(pass ? "PASS!" : "FAIL!");
}

Saya juga memutar ulang patokan dengan fungsi # 8 ditambahkan ke daftar. Saya tidak akan memposting hasilnya, karena agak memalukan (mis. Fungsi itu TIDAK cepat) ...

Hasil (singkat - saya menghapus tes yang sukses, karena hasilnya cukup panjang) adalah sebagai berikut:

Testing function 0
Value: (object) [object Array], Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (boolean) true, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (boolean) false, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: null, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (string) '', Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (string) '1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
FAIL!

Testing function 1
Value: (string) '1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!

Testing function 2
Value: (string) '1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!

Testing function 3
Value: (object) true, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (object) false, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (boolean) [object Array], Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (boolean) [object Object], Expect: (boolean) false, Result: (boolean) true, Match: false
Value: null, Expect: (boolean) false, Test skipped; function threw exception!
Value: (string) '', Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (string) 'a', Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (string) '1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
FAIL!

Testing function 4
Value: (string) '1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!

Testing function 5
Value: (string) '1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!

Testing function 6
Value: null, Expect: (boolean) false, Test skipped; function threw exception!
Value: (string) '1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!

Testing function 7
Value: (number) 1.1, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (number) -1.1, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (object) true, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (boolean) [object Array], Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (boolean) [object Object], Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (string) '', Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (string) '1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) true, Match: N/A
FAIL!

Testing function 8
Value: (string) '1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!

Testing function 9
Value: (string) '1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!

Saya telah meninggalkan kegagalan sehingga Anda dapat melihat di mana setiap fungsi gagal, dan (string) '#' menguji sehingga Anda dapat melihat bagaimana setiap fungsi menangani nilai integer dan float dalam string, karena beberapa mungkin ingin ini diuraikan sebagai angka dan beberapa mungkin tidak.

Dari 10 fungsi yang diuji, yang benar-benar sesuai dengan persyaratan OP adalah [1,3,5,6,8,9]

Ketentuan untuk validasi mengambang:

if (lnk.value == +lnk.value && lnk.value != (lnk.value | 0)) 

Condtion for Integer validation:

if (lnk.value == +lnk.value && lnk.value == (lnk.value | 0)) 

Semoga ini bisa membantu.

function int(a) {
  return a - a === 0 && a.toString(32).indexOf('.') === -1
}

function float(a) {
  return a - a === 0 && a.toString(32).indexOf('.') !== -1
}

Anda dapat menambahkan typeof a === 'number'jika Anda ingin mengecualikan string.