ประเภทตัวเลขหลักของ JavaScript ในบทความเดียว

บทความนี้นำเสนอความรู้ที่เกี่ยวข้องเกี่ยวกับ JavaScript ซึ่งส่วนใหญ่จะแนะนำเนื้อหาที่เกี่ยวข้องเกี่ยวกับประเภทตัวเลข ใน JavaScript มีสองประเภท: ประเภทตัวเลขและ BigInt เรามาดูกันดีกว่า ช่วย.

[คำแนะนำที่เกี่ยวข้อง: วิดีโอสอน JavaScript, ส่วนหน้าของเว็บ]

ตัวเลขใน JavaScript มีสองประเภท:

1. ประเภท Number ซึ่งเป็นประเภทตัวเลขตามความหมายทั่วไป จะถูกจัดเก็บไว้ในรูปแบบ IEEE-754 64 บิต และเป็น "ตัวเลขทศนิยมที่มีความแม่นยำสองเท่า" จนถึงขณะนี้ ตัวเลขทั้งหมดที่เราสัมผัสคือ ประเภท Number

2. ประเภท BigInt แสดงถึงจำนวนเต็มทุกความยาว โดยปกติเราจะไม่ใช้มัน ยกเว้นแต่ว่ามันแทนตัวเลขอื่นที่ไม่ใช่ 2 ⁵³ ถึง -2 ⁵³ เราจะแนะนำประเภทข้อมูลระดับมืออาชีพเหล่านี้โดยละเอียดในบทต่อๆ ไป

วิธีการเขียนตัวเลข

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

ตัวคั่น

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

 ให้สิบพันล้าน = 10000000000;

แม้ว่าการดำเนินการจะง่ายมาก แต่ก็มีปัญหา: เป็นการยากที่จะนับจำนวน 0 ตามหลัง 1 หากเรากำลังเขียนรหัสการโอน 0 ที่ผิดอาจทำให้ล้มละลายได้

ในตอนนี้เราสามารถใช้ _ เป็นตัวคั่นได้ดังนี้:

 ให้สิบพันล้าน = 10_000_000_000;

โค้ดด้านบนสามารถนับจำนวน 0 ได้อย่างชัดเจน ซึ่งเห็นได้ชัดว่าเป็นทางออกที่ดีที่สุด!

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

วงจรสมองชิงฉี

รองเท้าเด็กบางรุ่นต้องถามว่าผมอยู่ในกลุ่ม 4 0 มาตลอดตั้งแต่เด็กๆ แล้วทำไมต้องจับกลุ่ม 3 0 ? ดังนั้นเราจึงเขียนได้ดังนี้โดยไม่มีปัญหา:

 ให้สิบพันล้าน = 100_0000_0000;

หรืออาจเขียนได้ดังนี้:

 ให้สิบพันล้าน = 1_0000_0000_00;

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

ละเว้น 0

แม้ว่าการใช้ _ จะสามารถหาร 0 ได้อย่างสวยงาม แต่ในชีวิตจริง โดยทั่วไปแล้วเราไม่เขียนมันในลักษณะนี้ ตัวอย่างเช่น เรามักจะเขียน 10000000000 เป็น "10 พันล้าน" เพื่อให้สามารถละเว้น 0 จำนวนมากได้ ซึ่งจะช่วยลดความเป็นไปได้ในการสร้าง ความผิดพลาด

JavaScript ยังมีวิธีละเว้น 0 อีกด้วย เราสามารถใช้ตัวอักษร e ตามด้วยตัวเลขเพื่อแสดงตัวเลข 0 ได้ ตัวอย่างเช่น

 ให้ tenbillion = 1e10;//10 พันล้าน, 1 ตามด้วย 10 0sconsole.log(3.14e9);//3140000000 ตามด้วย 7 0s หากคุณมีคำถามใดๆ โปรดดูด้านล่าง

ความเข้าใจโค้ดข้างต้นนั้นง่ายมาก e10 สามารถเข้าใจได้ว่า 1_0000_0000_00 0 ก็คือ 1 ตามด้วย 10 ดังนั้นเราจึงคิดได้ว่า:

 1e10 === 1 * 1_0000_0000_00;//e10 หมายถึง 1 ตามด้วย 10 03.14e9 === 3.14 * 1_000_000_000;//e9 หมายถึง 1 ตามด้วย 9 0s

เรายังใช้วิธีนี้แทนจำนวนที่น้อยมากได้ เช่น 1 นาโนเมตร:

 ให้ nm = 0.000000001; //หน่วย (เมตร)

เนื่องจากมี 0 มากเกินไป เราจึงสามารถใช้ _ :

 ให้นาโนเมตร = 0.000_000_001;

แน่นอน คุณยังสามารถใช้ e เพื่อละเว้น 0 ทั้งหมดได้ ดังนี้:

 ให้ nm = 1e-9;//9 0s ทางซ้ายของ 1 รวมถึงอันที่อยู่หน้าจุดทศนิยม

กล่าวอีกนัยหนึ่ง e-9 หมายถึง 1 ^-9 ซึ่งก็คือ 1/1000_000_000 ดังนั้นสมการต่อไปนี้จึงเป็นจริง:

 1e-9 === 1 / 1_000_000_000;3.14e-8 === 3.14 / 1_000_000_00;

สิบหก, แปด, ไบนารี่

เลขฐานสิบหกเป็นรูปแบบที่ใช้กันทั่วไปในการเขียนโปรแกรม เช่น สี การเข้ารหัส ฯลฯ เราสามารถเติม 0x หน้าตัวเลขธรรมดาเพื่อแสดงเลขฐานสิบหกได้:

 ให้ hex = 0xff;//255 ไม่คำนึงถึงตัวพิมพ์เล็กและตัวพิมพ์ใหญ่ 0xFF ก็เหมือนกัน

เลขฐานสองเริ่มต้นด้วย 0b :

 ให้ bin = 0b1011;//11

เลขฐานแปดเริ่มต้นด้วย 0o :

 ให้ ต.ค. = 0o777;//511

วิธีการเขียนแบบง่าย ๆ นี้รองรับเฉพาะสามประเภทพิเศษเหล่านี้ สำหรับหมายเลขฐานอื่น ๆ คุณสามารถใช้ฟังก์ชันพิเศษเพื่อสร้างมันได้ ( parseInt )

toString (ฐาน)

วิธี toString สามารถแปลงตัวเลขเป็นรูปแบบสตริงที่สอดคล้องกับ base

ให้เกาลัด:

 ให้หมายเลข = 996;
console.log(num.toString(8));//แปลงเป็นสตริงฐานแปด console.log(num.toString(16));//แปลงเป็นสตริงเลขฐานสิบหก console.log(num.toString( 32));// แปลงเป็นสตริงเลขฐานสิบหก 32

ผลลัพธ์การรันโค้ดมีดังนี้:

ช่วงของ base สามารถอยู่ระหว่าง 2 ถึง 36 หากไม่ได้กรอก ค่าเริ่มต้นคือ 10

โปรดทราบว่าหากคุณใช้ตัวเลขเพื่อเรียกเมธอด toString โดยตรง ในบางกรณี คุณจะต้องใช้ 2 . เช่น:

 console.log(123.toString(8));//ข้อผิดพลาด, ข้อผิดพลาดทางไวยากรณ์ console.log(123..toString(8));//แก้ไข, 173

มีสอง . หลังตัวเลข เนื่องจากใน JavaScript จุด . หลังตัวเลขถือเป็นจุดทศนิยมและจุดที่สองคือที่เรียกใช้ .

ถ้าเป็นทศนิยม แสดงว่าปัญหานี้ไม่มีอยู่

 console.log(3.14.toString(8));

หรือเราสามารถใช้วงเล็บเพื่อหลีกเลี่ยงการใช้จุดสองจุดได้ เช่น

 console.log((123).toString(8));//'173

การปัดเศษ

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

1. ปัดเศษลง Math.floor(num)

    console.log(Math.floor(3.14));//3
   console.log(Math.floor(9.99));//9
   console.log(Math.floor(-3.14));//-4
   console.log(Math.floor(-9.99));//-10

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

2. ปัดเศษขึ้น Math.ceil(num)

    console.log(Math.ceil(3.14));//4
   console.log(Math.ceil(9.99));//10
   console.log(Math.ceil(-3.14));//-3
   console.log(Math.ceil(-9.99));//-9

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

3. ปัดเศษเป็นจำนวนเต็มที่ใกล้ที่สุด Math.round(num)

    console.log(Math.round(3.14));//3
   console.log(Math.round(9.99));//10
   console.log(Math.round(-3.14));//-3
   console.log(Math.round(-9.99));//-10

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

4. ลบทศนิยม Math.trunc(num)

    console.log(Math.trunc(3.14));//3
   console.log(Math.trunc(9.99));//9
   console.log(Math.trunc(-3.14));//-3
   console.log(Math.trunc(-9.99));//-9

   ลบตัวเลขที่อยู่หลังจุดทศนิยมโดยตรงแล้วปัดเศษให้เป็นเลขจำนวนเต็ม เบราว์เซอร์ IE ไม่รองรับวิธีนี้

เปรียบเทียบสี่วิธีข้างต้น:

ความแม่นยำ

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

มีสองวิธี:

1. การคูณและการหารทางคณิตศาสตร์

    ให้ pi = 3.1415926;console.log(Math.round(pi * 10,000) / 10,000);//3.1416

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

2. ถึงคงที่(n)

    ให้ pi = 3.1415926;console.log(pi.toFixed(4));//3.1416

   โค้ดด้านบนดูเหมือนจะไม่มีปัญหากับเอาต์พุต ที่จริงแล้ว toFixed ส่งคืนสตริง หากเราต้องการประเภทตัวเลข เราจำเป็นต้อง + pi.toFixed(4) มัน

   นอกจากนี้ หากแมนทิสซาทศนิยมยาวไม่พอ toFixed จะเพิ่ม '0' ต่อท้าย:

    ให้ num = 3.1;console.log(num.toFixed(9));

   ผลลัพธ์การรันโค้ดมีดังนี้:
   
   นอกจากนี้ยังพิสูจน์ว่าค่าที่ส่งคืนของ toFixed เป็นสตริง มิฉะนั้น 0 จะถูกละเว้น

ส่วนเบี่ยงเบน

การแสดงจุดลอยตัวมักมีอคติเสมอในหลายกรณี

ภายในคอมพิวเตอร์ หมายเลขจุดลอยตัวที่มีความแม่นยำจะแสดงตามมาตรฐาน IEEE-754 โดยที่หมายเลขจุดลอยตัวที่มีความแม่นยำเดี่ยวคือ 32 บิต และหมายเลขจุดลอยตัวที่มีความแม่นยำสองเท่าคือ 64 บิต ในจำนวนจุดลอยตัวที่มีความแม่นยำสองเท่านั้น 1 บิตจะใช้แทนเครื่องหมาย 52 บิตจะใช้เพื่อเก็บเลขนัยสำคัญ และ 11 บิตจะใช้เพื่อจัดเก็บตำแหน่งของจุดทศนิยม

ปรากฏการณ์การเบี่ยงเบน

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

 ให้ bigNum = 1e999;console.log(bigNum);//Infinity

ตัวเลขที่เกินค่าสูงสุดจะกลายเป็น Infinity (อนันต์) จึงสูญเสียขนาดของตัวเลขเดิมซึ่งเป็นค่าเบี่ยงเบนชนิดหนึ่ง

มีการเบี่ยงเบนอีกประเภทหนึ่งที่เราต้องเรียนรู้:

 console.log(0.1+0.2 === 0.3);//falseconsole.log(0.1 + 0.2);

ผลลัพธ์การรันโค้ดมีดังนี้:

ถูกต้อง ผลลัพธ์ของ 0.1 + 0.2 ไม่ใช่ 0.3 แต่เป็นพวงของ 0 ตามด้วย 4

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

ฉันเคยได้ยินเรื่องราวเกี่ยวกับพนักงานธนาคารคนหนึ่งที่ขโมยเงินหลายล้านดอลลาร์จากการหักค่าจ้างพนักงานแต่ละคนเพียง 20 เซ็นต์เท่านั้น!

ฉันคิดว่าถ้าสิ่งนี้เกิดขึ้นกับฉัน ฉันคงไม่สามารถค้นพบมันได้อย่างแน่นอน ดังนั้นมันจึงสำคัญมากที่จะต้องแม่นยำตลอดเวลา

ฉันไม่รู้ว่าเรื่องนี้จริงหรือเปล่า~~

สาเหตุของการเบี่ยงเบน

ลองใช้ระบบทศนิยมทั่วไป 1/3 ตัวอย่าง ทศนิยม 0.3333333(3) และ pi มันเป็นทศนิยมที่ไม่ซ้ำไม่มีที่สิ้นสุด อนันต์หมายความว่าขนาดของตัวเลขไม่สามารถอธิบายได้อย่างชัดเจนเป็นตัวเลข และสิ่งที่เราเขียนได้นั้นไม่ถูกต้อง

นอกจากนี้ยังมีตัวเลขที่วนซ้ำอย่างไม่สิ้นสุดในรูปแบบไบนารี่ ความแตกต่างก็คือ ในรูปแบบทศนิยม ตัวเลขเช่น 0.1 ซึ่งดูง่ายมาก นั้นเป็นทศนิยมแบบวนซ้ำไม่สิ้นสุดในไบนารี่

ตัวอย่างเช่น:

 ให้ x = 0.1;console.log(x.toFixed(20));

ผลลัพธ์การรันโค้ดมีดังนี้:

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

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

คำอธิบายนี้ยังใช้ได้หากแปลงเป็นไบนารี่

ในไบนารี่ จำนวนเต็มใดๆ ที่หารด้วย 2 หรือจำนวนเต็มยกกำลัง 2 จะเป็นจำนวนที่แน่นอนปกติ อย่างไรก็ตาม หากคุณหารมันด้วย 10 คุณจะได้จำนวนไบนารี่ที่ไม่มีที่สิ้นสุด

ดังนั้นเราจึงสรุปได้ว่าเลขฐานสองไม่สามารถแทน 0.1 และ 0.2 ได้อย่างแม่นยำ เช่นเดียวกับทศนิยมที่ไม่สามารถอธิบาย 1/3 ได้

สังเกต:

การเบี่ยงเบนข้อมูลประเภทนี้ไม่ใช่ข้อบกพร่องของ JavaScript แต่เป็นผลลัพธ์เดียวกันสำหรับ PHP, Java, C, Perl และ Ruby

สารละลาย

1. การปัดเศษ

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

    0.3.ถึงคงที่(2);//0.30

2. ใช้หน่วยขนาดเล็ก

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

อินฟินิตี้, แนน

มีค่าพิเศษสองค่าในตัวเลข JavaScript : Infinity และ NaN .

จะตัดสินได้อย่างไรว่าตัวเลขเป็นตัวเลขปกติ?

เราสามารถใช้สองวิธี:

1. มีจำนวนจำกัด(val)
   ฟังก์ชันนี้จะแปลงพารามิเตอร์ val เป็นประเภทตัวเลข จากนั้นพิจารณาว่าตัวเลขนั้นมีขอบเขตจำกัด และคืนค่า true เมื่อตัวเลขไม่ใช่ NaN , Infinity หรือ -Infinity

    console.log(isFinite(NaN));//falseconsole.log(isFinite(Infinity));//falseconsole.log(isFinite(3));//trueconsole.log(isFinite('12'));// จริง

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

    console.log(isFinite('xxxx'));//falseconsole.log(isFinite('Infinite'));//falseconsole.log(isFinite(' '));//true, สตริงว่างจะถูกแปลงเป็น 0

   ผลลัพธ์การรันโค้ดมีดังนี้:

2. คือNaN(วาล)
   คืนค่า true เมื่อ val เป็น NaN หรือค่าอื่นที่ไม่สามารถแปลงเป็นตัวเลขได้

    console.log(isNaN(NaN));//trueconsole.log(isNaN('Infinite'));//true

   ผลการรันโค้ด:
   
   เหตุใดจึงใช้ฟังก์ชัน isNaN แทนที่จะอ่านโดยตรง
   ตัวอย่างเช่น:

    console.log(น่าน === น่าน);//false

   ผลลัพธ์การรันโค้ดมีดังนี้:
   
   เนื่องจาก NaN ไม่เท่ากับจำนวนใดๆ รวมทั้งตัวมันเองด้วย

Object.is

Object.is(a,b) สามารถกำหนดได้ว่าพารามิเตอร์ a และ b เท่ากันหรือไม่ จะส่งกลับค่า true หรือไม่ก็ส่งกลับค่า false ผลลัพธ์มีเพียง 3 สถานการณ์เท่านั้น:

1. สามารถเปรียบเทียบกับ NaN ได้

    console.log(Object.is(NaN,NaN));//true

   ผลการรันโค้ด:

   

2. 0 และ -0

    console.log(Object.is(0,-0));//false

   ผลการรันโค้ด:

   

   ภายในคอมพิวเตอร์ ค่าบวกและค่าลบจะแสดงด้วย 0 และ 1 เนื่องจากเครื่องหมายต่างกัน 0 และ -0 จึงแตกต่างกันจริง ๆ และแสดงออกมาในรูปแบบที่แตกต่างกัน

3. อื่น
   สถานการณ์การเปรียบเทียบอื่นๆ a === b ทุกประการจะเหมือนกับ

parseInt, parseFloat

parseInt และ parseFloat สามารถแปลงสตริงเป็นตัวเลขได้ ต่างจาก + และ Number ตรงที่ข้อจำกัดจะหลวมกว่า ตัวอย่างเช่น การใช้ + และ Number สำหรับสตริงเช่น "100￥" จะส่งกลับ NaN อย่างหลีกเลี่ยงไม่ได้ แต่ parseInt และ parseFloat สามารถจัดการได้อย่างง่ายดาย

ตัวอย่างเช่น:

 console.log(+"100￥");console.log(parseInt("100￥"));console.log(parseFloat("12.5￥"));

ผลการรันโค้ด:

parseInt และ parseFloat อ่านตัวเลขจากสตริงจนกระทั่งไม่สามารถอ่านได้อีกต่อไป ทั้งสองเหมาะอย่างยิ่งสำหรับการประมวลผลสตริงที่ขึ้นต้นด้วยตัวเลขเช่น "99px" และ "11.4em" แต่ NaN จะถูกส่งกลับสำหรับสตริงที่ขึ้นต้นด้วยอักขระอื่น

 console.log(parseInt('ff2000'));//NaN

อย่างไรก็ตาม เราพบ ff2000 เป็นสตริงดิจิทัลที่เป็นเลขฐานสิบหก parseInt ก็สามารถจัดการสถานการณ์นี้ได้ แต่จำเป็นต้องเพิ่มพารามิเตอร์เลขฐานสิบหก

ตัวอย่างเช่น:

 console.log(parseInt('FF2000',16));
//16719872
console.log(parseInt('0xFF2000',16));
//16719872
console.log(parseInt('nnnnnn',36));
//1430456963

ผลการรันโค้ด:

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

ออบเจ็กต์ Math ในตัวมีค่าคงที่และวิธีการต่างๆ มากมายที่เรามักใช้ นี่เป็นเพียงตัวอย่างเล็กๆ น้อยๆ ของค่าคงที่ที่ใช้กันทั่วไป:

1. คณิต.พี

   Pi Π เป็นค่าคงที่ที่ไม่ใช่วงจรอนันต์ เราสามารถใช้ Math.PI แทนได้:

    console.log(คณิตศาสตร์.PI); 

   

2. คณิต.สุ่ม()
   สร้างตัวเลขสุ่มในช่วงเวลา [0,1) :

    console.log(Math.random());console.log(Math.random()); 

ถ้าเราต้องการตัวเลขสุ่มภายในช่วงที่ระบุ เราสามารถคูณมันด้วยค่าเฉพาะแล้วปัดเศษได้

3. Math.pow(a,b)

   คำนวณ a ^b เช่น:

    console.log(Math.pow(2,3));//8

4. Math.max()/Math.min()

   เลือกค่าสูงสุด/ต่ำสุดจากอาร์กิวเมนต์จำนวนเท่าใดก็ได้:

    console.log(Math.max(1,2,3,4,5));//5console.log(Math.min(1,2,3,4,5));//1