หมายเลข Js โดยไม่ต้องปัดเศษ รากสี่เหลี่ยมและลูกบาศก์ ปัดเศษเป็นพหุคูณที่ใกล้ที่สุด

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

งาน: จำนวนตำแหน่งทศนิยมของจาวาสคริปต์

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

มีหลายวิธีในการแก้ปัญหานี้

โซลูชันที่ 1: จำนวนตำแหน่งทศนิยมของจาวาสคริปต์โดยใช้วิธี toFixed

toFixed เป็นวิธีจาวาสคริปต์ในตัวที่ใช้กับตัวเลขใดๆ โดยใช้ความแม่นยำในการปัดเศษ (นั่นคือจำนวนตำแหน่งทศนิยม) เป็นพารามิเตอร์

ตัวเลข=1538.9891200153; num_str=num.toFixed(); //num_str=1538; num_str=num.toFixed(2); //num_str=1538.98; num_str=num.toFixed(5); //num_str=1538.98912;

พารามิเตอร์ความแม่นยำในฟังก์ชันนี้ต้องไม่น้อยกว่า 0 (ไม่ยอมรับค่าลบ) และไม่เกิน 20

คุณสามารถทำได้โดยไม่มีตัวแปร เช่น:

Num_str=(1538.9891200153).toFixed(2); //num_str=1538.98;

โซลูชันที่ 2: จำนวนตำแหน่งทศนิยมของจาวาสคริปต์โดยใช้วิธี toPrecision

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

ตัวเลข=1538.9891200153; num_str=num.toความแม่นยำ(5); //num_str=1538.9; num_str=num.toความแม่นยำ(7); //num_str=1538.989;

วิธีแก้ปัญหาโดยไม่มีตำแหน่งทศนิยม: จำนวนตำแหน่งทศนิยมของจาวาสคริปต์

หากจำเป็นต้องลบตำแหน่งทศนิยมออกทั้งหมดนั่นคือคุณต้องปัดเศษ จำนวนเศษส่วนเป็นจำนวนเต็ม จากนั้นคุณสามารถใช้ฟังก์ชันได้ ชั้นเรียนคณิตศาสตร์: กลม เพดาน และพื้น
รอบ - ปัดขึ้นหรือลง (ขึ้นอยู่กับจำนวน) หากค่าหลังจุดทศนิยมมากกว่าครึ่งจะถูกปัดเศษเป็น ด้านใหญ่ถ้าน้อยไปน้อย นั่นคือ ถ้า 0.51 กลายเป็น 1 ถ้า 0.49 กลายเป็น 0

ซีล - จากภาษาอังกฤษ เพดานจะโค้งขึ้นเสมอ

ชั้น - จากภาษาอังกฤษ พื้นจะโค้งมนลงเสมอ

ตัวเลข = 1538.9891200153; num_str=Math.round(ตัวเลข); //num_str=1539; num_str=Math.floor(ตัวเลข); //num_str=1538; num_str=Math.ceil(ตัวเลข); //num_str=1539;

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

การคำนวณมักให้ผลลัพธ์ที่อยู่นอกช่วงที่ต้องการ จึงจำเป็นต้องปฏิบัติ การปัดเศษ JavaScript จนถึงค่าหนึ่ง

ทำไมต้องเป็นเลขกลม?

JavaScript ไม่เก็บจำนวนเต็มเนื่องจากค่าของมันแสดงเป็นตัวเลขทศนิยม เศษส่วนจำนวนมากไม่สามารถแสดงเป็นตัวเลขที่มีจำนวนตำแหน่งทศนิยมที่จำกัดได้ ดังนั้น JavaScript จึงสามารถสร้างผลลัพธ์ดังต่อไปนี้:

0.1 * 0.2; > 0.020000000000000004

ในทางปฏิบัติสิ่งนี้จะไม่สร้างความแตกต่างใดๆ ตั้งแต่นั้นมา เรากำลังพูดถึงประมาณข้อผิดพลาด 2 ล้านล้าน แต่สิ่งนี้อาจส่งผลต่อผลลัพธ์เมื่อทำงานกับตัวเลขที่แสดงค่าสกุลเงิน เปอร์เซ็นต์ หรือขนาดไฟล์ ดังนั้นคุณต้องทำหรือถึงจุดทศนิยมที่แน่นอน

การปัดเศษเลขทศนิยม

เพื่อ "ตัด" เลขทศนิยมมีการใช้เมธอด toFixed() หรือ toPrecision() ทั้งคู่รับอาร์กิวเมนต์เดียว ซึ่งระบุจำนวนตำแหน่งที่มีนัยสำคัญและทศนิยมที่จะรวมไว้ในผลลัพธ์:

ถ้า toFixed() ไม่ได้ระบุอาร์กิวเมนต์ ค่าเริ่มต้นคือ 0 นั่นคือไม่มีตำแหน่งทศนิยม ค่าสูงสุดอาร์กิวเมนต์คือ 20 ;
หากไม่มีการกำหนดอาร์กิวเมนต์ให้กับ toPrecision() จำนวนจะไม่เปลี่ยนแปลง

var randNum = 6.25; randNum.toFixed(); > "6" Math.PI.toPrecision(1); > "3" เป็น randNum = 87.335; randNum.toFixed(2); > "87.33" เป็น randNum = 87.337; randNum.toความแม่นยำ(3); > "87.3"

บันทึก

ทั้ง toFixed() และ toPrecision ส่งคืนการแสดงสตริงแบบปัดเศษของผลลัพธ์ แทนที่จะเป็นตัวเลข ซึ่งหมายความว่าการเพิ่มการปัดเศษให้กับ randNum จะส่งผลให้มีการต่อสตริงเข้าด้วยกันแทนที่จะเป็นตัวเลขตัวเดียว:

console.log (randNum + ปัดเศษ); > "6.256"

หากคุณต้องการให้ JavaScript ปัดเศษตัวเลขให้เป็นทศนิยมที่ใกล้ที่สุด ให้ใช้ parseFloat() :

var randNum = 6.25; var ปัดเศษ = parseFloat (randNum.toFixed (1)); console.log (ปัดเศษ); > 6.3

toFixed() และ toPrecision() ยังเป็นวิธีการที่มีประโยชน์สำหรับการตัดแต่งอีกด้วย ปริมาณมากตำแหน่งทศนิยม สิ่งนี้มีประโยชน์เมื่อทำงานกับตัวเลขที่แสดงถึงหน่วยการเงิน:

var wholeNum = 1 var dollarCents = wholeNum.toFixed(2); console.log(dollarsCents); > "1.00"

โปรดทราบว่าหากตัวเลขมีตัวเลขมากกว่าความแม่นยำที่ระบุ toPrecision จะแสดงผลลัพธ์ในรูปแบบวิทยาศาสตร์:

var num = 123.435 num.toPrecision (2); > "1.2e+2"

วิธีหลีกเลี่ยงข้อผิดพลาดในการปัดเศษทศนิยม

ในบางกรณี toFixed และ toPrecision นำไปใช้ JavaScript ปัดเศษ 5 ลงและไม่มากไปกว่านี้:

var numTest = 1.005; numTest.toFixed (2); > 1;

ผลลัพธ์ของตัวอย่างข้างต้นควรเป็น 1.01 ไม่ใช่ 1 หากคุณต้องการหลีกเลี่ยงข้อผิดพลาดนี้ ฉันขอแนะนำให้ใช้เลขเอ็กซ์โพเนนเชียล:

ฟังก์ชัน รอบ(ค่า, ทศนิยม) ( return Number(Math.round(value+"e"+decimals)+"e-"+decimals); )

แอปพลิเคชัน:

รอบ(1.005,2); > 1.01

หากคุณต้องการโซลูชันที่มีประสิทธิภาพมากกว่าการปัดเศษ มีจำหน่ายที่ เอ็มดีเอ็น.

การปัดเศษด้วยเอปไซลอน

วิธีการทางเลือก JavaScript ปัดเศษเป็นสิบเปิดตัวใน ES6 ( หรือที่เรียกว่า JavaScript 2015). « เอปไซลอนของเครื่อง" ให้ข้อผิดพลาดที่สมเหตุสมผลเมื่อเปรียบเทียบตัวเลขทศนิยมสองตัว หากไม่มีการปัดเศษ การเปรียบเทียบอาจให้ผลลัพธ์ที่คล้ายกับต่อไปนี้:

0.1 + 0.2 === 0.3 > เท็จ

Math.EPSILON สามารถใช้ในฟังก์ชันเพื่อรับการเปรียบเทียบที่ถูกต้อง:

ฟังก์ชั่น epsEqu(x, y) ( ส่งกลับ Math.abs(x - y)< Number.EPSILON * Math.max(Math.abs(x), Math.abs(y)); }

ฟังก์ชันรับสองอาร์กิวเมนต์: อันหนึ่งประกอบด้วยการคำนวณ ส่วนอันที่สองคือผลลัพธ์ที่คาดหวัง (ปัดเศษ) โดยจะส่งกลับการเปรียบเทียบของพารามิเตอร์ทั้งสองนี้:

epsEqu(0.1 + 0.2, 0.3) > จริง

รองรับเบราว์เซอร์สมัยใหม่ทั้งหมด ฟังก์ชันทางคณิตศาสตร์อีเอส6. แต่หากคุณต้องการให้การสนับสนุนในเบราว์เซอร์รุ่นเก่า คุณจะต้องใช้โพลีฟิล

การตัดทอนตัวเลขทศนิยม

วิธีการทั้งหมดที่นำเสนอก่อนหน้านี้ดำเนินการ JavaScript ปัดเศษเป็นสิบ- เพื่อตัดทอน จำนวนบวกเป็นทศนิยมสองตำแหน่ง คูณด้วย 100 ตัดทอนอีกครั้ง แล้วหารผลลัพธ์ด้วย 100 คุณต้องการ:

ฟังก์ชั่น truncated(num) ( return Math.trunc(num * 100) / 100; ) truncated(3.1416) > 3.14

หากคุณต้องการอะไรที่ยืดหยุ่นกว่านี้ คุณสามารถใช้ตัวดำเนินการระดับบิต:

ฟังก์ชั่นถูกตัดทอน (num, decimalPlaces) ( var numPowerConverter = Math.pow(10, decimalPlaces); return ~~(num * numPowerConverter)/numPowerConverter; )

การใช้งาน:

var randInt = 35.874993; ตัดทอน (randInt,3); > 35.874

ปัดเศษให้เป็นตัวเลขที่ใกล้ที่สุด

เพื่อนำไปปฏิบัติ JavaScript ปัดเศษเป็นจำนวนเต็มที่ใกล้ที่สุด, Math.round() ถูกใช้:

รอบคณิต(4.3) > 4 รอบคณิต(4.5) > 5

โปรดทราบว่า " ครึ่งหนึ่งของค่า" เช่น .5 ให้ปัดเศษขึ้น

ปัดเศษลงให้เป็นจำนวนเต็มที่ใกล้ที่สุด

หากคุณต้องการปัดเศษลง ให้ใช้เมธอด Math.floor() ดังนี้

คณิต.พื้น(42.23); > 42 คณิตพื้น(36.93); > 36

การปัดเศษลงจะมีทิศทางเดียวสำหรับตัวเลขทั้งหมด รวมถึงจำนวนลบด้วย นี่สามารถจินตนาการได้ว่าเป็นตึกระฟ้าที่มีจำนวนชั้นไม่สิ้นสุด รวมถึงอยู่ต่ำกว่าระดับฐานรากด้วย ( แทนจำนวนลบ- หากคุณอยู่ในลิฟต์ระหว่างชั้นใต้ดินชั้น 2 และ 3 ( ซึ่งสอดคล้องกับค่า -2.5) Math.floor จะนำคุณไปที่ชั้น -3:

คณิต.พื้น(-2.5); > -3

หากคุณต้องการหลีกเลี่ยงสิ่งนี้ ให้ใช้การปัดเศษทางคณิตศาสตร์ของ JavaScript โดยใช้ Math.trunc() ซึ่งรองรับในทุกกรณี เบราว์เซอร์ที่ทันสมัย(ยกเว้น IE/ขอบ):

Math.trunc(-41.43); > -41

MDN ก็มีให้เช่นกัน polyfill สามบรรทัดเพื่อรองรับ Math.trunc ในเบราว์เซอร์รุ่นเก่าและ IE/Edge.

ปัดเศษขึ้นให้เป็นจำนวนเต็มที่ใกล้ที่สุด

หากคุณต้องการปัดเศษทศนิยมขึ้น ให้ใช้ Math.ceil วิธีนี้สามารถมองได้ว่าเป็นลิฟต์ที่ไม่มีที่สิ้นสุด: Math.ceil จะพาคุณ "ขึ้น" เสมอ ไม่ว่าตัวเลขจะเป็นลบหรือบวกก็ตาม:

คณิต.ซีล์(42.23); > 43 คณิต.ซีล์(36.93); > 37 คณิตซีล์(-36.93); -36

ปัดเศษเป็นพหุคูณที่ใกล้ที่สุด

หากคุณต้องการปัดเศษค่าให้เป็นพหุคูณที่ใกล้ที่สุดของ 5 ให้สร้างฟังก์ชันที่หารตัวเลขด้วย 5 ปัดเศษ แล้วคูณผลลัพธ์ด้วยค่าเดียวกัน:

ฟังก์ชั่น roundTo5(num) ( return Math.round(num/5)*5; )

การใช้งาน:

รอบถึง5(11); > 10

หากคุณต้องการให้ JavaScript ปัดเศษเป็นตัวเลขสองหลัก คุณสามารถส่งทั้งค่าเริ่มต้นและค่าพหุคูณไปยังฟังก์ชันได้:

ฟังก์ชั่น roundToMultiple(num, multiple) ( return Math.round(num/multiple)*multiple; )

หากต้องการใช้ฟังก์ชันนี้ ให้ใส่ตัวเลขที่จะปัดเศษและจำนวนพหุคูณในการเรียก:

var defaultNumber = 11; หลายตัวแปร = 10; RoundToMultiple (หมายเลขเริ่มต้น, หลายรายการ); > 10;

หากต้องการปัดเศษค่าขึ้นหรือลงเท่านั้น ให้แทนที่ทรงกลมด้วยเพดานหรือพื้นในฟังก์ชัน

การเชื่อมโยงช่วง

บางครั้งคุณต้องได้ค่า x ซึ่งต้องอยู่ภายใน บางช่วง- ตัวอย่างเช่น เราต้องการค่าตั้งแต่ 1 ถึง 100 แต่เราได้รับค่า 123 เพื่อแก้ไขปัญหานี้คุณสามารถใช้ min() ( ส่งกลับจำนวนที่น้อยที่สุด) และสูงสุด ( ส่งคืนจำนวนสูงสุดที่อนุญาต).

การใช้งาน:

var ขอบเขตต่ำ = 1; var ขอบเขตสูง = 100; var numInput = 123; var ถูกยึด = Math.max(lowBound, Math.min(numInput, highBound)); console.log (หนีบ); > 100;

คุณสามารถสร้างฟังก์ชันหรือส่วนขยายของคลาส Number ได้:

Number.prototype.clamp = function(min, max) ( return Math.min(Math.max(this, min), max); );

การใช้งาน:

(numInput).แคลมป์(lowBound, highBound);

การปัดเศษแบบเกาส์เซียน

การปัดเศษแบบเกาส์เซียน (“การธนาคาร” มาบรรจบกันหรือดัตช์) เป็นวิธีการปัดเศษโดยไม่มีข้อผิดพลาดทางสถิติ มาตรฐาน การปัดเศษ JavaScriptบางครั้งก็ทำให้เกิดข้อผิดพลาดในทิศทางที่ใหญ่กว่า การปัดเศษแบบเกาส์เซียนจะหลีกเลี่ยงข้อผิดพลาดนี้โดยการปัดเศษให้เป็นเลขคู่ที่ใกล้ที่สุด ทางออกที่ดีที่สุดซึ่งฉันรู้

ทำไมต้องเป็นเลขกลม?

0.1 * 0.2; > 0.020000000000000004

ในทางปฏิบัติ สิ่งนี้จะไม่สร้างความแตกต่างใดๆ เนื่องจากเรากำลังพูดถึงข้อผิดพลาดที่ 2 ในล้านล้าน แต่สิ่งนี้อาจส่งผลต่อผลลัพธ์เมื่อทำงานกับตัวเลขที่แสดงค่าสกุลเงิน เปอร์เซ็นต์ หรือขนาดไฟล์ ดังนั้นคุณต้องทำหรือถึงจุดทศนิยมที่แน่นอน

การปัดเศษเลขทศนิยม

ถึง " เล็ม» เลขทศนิยม ใช้วิธี toFixed() หรือ toPrecision() ทั้งคู่รับอาร์กิวเมนต์เดียว ซึ่งระบุจำนวนตำแหน่งที่มีนัยสำคัญและทศนิยมที่จะรวมไว้ในผลลัพธ์:

ถ้า toFixed() ไม่ได้ระบุอาร์กิวเมนต์ ค่าเริ่มต้นคือ 0 นั่นคือไม่มีตำแหน่งทศนิยม ค่าอาร์กิวเมนต์สูงสุดคือ 20 ;
หากไม่มีการกำหนดอาร์กิวเมนต์ให้กับ toPrecision() จำนวนจะไม่เปลี่ยนแปลง

บันทึก

Console.log (randNum + ปัดเศษ); > "6.256"

เท่ากับ randNum = 6.25; var ปัดเศษ = parseFloat (randNum.toFixed (1)); console.log (ปัดเศษ); > 6.3

toFixed() และ toPrecision() ยังเป็นวิธีการที่มีประโยชน์ในการตัดทอนตำแหน่งทศนิยมจำนวนมาก สิ่งนี้มีประโยชน์เมื่อทำงานกับตัวเลขที่แสดงถึงหน่วยการเงิน:

Var WholeNum = 1 var DollarCents = WholeNum.toFixed(2); console.log(dollarsCents); > "1.00"

Var num = 123.435 num.toความแม่นยำ (2); > "1.2e+2"

วิธีหลีกเลี่ยงข้อผิดพลาดในการปัดเศษทศนิยม

ในบางกรณี toFixed และ toPrecision นำไปใช้ JavaScript ปัดเศษ 5 ลงและไม่มากไปกว่านี้:

ตัวแปร numTest = 1.005; numTest.toFixed (2); > 1;

ฟังก์ชันปัดเศษ(ค่า, ทศนิยม) ( return Number(Math.round(value+"e"+decimals)+"e-"+decimals); )

แอปพลิเคชัน:

รอบ(1.005,2); > 1.01

การปัดเศษด้วยเอปไซลอน

วิธีการทางเลือก JavaScript ปัดเศษเป็นสิบเปิดตัวใน ES6 ( หรือที่เรียกว่า JavaScript 2015). "เอปไซลอนของเครื่อง" ให้ข้อผิดพลาดที่สมเหตุสมผลเมื่อเปรียบเทียบตัวเลขทศนิยมสองตัว หากไม่มีการปัดเศษ การเปรียบเทียบจะให้ผลลัพธ์ที่คล้ายกับตัวอย่างต่อไปนี้:

0.1 + 0.2 === 0.3 > เท็จ

Math.EPSILON สามารถใช้ในฟังก์ชันเพื่อรับการเปรียบเทียบที่ถูกต้อง:

ฟังก์ชัน epsEqu(x, y) ( ส่งกลับ Math.abs(x - y)< Number.EPSILON * Math.max(Math.abs(x), Math.abs(y)); }

ฟังก์ชันรับสองอาร์กิวเมนต์: อันหนึ่งมีการคำนวณ ส่วนอันที่สองคาดว่า ( โค้งมน) ผลลัพธ์. จะส่งกลับการเปรียบเทียบของพารามิเตอร์ทั้งสองนี้:

EpsEqu(0.1 + 0.2, 0.3) > จริง

เบราว์เซอร์สมัยใหม่ทั้งหมดรองรับฟังก์ชันทางคณิตศาสตร์ ES6 แต่หากคุณต้องการให้การสนับสนุนในเบราว์เซอร์รุ่นเก่า คุณจะต้องใช้โพลีฟิล

การตัดทอนตัวเลขทศนิยม

วิธีการทั้งหมดที่นำเสนอก่อนหน้านี้ดำเนินการ JavaScript ปัดเศษเป็นสิบ- หากต้องการตัดจำนวนบวกให้เป็นทศนิยมสองตำแหน่ง ให้คูณด้วย 100 ตัดอีกครั้ง จากนั้นหารผลลัพธ์ด้วย 100:

ฟังก์ชั่น truncated(num) ( return Math.trunc(num * 100) / 100; ) truncated(3.1416) > 3.14

ฟังก์ชั่นถูกตัดทอน (num, decimalPlaces) ( var numPowerConverter = Math.pow(10, decimalPlaces); return ~~(num * numPowerConverter)/numPowerConverter; )

การใช้งาน:

ตัวแปร RandInt = 35.874993; ตัดทอน (randInt,3); > 35.874

ปัดเศษให้เป็นตัวเลขที่ใกล้ที่สุด

เพื่อนำไปปฏิบัติ JavaScript ปัดเศษเป็นจำนวนเต็มที่ใกล้ที่สุด, Math.round() ถูกใช้:

รอบคณิต(4.3) > 4 รอบคณิต(4.5) > 5

โปรดทราบว่า " ครึ่งหนึ่งของค่า" เช่น .5 ให้ปัดเศษขึ้น

ปัดเศษลงให้เป็นจำนวนเต็มที่ใกล้ที่สุด

หากคุณต้องการปัดเศษลง ให้ใช้เมธอด Math.floor() ดังนี้

คณิต.พื้น(42.23); > 42 คณิตพื้น(36.93); > 36

การปัดเศษ" ลง" มีทิศทางเดียวสำหรับตัวเลขทั้งหมด รวมถึงจำนวนลบด้วย ซึ่งสามารถจินตนาการได้ว่าเป็นตึกระฟ้าที่มีจำนวนชั้นไม่สิ้นสุด รวมทั้งอยู่ต่ำกว่าระดับฐานรากด้วย ( แทนจำนวนลบ- หากคุณอยู่ในลิฟต์ระหว่างชั้นใต้ดินชั้น 2 และ 3 ( ซึ่งสอดคล้องกับค่า -2.5) Math.floor จะนำคุณไปที่ชั้น -3:

คณิต.พื้น(-2.5); > -3

หากคุณต้องการหลีกเลี่ยงสิ่งนี้ ให้ใช้การปัดเศษทางคณิตศาสตร์ของ JavaScript โดยใช้ Math.trunc() ซึ่งรองรับในเบราว์เซอร์รุ่นใหม่ทั้งหมด ( ยกเว้น IE/Edge):

Math.trunc(-41.43); > -41

ปัดเศษขึ้นให้เป็นจำนวนเต็มที่ใกล้ที่สุด

หากคุณต้องการปัดเศษทศนิยมขึ้น ให้ใช้ Math.ceil ผลกระทบของวิธีนี้ถือได้ว่าเป็นลิฟต์ที่ไม่มีที่สิ้นสุด: Math.ceil จะพาคุณไปเสมอ " ขึ้น" ไม่ว่าตัวเลขจะเป็นลบหรือบวกก็ตาม:

คณิต.ซีล์(42.23); > 43 คณิต.ซีล์(36.93); > 37 คณิต.ซีล์(-36.93); -36

ปัดเศษเป็นพหุคูณที่ใกล้ที่สุด

ฟังก์ชั่น roundTo5(num) ( return Math.round(num/5)*5; )

การใช้งาน:

รอบถึง5(11); > 10

ฟังก์ชั่น roundToMultiple(num, multiple) ( return Math.round(num/multiple)*multiple; )

ตัวแปรเริ่มต้นหมายเลข = 11; หลายตัวแปร = 10; RoundToMultiple (หมายเลขเริ่มต้น, หลายรายการ); > 10;

การเชื่อมโยงช่วง

บางครั้งคุณต้องได้ค่า x ที่ต้องอยู่ในช่วงที่กำหนด ตัวอย่างเช่น เราต้องการค่าตั้งแต่ 1 ถึง 100 แต่เราได้รับค่า 123 เพื่อแก้ไขปัญหานี้คุณสามารถใช้ min() ( ส่งกลับจำนวนที่น้อยที่สุด) และสูงสุด ( ส่งคืนจำนวนสูงสุดที่อนุญาต).

การใช้งาน:

ขอบเขตต่ำ = 1; var ขอบเขตสูง = 100; var numInput = 123; var ถูกยึด = Math.max(lowBound, Math.min(numInput, highBound)); console.log (หนีบ); > 100;

คุณสามารถสร้างฟังก์ชันหรือส่วนขยายของคลาส Number ได้:

Number.prototype.clamp = function(min, max) ( return Math.min(Math.max(this, min), max); );

การใช้งาน:

(numInput).แคลมป์(lowBound, highBound);

การปัดเศษแบบเกาส์เซียน

การปัดเศษแบบเกาส์เซียน (" การธนาคาร", มาบรรจบกันหรือดัตช์) เป็นวิธีการปัดเศษโดยไม่มีข้อผิดพลาดทางสถิติ มาตรฐาน การปัดเศษ JavaScriptบางครั้งก็ทำให้เกิดข้อผิดพลาดในทิศทางที่ใหญ่กว่า การปัดเศษแบบเกาส์เซียนจะหลีกเลี่ยงข้อผิดพลาดนี้โดยการปัดเศษให้เป็นเลขคู่ที่ใกล้ที่สุด ทางออกที่ดีที่สุดที่ฉันรู้คือ:

ฟังก์ชัน gaussRound(num, decimalPlaces) ( var d = decimalPlaces || 0, m = Math.pow(10, d), n = +(d ? num * m: num).toFixed(8), i = Math.floor (n), f = n - i, e = 1e-8, r = (f > 0.5 - e && f< 0.5 + e) ? ((i % 2 == 0) ? i: i + 1) : Math.round(n); return d ? r / m: r; }

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

เกาส์รอบ(2.5) > 2 เกาส์รอบ(3.5) > 4 เกาส์รอบ(2.57,1) > 2.6

ทศนิยมใน CSS

เนื่องจาก JavaScript มักใช้เพื่อรับข้อมูลตำแหน่งหรือแปลงองค์ประกอบ HTML จึงอาจสงสัยว่าจะเกิดอะไรขึ้นหากเราสร้างค่าทศนิยมสำหรับองค์ประกอบ:

#กล่อง ( กว้าง: 63.667731993px; )

เบราว์เซอร์สมัยใหม่รองรับค่าทศนิยมในรูปแบบบล็อก รวมถึงหน่วยเปอร์เซ็นต์และพิกเซล

การแปลบทความ “JavaScript Rounding Recipes” จัดทำโดยทีมงานที่เป็นมิตรของโครงการสร้างเว็บไซต์จาก A ถึง Z

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

เหตุใดการปัดเศษจึงจำเป็น?

ลักษณะที่น่าสนใจอย่างหนึ่งของ JavaScript ก็คือ มันไม่ได้เก็บจำนวนเต็มจริงๆ แต่เราทำงานกับตัวเลขทศนิยมได้ทันที เมื่อรวมกับความจริงที่ว่าค่าเศษส่วนจำนวนมากไม่สามารถแสดงเป็นทศนิยมจำนวนจำกัดได้ ใน JavaScript เราจะได้ผลลัพธ์ดังนี้:

0.1 * 0.2; > 0.020000000000000004 0.3 - 0.1 > 0.19999999999999998
ในทางปฏิบัติ ความไม่ถูกต้องนี้ไม่สำคัญเลย ในกรณีของเรากำลังพูดถึงข้อผิดพลาดในหน่วยล้านล้าน อย่างไรก็ตาม อาจทำให้บางคนผิดหวัง เรายังอาจได้ผลลัพธ์ที่ค่อนข้างแปลกเมื่อทำงานกับตัวเลขที่แสดงถึงสกุลเงิน เปอร์เซ็นต์ หรือขนาดไฟล์ เพื่อแก้ไขความไม่ถูกต้องเหล่านี้ เราเพียงแค่ต้องปัดเศษผลลัพธ์ได้ และตั้งค่าความแม่นยำของทศนิยมก็เพียงพอแล้ว

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

การปัดเศษเลขทศนิยม

หากต้องการตัดตัวเลขทศนิยม ให้ใช้วิธี toFixed หรือ toPrecision ทั้งสองคนใช้ข้อโต้แย้งเพียงข้อเดียวซึ่งจะกำหนดจำนวนข้อโต้แย้งตามลำดับ ตัวเลขสำคัญ(คือจำนวนหลักที่ใช้ในตัวเลข) หรือตำแหน่งทศนิยม (ตัวเลขหลังจุดทศนิยม) จะต้องมีผลลัพธ์ดังนี้

หากไม่ได้กำหนดอาร์กิวเมนต์สำหรับ toFixed() อาร์กิวเมนต์ก็จะเป็นค่าเริ่มต้น เท่ากับศูนย์ซึ่งหมายถึงทศนิยม 0 ตำแหน่ง อาร์กิวเมนต์มีค่าสูงสุด 20
หากไม่มีการโต้แย้งกับ toPrecision ตัวเลขก็จะไม่ถูกแตะต้อง

ให้ randNum = 6.25; randNum.toFixed(); > "6" Math.PI.toPrecision(1); > "3" แรนด์นัม = 87.335; randNum.toFixed(2); > "87.33" randNum = 87.337; randNum.toความแม่นยำ(3); > "87.3"
ทั้งเมธอด toFixed() และ toPrecision() ส่งคืนการแสดงสตริงของผลลัพธ์ ไม่ใช่ตัวเลข ซึ่งหมายความว่าเมื่อรวมค่าที่ปัดเศษด้วย randNum มันจะสร้างการต่อสตริงเข้าด้วยกันแทนที่จะเป็นผลรวมของตัวเลข:

ให้ randNum = 6.25; ให้ปัดเศษ = randNum.toFixed(); // "6" console.log(randNum + ปัดเศษ); > "6.256"
หากคุณต้องการให้ผลลัพธ์เป็น ประเภทตัวเลข data จากนั้นคุณจะต้องใช้ parseFloat:

ให้ randNum = 6.25; ให้ปัดเศษ = parseFloat(randNum.toFixed(1)); console.log (ปัดเศษ); > 6.3
โปรดทราบว่าค่า 5 จะถูกปัดเศษ ยกเว้นในบางกรณีที่เกิดขึ้นไม่บ่อยนัก

เมธอด toFixed() และ toPrecision() มีประโยชน์เพราะไม่เพียงแต่สามารถคลิปเท่านั้น เศษส่วนแต่ยังต้องเพิ่มตำแหน่งทศนิยมซึ่งสะดวกเมื่อทำงานกับสกุลเงิน:

ให้ WholeNum = 1 ให้ DollarCents = WholeNum.toFixed(2); console.log(dollarsCents); > "1.00"
เป็นที่น่าสังเกตว่า toPrecision จะสร้างผลลัพธ์ในรูปแบบเอ็กซ์โปเนนเชียล หากจำนวนเต็มมากกว่าความแม่นยำนั้นเอง:

ให้ num = 123.435 num.toPrecision(2); > "1.2e+2"

วิธีหลีกเลี่ยงข้อผิดพลาดในการปัดเศษด้วยทศนิยม

ในบางกรณี toFixed และ toPrecision จะปัดเศษค่า 5 ลงและขึ้น:

ให้ numTest = 1.005; numTest.toFixed (2); > "1.00"
ผลลัพธ์ของการคำนวณข้างต้นควรเป็น 1.01 ไม่ใช่ 1 หากคุณต้องการหลีกเลี่ยงข้อผิดพลาดที่คล้ายกัน เราสามารถใช้วิธีแก้ปัญหาที่เสนอโดย Jack L Moore ซึ่งใช้เลขเอ็กซ์โพเนนเชียลในการคำนวณ:

ฟังก์ชันปัดเศษ(ค่า, ทศนิยม) ( return Number(Math.round(value+"e"+decimals)+"e-"+decimals); )
ตอนนี้:

รอบ(1.005,2); > 1.01
หากคุณต้องการโซลูชันที่มีประสิทธิภาพมากกว่าที่แสดงด้านบน คุณสามารถไปที่ MDN

การปัดเศษเอปไซลอนของเครื่อง

มีการแนะนำวิธีการอื่นสำหรับการปัดเศษทศนิยมใน ES6 การปัดเศษเอปไซลอนของเครื่องทำให้เกิดข้อผิดพลาดที่สมเหตุสมผลเมื่อเปรียบเทียบตัวเลขทศนิยมสองตัว หากไม่มีการปัดเศษ การเปรียบเทียบอาจให้ผลลัพธ์ที่คล้ายกับต่อไปนี้:

0.1 + 0.2 === 0.3 > เท็จ
เราใช้ Math.EPSILON ในฟังก์ชันของเราเพื่อรับการเปรียบเทียบที่ถูกต้อง:

ฟังก์ชัน epsEqu(x, y) ( ส่งกลับ Math.abs(x - y)< Number.EPSILON * Math.max(Math.abs(x), Math.abs(y)); }
ฟังก์ชันรับสองอาร์กิวเมนต์ ข้อแรกคือการคำนวณปัจจุบัน ข้อที่สองคือผลลัพธ์ที่คาดหวัง มันจะส่งคืนการเปรียบเทียบของทั้งสอง:

EpsEqu(0.1 + 0.2, 0.3) > จริง
เบราว์เซอร์สมัยใหม่ทั้งหมดรองรับฟังก์ชันทางคณิตศาสตร์ ES6 อยู่แล้ว แต่ถ้าคุณต้องการการสนับสนุนในเบราว์เซอร์เช่น IE 11 ให้ใช้ polyfills

การตัดทอนส่วนที่เป็นเศษส่วน

วิธีการทั้งหมดที่นำเสนอข้างต้นสามารถปัดเศษเป็นเลขทศนิยมได้ หากต้องการตัดตัวเลขให้เป็นทศนิยมสองตำแหน่ง คุณต้องคูณด้วย 100 ก่อน แล้วจึงหารผลลัพธ์ที่ได้ด้วย 100:

ฟังก์ชั่น truncated(num) ( return Math.trunc(num * 100) / 100; ) truncated(3.1416) > 3.14
หากคุณต้องการปรับวิธีการให้เข้ากับตำแหน่งทศนิยมจำนวนเท่าใดก็ได้ คุณสามารถใช้การปฏิเสธสองเท่าระดับบิตได้:

ฟังก์ชั่นถูกตัดทอน (num, decimalPlaces) ( ให้ numPowerConverter = Math.pow(10, decimalPlaces); return ~~(num * numPowerConverter)/numPowerConverter; )
ตอนนี้:

ให้ randInt = 35.874993; ตัดทอน (randInt,3); > 35.874

ปัดเศษให้เป็นตัวเลขที่ใกล้ที่สุด

หากต้องการปัดเศษทศนิยมให้เป็นตัวเลขที่ใกล้ที่สุดขึ้นหรือลง ไม่ว่าคุณจะอยู่ใกล้ที่สุด ให้ใช้ Math.round():

รอบคณิต(4.3) > 4 รอบคณิต(4.5) > 5
โปรดทราบว่า "ค่าครึ่งหนึ่ง" คือ 0.5 จะถูกปัดขึ้นตามกฎของคณิตศาสตร์

ปัดเศษลงให้เป็นจำนวนเต็มที่ใกล้ที่สุด

หากคุณต้องการปัดเศษลงทุกครั้ง ให้ใช้ Math.floor:

คณิต.พื้น(42.23); > 42 คณิตพื้น(36.93); > 36
โปรดทราบว่าการปัดเศษลงใช้ได้กับตัวเลขทั้งหมด รวมถึงจำนวนลบด้วย ลองนึกภาพตึกระฟ้าที่มีจำนวนชั้นเป็นอนันต์ รวมถึงชั้นที่ชั้นล่างสุดด้วย (ซึ่งแสดงถึงจำนวนลบ) หากคุณอยู่ในลิฟต์ ระดับล่างระหว่าง 2 ถึง 3 (ซึ่งแทนค่า -2.5) Math.floor จะนำคุณไปที่ -3:

คณิต.พื้น(-2.5); > -3
แต่หากคุณต้องการหลีกเลี่ยงสถานการณ์นี้ ให้ใช้ Math.trunc ซึ่งรองรับในเบราว์เซอร์รุ่นใหม่ทั้งหมด (ยกเว้น IE/Edge):

Math.trunc(-41.43); > -41
บน MDN คุณจะพบ polyfill ที่จะให้การสนับสนุน Math.trunc ในเบราว์เซอร์และ IE/Edge

ปัดเศษขึ้นให้เป็นจำนวนเต็มที่ใกล้ที่สุด

ในทางกลับกัน หากคุณต้องการปัดเศษขึ้นเสมอ ให้ใช้ Math.ceil ขอย้ำอีกครั้งว่าลิฟต์อันไม่มีที่สิ้นสุด: Math.ceil จะ "ขึ้น" เสมอ ไม่ว่าตัวเลขจะเป็นลบหรือไม่ก็ตาม:

คณิต.ซีล์(42.23); > 43 คณิต.ซีล์(36.93); > 37 คณิต.ซีล์(-36.93); > -36

การปัดเศษขึ้น/ลงตามจำนวนที่ต้องการ

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

ฟังก์ชั่น roundTo5(num) ( return Math.round(num/5)*5; )
ตอนนี้:

รอบถึง5(11); > 10
หากคุณต้องการปัดเศษเป็นทวีคูณของค่าของคุณ เราจะใช้ค่ามากกว่านี้ ฟังก์ชั่นทั่วไปโดยส่งค่าเริ่มต้นและจำนวนทวีคูณเข้าไป:

ฟังก์ชั่น roundToMultiple(num, multiple) ( return Math.round(num/multiple)*multiple; )
ตอนนี้:

ให้ InitialNumber = 11; ให้หลายรายการ = 10; RoundToMultiple (หมายเลขเริ่มต้น, หลายรายการ); > 10;

การแก้ไขตัวเลขในช่วง

มีหลายกรณีที่เราต้องการได้รับค่า x ที่อยู่ในช่วง ตัวอย่างเช่น เราอาจต้องการค่าระหว่าง 1 ถึง 100 แต่สุดท้ายก็ได้ค่า 123 ในการแก้ไขปัญหานี้ เราสามารถใช้ min (ส่งกลับค่าที่น้อยที่สุดของชุดตัวเลข) และ max (ส่งกลับค่าที่ใหญ่ที่สุดของชุดใดๆ ก็ตาม ของตัวเลข) ในตัวอย่างของเรา ช่วงคือตั้งแต่ 1 ถึง 100:

ให้ lowBound = 1; ให้ highBound = 100; ให้ numInput = 123; ให้ยึดไว้ = Math.max(lowBound, Math.min(numInput, highBound)); console.log (หนีบ); > 100;
ขอย้ำอีกครั้งว่าเราสามารถนำการดำเนินการกลับมาใช้ใหม่และรวมทุกอย่างไว้ในฟังก์ชันได้ โดยใช้โซลูชันที่เสนอโดย Daniel X. Moore:

Number.prototype.clamp = function(min, max) ( return Math.min(Math.max(this, min), max); );
ตอนนี้:

NumInput.clamp(ขอบเขตต่ำ, ขอบเขตสูง); > 100;

การปัดเศษแบบเกาส์เซียน

การปัดเศษแบบเกาส์เซียนหรือที่เรียกว่าการปัดเศษของนายธนาคาร เกี่ยวข้องกับการปัดเศษให้เป็นเลขคู่ที่ใกล้ที่สุด วิธีการปัดเศษนี้ใช้งานได้โดยไม่มีข้อผิดพลาดทางสถิติ Tim Down แนะนำวิธีแก้ปัญหาที่ดีกว่า:

ฟังก์ชัน gaussRound(num, decimalPlaces) ( ให้ d = decimalPlaces || 0, m = Math.pow(10, d), n = +(d ? num * m: num).toFixed(8), i = Math.floor (n), f = n - i, e = 1e-8, r = (f > 0.5 - e && f< 0.5 + e) ? ((i % 2 == 0) ? i: i + 1) : Math.round(n); return d ? r / m: r; }
ตอนนี้:

เกาส์รอบ(2.5) > 2 เกาส์รอบ(3.5) > 4 เกาส์รอบ(2.57,1) > 2.6
ทศนิยมใน CSS:

เนื่องจาก JavaScript มักใช้ในการสร้างการแมปตำแหน่งสำหรับองค์ประกอบ HTML คุณอาจสงสัยว่าจะเกิดอะไรขึ้นหากเราสร้างค่าทศนิยมสำหรับองค์ประกอบของเรา:

#กล่อง ( กว้าง: 63.667731993px; )
ข่าวดีก็คือเบราว์เซอร์สมัยใหม่จะเคารพค่าทศนิยมในรูปแบบบล็อก รวมถึงเปอร์เซ็นต์หรือหน่วยพิกเซล

การเรียงลำดับ

บ่อยครั้งที่เราต้องจัดเรียงองค์ประกอบบางอย่าง เช่น เรามีบันทึกเกมมากมาย และจะต้องจัดเรียงตามลำดับอันดับผู้เล่นจากมากไปน้อย น่าเสียดาย, วิธีการมาตรฐาน sort() มีข้อจำกัดที่น่าประหลาดใจ: ใช้งานได้ดีกับคำภาษาอังกฤษทั่วไป แต่จะพังทันทีเมื่อพบตัวเลข อักขระที่ไม่ซ้ำ หรือคำใน ตัวพิมพ์ใหญ่.

เรียงตามตัวอักษร

ดูเหมือนว่าการเรียงลำดับอาร์เรย์ตามตัวอักษรควรเป็นเรื่องง่าย:

ให้ผลไม้ = ["บัตเตอร์นัตสควอช", "แอปริคอท", "แคนตาลูป"]; ผลไม้.sort(); > "แอปริคอท", "บัตเตอร์นัตสควอช", "แคนตาลูป"]
อย่างไรก็ตาม เราประสบปัญหาทันทีที่องค์ประกอบใดองค์ประกอบหนึ่งเป็นตัวพิมพ์ใหญ่:

ให้ผลไม้ = ["บัตเตอร์นัตสควอช", "แอปริคอท", "แคนตาโลป"]; ผลไม้.sort(); > "แคนตาลูป", "แอปริคอท", "สควอชบัตเตอร์นัท"]
เนื่องจากตามค่าเริ่มต้น ตัวเรียงลำดับจะเปรียบเทียบอักขระตัวแรกที่แสดงใน Unicode Unicode เป็นรหัสเฉพาะสำหรับอักขระใดๆ โดยไม่คำนึงถึงแพลตฟอร์ม โดยไม่คำนึงถึงโปรแกรม โดยไม่คำนึงถึงภาษา ตัวอย่างเช่น ถ้าคุณดูตารางโค้ด อักขระ "a" มีค่า U+0061 (in ระบบเลขฐานสิบหก 0x61) ในขณะที่อักขระ "C" มีรหัส U+0043 (0x43) ซึ่งมาก่อนหน้าในตาราง Unicode มากกว่าอักขระ "a"

ในการจัดเรียงอาร์เรย์ที่อาจมีอักษรตัวแรกแบบผสม เราต้องแปลงองค์ประกอบทั้งหมดเป็นการชั่วคราว ตัวพิมพ์เล็กหรือกำหนดลำดับการจัดเรียงของคุณเองโดยใช้เมธอด localeCompare() พร้อมอาร์กิวเมนต์บางส่วน ตามกฎแล้ว ในกรณีนี้ ควรสร้างฟังก์ชันเพื่อใช้งานซ้ำทันทีจะดีกว่า:

ฟังก์ชั่น alphaSort(arr) ( arr.sort(function (a, b) ( return a.localeCompare(b, "en", ("sensitivity": "base")); )); ) ให้ผลไม้ = ["บัตเตอร์นัตสควอช , "แอปริคอท", "แคนตาลูป"]; alphaSort (ผลไม้) >
หากคุณต้องการเรียงลำดับอาร์เรย์แบบย้อนกลับ ลำดับตัวอักษรเพียงสลับตำแหน่งของ a และ b ในฟังก์ชัน:

ฟังก์ชัน alphaSort(arr) ( arr.sort(function (a, b) ( return b.localeCompare(a, "en", ("sensitivity": "base")); )); ) ให้ผลไม้ = ["บัตเตอร์นัตสควอช , "แอปริคอท", "แคนตาลูป"]; alphaSort(ผลไม้) > ["แคนตาลูป", "บัตเตอร์นัตสควอช", "แอปริคอท"]
เป็นที่น่าสังเกตว่า localeCompare ใช้กับอาร์กิวเมนต์ เราต้องจำไว้ว่ามันรองรับโดย IE11+ สำหรับ IE เวอร์ชันเก่า เราสามารถใช้ได้โดยไม่มีอาร์กิวเมนต์ และในตัวพิมพ์เล็ก:

Function caseSort(arr) ( arr.sort(function (a, b) ( return a.toLowerCase().localeCompare(b.toLowerCase()); )); ) ให้ผลไม้ = ["บัตเตอร์นัทสควอช", "แอปริคอท", "แคนตาลูป"]; caseSort(ผลไม้) > ["แอปริคอท", "บัตเตอร์นัตสควอช", "แคนตาลูป"]

การเรียงลำดับตัวเลข

ทั้งหมดนี้ใช้ไม่ได้กับตัวอย่างที่เราพูดถึงข้างต้นเกี่ยวกับอาร์เรย์ของบันทึกเกม กับบ้าง อาร์เรย์ตัวเลขการเรียงลำดับทำงานได้อย่างสมบูรณ์แบบ แต่ในบางจุดผลลัพธ์อาจคาดเดาไม่ได้:

ให้คะแนนสูงสุด = ; คะแนนสูงสุด.sort(); -
ประเด็นก็คือเมธอด sort() จะทำการเปรียบเทียบพจนานุกรม: ซึ่งหมายความว่าตัวเลขจะถูกแปลงเป็นสตริง และจะทำการเปรียบเทียบอีกครั้งโดยจับคู่อักขระตัวแรกของสตริงนั้นตามลำดับอักขระในตาราง Unicode . ดังนั้นเราจึงจำเป็นต้องกำหนดลำดับการจัดเรียงของเราอีกครั้ง:

ให้คะแนนสูงสุด = ; highScores.sort(ฟังก์ชั่น(a,b) ( กลับ a - b; )); -
หากต้องการเรียงลำดับตัวเลขในลำดับย้อนกลับ ให้สลับตำแหน่งของ a และ b ในฟังก์ชัน

การเรียงลำดับโครงสร้างคล้าย JSON

และสุดท้าย หากเรามีโครงสร้างข้อมูลคล้าย JSON ที่แสดงเป็นอาร์เรย์ของบันทึกเกม:

ให้คะแนน = [ ( "ชื่อ": "แดเนียล", "คะแนน": 21768 ), ( "ชื่อ": "ไมเคิล", "คะแนน": 33579 ), ( "ชื่อ": "อลิสัน", "คะแนน": 38395 ) ];
ใน ES6+ คุณสามารถใช้ฟังก์ชันลูกศรได้:

Scores.sort((a, b) => b.score - a.score));
สำหรับเบราว์เซอร์รุ่นเก่าที่ไม่รองรับนี้:

Scores.sort(function(a, b) ( return a.score - b.score ));
อย่างที่คุณเห็น การเรียงลำดับใน JavaScript เป็นสิ่งที่ค่อนข้างคลุมเครือ ฉันหวังว่าตัวอย่างเหล่านี้จะทำให้ชีวิตง่ายขึ้น

การทำงานกับฟังก์ชันกำลัง

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

ใน JavaScript ฟังก์ชัน power จะแสดงเป็น Math.pow() ในมาตรฐาน ES7 ใหม่ที่ได้รับการแนะนำ ผู้ดำเนินการใหม่การยกกำลัง - " * * "

การยกกำลัง

หากต้องการเพิ่มตัวเลขยกกำลัง n ให้ใช้ฟังก์ชัน Math.pow() โดยที่อาร์กิวเมนต์แรกคือตัวเลขที่จะยกกำลัง อาร์กิวเมนต์ที่สองคือเลขชี้กำลัง:

Math.pow(3,2) > 9
สัญลักษณ์รูปแบบนี้หมายถึง 3 กำลังสอง หรือ 3 × 3 ซึ่งนำไปสู่ผลลัพธ์ 9 ก็สามารถยกตัวอย่างได้อีกตัวอย่างหนึ่ง:

Math.pow(5,3); > 125
นั่นคือ 5 ลูกบาศก์หรือ 5 × 5 × 5 เท่ากับ 125

ECMAScript 7 อยู่ถัดไป เวอร์ชันจาวาสคริปต์โดยหลักการแล้ว เราสามารถใช้ตัวดำเนินการยกกำลังที่เสนอใหม่ได้ - * * สัญกรณ์รูปแบบนี้อาจมีคำอธิบายมากกว่า:

3 ** 2 > 9
บน ในขณะนี้การสนับสนุนโอเปอเรเตอร์นี้ค่อนข้างจำกัด จึงไม่แนะนำให้ใช้

ฟังก์ชันเปิดปิดจะมีประโยชน์ในหลายสถานการณ์ ตัวอย่างง่ายๆ การคำนวณจำนวนวินาทีในหนึ่งชั่วโมง: Math.pow (60,2)

รากสี่เหลี่ยมและลูกบาศก์

Math.sqrt() และ Math.cbrt() ตรงกันข้ามกับ Math.pow() อย่างที่เราจำได้ รากที่สองของ a คือจำนวนที่ให้ a เมื่อกำลังสอง

Math.sqrt(9) > 3
ในเวลาเดียวกัน รากที่สามของ a คือตัวเลขที่ให้ a เมื่อยกให้เป็นลูกบาศก์

Math.cbrt(125) > 5
Math.cbrt() เพิ่งเปิดตัวในข้อกำหนดเฉพาะของ JavaScript ดังนั้นจึงรองรับเฉพาะในเบราว์เซอร์รุ่นใหม่เท่านั้น: Chrome 38+, Firefox และ Opera 25+ และ Safari 7.1+ คุณจะสังเกตได้ว่า อินเทอร์เน็ตเอ็กซ์พลอเรอร์ไม่อยู่ในรายการนี้ แต่คุณจะพบ polyfill บน MDN

ตัวอย่าง

แน่นอนว่าเราสามารถใช้ค่าที่ไม่ใช่จำนวนเต็มในฟังก์ชันใดฟังก์ชันหนึ่งเหล่านี้ได้:

คณิต.พาว(1.25, 2); > 1.5625 Math.cbrt(56.57) > 3.8387991760286138
โปรดทราบว่าวิธีนี้ใช้ได้ผลค่อนข้างดีเมื่อใช้ค่าอาร์กิวเมนต์เชิงลบ:

Math.pow(-5,2) > 25 Math.pow(10,-2) > 0.01
อย่างไรก็ตาม วิธีนี้ใช้ไม่ได้กับสแควร์รูท:

Math.sqrt(-9) > น่าน
จาก การวิเคราะห์ทางคณิตศาสตร์เรารู้ว่าตามจำนวนจินตภาพ เราหมายถึงรากที่สองของจำนวนลบ และนี่อาจจะนำเราไปสู่อีกเทคนิคหนึ่งในการทำงานด้วย จำนวนเชิงซ้อนแต่นั่นเป็นอีกเรื่องหนึ่ง

คุณสามารถใช้เศษส่วนใน Math.pow() เพื่อค้นหารากที่สองและรากที่สามของตัวเลขได้ รากที่สองใช้เลขชี้กำลัง 0.5:

คณิต.พาว(5, 0.5); // = Math.sqrt(5) = 5 ** (1/2) > 2.23606797749979
อย่างไรก็ตาม เนื่องจากจุดลอยตัวไม่แน่นอน คุณจึงไม่สามารถเดาผลลัพธ์ที่ถูกต้องได้:

Math.pow(2.23606797749979,2) > 5.000000000000001
ในสถานการณ์เช่นนี้ คุณจะต้องหันไปตัดเครื่องหมายออกจากตัวเลขหรือปัดเศษเป็นค่าบางค่า

ด้วยเหตุผลที่ไม่ทราบสาเหตุ บางคนสับสนระหว่างฟังก์ชัน Math.pow() กับ Math.exp() ซึ่งเป็นฟังก์ชันเลขชี้กำลังสำหรับตัวเลขโดยทั่วไป หมายเหตุ: ใน ภาษาอังกฤษ"เลขชี้กำลัง" แปลว่า "เลขชี้กำลัง" ดังนั้นจึงมีแนวโน้มที่จะใช้กับผู้พูดภาษาอังกฤษมากกว่า แม้ว่าจะมีชื่ออื่นสำหรับเลขชี้กำลัง เช่น ดัชนี กำลัง

ค่าคงที่ทางคณิตศาสตร์

การทำงานกับคณิตศาสตร์ใน JavaScript นั้นง่ายขึ้นด้วยค่าคงที่ในตัวจำนวนหนึ่ง ค่าคงที่เหล่านี้เป็นคุณสมบัติของวัตถุทางคณิตศาสตร์ เป็นที่น่าสังเกตว่าค่าคงที่เขียนด้วยตัวพิมพ์ใหญ่ ไม่ใช่รูปแบบ CamelCase

เฉพาะผู้ใช้ที่ลงทะเบียนเท่านั้นที่สามารถเข้าร่วมการสำรวจได้ กรุณาเข้าสู่ระบบ

แท็ก: