จะตรวจสอบว่าตัวแปรเป็นจำนวนเต็มใน JavaScript ได้อย่างไร?

405

ฉันจะตรวจสอบว่าตัวแปรเป็นจำนวนเต็มใน JavaScript ได้หรือไม่และแจ้งเตือนหากไม่มี ฉันลองสิ่งนี้ แต่มันไม่ทำงาน:

<html>
    <head>
        <script type="text/javascript">
            var data = 22;
            alert(NaN(data));
        </script>
    </head>
</html>
javascript 
— JBA
แหล่งที่มา
2
หนึ่ง posiblity parseIntที่นี่คือการใช้งาน
— พอล
2
jsben.ch/#/htLVw - มาตรฐานสำหรับวิธีการทั่วไปที่จะทำ
— EscapeNetscape
คำตอบทั้งหมดที่นี่ล้าสมัยจริงๆ วันนี้ฉันขอแนะนำให้ติดNumber.isIntegerซึ่งเป็นวิธีที่แฮ็กน้อยที่สุด
— Benjamin Gruenbaum
@Benjamim จะเกิดอะไรขึ้นถ้าตัวเลขเป็นสตริงที่สามารถแปลงเป็นจำนวนเต็มได้ และในรูปแบบ HTML ทุกอย่างเป็นสตริง .. ดังนั้น Number.isInteger ( "69") เป็นเท็จ
— joedotnot

คำตอบ:

344

ใช้โอเปอเรเตอร์ === ( ความเท่าเทียมอย่างเข้มงวด ) ดังต่อไปนี้

if (data === parseInt(data, 10))
    alert("data is integer")
else
    alert("data is not an integer")
— pranag
แหล่งที่มา
95
ซึ่งนับ NaN เป็นจำนวนเต็ม ยังทำงานได้แย่ลงเมื่อเทียบกับวิธีการของฉัน jsperf.com/numbers-and-integers
— Blake Regalia
2
หากคุณเรียกใช้ตัวอย่างของคุณผ่านโค้ดด้านบนมันแจ้งเตือน a เป็นจำนวนเต็มและอื่น ๆ ไม่ใช่จำนวนเต็มซึ่งเป็นกรณี ... ในกรณีของ NaN ชนิดของ NaN ยังแตกต่างจากประเภทของค่าตอบแทนของ pareInt () .....
— pranag
1
คุณอธิบายรายละเอียดเล็กน้อยได้ไหม? "ตัวอย่าง" แสดงให้เห็นว่าการใช้ parseInt ให้ประสิทธิภาพที่แย่กว่าการใช้คำหลัก typeof และตัวดำเนินการโมดูลัส แต่ฉันเห็นสิ่งที่คุณหมายถึงตอนนี้เกี่ยวกับ (NaN! = NaN)
— Blake Regalia
4
@connorbode ใน javascript ตัวเลขทั้งหมดมีประเภทเดียวกัน (ไม่มีการลอยหรือเป็นสองเท่า) ดังนั้น2.0 === 2เนื่องจากทศนิยมที่ไม่จำเป็นเป็นเพียงการแสดงตัวเลขที่แตกต่างกันของจำนวนเดียวกันดังนั้นจึงparseInt(2.0) === 2.0เทียบเท่ากับparseInt(2) === 2ที่เป็นจริง
— Michael Theriot
1
@BlakeRegalia: ถึงแม้ว่าวิธีการที่รวดเร็วของเขาจะไม่ผ่านค่าที่เป็นไปได้ทั้งหมดจากคำตอบนี้: stackoverflow.com/a/14794066/843732
— c00000fd
506

ขึ้นอยู่กับว่าคุณต้องการแปลงสตริงเป็นจำนวนเต็มด้วยหรือไม่?

สิ่งนี้จะทำ:

function isInt(value) {
  return !isNaN(value) && 
         parseInt(Number(value)) == value && 
         !isNaN(parseInt(value, 10));
}

ด้วยการทำงานของ Bitwise

แยกง่ายและตรวจสอบ

function isInt(value) {
  var x = parseFloat(value);
  return !isNaN(value) && (x | 0) === x;
}

ลัดวงจรและการบันทึกการดำเนินการแยก:

function isInt(value) {
  if (isNaN(value)) {
    return false;
  }
  var x = parseFloat(value);
  return (x | 0) === x;
}

หรือบางทีทั้งคู่ในนัดเดียว:

function isInt(value) {
  return !isNaN(value) && (function(x) { return (x | 0) === x; })(parseFloat(value))
}

แบบทดสอบ:

isInt(42)        // true
isInt("42")      // true
isInt(4e2)       // true
isInt("4e2")     // true
isInt(" 1 ")     // true
isInt("")        // false
isInt("  ")      // false
isInt(42.1)      // false
isInt("1a")      // false
isInt("4e2a")    // false
isInt(null)      // false
isInt(undefined) // false
isInt(NaN)       // false

นี่คือซอ: http://jsfiddle.net/opfyrqwp/28/

ประสิทธิภาพ

การทดสอบพบว่าโซลูชันการลัดวงจรมีประสิทธิภาพดีที่สุด (ops / วินาที)

// Short-circuiting, and saving a parse operation
function isInt(value) {
  var x;
  if (isNaN(value)) {
    return false;
  }
  x = parseFloat(value);
  return (x | 0) === x;
}

นี่คือมาตรฐาน: http://jsben.ch/#/htLVw

หากคุณนึกว่าการลัดวงจรแบบสั้น ๆ

function isInt(value) {
  var x;
  return isNaN(value) ? !1 : (x = parseFloat(value), (0 | x) === x);
}

แน่นอนฉันขอแนะนำให้ผู้ปฏิบัติงานดูแลมัน

— krisk
แหล่งที่มา
4
@krisk - อัปเดตหลายโซลูชั่น ทำการทดสอบอย่างรวดเร็วเกี่ยวกับ 4 ตัวแปรที่คุณให้ไว้: jsperf.com/tfm-is-integer - และพิจารณาว่าโซลูชันการลัดวงจรมีประสิทธิภาพดีที่สุด
— tfmontague
1
จะส่งคืนเท็จในวันที่ 2099999999999999: - (
— jkucharovic
1
@ jkucharovic ตัวดำเนินการระดับบิตหรือ OR เป็นผู้กระทำผิด การใช้เวอร์ชั่นที่ไม่ใช่บิตจะกลับมาเป็นจริง
— krisk
1
สิ่งนี้ทำให้ '2. ' ประเมินเป็นจริง
— cyberwombat
1
@cyberwombat อย่างดีนั่นคือเลขทศนิยม 2.0 :-)
— Kuba Beránek
120

สมมติว่าคุณไม่รู้อะไรเกี่ยวกับตัวแปรที่เป็นปัญหาคุณควรใช้วิธีนี้:

if(typeof data === 'number') {
    var remainder = (data % 1);
    if(remainder === 0) {
        // yes, it is an integer
    }
    else if(isNaN(remainder)) {
        // no, data is either: NaN, Infinity, or -Infinity
    }
    else {
        // no, it is a float (still a number though)
    }
}
else {
    // no way, it is not even a number
}

หากต้องการใส่เพียง:

if(typeof data==='number' && (data%1)===0) {
    // data is an integer
}
— Blake Regalia
แหล่งที่มา
8
คุณหมายถึงอะไร การตรวจสอบประเภทข้อมูลใน javascript "1.0"เป็นสตริงและไม่ใช่ตัวเลข มิฉะนั้น1จะเป็นค่าของตัวแปรถ้าคุณตั้งค่าอย่างนั้นvar my_var=1.0;ซึ่งจะถูกระบุอย่างถูกต้องโดยฟังก์ชั่นนี้เป็นจำนวนเต็ม
— Blake Regalia
4
เร็ว ๆ นี้Number.isInteger()จะทำงาน ... จนกว่าจะถึงตอนนี้เป็นวิธีที่ดีในการทำมัน
— Claudiu
Number.isInteger ไม่ทำงานสำหรับฉัน ฉันต้องทำอะไรผิดไป ทางออกของเบลค% 1 ทำงานได้อย่างสมบูรณ์แบบ
— mcmacerson
104

Number.isInteger() น่าจะเป็นวิธีที่จะไป

MDN ยังได้จัดทำโพลีฟิลต่อไปนี้สำหรับเบราว์เซอร์ที่ไม่รองรับNumber.isInteger()IE ส่วนใหญ่ทุกรุ่น

เชื่อมโยงไปยังหน้า MDN

Number.isInteger = Number.isInteger || function(value) {
    return typeof value === "number" && 
           isFinite(value) && 
           Math.floor(value) === value;
};
— วอลเตอร์โรมัน
แหล่งที่มา
2
MDN มีการทดสอบใน 9007199254740992 ลบออก
— Bernhard Döbler
2
นี่คือคำตอบที่ตรงไปตรงมาที่สุดและ "ถูกต้อง" ฉันหมายความว่า JavaScript มีวิธีการตรวจสอบจำนวนเต็มอยู่แล้ว ไม่จำเป็นต้องเขียนใหม่ isNaN () ทดสอบความเป็นตัวเลขไม่ใช่จำนวนเต็ม
— globewalldesk
66

คุณสามารถตรวจสอบว่าหมายเลขมีเศษเหลือหรือไม่:

var data = 22;

if(data % 1 === 0){
   // yes it's an integer.
}

โปรดทราบว่าหากการป้อนข้อมูลของคุณอาจเป็นข้อความและคุณต้องการตรวจสอบก่อนไม่ใช่ข้อมูลจากนั้นคุณสามารถตรวจสอบประเภทก่อน:

var data = 22;

if(typeof data === 'number'){
     // yes it is numeric

    if(data % 1 === 0){
       // yes it's an integer.
    }
}
— Nope
แหล่งที่มา
3
@Erwinus: เรียกใช้ 0 % 1 === 0ในคอนโซล มันกลับtrueเป็นผลตอบแทน0 % 1 0
— Nope
คุณลองใน IE ;-) แล้วหรือยัง
— Codebeat
1
@Erwinus: 0 % 1ส่งคืน0ในโหมดที่เข้ากันได้กับ IE9, IE8 และ IE7
— Nope
ลองใช้ IE แบบเก่าแท้ๆ นอกจากนี้ยังเป็นวิธีที่ดีในการเขียนโปรแกรมเพื่อตรวจสอบศูนย์และไม่ต้องพึ่งพาเบราว์เซอร์ว่าจะทำอย่างไร
— Codebeat
62
@Erwinus: ฉันคิดว่าคุณได้รับข้อมูลของคุณสับสน ข้อผิดพลาดการหารด้วยศูนย์จะเกิดขึ้นเมื่อคุณหารด้วยศูนย์ไม่ใช่เมื่อคุณหารศูนย์ด้วยตัวเลข ไม่เกี่ยวข้องกับเวอร์ชันของ IE เลย
— Nope
15

ก่อนอื่น NaN คือ "หมายเลข" (ใช่ฉันรู้ว่ามันแปลก ๆ แค่ม้วนมัน) และไม่ใช่ "ฟังก์ชั่น"

คุณต้องตรวจสอบทั้งคู่ว่าประเภทของตัวแปรเป็นตัวเลขหรือไม่และเพื่อตรวจสอบจำนวนเต็มฉันจะใช้โมดูลัส

alert(typeof data === 'number' && data%1 == 0);
— ฟิล
แหล่งที่มา
2
ควรเป็น: การแจ้งเตือน (ข้อมูล typeof == 'number' && (data == 0 || data% 1 == 0)); เพื่อหลีกเลี่ยงการหารด้วยศูนย์
— Codebeat
19
@Erwinus 0% 1 ยังคงถูกหารด้วย 1
— Phil
@Phil, จะมีการประเมินเพื่อ(0 == 0 || 0 % 1 == 0) true
— tomekwi
โอ้โดยวิธีการ0 % 1 == 0ประเมินยังtrue! %ไม่แบ่ง!
— tomekwi
13

ระวังขณะใช้งาน

จำนวน% 1

สตริงว่าง ('') หรือบูลีน (จริงหรือเท็จ) จะกลับมาเป็นจำนวนเต็ม คุณอาจไม่ต้องการทำเช่นนั้น

false % 1 // true
'' % 1 //true

Number.isInteger (ข้อมูล)

Number.isInteger(22); //true
Number.isInteger(22.2); //false
Number.isInteger('22'); //false

สร้างในฟังก์ชั่นในเบราว์เซอร์ Dosnt รองรับเบราว์เซอร์รุ่นเก่า

ทางเลือก:

Math.round(num)=== num

อย่างไรก็ตาม Math.round () จะล้มเหลวเนื่องจากสตริงว่างและบูลีน

— Jhankar Mahbub
แหล่งที่มา
8

วิธีตรวจสอบว่าต้องการจำนวนเต็มเช่นโปสเตอร์หรือไม่:

if (+data===parseInt(data)) {return true} else {return false}

แจ้งให้ทราบล่วงหน้า + ด้านหน้าของข้อมูล (แปลงสตริงเป็นตัวเลข) และ === สำหรับข้อมูลที่แน่นอน

นี่คือตัวอย่าง:

data=10
+data===parseInt(data)
true

data="10"
+data===parseInt(data)
true

data="10.2"
+data===parseInt(data)
false
— user603749
แหล่งที่มา
6
ดูเหมือนว่าวิธีการแก้ปัญหาที่ฉลาดที่สุดสำหรับกรณีของฉัน (ที่ฉันไม่คิดว่ามันเป็นจำนวนเต็มในสตริง) อย่างไรก็ตาม: ทำไมไม่เพียงแค่ไปreturn (+data===parseInt(data))?
— สวิสมิสเตอร์
6 
if(Number.isInteger(Number(data))){
    //-----
}
— แขก
แหล่งที่มา
1
ความคิดเห็นเช่นเดียวกับด้านล่าง: ไม่รองรับ IE และ Safari
— กากบาท
@ crisscross ตอนนี้รองรับทุกอย่างยกเว้น IE ซึ่งเป็นข้อกังวลถ้าคุณสนับสนุนระบบปฏิบัติการรุ่นเก่าเท่านั้น
— faintsignal
6

โซลูชัน pre-ECMAScript-6 ที่ง่ายและสะอาดที่สุด (ซึ่งมีความแข็งแกร่งเพียงพอที่จะส่งคืนค่าเท็จแม้ว่าค่าที่ไม่ใช่ตัวเลขเช่นสตริงหรือ null จะถูกส่งผ่านไปยังฟังก์ชัน) จะเป็นดังนี้:

function isInteger(x) { return (x^0) === x; }

วิธีแก้ปัญหาต่อไปนี้ยังสามารถใช้งานได้แม้ว่าจะไม่สวยงามเท่าที่กล่าวข้างต้น:

function isInteger(x) { return Math.round(x) === x; }

บันทึกว่า Math.ceil () หรือ Math.floor () สามารถใช้งานได้ดีอย่างเท่าเทียมกัน (แทน Math.round ()) ในการใช้งานด้านบน

หรืออีกทางหนึ่ง:

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

วิธีแก้ปัญหาที่ไม่ถูกต้องที่พบได้บ่อยอย่างหนึ่งคือ

function isInteger(x) { return parseInt(x, 10) === x; }

ในขณะที่วิธีการที่ใช้ parseInt นี้จะทำงานได้ดีสำหรับค่าหลาย ๆ ค่าของ x เมื่อ x มีขนาดใหญ่มากมันจะไม่ทำงานอย่างถูกต้อง ปัญหาคือที่ parseInt () รวมพารามิเตอร์ตัวแรกกับสตริงก่อนที่จะแยกวิเคราะห์ตัวเลข ดังนั้นเมื่อตัวเลขมีขนาดใหญ่พอการแทนสตริงจะถูกแสดงในรูปแบบเลขชี้กำลัง (เช่น 1e + 21) ดังนั้น parseInt () จะพยายามแยก 1e + 21 แต่จะหยุดการแยกวิเคราะห์เมื่ออักขระนั้นถึงอักขระ e ดังนั้นจะส่งกลับค่า 1 สังเกต:

> String(1000000000000000000000)
'1e+21'

> parseInt(1000000000000000000000, 10)
1

> parseInt(1000000000000000000000, 10) === 1000000000000000000000
false
— Arsen Aleksanyan
แหล่งที่มา
6

ทำไมไม่มีใครพูดถึงNumber.isInteger()?

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isInteger

ทำงานได้อย่างสมบูรณ์แบบสำหรับฉันและแก้ปัญหาด้วยการNaNเริ่มต้นตัวเลข

— คืน
แหล่งที่มา
1
โปรดทราบว่านี่คือ ES6 ดังนั้นเบราว์เซอร์รุ่นเก่า (เช่น IE <= 11) ไม่รองรับ เอกสารด้านบนเป็นโพลีฟิล
— บิชอป
มีคนพูดถึงNumber.isInteger()คุณ 3.5 ปีก่อน: stackoverflow.com/a/27424770/5208540
— Alex Stragies
ถ้าเราจะจับค่าจากอินพุตจากนั้นให้ตรวจสอบ Number.isInteger จะส่งคืนค่าเท็จเสมอเนื่องจากค่าอินพุตเป็นสตริงประเภทข้อมูล
— Shinigamae
6

ใน ES6 2 มีการเพิ่มวิธีการใหม่สำหรับ Number Object

ในนั้นมัน Number.isInteger () วิธีการส่งกลับจริงถ้าอาร์กิวเมนต์เป็นจำนวนเต็ม

ตัวอย่างการใช้งาน:

Number.isInteger(10);        // returns true
Number.isInteger(10.5);      // returns false
— อรุณ Joshla
แหล่งที่มา
4

ECMA-262 6.0 (ES6) มาตรฐานรวมถึงNumber.isIntegerฟังก์ชัน

เพื่อเพิ่มการสนับสนุนสำหรับเบราว์เซอร์เก่าฉันขอแนะนำให้ใช้โซลูชันที่แข็งแกร่งและสนับสนุนชุมชนจาก:

https://github.com/paulmillr/es6-shim

ซึ่งเป็นไลบรารี polyfills ES6 JSบริสุทธิ์ห้องสมุด

โปรดทราบว่า lib นี้ต้องการ es5-shim เพียงแค่ติดตาม README.md

— gavenkoa
แหล่งที่มา
4

คุณอาจจะลองNumber.isInteger(Number(value))ถ้าvalueอาจเป็นจำนวนเต็มในสตริงรูปแบบเช่นและคุณต้องการนี้ในการประเมินเพื่อvar value = "23" trueหลีกเลี่ยงการพยายามNumber.isInteger(parseInt(value))เพราะจะไม่ส่งคืนค่าที่ถูกต้องเสมอไป เช่นถ้าvar value = "23abc"และคุณใช้parseIntดำเนินการมันจะยังคงกลับมาจริง

แต่ถ้าคุณต้องการค่าจำนวนเต็มอย่างเคร่งครัดก็อาจNumber.isInteger(value)จะทำเคล็ดลับ

— gbozee
แหล่งที่มา
1
โปรดทราบว่า IE นี้ไม่รองรับ ตามที่ระบุไว้ ที่นี่ใน docuฉันได้รับ scrip ของฉันหยุดเพราะสิ่งนี้โดยเฉพาะถ้า var คุณกำลังตรวจสอบไม่ได้กำหนด
— mikewasmike
4 
var x = 1.5;
if(!isNaN(x)){
 console.log('Number');
 if(x % 1 == 0){
   console.log('Integer');
 }
}else {
 console.log('not a number');
}
— Hemant
แหล่งที่มา
3
หลังจาก 29 คำตอบใครจะคาดหวังว่าจะมีคำอธิบายเพิ่มขึ้นอีกนิดเพื่อให้คำตอบของคุณโดดเด่น ...
— brasofilo
3

ตรวจสอบว่าตัวแปรเท่ากับตัวแปรเดียวกันนั้นปัดเป็นจำนวนเต็มเช่นนี้หรือไม่:

if(Math.round(data) != data) {
    alert("Variable is not an integer!");
}
— Elliot Bonneville
แหล่งที่มา
คุณมากสามารถแก้ไขปัญหาของฟังก์ชั่นนี้กับการกลับมาtrueสำหรับNaNโดยเพียงแค่การเปลี่ยน!=ไป!==และกลับหัวifบล็อก สิ่งนี้ใช้ได้เพราะNaNเป็นค่าเดียวใน JavaScript ที่ไม่เท่ากัน ตัวอย่างเช่นรหัสใหม่ควรเป็นif (Math.round(x) === x) { /* x IS an integer! */ }
— mgthomas99
3

นอกจากนี้, Number.isInteger(). อาจNumber.isSafeInteger()เป็นตัวเลือกอื่นที่นี่โดยใช้ ES6 ที่ระบุ

ในการ polyfill Number.isSafeInteger(..)ในเบราว์เซอร์ pre-ES6:

Number.isSafeInteger = Number.isSafeInteger || function(num) {
    return typeof num === "number" && 
           isFinite(num) && 
           Math.floor(num) === num &&
           Math.abs( num ) <= Number.MAX_SAFE_INTEGER;
};
— zangw
แหล่งที่มา
3

Number.isInteger() เป็นวิธีที่ดีที่สุดถ้าเบราว์เซอร์ของคุณรองรับถ้าไม่ฉันคิดว่ามีหลายวิธี:

function isInt1(value){
  return (value^0) === value
}

หรือ:

function isInt2(value){
  return (typeof value === 'number') && (value % 1 === 0); 
}

หรือ:

function isInt3(value){
  return parseInt(value, 10) === value; 
}

หรือ:

function isInt4(value){
  return Math.round(value) === value; 
}

ตอนนี้เราสามารถทดสอบผลลัพธ์:

var value = 1
isInt1(value)   // return true
isInt2(value)   // return true
isInt3(value)   // return true
isInt4(value)   // return true

var value = 1.1
isInt1(value)   // return false
isInt2(value)   // return false
isInt3(value)   // return false
isInt4(value)   // return false

var value = 1000000000000000000
isInt1(value)   // return false
isInt2(value)   // return true
isInt3(value)   // return false
isInt4(value)   // return true

var value = undefined
isInt1(value)   // return false
isInt2(value)   // return false
isInt3(value)   // return false
isInt4(value)   // return false

var value = '1' //number as string
isInt1(value)   // return false
isInt2(value)   // return false
isInt3(value)   // return false
isInt4(value)   // return false

ดังนั้นวิธีการเหล่านี้ทั้งหมดใช้งานได้ แต่เมื่อจำนวนมีขนาดใหญ่มากผู้ประกอบการแยกวิเคราะห์และ ^ จะไม่ทำงานได้ดี

— ชาร์ลส์ชู
แหล่งที่มา
3

ลองทำสิ่งนี้:

let number = 5;
if (Number.isInteger(number)) {
    //do something
}
— ม.ค. WebDev
แหล่งที่มา
Number.isInteger () ไม่รองรับเบราว์เซอร์ IE ทุกรุ่น
— SKR
2

คุณสามารถใช้ฟังก์ชั่นนี้:

function isInteger(value) {
    return (value == parseInt(value));
}

มันจะกลับมาจริงแม้ว่าค่าเป็นสตริงที่มีค่าจำนวนเต็ม
ดังนั้นผลลัพธ์จะเป็น:

alert(isInteger(1)); // true
alert(isInteger(1.2)); // false
alert(isInteger("1")); // true
alert(isInteger("1.2")); // false
alert(isInteger("abc")); // false
— ferhrosa
แหล่งที่มา
2

แนวทางของฉัน:

a >= 1e+21การทดสอบสามารถส่งผ่านค่าที่ต้องเป็นตัวเลขและเท่านั้นค่าที่มีขนาดใหญ่มากเท่านั้น สิ่งนี้จะครอบคลุมทุกกรณีอย่างแน่นอนซึ่งแตกต่างจากโซลูชันอื่น ๆ ที่มีให้ในการสนทนานี้

a === (a|0)ถ้าอาร์กิวเมนต์ของฟังก์ชันที่ระบุนั้นมีค่าเท่ากับ (===) เหมือนกับค่าที่แปลงด้วยค่าบิตมันหมายความว่าอาร์กิวเมนต์นั้นเป็นจำนวนเต็ม

a|0จะคืน0ค่าใด ๆaที่ไม่ใช่ตัวเลขและถ้าaเป็นจำนวนจริงมันจะตัดสิ่งใด ๆ หลังจากจุดทศนิยมดังนั้น1.0001จะกลายเป็น1

function isInteger(a){
    return a >= 1e+21 ? true : a === (a|0)
}

/// tests ///////////////////////////
[
  1,                        // true
  1000000000000000000000,   // true
  4e2,                      // true
  Infinity,                 // true
  1.0,                      // true
  1.0000000000001,          // false
  0.1,                      // false
  "0",                      // false
  "1",                      // false
  "1.1",                    // false
  NaN,                      // false
  [],                       // false
  {},                       // false
  true,                     // false
  false,                    // false
  null,                     // false
  undefined                 // false
].forEach( a => console.log(typeof a, a, isInteger(a)) )
ขยายตัวอย่างข้อมูล

— vSync
แหล่งที่มา
1
ความคิดที่ดี! ฉันก็ชอบที่คุณแสดงการทดสอบของคุณ แต่น่าเสียดายที่นี่ไม่ได้พิจารณาค่าสตริงเป็น "0"
— Jammer
เฮ้ @vsync ไม่ตั้งใจ เดิมฉันโหวตขึ้น แต่ตัดสินใจที่จะคืนกลับเนื่องจากความคิดเห็นก่อนหน้าของฉัน ฉันต้องคลิกสองครั้งโดยไม่ตั้งใจหรือบางสิ่งบางอย่าง
— Jammer
1

คุณสามารถใช้ regexp สำหรับสิ่งนี้:

function isInteger(n) {
    return (typeof n == 'number' && /^-?\d+$/.test(n+''));
}
— macloving
แหล่งที่มา
1

จากhttp://www.toptal.com/javascript/interview-questions :

function isInteger(x) { return (x^0) === x; }

พบว่าเป็นวิธีที่ดีที่สุดในการทำเช่นนี้

— Avram Tudor
แหล่งที่มา
ไม่ใช่การใช้งานที่ถูกต้องทำงานได้กับจำนวนเต็มขนาดเล็กเท่านั้นโปรดดูdeveloper.mozilla.org/en-US/docs/Web/JavaScript/Reference/…สำหรับการใช้งานที่ถูกต้อง
— ถึง
1

ใช้|โอเปอเรเตอร์:

(5.3 | 0) === 5.3 // => false
(5.0 | 0) === 5.0 // => true

ดังนั้นฟังก์ชั่นทดสอบอาจมีลักษณะเช่นนี้:

var isInteger = function (value) {
  if (typeof value !== 'number') {
    return false;
  }

  if ((value | 0) !== value) {
    return false;
  }

  return true;
};
— Golo Roden
แหล่งที่มา
1

สิ่งนี้จะแก้สถานการณ์อีกหนึ่งสถานการณ์ ( 121. ) ซึ่งเป็นจุดที่สิ้นสุด

function isInt(value) {
        var ind = value.indexOf(".");
        if (ind > -1) { return false; }

        if (isNaN(value)) {
            return false;
        }

        var x = parseFloat(value);
        return (x | 0) === x;

    }
— Muhammed Rafiq
แหล่งที่มา
1

สำหรับค่าจำนวนเต็มบวกที่ไม่มีตัวคั่น:

return ( data !== '' && data === data.replace(/\D/, '') );

การทดสอบ 1. ถ้าไม่ว่างเปล่าและ 2. ถ้าค่าเท่ากับผลลัพธ์ของการแทนที่อักขระที่ไม่ใช่ตัวเลขในค่าของมัน

— นีลล์
แหล่งที่มา
1

ตกลงลบด้วยสาเหตุไม่ได้อธิบายตัวอย่างของฉันตัวอย่างเพิ่มเติม :):

ฉันใช้นิพจน์ทั่วไปและวิธีทดสอบ:

var isInteger = /^[0-9]\d*$/;

isInteger.test(123); //true
isInteger.test('123'); // true
isInteger.test('sdf'); //false
isInteger.test('123sdf'); //false

// If u want to avoid string value:
typeof testVal !== 'string' && isInteger.test(testValue);
— Vasyl Gutnyk
แหล่งที่มา
ได้ลบด้วยอาจเป็นเพราะการทดสอบไม่ใช่ฟังก์ชั่น
— imlokesh
@imlokesh คุณหมายถึงอะไร "ไม่ใช่ฟังก์ชั่น"? oO ฉันเขียนฉันใช้ "test method"
— Vasyl Gutnyk
@imlokesh ไม่มีปัญหาฉันเพียงแค่ขอ U ทำให้ฉันใช้มันในการผลิต :) และฉันคิดว่ายูพบข้อบกพร่องบาง :)
— Vasyl Gutnyk
1

คุณสามารถลองแบบนี้ได้ 

var data = 22;
if (Number.isInteger(data)) {
    console.log("integer");
 }else{
     console.log("not an integer");
 }

หรือ

if (data === parseInt(data, 10)){
    console.log("integer");
}else{
    console.log("not an integer");
}
— Adeojo Emmanuel IMM
แหล่งที่มา
data=22.5;นี้จะมีการทำผลผิด ทั้งสองสาขามีconsole.log("not an integer"):: S
— Colin Breame
0

ฉันต้องตรวจสอบว่าตัวแปร (สตริงหรือตัวเลข) เป็นจำนวนเต็มและฉันใช้เงื่อนไขนี้:

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

http://jsfiddle.net/e267369d/1/

คำตอบอื่น ๆ บางคำมีวิธีแก้ปัญหาที่คล้ายกัน (พึ่งพาparseFloatรวมกับisNaN) แต่ฉันควรจะตรงไปข้างหน้ามากขึ้นและอธิบายตัวเอง

แก้ไข: ฉันพบว่าวิธีการของฉันล้มเหลวสำหรับสตริงที่มีเครื่องหมายจุลภาค (เช่น "1,2") และฉันก็ตระหนักว่าในกรณีของฉันโดยเฉพาะฉันต้องการให้ฟังก์ชันล้มเหลวหากสตริงไม่ใช่จำนวนเต็มที่ถูกต้อง แม้ 1.0) ดังนั้นนี่คือฟังก์ชั่นของฉัน Mk II:

function isInt(a){
    return !isNaN(a) && parseInt(a) == parseFloat(a) && (typeof a != 'string' || (a.indexOf('.') == -1 && a.indexOf(',') == -1));
}

http://jsfiddle.net/e267369d/3/

แน่นอนว่าในกรณีที่คุณต้องการฟังก์ชั่นเพื่อรับจำนวนเต็ม (1.0 เรื่อง) คุณสามารถลบเงื่อนไขจุดa.indexOf('.') == -1ได้เสมอ

— jahu
แหล่งที่มา
โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.