ฉันจะแปลงเลขทศนิยมเป็นจำนวนเต็มใน JavaScript ได้อย่างไร

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

var intvalue = Math.floor( floatvalue );
var intvalue = Math.ceil( floatvalue ); 
var intvalue = Math.round( floatvalue );

// `Math.trunc` was added in ECMAScript 6
var intvalue = Math.trunc( floatvalue );

การอ้างอิงวัตถุทางคณิตศาสตร์

ตัวอย่าง

// value=x        //  x=5          5<x<5.5      5.5<=x<6  

Math.floor(value) //  5            5            5
Math.ceil(value)  //  5            6            6
Math.round(value) //  5            5            6
Math.trunc(value) //  5            5            5
parseInt(value)   //  5            5            5
~~value           //  5            5            5
value | 0         //  5            5            5
value >> 0        //  5            5            5
value >>> 0       //  5            5            5
value - value % 1 //  5            5            5

// value=x        // x=-5         -5>x>=-5.5   -5.5>x>-6

Math.floor(value) // -5           -6           -6
Math.ceil(value)  // -5           -5           -5
Math.round(value) // -5           -5           -6
Math.trunc(value) // -5           -5           -5
parseInt(value)   // -5           -5           -5
value | 0         // -5           -5           -5
~~value           // -5           -5           -5
value >> 0        // -5           -5           -5
value >>> 0       // 4294967291   4294967291   4294967291
value - value % 1 // -5           -5           -5

// x = Number.MAX_SAFE_INTEGER/10 // =900719925474099.1

// value=x            x=900719925474099    x=900719925474099.4  x=900719925474099.5

Math.floor(value) //  900719925474099      900719925474099      900719925474099
Math.ceil(value)  //  900719925474099      900719925474100      900719925474100
Math.round(value) //  900719925474099      900719925474099      900719925474100
Math.trunc(value) //  900719925474099      900719925474099      900719925474099
parseInt(value)   //  900719925474099      900719925474099      900719925474099
value | 0         //  858993459            858993459            858993459
~~value           //  858993459            858993459            858993459
value >> 0        //  858993459            858993459            858993459
value >>> 0       //  858993459            858993459            858993459
value - value % 1 //  900719925474099      900719925474099      900719925474099

// x = Number.MAX_SAFE_INTEGER/10 * -1 // -900719925474099.1

// value = x      // x=-900719925474099   x=-900719925474099.5 x=-900719925474099.6

Math.floor(value) // -900719925474099     -900719925474100     -900719925474100
Math.ceil(value)  // -900719925474099     -900719925474099     -900719925474099
Math.round(value) // -900719925474099     -900719925474099     -900719925474100
Math.trunc(value) // -900719925474099     -900719925474099     -900719925474099
parseInt(value)   // -900719925474099     -900719925474099     -900719925474099
value | 0         // -858993459           -858993459           -858993459
~~value           // -858993459           -858993459           -858993459
value >> 0        // -858993459           -858993459           -858993459
value >>> 0       //  3435973837           3435973837           3435973837
value - value % 1 // -900719925474099     -900719925474099     -900719925474099

ตัวดำเนินการระดับบิตหรือ

bitwise หรือโอเปอเรเตอร์สามารถใช้เพื่อตัดทอนตัวเลขจุดลอยตัวและใช้ได้กับผลบวกเช่นเดียวกับเนกาทีฟ:

function float2int (value) {
    return value | 0;
}

ผล

float2int(3.1) == 3
float2int(-3.1) == -3
float2int(3.9) == 3
float2int(-3.9) == -3

การเปรียบเทียบประสิทธิภาพ?

ฉันได้สร้างการทดสอบ JSPerfที่เปรียบเทียบประสิทธิภาพระหว่าง:

• Math.floor(val)
• val | 0 ^{ค่าบิตหรือ}
• ~~val ^{ไม่ bitwise}
• parseInt(val)

ใช้งานได้กับจำนวนบวกเท่านั้น ในกรณีนี้คุณปลอดภัยที่จะใช้การทำงานระดับบิตรวมทั้งMath.floorฟังก์ชั่น

แต่ถ้าคุณต้องการให้โค้ดทำงานกับผลบวกและเนกาทีฟการดำเนินการระดับบิตจะเร็วที่สุด (หรือเป็นรหัสที่ต้องการ) การทดสอบ JSPerf อื่น ๆ นี้เปรียบเทียบสิ่งเดียวกันกับที่เห็นได้ชัดว่าเนื่องจากการตรวจสอบเครื่องหมายเพิ่มเติมทางคณิตศาสตร์ตอนนี้ช้าที่สุดในสี่รายการ

บันทึก

ตามที่ระบุไว้ในความคิดเห็นผู้ประกอบการ BITWISE ทำงานกับจำนวนเต็ม 32 บิตที่ลงนามดังนั้นจำนวนมากจะถูกแปลงตัวอย่างเช่น:

1234567890  | 0 => 1234567890
12345678901 | 0 => -539222987

หมายเหตุ: คุณไม่สามารถใช้Math.floor()แทนการตัดทอนได้เพราะMath.floor(-3.1) = -4ไม่ใช่-3!!

การแทนที่ที่ถูกต้องสำหรับการตัดจะเป็น:

function truncate(value)
{
    if (value < 0) {
        return Math.ceil(value);
    }

    return Math.floor(value);
}

สามารถใช้โอเปอเรเตอร์bitwiseสองเท่าไม่ได้เพื่อตัดทอน การดำเนินงานอื่น ๆ ที่คุณกล่าวถึงเป็นใช้ได้ผ่านMath.floor, และMath.ceilMath.round

> ~~2.5
2
> ~~(-1.4)
-1

รายละเอียดเพิ่มเติมได้รับความอนุเคราะห์จาก James Padolsey

สำหรับการตัด:

var intvalue = Math.floor(value);

สำหรับรอบ:

var intvalue = Math.round(value);

คุณสามารถใช้วิธีparseIntโดยไม่มีการปัดเศษ ระมัดระวังการป้อนข้อมูลผู้ใช้เนื่องจากตัวเลือกนำหน้า 0x (hex) และ 0 (octal)

var intValue = parseInt(floatValue, 10);

การเลื่อนบิต 0 ซึ่งเทียบเท่ากับการหารด้วย 1

// >> or >>>
2.0 >> 0; // 2
2.0 >>> 0; // 2

ในกรณีของคุณเมื่อคุณต้องการสตริงในท้ายที่สุด (เพื่อแทรกเครื่องหมายจุลภาค) คุณยังสามารถใช้Number.toFixed()ฟังก์ชันได้ แต่สิ่งนี้จะทำการปัดเศษ

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

intval = floatval - floatval%1;

วิธีนี้ยังทำงานกับตัวเลขที่มีมูลค่าสูงซึ่งทั้ง '| 0' หรือ '~~' หรือ '>> 0' ทำงานไม่ถูกต้อง:

> n=4294967295;
> n|0
-1
> ~~n
-1
> n>>0
-1
> n-n%1
4294967295

วิธีตัดทอน :

// Math.trunc() is part of the ES6 spec
Math.trunc( 1.5 );  // returns 1
Math.trunc( -1.5 ); // returns -1
// Math.floor( -1.5 ) would return -2, which is probably not what you wanted

ถึงรอบ :

Math.round( 1.5 );  // 2
Math.round( 1.49 ); // 1
Math.round( -1.6 ); // -2
Math.round( -1.3 ); // -1

อีกวิธีหนึ่งที่เป็นไปได้ - ใช้การดำเนินการ XOR:

console.log(12.3 ^ 0); // 12
console.log("12.3" ^ 0); // 12
console.log(1.2 + 1.3 ^ 0); // 2
console.log(1.2 + 1.3 * 2 ^ 0); // 3
console.log(-1.2 ^ 0); // -1
console.log(-1.2 + 1 ^ 0); // 0
console.log(-1.2 - 1.3 ^ 0); // -2

ลำดับความสำคัญของการดำเนินการระดับบิตที่น้อยกว่าลำดับความสำคัญของการดำเนินการทางคณิตศาสตร์มันมีประโยชน์ ลองที่https://jsfiddle.net/au51uj3r/

หากมองไปที่Mathวัตถุพื้นเมืองใน JavaScript คุณจะได้รับฟังก์ชั่นมากมายในการทำงานกับตัวเลขและค่า ฯลฯ

โดยทั่วไปสิ่งที่คุณต้องการทำนั้นค่อนข้างง่ายและเป็นภาษาจาวาสคริปต์ ...

ลองนึกภาพคุณมีหมายเลขด้านล่าง:

const myValue = 56.4534931;

และตอนนี้ถ้าคุณต้องการปัดเศษมันเป็นตัวเลขที่ใกล้ที่สุดเพียงแค่ทำ:

const rounded = Math.floor(myValue);

และคุณจะได้รับ:

56

หากคุณต้องการปัดเศษขึ้นเป็นตัวเลขที่ใกล้ที่สุดให้ทำดังนี้

const roundedUp = Math.ceil(myValue);

และคุณจะได้รับ:

57

นอกจากนี้Math.roundเพียงแค่ปัดมันเป็นจำนวนที่สูงหรือต่ำกว่านั้นขึ้นอยู่กับว่าใครอยู่ใกล้กับจำนวน flot

นอกจากนี้คุณสามารถใช้~~หลังตัวเลขลอยที่จะแปลงลอยเป็นจำนวนเต็ม

คุณสามารถใช้มันเหมือน~~myValue...

ฉันแค่อยากจะชี้ให้เห็นว่าคุณต้องการปัดเศษรายได้โดยไม่ตัดทอน การถูกเพนนีมีโอกาสน้อยกว่ามากเนื่องจากการปัดเศษ 4.999452 * 100 จะให้ 5 คำตอบที่เป็นตัวแทนของคุณมากกว่า

อย่าลืมเกี่ยวกับการปัดเศษของนายธนาคารซึ่งเป็นวิธีที่จะตอบโต้อคติเชิงบวกเล็กน้อยที่การปัดเศษให้ตรง - ใบสมัครทางการเงินของคุณอาจต้องการ

การปัดเศษแบบเกาส์ / นายธนาคารใน JavaScript

หากคุณใช้ angularjs แล้ววิธีง่ายๆดังต่อไปนี้ในการผูกแม่แบบ HTML

{{val | number:0}}

มันจะแปลง val เป็นจำนวนเต็ม

ทำตามลิงค์นี้docs.angularjs.org/api/ng/filter/number