diff --git a/1-js/02-first-steps/09-comparison/article.md b/1-js/02-first-steps/09-comparison/article.md
index 20580813e..bb249116d 100644
--- a/1-js/02-first-steps/09-comparison/article.md
+++ b/1-js/02-first-steps/09-comparison/article.md
@@ -1,101 +1,101 @@
-## การเปรียบเทียบ
+# การเปรียบเทียบ
 
-เราทุกคนรู้จักตัวดำเนินการเปรียบเทียบจากวิชาคณิตศาสตร์กันอยู่แล้ว
+เรารู้จักเครื่องหมายเปรียบเทียบ9y;อย่างจากคณิตศาสตร์
 
-ใน JavaScript ตัวดำเนินการเปรียบเทียบเขียนแบบนี้:
+ใน JavaScript เขียนได้ดังนี้:
 
-- มากกว่า/น้อยกว่า: `a > b`, `a < b`.
-- มากกว่า/น้อยกว่าหรือเท่ากับ: `a >= b`, `a <= b`.
-- เท่ากับ: `a == b`, โปรดทราบว่าเครื่องหมายเท่ากับสองตัว `==` หมายถึงการทดสอบความเท่ากับ ในขณะที่เครื่องหมายเท่ากับตัวเดียว `a = b` หมายถึงการกำหนดค่า
-- ไม่เท่ากับ: ในคณิตศาสตร์ใช้สัญลักษณ์ `≠` แต่ใน JavaScript เขียนเป็น `a != b`
+- มากกว่า/น้อยกว่า: <code>a &gt; b</code>, <code>a &lt; b</code>
+- มากกว่าหรือเท่ากับ/น้อยกว่าหรือเท่ากับ: <code>a &gt;= b</code>, <code>a &lt;= b</code>
+- เท่ากับ: `a == b` สังเกตว่าต้องใช้เครื่องหมายเท่ากับสองตัว `==` สำหรับการเช็คความเท่ากัน ส่วนเครื่องหมายเดียว `a = b` ใช้สำหรับการกำหนดค่า
+- ไม่เท่ากับ: ในเชิงคณิตศาสตร์ใช้สัญลักษณ์ <code>&ne;</code> แต่ใน JavaScript เขียนเป็น <code>a != b</code>
 
-ในบทความนี้ เราจะเรียนรู้เพิ่มเติมเกี่ยวกับประเภทของการเปรียบเทียบที่แตกต่างกัน ว่า JavaScript เปรียบเทียบอย่างไร รวมถึงความแปลกประหลาดที่สำคัญ
+ในบทความนี้ เราจะเรียนรู้เพิ่มเติมเกี่ยวกับการเปรียบเทียบแบบต่างๆ วิธีที่ JavaScript เปรียบเทียบ รวมถึงข้อควรระวังสำคัญ 
 
-ในตอนท้าย คุณจะได้พบกับสูตรเด็ดในการหลีกเลี่ยงปัญหาที่เกี่ยวข้องกับ "JavaScript Quirks"
+ท้ายบทความมีเคล็ดลับดีๆ ในการหลีกเลี่ยงปัญหาที่มักพบใน JavaScript
 
-## เปรียบเทียบแล้วได้บูลีน (Boolean)
+## ผลลัพธ์เป็น Boolean
 
-ตัวดำเนินการเปรียบเทียบทั้งหมดจะส่งคืนค่า **บูลีน (Boolean)**:
+ผลการเปรียบเทียบทั้งหมดจะให้ค่า boolean:
 
-- `true` -- หมายถึง "ใช่" "ถูกต้อง" หรือ "ความจริง"
-- `false` -- หมายถึง "ไม่ใช่" "ผิด" หรือ "ไม่ใช่ความจริง"
+- `true` หมายถึง "ใช่" "ถูกต้อง" หรือ "จริง"
+- `false` หมายถึง "ไม่" "ไม่ถูกต้อง" หรือ "ไม่จริง" 
 
 ตัวอย่างเช่น:
 
 ```js run
-alert( 2 > 1 );  // true (ใช่)
-alert( 2 == 1 ); // false (ไม่ใช่)
-alert( 2 != 1 ); // true (ใช่)
+alert( 2 > 1 );  // true (ถูก)
+alert( 2 == 1 ); // false (ไม่ถูก)
+alert( 2 != 1 ); // true (ถูก)
 ```
 
-ผลลัพธ์ของการเปรียบเทียบสามารถกำหนดให้กับตัวแปรได้เช่นเดียวกับค่าอื่นๆ:
+ผลการเปรียบเทียบสามารถเก็บในตัวแปรได้ เหมือนกับค่าอื่นๆ:
 
 ```js run
-let result = 5 > 4; // กำหนดผลลัพธ์ของการเปรียบเทียบ
+let result = 5 > 4; // เก็บผลการเปรียบเทียบ
 alert( result ); // true
 ```
 
-## เปรียบเทียบสตริง (String)
+## การเปรียบเทียบ string
 
-เพื่อดูว่าสตริงหนึ่งมากกว่าอีกสตริงหนึ่งหรือไม่ JavaScript ใช้ลำดับที่เรียกว่า "พจนานุกรม" หรือ "lexicographical"
+ในการเช็คว่า string อันหนึ่งมากกว่าอีกอันหรือไม่ JavaScript ใช้การเรียงลำดับแบบ "พจนานุกรม" หรือ "ตามตัวอักษร"
 
-กล่าวอีกนัยหนึ่ง สตริงจะถูกเปรียบเทียบทีละตัวอักษร
+หรือพูดง่ายๆ คือเปรียบเทียบ string ทีละตัวอักษร
 
 ตัวอย่างเช่น:
 
 ```js run
 alert( 'Z' > 'A' ); // true
 alert( 'Glow' > 'Glee' ); // true
-alert( 'Bee' > 'Be' ); // true
+alert( 'Bee' > 'Be' ); // true 
 ```
 
-ขั้นตอนการเปรียบเทียบสตริงสองสตริงทำได้ง่ายๆ ดังนี้:
+ขั้นตอนในการเปรียบเทียบ string สองอันมีดังนี้:
 
-1. เปรียบเทียบตัวอักษรตัวแรกของทั้งสองสตริง
-2. ถ้าตัวอักษรตัวแรกของสตริงแรกมากกว่า (หรือน้อยกว่า) ตัวอักษรของอีกสตริง แสดงว่าสตริงแรกมากกว่า (หรือน้อยกว่า) สตริงที่สอง เสร็จเรียบร้อย
-3. มิฉะนั้น ถ้าตัวอักษรตัวแรกของทั้งสองสตริงเหมือนกัน ให้เปรียบเทียบตัวอักษรตัวที่สองเช่นเดียวกัน
-4. ทำซ้ำจนกว่าจะถึงจุดสิ้นสุดของสตริงใดสตริงหนึ่ง
-5. ถ้าทั้งสองสตริงจบลงที่ความยาวเท่ากัน แสดงว่าทั้งสองสตริงเท่ากัน มิฉะนั้น สตริงที่ยาวกว่าจะใหญ่กว่า
+1. เปรียบเทียบตัวอักษรตัวแรกของ string ทั้งสองอัน
+2. ถ้าตัวอักษรตัวแรกจาก string แรกมากกว่า (หรือน้อยกว่า) string ที่สอง แสดงว่า string แรกมากกว่า (หรือน้อยกว่า) string ที่สอง จบการทำงาน
+3. ถ้าตัวอักษรตัวแรกของ string ทั้งสองเหมือนกัน ให้เปรียบเทียบตัวอักษรที่สองแบบเดียวกัน  
+4. ทำซ้ำไปเรื่อยๆ จนกว่าจะเจอตัวอักษรที่แตกต่างกันหรือจนหมด string
+5. ถ้าหมด string พร้อมกันที่ความยาวเท่ากัน แปลว่าเท่ากัน ไม่อย่างนั้น string ที่ยาวกว่าจะมากกว่า
 
-ในตัวอย่างแรกข้างต้น การเปรียบเทียบ `'Z' > 'A'` จะได้ผลลัพธ์ในขั้นตอนแรก
+ในตัวอย่างแรกข้างบน การเปรียบเทียบ `'Z' > 'A'` ให้ผลลัพธ์ตั้งแต่ขั้นตอนแรก
 
-การเปรียบเทียบที่สอง `'Glow'` และ `'Glee'` ต้องใช้ขั้นตอนเพิ่มเติมเนื่องจากสตริงถูกเปรียบเทียบทีละตัวอักษร:
+การเปรียบเทียบที่สองระหว่าง `'Glow'` กับ `'Glee'` ต้องใช้หลายขั้นตอนมากกว่า โดยเปรียบเทียบตัวอักษรทีละตัว:
 
-1. `G` เหมือนกับ `G`
-2. `l` เหมือนกับ `l`
-3. `o` มากกว่า `e` หยุดตรงนี้. สตริงแรกมากกว่า
+1. `G` เท่ากับ `G`
+2. `l` เท่ากับ `l`
+3. `o` มากกว่า `e` หยุดตรงนี้ string แรกมากกว่า
 
 ```smart header="ไม่ใช่พจนานุกรมจริงๆ แต่เป็นลำดับ Unicode"
-ขั้นตอนการเปรียบเทียบที่ให้ไว้ข้างต้นนั้นเทียบเท่ากับที่ใช้ในพจนานุกรมหรือสมุดโทรศัพท์ แต่ไม่เหมือนกันซะทีเดียว
+ขั้นตอนการเปรียบเทียบข้างต้นคล้ายกับที่ใช้ในพจนานุกรมหรือสมุดโทรศัพท์ แต่ไม่เหมือนกันทีเดียว
 
-ตัวอย่างเช่น ตัวพิมพ์ใหญ่มีผล ตัวพิมพ์ใหญ่ `"A"` ไม่เท่ากับตัวพิมพ์เล็ก `"a"` ตัวไหนใหญ่กว่า? ตัวพิมพ์เล็ก `"a"`. ทำไม? เนื่องจากตัวอักษรตัวเล็กมีดัชนีที่สูงกว่าในตารางการเข้ารหัสภายในที่ JavaScript ใช้ (Unicode) เราจะกลับมาดูรายละเอียดและผลที่ตามมาของเรื่องนี้ในบท <info:string>.
+เช่น ตัวพิมพ์ใหญ่เล็กมีผล `"A"` ไม่เท่ากับ `"a"` ตัวไหนมากกว่า? `"a"` เพราะมันมีค่าดัชนีที่สูงกว่าในตารางเข้ารหัสภายใน (Unicode) ที่ JavaScript ใช้ เราจะกลับมาดูรายละเอียดและผลที่ตามมาในบท <info:string>
 ```
 
-## เปรียบเทียบคนละแบบ (Comparison of different types)
+## การเปรียบเทียบข้อมูลต่างชนิด
 
-เวลาเปรียบเทียบค่าคนละแบบ JavaScript จะแปลงค่าเหล่านั้นเป็นตัวเลขเหมือนทำเวทมนตร์!
+เมื่อเปรียบเทียบค่าที่มีชนิดต่างกัน JavaScript จะแปลงค่าเป็นตัวเลขก่อน
 
 ตัวอย่างเช่น:
 
 ```js run
-alert( '2' > 1 ); // true, string '2' becomes a number 2
-alert( '01' == 1 ); // true, string '01' becomes a number 1
+alert( '2' > 1 ); // true, string '2' จะถูกแปลงเป็นตัวเลข 2
+alert( '01' == 1 ); // true, string '01' จะถูกแปลงเป็นตัวเลข 1
 ```
 
-สำหรับค่าบูลีน `true` จะกลายเป็น `1` และ `false` จะกลายเป็น `0` เหมือนการเปิดไฟ (true) กับปิดไฟ (false)
+สำหรับค่า boolean `true` จะกลายเป็น `1` และ `false` จะกลายเป็น `0`
 
-For example:
+ตัวอย่างเช่น:
 
 ```js run
-alert( true == 1 ); // true
+alert( true == 1 ); // true  
 alert( false == 0 ); // true
 ```
 
-````smart header="สนุกกับผลลัพธ์"
-บางครั้งอาจเกิดขึ้นพร้อมกัน:
+````smart header="ผลลัพธ์ที่แปลกประหลาด"
+มันเป็นไปได้ว่าในเวลาเดียวกัน:
 
-- สองค่าเท่ากัน
-- หนึ่งในนั้นเป็น `true` อีกอันเป็น `false`
+- สองค่านั้นเท่ากัน
+- แต่ค่าหนึ่งเป็น `true` เมื่อแปลงเป็น boolean ส่วนอีกค่าเป็น `false` เมื่อแปลงเป็น boolean
 
 ตัวอย่างเช่น:
 
@@ -103,119 +103,114 @@ alert( false == 0 ); // true
 let a = 0;
 alert( Boolean(a) ); // false
 
-let b = "0";
+let b = "0"; 
 alert( Boolean(b) ); // true
 
 alert(a == b); // true!
 ```
 
-จากมุมมองของ JavaScript ผลลัพธ์นี้ค่อนข้างปกติ การตรวจสอบความเท่ากันจะแปลงค่าโดยใช้การแปลงตัวเลข (ดังนั้น `"0"` จึงกลายเป็น `0`) ในขณะที่การแปลง `Boolean` อย่างชัดเจนใช้อีกชุดของกฎ
+จากมุมมองของ JavaScript ผลลัพธ์นี้ถือว่าปกติ การเช็คความเท่ากันจะแปลงค่าโดยใช้การแปลงเป็นตัวเลข (ทำให้ `"0"` เป็น `0`) ในขณะที่การแปลงเป็น `Boolean` โดยตรงใช้ชุดกฎที่แตกต่างกัน
 ````
 
-## เปรียบเทียบแบบเข้มงวด (Strict equality)
+## ความเท่าเทียมกันอย่างเข้มงวด
 
-เปรียบเทียบแบบธรรมดาๆ `==` มีปัญหาอยู่! มันแยกความแตกต่างระหว่าง `0` กับ `false` ไม่ได้
+การตรวจสอบความเท่าเทียมกันแบบปกติด้วย `==` มีปัญหาคือไม่สามารถแยกแยะความแตกต่างระหว่าง `0` กับ `false` ได้:
 
 ```js run
 alert( 0 == false ); // true
 ```
 
-เหมือนตาบอดสีเลย!
-
-ก็มันแปลง `0` กับ `false` ให้กลายเป็นตัวเลขเหมือนกันซะนี่
+เหตุการณ์เดียวกันนี้เกิดขึ้นกับ string ว่างด้วย:
 
-```js run
+```js run 
 alert( '' == false ); // true
 ```
 
-เอาไงดีล่ะถ้าอยากแยก `0` กับ `false` ออกจากกัน?
+สิ่งนี้เกิดขึ้นเพราะเมื่อเปรียบเทียบข้อมูลคนละชนิดด้วยเครื่องหมาย `==` JavaScript จะแปลงชนิดข้อมูลเป็นตัวเลขก่อน ทั้ง string ว่างและ `false` จะถูกแปลงเป็นศูนย์
 
-**ใช้การเปรียบเทียบแบบเข้มงวด `===` สิ!**
+แล้วถ้าเราอยากแยกแยะความแตกต่างระหว่าง `0` กับ `false` ล่ะ จะทำอย่างไร?
 
-ตัวดำเนินการนี้เปรียบเทียบแบบละเอียด ไม่ต้องแปลงชนิดข้อมูล
+**เครื่องหมายเท่ากันอย่างเข้มงวด `===` จะเปรียบเทียบความเท่าเทียมกันโดยไม่แปลงชนิดข้อมูล**
 
-พูดอีกอย่างก็คือ ถ้า `a` กับ `b` มีชนิดข้อมูลต่างกัน `a === b` จะรีบส่งคืน `false` ทันทีแบบไม่ต้องพยายามแปลง
+อีกนัยหนึ่ง ถ้า `a` และ `b` เป็นคนละชนิดกัน `a === b` จะคืนค่า `false` ทันที โดยไม่พยายามแปลงชนิดข้อมูล
 
-ลองดู:
+ลองดูตัวอย่าง:
 
 ```js run
-alert( 0 === false ); // false เพราะชนิดข้อมูลต่างกัน
+alert( 0 === false ); // false เพราะเป็นคนละชนิดกัน  
 ```
 
-นอกจากนี้ยังมีตัวดำเนินการ "ไม่เท่าเทียมแบบเข้มงวด" `!==` ที่คล้ายกับ `!=`
-
-ตัวดำเนินการความเท่าเทียมแบบเข้มงวดเขียนยาวกว่าเล็กน้อย แต่ทำให้เห็นได้ชัดว่าเกิดอะไรขึ้นและมีโอกาสเกิดข้อผิดพลาดน้อยลง
-
-## เปรียบเทียบกับ null และ undefined
+นอกจากนี้ยังมีเครื่องหมาย "ไม่เท่ากันอย่างเข้มงวด" `!==` ที่คล้ายกับ `!=` ด้วย
 
-เดี๋ยวๆๆๆๆ มีเรื่องตลกๆ เกี่ยวกับการเปรียบเทียบ `null` และ `undefined` กับค่าอื่นๆ นะ
+การใช้เครื่องหมายเท่ากันแบบเข้มงวดอาจเขียนยาวขึ้นหน่อย แต่จะทำให้เห็นชัดเจนว่าเกิดอะไรขึ้นและลดโอกาสเกิดข้อผิดพลาดได้มากกว่า
 
-**เปรียบเทียบแบบเข้มงวด `===`**
+## การเปรียบเทียบกับ null และ undefined
 
-สองคนนี้ต่างกันนะ เพราะคนละชนิดกัน
+เมื่อ `null` หรือ `undefined` ถูกนำมาเปรียบเทียบกับค่าอื่นๆ อาจเกิดพฤติกรรมที่ไม่ตรงกับความคาดหมายเสมอไป
 
-    ```js run
-    alert( null === undefined ); // false
-    ```
+สำหรับการตรวจสอบความเท่ากันอย่างเข้มงวดด้วย `===`:
+: ค่าเหล่านี้แตกต่างกัน เพราะแต่ละค่ามีประเภทข้อมูลต่างกัน
 
-**เปรียบเทียบแบบธรรมดา `==`**
-
-อุ๊ย! มีกฎลับ! สองคนนี้เป็น "คู่รักสุดคิ้วท์": เท่ากัน (ตาม `==`) แต่ไม่เท่ากับค่าอื่นๆ นะ
+```js run
+alert( null === undefined ); // false
+```
 
-    ```js run
-    alert( null == undefined ); // true
-    ```
+สำหรับการตรวจสอบความเท่ากันแบบไม่เข้มงวดด้วย `==`:
+: มีกฎพิเศษ ค่าทั้งสองนี้เป็น "คู่รักในฝัน" คือเท่ากันในแง่ของ `==` แต่ไม่เท่ากับค่าอื่นใด
 
-**เปรียบเทียบแบบอื่นๆ `< > <= >=`**
+```js run
+alert( null == undefined ); // true
+```  
 
-`null` และ `undefined` จะถูกแปลงเป็นตัวเลข: `null` เป็น `0`, `undefined` เป็น `NaN` (Not a Number)
+สำหรับการคำนวณทางคณิตศาสตร์และการเปรียบเทียบอื่นๆ `< > <= >=`:
+: `null/undefined` จะถูกแปลงเป็นตัวเลข โดย `null` เป็น `0` และ `undefined` เป็น `NaN` 
 
-เดี๋ยวมาดูเรื่องตลกๆ ที่เกิดขึ้นจากกฎเหล่านี้กัน และที่สำคัญกว่านั้น เราจะไม่พลาดท่ากับกฎเหล่านี้อย่างไร
+เรามาดูเหตุการณ์แปลกๆ ที่เกิดขึ้นเมื่อใช้กฎเหล่านี้ และที่สำคัญกว่านั้น คือเราจะหลีกเลี่ยงกับดักเหล่านี้ได้อย่างไร
 
-### สับสนงงงวย: null vs 0
+### ผลลัพธ์ประหลาด: null เทียบกับ 0
 
-ลองเปรียบเทียบ `null` กับ 0 กัน:
+ลองเปรียบเทียบ `null` กับศูนย์ดู:
 
 ```js run
 alert( null > 0 );  // (1) false
 alert( null == 0 ); // (2) false
-alert( null >= 0 ); // (3) *!*true*/!*
+alert( null >= 0 ); // (3) *!*true*/!*  
 ```
 
-งงดิ! ผลลัพธ์สุดท้ายบอกว่า `null` มากกว่าหรือน้อยกว่าหรือเท่ากับ "0" ดังนั้นในการเปรียบเทียบข้างต้นอย่างน้อยหนึ่งข้อควรเป็น `true` แต่ดันเป็น `false` ทั้งคู่
+ทางคณิตศาสตร์แล้วมันแปลกมาก ผลลัพธ์สุดท้ายบอกว่า "`null` มากกว่าหรือเท่ากับศูนย์" ดังนั้นในการเปรียบเทียบข้างต้นต้องมีอย่างน้อยหนึ่งค่าเป็น `true` แต่กลับเป็น false ทั้งคู่
 
-สาเหตุคือการตรวจสอบความเท่าเทียม `==` และการเปรียบเทียบ `> < >= <=` ทำงานแตกต่างกัน การเปรียบเทียบจะแปลง `null` เป็นตัวเลข โดยพิจารณาว่าเป็น `0` นั่นคือเหตุผลที่ (3) `null >= 0` เป็น `true` และ (1) `null > 0` เป็น `false`
+สาเหตุคือ การตรวจสอบความเท่ากันด้วย `==` และการเปรียบเทียบ `> < >= <=` ทำงานต่างกัน การเปรียบเทียบจะแปลง `null` เป็นตัวเลขและถือว่าเป็น `0` นั่นเป็นเหตุผลที่ (3) `null >= 0` เป็น true และ (1) `null > 0` เป็น false
 
-ในทางกลับกัน การตรวจสอบความเท่าเทียม `==` สำหรับ `undefined` และ `null` ถูกกำหนดไว้ในลักษณะที่ ไม่ต้องแปลงใดๆ ก็เท่ากัน และไม่เท่ากับอะไรอื่น นั่นคือเหตุผลที่ (2) `null == 0` เป็น `false`
+ในทางกลับกัน การตรวจสอบความเท่ากันด้วย `==` ระหว่าง `undefined` กับ `null` นั้นถูกกำหนดไว้ว่า หากไม่มีการแปลงประเภท มันจะเท่ากันเองเท่านั้นและไม่เท่ากับค่าอื่นใด นั่นเป็นเหตุผลที่ (2) `null == 0` เป็น false
 
-## undefined จอมไม่เข้าใครออกใคร
+### undefined ไม่สามารถเปรียบเทียบได้
 
-เจ้า `undefined` นี่มันไม่ชอบเปรียบเทียบกับใครเลยจริงๆ:
+เราไม่ควรนำค่า `undefined` ไปเปรียบเทียบกับค่าอื่นๆ:
 
 ```js run
 alert( undefined > 0 ); // false (1)
-alert( undefined < 0 ); // false (2)
+alert( undefined < 0 ); // false (2) 
 alert( undefined == 0 ); // false (3)
 ```
 
-ทำไมมันถึงไม่ชอบเลข 0 ขนาดนั้น? เจออะไรก็ `false`
+ทำไม `undefined` ถึงเกลียดศูนย์ขนาดนั้น จนเป็น false ตลอด!
 
-เหตุผลที่เราได้ผลลัพธ์เหล่านี้ก็คือ:
+เพราะว่า:
 
-- การเปรียบเทียบ `(1)` และ `(2)` ส่งคืน `false` เพราะ `undefined` ถูกแปลงเป็น `NaN` และ `NaN` เป็นค่าตัวเลขพิเศษที่ส่งคืน `false` สำหรับการเปรียบเทียบทั้งหมด
-- การตรวจสอบความเท่าเทียม `(3)` ส่งคืน `false` เพราะ `undefined` เท่ากับ `null`, `undefined` และไม่มีค่าอื่นใด
+- การเปรียบเทียบ `(1)` และ `(2)` ให้ค่า `false` เพราะ `undefined` ถูกแปลงเป็น `NaN` ซึ่ง `NaN` เป็นค่าตัวเลขพิเศษที่ให้ผลเป็น `false` เสมอเมื่อเปรียบเทียบ
+- การตรวจสอบความเท่ากัน `(3)` ให้ค่า `false` เพราะ `undefined` จะเท่ากับ `null` และ `undefined` เท่านั้น ไม่เท่ากับค่าอื่น
 
-##  ข้อควรระวัง
+### หลีกเลี่ยงปัญหา
 
-เราเรียนรู้เรื่องพวกนี้ไปทำไม? เราต้องจำไว้ทุกอย่างเลยเหรอ? ไม่จำเป็นหรอก! ยิ่งใช้ JavaScript ไปเรื่อยๆ เดี๋ยวก็ชินกับความแปลกๆ เหล่านี้เอง แต่มีวิธีที่แน่นอนในการหลีกเลี่ยงปัญหา:
+ทำไมเราถึงยกตัวอย่างเหล่านี้? เราจำเป็นต้องจำความพิเศษเหล่านี้ตลอดเวลาหรือ? ไม่จำเป็นหรอก จริงๆ แล้วสิ่งที่ดูยุ่งยากเหล่านี้จะค่อยๆ คุ้นเคยไปเองตามเวลา แต่มีวิธีที่ดีกว่าในการหลีกเลี่ยงปัญหาพวกนี้:
 
-- ระมัดระวังเป็นพิเศษเมื่อเปรียบเทียบค่าอะไรก็ตามกับ `undefined/null` ยกเว้นการเปรียบเทียบแบบเข้มงวด `===`
-- อย่าใช้การเปรียบเทียบ `>= > < <=` กับตัวแปรที่อาจเป็น `null/undefined` เว้นแต่คุณจะมั่นใจจริงๆ ว่าคุณกำลังทำอะไรอยู่ ถ้าตัวแปรอาจมีค่าเหล่านี้ ให้ตรวจสอบแยกต่างหาก
+- ระมัดระวังเป็นพิเศษเมื่อเปรียบเทียบกับ `undefined/null` ยกเว้นการตรวจสอบความเท่ากันแบบเข้มงวดด้วย `===`
+- อย่าใช้การเปรียบเทียบ `>= > < <=` กับตัวแปรที่อาจเป็น `null/undefined` เว้นแต่คุณจะมั่นใจว่าตัวเองกำลังทำอะไร ถ้าตัวแปรอาจมีค่าเหล่านี้ได้ ให้ตรวจสอบ `null/undefined` แยกต่างหาก
 
 ## สรุป
 
-- ตัวดำเนินการเปรียบเทียบจะส่งคืนค่าบูลีน
-- สตริงจะถูกเปรียบเทียบทีละตัวอักษรตามลำดับ "พจนานุกรม"
-- เมื่อเปรียบเทียบค่าที่มีประเภทข้อมูลต่างกัน ค่าเหล่านั้นจะถูกแปลงเป็นตัวเลข (ยกเว้นการเปรียบเทียบแบบเข้มงวด)
-- ค่า `null` และ `undefined` เท่ากัน `==` กันเองและไม่เท่ากับค่าอื่นใด
-- ระมัดระวังเมื่อใช้การเปรียบเทียบ เช่น `>` หรือ `<` กับตัวแปรที่อาจเป็น `null/undefined` เป็นครั้งคราว การตรวจสอบ `null/undefined` แยกต่างหากเป็นแนวคิดที่ดี
+- ตัวดำเนินการเปรียบเทียบให้ค่าเป็น boolean
+- การเปรียบเทียบ string จะเปรียบเทียบทีละตัวอักษรตามลำดับ "พจนานุกรม"
+- เมื่อเปรียบเทียบค่าต่างประเภทกัน ค่าจะถูกแปลงเป็นตัวเลข (ยกเว้นการตรวจสอบความเท่ากันอย่างเข้มงวด) 
+- ค่า `null` และ `undefined` เท่ากันเฉพาะเมื่อใช้ `==` และไม่เท่ากับค่าอื่นใดทั้งสิ้น
+- ระมัดระวังเมื่อใช้การเปรียบเทียบ เช่น `>` หรือ `<` กับตัวแปรที่อาจเป็น `null/undefined` ได้ บางครั้งการตรวจสอบ `null/undefined` แยกต่างหากถือเป็นแนวทางที่ดี
\ No newline at end of file