ฉันจะตรวจสอบว่าตัวเลขเป็นทศนิยมหรือจำนวนเต็มได้อย่างไร

จะหาได้อย่างไรว่าเป็นจำนวนfloatหรือinteger?

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

ตรวจสอบส่วนที่เหลือเมื่อหารด้วย 1:

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

หากคุณไม่ทราบว่าอาร์กิวเมนต์เป็นตัวเลขคุณต้องทำการทดสอบสองครั้ง:

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

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

อัปเดต 2019 5 ปีหลังจากที่เขียนคำตอบนี้โซลูชันได้มาตรฐานใน ECMA Script 2015 โซลูชันดังกล่าวครอบคลุมอยู่ในคำตอบนี้

ลองใช้ฟังก์ชันเหล่านี้เพื่อทดสอบว่าค่าเป็นค่าดั้งเดิมที่ไม่มีส่วนที่เป็นเศษส่วนหรือไม่และอยู่ภายในขีด จำกัด ขนาดของสิ่งที่สามารถแสดงเป็นจำนวนเต็มได้

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

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

ทำไมไม่เป็นเช่นนี้:

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

มีวิธีการที่เรียกว่าNumber.isInteger()ซึ่งปัจจุบันมีการใช้งานในทุกสิ่งยกเว้น IE MDNยังให้บริการ polyfill สำหรับเบราว์เซอร์อื่น ๆ :

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

อย่างไรก็ตามสำหรับกรณีการใช้งานส่วนใหญ่คุณจะดีกว่าการใช้Number.isSafeInteger ซึ่งจะตรวจสอบว่าค่าสูง / ต่ำจนตำแหน่งทศนิยมจะหายไปหรือไม่ MDNมี polyfil สำหรับสิ่งนี้เช่นกัน (คุณต้องมีisIntegerpollyfill ด้านบนด้วย)

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

คุณสามารถใช้นิพจน์ทั่วไปอย่างง่าย:

function isInt(value) {

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

    return er.test(value);
}

หรือคุณสามารถใช้ฟังก์ชั่นด้านล่างได้เช่นกันตามความต้องการของคุณ พวกเขาจะได้รับการพัฒนาโดยโครงการ PHPJS

is_int() => ตรวจสอบว่าประเภทตัวแปรเป็นจำนวนเต็มหรือไม่และเนื้อหานั้นเป็นจำนวนเต็มหรือไม่

is_float() => ตรวจสอบว่าประเภทตัวแปรลอยหรือไม่และเนื้อหาเป็นประเภทลอยหรือไม่

ctype_digit() => ตรวจสอบว่าประเภทตัวแปรเป็นสตริงหรือไม่และมีเนื้อหาเป็นเลขทศนิยมหรือไม่

อัปเดต 1

ตอนนี้ก็ตรวจสอบตัวเลขที่เป็นลบเช่นกันขอบคุณสำหรับความคิดเห็น @ChrisBartley !

นี่คือฟังก์ชันที่มีประสิทธิภาพที่ตรวจสอบว่าค่าเป็นตัวเลขหรือสามารถแปลงเป็นตัวเลขได้อย่างปลอดภัย :

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

และสำหรับจำนวนเต็ม (จะคืนค่าเท็จหากค่าเป็นทศนิยม):

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

ประสิทธิภาพที่นี่คือ parseInt (หรือ parseNumber) จะหลีกเลี่ยงเมื่อค่าเป็นตัวเลขอยู่แล้ว ฟังก์ชันการแยกวิเคราะห์ทั้งสองจะแปลงเป็นสตริงก่อนเสมอและพยายามแยกสตริงนั้นซึ่งจะเป็นการสิ้นเปลืองหากค่านั้นเป็นตัวเลขอยู่แล้ว

ขอบคุณที่โพสต์อื่น ๆ ที่นี่เพื่อให้ความคิดเพิ่มเติมสำหรับการเพิ่มประสิทธิภาพ!

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

ใช้ได้กับทุกกรณี

ตามที่คนอื่นพูดถึงคุณมีเพียงสองเท่าใน JS ดังนั้นคุณจะกำหนดจำนวนเป็นจำนวนเต็มได้อย่างไร เพียงตรวจสอบว่าหมายเลขที่ปัดเศษมีค่าเท่ากับตัวเองหรือไม่:

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

แล้วอันนี้ละ?

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

นี่คือสิ่งที่ฉันใช้สำหรับจำนวนเต็ม:

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

สั้นดี :) ใช้งานได้ตลอดเวลา นี่คือสิ่งที่ David Flanagan แนะนำถ้าฉันไม่ผิด

มันขึ้นอยู่กับสิ่งที่คุณต้องการบรรลุ หากคุณต้องการ "เลียนแบบ" ภาษาที่พิมพ์อย่างยิ่งแล้วฉันขอแนะนำให้คุณไม่ลอง ตามที่คนอื่น ๆ กล่าวถึงตัวเลขทั้งหมดมีการแสดงเหมือนกัน (ประเภทเดียวกัน)

ใช้บางอย่างเช่นClaudiu ที่จัดเตรียมไว้:

isInteger( 1.0 ) -> จริง

ซึ่งดูดีสำหรับสามัญสำนึก แต่ในบางสิ่งบางอย่างเช่น C คุณจะได้รับ false

หมายเลขโฟลตใด ๆ ที่มีส่วนทศนิยมเป็นศูนย์ (เช่น 1.0, 12.00, 0.0) จะถูกส่งไปยัง Integer โดยปริยายดังนั้นจึงไม่สามารถตรวจสอบได้ว่าเป็นโฟลตหรือไม่

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

มันไม่จำเป็นต้องซับซ้อนมากนัก ค่าตัวเลขของ parseFloat () และ parseInt () ที่เทียบเท่าของจำนวนเต็มจะเท่ากัน ดังนั้นคุณสามารถทำเช่นนั้น:

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

แล้วก็

if (isInt(x)) // do work

วิธีนี้จะอนุญาตให้มีการตรวจสอบสตริงและทำให้ไม่เข้มงวด หากต้องการโซลูชันประเภทที่รัดกุม (aka จะไม่ทำงานกับสตริง):

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

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

ยังไม่มีกรณีที่สิ่งนี้ไม่ได้ทำงาน

นี่คือรหัสสุดท้ายสำหรับการตรวจสอบทั้ง INT และการลอยตัว

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

หรือ

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

ง่ายเหมือน:

if( n === parseInt(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!

สิ่งนี้ทำให้ผู้คนสับสนมาก เมื่อใดก็ตามที่บางสิ่งบางอย่างเป็น. 0 มันจะไม่ลอยอีกต่อไป มันเป็นจำนวนเต็ม หรือคุณอาจเรียกมันว่า "สิ่งที่เป็นตัวเลข" เพราะไม่มีความแตกต่างที่เข้มงวดเหมือนย้อนกลับไปในยุคค.

โดยพื้นฐานแล้วสิ่งที่คุณทำได้คือตรวจสอบจำนวนเต็มที่ยอมรับความจริงที่ว่า 1,000 เป็นจำนวนเต็ม

ข้อความด้านที่น่าสนใจ

มีความคิดเห็นเกี่ยวกับคนจำนวนมาก จำนวนมากหมายถึงไม่มีปัญหาสำหรับวิธีการนี้ เมื่อใดก็ตามที่การแยกวิเคราะห์ไม่สามารถจัดการกับตัวเลข (เพราะมันใหญ่เกินไป) มันจะคืนค่าอย่างอื่นมากกว่าค่าจริงดังนั้นการทดสอบจะคืนค่า FALSE นี่เป็นสิ่งที่ดีเพราะถ้าคุณพิจารณาบางสิ่งบางอย่าง "จำนวน" คุณคาดหวังว่า JS จะสามารถคำนวณได้ - ดังนั้นใช่ตัวเลขมี จำกัด และการแยกวิเคราะห์จะนำสิ่งนี้มาพิจารณาด้วยวิธีนี้

ลองสิ่งนี้:

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

ในเบราว์เซอร์ของฉัน (IE8) สิ่งนี้จะส่งกลับ "a is ok; b failed" ซึ่งเป็นสิ่งที่เกิดขึ้นเพราะมีจำนวนมากใน b ขีด จำกัด อาจแตกต่างกัน แต่ฉันเดา 20 หลัก "ควรจะเพียงพอสำหรับทุกคน" เพื่อพูดคลาสสิก :)

วิธีนี้ใช้ได้ผลสำหรับฉัน

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

สำหรับจำนวนเต็มฉันใช้อันนี้

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

ในจาวาสคริปต์หมายเลขทั้งหมดนั้นinternally 64 bit floating pointเหมือนกับ double ใน java ไม่มีประเภทที่แตกต่างกันใน JavaScript numberมีทั้งหมดจะเป็นตัวแทนโดยแบ่งตามชนิด ดังนั้นคุณจะไม่สามารถinstanceofตรวจสอบได้ อย่างไรก็ตามคุณสามารถใช้วิธีแก้ไขปัญหาข้างต้นที่ให้มาเพื่อดูว่าเป็นเศษส่วนหรือไม่ นักออกแบบของจาวาสคริปต์รู้สึกกับประเภทเดียวที่พวกเขาสามารถหลีกเลี่ยงข้อผิดพลาดที่หล่อประเภท

บางครั้งจำนวนวัตถุไม่อนุญาตให้คุณใช้ตัวดำเนินการ mod (%) โดยตรงหากคุณเผชิญกับกรณีนั้นคุณสามารถใช้วิธีนี้

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

ลองคำตอบที่นี่ฉันลงเอยด้วยการเขียนโซลูชันนี้ ใช้ได้กับตัวเลขภายในสตริงด้วย

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

นี่อาจจะไม่ใช่ตัวแสดงคำตอบ% ซึ่งทำให้คุณไม่ต้องแปลงเป็นสตริงก่อน แต่ฉันยังไม่เคยเห็นใครโพสต์เลยดังนั้นนี่เป็นอีกตัวเลือกหนึ่งที่น่าจะใช้ได้ดี:

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

สำหรับผู้ที่สงสัยการใช้ Benchmark.js ฉันทดสอบคำตอบที่ได้รับการโหวตมากที่สุด (และโพสต์ที่โพสต์วันนี้) ในโพสต์นี้นี่คือผลลัพธ์ของฉัน:

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

นี่คือรหัสของฉัน มันตรวจสอบเพื่อให้แน่ใจว่ามันไม่ใช่สตริงว่างเปล่า (ซึ่งจะผ่าน) และจากนั้นแปลงเป็นรูปแบบตัวเลข ตอนนี้ขึ้นอยู่กับว่าคุณต้องการให้ '1.1' เท่ากับ 1.1 นี่อาจเป็นสิ่งที่คุณกำลังมองหาหรือไม่

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;

};

ฉันชอบฟังก์ชันเล็ก ๆ นี้ซึ่งจะคืนค่าจริงสำหรับทั้งจำนวนเต็มบวกและลบ:

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

สิ่งนี้ใช้งานได้เนื่องจาก 1 หรือ "1" กลายเป็น "1.0" ซึ่ง isNaN () ส่งคืน false บน (ซึ่งเราจะคัดค้านและส่งคืน) แต่ 1.0 หรือ "1.0" กลายเป็น "1.0.0" ในขณะที่ "string" กลายเป็น "สตริง 0 "ซึ่งไม่ใช่ตัวเลขดังนั้น isNaN () จะส่งกลับค่า false (และอีกครั้งจะถูกทำให้ไร้ผล)

หากคุณต้องการจำนวนเต็มบวกเท่านั้นมีตัวแปรนี้:

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

หรือสำหรับจำนวนเต็มลบ:

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

isPositiveInt () ทำงานโดยการย้ายสตริงตัวเลขที่ต่อกันไว้ข้างหน้าของค่าที่จะทดสอบ ตัวอย่างเช่น isPositiveInt (1) ให้ผลลัพธ์เป็น isNaN () ประเมิน "01" ซึ่งประเมินค่าเท็จ ในขณะเดียวกัน isPositiveInt (-1) ให้ผลลัพธ์เป็น isNaN () ประเมิน "0-1" ซึ่งประเมินค่าจริง เราปฏิเสธค่าส่งคืนและให้สิ่งที่เราต้องการ isNegativeInt () ทำงานในทำนองเดียวกัน แต่ไม่ส่งคืนค่า isNaN ()

แก้ไข:

การใช้งานดั้งเดิมของฉันก็จะกลับมาจริงในอาร์เรย์และสตริงที่ว่างเปล่า การใช้งานนี้ไม่มีข้อบกพร่องนั้น นอกจากนี้ยังมีประโยชน์ในการคืนค่าก่อนถ้า val ไม่ใช่สตริงหรือหมายเลขหรือถ้าเป็นสตริงว่างทำให้เร็วขึ้นในกรณีเหล่านี้ คุณสามารถแก้ไขเพิ่มเติมได้โดยแทนที่สองประโยคแรกด้วย

typeof(val) != "number"

ถ้าคุณต้องการจับคู่ตัวเลขที่แท้จริง (และไม่ใช่สตริง)

แก้ไข:

ฉันยังไม่สามารถโพสต์ความคิดเห็นได้ดังนั้นฉันจึงเพิ่มคำตอบของฉัน มาตรฐานที่โพสต์โดย @ อโศกนั้นมีข้อมูลมาก อย่างไรก็ตามฟังก์ชั่นที่เร็วที่สุดนั้นไม่ตรงกับความต้องการเนื่องจากมันจะส่งกลับค่า TRUE สำหรับการลอย, อาร์เรย์, บูลีนและสตริงว่าง

ฉันสร้างชุดทดสอบต่อไปนี้เพื่อทดสอบแต่ละฟังก์ชันเพิ่มคำตอบของฉันลงในรายการด้วย (ฟังก์ชัน 8 ซึ่งแยกสตริงและฟังก์ชัน 9 ซึ่งไม่ได้):

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

ฉันยังเรียกใช้เบนช์มาร์กด้วยฟังก์ชัน # 8 อีกครั้งในรายการ ฉันจะไม่โพสต์ผลเนื่องจากพวกเขาน่าอายเล็กน้อย (เช่นฟังก์ชั่นนั้นไม่เร็ว) ...

The (ย่อ - ฉันลบการทดสอบที่สำเร็จเนื่องจากผลลัพธ์ค่อนข้างยาว) ผลลัพธ์มีดังนี้:

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!

ฉันทิ้งไว้ในความล้มเหลวเพื่อให้คุณสามารถดูว่าแต่ละฟังก์ชั่นล้มเหลวและการทดสอบ (สตริง) '#' เพื่อให้คุณสามารถดูว่าแต่ละฟังก์ชั่นการจัดการจำนวนเต็มและค่าลอยในสตริงเพราะบางคนอาจต้องการแยกวิเคราะห์เป็นตัวเลขและบางส่วน อาจจะไม่.

จากการทดสอบฟังก์ชั่นทั้ง 10 ฟังก์ชั่นที่ตรงกับความต้องการของ OP คือ [1,3,5,6,8,9]

เงื่อนไขสำหรับการตรวจสอบลอย:

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

เงื่อนไขสำหรับการตรวจสอบจำนวนเต็ม:

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

หวังว่านี่อาจจะเป็นประโยชน์

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

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

คุณสามารถเพิ่มtypeof a === 'number'ถ้าคุณต้องการที่จะไม่รวมสตริง