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

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

23 -> OK
5 -> OK
3.5 -> not OK
34.345 -> not OK

if(number is integer) {...}

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

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

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

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

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

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

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

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

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

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

Math.floor(number) === number;

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

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

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

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

number = 20.5

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

alert("Integer")

} else {

alert("Decimal")

}

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

var re=/^-?[0-9]+$/;
var num=10;
re.test(num);

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

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

parseInt(num) === num

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

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

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

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
}

นี่คือข้อความที่ตัดตอนมาจากห้องสมุดยามของฉัน (แรงบันดาลใจจาก 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

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

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

function isDecimal(num) {
  return (num !== parseInt(num, 10));
}

คุณสามารถใช้การดำเนินการระดับบิตที่ไม่เปลี่ยนค่า ( ^ 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

function isWholeNumber(num) {
  return num === Math.round(num);
}

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

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 บังคับให้ค่าเป็นบูลีนและจะแปรค่าของมัน ฉันใช้ !! เพื่อบังคับให้ค่าเป็นบูลีนและกลับค่าเป็นค่าบูลีนเดิม

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

function IsDecimalExist(p_decimalNumber) {
    var l_boolIsExist = true;

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

    return l_boolIsExist;
}

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

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

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

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

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

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