Refactor number formatting and rounding in article.md

Author: EpicHigh

1-js/05-data-types/02-number/article.md

@@ -280,4 +280,165 @@ alert( 9999999999999999 ); // แสดง 10000000000000000
 JavaScript ไม่ทำให้เกิดข้อผิดพลาดในเหตุการณ์เช่นนี้ มันพยายามอย่างดีที่สุดเพื่อให้ตัวเลขพอดีกับรูปแบบที่ต้องการ แต่น่าเสียดายที่รูปแบบนี้ไม่ใหญ่พอ
 ````
 
-```smart header="ศูนย์สองตัว"
+```smart header="ศูนย์สองตัว"
+ผลที่ตลกอีกอย่างหนึ่งของการแสดงตัวเลขภายในคือการมีศูนย์สองตัว: `0` และ `-0`
+
+นั่นเป็นเพราะเครื่องหมายถูกแสดงด้วยบิตเดียว ดังนั้นจึงสามารถตั้งค่าหรือไม่ตั้งค่าสำหรับตัวเลขใดๆ รวมถึงศูนย์
+
+ในกรณีส่วนใหญ่ ความแตกต่างไม่สามารถสังเกตเห็นได้ เพราะตัวดำเนินการถูกปรับให้ปฏิบัติต่อพวกมันเหมือนกัน
+```
+
+## การทดสอบ: isFinite และ isNaN
+
+จำค่าตัวเลขพิเศษสองตัวนี้ได้ไหม?
+
+- `Infinity` (และ `-Infinity`) เป็นค่าตัวเลขพิเศษที่มากกว่า (น้อยกว่า) ทุกอย่าง
+- `NaN` แสดงถึงข้อผิดพลาด
+
+พวกมันเป็นของประเภท `number` แต่ไม่ใช่ตัวเลข "ปกติ" ดังนั้นจึงมีฟังก์ชันพิเศษเพื่อตรวจสอบพวกมัน:
+
+
+- `isNaN(value)` แปลงอาร์กิวเมนต์ของมันเป็นตัวเลขและจากนั้นทดสอบว่าเป็น `NaN`:
+
+    ```js run
+    alert( isNaN(NaN) ); // จริง
+    alert( isNaN("str") ); // จริง
+    ```
+
+    แต่เราจำเป็นต้องใช้ฟังก์ชันนี้หรือไม่? เราไม่สามารถใช้การเปรียบเทียบ `=== NaN` ได้หรือ? ขอโทษ แต่คำตอบคือไม่ได้ ค่า `NaN` เป็นเอกลักษณ์ในการที่มันไม่เท่ากับอะไรเลย รวมถึงตัวมันเอง:
+
+    ```js run
+    alert( NaN === NaN ); // เท็จ
+    ```
+
+- `isFinite(value)` แปลงอาร์กิวเมนต์ของมันเป็นตัวเลขและคืนค่า `จริง` ถ้ามันเป็นตัวเลขปกติ ไม่ใช่ `NaN/Infinity/-Infinity`:
+
+    ```js run
+    alert( isFinite("15") ); // จริง
+    alert( isFinite("str") ); // เท็จ เพราะเป็นค่าพิเศษ: NaN
+    alert( isFinite(Infinity) ); // เท็จ เพราะเป็นค่าพิเศษ: Infinity
+    ```
+
+บางครั้ง `isFinite` ถูกใช้เพื่อตรวจสอบว่าค่าสตริงเป็นตัวเลขปกติหรือไม่:
+
+
+```js run
+let num = +prompt("ป้อนตัวเลข", '');
+
+// จะเป็นจริงยกเว้นคุณป้อน Infinity, -Infinity หรือไม่ใช่ตัวเลข
+alert( isFinite(num) );
+```
+
+โปรดทราบว่าสตริงว่างเปล่าหรือสตริงที่มีเฉพาะช่องว่างจะถูกปฏิบัติเป็น `0` ในทุกฟังก์ชันตัวเลขรวมถึง `isFinite`
+
+```smart header="เปรียบเทียบกับ `Object.is`"
+
+มีวิธีการในตัวพิเศษ [`Object.is`](mdn:js/Object/is) ที่เปรียบเทียบค่าเหมือน `===` แต่น่าเชื่อถือมากกว่าสำหรับสองกรณีพิเศษ:
+
+1. มันทำงานกับ `NaN`: `Object.is(NaN, NaN) === true` นั่นเป็นสิ่งที่ดี
+2. ค่า `0` และ `-0` แตกต่างกัน: `Object.is(0, -0) === false` ทางเทคนิคแล้วนั่นเป็นความจริง เพราะภายในตัวเลขมีบิตเครื่องหมายที่อาจแตกต่างกันแม้ว่าบิตอื่นๆ ทั้งหมดจะเป็นศูนย์
+
+ในทุกกรณีอื่นๆ `Object.is(a, b)` เหมือนกับ `a === b`
+
+วิธีการเปรียบเทียบนี้มักใช้ในข้อกำหนดของ JavaScript เมื่ออัลกอริทึมภายในต้องการเปรียบเทียบสองค่าว่าเหมือนกันพอดีหรือไม่ มันใช้ `Object.is` (เรียกภายในว่า [SameValue](https://tc39.github.io/ecma262/#sec-samevalue))
+```
+
+
+## parseInt และ parseFloat
+
+การแปลงเป็นตัวเลขโดยใช้เครื่องหมายบวก `+` หรือ `Number()` นั้นเข้มงวด ถ้าค่าไม่ใช่ตัวเลขพอดี มันจะล้มเหลว:
+
+```js run
+alert( +"100px" ); // NaN
+```
+
+ข้อยกเว้นเพียงอย่างเดียวคือช่องว่างที่อยู่ต้นหรือท้ายสตริง เพราะมันจะถูกละเลย
+
+แต่ในชีวิตจริง เรามักจะมีค่าในหน่วยต่างๆ เช่น `"100px"` หรือ `"12pt"` ใน CSS และในหลายประเทศสัญลักษณ์สกุลเงินจะอยู่หลังจำนวนเงิน ดังนั้นเราจึงมี `"19€"` และต้องการแยกค่าตัวเลขออกมา
+
+นั่นคือสิ่งที่ `parseInt` และ `parseFloat` มีไว้
+
+พวกมัน "อ่าน" ตัวเลขจากสตริงจนกว่าจะไม่สามารถอ่านได้ ในกรณีที่เกิดข้อผิดพลาด ตัวเลขที่รวบรวมได้จะถูกส่งคืน ฟังก์ชัน `parseInt` ส่งคืนจำนวนเต็ม ในขณะที่ `parseFloat` จะส่งคืนตัวเลขที่มีทศนิยม:
+
+```js run
+alert( parseInt('100px') ); // 100
+alert( parseFloat('12.5em') ); // 12.5
+
+alert( parseInt('12.3') ); // 12, เฉพาะส่วนจำนวนเต็มถูกส่งคืน
+alert( parseFloat('12.3.4') ); // 12.3, จุดที่สองหยุดการอ่าน
+```
+
+มีสถานการณ์ที่ `parseInt/parseFloat` จะส่งคืน `NaN` มันเกิดขึ้นเมื่อไม่สามารถอ่านตัวเลขได้เลย:
+
+```js run
+alert( parseInt('a123') ); // NaN, สัญลักษณ์แรกหยุดกระบวนการ
+```
+
+````smart header="อาร์กิวเมนต์ที่สองของ `parseInt(str, radix)`"
+ฟังก์ชัน `parseInt()` มีพารามิเตอร์ที่สองซึ่งเป็นตัวเลือก มันระบุฐานของระบบตัวเลข ดังนั้น `parseInt` สามารถแยกวิเคราะห์สตริงของตัวเลขฐานสิบหก ตัวเลขฐานสอง และอื่นๆ ได้:
+
+```js run
+alert( parseInt('0xff', 16) ); // 255
+alert( parseInt('ff', 16) ); // 255, ไม่มี 0x ก็ทำงานได้
+
+alert( parseInt('2n9c', 36) ); // 123456
+```
+````
+
+## ฟังก์ชันทางคณิตศาสตร์อื่นๆ
+
+JavaScript มีวัตถุ [Math](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Math) ในตัวซึ่งมีไลบรารีขนาดเล็กของฟังก์ชันทางคณิตศาสตร์และค่าคงที่
+
+ตัวอย่างบางส่วน:
+
+`Math.random()`
+: ส่งคืนตัวเลขสุ่มตั้งแต่ 0 ถึง 1 (ไม่รวม 1)
+
+    ```js run
+    alert( Math.random() ); // 0.1234567894322
+    alert( Math.random() ); // 0.5435252343232
+    alert( Math.random() ); // ... (ตัวเลขสุ่มใดๆ)
+    ```
+
+`Math.max(a, b, c...)` / `Math.min(a, b, c...)`
+: ส่งคืนค่าที่มากที่สุด/น้อยที่สุดจากอาร์กิวเมนต์จำนวนใดๆ
+
+    ```js run
+    alert( Math.max(3, 5, -10, 0, 1) ); // 5
+    alert( Math.min(1, 2) ); // 1
+    ```
+
+`Math.pow(n, power)`
+: ส่งคืน `n` ยกกำลัง `power`
+
+    ```js run
+    alert( Math.pow(2, 10) ); // 2 ยกกำลัง 10 = 1024
+    ```
+
+มีฟังก์ชันและค่าคงที่อื่นๆ อีกมากใน `Math` รวมถึงตรีโกณมิติ ซึ่งคุณสามารถพบได้ในเอกสารสำหรับวัตถุ [Math](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Math)
+
+## สรุป
+
+การเขียนตัวเลขที่มีศูนย์จำนวนมาก:
+
+- ต่อท้าย `"e"` กับจำนวนศูนย์ไปยังตัวเลข เช่น: `123e6` เหมือนกับ `123` ตามด้วยศูนย์ 6 ตัว `123000000`
+- ตัวเลขลบหลัง `"e"` ทำให้ตัวเลขถูกหารด้วย 1 ตามด้วยจำนวนศูนย์ที่กำหนด เช่น `123e-6` หมายถึง `0.000123` (`123` หนึ่งในล้าน)
+
+สำหรับระบบตัวเลขต่างๆ:
+
+- สามารถเขียนตัวเลขโดยตรงในระบบฐานสิบหก (`0x`), ฐานแปด (`0o`) และฐานสอง (`0b`)
+- `parseInt(str, base)` แยกวิเคราะห์สตริง `str` เป็นจำนวนเต็มในระบบตัวเลขที่มีฐาน `base`, `2 ≤ base ≤ 36`
+- `num.toString(base)` แปลงตัวเลขเป็นสตริงในระบบตัวเลขที่มีฐานที่กำหนด
+
+สำหรับการแปลงค่าเช่น `12pt` และ `100px` เป็นตัวเลข:
+
+- ใช้ `parseInt/parseFloat` สำหรับการแปลง "แบบนุ่มนวล" ซึ่งอ่านตัวเลขจากสตริงและจากนั้นส่งคืนค่าที่สามารถอ่านได้ก่อนเกิดข้อผิดพลาด
+
+สำหรับเศษส่วน:
+
+- ปัดเศษโดยใช้ `Math.floor`, `Math.ceil`, `Math.trunc`, `Math.round` หรือ `num.toFixed(precision)`
+- ต้องแน่ใจว่าจำไว้ว่ามีการสูญเสียความแม่นยำเมื่อทำงานกับเศษส่วน
+
+ฟังก์ชันทางคณิตศาสตร์เพิ่มเติม:
+
+- ดูวัตถุ [Math](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Math) เมื่อคุณต้องการใช้ ไลบรารีนี้มีขนาดเล็กมาก แต่สามารถครอบคลุมความต้องการทางคณิตศาสตร์ที่สำคัญ