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

หลังจากอ่านบทความปัจจุบัน คุณจะพบว่าเหตุใดจึงต้องปัดเศษตัวเลข วิธีและคุณสมบัติใดใน js ที่ทำหน้าที่นี้ และอะไรที่ทำให้การหารด้วย 0 แตกต่าง โดยไม่เปลี่ยนหลักการ ฉันจะแนบตัวอย่างไปยังประเด็นสำคัญของ วัสดุและอธิบายแต่ละการกระทำโดยละเอียด ตอนนี้มาเริ่มเรียนรู้กันเถอะ!

หมายเหตุสำคัญเกี่ยวกับตัวเลข

อันดับแรก จำไว้ว่าใน js ตัวเลขทุกชนิด (เศษส่วนและจำนวนเต็ม) เป็นประเภท ตัวเลข. นอกจากนี้ ทั้งหมดยังเป็นแบบ 64 บิต เนื่องจากจัดเก็บในรูปแบบ "double precision" ซึ่งเรียกอีกอย่างว่ามาตรฐาน IEEE-754

ตัวแปรตัวเลขถูกสร้างขึ้นด้วยวิธีปกติ:

var ชา = 35; // จำนวนธรรมชาติ

วาร์ดรอบ = 0.93; // การแสดงทศนิยม

var มึน 16 = 0xFF; // ระบบเลขฐานสิบหก

รองรับการแสดงตัวเลขอื่น ๆ เช่นกัน ดังนั้น คุณยังสามารถสร้างตัวเลขทศนิยมได้ (บางครั้งเรียกว่า "ตัวเลขในรูปแบบวิทยาศาสตร์")

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

varnum = 714000.80;

แจ้งเตือน (num.toLocaleString ());

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

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

คณิตศาสตร์ที่ยิ่งใหญ่และทรงพลัง

Global Math object มีฟังก์ชันทางคณิตศาสตร์และตรีโกณมิติที่หลากหลาย นี่เป็นวัตถุที่จำเป็นมากและมักจะช่วยนักพัฒนาเมื่อทำงานกับข้อมูลดิจิทัล

บนแพลตฟอร์มอื่นๆ มีการเปรียบเทียบกับคณิตศาสตร์ ตัวอย่างเช่น ในภาษายอดนิยม เช่น Java และ C# คณิตศาสตร์เป็นคลาสที่รองรับฟังก์ชันมาตรฐานเดียวกันทั้งหมด อย่างที่คุณเห็นเครื่องมือนี้ยอดเยี่ยมและทรงพลังมาก

ตอนนี้ฉันต้องการดูวิธีการปัดเศษเฉพาะและพูดคุยเกี่ยวกับรายละเอียดเหล่านี้

Math.floor()

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

เป็นไปได้ว่าหมายเลขที่ประมวลผลโดยใช้ฟังก์ชันนี้ยังคงเหมือนเดิม นี่เป็นเพราะการปัดเศษดำเนินการตามอสมการที่ไม่เข้มงวด (<=). Таким образом, при отработке этой строчки кода:

แจ้งเตือน (ชั้นคณิตศาสตร์ (4.5));

คำตอบจะเป็นหมายเลข 4

Math.ceil()

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

แจ้งเตือน (Math.ceil (4.5));

อย่างที่คุณเดาได้ คำตอบจะเป็นเลข 5

รอบคณิตศาสตร์ ()

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

แจ้งเตือน (รอบคณิตศาสตร์ (4.5));

ฉันหวังว่าทุกคนจะคิดหรือพูดว่าคำตอบที่ถูกต้องคือ 5

อีกสองสามวิธี

JavaScript ยังมีอีก 2 วิธีที่เกี่ยวข้องกับการปัดเศษแทนตัวเลข อย่างไรก็ตามมีความแตกต่างกันบ้าง

เรากำลังพูดถึงเครื่องมือเช่น เพื่อแก้ไข ()และ เพื่อความแม่นยำ(). พวกเขามีหน้าที่รับผิดชอบไม่เพียงแค่การปัดเศษเท่านั้น แต่ยังรวมถึงความแม่นยำของสัญญาณบางอย่างด้วย มาเจาะลึกกัน

เพื่อแก้ไข ()

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

varnum = 5656.9393;

document.writeln(จำนวน.toFixed()); //5657

document.writeln(จำนวน.toFixed(2)); // 5656.94

document.writeln(จำนวน.toFixed(7)); //5656.9393000

อย่างที่คุณเห็น หากคุณไม่ระบุอาร์กิวเมนต์ toFixed ()) จะปัดเศษเป็นค่าเศษส่วน ไปทั้งหมดตัวเลข บรรทัดที่สามถูกปัดเศษ สูงสุด 2 ตัวอักษรและในลำดับที่สี่ มีการเพิ่ม 0 อีกสามตัวเนื่องจากพารามิเตอร์ "7"

เพื่อความแม่นยำ()

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

varnum = 5656.9393;

document.writeln(จำนวน.toPrecision()); // 5656.9393

document.writeln(จำนวน.toPrecision(2)); // 5.7e+3

document.writeln(จำนวน.toPrecision(7)); // 5656.939

คุณลักษณะของการหารด้วย 0 ใน js

ดังที่คุณทราบจากบทเรียนคณิตศาสตร์ คุณไม่สามารถหารด้วยศูนย์ได้ กฎนี้เป็นพื้นฐานโดยผู้สร้างภาษาโปรแกรมส่วนใหญ่ ดังนั้นเมื่อหารด้วยศูนย์ โปรแกรมทั้งหมดจะสร้างข้อผิดพลาด

อย่างไรก็ตาม JavaScript ก็ทำได้ดีเช่นกัน ดังนั้นในระหว่างการดำเนินการดังกล่าวจะไม่มีรายงานข้อผิดพลาดเกิดขึ้น ... เนื่องจากการดำเนินการดังกล่าวจะส่งกลับ "อินฟินิตี้"!

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

สำหรับผู้ที่ยังใหม่กับความหมายของ Infinity ฉันได้อธิบายคุณสมบัติของมันไว้ด้านล่าง

อินฟินิตี้ - หมายถึงอินฟินิตี้และสอดคล้องกับเครื่องหมายทางคณิตศาสตร์ ∞ อย่างสมบูรณ์

อาจเป็นลบ กฎมาตรฐานทั้งหมดสำหรับการทำงานกับตัวดำเนินการทางคณิตศาสตร์จะถูกรักษาไว้เช่นกัน

แจ้งเตือน (12/0); // อินฟินิตี้

แจ้งเตือน (12.34/0); // อินฟินิตี้

แจ้งเตือน (-3/0); // -อินฟินิตี้

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

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

ฟังก์ชัน isFinite

ฟังก์ชัน isFinite ช่วยให้คุณตรวจสอบว่าอาร์กิวเมนต์เป็นจำนวนจำกัดหรือไม่

ฟังก์ชันนี้ส่งคืนค่าเท็จเป็นคำตอบหากอาร์กิวเมนต์คือ Infinity , -Infinity , NaN หรือจะถูกแปลงเป็นค่าตัวเลขพิเศษค่าใดค่าหนึ่งเหล่านี้ มิฉะนั้น ฟังก์ชันนี้จะคืนค่าจริง

อิสฟิไนต์(73); // ทรู isFinite(-1/0); // เท็จ isFinite (ไม่มีที่สิ้นสุด); // เท็จ isFinite (NaN); // เท็จ isFinite ("ข้อความ"); // เท็จ

นอกเหนือจากฟังก์ชันสากล isFinite แล้ว JavaScript ยังมีเมธอด Number.isFinite ซึ่งแตกต่างจาก isFinite ตรงที่ไม่บังคับให้อาร์กิวเมนต์ถูกแปลงเป็นตัวเลข

IsFinite("73"); // True Number.isFinite("73"); // เท็จ

ฟังก์ชัน isNaN

ฟังก์ชัน isNaN ใช้สำหรับพิจารณาว่าอาร์กิวเมนต์เป็นตัวเลขหรือสามารถแปลงเป็นตัวเลขได้หรือไม่ ถ้าเป็นเช่นนั้น ฟังก์ชัน isNaN จะคืนค่าเป็นเท็จ มิฉะนั้นจะคืนค่าจริง

IsNaN(น่าน); // isNaN จริง ("25px"); //จริงเพราะ 20px ไม่ใช่ตัวเลข isNaN(25.5); //เท็จ isNaN("25.5"); //เท็จ isNaN(" "); //ผิดเพราะ ช่องว่างหรือหลายช่องว่างถูกแปลงเป็น 0 isNaN(null); //ผิดเพราะ ค่า Null จะถูกแปลงเป็น 0 isNaN(จริง); //ผิดเพราะ จริงถูกแปลงเป็น 1 isNaN(เท็จ); //ผิดเพราะ ค่าเท็จจะถูกแปลงเป็น 0

หากต้องดำเนินการนี้โดยไม่มีการโยนประเภท ให้ใช้เมธอด Number.isNaN วิธีนี้ได้รับการแนะนำในภาษาตั้งแต่ ECMAScript 6

วิธีแปลงสตริงเป็นตัวเลขอย่างชัดเจน

คุณสามารถแปลงสตริงเป็นตัวเลขได้อย่างชัดเจนโดยใช้วิธีการต่อไปนี้:

1. ใช้ ตัวดำเนินการเอกนารี +ที่จะวางไว้ก่อนค่า

+"7.35"; // 7.35 +"ข้อความ"; // แนน

เมธอดนี้ละเว้นช่องว่างที่จุดเริ่มต้นและจุดสิ้นสุดของบรรทัด เช่นเดียวกับ \n (การป้อนบรรทัด)

+"7.35"; //7.35 +"7.35\n"; //7.35

โดยใช้ วิธีนี้โปรดทราบว่าสตริงว่างหรือสตริงที่ประกอบด้วยช่องว่างและ \n จะถูกแปลงเป็นเลข 0 นอกจากนี้ ยังแปลงชนิดข้อมูล null และบูลีนเป็นตัวเลขอีกด้วย

โมฆะ; //0 +จริง; //1 +เท็จ; //0 +" "; //0

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

ParseInt("18px"); //18 parseInt("33.3%"); //33

ฟังก์ชั่นนี้สามารถทำงานร่วมกับ ระบบที่แตกต่างกันเลข (ฐานสอง, ฐานแปด, ทศนิยม, เลขฐานสิบหก) การระบุฐานของระบบตัวเลขนั้นดำเนินการโดยใช้ 2 อาร์กิวเมนต์

ParseInt("18px", 10); //18 parseInt("33.3%", 10); //33 parseInt("101",2); //5 parseInt("B5",16); //181

นอกจากฟังก์ชัน parseInt แล้ว JavaScript ยังมีเมธอด Number.parseInt วิธีการนี้ไม่แตกต่างจากฟังก์ชัน parseInt และได้รับการแนะนำให้รู้จักกับ JavaScript ด้วยข้อกำหนดเฉพาะของ ECMASCRIPT 2015(6)

3. ฟังก์ชัน parseFloat ฟังก์ชัน parseFloat คล้ายกับ parseInt ยกเว้นว่าจะอนุญาตให้คุณแปลงอาร์กิวเมนต์เป็นตัวเลขเศษส่วน

ParseFloat("33.3%"); //33.3

นอกจากนี้ ฟังก์ชัน parseFloat ซึ่งแตกต่างจาก parseInt คือไม่มี 2 อาร์กิวเมนต์ ดังนั้นจึงพยายามถือว่าสตริงเป็นตัวเลขในรูปแบบทศนิยมเสมอ

ParseFloat("3.14"); parseFloat("314e-2"); parseFloat("0.0314E+2");

นอกจากฟังก์ชัน parseFloat แล้ว JavaScript ยังมีเมธอด Number.parseFloat วิธีนี้ไม่แตกต่างจากฟังก์ชัน parseFloat และได้รับการแนะนำใน JavaScript ด้วยข้อกำหนด ECMASCRIPT 2015(6)

แปลงตัวเลขเป็นสตริง

คุณสามารถแปลงตัวเลขเป็นสตริงโดยใช้เมธอด toString

(12.8).toString(); //"12.8"

เมธอด toString ยังให้คุณระบุฐานของระบบตัวเลข โดยคำนึงถึงว่าคุณต้องแปลงตัวเลขไปยังสตริงอย่างชัดเจน:

(255).toString(16); //"ฟ"

วิธีตรวจสอบว่าตัวแปรเป็นตัวเลขหรือไม่

คุณสามารถกำหนดว่าค่าของตัวแปรเป็นตัวเลขหรือไม่โดยใช้วิธีใดวิธีหนึ่งต่อไปนี้:

1. การใช้ฟังก์ชัน isNaN และ isFinite:

// myVar เป็นตัวแปร if (!isNaN(parseFloat(myVar)) && isFinite(parseFloat(myVar))) ( //myVar เป็นตัวเลขหรือสามารถส่งไปได้ );

เป็นฟังก์ชัน:

// ฟังก์ชัน ฟังก์ชัน isNumeric(value) ( ​​return !isNaN(parseFloat(value)) && isFinite(parseFloat(value)); ) // การใช้งาน var myVar = "12px"; console.log(isNumeric(myVar)); //จริง

วิธีนี้ช่วยให้คุณกำหนดได้ว่าค่าที่ระบุเป็นตัวเลขหรือสามารถแปลงเป็นค่านั้นได้หรือไม่ ตัวเลือกนี้ไม่นับสตริงว่าง สตริงของช่องว่าง null , Infinity , -Infinity , จริงและเท็จเป็นตัวเลข

2. การใช้ตัวดำเนินการ typeof และฟังก์ชัน isFinite, isNaN:

// ฟังก์ชันที่ตรวจสอบว่าค่าเป็นตัวเลขหรือไม่ ฟังก์ชัน isNumber(value) ( ​​return typeof value === "number" && isFinite(value) && !isNaN(value); }; // использование функции isNumber isNumber(18); //true // использование функций для проверки текстовых значений isNumber(parseFloat("")); //false isNumber(parseFloat("Infinity")); //false isNumber(parseFloat("12px")); //true !}

ฟังก์ชันนี้กำหนดว่าค่าที่ระบุเป็นประเภท Number และไม่ใช่ค่าพิเศษ Infinity, -Infinity และ NaN ถ้าเป็นเช่นนั้น ฟังก์ชันนี้จะคืนค่าจริง

3. ใช้เมธอด Number.isInteger(value) ของ ECMAScript 6 วิธีนี้ช่วยให้คุณกำหนดได้ว่าค่าที่ระบุเป็นจำนวนเต็มหรือไม่

Number.isInteger("20"); //ผิดเพราะ วิธีนี้ไม่ได้แปลสตริงเป็นตัวเลข Number.isInteger(20); //จริงเพราะ ค่าที่กำหนดเป็นตัวเลข

เลขคู่และเลขคี่

คุณสามารถตรวจสอบว่าตัวเลขเป็นเลขคู่หรือเลขคี่โดยใช้ฟังก์ชันต่อไปนี้:

// ฟังก์ชันตรวจสอบว่าตัวเลขเป็นเลขคู่หรือไม่ function isEven(n) ( return n % 2 == 0; ) // ฟังก์ชันตรวจสอบว่าตัวเลขเป็นเลขคี่หรือไม่ function isOdd(n) ( return Math.abs(n % 2) == 1; )

แต่ก่อนที่จะดำเนินการตรวจสอบดังกล่าว ขอแนะนำให้ตรวจสอบให้แน่ใจว่าค่าที่ระบุเป็นตัวเลข:

ค่า=20; ถ้า (Number.isInteger(ค่า)) ( ถ้า (isEven(ค่า)) ( console.log("Number " + value.toString() + " - คู่"); ) )

Prime Numbers ใน Javascript

พิจารณาตัวอย่างที่เราแสดงโดยใช้ Javascript จำนวนเฉพาะจาก 2 ถึง 100

// ฟังก์ชันที่ตรวจสอบว่าตัวเลขเป็นฟังก์ชันเฉพาะหรือไม่ isPrime(value) ( ​​if (isNaN(value) || !isFinite(value) || value%1 || value< 2) return false; var max=Math.floor(Math.sqrt(value)); for (var i = 2; i< = max; i++) { if (value%i==0) { return false; } } return true; } // создать массив, который будет содержать простые числа от 2 до 100 var primaryNumber = ; for (var i = 2; i <= 100; i++) { if(isPrime(i)) primaryNumber.push(i); } // вывести в консоль простые числа от 2 до 100 console.log(primaryNumber);

การปัดเศษตัวเลขใน Javascript

มีหลายวิธีในการปัดเศษเศษส่วนให้เป็นค่าจำนวนเต็มใน JavaScript

1. ใช้วิธี Math.floor , Math.ceil และ Math.round ที่ออกแบบมาเป็นพิเศษสำหรับสิ่งนี้ วิธี Math.floor ปัดเศษเศษส่วนลงเป็นจำนวนเต็มที่ใกล้เคียงที่สุด เช่น เพียงแค่ทิ้งส่วนที่เป็นเศษส่วน Math.ceil ปัดเศษเศษส่วนขึ้นเป็นจำนวนเต็มที่ใกล้เคียงที่สุด Math.round ปัดตัวเลขขึ้นหรือลงขึ้นอยู่กับค่าของเศษส่วน หากส่วนที่เป็นเศษส่วนมากกว่าหรือเท่ากับ 0.5 ให้ขึ้น มิฉะนั้นให้เลื่อนลง

Console.log(ชั้นคณิตศาสตร์(7.9)); //7 console.log(คณิตศาสตร์.ceil(7.2)); //8 console.log(คณิตศาสตร์รอบ(7.5)); //8

2. ใช้ toFixed (ความแม่นยำ) วิธีการ วิธีนี้ปัดส่วนที่เป็นเศษส่วนของตัวเลขให้มีความแม่นยำที่ระบุ ผลการปัดเศษจะถูกส่งกลับเป็นสตริง

Console.log(7.987.toFixed(2)); //"7.99"

หากมีตำแหน่งทศนิยมไม่เพียงพอที่จะกำหนดความถูกต้องของตัวเลขที่ระบุ ตัวเลขนั้นจะถูกเติมด้วยเลขศูนย์

Console.log(7.987.toFixed(5)); //"7.98700"

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

Console.log((1001).toPrecision(2)); //"1.0e+3" console.log((1001).toPrecision(5)); //"1001.0" console.log((12.4).toPrecision(1)); //"1e+1" console.log((12.4).toPrecision(2)); //"12" console.log((12.4).toPrecision(3)); //"12.4" console.log((12.4).toPrecision(5)); //"12.400"

4. การใช้ตัวดำเนินการแบบลอจิคัล NOT หรือ OR

// ผ่านการปฏิเสธตรรกะสองครั้ง console.log (~~ 7.9); //7 // โดยใช้ตรรกะหรือศูนย์: console.log(7.9^0); //7

จำนวนเต็มและเศษส่วนของจำนวน

คุณสามารถรับส่วนจำนวนเต็มของตัวเลขโดยใช้เมธอด Math.floor() และ parseInt():

Console.log(ชั้นคณิตศาสตร์(7.21)); // 7 console.log(parseInt(7.21)); // 7

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

Console.log(7.21%1); // 0.209999999999999996 // ทศนิยม 2 ตำแหน่งพอดี console.log((7.21%1).toFixed(2)); // "0.21"

นอกจากนี้ยังสามารถรับส่วนที่เป็นเศษส่วนโดยใช้การคำนวณ:

หมายเลข var = 7.21; var fractionNumber = ตัวเลข - Math.floor(Math.abs(ตัวเลข)); console.log(fractionNumber); // 0.20999999999999996

เป็นจำนวนที่หารลงตัว

คุณสามารถกำหนดว่าตัวเลขหารลงตัวหรือไม่โดยใช้ตัวดำเนินการเปอร์เซ็นต์:

วาร์นัมเบอร์ = 9; // ถ้าจำนวนที่เหลือหารด้วย 3 เป็น 0 แสดงว่าใช่ มิฉะนั้นไม่ใช่ if (number%3==0) ( console.log ("จำนวน " + จำนวน + " หารด้วย 3 ลงตัว"); ) else ( console.log("จำนวน " + จำนวน + " หารด้วย 3 ไม่ลงตัว"); )

การจัดรูปแบบตัวเลข

ใน JavaScript เมธอด toLocaleString() ช่วยให้คุณจัดรูปแบบเอาต์พุตของตัวเลขตามโลแคล (การตั้งค่าภาษาของระบบปฏิบัติการ)

ตัวอย่างเช่น ลองจัดรูปแบบตัวเลขตามมาตรฐานภูมิภาคที่ติดตั้งในระบบตามค่าเริ่มต้น:

หมายเลข var = 345.46; console.log(number.toLocaleString()); //"345,46"

ตัวอย่างเช่น จัดรูปแบบตัวเลขตามมาตรฐานภูมิภาคของรัสเซีย (ru):

Console.log((108.1).toLocaleString("ru-RU")); //"108.1"

วิธีนี้สามารถใช้จัดรูปแบบตัวเลขเป็นสกุลเงินได้ด้วย:

Console.log((2540.125).toLocaleString("ru-RU",(สไตล์:"สกุลเงิน", สกุลเงิน:"RUB"))); //"2,540.13 ₽" console.log((89.3).toLocaleString("ru-RU",(สไตล์:"currency", สกุลเงิน:"USD"))); //"$89.30" console.log((2301.99).toLocaleString("ru-RU",(สไตล์:"currency", สกุลเงิน:"EUR"))); //"€2,301.99"

คิดเป็นเปอร์เซ็นต์:

Console.log((0.45).toLocaleString("ru-RU",(สไตล์:"เปอร์เซ็นต์"))); //"45%"

แบ่งตัวเลขเป็นตัวเลข (คุณสมบัติ useGrouping):

Console.log((125452.32).toLocaleString("ru-RU",(useGrouping:true))); //"125 452.32"

พิมพ์ตัวเลขที่มีจำนวนหลัก (2) หลังจุดทศนิยม:

Console.log((1240.4564).toLocaleString("ru-RU",(minimumFractionDigits:2, maximumFractionDigits:2))); //"1240.46"

การเปรียบเทียบจำนวน

ตัวดำเนินการต่อไปนี้ใช้เพื่อเปรียบเทียบตัวเลขใน JavaScript: == (เท่ากับ), != (ไม่เท่ากับ), > (มากกว่า),< (меньше), >= (มากกว่าหรือเท่ากับ),<= (меньше или равно).

ตัวอย่างเช่น ลองเปรียบเทียบตัวเลขสองตัว:

Console.log(2>3); //เท็จ console.log(5>=3); //จริง

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

ตัวอย่างเช่น ใน JavaScript ผลรวมของตัวเลข (0.2 + 0.4) ไม่เท่ากับ 0.6:

Console.log((0.2+0.4)==0.6); //เท็จ

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

เช่น เบอร์ 0.25 10 นิ้ว ระบบเลขฐานสองแปลงอย่างแน่นอน

0.125 × 2 = 0.25 | 0 0.25 × 2 = 0.5 | 0 0.5 × 2 = 1 | 1 0.125 10 = 0.001 2

ตัวอย่างเช่น ตัวเลข 0.2 10 สามารถแปลงเป็น 2 ระบบได้ด้วยความแม่นยำบางอย่างเท่านั้น:

0.2 × 2 = 0.4 | 0 0.4 × 2 = 0.8 | 0 0.8 × 2 = 1.6 | 1 0.6 × 2 = 1.2 | 1 0.2 × 2 = 0.4 | 0 0.4 × 2 = 0.8 | 0 0.8 × 2 = 1.6 | 1 0.6 × 2 = 1.2 | 1 0.2 × 2 = 0.4 | 0 0.4 × 2 = 0.8 | 0 0.8 × 2 = 1.6 | 1 0.6 × 2 = 1.2 | 1 ... 0.2 10 = 0.001100110011... 2

ดังนั้น ข้อผิดพลาดเหล่านี้จะส่งผลต่อการคำนวณผลรวมของตัวเลขสองตัวและผลการเปรียบเทียบ เหล่านั้น. ปรากฎว่าในความเป็นจริง JavaScript จะเห็นรายการนี้ดังนี้:

0.6000000000000001==0.6

เมื่อคำนวณหรือแสดงตัวเลขที่มีเศษส่วน คุณต้องระบุความแม่นยำที่จะทำสิ่งนี้เสมอ

ตัวอย่างเช่น เปรียบเทียบตัวเลขที่มีทศนิยมสูงสุด 2 ตำแหน่งโดยใช้เมธอด toFixed() และ toPrecision()

//เมธอด toFixed() console.log((0.2+0.4).toFixed(2)==(0.6).toFixed(2)); //true //toPrecision() วิธีการ console.log((0.2+0.4).toPrecision(2)==(0.6).toPrecision(2)); //จริง

การดำเนินการทางคณิตศาสตร์ขั้นพื้นฐาน

JavaScript มีตัวดำเนินการทางคณิตศาสตร์ดังต่อไปนี้: + (การบวก), - (การลบ), * (การคูณ), / (การหาร), % (การหารที่เหลือ), ++ (การเพิ่มค่าทีละ 1), -- (การลดค่าทีละ 1 ).

6+3 //9 6-3 //3 6*3 //18 6/3 //2 6%3 //0 เช่น 6:3=2 => 6-3*2 => พัก(0) 5%2 //1 เช่น 5:2=2(.5) => 5-2*2 => พัก(1) 7.3%2 //1.3 เช่น 7.3:2=3(.65) => 7.3-2*3 => ส่วนที่เหลือ(1.3) //เครื่องหมายของผลลัพธ์การดำเนินการ % เท่ากับเครื่องหมายของค่าแรก -9%2.5 //-1.5 เช่น 9:2.5=3(.6) => 9-2.5*3 => พัก(1.5) -9%-2.5 //-1.5 เช่น 9:2.5=3(.6) => 9-2.5*3 => พัก(1.5) -2%5 //-2 เช่น 2:5=0(.4) => 2-5*0 => พัก(2) x = 3; บันทึกคอนโซล (x ++); // แสดง 3 จากนั้นตั้งค่า y เป็น 4 console.log(x); //4 x = 3; บันทึกคอนโซล (++ x); // ตั้งค่า 4 และเอาต์พุต x = 5; บันทึกคอนโซล (x--); // เอาต์พุต 5 จากนั้น y ตั้งค่า 4 console.log(x); //4 x = 5; บันทึกคอนโซล (--x); // ตั้งค่าเป็น 4 และเอาต์พุต นอกจากนี้ยังมีตัวดำเนินการรวมกันใน JavaScript: x+=y (x=x+y), x-=y (x=x-y), x*=y (x=x*y), x/= y (x=x/y), x%=y (x=x%y) x=3; ย=6; x+=y; บันทึกคอนโซล (x); //9 x = 3; ย=6; x-=y; บันทึกคอนโซล (x); //-3 x = 3; ย=6; x*=y; บันทึกคอนโซล (x); //18 x = 3; ย=6; x/=y; บันทึกคอนโซล (x); //0.5 x = 3; ย=6; x%=y; บันทึกคอนโซล (x); //3

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

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

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

0.1 * 0.2; > 0.020000000000000004

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

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

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

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

var randNum = 6.25; randNum.toFixed(); > "6" Math.PI.toPrecision(1); > "3" var randNum = 87.335; randNum.toFixed(2); > "87.33" var randNum = 87.337; randNum.toPrecision(3); > "87.3"

บันทึก

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

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

หากคุณต้องการให้ JavaScript ปัดเศษเป็นร้อย ให้ใช้ parseFloat() :

var randNum = 6.25; var ปัด = parseFloat(randNum.toFixed(1)); บันทึกคอนโซล (ปัดเศษ); > 6.3

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

var wholeNum = 1 var dollarCents = wholeNum.toFixed(2); console.log(ดอลลาร์เซ็นต์); > "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 หากคุณต้องการหลีกเลี่ยงข้อผิดพลาดนี้ เราขอแนะนำให้ใช้เลขชี้กำลัง:

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

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

รอบ (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 :

ฟังก์ชันที่ถูกตัด (จำนวน) ( คืนค่า Math.trunc (จำนวน * 100) / 100; ) ที่ถูกตัดทอน (3.1416) > 3.14

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

ฟังก์ชันที่ถูกตัดทอน (จำนวน, ตำแหน่งทศนิยม) ( var numPowerConverter = Math.pow (10, ตำแหน่งทศนิยม); คืนค่า ~~(จำนวน * numPowerConverter)/numPowerConverter; )

การใช้งาน:

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

การปัดเศษเป็นจำนวนที่ใกล้ที่สุด

ดำเนินต่อไป JavaScript ปัดเศษเป็นจำนวนเต็ม, Math.round() ใช้:

รอบคณิตศาสตร์(4.3) > 4 รอบคณิตศาสตร์(4.5) > 5

โปรดทราบว่า " ค่าครึ่งหนึ่ง“ เช่น .5 จะปัดขึ้น

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

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

Math.floor(42.23); > 42 Math.floor(36.93); > 36

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

Math.floor(-2.5); > -3

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

Math.trunc(-41.43); > -41

MDN ยังให้บริการ โพลีฟิล 3 บรรทัดเพื่อรองรับ Math.trunc ในเบราว์เซอร์รุ่นเก่าและ IE/Edge.

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

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

Math.ceil(42.23); > 43 Math.ceil(36.93); > 37 Math.ceil(-36.93); -36

การปัดเศษเป็นจำนวนที่ใกล้เคียงที่สุด

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

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

การใช้งาน:

roundTo5(11); > 10

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

ฟังก์ชัน roundToMultiple(จำนวน, หลายรายการ) ( คืนค่า Math.round(จำนวน/ค่าหลายค่า)*ค่าคูณ; )

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

var initialNumber = 11; var หลายตัว = 10; roundToMultiple (จำนวนเริ่มต้น หลายรายการ); > 10;

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

ผูกพันกับช่วง

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

การใช้งาน:

var ขอบเขตต่ำ = 1; varhighBound = 100; varnumInput = 123; var ที่หนีบไว้ = Math.max(lowBound, Math.min(numInput, highBound)); บันทึกคอนโซล (บีบ); > 100;

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

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

งาน: javascript จำนวนตำแหน่งทศนิยม

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

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

โซลูชันที่ 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.toPrecision(5); //num_str=1538.9; num_str=num.toPrecision(7); //num_str=1538.989;

วิธีแก้ปัญหาที่ไม่มีทศนิยม: javascript จำนวนทศนิยม

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

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

ชั้น - จากภาษาอังกฤษ เพศปัดลงเสมอ

วาร์นัม = 1538.9891200153; num_str=math.round(ตัวเลข); //num_str=1539; num_str=Math.floor(จำนวน); //num_str=1538; num_str=คณิตศาสตร์.ceil(จำนวน); //num_str=1539;

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