Làm cách nào để kiểm tra xem một số là float hay số nguyên?

Làm thế nào để tìm thấy một số là floathay integer?

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

kiểm tra phần còn lại khi chia cho 1:

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

Nếu bạn không biết rằng đối số là một số bạn cần hai bài kiểm tra:

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

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

Cập nhật 2019 5 năm sau khi câu trả lời này được viết, một giải pháp đã được chuẩn hóa trong ECMA Script 2015. Giải pháp đó được đề cập trong câu trả lời này .

Hãy thử các hàm này để kiểm tra xem một giá trị có phải là một giá trị nguyên thủy không có phần phân số hay không và nằm trong giới hạn kích thước của những gì có thể được biểu diễn dưới dạng một số nguyên chính xác.

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

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

Tại sao không phải là một cái gì đó như thế này:

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

Có một phương thức được gọi Number.isInteger()là hiện đang được triển khai trong mọi thứ trừ IE. MDN cũng cung cấp một polyfill cho các trình duyệt khác:

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

Tuy nhiên, đối với hầu hết các trường hợp sử dụng, bạn nên sử dụng Number.isSafeInteger nó để kiểm tra xem giá trị đó có cao / thấp đến mức bất kỳ vị trí thập phân nào cũng sẽ bị mất hay không. MDN cũng có một polyfil cho điều này. (Bạn cũng cần isIntegerpollyfill ở trên.)

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

Bạn có thể sử dụng một biểu thức chính quy đơn giản:

function isInt(value) {

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

    return er.test(value);
}

Hoặc bạn có thể sử dụng các chức năng dưới đây, theo nhu cầu của bạn. Chúng được phát triển bởi Dự án PHPJS .

is_int() => Kiểm tra xem loại biến có phải là số nguyên không và nội dung của nó có phải là số nguyên không

is_float() => Kiểm tra xem loại biến là float và nếu nội dung của nó là float

ctype_digit() => Kiểm tra xem loại biến có phải là chuỗi không và nếu nội dung của nó chỉ có các chữ số thập phân

Cập nhật 1

Bây giờ nó cũng kiểm tra số âm, cảm ơn vì bình luận của @ChrisBartley !

Dưới đây là các hàm hiệu quả để kiểm tra xem giá trị là số hay có thể được chuyển đổi an toàn thành số:

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

Và đối với số nguyên (sẽ trả về false nếu giá trị là float):

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

Hiệu quả ở đây là parseInt (hoặc parseNumber) được tránh khi giá trị đã là một số. Cả hai hàm phân tích luôn luôn chuyển đổi thành chuỗi trước và sau đó cố gắng phân tích chuỗi đó, điều này sẽ gây lãng phí nếu giá trị đã là một số.

Cảm ơn các bài viết khác ở đây đã cung cấp thêm ý tưởng để tối ưu hóa!

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

làm việc cho tất cả các trường hợp.

Như những người khác đã đề cập, bạn chỉ có gấp đôi trong JS. Vậy làm thế nào để bạn xác định một số là một số nguyên? Chỉ cần kiểm tra xem số làm tròn có bằng chính nó không:

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

Cái này thì sao?

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

Đây là những gì tôi sử dụng cho số nguyên:

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

Ngắn, đẹp :) Hoạt động mọi lúc. Đây là những gì David Flanagan gợi ý nếu tôi không nhầm.

Nó thực sự phụ thuộc vào những gì bạn muốn đạt được. Nếu bạn muốn "mô phỏng" các ngôn ngữ được gõ mạnh thì tôi khuyên bạn không nên thử. Như những người khác đã đề cập, tất cả các số có cùng một đại diện (cùng loại).

Sử dụng một cái gì đó giống như Claudiu cung cấp:

isInteger( 1.0 ) -> đúng

Điều này có vẻ tốt đối với lẽ thường, nhưng trong một cái gì đó như C, bạn sẽ nhận được false

Bất kỳ số Float nào có phần thập phân bằng 0 (ví dụ 1.0, 12.00, 0.0) đều được truyền hoàn toàn sang Integer, do đó không thể kiểm tra xem chúng có phải là Float hay không.

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

Nó thực sự không cần phải quá phức tạp. Giá trị số của các tương đương parseFloat () và parseInt () của một số nguyên sẽ giống nhau. Vì vậy, bạn có thể làm như vậy:

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

Sau đó

if (isInt(x)) // do work

Điều này cũng sẽ cho phép kiểm tra chuỗi và do đó không nghiêm ngặt. Nếu muốn một giải pháp loại mạnh (aka, sẽ không hoạt động với chuỗi):

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

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

Không có trường hợp nào việc này không thực hiện được.

ĐÂY LÀ MÃ CUỐI CÙNG ĐỂ KIỂM TRA CẢ HAI VÀ NỀN

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

HOẶC LÀ

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

Nó đơn giản như:

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

Hãy thử điều này trong bảng điều khiển:

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!

Điều này làm bối rối rất nhiều người. Bất cứ khi nào một cái gì đó là 0, nó không còn nổi nữa. Đó là một số nguyên. Hoặc bạn chỉ có thể gọi nó là "một thứ số" vì không có sự phân biệt nghiêm ngặt như hồi đó trong C. Thời xưa tốt đẹp.

Về cơ bản, tất cả những gì bạn có thể làm là kiểm tra số nguyên chấp nhận thực tế rằng 1.000 là số nguyên.

Lưu ý bên thú vị

Đã có một bình luận về những con số khổng lồ. Số lượng lớn có nghĩa là KHÔNG có vấn đề cho phương pháp này; Bất cứ khi nào parseInt không thể xử lý số (vì nó quá lớn), nó sẽ trả về một cái gì đó khác với giá trị thực tế để kiểm tra sẽ trả về SAI. Đây là một điều tốt bởi vì nếu bạn coi một cái gì đó là "số", bạn thường mong đợi JS có thể tính toán với nó - vì vậy, có, số lượng bị hạn chế và parseInt sẽ xem xét điều này , để đưa nó theo cách này.

Thử cái này:

<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>

Trong trình duyệt của tôi (IE8), điều này trả về "a là ok; b fail", điều này chính xác là do số lượng rất lớn trong b. Giới hạn có thể khác nhau nhưng tôi đoán 20 chữ số "nên là đủ cho bất cứ ai", để trích dẫn một cổ điển :)

Giải pháp này đã làm việc cho tôi.

<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>

Đối với số nguyên tôi sử dụng này

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

Trong tập lệnh java, tất cả các số đều internally 64 bit floating pointgiống như gấp đôi trong java. Không có các loại khác nhau trong javascript, tất cả được thể hiện theo loại number. Do đó bạn sẽ không thể instanceofkiểm tra. Tuy nhiên, bạn có thể sử dụng các giải pháp trên được đưa ra để tìm hiểu xem đó có phải là một số phân số không. các nhà thiết kế kịch bản java cảm thấy với một loại duy nhất họ có thể tránh được nhiều lỗi truyền kiểu.

Đôi khi, các đối tượng Số không cho phép bạn sử dụng trực tiếp toán tử mod (%), nếu bạn gặp phải trường hợp đó, bạn có thể sử dụng giải pháp này.

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

Thử một số câu trả lời ở đây tôi đã kết thúc việc viết giải pháp này. Điều này cũng hoạt động với các số bên trong một chuỗi.

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

Điều này có thể không hiệu quả như câu trả lời%, điều này ngăn bạn trước tiên phải chuyển đổi thành một chuỗi, nhưng tôi chưa thấy ai đăng nó, vì vậy đây là một tùy chọn khác nên hoạt động tốt:

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

Đối với những người tò mò, sử dụng Benchmark.js tôi đã kiểm tra các câu trả lời được bình chọn nhiều nhất (và câu trả lời được đăng ngày hôm nay) trên bài đăng này, đây là kết quả của tôi:

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

Đây là mã của tôi. Nó kiểm tra để đảm bảo rằng nó không phải là một chuỗi rỗng (nếu không sẽ vượt qua) và sau đó chuyển đổi nó thành định dạng số. Bây giờ, tùy thuộc vào việc bạn muốn '1.1' bằng 1.1, điều này có thể hoặc không phải là điều bạn đang tìm kiếm.

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;

};

Tôi thích hàm nhỏ này, sẽ trả về true cho cả số nguyên dương và số âm:

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

Điều này hoạt động vì 1 hoặc "1" trở thành "1.0", nghĩa làNaN () trả về false (sau đó chúng ta phủ định và trả về), nhưng 1.0 hoặc "1.0" trở thành "1.0.0", trong khi "chuỗi" trở thành "chuỗi". 0 ", không phải số nào trong số đó là số, vì vậy isNaN () trả về false (và, một lần nữa, bị phủ định).

Nếu bạn chỉ muốn số nguyên dương, có biến thể này:

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

hoặc, đối với số nguyên âm:

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

isPositiveInt () hoạt động bằng cách di chuyển chuỗi số được nối trước giá trị cần kiểm tra. Ví dụ: isPositiveInt (1) dẫn đến isNaN () đánh giá "01", đánh giá sai. Trong khi đó, kết quả isPositiveInt (-1) trong isNaN () đánh giá "0-1", đánh giá đúng. Chúng tôi phủ nhận giá trị trả lại và điều đó cho chúng tôi những gì chúng tôi muốn. isNegativeInt () hoạt động tương tự, nhưng không phủ nhận giá trị trả về của isNaN ().

Biên tập:

Việc triển khai ban đầu của tôi cũng sẽ trả về true trên mảng và chuỗi rỗng. Doe thực hiện này không có khiếm khuyết đó. Nó cũng có lợi ích là trả về sớm nếu val không phải là một chuỗi hoặc số hoặc nếu đó là một chuỗi rỗng, làm cho nó nhanh hơn trong những trường hợp này. Bạn có thể sửa đổi thêm bằng cách thay thế hai mệnh đề đầu tiên bằng

typeof(val) != "number"

nếu bạn chỉ muốn khớp các số bằng chữ (và không phải chuỗi)

Biên tập:

Tôi chưa thể đăng bình luận, vì vậy tôi đang thêm câu này vào câu trả lời của mình. Điểm chuẩn được đăng bởi @Asok là rất nhiều thông tin; tuy nhiên, hàm nhanh nhất không phù hợp với các yêu cầu, vì nó cũng trả về TRUE cho các float, mảng, booleans và chuỗi rỗng.

Tôi đã tạo bộ kiểm tra sau để kiểm tra từng hàm, thêm câu trả lời của tôi vào danh sách (hàm 8, phân tích cú pháp chuỗi và hàm 9, không):

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

Tôi cũng chạy lại điểm chuẩn với chức năng # 8 được thêm vào danh sách. Tôi sẽ không đăng kết quả, vì họ hơi lúng túng (ví dụ: chức năng đó KHÔNG nhanh) ...

Kết quả (được rút ngắn - Tôi đã xóa các thử nghiệm thành công, vì kết quả đầu ra khá dài) như sau:

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!

Tôi đã để lại các lỗi và bạn có thể thấy mỗi hàm bị lỗi ở đâu và các phép thử (chuỗi) '#' để bạn có thể thấy cách mỗi hàm xử lý các giá trị nguyên và dấu phẩy trong các chuỗi, vì một số có thể muốn các phân tích này được phân tách thành số và một số có thể không.

Trong số 10 chức năng được thử nghiệm, những chức năng thực sự phù hợp với yêu cầu của OP là [1,3,5,6,8,9]

Tiến hành xác nhận thả nổi:

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

Tiến hành xác nhận số nguyên:

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

Hy vọng điều này có thể hữu ích.

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

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

Bạn có thể thêm typeof a === 'number'nếu bạn muốn loại trừ chuỗi.