ตรวจสอบว่าตัวเลขมีจุดทศนิยมหรือเป็นจำนวนเต็ม


284

ฉันกำลังมองหาวิธีที่ง่ายใน JavaScript เพื่อตรวจสอบว่าตัวเลขมีทศนิยมในนั้นหรือไม่ (เพื่อพิจารณาว่าเป็นจำนวนเต็ม) ตัวอย่างเช่น

23 -> OK
5 -> OK
3.5 -> not OK
34.345 -> not OK
if(number is integer) {...}

คำตอบ:


820

การใช้มอดุลัสจะทำงาน:

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

โปรดทราบว่าสิ่งนี้จะขึ้นอยู่กับค่าตัวเลขของตัวเลขโดยไม่คำนึงถึงรูปแบบ มันปฏิบัติต่อสายตัวเลขที่มีตัวเลขทั้งหมดที่มีจุดทศนิยมคงที่เช่นเดียวกับจำนวนเต็ม:

'10.0' % 1; // returns 0
10 % 1; // returns 0
'10.5' % 1; // returns 0.5
10.5 % 1; // returns 0.5

10
ฉันไม่ได้ลงคะแนน แต่ฉันบอกว่ามันจะทำอย่างไรกับ 20.0 ยังคงมีจุดทศนิยมและเป็นไปตามข้างต้น +1 จากฉันต่อไปสำหรับการสอนอะไรใหม่ ๆ ให้ฉัน :)
Abe Petrillo

7
@ Abe: จริงพอถึงแม้ว่าฉันคิดว่าไม่น่าเป็นไปได้ เป็นไปไม่ได้ที่จะบอกว่า20.0มีจุดทศนิยมโดยทางโปรแกรมเว้นแต่ว่ามันจะแสดงเป็นสตริง นอกจากนี้ยังไม่มีวิธีการแก้ปัญหาอื่นใดที่ได้รับการโหวตให้ลงคะแนนเพื่อไม่แก้ปัญหานั้น ;-)
Andy E

1
@SREEP: ดูความคิดเห็นด้านบน 0.00 ไม่ได้เป็น 0.00 ใน JavaScript เมื่อแสดงเป็นค่าตัวเลข มันสามารถแสดงเป็นสตริง ("0.00") ซึ่งในกรณีนี้คำถามคือ"ตรวจสอบว่าสตริงเป็นจำนวนเต็ม"แทนที่จะเป็น"ตรวจสอบว่าตัวเลขเป็นจำนวนเต็ม"หรือไม่
Andy E

3
@Swanidhi: คุณหมายถึงอะไร อะไรจะไม่ถูกต้อง "10."เป็นจำนวนทั้งหมดและผลที่ได้จะเหมือนกับหรือ"10" 10
Andy E

3
OP ถามเกี่ยวกับการตรวจสอบว่าNUMBERเป็นจำนวนเต็มหรือไม่ เขาไม่มีที่กล่าวถึงสตริง - ในเรื่องนั้นคำตอบของแอนดี้นั้นถูกต้อง
Om Shankar

58
Number.isInteger(23);  // true
Number.isInteger(1.5); // false
Number.isInteger("x"); // false: 

Number.isInteger ()เป็นส่วนหนึ่งของมาตรฐาน ES6 และไม่รองรับใน IE11

ก็จะส่งกลับเท็จNaN, Infinityการขัดแย้งและไม่ใช่ตัวเลขในขณะที่x % 1 != 0ผลตอบแทนที่แท้จริง


2
วิธีแก้ปัญหาล้มเหลวสำหรับ 12.0
Vikas Arora

@VikasArora ไม่มันทำงานได้ตามที่ตั้งใจไว้ ผลตอบแทนNumber.isInteger(12.0) true
le_m

ดูเหมือนว่ามันควรจะเป็นคำตอบที่ถูกต้อง แต่น่าเสียดายที่มันไม่ได้ใช้สำหรับสัญกรณ์ทางวิทยาศาสตร์เช่นNumber.isInteger('1e3')คือfalseแม้ว่าจะNumber.isInteger(1e3)เป็นจริง สมมติว่าเจตนาของคำถามคือการหาค่าที่ไม่ใช่จำนวนเต็ม (มากกว่าการแสดงตนที่แท้จริงของจุดทศนิยมในการเป็นตัวแทน) แล้วค่าสตริง '12 .0' ควรผ่านเป็นมันหมายถึงจำนวนเต็ม แต่อีกครั้งเป็นNumber.isInteger('12.0') false
brianmearns

@brianmearns คำถามของ OP ไม่ว่าจะnumberเป็นทั้งหมดหรือไม่ หากอินพุตของคุณเป็นสตริงคุณจะต้องแปลงเป็นสตริงnumberเช่นผ่านparseFloat()แน่นอน
le_m

47

หรือคุณสามารถใช้เพื่อดูว่าไม่ใช่ทศนิยมหรือไม่:

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

2
ฉันคิดว่าอันนี้เป็นทางออกที่แท้จริงเนื่องจากมันใช้งานได้กับ XX.0
Deepankar Sarkar

5
แปลงเป็นสตริงก่อนดำเนินการต่อ .. เช่น: yournumber.toString.indexOf(".")
Daniel Omine

1
francisco_ssb .. สัญลักษณ์จุดเป็นสากล ... แสดงถึงทศนิยมในภาษาคณิตศาสตร์ .. นี้เป็นสากลและควรทำงานในประเทศใด ๆ หากคุณพูดถึงเครื่องหมายจุลภาค (",") คุณจะต้องแปลงให้เป็นจุด (".") หน้า indexOf (".") ชัด ๆ ..
Daniel Omine

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

1
นี้จะไม่ทำงานถ้าทศนิยมเท่ากับ 1.00 และคุณต้องการที่จะเป็น int จนกว่าคุณจะบีบบังคับให้คุ้มค่า
Simon-PR

21

วิธีแก้ปัญหาที่พบบ่อยที่สุดคือการตัดส่วนจำนวนเต็มของตัวเลขและเปรียบเทียบกับศูนย์เช่น:

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

31
ทำไมไม่เพียงstartVal != Math.floor(startVal)?
Andy E

2
ดี แนวคิดเดียวกัน แต่รุ่นของคุณสะอาดกว่าเดิม
โธมัส

1
@Andy E: นี่เป็นไปได้สำหรับตัวเลขที่เป็นบวกเท่านั้น มันจะใช้ไม่ได้กับจำนวนลบ ..
Seeya K

3
@SeeyaK: แน่นอนว่ามันจะใช้ได้กับจำนวนลบ โปรดลองดู
Andy E

1
@DeepakGoyal - นั่นคือโดยการออกแบบ Math.Floorฟังก์ชั่นใช้เวลาค่าทศนิยมและค่าทศนิยมที่ใหญ่ที่สุดได้รับอนุญาตใน JavaScript เป็นหรือ2^53 - 1 9007199254740991เนื่องจาก893144042145698745.3มีขนาดใหญ่กว่าค่าสูงสุดนี้ฟังก์ชันจะล้มเหลว
โทมัส

20

เรียบง่าย แต่มีประสิทธิภาพ!

Math.floor(number) === number;

4
@OmShankar มีประสิทธิภาพ! = effective
Fiddles

Math.floor(3.0) == 3.0เป็นจริงMath.floor(3.3) == 3.3เป็นเท็จ
Rohmer

@ ปริศนา, ใช่แล้ว, นั่นคือสิ่งที่ฉันต้องการจะพูด: ไม่มีประสิทธิภาพเนื่องจากประสิทธิภาพการทำงานช้าลงมากเมื่อเทียบกับวิธี% mod ขอบคุณสำหรับการแก้ไข
Om Shankar

19

// แล้ว byte-ing มันล่ะ?

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

ฉันมักจะรู้สึกไม่ดีสำหรับตัวดำเนินการบิตใน javascript-

พวกเขาแทบจะไม่ได้ออกกำลังกายเลย


14
ที่ล้มเหลวสำหรับจำนวนเต็มมากกว่า 2 ^ 31 - 1 เนื่องจาก>>แปลงค่าเป็นจำนวนเต็ม 32 บิตที่ลงนามแล้ว
Matthew Crumley

1
@kennebec ยอดเยี่ยม - นั่นเป็นทางออกที่สนุกที่สุด และมันก็เป็นสิ่งที่ดีกว่า RegEx มาก
Daniel B. Chapman

5
number = 20.5

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

alert("Integer")

} else {

alert("Decimal")

}

สวยเท่ห์และใช้งานได้กับสิ่งต่าง ๆ เช่น XX.0 ด้วย! มันใช้งานได้เพราะ Math.floor () ตัดทศนิยมใด ๆ ถ้ามันมีหนึ่งดังนั้นถ้าชั้นแตกต่างจากหมายเลขเดิมที่เรารู้ว่ามันเป็นทศนิยม! และไม่มีการแปลงสตริง :)



4

Number.isInteger()อาจจะกระชับที่สุด มันจะส่งกลับจริงถ้ามันเป็นจำนวนเต็มและเท็จถ้ามันไม่ได้


1
นี่ควรเป็นคำตอบที่ยอมรับเพราะดีกว่าแล้วใช้โมดูลัสเนื่องจากปัญหาสตริง
Ini

3
function isDecimal(n){
    if(n == "")
        return false;

    var strCheck = "0123456789";
    var i;

    for(i in n){
        if(strCheck.indexOf(n[i]) == -1)
            return false;
    }
    return true;
}

ไม่ต้องการคำอธิบาย มันค่อนข้างง่าย
Grant Birchmeier

1
หากสตริงมีค่าใด ๆ ใน strCheck มันเป็นทศนิยม ... (เขาขาดหายไปและแม้ว่า ...
NicoJuicy

2
parseInt(num) === num

เมื่อผ่านตัวเลขparseInt()เพียงแค่คืนค่าเป็น int:

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

4
ฉันชอบสิ่งนี้มาก แต่ขึ้นอยู่กับความต้องการเฉพาะของคน น่าเสียดายที่ฉันต้องการฟังก์ชั่นเพื่อทดสอบ FAILparseInt(3.0) === 3.0 // true
zipzit

2

แปลงสตริงจำนวนเป็นอาร์เรย์โดยแยกตามจุดทศนิยม จากนั้นถ้าอาร์เรย์มีเพียงค่าเดียวนั่นหมายความว่าไม่มีทศนิยมในสตริง

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

วิธีนี้คุณสามารถรู้ได้ว่าจำนวนจริงและจำนวนเต็มเป็นเท่าใด เป็นตัวอย่างที่สูงขึ้น

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

if(!dece){
    //do stuff
}

1

นี่คือข้อความที่ตัดตอนมาจากห้องสมุดยามของฉัน (แรงบันดาลใจจาก JavaScript ที่มีประสิทธิภาพโดย David Herman):

var guard = {

    guard: function(x) {
        if (!this.test(x)) {
            throw new TypeError("expected " + this);
        }
    }

    // ...
};

// ...

var number = Object.create(guard);
number.test = function(x) {
    return typeof x === "number" || x instanceof Number;
};
number.toString = function() {
    return "number";
};


var uint32 = Object.create(guard);
uint32.test = function(x) {
    return typeof x === "number" && x === (x >>> 0);
};
uint32.toString = function() {
    return "uint32";
};


var decimal = Object.create(guard);
decimal.test = function(x) {
    return number.test(x) && !uint32.test(x);
};
decimal.toString = function() {
    return "decimal";
};


uint32.guard(1234);     // fine
uint32.guard(123.4);    // TypeError: expected uint32

decimal.guard(1234);    // TypeError: expected decimal
decimal.guard(123.4);   // fine

1

คุณสามารถคูณมันด้วย 10แล้วทำการ " โมดูโล " การดำเนินการ / divison ด้วย 10และตรวจสอบว่าผลลัพธ์ของการดำเนินการที่สองเป็นศูนย์ ผลลัพธ์ของการดำเนินการสองอย่างนั้นจะให้ตัวเลขแรกหลังจากจุดทศนิยม หากผลลัพธ์เท่ากับศูนย์ดังนั้นตัวเลขจะเป็นจำนวนเต็ม

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


1

คุณสามารถใช้การดำเนินการระดับบิตที่ไม่เปลี่ยนค่า ( ^ 0หรือ~~) เพื่อทิ้งส่วนทศนิยมซึ่งสามารถใช้สำหรับการปัดเศษ หลังจากปัดเศษตัวเลขจะถูกนำไปเปรียบเทียบกับค่าเดิม:

function isDecimal(num) {
  return (num ^ 0) !== num;
}

console.log( isDecimal(1) ); // false
console.log( isDecimal(1.5) ); // true
console.log( isDecimal(-0.5) ); // true


1

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

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

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

เห็นได้ชัดว่าผู้ใช้บางคนต้องการคำอธิบาย ฉันจะแบ่งมันเป็นชิ้น ๆ : (NUM% 1)

วงเล็บหมายถึงดำเนินการเหล่านั้นก่อน num - ตัวแปรที่ส่งผ่านโดยฟังก์ชัน % - สัญลักษณ์โมดูลัสซึ่งพยายามที่จะหารจำนวนซ้ายทางขวา หากมีเศษเหลือก็จะคืนค่าเป็นทศนิยม ถ้ามันหารเท่า ๆ กันมันจะคืนค่า 0

ดังนั้นสรุปสิ่งที่เรามีจนถึงตอนนี้ (จำนวน 1%) จะกลับมา:

0 เมื่อแบ่งเท่า ๆ กันหรือ # .##### ถ้าไม่ใช่

0 == false

[ANY_NUMBER_NOT_ZERO] == จริง

ตัวอย่าง: บูลีนใหม่ (0) เป็นเท็จบูลีนใหม่ (12312.1231) เป็นจริง

ทางเลือกอื่น ๆ : ผู้ใช้อาจลองส่งคืนค่าของ (num% 1). ซึ่งโดยทั่วไปแล้วจะได้รับสิ่งเดียวกัน เนื่องจาก return (0) เป็นเท็จและ return (1.213113) เป็นจริง

แต่ฉันต้องการคืนค่าบูลีน ดังนั้นทางลัดในการบังคับค่าลงในบูลีนฉันจึงเพิ่ม! สัญลักษณ์ก่อนมัน

มากเท่าที่อาจจะรู้! หมายความว่าไม่ แต่มันยังบังคับให้ค่าเป็นบูลีน

ตั้งแต่! symobol บังคับให้ค่าเป็นบูลีนและจะแปรค่าของมัน ฉันใช้ !! เพื่อบังคับให้ค่าเป็นบูลีนและกลับค่าเป็นค่าบูลีนเดิม

ป้อนคำอธิบายรูปภาพที่นี่


ในขณะที่รหัสนี้อาจตอบคำถามให้บริบทเพิ่มเติมเกี่ยวกับวิธีการและ / หรือทำไมมันแก้ปัญหาจะปรับปรุงค่าระยะยาวของคำตอบ
Nic3500

0

ฟังก์ชั่นสำหรับหมายเลขเช็คคือทศนิยมหรือจำนวนเต็ม

function IsDecimalExist(p_decimalNumber) {
    var l_boolIsExist = true;

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

    return l_boolIsExist;
}

0

บางทีนี่อาจจะเหมาะกับคุณ

มันใช้ regex เพื่อตรวจสอบว่ามีเครื่องหมายจุลภาคในจำนวนและถ้าไม่มีก็จะเพิ่มเครื่องหมายจุลภาคและแถบ

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

ยินดีต้อนรับสู่ StackOverflow คุณช่วยอธิบายสิ่งที่รหัสนี้ทำและทำไมคุณคิดว่ามันจะแก้ปัญหา
quinz

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

0

ใช้ค่าต่อไปนี้ถ้าค่าเป็นสตริง (เช่นจาก<input):

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

ฉันเพิ่ม.toString()ไปที่พื้นเพื่อให้มันทำงานได้เช่นกันเมื่อvalue == "1."(สิ้นสุดด้วยตัวคั่นทศนิยมหรือสตริงอื่น) นอกจากนี้ยังMath.floorมักจะส่งกลับค่าบางอย่างเพื่อ.toString()ไม่เคยล้มเหลว

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