Refactor number formatting and rounding in article.md

Author: EpicHigh

1-js/05-data-types/03-string/article.md

@@ -405,4 +405,118 @@ alert( "วิด*!*เจ็ต*/!*".endsWith("เจ็ต") ); // true, "ว
 | `substr(start, length)` | จาก `start` ดึง `length` อักขระ | อนุญาต `start` เป็นลบ |
 
 ```smart header="เลือกตัวไหนดี?"
-ทั้งหมดสามารถทำงานได้ อย่างเป็นทางการ `substr` มีข้อเสียเล็กน้อย: มันถูกอธิบายไว้ไม่ใช่ในข้อกำหนดหลักของ JavaScript แต่ใน Annex B ซึ่งครอบคลุมคุณลักษณะของเบราว์เซอร์เท่านั้นที่มีอยู่ส่วนใหญ่เพื่อเหตุผลทางประวัติศาสตร์ ดังนั้น สภาพแวดล้อมที่ไม่ใ
+ทั้งหมดสามารถทำงานได้ อย่างเป็นทางการ `substr` มีข้อเสียเล็กน้อย: มันถูกอธิบายไว้ไม่ใช่ในข้อกำหนดหลักของ JavaScript แต่ใน Annex B ซึ่งครอบคลุมคุณลักษณะของเบราว์เซอร์เท่านั้นที่มีอยู่ส่วนใหญ่เพื่อเหตุผลทางประวัติศาสตร์ ดังนั้น สภาพแวดล้อมที่ไม่ใช่เบราว์เซอร์อาจล้มเหลวในการสนับสนุนมัน แต่ในทางปฏิบัติมันทำงานได้ทุกที่
+
+จากสองตัวเลือกที่เหลือ `slice` มีความยืดหยุ่นมากกว่าเล็กน้อย เพราะอนุญาตให้ใช้อาร์กิวเมนต์ที่เป็นลบได้และสั้นกว่าในการเขียน
+
+ดังนั้น สำหรับการใช้งานในทางปฏิบัติ การจำแค่ `slice` ก็เพียงพอแล้ว
+```
+
+## การเปรียบเทียบสตริง
+
+ดังที่เราทราบจากบท <info:comparison> สตริงจะถูกเปรียบเทียบทีละอักขระตามลำดับตัวอักษร
+
+อย่างไรก็ตาม มีความแปลกประหลาดบางอย่าง:
+
+1. ตัวพิมพ์เล็กจะมากกว่าตัวพิมพ์ใหญ่เสมอ:
+
+    ```js run
+    alert( 'a' > 'Z' ); // true
+    ```
+
+2. ตัวอักษรที่มีเครื่องหมายกำกับจะ "ไม่เป็นไปตามลำดับ":
+
+    ```js run
+    alert( 'Österreich' > 'Zealand' ); // true
+    ```
+
+    สิ่งนี้อาจนำไปสู่ผลลัพธ์ที่แปลกประหลาดถ้าเราเรียงลำดับชื่อประเทศเหล่านี้ โดยปกติแล้วคนจะคาดหวังว่า `Zealand` จะอยู่หลัง `Österreich` ในรายการ
+
+เพื่อเข้าใจว่าเกิดอะไรขึ้น เราควรตระหนักว่าสตริงใน JavaScript ถูกเข้ารหัสโดยใช้ [UTF-16](https://en.wikipedia.org/wiki/UTF-16) นั่นคือ: แต่ละอักขระมีรหัสตัวเลขที่สอดคล้องกัน
+
+มีเมธอดพิเศษที่ช่วยให้เราได้อักขระจากรหัสและกลับกัน:
+
+`str.codePointAt(pos)`
+: ส่งคืนตัวเลขฐานสิบที่แสดงถึงรหัสสำหรับอักขระที่ตำแหน่ง `pos`:
+
+    ```js run
+    // ตัวอักษรที่มีตัวพิมพ์ต่างกันจะมีรหัสต่างกัน
+    alert( "Z".codePointAt(0) ); // 90
+    alert( "z".codePointAt(0) ); // 122
+    alert( "z".codePointAt(0).toString(16) ); // 7a (ถ้าเราต้องการค่าฐานสิบหก)
+    ```
+
+`String.fromCodePoint(code)`
+: สร้างอักขระโดยรหัสตัวเลข `code`
+
+    ```js run
+    alert( String.fromCodePoint(90) ); // Z
+    alert( String.fromCodePoint(0x5a) ); // Z (เราสามารถใช้ค่าฐานสิบหกเป็นอาร์กิวเมนต์ได้ด้วย)
+    ```
+
+ตอนนี้มาดูอักขระที่มีรหัส `65..220` (ตัวอักษรละตินและเพิ่มเติมเล็กน้อย) โดยการสร้างสตริงจากพวกมัน:
+
+```js run
+let str = '';
+
+for (let i = 65; i <= 220; i++) {
+  str += String.fromCodePoint(i);
+}
+alert( str );
+// ผลลัพธ์:
+// ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
+// ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜ
+```
+
+เห็นไหม? ตัวอักษรตัวพิมพ์ใหญ่มาก่อน จากนั้นก็มีอักขระพิเศษบางตัว แล้วตามด้วยตัวอักษรตัวพิมพ์เล็ก และ `Ö` อยู่ใกล้ท้ายของผลลัพธ์
+
+ตอนนี้มันชัดเจนแล้วว่าทำไม `a > Z`
+
+อักขระถูกเปรียบเทียบโดยรหัสตัวเลขของพวกมัน รหัสที่มากกว่าหมายความว่าอักขระนั้นมากกว่า รหัสสำหรับ `a` (97) มากกว่ารหัสสำหรับ `Z` (90)
+
+- ตัวอักษรตัวพิมพ์เล็กทั้งหมดมาหลังตัวอักษรตัวพิมพ์ใหญ่เพราะรหัสของพวกมันมากกว่า
+- ตัวอักษรบางตัวเช่น `Ö` แยกออกจากตัวอักษรหลัก ในที่นี้ รหัสของมันมากกว่าอะไรก็ตามจาก `a` ถึง `z`
+
+### การเปรียบเทียบที่ถูกต้อง [#correct-comparisons]
+
+อัลกอริทึม "ที่ถูกต้อง" ในการเปรียบเทียบสตริงนั้นซับซ้อนกว่าที่อาจดูเหมือน เพราะตัวอักษรแตกต่างกันสำหรับภาษาต่างๆ
+
+ดังนั้น เบราว์เซอร์จำเป็นต้องรู้ภาษาเพื่อเปรียบเทียบ
+
+โชคดีที่เบราว์เซอร์สมัยใหม่สนับสนุนมาตรฐานการทำให้เป็นสากล [ECMA-402](https://www.ecma-international.org/publications-and-standards/standards/ecma-402/)
+
+มันให้เมธอดพิเศษสำหรับการเปรียบเทียบสตริงในภาษาต่างๆ ตามกฎของพวกมัน
+
+การเรียก [str.localeCompare(str2)](mdn:js/String/localeCompare) ส่งคืนจำนวนเต็มที่บ่งบอกว่า `str` น้อยกว่า เท่ากับ หรือมากกว่า `str2` ตามกฎภาษา:
+
+- ส่งคืนจำนวนติดลบถ้า `str` น้อยกว่า `str2`
+- ส่งคืนจำนวนบวกถ้า `str` มากกว่า `str2`
+- ส่งคืน `0` ถ้าพวกมันเท่ากัน
+
+ตัวอย่างเช่น:
+
+```js run
+alert( 'Österreich'.localeCompare('Zealand') ); // -1
+```
+
+เมธอดนี้จริงๆ แล้วมีอาร์กิวเมนต์เพิ่มเติมอีกสองตัวที่ระบุใน [เอกสาร](mdn:js/String/localeCompare) ซึ่งช่วยให้ระบุภาษาได้ (โดยค่าเริ่มต้นจะใช้จากสภาพแวดล้อม ลำดับตัวอักษรขึ้นอยู่กับภาษา) และตั้งค่ากฎเพิ่มเติมเช่นการคำนึงถึงตัวพิมพ์ใหญ่-เล็กหรือควรปฏิบัติกับ `"a"` และ `"á"` เหมือนกันหรือไม่ เป็นต้น
+
+## สรุป
+
+- มีเครื่องหมายคำพูด 3 ประเภท Backticks ช่วยให้สตริงสามารถขึ้นหลายบรรทัดและแทรกนิพจน์ `${…}` ได้
+- เราสามารถใช้อักขระพิเศษได้ เช่น การขึ้นบรรทัดใหม่ `\n`
+- ในการรับอักขระ ใช้: `[]` หรือเมธอด `at`
+- ในการรับสตริงย่อย ใช้: `slice` หรือ `substring`
+- ในการทำให้สตริงเป็นตัวพิมพ์เล็ก/ใหญ่ ใช้: `toLowerCase/toUpperCase`
+- ในการค้นหาสตริงย่อย ใช้: `indexOf` หรือ `includes/startsWith/endsWith` สำหรับการตรวจสอบอย่างง่าย
+- ในการเปรียบเทียบสตริงตามภาษา ใช้: `localeCompare` มิฉะนั้นพวกมันจะถูกเปรียบเทียบตามรหัสอักขระ
+
+มีเมธอดที่เป็นประโยชน์อื่นๆ อีกหลายตัวในสตริง:
+
+- `str.trim()` -- ลบ ("ตัด") ช่องว่างจากจุดเริ่มต้นและจุดสิ้นสุดของสตริง
+- `str.repeat(n)` -- ทำซ้ำสตริง `n` ครั้ง
+- ...และอื่นๆ ที่สามารถพบได้ใน[คู่มือ](mdn:js/String)
+
+สตริงยังมีเมธอดสำหรับการค้นหา/แทนที่ด้วยนิพจน์ทั่วไป (regular expressions) แต่นั่นเป็นหัวข้อใหญ่ ดังนั้นจึงอธิบายในส่วนบทเรียนแยกต่างหาก <info:regular-expressions>
+
+นอกจากนี้ ณ ตอนนี้สิ่งสำคัญคือต้องทราบว่าสตริงอยู่บนพื้นฐานของการเข้ารหัส Unicode และดังนั้นจึงมีปัญหาเกี่ยวกับการเปรียบเทียบ มีข้อมูลเพิ่มเติมเกี่ยวกับ Unicode ในบท <info:unicode>