diff --git a/1-js/01-getting-started/1-intro/article.md b/1-js/01-getting-started/1-intro/article.md
index 2f4f518f3..13e8486ff 100644
--- a/1-js/01-getting-started/1-intro/article.md
+++ b/1-js/01-getting-started/1-intro/article.md
@@ -1,72 +1,99 @@
-# An Introduction to JavaScript
+# บทนำสู่ JavaScript
 
-Let's see what's so special about JavaScript, what we can achieve with it, and what other technologies play well with it.
+มาดูกันว่า JavaScript มีลักษณะพิเศษอะไรบ้าง เราสามารถทำอะไรได้ด้วยภาษานี้ และมันเข้ากันได้ดีกับเทคโนโลยีใดบ้าง
 
-## What is JavaScript?
+## JavaScript คืออะไร?
 
-*JavaScript* was initially created to "make web pages alive".
+*JavaScript* ถูกสร้างขึ้นเพื่อ "ทำให้เว็บเพจมีชีวิตชีวา"
 
-The programs in this language are called *scripts*. They can be written right in a web page's HTML and run automatically as the page loads.
+โปรแกรมที่เขียนด้วยภาษานี้เรียกว่า *สคริปต์* ซึ่งสามารถแทรกลงในโค้ด HTML ของเว็บเพจได้โดยตรง และทำงานโดยอัตโนมัติเมื่อเพจนั้นโหลดขึ้นมา
 
-Scripts are provided and executed as plain text. They don't need special preparation or compilation to run.
+สคริปต์จะถูกเตรียมและประมวลผลในรูปแบบข้อความธรรมดา ไม่จำเป็นต้องมีขั้นตอนการเตรียมหรือคอมไพล์พิเศษใดๆ ก่อนการทำงาน 
 
-In this aspect, JavaScript is very different from another language called [Java](https://en.wikipedia.org/wiki/Java_(programming_language)).
+ในแง่นี้ JavaScript แตกต่างจากภาษา [Java](https://en.wikipedia.org/wiki/Java_(programming_language)) อย่างชัดเจน
 
-```smart header="Why is it called <u>Java</u>Script?"
-When JavaScript was created, it initially had another name: "LiveScript". But Java was very popular at that time, so it was decided that positioning a new language as a "younger brother" of Java would help.
+```smart header="ทำไมถึงมีชื่อว่า <u>Java</u>Script?"
+เมื่อ JavaScript ถูกสร้างขึ้นในยุคแรก มันมีชื่อว่า "LiveScript" แต่เนื่องจากในขณะนั้น Java กำลังได้รับความนิยมอย่างสูง จึงมีการตัดสินใจว่าการนำเสนอภาษาใหม่นี้ในฐานะ "น้องชาย" ของ Java จะช่วยให้เป็นที่สนใจมากขึ้น
 
-But as it evolved, JavaScript became a fully independent language with its own specification called [ECMAScript](http://en.wikipedia.org/wiki/ECMAScript), and now it has no relation to Java at all.
+แต่เมื่อมันค่อยๆ พัฒนาไป ในที่สุด JavaScript ก็กลายเป็นภาษาที่มีเอกลักษณ์เฉพาะตัวอย่างสมบูรณ์ มีมาตรฐานของตัวเองที่เรียกว่า [ECMAScript](http://en.wikipedia.org/wiki/ECMAScript) และปัจจุบันไม่มีความเกี่ยวข้องใดๆ กับ Java อีกต่อไป
 ```
 
-Today, JavaScript can execute not only in the browser, but also on the server, or actually on any device that has a special program called [the JavaScript engine](https://en.wikipedia.org/wiki/JavaScript_engine).
+ในยุคปัจจุบัน JavaScript สามารถทำงานได้ไม่เพียงแค่ในเบราว์เซอร์ แต่ยังรันได้บนเซิร์ฟเวอร์หรืออุปกรณ์ใดๆ ที่มีโปรแกรมพิเศษที่เรียกว่า [the JavaScript engine](https://en.wikipedia.org/wiki/JavaScript_engine)
 
-The browser has an embedded engine sometimes called a "JavaScript virtual machine".
+เบราว์เซอร์แต่ละตัวมี engine ของตัวเองฝังอยู่ในตัว บางครั้งเรียกว่า "JavaScript virtual machine"
 
-Different engines have different "codenames". For example:
+Engine แต่ละตัวมีชื่อเรียก (codename) ที่แตกต่างกัน เช่น:
 
-- [V8](https://en.wikipedia.org/wiki/V8_(JavaScript_engine)) -- in Chrome, Opera and Edge.
-- [SpiderMonkey](https://en.wikipedia.org/wiki/SpiderMonkey) -- in Firefox.
-- ...There are other codenames like "Chakra" for IE, "JavaScriptCore", "Nitro" and "SquirrelFish" for Safari, etc.
+- [V8](https://en.wikipedia.org/wiki/V8_(JavaScript_engine)) -- ใน Chrome, Opera และ Edge
+- [SpiderMonkey](https://en.wikipedia.org/wiki/SpiderMonkey) -- ใน Firefox
+- ...มีชื่อเรียกอื่นๆ อีก เช่น "Chakra" ใน IE, "JavaScriptCore", "Nitro" และ "SquirrelFish" ใน Safari เป็นต้น
 
-The terms above are good to remember because they are used in developer articles on the internet. We'll use them too. For instance, if "a feature X is supported by V8", then it probably works in Chrome, Opera and Edge.
+จำคำศัพท์เหล่านี้ไว้จะเป็นประโยชน์ เพราะมักจะถูกกล่าวถึงในบทความสำหรับนักพัฒนาบ่อยๆ เราก็จะใช้มันเช่นกัน ตัวอย่างเช่น ถ้ามีการพูดว่า "ฟีเจอร์ X รองรับโดย V8" ซึ่งหมายความว่ามันน่าจะทำงานได้ใน Chrome, Opera และ Edge
 
-```smart header="How do engines work?"
+```smart header="engine ทำงานอย่างไร?"
 
-Engines are complicated. But the basics are easy.
+Engine มีกระบวนการทำงานที่ค่อนข้างซับซ้อน แต่พื้นฐานแล้วไม่ยาก
 
+<<<<<<< HEAD
+1. Engine (ที่ฝังมากับเบราว์เซอร์) อ่าน ("parse") สคริปต์
+2. แล้วแปลง ("compile") สคริปต์ให้เป็นภาษาเครื่อง
+3. จากนั้นก็รันโค้ดภาษาเครื่องได้อย่างรวดเร็ว
+=======
 1. The engine (embedded if it's a browser) reads ("parses") the script.
 2. Then it converts ("compiles") the script to machine code.
 3. And then the machine code runs, pretty fast.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-The engine applies optimizations at each step of the process. It even watches the compiled script as it runs, analyzes the data that flows through it, and further optimizes the machine code based on that knowledge.
+Engine จะใช้เทคนิคการปรับแต่งในทุกขั้นตอน มันจะติดตามข้อมูลของสคริปต์ที่ผ่านการคอมไพล์แล้ว วิเคราะห์การไหลของข้อมูล และใช้ข้อมูลที่ได้จากการวิเคราะห์นั้นมาปรับแต่งรหัสภาษาเครื่องให้ดีขึ้นไปอีก 
 ```
 
-## What can in-browser JavaScript do?
+## JavaScript ในเบราว์เซอร์ทำอะไรได้บ้าง?
 
+<<<<<<< HEAD
+JavaScript สมัยใหม่เป็นภาษาโปรแกรมที่ "ปลอดภัย" มันไม่สามารถเข้าถึงระดับล่างของหน่วยความจำหรือซีพียูได้โดยตรง เพราะถูกออกแบบมาเพื่อใช้งานในเบราว์เซอร์ที่ไม่จำเป็นต้องใช้ฟีเจอร์เหล่านั้น
+=======
 Modern JavaScript is a "safe" programming language. It does not provide low-level access to memory or the CPU, because it was initially created for browsers which do not require it.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-JavaScript's capabilities greatly depend on the environment it's running in. For instance, [Node.js](https://wikipedia.org/wiki/Node.js) supports functions that allow JavaScript to read/write arbitrary files, perform network requests, etc.
+ความสามารถของ JavaScript นั้นขึ้นอยู่กับสภาพแวดล้อมที่มันทำงานอยู่เป็นอย่างมาก เช่น [Node.js](https://wikipedia.org/wiki/Node.js) ช่วยเสริมความสามารถให้ JavaScript สามารถอ่านหรือเขียนแฟ้มใดๆ ก็ได้ ส่งคำขอผ่านเน็ตเวิร์ค เป็นต้น
 
-In-browser JavaScript can do everything related to webpage manipulation, interaction with the user, and the webserver.
+ส่วน JavaScript ในเบราว์เซอร์นั้น สามารถทำอะไรก็ตามที่เกี่ยวข้องกับการจัดการเว็บเพจ การโต้ตอบกับผู้ใช้ และเว็บเซิร์ฟเวอร์
 
-For instance, in-browser JavaScript is able to:
+ตัวอย่างเช่น JavaScript ในเบราว์เซอร์สามารถ:
 
-- Add new HTML to the page, change the existing content, modify styles.
-- React to user actions, run on mouse clicks, pointer movements, key presses.
-- Send requests over the network to remote servers, download and upload files (so-called [AJAX](https://en.wikipedia.org/wiki/Ajax_(programming)) and [COMET](https://en.wikipedia.org/wiki/Comet_(programming)) technologies).
-- Get and set cookies, ask questions to the visitor, show messages.
-- Remember the data on the client-side ("local storage").
+- เพิ่ม HTML ใหม่ลงในหน้าเว็บ เปลี่ยนแปลงเนื้อหาที่มีอยู่ แก้ไขรูปแบบ (style) ของหน้าเว็บ
+- ตอบสนองต่อการกระทำของผู้ใช้ เช่นการคลิกเมาส์ การเลื่อนเคอร์เซอร์ และการกดปุ่ม
+- ส่งคำขอไปยังเซิร์ฟเวอร์ผ่านเครือข่าย ดาวน์โหลดและอัปโหลดไฟล์ (เรียกกันว่า [AJAX](https://en.wikipedia.org/wiki/Ajax_(programming)) และ [COMET](https://en.wikipedia.org/wiki/Comet_(programming)))
+- รับและตั้งค่าคุกกี้ ถามคำถามผู้ใช้ แสดงข้อความ
+- จำข้อมูลฝั่งไคลเอนต์ ("local storage")
 
-## What CAN'T in-browser JavaScript do?
+## JavaScript ในเบราว์เซอร์ทำอะไรไม่ได้บ้าง? 
 
+<<<<<<< HEAD
+ความสามารถของ JavaScript ในเบราว์เซอร์มีข้อจำกัดเพื่อความปลอดภัยของผู้ใช้ มีจุดประสงค์เพื่อป้องกันหน้าเว็บที่ไม่น่าไว้วางใจจากการเข้าถึงข้อมูลส่วนตัว หรือทำให้ข้อมูลของผู้ใช้เสียหาย
+=======
 JavaScript's abilities in the browser are limited to protect the user's safety. The aim is to prevent an evil webpage from accessing private information or harming the user's data.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-Examples of such restrictions include:
+ตัวอย่างของข้อจำกัดเหล่านั้น ได้แก่:
 
-- JavaScript on a webpage may not read/write arbitrary files on the hard disk, copy them or execute programs. It has no direct access to OS functions.
+- JavaScript ในหน้าเว็บไม่สามารถอ่าน/เขียน/คัดลอกไฟล์ในฮาร์ดดิสก์ หรือเรียกใช้โปรแกรมอื่นๆ ได้โดยตรง มันไม่มีสิทธิ์เข้าถึงฟังก์ชันระบบของระบบปฏิบัติการเองโดยตรง
 
-    Modern browsers allow it to work with files, but the access is limited and only provided if the user does certain actions, like "dropping" a file into a browser window or selecting it via an `<input>` tag.
+    เบราว์เซอร์รุ่นใหม่ๆ อนุญาตให้มันทำงานกับไฟล์ได้บ้าง แต่การเข้าถึงนั้นจะถูกจำกัดมากและต้องได้รับการยินยอมจากผู้ใช้ เช่นการ "ลาก" ไฟล์ลงในหน้าเว็บ หรือเลือกผ่านแท็ก `<input>`
 
+<<<<<<< HEAD
+    มีวิธีโต้ตอบกับกล้อง ไมโครโฟน และอุปกรณ์อื่นๆ ได้ แต่ต้องได้รับอนุญาตอย่างชัดเจนจากผู้ใช้เสมอ เพราะฉะนั้นหน้าเว็บที่ใช้ JavaScript จะไม่สามารถเปิดเว็บแคมแอบดูโดยไม่ให้ผู้ใช้สังเกตเห็นและส่งข้อมูลไปยัง [NSA](https://en.wikipedia.org/wiki/National_Security_Agency) ได้ 
+- แท็บ/วินโดว์ที่แตกต่างกันโดยปกติแล้วไม่รู้จักกัน แม้ในบางครั้งที่อาจทำได้ เช่นเมื่อหน้าต่างหนึ่งใช้ JavaScript เปิดหน้าต่างอื่นขึ้นมา แต่แม้ในกรณีนี้ JavaScript จากหน้าหนึ่งก็ไม่สามารถเข้าถึงหน้าอื่นได้หาก URL ของหน้านั้นมาจากโดเมน โปรโตคอล หรือพอร์ตที่ต่างกัน เรียกว่า "Same Origin Policy"
+
+    สิ่งนี้จำเป็นต้องทำเพื่อให้มีการยินยอมและทำความเข้าใจ *ระหว่างหน้าเว็บทั้งสองฝ่าย* ในการแลกเปลี่ยนข้อมูล และต้องใช้โค้ด JavaScript พิเศษเพื่อจัดการเรื่องนี้ เราจะกล่าวถึงเรื่องนี้ในบทเรียนข้างหน้า
+
+    ข้อจำกัดนี้ก็เพื่อความปลอดภัยของผู้ใช้ด้วยเช่นกัน ไม่ควรให้หน้า `http://anysite.com` ที่เปิดอยู่ในแท็บหนึ่ง สามารถเข้าถึง URL `http://gmail.com` ในอีกแท็บของเบราว์เซอร์ ซึ่งอาจจะขโมยข้อมูลจากที่นั่นไปได้
+- JavaScript ติดต่อสื่อสารกับเซิร์ฟเวอร์ที่หน้านั้นมาจากได้โดยง่าย แต่ความสามารถในการรับข้อมูลจากโดเมนหรือไซต์อื่นๆ นั้นถูกจำกัด เป็นไปได้แต่ต้องมีข้อตกลงชัดเจนจากเซิร์ฟเวอร์ปลายทาง (แสดงด้วย HTTP header) เป็นข้อจำกัดทางความปลอดภัยอีกเช่นกัน
+
+![](limitations.svg)
+
+ข้อจำกัดเหล่านี้ไม่มีการบังคับใช้เลยหาก JavaScript ทำงานนอกเบราว์เซอร์ เช่นบนเซิร์ฟเวอร์ สำหรับเบราว์เซอร์สมัยใหม่ก็อนุญาตให้ปลั๊กอิน/ส่วนขยายขอสิทธิ์เพิ่มเติมได้
+=======
     There are ways to interact with the camera/microphone and other devices, but they require a user's explicit permission. So a JavaScript-enabled page may not sneakily enable a web-camera, observe the surroundings and send the information to the [NSA](https://en.wikipedia.org/wiki/National_Security_Agency).
 - Different tabs/windows generally do not know about each other. Sometimes they do, for example when one window uses JavaScript to open the other one. But even in this case, JavaScript from one page may not access the other page if they come from different sites (from a different domain, protocol or port).
 
@@ -78,34 +105,52 @@ Examples of such restrictions include:
 ![](limitations.svg)
 
 Such limitations do not exist if JavaScript is used outside of the browser, for example on a server. Modern browsers also allow plugins/extensions which may ask for extended permissions.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-## What makes JavaScript unique?
+## อะไรที่ทำให้ JavaScript โดดเด่นเป็นเอกลักษณ์?
 
-There are at least *three* great things about JavaScript:
+JavaScript มีอย่างน้อย *3 คุณสมบัติ* ที่โดดเด่น:
 
 ```compare
-+ Full integration with HTML/CSS.
-+ Simple things are done simply.
-+ Supported by all major browsers and enabled by default.
++ ผสานเข้ากับ HTML/CSS ได้อย่างลงตัว
++ ทำสิ่งง่ายๆ ได้อย่างง่ายดาย  
++ รองรับโดยเบราว์เซอร์หลักทั้งหมด และเปิดใช้งานเป็นค่าเริ่มต้น
 ```
-JavaScript is the only browser technology that combines these three things.
 
-That's what makes JavaScript unique. That's why it's the most widespread tool for creating browser interfaces.
+JavaScript เป็นเทคโนโลยีเบราว์เซอร์เพียงอย่างเดียวที่รวมทั้ง 3 คุณสมบัตินี้เข้าด้วยกัน
 
+<<<<<<< HEAD
+ด้วยคุณสมบัติเฉพาะตัวเหล่านี้ ทำให้ JavaScript กลายเป็นเครื่องมือที่ได้รับความนิยมอย่างกว้างขวางในการสร้างส่วนติดต่อผู้ใช้บนเบราว์เซอร์
+=======
 That said, JavaScript can be used to create servers, mobile applications, etc.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-## Languages "over" JavaScript
+อย่างไรก็ตาม ปัจจุบัน JavaScript ยังสามารถใช้สร้างเซิร์ฟเวอร์ แอปพลิเคชันมือถือ และอื่นๆ ได้อีกด้วย
 
-The syntax of JavaScript does not suit everyone's needs. Different people want different features.
+## ภาษาที่ถูก "transpile" เป็น JavaScript
 
-That's to be expected, because projects and requirements are different for everyone.
+ไวยากรณ์ของ JavaScript อาจไม่ตอบโจทย์ความต้องการของทุกคน แต่ละคนต้องการฟีเจอร์ที่แตกต่างกันไป
 
+<<<<<<< HEAD
+ซึ่งเป็นเรื่องที่เข้าใจได้ เพราะแต่ละโปรเจกต์และความต้องการของแต่ละคนมีความแตกต่างกัน
+=======
 So, recently a plethora of new languages appeared, which are *transpiled* (converted) to JavaScript before they run in the browser.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
+
+ดังนั้น จึงมีภาษาโปรแกรมใหม่ๆ เกิดขึ้นมากมายในช่วงไม่นานมานี้ โดยภาษาเหล่านี้จะถูก *transpile* (แปลง) เป็น JavaScript ก่อนที่จะทำงานในเบราว์เซอร์
 
-Modern tools make the transpilation very fast and transparent, actually allowing developers to code in another language and auto-converting it "under the hood".
+เครื่องมือสมัยใหม่ทำให้ขั้นตอนการ transpile เป็นไปได้อย่างรวดเร็วและโปร่งใส ทำให้นักพัฒนาสามารถเขียนโค้ดด้วยภาษาอื่น แล้วแปลงเป็น JavaScript โดยอัตโนมัติเบื้องหลังได้
 
-Examples of such languages:
+<<<<<<< HEAD
+ตัวอย่างของภาษาเหล่านั้น ได้แก่:
 
+- [CoffeeScript](https://coffeescript.org/) เป็น "syntactic sugar" สำหรับ JavaScript โดยนำเสนอไวยากรณ์ที่กระชับกว่า ช่วยให้เราเขียนโค้ดได้ชัดเจนและถูกต้องมากขึ้น เป็นที่นิยมในหมู่นักพัฒนา Ruby
+- [TypeScript](https://www.typescriptlang.org/) เน้นการเพิ่ม "strict data typing" เพื่อให้การพัฒนาและดูแลระบบที่ซับซ้อนง่ายขึ้น พัฒนาโดย Microsoft 
+- [Flow](https://flow.org/) ก็เพิ่ม data typing เช่นกัน แต่ในรูปแบบที่แตกต่างออกไป พัฒนาโดย Facebook
+- [Dart](https://www.dartlang.org/) เป็นภาษาแยกต่างหากที่มี engine เป็นของตัวเอง สามารถทำงานในสภาพแวดล้อมที่ไม่ใช่เบราว์เซอร์ได้ (เช่น แอปมือถือ) และยังสามารถ transpile เป็น JavaScript ได้ พัฒนาโดย Google
+- [Brython](https://brython.info/) เป็น transpiler ที่แปลง Python เป็น JavaScript ทำให้สามารถเขียนแอปด้วย Python บริสุทธิ์ได้โดยไม่ต้องใช้ JavaScript  
+- [Kotlin](https://kotlinlang.org/docs/reference/js-overview.html) เป็นภาษาโปรแกรมสมัยใหม่ที่กระชับและปลอดภัย สามารถกำหนดเป้าหมายไปที่เบราว์เซอร์หรือ Node ได้
+=======
 - [CoffeeScript](https://coffeescript.org/) is "syntactic sugar" for JavaScript. It introduces shorter syntax, allowing us to write clearer and more precise code. Usually, Ruby devs like it.
 - [TypeScript](https://www.typescriptlang.org/) is concentrated on adding "strict data typing" to simplify the development and support of complex systems. It is developed by Microsoft.
 - [Flow](https://flow.org/) also adds data typing, but in a different way. Developed by Facebook.
@@ -114,9 +159,12 @@ Examples of such languages:
 - [Kotlin](https://kotlinlang.org/docs/reference/js-overview.html) is a modern, concise and safe programming language that can target the browser or Node.
 
 There are more. Of course, even if we use one of these transpiled languages, we should also know JavaScript to really understand what we're doing.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
+
+มีภาษาอื่นๆ อีกมากมาย แม้จะใช้ภาษาเหล่านี้ก็จริง แต่การศึกษา JavaScript เองก็ยังมีความจำเป็น เพื่อให้เข้าใจอย่างถ่องแท้ว่ากำลังทำอะไรอยู่
 
-## Summary
+## สรุป
 
-- JavaScript was initially created as a browser-only language, but it is now used in many other environments as well.
-- Today, JavaScript has a unique position as the most widely-adopted browser language, fully integrated with HTML/CSS.
-- There are many languages that get "transpiled" to JavaScript and provide certain features. It is recommended to take a look at them, at least briefly, after mastering JavaScript.
+- JavaScript ถูกสร้างขึ้นมาเพื่อใช้เป็นภาษาสำหรับเบราว์เซอร์โดยเฉพาะ แต่ปัจจุบันก็ถูกนำไปใช้ในสภาพแวดล้อมอื่นๆ มากมาย
+- ในปัจจุบัน JavaScript มีบทบาทสำคัญในฐานะภาษาเบราว์เซอร์ที่ได้รับการยอมรับอย่างกว้างขวางที่สุด โดยสามารถทำงานร่วมกับ HTML/CSS ได้อย่างลงตัว  
+- มีภาษาอีกหลายภาษาที่ถูก "transpile" เป็น JavaScript และมีฟีเจอร์เสริมบางอย่าง แนะนำให้ลองศึกษาคร่าวๆ หลังจากที่เชี่ยวชาญ JavaScript แล้ว
diff --git a/1-js/01-getting-started/2-manuals-specifications/article.md b/1-js/01-getting-started/2-manuals-specifications/article.md
index 3fa243336..cb114726c 100644
--- a/1-js/01-getting-started/2-manuals-specifications/article.md
+++ b/1-js/01-getting-started/2-manuals-specifications/article.md
@@ -1,37 +1,58 @@
+# คู่มือและข้อกำหนด
 
-# Manuals and specifications
+หนังสือเล่มนี้เป็น *บทเรียน* ที่มุ่งหวังให้คุณค่อยๆ เรียนรู้ภาษา JavaScript อย่างเป็นขั้นเป็นตอน แต่เมื่อคุณคุ้นเคยกับพื้นฐานแล้ว คุณอาจต้องการแหล่งข้อมูลอ้างอิงเพิ่มเติม ดังนี้
 
+<<<<<<< HEAD
+## ข้อกำหนด
+=======
 This book is a *tutorial*. It aims to help you gradually learn the language. But once you're familiar with the basics, you'll need other resources.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-## Specification
+[ข้อกำหนด ECMA-262](https://www.ecma-international.org/publications/standards/Ecma-262.htm) เป็นเอกสารที่มีรายละเอียดเชิงลึก ครบถ้วน และเป็นทางการที่สุดเกี่ยวกับ JavaScript เป็นตัวกำหนดมาตรฐานของภาษานี้
 
-[The ECMA-262 specification](https://www.ecma-international.org/publications/standards/Ecma-262.htm) contains the most in-depth, detailed and formalized information about JavaScript. It defines the language.
+แต่เนื่องจากมีลักษณะเป็นทางการมาก จึงอาจทำความเข้าใจได้ยากในช่วงแรก ดังนั้น หากคุณต้องการแหล่งอ้างอิงที่ถูกต้องที่สุดเกี่ยวกับรายละเอียดต่างๆ ของภาษา ข้อกำหนดนี้คือสิ่งที่คุณควรใช้ แต่อาจไม่เหมาะสำหรับการอ้างอิงในชีวิตประจำวัน
 
-But being that formalized, it's difficult to understand at first. So if you need the most trustworthy source of information about the language details, the specification is the right place. But it's not for everyday use.
+ข้อกำหนดเวอร์ชันใหม่จะถูกปล่อยออกมาเป็นประจำทุกปี ในระหว่างช่วงที่ยังไม่มีการปล่อยเวอร์ชันใหม่ สามารถดูร่างข้อกำหนดล่าสุดได้ที่ <https://tc39.es/ecma262/>
 
+<<<<<<< HEAD
+หากคุณต้องการอ่านเกี่ยวกับคุณสมบัติใหม่ล่าสุด รวมถึงคุณสมบัติที่ "ใกล้จะเป็นมาตรฐาน" (หรือที่เรียกว่า "stage 3") สามารถดูได้ที่ <https://github.com/tc39/proposals>
+=======
 A new specification version is released every year. Between these releases, the latest specification draft is at <https://tc39.es/ecma262/>.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-To read about new bleeding-edge features, including those that are "almost standard" (so-called "stage 3"), see proposals at <https://github.com/tc39/proposals>.
+นอกจากนี้ ถ้าคุณกำลังพัฒนาเว็บสำหรับเบราว์เซอร์ จะมีข้อกำหนดเพิ่มเติมอื่นๆ ที่กล่าวถึงใน[ส่วนที่สอง](info:browser-environment) ของบทเรียนนี้
 
-Also, if you're developing for the browser, then there are other specifications covered in the [second part](info:browser-environment) of the tutorial.
+## คู่มืออ้างอิง
 
-## Manuals
+- **MDN (Mozilla) JavaScript Reference** เป็นคู่มือหลักที่มีตัวอย่างและข้อมูลเชิงลึกอื่นๆ เป็นแหล่งข้อมูลที่ยอดเยี่ยมสำหรับการค้นหารายละเอียดเกี่ยวกับฟังก์ชัน เมท็อด และอื่นๆ ในภาษานี้ 
 
-- **MDN (Mozilla) JavaScript Reference** is the main manual with examples and other information. It's great to get in-depth information about individual language functions, methods etc.
+  สามารถเข้าถึงได้ที่ <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference>
 
+<<<<<<< HEAD
+  อย่างไรก็ตาม บ่อยครั้งแล้วการค้นหาโดยใช้ Google จะสะดวกกว่า เพียงพิมพ์ "MDN [คำที่ต้องการค้นหา]" เช่น ค้นหา <https://google.com/search?q=MDN+parseInt> เพื่อหาข้อมูลเกี่ยวกับฟังก์ชัน `parseInt`
+
+## ตารางความเข้ากันได้
+=======
     You can find it at <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference>.
 
 Although, it's often best to use an internet search instead. Just use "MDN [term]" in the query, e.g. <https://google.com/search?q=MDN+parseInt> to search for the `parseInt` function.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
+
+JavaScript เป็นภาษาที่มีการพัฒนาอย่างต่อเนื่อง มีการเพิ่มคุณสมบัติใหม่ๆ เป็นประจำ
 
-## Compatibility tables
+เพื่อตรวจสอบว่าคุณสมบัติต่างๆ นั้นรองรับโดยเบราว์เซอร์และเอ็นจิ้นอื่นๆ มากน้อยเพียงใด สามารถดูได้จาก:
 
-JavaScript is a developing language, new features get added regularly.
+- <https://caniuse.com> - แสดงตารางการรองรับคุณสมบัติแยกตามหมวดหมู่ เช่น หากต้องการดูว่าเอ็นจิ้นใดบ้างที่รองรับฟังก์ชันการเข้ารหัสลับสมัยใหม่ สามารถค้นหาได้ที่ <https://caniuse.com/#feat=cryptography>
 
-To see their support among browser-based and other engines, see:
+<<<<<<< HEAD
+- <https://kangax.github.io/compat-table> - ตารางแสดงคุณสมบัติต่างๆ ของภาษา และระบุว่าเอ็นจิ้นใดรองรับหรือไม่รองรับบ้าง
 
+แหล่งข้อมูลเหล่านี้มีประโยชน์อย่างมากในการพัฒนาจริง เนื่องจากมีข้อมูลที่สำคัญเกี่ยวกับรายละเอียดของภาษา ความเข้ากันได้ และอื่นๆ
+=======
 - <https://caniuse.com> - per-feature tables of support, e.g. to see which engines support modern cryptography functions: <https://caniuse.com/#feat=cryptography>.
 - <https://kangax.github.io/compat-table> - a table with language features and engines that support those or don't support.
 
 All these resources are useful in real-life development, as they contain valuable information about language details, their support, etc.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-Please remember them (or this page) for the cases when you need in-depth information about a particular feature.
+โปรดจดจำแหล่งอ้างอิงเหล่านี้ (หรือบุ๊กมาร์กหน้านี้ไว้) เพื่อใช้ในยามที่คุณต้องการข้อมูลเชิงลึกเกี่ยวกับคุณสมบัติเฉพาะใดๆ ของภาษา
diff --git a/1-js/01-getting-started/3-code-editors/article.md b/1-js/01-getting-started/3-code-editors/article.md
index ca6194741..7b8338e40 100644
--- a/1-js/01-getting-started/3-code-editors/article.md
+++ b/1-js/01-getting-started/3-code-editors/article.md
@@ -1,49 +1,71 @@
-# Code editors
+# ตัวแก้ไขโค้ด 
 
-A code editor is the place where programmers spend most of their time.
+ตัวแก้ไขโค้ด (code editor) คือเครื่องมือที่โปรแกรมเมอร์ใช้เวลาส่วนใหญ่ในการทำงานด้วย 
 
-There are two main types of code editors: IDEs and lightweight editors. Many people use one tool of each type.
+ตัวแก้ไขโค้ดมีสองประเภทหลักๆ คือ IDE และตัวแก้ไขแบบเบา (lightweight editor) ซึ่งนักพัฒนาหลายคนมักจะใช้ทั้งสองแบบควบคู่กันไป
 
 ## IDE
 
-The term [IDE](https://en.wikipedia.org/wiki/Integrated_development_environment) (Integrated Development Environment) refers to a powerful editor with many features that usually operates on a "whole project." As the name suggests, it's not just an editor, but a full-scale "development environment."
+[IDE](https://en.wikipedia.org/wiki/Integrated_development_environment) ย่อมาจาก Integrated Development Environment หมายถึงตัวแก้ไขโค้ดที่มีความสามารถสูง พร้อมฟีเจอร์ต่างๆ มากมาย โดยมักจะทำงานในระดับ "โปรเจ็กต์ทั้งหมด" ตามชื่อที่บ่งบอก มันไม่ใช่แค่ตัวแก้ไขธรรมดา แต่เป็น "สภาพแวดล้อมการพัฒนา" อย่างครบวงจร
 
-An IDE loads the project (which can be many files), allows navigation between files, provides autocompletion based on the whole project (not just the open file), and integrates with a version management system (like [git](https://git-scm.com/)), a testing environment, and other "project-level" stuff.
+IDE จะโหลดโครงการ (ซึ่งอาจประกอบด้วยหลายไฟล์) เข้ามา ช่วยให้เราสามารถสลับไปมาระหว่างไฟล์ต่างๆ ได้ มีระบบเติมโค้ดอัตโนมัติตามบริบทของโปรเจ็กต์ทั้งหมด (ไม่ใช่เฉพาะไฟล์ที่กำลังเปิดอยู่) และเชื่อมต่อกับระบบจัดการเวอร์ชัน เช่น [git](https://git-scm.com/) รวมถึงมีการผนวกรวมกับสภาพแวดล้อมการทดสอบ และอื่นๆ ในระดับของโครงการด้วย
 
-If you haven't selected an IDE yet, consider the following options:
+หากคุณยังไม่เคยเลือกใช้ IDE มาก่อน ลองพิจารณาตัวเลือกเหล่านี้ดู:
 
+<<<<<<< HEAD
+- [Visual Studio Code](https://code.visualstudio.com/) (รองรับหลายแพลตฟอร์ม, ฟรี) 
+- [WebStorm](https://www.jetbrains.com/webstorm/) (รองรับหลายแพลตฟอร์ม, มีค่าใช้จ่าย)
+=======
 - [Visual Studio Code](https://code.visualstudio.com/) (cross-platform, free).
 - [WebStorm](https://www.jetbrains.com/webstorm/) (cross-platform, paid).
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-For Windows, there's also "Visual Studio", not to be confused with "Visual Studio Code". "Visual Studio" is a paid and mighty Windows-only editor, well-suited for the .NET platform. It's also good at JavaScript. There's also a free version [Visual Studio Community](https://www.visualstudio.com/vs/community/).
+สำหรับ Windows ยังมี "Visual Studio" ด้วย อย่าสับสนกับ "Visual Studio Code" นะ "Visual Studio" เป็น IDE ที่ทรงพลังและเสียค่าใช้จ่าย มีเฉพาะบน Windows เท่านั้น เหมาะสำหรับการพัฒนาบนแพลตฟอร์ม .NET และสามารถใช้งานกับ JavaScript ได้เป็นอย่างดีเช่นกัน โดยมีเวอร์ชันฟรีชื่อ [Visual Studio Community](https://www.visualstudio.com/vs/community/)
 
-Many IDEs are paid, but have a trial period. Their cost is usually negligible compared to a qualified developer's salary, so just choose the best one for you.
+IDE หลายตัวมีค่าใช้จ่าย แต่ก็มีระยะทดลองใช้ฟรี ซึ่งเมื่อเทียบกับเงินเดือนของนักพัฒนาที่ดีแล้ว ค่าใช้จ่ายเหล่านั้นถือว่าน้อยมาก ดังนั้นควรเลือกตัวที่เหมาะสมกับตัวเองที่สุด
 
-## Lightweight editors
+## ตัวแก้ไขแบบเบา
 
-"Lightweight editors" are not as powerful as IDEs, but they're fast, elegant and simple.
+ตัวแก้ไขแบบเบา (lightweight editor) อาจจะไม่ทรงพลังเท่า IDE แต่มันมีความเร็ว เบา และเรียบง่าย
 
-They are mainly used to open and edit a file instantly.
+ส่วนใหญ่แล้วจะใช้เพื่อเปิดและแก้ไขไฟล์ได้อย่างรวดเร็ว
 
-The main difference between a "lightweight editor" and an "IDE" is that an IDE works on a project-level, so it loads much more data on start, analyzes the project structure if needed and so on. A lightweight editor is much faster if we need only one file.
+ความแตกต่างหลักระหว่าง "ตัวแก้ไขแบบเบา" กับ "IDE" ก็คือ IDE จะทำงานในระดับโปรเจ็กต์ ดังนั้นตอนเริ่มต้นโหลดมันจะใช้เวลามากกว่า ต้องวิเคราะห์โครงสร้างโปรเจ็กต์หากจำเป็น และอื่นๆ อีกมาก ส่วนตัวแก้ไขแบบเบานั้นจะเปิดไฟล์ได้เร็วกว่ามาก
 
-In practice, lightweight editors may have a lot of plugins including directory-level syntax analyzers and autocompleters, so there's no strict border between a lightweight editor and an IDE.
+ในทางปฏิบัติ ตัวแก้ไขแบบเบาก็อาจมีปลั๊กอินต่างๆ เพิ่มเข้ามาได้มากมาย รวมถึงมีตัวช่วยวิเคราะห์ไวยากรณ์และระบบเติมโค้ดอัตโนมัติในระดับไดเรกทอรี ทำให้แยกความแตกต่างระหว่างตัวแก้ไขแบบเบากับ IDE ได้ไม่ชัดเจนนัก
 
+<<<<<<< HEAD
+มีตัวเลือกมากมาย เช่น:
+
+- [Sublime Text](https://www.sublimetext.com/) (รองรับหลายแพลตฟอร์ม, shareware)
+- [Notepad++](https://notepad-plus-plus.org/) (Windows, ฟรี)
+- [Vim](https://www.vim.org/) และ [Emacs](https://www.gnu.org/software/emacs/) ก็เจ๋งมากหากคุณรู้วิธีใช้
+=======
 There are many options, for instance:
 
 - [Sublime Text](https://www.sublimetext.com/) (cross-platform, shareware).
 - [Notepad++](https://notepad-plus-plus.org/) (Windows, free).
 - [Vim](https://www.vim.org/) and [Emacs](https://www.gnu.org/software/emacs/) are also cool if you know how to use them.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
+
+## อย่าถกเถียงกันเลย
+
+ตัวแก้ไขโค้ดที่ยกตัวอย่างมาข้างต้น เป็นที่นิยมใช้กันมานานแล้วในหมู่ผู้เขียนและเพื่อนๆ ที่เป็นนักพัฒนาชั้นยอด และทุกคนก็พอใจกับมัน
 
-## Let's not argue
+แน่นอนว่ายังมีตัวแก้ไขโค้ดอื่นๆ อีกมากมายในโลกกว้าง เลือกใช้ตัวที่คุณชื่นชอบที่สุดแล้วกัน
 
-The editors in the lists above are those that either I or my friends whom I consider good developers have been using for a long time and are happy with.
+<<<<<<< HEAD
+การเลือกใช้ตัวแก้ไขโค้ด ก็เหมือนกับการเลือกใช้เครื่องมืออื่นๆ เป็นเรื่องของรสนิยมส่วนบุคคล และขึ้นอยู่กับประเภทของโปรเจ็กต์ นิสัยการทำงาน และความชอบเฉพาะตัวของแต่ละคน
 
-There are other great editors in our big world. Please choose the one you like the most.
+ความเห็นส่วนตัวของผู้เขียน:
 
+- ผมใช้ [Visual Studio Code](https://code.visualstudio.com/) หากพัฒนา frontend (ฝั่งหน้าบ้าน) เป็นหลัก
+- แต่หากใช้ภาษา/แพลตฟอร์มอื่นๆ เป็นส่วนใหญ่ โดยมี frontend แค่บางส่วน ผมจะพิจารณาใช้ตัวอื่น เช่น XCode (Mac), Visual Studio (Windows) หรือ IDE จากค่าย Jetbrains (WebStorm สำหรับ JavaScript, PHPStorm สำหรับ PHP, RubyMine สำหรับ Ruby เป็นต้น) ทั้งนี้ขึ้นอยู่กับภาษาหลักของโปรเจ็กต์
+=======
 The choice of an editor, like any other tool, is individual and depends on your projects, habits, and personal preferences.
 
 The author's personal opinion:
 
 - I'd use [Visual Studio Code](https://code.visualstudio.com/) if I develop mostly frontend.
 - Otherwise, if it's mostly another language/platform and partially frontend, then consider other editors, such as XCode (Mac), Visual Studio (Windows) or Jetbrains family (Webstorm, PHPStorm, RubyMine etc, depending on the language).
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
diff --git a/1-js/01-getting-started/4-devtools/article.md b/1-js/01-getting-started/4-devtools/article.md
index bbe8af920..5551a8b23 100644
--- a/1-js/01-getting-started/4-devtools/article.md
+++ b/1-js/01-getting-started/4-devtools/article.md
@@ -1,63 +1,67 @@
-# Developer console
+# คอนโซลนักพัฒนา
 
-Code is prone to errors. You will quite likely make errors... Oh, what am I talking about? You are *absolutely* going to make errors, at least if you're a human, not a [robot](https://en.wikipedia.org/wiki/Bender_(Futurama)).
+เมื่อเขียนโค้ด มักจะเกิดข้อผิดพลาดได้เสมอ ไม่ว่าคุณจะระมัดระวังแค่ไหน ก็ยังมีโอกาสทำผิดพลาดอยู่ดี... เอ่อ กำลังพูดถึงอะไรอยู่น่ะ? ต้องขอแก้ใหม่ หากคุณเป็นมนุษย์ คุณ *จะต้อง* ทำผิดพลาดแน่ๆ ยกเว้นว่าคุณจะเป็น[หุ่นยนต์](https://en.wikipedia.org/wiki/Bender_(Futurama))
 
-But in the browser, users don't see errors by default. So, if something goes wrong in the script, we won't see what's broken and can't fix it.
+แต่โดยค่าเริ่มต้น ผู้ใช้จะไม่เห็นข้อผิดพลาดเหล่านั้นบนหน้าเว็บ ดังนั้น หากสคริปต์มีจุดบกพร่อง เราจะไม่รู้ว่ามันพังตรงไหน ทำให้ไม่สามารถแก้ไขได้
 
-To see errors and get a lot of other useful information about scripts, "developer tools" have been embedded in browsers.
+เพื่อให้เห็นข้อผิดพลาดและข้อมูลดีบั๊กที่มีประโยชน์อื่นๆ เกี่ยวกับสคริปต์ เบราว์เซอร์จึงมี "เครื่องมือนักพัฒนา" (developer tools) ติดตั้งมาด้วย
 
-Most developers lean towards Chrome or Firefox for development because those browsers have the best developer tools. Other browsers also provide developer tools, sometimes with special features, but are usually playing "catch-up" to Chrome or Firefox. So most developers have a "favorite" browser and switch to others if a problem is browser-specific.
+นักพัฒนาส่วนใหญ่นิยมใช้ Chrome หรือ Firefox ในการพัฒนา เพราะมีเครื่องมือนักพัฒนาที่ทรงพลังที่สุด แม้ว่าเบราว์เซอร์อื่นๆ ก็มีเครื่องมือที่คล้ายกัน บางทีอาจจะมีฟีเจอร์พิเศษด้วย แต่มักจะตามหลัง Chrome หรือ Firefox เสมอ ดังนั้นนักพัฒนาจึงมักมีเบราว์เซอร์ "โปรด" สำหรับทำงาน และเปลี่ยนไปใช้เบราว์เซอร์อื่นเป็นครั้งคราวเมื่อพบปัญหาเฉพาะของเบราว์เซอร์นั้น 
 
-Developer tools are potent; they have many features. To start, we'll learn how to open them, look at errors, and run JavaScript commands.
+เครื่องมือนักพัฒนานั้นมีประสิทธิภาพสูงและมีฟีเจอร์มากมาย ในช่วงแรก เราจะเรียนรู้วิธีเปิดใช้งาน ดูข้อผิดพลาด และรันคำสั่ง JavaScript กัน
 
 ## Google Chrome
 
-Open the page [bug.html](bug.html).
+ลองเปิดหน้า [bug.html](bug.html) ดู 
 
-There's an error in the JavaScript code on it. It's hidden from a regular visitor's eyes, so let's open developer tools to see it.
+ในโค้ด JavaScript บนหน้านั้นมีบั๊กซ่อนอยู่ มันถูกซ่อนไว้จากสายตาผู้ใช้ทั่วไป เราลองเปิดเครื่องมือนักพัฒนาเพื่อมองหามันกัน
 
-Press `key:F12` or, if you're on Mac, then `key:Cmd+Opt+J`.
+กด `key:F12` หรือหากใช้ Mac ให้กด `key:Cmd+Opt+J`
 
-The developer tools will open on the Console tab by default.
+เครื่องมือนักพัฒนาจะเปิดขึ้นที่แท็บ Console เป็นค่าเริ่มต้น
 
-It looks somewhat like this:
+หน้าตาจะออกมาประมาณนี้:
 
 ![chrome](chrome.webp)
 
-The exact look of developer tools depends on your version of Chrome. It changes from time to time but should be similar.
+รูปลักษณ์ที่แน่นอนของเครื่องมือนักพัฒนาขึ้นอยู่กับเวอร์ชันของ Chrome ที่ใช้ มันมีการเปลี่ยนแปลงไปเรื่อยๆ แต่น่าจะคล้ายๆ กับในภาพ
 
-- Here we can see the red-colored error message. In this case, the script contains an unknown "lalala" command.
-- On the right, there is a clickable link to the source `bug.html:12` with the line number where the error has occurred.
+- ตรงนี้เราจะเห็นข้อความแสดงข้อผิดพลาดสีแดง ในกรณีนี้ สคริปต์มีคำสั่งที่ไม่รู้จักชื่อ "lalala"
+- ทางด้านขวา จะมีลิงก์ที่คลิกได้ ซึ่งจะระบุไฟล์ต้นทาง `bug.html:12` พร้อมเลขบรรทัดที่เกิดข้อผิดพลาด
 
-Below the error message, there is a blue `>` symbol. It marks a "command line" where we can type JavaScript commands. Press `key:Enter` to run them.
+ใต้ข้อความแสดงข้อผิดพลาดจะมีสัญลักษณ์ `>` สีฟ้า นี่คือ "บรรทัดคำสั่ง" (command line) ที่เราสามารถพิมพ์คำสั่ง JavaScript แล้วกด `key:Enter` เพื่อรันมันได้
 
-Now we can see errors, and that's enough for a start. We'll come back to developer tools later and cover debugging more in-depth in the chapter <info:debugging-chrome>.
+ตอนนี้เราก็เห็นข้อผิดพลาดแล้ว ซึ่งเพียงพอสำหรับการเริ่มต้น เราจะกลับมาศึกษาเครื่องมือนักพัฒนากันอีกในภายหลัง และจะคุยเรื่องการดีบั๊กอย่างละเอียดมากขึ้นในบท <info:debugging-chrome>
 
-```smart header="Multi-line input"
-Usually, when we put a line of code into the console, and then press `key:Enter`, it executes.
+```smart header="การป้อนหลายบรรทัด"
+โดยปกติ เมื่อเราพิมพ์โค้ดบรรทัดเดียวลงไปในคอนโซล และกด `key:Enter` มันจะรันคำสั่งนั้นทันที
 
-To insert multiple lines, press `key:Shift+Enter`. This way one can enter long fragments of JavaScript code.
+แต่ถ้าต้องการพิมพ์หลายบรรทัด ให้กด `key:Shift+Enter` แทน วิธีนี้จะช่วยให้เราใส่ชิ้นส่วนโค้ด JavaScript ยาวๆ ได้
 ```
 
-## Firefox, Edge, and others
+## Firefox, Edge และอื่นๆ 
 
-Most other browsers use `key:F12` to open developer tools.
+เบราว์เซอร์ส่วนใหญ่ใช้ `key:F12` เพื่อเปิดเครื่องมือนักพัฒนา
 
-The look & feel of them is quite similar. Once you know how to use one of these tools (you can start with Chrome), you can easily switch to another.
+ลักษณะและความรู้สึกในการใช้งานค่อนข้างใกล้เคียงกัน เมื่อคุณรู้วิธีใช้เครื่องมือใดเครื่องมือหนึ่ง (เช่น เริ่มจาก Chrome) คุณก็สามารถเปลี่ยนไปใช้อันอื่นๆ ได้อย่างง่ายดาย
 
 ## Safari
 
-Safari (Mac browser, not supported by Windows/Linux) is a little bit special here. We need to enable the "Develop menu" first.
+Safari (เบราว์เซอร์ของ Mac ไม่รองรับ Windows/Linux) จะแตกต่างออกไปเล็กน้อย เราต้องเปิดใช้งาน "Develop menu" ก่อน
 
+<<<<<<< HEAD
+ไปที่ Preferences และเลือกแท็บ "Advanced" จะเห็นช่องทำเครื่องหมายที่ด้านล่างของหน้า:
+=======
 Open Settings and go to the "Advanced" pane. There's a checkbox at the bottom:
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
 ![safari](safari.png)
 
-Now `key:Cmd+Opt+C` can toggle the console. Also, note that the new top menu item named "Develop" has appeared. It has many commands and options.
+ตอนนี้ `key:Cmd+Opt+C` จะสามารถเปิด/ปิดคอนโซลได้ และสังเกตว่าจะมีเมนูใหม่ชื่อ "Develop" ปรากฏที่ด้านบนขวา ซึ่งมีคำสั่งและตัวเลือกต่างๆ มากมาย
 
-## Summary
+## สรุป
 
-- Developer tools allow us to see errors, run commands, examine variables, and much more.
-- They can be opened with `key:F12` for most browsers on Windows. Chrome for Mac needs `key:Cmd+Opt+J`, Safari: `key:Cmd+Opt+C` (need to enable first).
+- เครื่องมือนักพัฒนาช่วยให้เราเห็นข้อผิดพลาด รันคำสั่ง ตรวจสอบตัวแปร และอีกสารพัด
+- สามารถเปิดใช้งานได้ด้วย `key:F12` ในเบราว์เซอร์ส่วนใหญ่บน Windows ส่วน Chrome บน Mac ใช้ `key:Cmd+Opt+J`, Safari ใช้ `key:Cmd+Opt+C` (ต้องเปิดใช้ก่อน)
 
-Now we have the environment ready. In the next section, we'll get down to JavaScript.
+ตอนนี้เตรียมสภาพแวดล้อมเรียบร้อยแล้ว ในบทต่อๆ ไป เราจะเริ่มศึกษา JavaScript อย่างละเอียดมากขึ้น
diff --git a/1-js/01-getting-started/index.md b/1-js/01-getting-started/index.md
index b327c7860..685f6dad9 100644
--- a/1-js/01-getting-started/index.md
+++ b/1-js/01-getting-started/index.md
@@ -1,3 +1,3 @@
-# An introduction
+# บทนำ
 
-About the JavaScript language and the environment to develop with it.
+ในบทนี้เราจะพูดถึงเกี่ยวกับภาษา JavaScript และสภาพแวดล้อมที่ใช้ในการพัฒนาโปรแกรมด้วยภาษานี้
diff --git a/1-js/02-first-steps/01-hello-world/1-hello-alert/task.md b/1-js/02-first-steps/01-hello-world/1-hello-alert/task.md
index afed6a91d..b1f35ea9b 100644
--- a/1-js/02-first-steps/01-hello-world/1-hello-alert/task.md
+++ b/1-js/02-first-steps/01-hello-world/1-hello-alert/task.md
@@ -2,11 +2,11 @@ importance: 5
 
 ---
 
-# Show an alert
+# โชว์หน้าแจ้งเตือน
 
-Create a page that shows a message "I'm JavaScript!".
+สร้างเว็บเพจที่เปิดขึ้นมาจะแสดงหน้าต่าง `alert` ว่า "I'm JavaScript!".
 
-Do it in a sandbox, or on your hard drive, doesn't matter, just ensure that it works.
+ที่นี่เป็นพื้นที่การเล่นที่ปลอดภัย ดังนั้นไม่ต้องกังวลว่าคอมพิวเตอร์จะเสียหาย
 
 [demo src="solution"]
 
diff --git a/1-js/02-first-steps/01-hello-world/2-hello-alert-ext/solution.md b/1-js/02-first-steps/01-hello-world/2-hello-alert-ext/solution.md
index f42c41e6d..0fa1300cf 100644
--- a/1-js/02-first-steps/01-hello-world/2-hello-alert-ext/solution.md
+++ b/1-js/02-first-steps/01-hello-world/2-hello-alert-ext/solution.md
@@ -1,8 +1,8 @@
-The HTML code:
+HTML:
 
 [html src="index.html"]
 
-For the file `alert.js` in the same folder:
+สำหรับไฟล์ `alert.js` อยู่ในโฟลเดอร์เดียวกัน:
 
 [js src="alert.js"]
 
diff --git a/1-js/02-first-steps/01-hello-world/2-hello-alert-ext/task.md b/1-js/02-first-steps/01-hello-world/2-hello-alert-ext/task.md
index 26168d6a7..f5d000b28 100644
--- a/1-js/02-first-steps/01-hello-world/2-hello-alert-ext/task.md
+++ b/1-js/02-first-steps/01-hello-world/2-hello-alert-ext/task.md
@@ -2,8 +2,8 @@ importance: 5
 
 ---
 
-# Show an alert with an external script
+# โชว์หน้าแจ้งเตือนด้วยสคริปต์จากภายนอก
 
-Take the solution of the previous task <info:task/hello-alert>. Modify it by extracting the script content into an external file `alert.js`, residing in the same folder.
+ใช้ความรู้จากแบบฝึกหัดที่แล้ว <info:task/hello-alert> ช่วยบอกเบราเซอร์ให้รู้ว่าที่อยู่ของไฟล์ `alert.js` อยู่ที่ใด ขอใบ้ว่าอยู่ในโฟลเดอร์เดียวกัน
 
-Open the page, ensure that the alert works.
+เปิดหน้าเว็บขึ้นมา เพื่อดูว่าสคริปต์ทำงานได้ตามที่คาดหวังไว้
diff --git a/1-js/02-first-steps/01-hello-world/article.md b/1-js/02-first-steps/01-hello-world/article.md
index 35f82bf5d..b7a200589 100644
--- a/1-js/02-first-steps/01-hello-world/article.md
+++ b/1-js/02-first-steps/01-hello-world/article.md
@@ -1,17 +1,16 @@
-# Hello, world!
+# สวัสดี ชาวโลก!
 
-This part of the tutorial is about core JavaScript, the language itself.
+ในส่วนนี้ของบทเรียน เราจะเริ่มศึกษาเกี่ยวกับพื้นฐานของภาษา JavaScript
 
-But we need a working environment to run our scripts and, since this book is online, the browser is a good choice. We'll keep the amount of browser-specific commands (like `alert`) to a minimum so that you don't spend time on them if you plan to concentrate on another environment (like Node.js). We'll focus on JavaScript in the browser in the [next part](/ui) of the tutorial.
+แต่ก่อนอื่น เราต้องมีสภาพแวดล้อมที่พร้อมสำหรับการรันสคริปต์ และเนื่องจากหนังสือเล่มนี้อยู่บนออนไลน์ เบราว์เซอร์จึงเป็นตัวเลือกที่เหมาะสม เราจะพยายามจำกัดการใช้คำสั่งเฉพาะของเบราว์เซอร์ (เช่น `alert`) ให้น้อยที่สุด เพื่อที่คุณจะได้ไม่ต้องเสียเวลากับมันมากนัก หากคุณตั้งใจจะมุ่งเน้นการใช้ JavaScript ในสภาพแวดล้อมอื่นๆ เช่น Node.js ส่วนการใช้ JavaScript ในเบราว์เซอร์โดยเฉพาะจะมีกล่าวถึงในรายละเอียดใน[ส่วนถัดไป](/ui)ของบทเรียน
 
-So first, let's see how we attach a script to a webpage. For server-side environments (like Node.js), you can execute the script with a command like `"node my.js"`.
+ดังนั้น ก่อนอื่นเรามาดูกันว่าจะแทรกสคริปต์ลงในหน้าเว็บได้อย่างไร ซึ่งหากเป็นสภาพแวดล้อมฝั่งเซิร์ฟเวอร์อย่าง Node.js เราสามารถรันสคริปต์โดยใช้คำสั่ง `"node my.js"` ได้เลย
 
+## แท็ก "script"
 
-## The "script" tag
+โปรแกรม JavaScript สามารถแทรกลงในเอกสาร HTML ได้เกือบทุกที่ด้วยการใช้แท็ก `<script>`
 
-JavaScript programs can be inserted almost anywhere into an HTML document using the `<script>` tag.
-
-For instance:
+ตัวอย่างเช่น:
 
 ```html run height=100
 <!DOCTYPE HTML>
@@ -19,15 +18,15 @@ For instance:
 
 <body>
 
-  <p>Before the script...</p>
+  <p>ก่อนสคริปต์...</p>
 
 *!*
   <script>
-    alert( 'Hello, world!' );
+    alert( 'สวัสดี ชาวโลก!' );
   </script>
 */!*
 
-  <p>...After the script.</p>
+  <p>...หลังสคริปต์</p>
 
 </body>
 
@@ -35,24 +34,23 @@ For instance:
 ```
 
 ```online
-You can run the example by clicking the "Play" button in the right-top corner of the box above.
+คุณสามารถลองรันตัวอย่างนี้ได้โดยคลิกที่ปุ่ม "เล่น" ที่มุมบนขวาของกล่องโค้ด
 ```
 
-The `<script>` tag contains JavaScript code which is automatically executed when the browser processes the tag.
-
+แท็ก `<script>` จะมีโค้ด JavaScript อยู่ข้างใน ซึ่งจะทำงานโดยอัตโนมัติเมื่อเบราว์เซอร์ประมวลผลถึงแท็กนี้
 
-## Modern markup
+## Markup สมัยใหม่
 
-The `<script>` tag has a few attributes that are rarely used nowadays but can still be found in old code:
+แท็ก `<script>` มีแอตทริบิวต์บางอย่างที่ปัจจุบันไม่ค่อยใช้แล้ว แต่ยังพบเห็นได้ในโค้ดเก่าๆ:
 
-The `type` attribute: <code>&lt;script <u>type</u>=...&gt;</code>
-: The old HTML standard, HTML4, required a script to have a `type`. Usually it was `type="text/javascript"`. It's not required anymore. Also, the modern HTML standard totally changed the meaning of this attribute. Now, it can be used for JavaScript modules. But that's an advanced topic, we'll talk about modules in another part of the tutorial.
+แอตทริบิวต์ `type`: <code>&lt;script <u>type</u>=...&gt;</code>
+: ในมาตรฐาน HTML เก่า (HTML4) สคริปต์จะต้องมีแอตทริบิวต์ `type` โดยปกติจะเป็น `type="text/javascript"` แต่ปัจจุบันไม่จำเป็นต้องระบุแล้ว อีกทั้งใน HTML มาตรฐานใหม่ ความหมายของแอตทริบิวต์นี้ก็เปลี่ยนไปอย่างสิ้นเชิง โดยตอนนี้ใช้ระบุโมดูล JavaScript แทน แต่นั่นเป็นหัวข้อขั้นสูง ซึ่งเราจะกล่าวถึงในส่วนอื่นของบทเรียน
 
-The `language` attribute: <code>&lt;script <u>language</u>=...&gt;</code>
-: This attribute was meant to show the language of the script. This attribute no longer makes sense because JavaScript is the default language. There is no need to use it.
+แอตทริบิวต์ `language`: <code>&lt;script <u>language</u>=...&gt;</code>
+: แอตทริบิวต์นี้เคยใช้เพื่อระบุภาษาของสคริปต์ แต่ปัจจุบันก็ไม่จำเป็นแล้วเช่นกัน เพราะ JavaScript เป็นภาษาเริ่มต้นอยู่แล้ว จึงไม่ต้องระบุก็ได้
 
-Comments before and after scripts.
-: In really ancient books and guides, you may find comments inside `<script>` tags, like this:
+คอมเมนต์ก่อนและหลังสคริปต์
+: ในหนังสือและคู่มือเก่าๆ คุณอาจเจอคอมเมนต์ภายในแท็ก `<script>` แบบนี้:
 
     ```html no-beautify
     <script type="text/javascript"><!--
@@ -60,28 +58,27 @@ Comments before and after scripts.
     //--></script>
     ```
 
-    This trick isn't used in modern JavaScript. These comments hide JavaScript code from old browsers that didn't know how to process the `<script>` tag. Since browsers released in the last 15 years don't have this issue, this kind of comment can help you identify really old code.
+    เทคนิคนี้ไม่ได้ใช้กันแล้วในยุค JavaScript สมัยใหม่ คอมเมนต์แบบนี้มีไว้เพื่อซ่อนโค้ด JavaScript จากเบราว์เซอร์รุ่นเก่ามากๆ ที่ไม่รู้จักวิธีประมวลผลแท็ก `<script>` แต่เบราว์เซอร์ที่ออกมาในช่วง 15 ปีหลังนี้ไม่มีปัญหาเรื่องนั้นแล้ว คอมเมนต์แบบนี้จึงช่วยให้คุณแยกแยะได้ว่าโค้ดนั้นเก่ามากแค่ไหน
 
+## สคริปต์ภายนอก
 
-## External scripts
+หากเรามีโค้ด JavaScript จำนวนมาก เราสามารถนำมันไปไว้ในไฟล์แยกต่างหากได้
 
-If we have a lot of JavaScript code, we can put it into a separate file.
-
-Script files are attached to HTML with the `src` attribute:
+ไฟล์สคริปต์จะถูกแทรกเข้าไปใน HTML ด้วยแอตทริบิวต์ `src`:
 
 ```html
 <script src="/path/to/script.js"></script>
 ```
 
-Here, `/path/to/script.js` is an absolute path to the script from the site root. One can also provide a relative path from the current page. For instance, `src="script.js"`, just like `src="./script.js"`, would mean a file `"script.js"` in the current folder.
+ที่นี่ `/path/to/script.js` คือพาธเต็มไปยังไฟล์สคริปต์นับจากรากของเว็บไซต์ นอกจากนี้คุณยังสามารถระบุพาธสัมพัทธ์จากหน้าปัจจุบันก็ได้ เช่น `src="script.js"` หมายถึงไฟล์ `"script.js"` อยู่ในโฟลเดอร์เดียวกับหน้า HTML ส่วน `src="./script.js"` ก็จะหมายถึงไฟล์ `"script.js"` อยู่ในโฟลเดอร์ปัจจุบันเช่นกัน
 
-We can give a full URL as well. For instance:
+เราสามารถระบุ URL แบบเต็มๆ ได้ด้วย เช่น:
 
 ```html
 <script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.11/lodash.js"></script>
 ```
 
-To attach several scripts, use multiple tags:
+ในการแทรกสคริปต์หลายไฟล์ ให้ใช้แท็กหลายอัน:
 
 ```html
 <script src="/js/script1.js"></script>
@@ -90,29 +87,29 @@ To attach several scripts, use multiple tags:
 ```
 
 ```smart
-As a rule, only the simplest scripts are put into HTML. More complex ones reside in separate files.
+โดยทั่วไป ในโค้ด HTML จะมีแต่สคริปต์ที่ไม่ซับซ้อนและสั้นๆ เท่านั้น ส่วนโค้ดที่ยาวและซับซ้อนกว่ามักจะแยกไปอยู่ในไฟล์อื่น
 
-The benefit of a separate file is that the browser will download it and store it in its [cache](https://en.wikipedia.org/wiki/Web_cache).
+ข้อดีของการแยกสคริปต์ไปอยู่ในไฟล์ต่างหากคือ เบราว์เซอร์จะดาวน์โหลดไฟล์นั้นมาแล้วเก็บไว้ใน[แคช](https://en.wikipedia.org/wiki/Web_cache)
 
-Other pages that reference the same script will take it from the cache instead of downloading it, so the file is actually downloaded only once.
+เมื่อหน้าอื่นๆ อ้างถึงสคริปต์ไฟล์เดียวกัน แทนที่จะดาวน์โหลดใหม่ มันจะเรียกใช้ไฟล์จากแคชแทน ทำให้ไฟล์นั้นถูกดาวน์โหลดจริงๆ เพียงแค่ครั้งเดียว
 
-That reduces traffic and makes pages faster.
+สิ่งนี้ช่วยลดปริมาณการรับส่งข้อมูลผ่านเครือข่าย ทำให้หน้าเว็บโหลดได้เร็วขึ้น
 ```
 
-````warn header="If `src` is set, the script content is ignored."
-A single `<script>` tag can't have both the `src` attribute and code inside.
+````warn header="ถ้าตั้งแอตทริบิวต์ `src` ไว้ เนื้อหาภายในแท็กจะถูกเพิกเฉย"
+แท็ก `<script>` เดียวจะมีแอตทริบิวต์ `src` หรือมีโค้ดข้างในอย่างใดอย่างหนึ่งเท่านั้น ไม่สามารถมีทั้งคู่ได้
 
-This won't work:
+โค้ดแบบนี้จะไม่ทำงาน:
 
 ```html
 <script *!*src*/!*="file.js">
-  alert(1); // the content is ignored, because src is set
+  alert(1); // เนื้อหาข้างในจะถูกเพิกเฉย เพราะมีการตั้งค่า src
 </script>
 ```
 
-We must choose either an external `<script src="…">` or a regular `<script>` with code.
+เราต้องเลือกใช้อย่างใดอย่างหนึ่ง: ไฟล์ภายนอกด้วย `<script src="…">` หรือใส่โค้ดข้างในแท็ก `<script>` ตรงๆ
 
-The example above can be split into two scripts to work:
+ตัวอย่างข้างบนสามารถแยกเป็นสองแท็ก `<script>` เพื่อให้ทำงานได้:
 
 ```html
 <script src="file.js"></script>
@@ -122,11 +119,10 @@ The example above can be split into two scripts to work:
 ```
 ````
 
-## Summary
-
-- We can use a `<script>` tag to add JavaScript code to a page.
-- The `type` and `language` attributes are not required.
-- A script in an external file can be inserted with `<script src="path/to/script.js"></script>`.
+## สรุป
 
+- เราสามารถใช้แท็ก `<script>` เพื่อเพิ่มโค้ด JavaScript ลงในหน้าเว็บได้
+- แอตทริบิวต์ `type` และ `language` ไม่จำเป็นต้องระบุแล้วในปัจจุบัน
+- สคริปต์ในไฟล์ภายนอกสามารถแทรกเข้ามาได้โดยใช้ `<script src="path/to/script.js"></script>`
 
-There is much more to learn about browser scripts and their interaction with the webpage. But let's keep in mind that this part of the tutorial is devoted to the JavaScript language, so we shouldn't distract ourselves with browser-specific implementations of it. We'll be using the browser as a way to run JavaScript, which is very convenient for online reading, but only one of many.
+เรายังมีอะไรต้องเรียนรู้อีกมากเกี่ยวกับการใช้สคริปต์ในเบราว์เซอร์และการสื่อสารระหว่างสคริปต์กับหน้าเว็บ แต่อย่าลืมว่าส่วนนี้ของบทเรียนเราจะมุ่งเน้นที่ภาษา JavaScript เอง ดังนั้นเราควรพยายามไม่ออกนอกเรื่องมากเกินไป
diff --git a/1-js/02-first-steps/02-structure/article.md b/1-js/02-first-steps/02-structure/article.md
index e81fd343d..01cf889d1 100644
--- a/1-js/02-first-steps/02-structure/article.md
+++ b/1-js/02-first-steps/02-structure/article.md
@@ -1,59 +1,59 @@
-# Code structure
+# โครงสร้างโค้ด
 
-The first thing we'll study is the building blocks of code.
+ในการเรียนรู้ภาษาโปรแกรมมิ่ง สิ่งแรกที่เราต้องทำความเข้าใจคือบล็อกพื้นฐานของโค้ด ซึ่งได้แก่ statements (คำสั่ง) และ comments (คอมเมนต์)
 
-## Statements
+## Statements (คำสั่ง)
 
-Statements are syntax constructs and commands that perform actions.
+Statements คือโครงสร้างและคำสั่งทางไวยากรณ์ที่ใช้สั่งให้โปรแกรมทำการกระทำบางอย่าง
 
-We've already seen a statement, `alert('Hello, world!')`, which shows the message "Hello, world!".
+เราเคยเห็นตัวอย่างของ statement มาแล้วนั่นคือ `alert('Hello, world!')` ซึ่งเป็นคำสั่งให้แสดงข้อความ "Hello, world!"
 
-We can have as many statements in our code as we want. Statements can be separated with a semicolon.
+เราสามารถเขียน statements ในโค้ดได้หลายคำสั่ง โดยแยกแต่ละคำสั่งด้วยเครื่องหมายอัฒภาค (semicolon)
 
-For example, here we split "Hello World" into two alerts:
+ตัวอย่างเช่น ที่นี่เราแยก "Hello World" ออกเป็นสอง alerts:
 
 ```js run no-beautify
 alert('Hello'); alert('World');
 ```
 
-Usually, statements are written on separate lines to make the code more readable:
+โดยปกติแล้ว statements จะเขียนแยกบรรทัดกันเพื่อให้อ่านโค้ดง่ายขึ้น:
 
 ```js run no-beautify
 alert('Hello');
 alert('World');
 ```
 
-## Semicolons [#semicolon]
+## เครื่องหมายอัฒภาค (Semicolons) [#semicolon]
 
-A semicolon may be omitted in most cases when a line break exists.
+ในหลายกรณี JavaScript อนุญาตให้ละเครื่องหมายอัฒภาคได้ถ้ามีการขึ้นบรรทัดใหม่
 
-This would also work:
+ตัวอย่างเช่น โค้ดนี้จะทำงานได้เหมือนกัน:
 
 ```js run no-beautify
 alert('Hello')
-alert('World')
+alert('World') 
 ```
 
-Here, JavaScript interprets the line break as an "implicit" semicolon. This is called an [automatic semicolon insertion](https://tc39.github.io/ecma262/#sec-automatic-semicolon-insertion).
+ที่นี่ JavaScript จะถือว่าการขึ้นบรรทัดใหม่เป็นการใส่เครื่องหมายอัฒภาคโดยนัย เรียกว่า [Automatic Semicolon Insertion](https://tc39.github.io/ecma262/#sec-automatic-semicolon-insertion)
 
-**In most cases, a newline implies a semicolon. But "in most cases" does not mean "always"!**
+**ในหลายๆ กรณี การขึ้นบรรทัดใหม่หมายถึงการใส่เครื่องหมายอัฒภาค แต่ "หลายๆ กรณี" ไม่ได้แปลว่า "เสมอไป"!**
 
-There are cases when a newline does not mean a semicolon. For example:
+มีบางสถานการณ์ที่การขึ้นบรรทัดใหม่ไม่ได้หมายถึงการใส่เครื่องหมายอัฒภาค เช่นในตัวอย่างนี้:
 
 ```js run no-beautify
 alert(3 +
-1
+1  
 + 2);
 ```
 
-The code outputs `6` because JavaScript does not insert semicolons here. It is intuitively obvious that if the line ends with a plus `"+"`, then it is an "incomplete expression", so a semicolon there would be incorrect. And in this case, that works as intended.
+โค้ดจะแสดงผลเป็น `6` เพราะ JavaScript ไม่ได้ใส่เครื่องหมายอัฒภาค มันเข้าใจได้เองว่าถ้าบรรทัดจบด้วย `+` แสดงว่า expression ยังไม่จบ การใส่เครื่องหมายอัฒภาคตรงนั้นจะไม่ถูกต้อง และในกรณีนี้มันก็ทำงานตรงตามที่เราต้องการจริงๆ 
 
-**But there are situations where JavaScript "fails" to assume a semicolon where it is really needed.**
+**แต่มีบางสถานการณ์ที่ JavaScript "ไม่สามารถ" ใส่เครื่องหมายอัฒภาคให้เราในตำแหน่งที่ควรจะมี**
 
-Errors which occur in such cases are quite hard to find and fix.
+ข้อผิดพลาดที่เกิดจากการไม่ใส่เครื่องหมายอัฒภาคมักจะหาสาเหตุและแก้ไขได้ยาก
 
-````smart header="An example of an error"
-If you're curious to see a concrete example of such an error, check this code out:
+````smart header="ตัวอย่างข้อผิดพลาด"
+ถ้าอยากเห็นตัวอย่างของข้อผิดพลาดเช่นนี้ ลองพิจารณาโค้ดนี้ดู:
 
 ```js run
 alert("Hello");
@@ -61,9 +61,9 @@ alert("Hello");
 [1, 2].forEach(alert);
 ```
 
-No need to think about the meaning of the brackets `[]` and `forEach` yet. We'll study them later. For now, just remember the result of running the code: it shows `Hello`, then `1`, then `2`.
+ตอนนี้ไม่ต้องสนใจความหมายของ `[]` และ `forEach` เรายังไม่ได้เรียนเรื่องพวกนี้ เพียงแค่จำไว้ว่ามันจะแสดง `Hello` ตามด้วย `1` และ `2` ในบรรทัดถัดๆ ไป
 
-Now let's remove the semicolon after the `alert`:
+ทีนี้ลองลบเครื่องหมายอัฒภาคหลัง `alert` ออกดู:
 
 ```js run no-beautify
 alert("Hello")
@@ -71,85 +71,87 @@ alert("Hello")
 [1, 2].forEach(alert);
 ```
 
-The difference compared to the code above is only one character: the semicolon at the end of the first line is gone.
+ความต่างจากโค้ดก่อนหน้าคือไม่มีเพียงหนึ่งตัวอักษร นั่นคือเครื่องหมายอัฒภาค `;` ตอนจบบรรทัดแรก 
 
-If we run this code, only the first `Hello` shows (and there's an error, you may need to open the console to see it). There are no numbers any more.
+ถ้าเรารันโค้ดนี้ มันจะแสดง `Hello` แล้วเกิด error (คุณอาจต้องเปิดคอนโซลเพื่อดูมัน) โดยไม่มีการแสดงเลข 1 และ 2
 
-That's because JavaScript does not assume a semicolon before square brackets `[...]`. So, the code in the last example is treated as a single statement.
+นั่นเป็นเพราะ JavaScript ไม่ได้ใส่เครื่องหมายอัฒภาคโดยอัตโนมัติก่อนวงเล็บ `[...]` ดังนั้น โค้ดในตัวอย่างหลังจึงถูกรวมเป็นคำสั่งเดียวกันหมด
 
-Here's how the engine sees it:
+จริงๆ แล้ว JavaScript engine มองเห็นโค้ดเป็นแบบนี้:
 
 ```js run no-beautify
 alert("Hello")[1, 2].forEach(alert);
 ```
 
-Looks weird, right? Such merging in this case is just wrong. We need to put a semicolon after `alert` for the code to work correctly.
+ดูแปลกๆ ใช่ไหม? การรวมแบบนี้ไม่ถูกต้องแน่นอน เราต้องใส่เครื่องหมายอัฒภาคหลัง `alert` เพื่อให้โค้ดทำงานได้ถูกต้อง
 
-This can happen in other situations also.
+ปัญหาแบบนี้อาจเกิดขึ้นได้ในสถานการณ์อื่นๆ ด้วย
 ````
 
-We recommend putting semicolons between statements even if they are separated by newlines. This rule is widely adopted by the community. Let's note once again -- *it is possible* to leave out semicolons most of the time. But it's safer -- especially for a beginner -- to use them.
+เราแนะนำให้ใส่เครื่องหมายอัฒภาคระหว่าง statements แม้จะแยกคำสั่งด้วยการขึ้นบรรทัดใหม่แล้วก็ตาม กฎนี้เป็นที่ยอมรับอย่างกว้างขวางในชุมชนนักพัฒนา และอีกครั้ง *เราสามารถ* ละเครื่องหมายอัฒภาคได้ในหลายๆ กรณี แต่จะปลอดภัยกว่าโดยเฉพาะสำหรับมือใหม่ถ้าใส่มันไว้ตลอด 
 
-## Comments [#code-comments]
+## Comments (คอมเมนต์)
 
-As time goes on, programs become more and more complex. It becomes necessary to add *comments* which describe what the code does and why.
+เมื่อเวลาผ่านไป โปรแกรมที่เราพัฒนาจะมีความซับซ้อนมากขึ้นเรื่อยๆ จึงจำเป็นต้องมีการเขียน *คอมเมนต์* ที่อธิบายว่าทำไมโค้ดถึงทำแบบนี้และมันทำอะไร
 
-Comments can be put into any place of a script. They don't affect its execution because the engine simply ignores them.
+คอมเมนต์สามารถเขียนลงไปได้ทุกที่ในสคริปต์ มันจะไม่ส่งผลต่อการทำงานของโค้ดเพราะ JavaScript engine จะข้ามไปไม่สนใจพวกมัน
 
-**One-line comments start with two forward slash characters `//`.**
+**คอมเมนต์บรรทัดเดียวเริ่มต้นด้วย `//`**
 
-The rest of the line is a comment. It may occupy a full line of its own or follow a statement.
+เนื้อหาที่เหลือของบรรทัดหลังเครื่องหมาย `//` จะเป็นคอมเมนต์ทั้งหมด มันอาจเป็นคอมเมนต์บรรทัดเดียวเต็มหรือต่อท้ายจาก statement ก็ได้
+
+แบบนี้:
 
-Like here:
 ```js run
-// This comment occupies a line of its own
+// คอมเมนต์นี้เป็นบรรทัดเดียว
 alert('Hello');
 
-alert('World'); // This comment follows the statement
+alert('World'); // คอมเมนต์นี้ต่อท้าย statement
 ```
 
-**Multiline comments start with a forward slash and an asterisk <code>/&#42;</code> and end with an asterisk and a forward slash <code>&#42;/</code>.**
+**คอมเมนต์หลายบรรทัดเริ่มด้วย <code>/&#42;</code> และจบด้วย <code>&#42;/</code>**
 
-Like this:
+แบบนี้:
 
 ```js run
-/* An example with two messages.
-This is a multiline comment.
+/* ตัวอย่างที่มีสองข้อความ
+นี่คือคอมเมนต์ 
+หลายบรรทัด
 */
 alert('Hello');
-alert('World');
+alert('World'); 
 ```
 
-The content of comments is ignored, so if we put code inside <code>/&#42; ... &#42;/</code>, it won't execute.
+เนื้อหาของคอมเมนต์จะถูกข้ามไปไม่ถูกประมวลผล ดังนั้นถ้าเราใส่โค้ดลงไปใน <code>/&#42; ... &#42;/</code> มันจะไม่ทำงาน
 
-Sometimes it can be handy to temporarily disable a part of code:
+บางครั้งมีประโยชน์ในการปิดโค้ดบางส่วนชั่วคราวด้วย:
 
 ```js run
-/* Commenting out the code
+/* ใส่คอมเมนต์โค้ดนี้
 alert('Hello');
 */
 alert('World');
 ```
 
-```smart header="Use hotkeys!"
-In most editors, a line of code can be commented out by pressing the `key:Ctrl+/` hotkey for a single-line comment and something like `key:Ctrl+Shift+/` -- for multiline comments (select a piece of code and press the hotkey). For Mac, try `key:Cmd` instead of `key:Ctrl` and `key:Option` instead of `key:Shift`.
+```smart header="ใช้ปุ่มลัดเพื่อใส่คอมเมนต์!"
+ในเครื่องมือแก้ไขโค้ดส่วนใหญ่ คุณสามารถใส่คอมเมนต์บรรทัดเดียวให้โค้ดได้โดยกด `key:Ctrl+/`  สำหรับคอมเมนต์หลายบรรทัด ให้เลือกโค้ดแล้วกด `key:Ctrl+Shift+/` (บน Mac ใช้ `key:Cmd` แทน `key:Ctrl` และ `key:Option` แทน `key:Shift`)  
 ```
 
-````warn header="Nested comments are not supported!"
-There may not be `/*...*/` inside another `/*...*/`.
+````warn header="คอมเมนต์ซ้อนกันไม่รองรับ!"
+ไม่ควรมี <code>/&#42; ... &#42;/</code> อยู่ข้างในคอมเมนต์หลายบรรทัด <code>/&#42; ... &#42;/</code> อีก
 
-Such code will die with an error:
+โค้ดแบบนี้จะเกิดข้อผิดพลาด:
 
 ```js run no-beautify
 /*
-  /* nested comment ?!? */
+  /* คอมเมนต์ซ้อนกัน ?!? */
 */
 alert( 'World' );
 ```
 ````
 
-Please, don't hesitate to comment your code.
+อย่าลังเลใจที่จะใส่คอมเมนต์ในโค้ดของคุณ
 
-Comments increase the overall code footprint, but that's not a problem at all. There are many tools which minify code before publishing to a production server. They remove comments, so they don't appear in the working scripts. Therefore, comments do not have negative effects on production at all.
+คอมเมนต์อาจจะเพิ่มปริมาณโค้ดให้มากขึ้นแต่นั่นไม่ใช่ปัญหา มีเครื่องมือหลายตัวที่ช่วยลดขนาดสคริปต์ก่อนนำไปเผยแพร่บนเซิร์ฟเวอร์จริง โดยจะตัดคอมเมนต์ทิ้งไปเลยทำให้ไม่ปรากฏในสคริปต์ที่ใช้งานจริง ดังนั้นคอมเมนต์จึงไม่ส่งผลกระทบด้านลบใดๆ ต่อการใช้งาน
 
-Later in the tutorial there will be a chapter <info:code-quality> that also explains how to write better comments.
+ในบทต่อๆ ไปของบทเรียนอย่าง <info:code-quality> เราจะอธิบายเพิ่มเติมถึงวิธีเขียนคอมเมนต์ที่ดีด้วย
diff --git a/1-js/02-first-steps/03-strict-mode/article.md b/1-js/02-first-steps/03-strict-mode/article.md
index 9586733cc..24f7ed07f 100644
--- a/1-js/02-first-steps/03-strict-mode/article.md
+++ b/1-js/02-first-steps/03-strict-mode/article.md
@@ -1,68 +1,68 @@
-# The modern mode, "use strict"
+# โหมดสมัยใหม่ "use strict" 
 
-For a long time, JavaScript evolved without compatibility issues. New features were added to the language while old functionality didn't change.
+เป็นเวลายาวนานที่ JavaScript ถูกพัฒนาโดยไม่ต้องกังวลเรื่องความเข้ากันได้ มีการเพิ่มคุณสมบัติใหม่ๆ เข้ามาอย่างต่อเนื่อง ในขณะที่ฟังก์ชันเดิมๆ ยังคงทำงานเหมือนเดิม 
 
-That had the benefit of never breaking existing code. But the downside was that any mistake or an imperfect decision made by JavaScript's creators got stuck in the language forever.
+ซึ่งในแง่หนึ่งก็เป็นเรื่องดี เพราะไม่ทำให้โค้ดเดิมพังไป แต่ในอีกแง่ก็ทำให้ข้อผิดพลาดหรือการตัดสินใจออกแบบที่ไม่สมบูรณ์แบบของผู้พัฒนา JavaScript ถูกสืบทอดมาในภาษาเรื่อยๆ 
 
-This was the case until 2009 when ECMAScript 5 (ES5) appeared. It added new features to the language and modified some of the existing ones. To keep the old code working, most such modifications are off by default. You need to explicitly enable them with a special directive: `"use strict"`.
+สถานการณ์เป็นแบบนั้นจนถึงปี 2009 เมื่อ ECMAScript 5 (ES5) เปิดตัว โดยมีการเพิ่มคุณสมบัติใหม่ และปรับปรุงบางส่วนที่มีอยู่เดิมให้ดีขึ้น แต่เพื่อให้โค้ดเก่ายังทำงานได้ การปรับปรุงส่วนใหญ่จึงถูกปิดไว้เป็นค่าเริ่มต้น ผู้ใช้ต้องเปิดใช้งานผ่าน directive พิเศษที่เรียกว่า `"use strict"`
 
 ## "use strict"
 
-The directive looks like a string: `"use strict"` or `'use strict'`. When it is located at the top of a script, the whole script works the "modern" way.
+Directive จะมีลักษณะคล้ายสตริง: `"use strict"` หรือ `'use strict'` เมื่อวางไว้ที่ต้นสคริปต์ ทั้งสคริปต์จะทำงานในโหมด "สมัยใหม่"
 
-For example:
+ตัวอย่างเช่น:
 
 ```js
 "use strict";
 
-// this code works the modern way
+// โค้ดนี้จะทำงานในโหมดสมัยใหม่
 ...
 ```
 
-Quite soon we're going to learn functions (a way to group commands), so let's note in advance that `"use strict"` can be put at the beginning of a function. Doing that enables strict mode in that function only. But usually people use it for the whole script.
+เร็วๆ นี้เราจะได้เรียนรู้เรื่องฟังก์ชัน (การจัดกลุ่มคำสั่ง) ดังนั้นจึงขอบอกไว้ก่อนว่า `"use strict"` สามารถวางไว้ในฟังก์ชันได้ มันจะเปิดใช้งานโหมดเข้มงวดเฉพาะในฟังก์ชันนั้นเท่านั้น แต่โดยทั่วไปแล้วผู้คนจะใช้มันกับทั้งสคริปต์
 
-````warn header="Ensure that \"use strict\" is at the top"
-Please make sure that `"use strict"` is at the top of your scripts, otherwise strict mode may not be enabled.
+````warn header="ตรวจสอบให้แน่ใจว่า \"use strict\" อยู่ที่ต้นสคริปต์"
+โปรดตรวจสอบให้แน่ใจว่า `"use strict"` อยู่ด้านบนสุดของสคริปต์ ไม่เช่นนั้นโหมดเข้มงวดอาจไม่ถูกเปิดใช้งาน
 
-Strict mode isn't enabled here:
+ดังเช่นในตัวอย่างนี้ โหมดเข้มงวดจะไม่ทำงาน:
 
 ```js no-strict
 alert("some code");
-// "use strict" below is ignored--it must be at the top
+// "use strict" ด้านล่างถูกเพิกเฉย -- ต้องอยู่บรรทัดบนสุด
 
 "use strict";
 
-// strict mode is not activated
+// โหมดเข้มงวดยังไม่เปิดใช้งาน
 ```
 
-Only comments may appear above `"use strict"`.
+มีเพียงคอมเมนต์เท่านั้นที่สามารถปรากฏขึ้นเหนือ `"use strict"` ได้
 ````
 
-```warn header="There's no way to cancel `use strict`"
-There is no directive like `"no use strict"` that reverts the engine to old behavior.
+```warn header="ไม่มีทางยกเลิก `use strict`"
+ไม่มี directive อย่างเช่น `"no use strict"` ที่จะทำให้เอนจินย้อนกลับไปใช้พฤติกรรมแบบเก่า
 
-Once we enter strict mode, there's no going back.
+เมื่อเราเข้าสู่โหมดเข้มงวดแล้ว ก็ไม่มีทางย้อนกลับได้อีก
 ```
 
-## Browser console
+## คอนโซลเบราว์เซอร์
 
-When you use a [developer console](info:devtools) to run code, please note that it doesn't `use strict` by default.
+เมื่อคุณใช้ [คอนโซลนักพัฒนา](info:devtools) ในการรันโค้ด โปรดสังเกตว่ามันไม่ได้ `use strict` โดยค่าเริ่มต้น
 
-Sometimes, when `use strict` makes a difference, you'll get incorrect results.
+ในบางครั้ง เมื่อ `use strict` มีผลแตกต่างออกไป คุณอาจได้ผลลัพธ์ที่ไม่ถูกต้อง 
 
-So, how to actually `use strict` in the console?
+แล้วจะใช้ `use strict` ในคอนโซลได้อย่างไร?
 
-First, you can try to press `key:Shift+Enter` to input multiple lines, and put `use strict` on top, like this:
+ก่อนอื่น คุณสามารถลองใช้ `key:Shift+Enter` เพื่อป้อนหลายบรรทัด แล้ววาง `use strict` ไว้ด้านบน แบบนี้:
 
 ```js
-'use strict'; <Shift+Enter for a newline>
-//  ...your code
-<Enter to run>
+'use strict'; <Shift+Enter สำหรับขึ้นบรรทัดใหม่>
+//  ...โค้ดของคุณ
+<Enter เพื่อรันโค้ด>
 ```
 
-It works in most browsers, namely Firefox and Chrome.
+วิธีนี้ใช้ได้กับเบราว์เซอร์ส่วนใหญ่ เช่น Firefox และ Chrome
 
-If it doesn't, e.g. in an old browser, there's an ugly, but reliable way to ensure `use strict`. Put it inside this kind of wrapper:
+ถ้าไม่ได้ผล เช่นในเบราว์เซอร์รุ่นเก่า มีอีกทางที่อาจดูไม่สวยงามแต่ใช้งานได้ นั่นคือให้ห่อหุ้มมันด้วยฟังก์ชันแบบนี้:
 
 ```js
 (function() {
@@ -72,18 +72,18 @@ If it doesn't, e.g. in an old browser, there's an ugly, but reliable way to ensu
 })()
 ```
 
-## Should we "use strict"?
+## เราควรใช้ "use strict" หรือไม่?
 
-The question may sound obvious, but it's not so.
+คำถามอาจดูชัดเจน แต่จริงๆ แล้วไม่ได้ชัดเจนขนาดนั้น
 
-One could recommend to start scripts with `"use strict"`... But you know what's cool?
+ถ้าสอบถามความเห็นผู้อื่น บางคนอาจแนะนำให้เริ่มสคริปต์ทุกตัวด้วย `"use strict"`... แต่คุณรู้อะไรมั้ย? มีเรื่องที่น่าสนใจกว่านั้น
 
-Modern JavaScript supports "classes" and "modules" - advanced language structures (we'll surely get to them), that enable `use strict` automatically. So we don't need to add the `"use strict"` directive, if we use them.
+JavaScript สมัยใหม่รองรับ "classes" และ "modules" - โครงสร้างขั้นสูงของภาษา (เราจะต้องได้เรียนแน่นอน) ซึ่งจะเปิดใช้งาน `use strict` โดยอัตโนมัติ ดังนั้นเราจึงไม่จำเป็นต้องเพิ่ม directive `"use strict"` เองเมื่อใช้คุณสมบัติเหล่านี้
 
-**So, for now `"use strict";` is a welcome guest at the top of your scripts. Later, when your code is all in classes and modules, you may omit it.**
+**ดังนั้น ตอนนี้ `"use strict"` คือส่วนเสริมที่ดีที่ควรใส่ไว้ต้นสคริปต์ แต่ในอนาคตเมื่อโค้ดทั้งหมดถูกเขียนเป็น classes และ modules เราก็อาจละมันไปได้**
 
-As of now, we've got to know about `use strict` in general.
+ถึงตอนนี้เราก็ได้มีความรู้เบื้องต้นเกี่ยวกับ `use strict` แล้ว
 
-In the next chapters, as we learn language features, we'll see the differences between the strict and old modes. Luckily, there aren't many and they actually make our lives better.
+ในบทต่อๆ ไป เมื่อเราเรียนรู้คุณสมบัติต่างๆ ของภาษา เราจะเห็นความแตกต่างระหว่างโหมดเข้มงวดและโหมดปกติ โชคดีที่มันไม่ได้แตกต่างกันมากนัก และจริงๆ แล้วโหมดเข้มงวดทำให้ชีวิตเราสะดวกขึ้นด้วยซ้ำ
 
-All examples in this tutorial assume strict mode unless (very rarely) specified otherwise.
+ทุกตัวอย่างโค้ดในบทเรียนนี้จะถือว่าใช้โหมดเข้มงวด ยกเว้น (ซึ่งพบได้น้อยมาก) ที่ระบุเป็นอย่างอื่น
diff --git a/1-js/02-first-steps/04-variables/1-hello-variables/solution.md b/1-js/02-first-steps/04-variables/1-hello-variables/solution.md
index 9249e1c84..d2b9ca9ff 100644
--- a/1-js/02-first-steps/04-variables/1-hello-variables/solution.md
+++ b/1-js/02-first-steps/04-variables/1-hello-variables/solution.md
@@ -1,4 +1,4 @@
-In the code below, each line corresponds to the item in the task list.
+โค้ดด้านล่างจะสัมพันธ์กับ รายการใน task list
 
 ```js run
 let admin, name; // can declare two variables at once
diff --git a/1-js/02-first-steps/04-variables/1-hello-variables/task.md b/1-js/02-first-steps/04-variables/1-hello-variables/task.md
index 84f009e8c..564023a59 100644
--- a/1-js/02-first-steps/04-variables/1-hello-variables/task.md
+++ b/1-js/02-first-steps/04-variables/1-hello-variables/task.md
@@ -2,9 +2,9 @@ importance: 2
 
 ---
 
-# Working with variables
+# เล่นกับตัวแปร
 
-1. Declare two variables: `admin` and `name`.
-2. Assign the value `"John"` to `name`.
-3. Copy the value from `name` to `admin`.
-4. Show the value of `admin` using `alert` (must output "John").
+1. สร้างตัวแปรมาสองตัวชื่อ `admin` และ `name`
+2. กำหนดค่าให้ตัวแปรทั้งสองคือ `"John"` ไปที่ `name`
+3. คัดลอกค่าจาก `name` ไปที่ `admin`
+4. แสดงค่าที่เก็บใน `admin` โดยใช้ `alert` (ผลลัพธ์จะต้องออกมาเป็น "John")
diff --git a/1-js/02-first-steps/04-variables/2-declare-variables/solution.md b/1-js/02-first-steps/04-variables/2-declare-variables/solution.md
index 392f4e26f..5db98e945 100644
--- a/1-js/02-first-steps/04-variables/2-declare-variables/solution.md
+++ b/1-js/02-first-steps/04-variables/2-declare-variables/solution.md
@@ -1,21 +1,21 @@
-## The variable for our planet
+## ชื่อตัวแปรที่เก็บค่าดาวโลกไว้
 
-That's simple:
+ก็ง่ายมาก
 
 ```js
 let ourPlanetName = "Earth";
 ```
 
-Note, we could use a shorter name `planet`, but it might not be obvious what planet it refers to. It's nice to be more verbose. At least until the variable isNotTooLong.
+จำไว้ว่า ที่จริงเราควรใช้ชื่อที่สั้นอย่าง `planet` แต่ตัวแปรก็ยังไม่ชัดเจนว่าจะสื่อถึงดาวเคราะห์ดวงไหน เราจะตั้งชื่อให้ยาวไปอีกสักนิดเพื่อการสื่อความ ตราบใดที่ชื่อตัวแปรไม่ได้ isNotTooLong
 
-## The name of the current visitor
+## ชื่อตัวแปรที่เก็บชื่อผู้เยี่ยมชมเว็บไซต์ปัจจุบัน
 
 ```js
 let currentUserName = "John";
 ```
 
-Again, we could shorten that to `userName` if we know for sure that the user is current.
+ที่จริงเราจะควรใช้ชื่อที่สั้นกว่านี้ อย่างเช่น `userName` หากเรารู้แน่นอนว่านี่คือผู้ใช้คนปัจจุบัน
 
-Modern editors and autocomplete make long variable names easy to write. Don't save on them. A name with 3 words in it is fine.
+ใน editors ใหม่ๆ จะมาพร้อมกับฟีเจอร์ autocomplete ที่ไม่ต้องเสียเวลาพิมพ์ชื่อตัวแปรยาวๆ
 
-And if your editor does not have proper autocompletion, get [a new one](/code-editors).
+และหาก editors ที่คุณใช้ดูยังไม่มีฟีเจอร์นี้ เราขอแนะนำให้[หามาใช้สักตัว](/code-editors)
diff --git a/1-js/02-first-steps/04-variables/2-declare-variables/task.md b/1-js/02-first-steps/04-variables/2-declare-variables/task.md
index f364badf4..dcb077d96 100644
--- a/1-js/02-first-steps/04-variables/2-declare-variables/task.md
+++ b/1-js/02-first-steps/04-variables/2-declare-variables/task.md
@@ -2,7 +2,7 @@ importance: 3
 
 ---
 
-# Giving the right name
+# จงมอบนามที่ถูกต้อง
 
-1. Create a variable with the name of our planet. How would you name such a variable?
-2. Create a variable to store the name of a current visitor to a website. How would you name that variable?
+1. จะตั้งชื่อตัวแปรที่เก็บค่า "Earth" ไว้ว่าอะไรดี
+2. จะตั้งชื่อตัวแปรที่เก็บชื่อผู้เยี่ยมชมเว็บไซต์ตอนนี้ว่าอะไรดี
diff --git a/1-js/02-first-steps/04-variables/3-uppercast-constant/solution.md b/1-js/02-first-steps/04-variables/3-uppercast-constant/solution.md
index acd643fde..c35e5e902 100644
--- a/1-js/02-first-steps/04-variables/3-uppercast-constant/solution.md
+++ b/1-js/02-first-steps/04-variables/3-uppercast-constant/solution.md
@@ -1,5 +1,5 @@
-We generally use upper case for constants that are "hard-coded". Or, in other words, when the value is known prior to execution and directly written into the code.
+โดยปกติเราใช้ตัวพิมพ์ใหญ่สำหรับตัวแปรที่เก็บค่าคงที่ที่เป็น "ฮาร์ดโค้ด"
 
-In this code, `birthday` is exactly like that. So we could use the upper case for it.
+ในโค้ดนี้ตัวแปร `birthday` เก็บค่าวันเกิดเอาไว้ ซึ่งพิจารณาได้ว่าเป็น "ฮาร์ดโค้ด" เราเลยใช้ชื่อตัวแปรเป็นตัวพิมพ์ใหญ่
 
-In contrast, `age` is evaluated in run-time. Today we have one age, a year after we'll have another one. It is constant in a sense that it does not change through the code execution. But it is a bit "less of a constant" than `birthday`: it is calculated, so we should keep the lower case for it.
+แต่ตัวแปร `age` จะมีค่าก็ต่อเมื่อโค้ดนี้ทำงาน โดยปีนี้เราจะได้อายุค่าหนึ่ง ปีหน้าก็เป็นอีกค่าหนึ่ง เนื่องจากตัวแปร `age` จะมีค่าหลังจากถูกคำนวณแล้ว ในแง่ความเป็นค่าคงที่แล้ว จึงมีความเป็นค่าคงที่น้อยกว่าตัวแปร `birthday`   
diff --git a/1-js/02-first-steps/04-variables/3-uppercast-constant/task.md b/1-js/02-first-steps/04-variables/3-uppercast-constant/task.md
index f3c208a74..85653e80e 100644
--- a/1-js/02-first-steps/04-variables/3-uppercast-constant/task.md
+++ b/1-js/02-first-steps/04-variables/3-uppercast-constant/task.md
@@ -2,9 +2,9 @@ importance: 4
 
 ---
 
-# Uppercase const?
+# const แบบพิมพ์ใหญ่
 
-Examine the following code:
+ลองพิจารณาจากโค้ดดังต่อไปนี้
 
 ```js
 const birthday = '18.04.1982';
@@ -12,11 +12,15 @@ const birthday = '18.04.1982';
 const age = someCode(birthday);
 ```
 
+<<<<<<< HEAD
+เรามีตัวแปร `birthday` และ `age` ที่จะถูกคำนวณจากค่าเริ่มต้นอย่าง `birthday` ด้วยความช่วยเหลือจากฟังก์ชั่น `someCode` (ในตอนนี้ยังไม่ต้องรู้จักฟังก์ชั่น เพราะยังไม่ใช่ประเด็นในตอนนี้)
+=======
 Here we have a constant `birthday` for the date, and also the `age` constant.
 
 The `age` is calculated from `birthday` using `someCode()`, which means a function call that we didn't explain yet (we will soon!), but the details don't matter here, the point is that `age` is calculated somehow based on the `birthday`.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-Would it be right to use upper case for `birthday`? For `age`? Or even for both?
+จะให้ชื่อตัวแปรไหนเป็น ตัวพิมพ์เล็ก หรือ ตัวใหญ่ดีตัวแปร `birthday` ดีไหม? หรือตัวแปร `age` หรือจะทั้งคู่ดีละ
 
 ```js
 const BIRTHDAY = '18.04.1982'; // make birthday uppercase?
diff --git a/1-js/02-first-steps/04-variables/article.md b/1-js/02-first-steps/04-variables/article.md
index e91d0ea7e..2fb1ff063 100644
--- a/1-js/02-first-steps/04-variables/article.md
+++ b/1-js/02-first-steps/04-variables/article.md
@@ -1,274 +1,326 @@
-# Variables
+# ตัวแปร
 
-Most of the time, a JavaScript application needs to work with information. Here are two examples:
-1. An online shop -- the information might include goods being sold and a shopping cart.
-2. A chat application -- the information might include users, messages, and much more.
+ในการพัฒนาแอปพลิเคชัน JavaScript ส่วนใหญ่ เรามักจะต้องทำงานกับข้อมูล ยกตัวอย่างเช่น
+1. ร้านค้าออนไลน์ -- ข้อมูลอาจประกอบด้วยสินค้าที่จำหน่ายและตะกร้าสินค้า
+2. แอปพลิเคชันแชท -- ข้อมูลอาจประกอบด้วยผู้ใช้ ข้อความ และอื่นๆ อีกมากมาย
 
-Variables are used to store this information.
+ตัวแปรถูกใช้เพื่อจัดเก็บข้อมูลเหล่านี้
 
-## A variable
+## ตัวแปรคืออะไร
 
-A [variable](https://en.wikipedia.org/wiki/Variable_(computer_science)) is a "named storage" for data. We can use variables to store goodies, visitors, and other data.
+[ตัวแปร](https://en.wikipedia.org/wiki/Variable_(computer_science)) คือ "พื้นที่จัดเก็บข้อมูลที่มีชื่อกำกับ" เราสามารถใช้ตัวแปรเพื่อเก็บสินค้า ข้อมูลผู้เยี่ยมชม และข้อมูลอื่นๆ ได้
 
-To create a variable in JavaScript, use the `let` keyword.
+ในการสร้างตัวแปรใน JavaScript ให้ใช้คีย์เวิร์ด `let`
 
-The statement below creates (in other words: *declares*) a variable with the name "message":
+คำสั่งด้านล่างจะสร้าง (หรือที่เรียกอีกอย่างว่า *ประกาศ*) ตัวแปรที่มีชื่อว่า "message":
 
 ```js
 let message;
 ```
 
-Now, we can put some data into it by using the assignment operator `=`:
+ตอนนี้เราสามารถใส่ข้อมูลลงในตัวแปรได้ด้วยการใช้เครื่องหมาย `=` หรือที่เรียกว่าตัวดำเนินการกำหนดค่า (assignment operator):
 
 ```js
 let message;
 
 *!*
-message = 'Hello'; // store the string 'Hello' in the variable named message
+message = 'สวัสดี'; // เก็บข้อความ 'สวัสดี' ในตัวแปรที่ชื่อว่า message
 */!*
 ```
 
-The string is now saved into the memory area associated with the variable. We can access it using the variable name:
+ข้อความนี้จะถูกบันทึกลงในพื้นที่หน่วยความจำที่สัมพันธ์กับตัวแปร และเราสามารถเข้าถึงข้อมูลนี้ได้ด้วยการอ้างอิงชื่อตัวแปร:
 
 ```js run
 let message;
-message = 'Hello!';
+message = 'สวัสดี!';
 
 *!*
-alert(message); // shows the variable content
+alert(message); // แสดงค่าในตัวแปร
 */!*
 ```
 
-To be concise, we can combine the variable declaration and assignment into a single line:
+เพื่อความกระชับ เราสามารถรวมการประกาศตัวแปรและกำหนดค่าเริ่มต้นไว้ในบรรทัดเดียวกันได้:
 
 ```js run
-let message = 'Hello!'; // define the variable and assign the value
+let message = 'สวัสดี!'; // ประกาศตัวแปรและกำหนดค่าในคำสั่งเดียว
 
-alert(message); // Hello!
+alert(message); // สวัสดี!
 ```
 
-We can also declare multiple variables in one line:
+นอกจากนี้ เรายังสามารถประกาศตัวแปรหลายตัวในบรรทัดเดียวได้ด้วย:
 
 ```js no-beautify
-let user = 'John', age = 25, message = 'Hello';
+let user = 'จอห์น', age = 25, message = 'สวัสดี';
 ```
 
-That might seem shorter, but we don't recommend it. For the sake of better readability, please use a single line per variable.
+วิธีนี้อาจจะดูสั้นกระชับดี แต่เราไม่แนะนำให้ใช้ เพื่อความสะดวกในการอ่านโค้ด ควรประกาศตัวแปรแต่ละตัวแยกเป็นคนละบรรทัดจะดีกว่า
 
-The multiline variant is a bit longer, but easier to read:
+แบบนี้อาจยาวกว่าเล็กน้อย แต่อ่านง่ายขึ้นมาก:
 
 ```js
-let user = 'John';
+let user = 'จอห์น';
 let age = 25;
-let message = 'Hello';
+let message = 'สวัสดี';
 ```
 
+<<<<<<< HEAD
+บางคนยังชอบประกาศตัวแปรหลายตัวแบบหลายบรรทัดแบบนี้:
+=======
 Some people also define multiple variables in this multiline style:
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
 ```js no-beautify
-let user = 'John',
+let user = 'จอห์น',
   age = 25,
-  message = 'Hello';
+  message = 'สวัสดี';
 ```
 
-...Or even in the "comma-first" style:
+หรือแม้กระทั่งเขียนในรูปแบบ "เริ่มต้นด้วยเครื่องหมายจุลภาค":
 
 ```js no-beautify
-let user = 'John'
+let user = 'จอห์น'
   , age = 25
-  , message = 'Hello';
+  , message = 'สวัสดี';
 ```
 
-Technically, all these variants do the same thing. So, it's a matter of personal taste and aesthetics.
+ในเชิงเทคนิคแล้ว ตัวแปรทั้งหมดที่ยกตัวอย่างมาทำงานในลักษณะเดียวกัน จึงเป็นเรื่องของรสนิยมและความชอบส่วนตัว
 
-````smart header="`var` instead of `let`"
-In older scripts, you may also find another keyword: `var` instead of `let`:
+````smart header="`var` กับ `let`"
+ในสคริปต์เก่าๆ คุณอาจเจอการใช้คีย์เวิร์ด `var` แทน `let` ในการประกาศตัวแปร:
 
 ```js
-*!*var*/!* message = 'Hello';
+*!*var*/!* message = 'สวัสดี';
 ```
 
+<<<<<<< HEAD
+คีย์เวิร์ด `var` นั้น*เกือบจะ*เหมือนกับ `let` คือใช้ประกาศตัวแปร แต่จะมีความแตกต่างเล็กน้อยในสไตล์ที่ค่อนข้าง "เชย"
+
+ความแตกต่างระหว่าง `let` กับ `var` นั้นไม่ใช่ประเด็นสำคัญสำหรับเราในตอนนี้ เราจะกล่าวถึงรายละเอียดในบทเรียน <info:var>
+
+โดยทั่วไปแล้ว ในโค้ด JavaScript สมัยใหม่เรามักใช้ `let` ในการประกาศตัวแปร ส่วนการใช้ `var` ถือเป็นวิธีการแบบเดิมที่ปัจจุบันไม่เป็นที่นิยมแล้ว
+=======
 The `var` keyword is *almost* the same as `let`. It also declares a variable but in a slightly different, "old-school" way.
 
 There are subtle differences between `let` and `var`, but they do not matter to us yet. We'll cover them in detail in the chapter <info:var>.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 ````
 
-## A real-life analogy
+# การเปรียบเทียบกับสถานการณ์ในชีวิตจริง
 
-We can easily grasp the concept of a "variable" if we imagine it as a "box" for data, with a uniquely-named sticker on it.
+เราสามารถเข้าใจแนวคิดของ "ตัวแปร" ได้ง่ายขึ้น ถ้าลองนึกภาพว่ามันเป็น "กล่อง" ไว้ใส่ข้อมูล โดยมีสติกเกอร์ชื่อเฉพาะติดอยู่
 
+<<<<<<< HEAD
+ยกตัวอย่างเช่น ตัวแปร `message` จะเปรียบได้กับกล่องที่มีป้ายชื่อ `"message"` และมีค่า `"สวัสดี!"` ข้างใน:
+=======
 For instance, the variable `message` can be imagined as a box labelled `"message"` with the value `"Hello!"` in it:
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
 ![](variable.svg)
 
-We can put any value in the box.
+เราสามารถใส่ค่าอะไรก็ได้ลงในกล่องนี้ 
 
+และเปลี่ยนค่าได้ตามใจชอบ:
+
+<<<<<<< HEAD
+=======
 We can also change it as many times as we want:
 
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 ```js run
 let message;
 
-message = 'Hello!';
+message = 'สวัสดี!';
 
-message = 'World!'; // value changed
+message = 'ชาวโลก!'; // เปลี่ยนค่าแล้ว
 
 alert(message);
 ```
 
-When the value is changed, the old data is removed from the variable:
+เวลาเปลี่ยนค่า ข้อมูลเก่าจะถูกนำออกจากตัวแปรไป: 
 
 ![](variable-change.svg)
 
-We can also declare two variables and copy data from one into the other.
+นอกจากนี้ เรายังสามารถประกาศตัวแปรสองตัว แล้วคัดลอกข้อมูลจากตัวหนึ่งไปอีกตัวหนึ่งได้ด้วย
 
 ```js run
-let hello = 'Hello world!';
+let hello = 'สวัสดีชาวโลก!';
 
 let message;
 
 *!*
-// copy 'Hello world' from hello into message
+// คัดลอก 'สวัสดีชาวโลก!' จาก hello มาเก็บใน message
 message = hello;
 */!*
 
-// now two variables hold the same data
-alert(hello); // Hello world!
-alert(message); // Hello world!
+// ตอนนี้ตัวแปรทั้งสองมีข้อมูลชุดเดียวกัน
+alert(hello); // สวัสดีชาวโลก!
+alert(message); // สวัสดีชาวโลก!
 ```
 
-````warn header="Declaring twice triggers an error"
-A variable should be declared only once.
+````warn header="การประกาศตัวแปรซ้ำจะเกิดข้อผิดพลาด"
+ควรประกาศตัวแปรเพียงครั้งเดียวเท่านั้น 
 
-A repeated declaration of the same variable is an error:
+หากประกาศตัวแปรเดิมซ้ำอีก จะถือเป็นข้อผิดพลาด:
 
 ```js run
-let message = "This";
+let message = "นี่";
 
-// repeated 'let' leads to an error
-let message = "That"; // SyntaxError: 'message' has already been declared
+// ประกาศ 'let' ซ้ำ ทำให้เกิด error
+let message = "นั่น"; // SyntaxError: 'message' ถูกประกาศไปแล้ว
 ```
-So, we should declare a variable once and then refer to it without `let`.
+
+ดังนั้น เราควรประกาศตัวแปรแค่ครั้งเดียว จากนั้นก็อ้างอิงถึงมันได้เลยโดยไม่ต้องมี `let` อีก
 ````
 
+<<<<<<< HEAD
+```smart header="ภาษาการเขียนโปรแกรมแบบฟังก์ชัน"
+น่าสนใจว่า มีภาษาโปรแกรมที่เรียกว่า [ฟังก์ชันเชิงบริสุทธิ์](https://en.wikipedia.org/wiki/Purely_functional_programming) เช่น [Haskell](https://en.wikipedia.org/wiki/Haskell) ซึ่งห้ามไม่ให้เปลี่ยนค่าตัวแปรเด็ดขาด
+=======
 ```smart header="Functional languages"
 It's interesting to note that there exist so-called [pure functional](https://en.wikipedia.org/wiki/Purely_functional_programming) programming languages, such as [Haskell](https://en.wikipedia.org/wiki/Haskell), that forbid changing variable values.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-In such languages, once the value is stored "in the box", it's there forever. If we need to store something else, the language forces us to create a new box (declare a new variable). We can't reuse the old one.
+ในภาษาเหล่านี้ เมื่อเก็บค่าใส่ "กล่อง" ไปแล้ว มันจะอยู่ในนั้นตลอดกาล หากต้องการเก็บข้อมูลอย่างอื่น ภาษาจะบังคับให้เราต้องสร้างกล่องใหม่ (ประกาศตัวแปรใหม่) จะนำกล่องเก่ามาใช้ใหม่ไม่ได้ 
 
+<<<<<<< HEAD
+ถึงแม้พอแรกอาจฟังดูแปลกๆ แต่ภาษาพวกนี้ก็มีความสามารถในการพัฒนาโปรแกรมจริงจังได้นะ ยิ่งไปกว่านั้น ในบางด้านอย่างการประมวลผลแบบขนาน ข้อจำกัดนี้กลับให้ประโยชน์บางอย่างเสียด้วยซ้ำ
+=======
 Though it may seem a little odd at first sight, these languages are quite capable of serious development. More than that, there are areas like parallel computations where this limitation confers certain benefits.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 ```
 
-## Variable naming [#variable-naming]
+## การตั้งชื่อตัวแปร [#variable-naming]
 
-There are two limitations on variable names in JavaScript:
+ในภาษา JavaScript มีข้อจำกัด 2 ประการในการตั้งชื่อตัวแปร:
 
-1. The name must contain only letters, digits, or the symbols `$` and `_`.
-2. The first character must not be a digit.
+1. ชื่อต้องประกอบด้วยตัวอักษร ตัวเลข หรือสัญลักษณ์ `$` และ `_` เท่านั้น
+2. ตัวอักษรตัวแรกต้องไม่ใช่ตัวเลข
 
-Examples of valid names:
+ตัวอย่างชื่อที่ใช้ได้:
 
 ```js
 let userName;
 let test123;
 ```
 
-When the name contains multiple words, [camelCase](https://en.wikipedia.org/wiki/CamelCase) is commonly used. That is: words go one after another, each word except first starting with a capital letter: `myVeryLongName`.
+เมื่อชื่อประกอบด้วยหลายคำ มักนิยมใช้รูปแบบ [camelCase](https://en.wikipedia.org/wiki/CamelCase) นั่นคือเขียนคำต่อกันเรื่อยๆ โดยขึ้นต้นคำแรกด้วยตัวพิมพ์เล็ก ส่วนคำถัดๆ ไปให้ขึ้นต้นด้วยตัวพิมพ์ใหญ่ เช่น `myVeryLongName`
 
-What's interesting -- the dollar sign `'$'` and the underscore `'_'` can also be used in names. They are regular symbols, just like letters, without any special meaning.
+ที่น่าสนใจคือ เครื่องหมายดอลลาร์ `'$'` และอันเดอร์สกอร์ `'_'` ก็สามารถใช้เป็นส่วนหนึ่งของชื่อได้ โดยมันเป็นแค่สัญลักษณ์ธรรมดาเหมือนตัวอักษร ไม่ได้มีความหมายพิเศษอะไร
 
-These names are valid:
+ชื่อเหล่านี้ใช้ได้:
 
 ```js run untrusted
-let $ = 1; // declared a variable with the name "$"
-let _ = 2; // and now a variable with the name "_"
+let $ = 1; // ประกาศตัวแปรชื่อ "$"
+let _ = 2; // และนี่ตัวแปรชื่อ "_"
 
 alert($ + _); // 3
 ```
 
-Examples of incorrect variable names:
+ตัวอย่างชื่อตัวแปรที่ใช้ไม่ได้:
 
 ```js no-beautify
-let 1a; // cannot start with a digit
+let 1a; // ห้ามขึ้นต้นด้วยตัวเลข
 
-let my-name; // hyphens '-' aren't allowed in the name
+let my-name; // เครื่องหมายขีด '-' ไม่อนุญาตให้ใช้ในชื่อ
 ```
 
+<<<<<<< HEAD
+```smart header="ตัวพิมพ์ใหญ่-เล็กมีผล"
+ตัวแปร `apple` กับ `APPLE` ถือเป็นคนละตัวกัน
+```
+
+```smart header="อักษรที่ไม่ใช่ภาษาอังกฤษใช้ได้ แต่ไม่แนะนำ"
+เราสามารถใช้ภาษาอื่นๆ ได้ รวมถึงอักษรภาษารัสเซีย อักษรจีน หรืออื่นๆ เช่น:
+=======
 ```smart header="Case matters"
 Variables named `apple` and `APPLE` are two different variables.
 ```
 
 ````smart header="Non-Latin letters are allowed, but not recommended"
 It is possible to use any language, including Cyrillic letters, Chinese logograms and so on, like this:
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
 ```js
 let имя = '...';
 let 我 = '...';
 ```
 
+<<<<<<< HEAD
+ในทางเทคนิคแล้ว ตัวอย่างข้างบนไม่มีข้อผิดพลาด การตั้งชื่อแบบนั้นใช้ได้ แต่เรามีข้อตกลงสากลว่าควรใช้ภาษาอังกฤษในการตั้งชื่อตัวแปร เพราะถึงแม้จะเป็นสคริปต์สั้นๆ แต่ก็อาจจะมีชีวิตอยู่ได้นานมาก และในอนาคตอาจมีคนจากประเทศอื่นจำเป็นต้องเข้ามาอ่านมันก็เป็นได้
+```
+=======
 Technically, there is no error here. Such names are allowed, but there is an international convention to use English in variable names. Even if we're writing a small script, it may have a long life ahead. People from other countries may need to read it sometime.
 ````
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-````warn header="Reserved names"
-There is a [list of reserved words](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#Keywords), which cannot be used as variable names because they are used by the language itself.
+```warn header="ชื่อที่สงวนไว้"
+มี[รายการคำสงวน](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#Keywords) ที่ไม่อนุญาตให้นำมาตั้งเป็นชื่อตัวแปร เพราะมันถูกสงวนไว้ใช้โดยตัวภาษาเอง
 
-For example: `let`, `class`, `return`, and `function` are reserved.
+ตัวอย่างเช่น: `let`, `class`, `return` และ `function` เป็นคำสงวน
 
-The code below gives a syntax error:
+โค้ดด้านล่างจะเกิด syntax error:
 
 ```js run no-beautify
-let let = 5; // can't name a variable "let", error!
-let return = 5; // also can't name it "return", error!
+let let = 5; // ไม่สามารถตั้งชื่อตัวแปรว่า "let" เพราะเป็นคำสงวน เกิด error!
+let return = 5; // เช่นเดียวกัน ห้ามตั้งชื่อเป็น "return" เกิด error!
+```
 ```
-````
 
-````warn header="An assignment without `use strict`"
+```warn header="การกำหนดค่าโดยไม่ใช้ `use strict`"
 
-Normally, we need to define a variable before using it. But in the old times, it was technically possible to create a variable by a mere assignment of the value without using `let`. This still works now if we don't put `use strict` in our scripts to maintain compatibility with old scripts.
+โดยปกติแล้วเราต้องประกาศตัวแปรก่อนใช้งาน แต่ในสมัยก่อนมีช่องโหว่ทางเทคนิคที่ทำให้สร้างตัวแปรได้โดยแค่กำหนดค่าให้มันเลย โดยไม่ต้องใช้ `let` ซึ่งยังคงใช้ได้อยู่ในปัจจุบันหากไม่ใส่ `use strict` ลงในสคริปต์ เพื่อรักษาความเข้ากันได้กับสคริปต์เก่าๆ 
 
 ```js run no-strict
-// note: no "use strict" in this example
+// หมายเหตุ: ไม่มีการใช้ "use strict" ในตัวอย่างนี้
 
-num = 5; // the variable "num" is created if it didn't exist
+num = 5; // ถ้าไม่มีตัวแปร "num" มันจะถูกสร้างขึ้นโดยอัตโนมัติ
 
 alert(num); // 5
 ```
 
-This is a bad practice and would cause an error in strict mode:
+วิธีนี้ถือเป็นแนวปฏิบัติที่ไม่ดี และจะเกิดข้อผิดพลาดในโหมดเข้มงวด (strict mode):
 
 ```js
 "use strict";
 
 *!*
-num = 5; // error: num is not defined
+num = 5; // error: ตัวแปร num ไม่ได้ถูกประกาศไว้ก่อน
 */!*
 ```
-````
 
-## Constants
+## ค่าคงที่ (Constants)
 
-To declare a constant (unchanging) variable, use `const` instead of `let`:
+เพื่อประกาศตัวแปรค่าคงที่ (ไม่เปลี่ยนแปลงค่า) ให้ใช้ `const` แทน `let`:
 
 ```js
 const myBirthday = '18.04.1982';
 ```
 
-Variables declared using `const` are called "constants". They cannot be reassigned. An attempt to do so would cause an error:
+ตัวแปรที่ประกาศด้วย `const` จะเรียกว่า "ค่าคงที่" ซึ่งไม่สามารถกำหนดค่าใหม่ได้ หากพยายามทำเช่นนั้นจะเกิดข้อผิดพลาด:
 
 ```js run
 const myBirthday = '18.04.1982';
 
-myBirthday = '01.01.2001'; // error, can't reassign the constant!
+myBirthday = '01.01.2001'; // error เพราะไม่สามารถกำหนดค่าใหม่ให้ค่าคงที่ได้!
 ```
 
+<<<<<<< HEAD
+เมื่อโปรแกรมเมอร์มั่นใจว่าตัวแปรจะไม่มีวันเปลี่ยนแปลงค่า ก็สามารถประกาศเป็นค่าคงที่ด้วย `const` เพื่อการันตีและสื่อสารข้อเท็จจริงดังกล่าวให้ทุกคนรับทราบ
+
+### ค่าคงที่ที่เขียนด้วยตัวพิมพ์ใหญ่
+=======
 When a programmer is sure that a variable will never change, they can declare it with `const` to guarantee and communicate that fact to everyone.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-### Uppercase constants
+ในทางปฏิบัติ มักนิยมใช้ค่าคงที่เป็นนามแทนสำหรับค่าที่จำยาก ซึ่งทราบค่าตายตัวก่อนการประมวลผลโปรแกรมแล้ว
 
+<<<<<<< HEAD
+ค่าคงที่ลักษณะนี้มักตั้งชื่อโดยใช้ตัวพิมพ์ใหญ่และอันเดอร์สกอร์
+=======
 There is a widespread practice to use constants as aliases for difficult-to-remember values that are known before execution.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-Such constants are named using capital letters and underscores.
-
-For instance, let's make constants for colors in so-called "web" (hexadecimal) format:
+ยกตัวอย่างเช่น ลองสร้างค่าคงที่แทนรหัสสีในฟอร์แมต "web" (เขียนเป็นเลขฐานสิบหก):
 
 ```js run
 const COLOR_RED = "#F00";
@@ -276,70 +328,96 @@ const COLOR_GREEN = "#0F0";
 const COLOR_BLUE = "#00F";
 const COLOR_ORANGE = "#FF7F00";
 
-// ...when we need to pick a color
+// เมื่อต้องการเลือกสีใดสีหนึ่ง
 let color = COLOR_ORANGE;
 alert(color); // #FF7F00
 ```
 
-Benefits:
+ข้อดี:
 
-- `COLOR_ORANGE` is much easier to remember than `"#FF7F00"`.
-- It is much easier to mistype `"#FF7F00"` than `COLOR_ORANGE`.
-- When reading the code, `COLOR_ORANGE` is much more meaningful than `#FF7F00`.
+- `COLOR_ORANGE` จำได้ง่ายกว่า `"#FF7F00"` มาก
+- พิมพ์ผิดเป็น `"#FF7F00"` ได้ง่ายกว่า `COLOR_ORANGE`
+- เวลาอ่านโค้ด `COLOR_ORANGE` สื่อความหมายได้ชัดเจนกว่า `#FF7F00`
 
-When should we use capitals for a constant and when should we name it normally? Let's make that clear.
+แล้วเราควรใช้ตัวพิมพ์ใหญ่กับค่าคงที่เมื่อไหร่ และควรตั้งชื่อปกติเมื่อไหร่? ลองมาทำความเข้าใจกัน
 
+<<<<<<< HEAD
+คำว่า "ค่าคงที่" หมายถึงค่าของตัวแปรจะไม่มีวันเปลี่ยนแปลงเท่านั้น แต่ค่าคงที่บางตัวเป็นที่รู้จักก่อนการประมวลผล (เช่นค่าฐานสิบหกของสีแดง) ส่วนค่าคงที่อีกประเภทคือถูก*คำนวณ*ระหว่างรันไทม์ ในช่วงการประมวลผล แต่จะไม่เปลี่ยนแปลงหลังจากกำหนดค่าไปแล้ว
+
+ตัวอย่างเช่น:
+
+=======
 Being a "constant" just means that a variable's value never changes. But some constants are known before execution (like a hexadecimal value for red) and some constants are *calculated* in run-time, during the execution, but do not change after their initial assignment.
 
 For instance:
 
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 ```js
-const pageLoadTime = /* time taken by a webpage to load */;
+const pageLoadTime = /* เวลาที่ใช้ในการโหลดเว็บเพจ */;
 ```
 
+<<<<<<< HEAD
+ค่าของ `pageLoadTime` ไม่เป็นที่ทราบก่อนโหลดเพจ ดังนั้นจึงตั้งชื่อแบบปกติ แต่ถึงอย่างนั้นมันก็ยังเป็นค่าคงที่ เพราะไม่มีการเปลี่ยนแปลงค่าหลังจากกำหนดไปแล้ว
+
+หรือพูดอีกอย่างคือ ค่าคงที่ที่ตั้งชื่อด้วยตัวพิมพ์ใหญ่จะใช้เป็นเพียงแค่นามแทนสำหรับค่าที่ "ฮาร์ดโค้ด" เข้าไปโดยตรงเท่านั้น
+=======
 The value of `pageLoadTime` is not known before the page load, so it's named normally. But it's still a constant because it doesn't change after the assignment.
 
 In other words, capital-named constants are only used as aliases for "hard-coded" values.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
+
+## ตั้งชื่อให้ถูกต้อง
 
-## Name things right
+เมื่อพูดถึงตัวแปร มีอีกเรื่องสำคัญมากที่ต้องคำนึงถึง นั่นคือ
 
-Talking about variables, there's one more extremely important thing.
+ชื่อตัวแปรควรมีความหมายที่ชัดเจน เข้าใจง่าย สามารถอธิบายข้อมูลที่เก็บอยู่ภายในได้
 
-A variable name should have a clean, obvious meaning, describing the data that it stores.
+<<<<<<< HEAD
+การตั้งชื่อตัวแปรถือเป็นหนึ่งในทักษะที่สำคัญและซับซ้อนที่สุดในการเขียนโปรแกรม เพียงแค่กวาดตามองผ่านชื่อตัวแปร ก็สามารถบอกได้แล้วว่าโค้ดนั้นเขียนโดยมือใหม่หรือนักพัฒนาที่มีประสบการณ์
 
+ในโปรเจ็กต์จริง เรามักใช้เวลาส่วนใหญ่ไปกับการแก้ไขและต่อยอดโค้ดเดิมที่มีอยู่แล้ว มากกว่าการเขียนโค้ดใหม่ล้วนๆ จากศูนย์ เมื่อต้องย้อนกลับไปดูโค้ดหลังจากไปทำอย่างอื่นสักพัก การมีข้อมูลที่ตั้งชื่อตัวแปรไว้อย่างดีจะช่วยให้เราหาสิ่งที่ต้องการได้ง่ายขึ้นมาก หรือพูดอีกอย่างคือ เมื่อตัวแปรมีชื่อที่ดีนั่นเอง
+=======
 Variable naming is one of the most important and complex skills in programming. A glance at variable names can reveal which code was written by a beginner versus an experienced developer.
 
 In a real project, most of the time is spent modifying and extending an existing code base rather than writing something completely separate from scratch. When we return to some code after doing something else for a while, it's much easier to find information that is well-labelled. Or, in other words, when the variables have good names.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-Please spend time thinking about the right name for a variable before declaring it. Doing so will repay you handsomely.
+ดังนั้น ควรใช้เวลาคิดพิจารณาชื่อที่เหมาะสมให้ตัวแปร ก่อนที่จะประกาศใช้มัน การทำเช่นนี้จะคุ้มค่าเป็นอย่างมากในภายหลัง
 
-Some good-to-follow rules are:
+ต่อไปนี้คือกฎที่ควรนำไปปฏิบัติ:
 
+<<<<<<< HEAD
+- ใช้ชื่อที่มนุษย์อ่านเข้าใจได้ เช่น `userName` หรือ `shoppingCart`
+- หลีกเลี่ยงการใช้คำย่อหรือชื่อสั้นๆ อย่าง `a`, `b` หรือ `c` ยกเว้นว่าคุณมั่นใจว่ากำลังทำอะไรอยู่
+- ตั้งชื่อให้อธิบายได้ชัดเจนที่สุดและกระชับ ตัวอย่างชื่อที่ไม่ดี ได้แก่ `data` และ `value` เพราะไม่ได้สื่อความหมายอะไร ยกเว้นบริบทของโค้ดจะบ่งชี้ชัดว่าตัวแปรนั้นหมายถึงข้อมูลหรือค่าใด
+- ตกลงใช้ศัพท์เฉพาะกันภายในทีมและในใจของคุณเอง ถ้าเรียกผู้เยี่ยมชมเว็บว่า "user" เราก็ควรตั้งชื่อตัวแปรที่เกี่ยวข้องว่า `currentUser` หรือ `newUser` แทนที่จะเป็น `currentVisitor` หรือ `newManInTown`
+=======
 - Use human-readable names like `userName` or `shoppingCart`.
 - Stay away from abbreviations or short names like `a`, `b`, and `c`, unless you know what you're doing.
 - Make names maximally descriptive and concise. Examples of bad names are `data` and `value`. Such names say nothing. It's only okay to use them if the context of the code makes it exceptionally obvious which data or value the variable is referencing.
 - Agree on terms within your team and in your mind. If a site visitor is called a "user" then we should name related variables `currentUser` or `newUser` instead of `currentVisitor` or `newManInTown`.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-Sounds simple? Indeed it is, but creating descriptive and concise variable names in practice is not. Go for it.
+ฟังดูง่ายมั้ย แต่ในทางปฏิบัติ การสร้างชื่อตัวแปรที่สื่อความหมายและกระชับไม่ใช่เรื่องง่ายเลย ลองทำดูนะ
 
-```smart header="Reuse or create?"
-And the last note. There are some lazy programmers who, instead of declaring new variables, tend to reuse existing ones.
+```smart header="ใช้ซ้ำหรือสร้างใหม่"
+และอีกหนึ่งข้อสังเกต มีนักเขียนโปรแกรมบางส่วนที่ขี้เกียจ ชอบเอาตัวแปรที่มีอยู่แล้วมาใช้ซ้ำ แทนที่จะประกาศตัวแปรใหม่
 
-As a result, their variables are like boxes into which people throw different things without changing their stickers. What's inside the box now? Who knows? We need to come closer and check.
+ผลที่ได้ก็คือ ตัวแปรของพวกเขาจะเหมือนกล่องที่มีคนเอาของต่างๆ ใส่ลงไป โดยไม่เปลี่ยนป้ายข้างนอก แล้วตอนนี้ในกล่องมีอะไรบ้าง? ไม่มีใครรู้ ต้องเดินเข้าไปดูใกล้ๆ 
 
-Such programmers save a little bit on variable declaration but lose ten times more on debugging.
+โปรแกรมเมอร์พวกนี้อาจจะประหยัดการประกาศตัวแปรไปได้นิดหน่อย แต่กลับเสียเวลาดีบั๊กไปมากกว่าสิบเท่า
 
-An extra variable is good, not evil.
+การมีตัวแปรเพิ่มถือว่าดี ไม่ใช่เรื่องไม่ดี
 
-Modern JavaScript minifiers and browsers optimize code well enough, so it won't create performance issues. Using different variables for different values can even help the engine optimize your code.
+JavaScript minifier และเบราว์เซอร์สมัยใหม่ สามารถปรับแต่งโค้ดได้ดีพอที่จะไม่ก่อให้เกิดปัญหาด้านประสิทธิภาพ และการใช้ตัวแปรต่างกันเพื่อเก็บค่าที่ต่างกัน ยังช่วยให้เอนจินสามารถปรับแต่งโค้ดให้ดีขึ้นได้อีกด้วย
 ```
 
-## Summary
+## สรุป
 
-We can declare variables to store data by using the `var`, `let`, or `const` keywords.
+เราสามารถประกาศตัวแปรเพื่อเก็บข้อมูลโดยใช้คีย์เวิร์ด `var`, `let` หรือ `const`
 
-- `let` -- is a modern variable declaration.
-- `var` -- is an old-school variable declaration. Normally we don't use it at all, but we'll cover subtle differences from `let` in the chapter <info:var>, just in case you need them.
-- `const` -- is like `let`, but the value of the variable can't be changed.
+- `let` -- เป็นรูปแบบการประกาศตัวแปรแบบสมัยใหม่
+- `var` -- เป็นการประกาศตัวแปรแบบเก่า ปกติเราไม่ค่อยใช้แล้ว แต่เราจะกล่าวถึงความแตกต่างเล็กๆ น้อยๆ จาก `let` ในบทเรียน <info:var> ในกรณีที่คุณจำเป็นต้องใช้มัน
+- `const` -- คล้ายกับ `let` แต่ค่าของตัวแปรจะไม่สามารถเปลี่ยนแปลงได้
 
-Variables should be named in a way that allows us to easily understand what's inside them.
+ตัวแปรควรถูกตั้งชื่อในลักษณะที่ทำให้เราสามารถเข้าใจได้โดยง่าย ว่ามีข้อมูลอะไรถูกเก็บอยู่ภายใน
diff --git a/1-js/02-first-steps/05-types/1-string-quotes/solution.md b/1-js/02-first-steps/05-types/1-string-quotes/solution.md
index 68a13c15b..2c91e5885 100644
--- a/1-js/02-first-steps/05-types/1-string-quotes/solution.md
+++ b/1-js/02-first-steps/05-types/1-string-quotes/solution.md
@@ -1,5 +1,5 @@
 
-Backticks embed the expression inside `${...}` into the string.
+Backtick สามารถใส่นิพจน์ (expression) ใดๆก็ได้ลงไปใน `${...}`
 
 ```js run
 let name = "Ilya";
diff --git a/1-js/02-first-steps/05-types/1-string-quotes/task.md b/1-js/02-first-steps/05-types/1-string-quotes/task.md
index 14ea6b4d6..179502b5d 100644
--- a/1-js/02-first-steps/05-types/1-string-quotes/task.md
+++ b/1-js/02-first-steps/05-types/1-string-quotes/task.md
@@ -4,7 +4,7 @@ importance: 5
 
 # String quotes
 
-What is the output of the script?
+จงเดาผลลัพธ์จากโค้ดด้านล่างนี้
 
 ```js
 let name = "Ilya";
@@ -14,4 +14,4 @@ alert( `hello ${1}` ); // ?
 alert( `hello ${"name"}` ); // ?
 
 alert( `hello ${name}` ); // ?
-```
\ No newline at end of file
+```
diff --git a/1-js/02-first-steps/05-types/article.md b/1-js/02-first-steps/05-types/article.md
index 04e8b2450..99e0ae6b0 100644
--- a/1-js/02-first-steps/05-types/article.md
+++ b/1-js/02-first-steps/05-types/article.md
@@ -1,18 +1,18 @@
-# Data types
+# ชนิดข้อมูล
 
-A value in JavaScript is always of a certain type. For example, a string or a number.
+ค่าใน JavaScript จะมีชนิดข้อมูลเฉพาะเสมอ เช่น `string` หรือ `number`
 
-There are eight basic data types in JavaScript. Here, we'll cover them in general and in the next chapters we'll talk about each of them in detail.
+ใน JavaScript มีชนิดข้อมูลพื้นฐาน 8 ประเภท ในที่นี้เราจะกล่าวถึงภาพรวมของแต่ละประเภท และในบทต่อๆ ไปจะอธิบายแต่ละประเภทอย่างละเอียด
 
-We can put any type in a variable. For example, a variable can at one moment be a string and then store a number:
+เราสามารถใส่ค่าชนิดใดก็ได้ลงในตัวแปร ยกตัวอย่างเช่น ตัวแปรหนึ่งอาจเป็น `string` ได้ในขณะหนึ่ง แล้วเก็บ `number` ในอีกขณะหนึ่ง:
 
 ```js
-// no error
+// ไม่มี error
 let message = "hello";
 message = 123456;
 ```
 
-Programming languages that allow such things, such as JavaScript, are called "dynamically typed", meaning that there exist data types, but variables are not bound to any of them.
+ภาษาโปรแกรมที่อนุญาตให้ทำเช่นนี้ได้ เช่น JavaScript จะเรียกว่า "dynamically typed" ซึ่งหมายความว่ามีชนิดข้อมูลหลากหลาย แต่ตัวแปรไม่จำเป็นต้องถูกผูกไว้กับชนิดข้อมูลใดชนิดหนึ่งตายตัว
 
 ## Number
 
@@ -21,32 +21,33 @@ let n = 123;
 n = 12.345;
 ```
 
-The *number* type represents both integer and floating point numbers.
+ชนิดข้อมูล *number* ใช้แทนได้ทั้งจำนวนเต็มและจำนวนทศนิยม
 
-There are many operations for numbers, e.g. multiplication `*`, division `/`, addition `+`, subtraction `-`, and so on.
+มีตัวดำเนินการหลายอย่างสำหรับจำนวน เช่น การคูณ `*`, การหาร `/`, การบวก `+`, การลบ `-` และอื่นๆ
 
-Besides regular numbers, there are so-called "special numeric values" which also belong to this data type: `Infinity`, `-Infinity` and `NaN`.
+นอกเหนือจากตัวเลขทั่วไปแล้ว ยังมีค่าที่เรียกว่า "ค่าตัวเลขพิเศษ" ซึ่งก็จัดอยู่ในชนิดข้อมูลนี้ด้วย ได้แก่ `Infinity`, `-Infinity` และ `NaN`
 
-- `Infinity` represents the mathematical [Infinity](https://en.wikipedia.org/wiki/Infinity) ∞. It is a special value that's greater than any number.
+- `Infinity` หมายถึง [อนันต์](https://en.wikipedia.org/wiki/Infinity) ∞ ในเชิงคณิตศาสตร์ เป็นค่าพิเศษที่มากกว่าตัวเลขใดๆ 
 
-    We can get it as a result of division by zero:
+    เราอาจได้ค่านี้จากการหารด้วยศูนย์:
 
     ```js run
     alert( 1 / 0 ); // Infinity
     ```
 
-    Or just reference it directly:
+    หรืออ้างอิงถึงโดยตรง:
 
     ```js run
     alert( Infinity ); // Infinity
     ```
-- `NaN` represents a computational error. It is a result of an incorrect or an undefined mathematical operation, for instance:
+
+- `NaN` หมายถึงความผิดพลาดในการคำนวณ เป็นผลลัพธ์จากการดำเนินการทางคณิตศาสตร์ที่ไม่ถูกต้องหรือไม่ได้กำหนดไว้ เช่น:
 
     ```js run
-    alert( "not a number" / 2 ); // NaN, such division is erroneous
+    alert( "not a number" / 2 ); // NaN เพราะการหารแบบนี้ผิด  
     ```
 
-    `NaN` is sticky. Any further mathematical operation on `NaN` returns `NaN`:
+    `NaN` มีคุณสมบัติเหนียว การดำเนินการทางคณิตศาสตร์ใดๆ กับ `NaN` จะให้ผลลัพธ์เป็น `NaN` เสมอ:
 
     ```js run
     alert( NaN + 1 ); // NaN
@@ -54,20 +55,25 @@ Besides regular numbers, there are so-called "special numeric values" which also
     alert( "not a number" / 2 - 1 ); // NaN
     ```
 
-    So, if there's a `NaN` somewhere in a mathematical expression, it propagates to the whole result (there's only one exception to that: `NaN ** 0` is `1`).
+    ดังนั้นถ้ามี `NaN` อยู่ในนิพจน์ทางคณิตศาสตร์ตรงไหน มันจะแผ่ขยายไปทั่วผลลัพธ์ทั้งหมด (มีข้อยกเว้นเพียงอย่างเดียวคือ `NaN ** 0` จะเป็น `1`)
 
-```smart header="Mathematical operations are safe"
-Doing maths is "safe" in JavaScript. We can do anything: divide by zero, treat non-numeric strings as numbers, etc.
+```smart header="การดำเนินการทางคณิตศาสตร์มีความปลอดภัย"
+การคำนวณทางคณิตศาสตร์ใน JavaScript นั้น "ปลอดภัย" เราสามารถทำอะไรก็ได้ เช่น หารด้วยศูนย์ หรือดำเนินการกับสตริงที่ไม่ใช่ตัวเลขเหมือนเป็นตัวเลข เป็นต้น 
 
-The script will never stop with a fatal error ("die"). At worst, we'll get `NaN` as the result.
+สคริปต์จะไม่มีวันหยุดทำงานด้วย fatal error ("ตาย") ในกรณีที่แย่ที่สุด ผลลัพธ์ที่ได้จะเป็น `NaN`
 ```
 
-Special numeric values formally belong to the "number" type. Of course they are not numbers in the common sense of this word.
+อย่างเป็นทางการแล้วค่าตัวเลขพิเศษเหล่านี้จัดอยู่ในชนิดข้อมูล "number" แต่แน่นอนว่ามันไม่ใช่ตัวเลขในความหมายทั่วไปของคำนี้
 
-We'll see more about working with numbers in the chapter <info:number>.
+เราจะเรียนรู้เพิ่มเติมเกี่ยวกับการใช้งานตัวเลขในบทเรียน <info:number>
 
 ## BigInt [#bigint-type]
 
+<<<<<<< HEAD
+ในภาษา JavaScript ชนิดข้อมูล "number" ไม่สามารถแสดงค่าจำนวนเต็มที่มากกว่า <code>(2<sup>53</sup>-1)</code> (ซึ่งก็คือ `9007199254740991`) หรือน้อยกว่า <code>-(2<sup>53</sup>-1)</code> สำหรับจำนวนลบได้อย่างปลอดภัย
+
+ถ้าจะให้พูดให้ถูกต้องจริงๆ ชนิดข้อมูล "number" จะเก็บจำนวนเต็มที่ใหญ่กว่านั้นได้ (สูงสุดถึง <code>1.7976931348623157 * 10<sup>308</sup></code>) แต่นอกเหนือจากช่วงจำนวนเต็มที่ปลอดภัยคือ <code>±(2<sup>53</sup>-1)</code> แล้ว จะมีข้อผิดพลาดในการแสดงตัวเลขที่ละเอียด เพราะไม่สามารถเก็บตัวเลขได้ทุกหลักในพื้นที่จัดเก็บแบบคงที่ขนาด 64 บิต ดังนั้นค่าที่เก็บอาจจะเป็นค่า "โดยประมาณ"
+=======
 In JavaScript, the "number" type cannot safely represent integer values larger than <code>(2<sup>53</sup>-1)</code> (that's `9007199254740991`), or less than <code>-(2<sup>53</sup>-1)</code> for negatives.
 
 To be really precise, the "number" type can store larger integers (up to <code>1.7976931348623157 * 10<sup>308</sup></code>), but outside of the safe integer range <code>±(2<sup>53</sup>-1)</code> there'll be a precision error, because not all digits fit into the fixed 64-bit storage. So an "approximate" value may be stored.
@@ -82,144 +88,171 @@ console.log(9007199254740991 + 2); // 9007199254740992
 So to say, all odd integers greater than <code>(2<sup>53</sup>-1)</code> can't be stored at all in the "number" type.
 
 For most purposes <code>±(2<sup>53</sup>-1)</code> range is quite enough, but sometimes we need the entire range of really big integers, e.g. for cryptography or microsecond-precision timestamps.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
+
+ยกตัวอย่างเช่น จำนวนสองตัวนี้ (ที่อยู่เหนือช่วงปลอดภัยเล็กน้อย) จะมีค่าเท่ากัน:
+
+```js
+console.log(9007199254740991 + 1); // 9007199254740992
+console.log(9007199254740991 + 2); // 9007199254740992
+```
+
+หรือพูดได้ว่า จำนวนเต็มคี่ทุกตัวที่มากกว่า <code>(2<sup>53</sup>-1)</code> จะไม่สามารถเก็บในชนิดข้อมูล "number" ได้เลย
 
-`BigInt` type was recently added to the language to represent integers of arbitrary length.
+ในการใช้งานส่วนใหญ่ ช่วง <code>±(2<sup>53</sup>-1)</code> ก็เพียงพอแล้ว แต่บางครั้งเราอาจต้องการช่วงของจำนวนเต็มที่ใหญ่จริงๆ เช่น สำหรับการเข้ารหัสลับหรือการระบุเวลาแบบละเอียดถึงระดับไมโครวินาที
 
-A `BigInt` value is created by appending `n` to the end of an integer:
+ชนิดข้อมูล `BigInt` ได้ถูกเพิ่มเข้ามาในภาษาเมื่อไม่นานมานี้ เพื่อใช้แสดงจำนวนเต็มที่มีความยาวเท่าใดก็ได้
+
+สร้างค่า `BigInt` ได้โดยใส่ `n` ต่อท้ายจำนวนเต็ม:
 
 ```js
-// the "n" at the end means it's a BigInt
+// ตัว "n" ท้ายสุดหมายความว่าเป็น BigInt
 const bigInt = 1234567890123456789012345678901234567890n;
 ```
 
-As `BigInt` numbers are rarely needed, we don't cover them here, but devoted them a separate chapter <info:bigint>. Read it when you need such big numbers.
+เนื่องจากไม่ค่อยได้ใช้ตัวเลข `BigInt` บ่อยนัก เราจึงไม่ขอลงรายละเอียดในที่นี้ แต่จะแยกอธิบายไว้ในบทเรียน <info:bigint> อ่านได้เมื่อคุณต้องการใช้จำนวนขนาดใหญ่มากๆ นะ
+
+<<<<<<< HEAD
+
+```smart header="ปัญหาความเข้ากันได้"
+ปัจจุบัน `BigInt` รองรับใน Firefox/Chrome/Edge/Safari แต่ยังไม่รองรับใน IE 
+```
+
+คุณสามารถดูได้จาก [ตารางความเข้ากันได้ของ BigInt บน *MDN*](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt#Browser_compatibility) ว่ารองรับในเบราว์เซอร์เวอร์ชันใดบ้าง
 
+=======
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 ## String
 
-A string in JavaScript must be surrounded by quotes.
+ใน JavaScript string ต้องถูกล้อมรอบด้วยเครื่องหมายคำพูด
 
 ```js
 let str = "Hello";
-let str2 = 'Single quotes are ok too';
-let phrase = `can embed another ${str}`;
+let str2 = 'ใช้เครื่องหมายคำพูดเดี่ยวก็ได้';
+let phrase = `สามารถฝัง ${str} ได้ด้วย`;
 ```
 
-In JavaScript, there are 3 types of quotes.
+ใน JavaScript มีเครื่องหมายคำพูด 3 แบบ
 
-1. Double quotes: `"Hello"`.
-2. Single quotes: `'Hello'`.
-3. Backticks: <code>&#96;Hello&#96;</code>.
+1. เครื่องหมายคำพูดคู่: `"สวัสดี"`
+2. เครื่องหมายคำพูดเดี่ยว: `'สวัสดี'`
+3. แบ็กติก (Backticks): <code>&#96;สวัสดี&#96;</code>
 
-Double and single quotes are "simple" quotes. There's practically no difference between them in JavaScript.
+เครื่องหมายคำพูดคู่และเดี่ยวเป็นแบบ "ธรรมดา" ในทางปฏิบัติแล้วไม่มีความแตกต่างระหว่างสองแบบนี้ใน JavaScript
 
-Backticks are "extended functionality" quotes. They allow us to embed variables and expressions into a string by wrapping them in `${…}`, for example:
+ส่วนแบ็กติกเป็นเครื่องหมายคำพูดที่มี "ฟังก์ชันเพิ่มเติม" มันช่วยให้เราสามารถแทรกตัวแปรและนิพจน์ลงใน string ได้ โดยครอบด้วย `${…}` เช่น:
 
 ```js run
-let name = "John";
+let name = "สมชาย";
 
-// embed a variable
-alert( `Hello, *!*${name}*/!*!` ); // Hello, John!
+// แทรกตัวแปร
+alert( `สวัสดี *!*${name}*/!*!` ); // สวัสดี สมชาย!
 
-// embed an expression
-alert( `the result is *!*${1 + 2}*/!*` ); // the result is 3
+// แทรกนิพจน์
+alert( `ผลลัพธ์คือ *!*${1 + 2}*/!*` ); // ผลลัพธ์คือ 3
 ```
 
-The expression inside `${…}` is evaluated and the result becomes a part of the string. We can put anything in there: a variable like `name` or an arithmetical expression like `1 + 2` or something more complex.
+นิพจน์ภายใน `${…}` จะถูกประเมินค่า และผลลัพธ์จะกลายเป็นส่วนหนึ่งของ string เราสามารถใส่อะไรก็ได้ลงไปในนั้น ไม่ว่าจะเป็นตัวแปรอย่าง `name` หรือนิพจน์ทางคณิตศาสตร์อย่าง `1 + 2` หรือสิ่งที่ซับซ้อนกว่านั้น
+
+โปรดจำไว้ว่า การแทรกเช่นนี้ทำได้เฉพาะในแบ็กติกเท่านั้น เครื่องหมายคำพูดรูปแบบอื่นไม่มีความสามารถในการแทรกแบบนี้!
 
-Please note that this can only be done in backticks. Other quotes don't have this embedding functionality!
 ```js run
-alert( "the result is ${1 + 2}" ); // the result is ${1 + 2} (double quotes do nothing)
+alert( "ผลลัพธ์คือ ${1 + 2}" ); // ผลลัพธ์คือ ${1 + 2} (เครื่องหมายคำพูดคู่ไม่ได้แทรกอะไร)
 ```
 
-We'll cover strings more thoroughly in the chapter <info:string>.
+เราจะพูดถึง string อย่างละเอียดอีกครั้งในบทเรียน <info:string>
 
-```smart header="There is no *character* type."
-In some languages, there is a special "character" type for a single character. For example, in the C language and in Java it is called "char".
+```smart header="ไม่มีชนิดข้อมูล *ตัวอักษร*"
+ในบางภาษา จะมีชนิดข้อมูลพิเศษ "ตัวอักษร" ไว้แทนอักขระตัวเดียว เช่นในภาษา C และ Java จะเรียกว่า "char"
 
-In JavaScript, there is no such type. There's only one type: `string`. A string may consist of zero characters (be empty), one character or many of them.
+แต่ใน JavaScript ไม่มีชนิดข้อมูลเช่นนั้น มีเพียงชนิด `string` เท่านั้น ซึ่ง string อาจเป็นอักขระศูนย์ตัว (ว่างเปล่า), หนึ่งตัว หรือหลายตัวก็ได้
 ```
 
-## Boolean (logical type)
+## Boolean (ชนิดข้อมูลตรรกะ)
 
-The boolean type has only two values: `true` and `false`.
+ชนิดข้อมูล boolean มีค่าได้เพียงสองค่าเท่านั้น คือ `true` และ `false`
 
-This type is commonly used to store yes/no values: `true` means "yes, correct", and `false` means "no, incorrect".
+ชนิดข้อมูลนี้มักใช้สำหรับเก็บค่าแบบ ใช่/ไม่ใช่ โดย `true` หมายถึง "ใช่ ถูกต้อง" ส่วน `false` หมายถึง "ไม่ใช่ ไม่ถูกต้อง" 
 
-For instance:
+ยกตัวอย่างเช่น:
 
 ```js
-let nameFieldChecked = true; // yes, name field is checked
-let ageFieldChecked = false; // no, age field is not checked
+let nameFieldChecked = true; // ใช่ ช่องชื่อถูกเลือก
+let ageFieldChecked = false; // ไม่ใช่ ช่องอายุไม่ได้ถูกเลือก
 ```
 
-Boolean values also come as a result of comparisons:
+นอกจากนี้ ค่า boolean ยังเป็นผลลัพธ์ที่ได้จากการเปรียบเทียบด้วย:
 
 ```js run
 let isGreater = 4 > 1;
 
-alert( isGreater ); // true (the comparison result is "yes")
+alert( isGreater ); // true (ผลการเปรียบเทียบคือ "ใช่")
 ```
 
-We'll cover booleans more deeply in the chapter <info:logical-operators>.
+เราจะกล่าวถึง boolean โดยละเอียดอีกครั้งในบทเรียน <info:logical-operators>
 
-## The "null" value
+## ค่า "null" 
 
-The special `null` value does not belong to any of the types described above.
+ค่าพิเศษ `null` ไม่ได้จัดอยู่ในชนิดข้อมูลที่กล่าวมาข้างต้นเลย
 
-It forms a separate type of its own which contains only the `null` value:
+มันเป็นชนิดข้อมูลแยกต่างหาก ที่มีเพียงค่า `null` เท่านั้น:
 
 ```js
 let age = null;
 ```
 
-In JavaScript, `null` is not a "reference to a non-existing object" or a "null pointer" like in some other languages.
+ใน JavaScript `null` ไม่ใช่ "การอ้างอิงถึงออบเจ็กต์ที่ไม่มีอยู่จริง" หรือ "null pointer" เหมือนในบางภาษา
 
-It's just a special value which represents "nothing", "empty" or "value unknown".
+แต่เป็นค่าพิเศษ ที่ใช้แทนความหมาย "ไม่มีอะไร", "ว่างเปล่า" หรือ "ไม่ทราบค่า"
 
-The code above states that `age` is unknown.
+ในตัวอย่างโค้ดข้างต้น หมายความว่า `age` เป็นค่าที่ไม่ทราบ
 
-## The "undefined" value
+## ค่า "undefined"
 
-The special value `undefined` also stands apart. It makes a type of its own, just like `null`.
+ค่าพิเศษ `undefined` นั้นมีลักษณะเฉพาะตัว โดยจัดเป็นชนิดข้อมูลแยกออกมาต่างหาก เช่นเดียวกับ `null`
 
-The meaning of `undefined` is "value is not assigned".
+ความหมายของ `undefined` คือ "ยังไม่ได้กำหนดค่า"
 
-If a variable is declared, but not assigned, then its value is `undefined`:
+หากตัวแปรถูกประกาศแต่ยังไม่ได้กำหนดค่า ค่าของตัวแปรนั้นจะเป็น `undefined`:
 
 ```js run
 let age;
 
-alert(age); // shows "undefined"
+alert(age); // แสดงผลเป็น "undefined"
 ```
 
-Technically, it is possible to explicitly assign `undefined` to a variable:
+ในทางเทคนิค เราสามารถกำหนดค่า `undefined` ให้กับตัวแปรได้อย่างชัดเจน:
 
 ```js run
 let age = 100;
 
-// change the value to undefined
+// เปลี่ยนค่าเป็น undefined
 age = undefined;
 
-alert(age); // "undefined"
+alert(age); // แสดงผลเป็น "undefined"
 ```
 
-...But we don't recommend doing that. Normally, one uses `null` to assign an "empty" or "unknown" value to a variable, while `undefined` is reserved as a default initial value for unassigned things.
+อย่างไรก็ตาม เราไม่แนะนำให้ทำเช่นนั้น โดยทั่วไปแล้ว นิยมใช้ `null` เพื่อกำหนดค่า "ว่างเปล่า" หรือ "ไม่ทราบค่า" ให้กับตัวแปร ส่วน `undefined` จะถูกสงวนไว้ใช้เป็นค่าเริ่มต้นสำหรับสิ่งที่ยังไม่ได้รับการกำหนดค่า
 
-## Objects and Symbols
+## Object และ Symbol
 
-The `object` type is special.
+ชนิดข้อมูล `object` นั้นมีความพิเศษ
 
-All other types are called "primitive" because their values can contain only a single thing (be it a string or a number or whatever). In contrast, objects are used to store collections of data and more complex entities.
+ชนิดข้อมูลอื่นๆ ทั้งหมดเรียกว่า "primitive" เนื่องจากค่าของชนิดข้อมูลเหล่านั้นสามารถเก็บได้เพียงสิ่งเดียว (ไม่ว่าจะเป็น string, number หรืออย่างอื่น) ในทางตรงกันข้าม object ใช้สำหรับเก็บชุดของข้อมูลและสิ่งที่มีโครงสร้างซับซ้อนกว่า
 
-Being that important, objects deserve a special treatment. We'll deal with them later in the chapter <info:object>, after we learn more about primitives.
+ด้วยความสำคัญดังกล่าว object จึงสมควรได้รับการจัดการเป็นพิเศษ เราจะกล่าวถึงรายละเอียดเกี่ยวกับ object ในบท <info:object> หลังจากที่เราได้เรียนรู้เพิ่มเติมเกี่ยวกับ primitive แล้ว
 
-The `symbol` type is used to create unique identifiers for objects. We have to mention it here for the sake of completeness, but also postpone the details till we know objects.
+ชนิดข้อมูล `symbol` ใช้สำหรับสร้างตัวระบุ (identifier) ที่ไม่ซ้ำกันสำหรับ object เราจำเป็นต้องกล่าวถึงมันที่นี่เพื่อให้ครบถ้วน แต่จะเลื่อนรายละเอียดไปจนกว่าเราจะเข้าใจเรื่อง object
 
-## The typeof operator [#type-typeof]
+## typeof operator [#type-typeof]
 
+<<<<<<< HEAD
+`typeof` operator จะคืนค่าชนิดข้อมูลของ operand มันมีประโยชน์เมื่อเราต้องการประมวลผลค่าที่มีชนิดข้อมูลแตกต่างกัน หรือเพียงแค่ต้องการตรวจสอบแบบรวดเร็ว
+=======
 The `typeof` operator returns the type of the operand. It's useful when we want to process values of different types differently or just want to do a quick check.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-A call to `typeof x` returns a string with the type name:
+การเรียกใช้ `typeof x` จะคืนค่าเป็น string ที่ระบุชื่อชนิดข้อมูล:
 
 ```js
 typeof undefined // "undefined"
@@ -247,26 +280,38 @@ typeof alert // "function"  (3)
 */!*
 ```
 
-The last three lines may need additional explanation:
+สามบรรทัดสุดท้ายอาจต้องมีคำอธิบายเพิ่มเติม:
 
-1. `Math` is a built-in object that provides mathematical operations. We will learn it in the chapter <info:number>. Here, it serves just as an example of an object.
-2. The result of `typeof null` is `"object"`. That's an officially recognized error in `typeof`, coming from very early days of JavaScript and kept for compatibility. Definitely, `null` is not an object. It is a special value with a separate type of its own. The behavior of `typeof` is wrong here.
-3. The result of `typeof alert` is `"function"`, because `alert` is a function. We'll study functions in the next chapters where we'll also see that there's no special "function" type in JavaScript. Functions belong to the object type. But `typeof` treats them differently, returning `"function"`. That also comes from the early days of JavaScript. Technically, such behavior isn't correct, but can be convenient in practice.
+1. `Math` เป็น built-in object ที่มีฟังก์ชันทางคณิตศาสตร์ให้ใช้งาน เราจะเรียนรู้เพิ่มเติมในบท <info:number> ที่นี่ใช้เพียงเป็นตัวอย่างของ object เท่านั้น
+2. ผลลัพธ์ของ `typeof null` คือ `"object"` ซึ่งเป็นข้อผิดพลาดที่ยอมรับอย่างเป็นทางการใน `typeof` โดยมีมาตั้งแต่ยุคแรกเริ่มของ JavaScript และคงไว้เพื่อให้เข้ากันได้กับโค้ดเก่า อันที่จริง `null` ไม่ใช่ object แต่เป็นค่าพิเศษที่มีชนิดข้อมูลเป็นของตัวเอง การทำงานของ `typeof` ในกรณีนี้จึงไม่ถูกต้อง
+3. ผลลัพธ์ของ `typeof alert` คือ `"function"` เพราะ `alert` เป็นฟังก์ชัน เราจะศึกษาเกี่ยวกับฟังก์ชันในบทถัดๆ ไป โดยจะเห็นว่าไม่มีชนิดข้อมูล "function" โดยเฉพาะใน JavaScript ฟังก์ชันจัดเป็นส่วนหนึ่งของชนิดข้อมูล object แต่ `typeof` ปฏิบัติต่อฟังก์ชันแตกต่างออกไป โดยคืนค่าเป็น `"function"` ซึ่งก็เป็นพฤติกรรมที่มีมาตั้งแต่ยุคแรกเริ่มของ JavaScript ในทางเทคนิคแล้ว พฤติกรรมดังกล่าวไม่ถูกต้อง แต่ในทางปฏิบัติอาจสะดวกกว่า
 
-```smart header="The `typeof(x)` syntax"
-You may also come across another syntax: `typeof(x)`. It's the same as `typeof x`.
+```smart header="ไวยากรณ์ `typeof(x)`"
+คุณอาจเจอไวยากรณ์รูปแบบอื่นด้วย เช่น `typeof(x)` ซึ่งมีความหมายเหมือนกับ `typeof x` 
 
-To put it clear: `typeof` is an operator, not a function. The parentheses here aren't a part of `typeof`. It's the kind of parentheses used for mathematical grouping.
+เพื่อให้ชัดเจน: `typeof` เป็น operator ไม่ใช่ฟังก์ชัน วงเล็บที่เห็นไม่ใช่ส่วนหนึ่งของ `typeof` แต่เป็นวงเล็บที่ใช้เพื่อจัดกลุ่มในเชิงคณิตศาสตร์
 
-Usually, such parentheses contain a mathematical expression, such as `(2 + 2)`, but here they contain only one argument `(x)`. Syntactically, they allow to avoid a space between the `typeof` operator and its argument, and some people like it.
+โดยปกติวงเล็บแบบนี้จะใช้ครอบนิพจน์ทางคณิตศาสตร์ เช่น `(2 + 2)` แต่ในที่นี้มีเพียงอาร์กิวเมนต์เดียวคือ `(x)` ในแง่ของไวยากรณ์ มันช่วยให้ไม่ต้องเว้นวรรคระหว่าง operator `typeof` กับอาร์กิวเมนต์ และบางคนชอบใช้แบบนี้
 
-Some people prefer `typeof(x)`, although the `typeof x` syntax is much more common.
+อย่างไรก็ตาม ไวยากรณ์ `typeof x` ยังคงเป็นที่นิยมใช้กันมากกว่า `typeof(x)` แม้ว่าบางคนจะชอบใช้รูปแบบหลังก็ตาม  
 ```
 
-## Summary
-
-There are 8 basic data types in JavaScript.
-
+## สรุป
+
+ใน JavaScript มีชนิดข้อมูลพื้นฐาน 8 ชนิด ได้แก่
+
+<<<<<<< HEAD
+- ชนิดข้อมูล primitive 7 ชนิด:
+    - `number` สำหรับตัวเลขทุกประเภท ทั้งจำนวนเต็มและทศนิยม โดยจำนวนเต็มจะมีขอบเขตอยู่ที่ <code>±(2<sup>53</sup>-1)</code>
+    - `bigint` สำหรับจำนวนเต็มที่มีความยาวเท่าใดก็ได้
+    - `string` สำหรับข้อความ โดยข้อความอาจมีตัวอักษรตั้งแต่ศูนย์ตัวขึ้นไป และไม่มีชนิดข้อมูลแยกต่างหากสำหรับตัวอักษรเพียงหนึ่งตัว
+    - `boolean` สำหรับค่า `true` หรือ `false`
+    - `null` สำหรับค่าที่ไม่ทราบ เป็นชนิดข้อมูลแยกต่างหากที่มีค่าเพียงค่าเดียวคือ `null`
+    - `undefined` สำหรับค่าที่ยังไม่ได้กำหนด เป็นชนิดข้อมูลแยกต่างหากที่มีค่าเพียงค่าเดียวคือ `undefined`
+    - `symbol` สำหรับการสร้างตัวระบุที่ไม่ซ้ำกัน
+- และชนิดข้อมูลที่ไม่ใช่ primitive 1 ชนิด:
+    - `object` สำหรับโครงสร้างข้อมูลที่มีความซับซ้อนมากขึ้น
+=======
 - Seven primitive data types:
     - `number` for numbers of any kind: integer or floating-point, integers are limited by <code>±(2<sup>53</sup>-1)</code>.
     - `bigint` for integer numbers of arbitrary length.
@@ -277,11 +322,12 @@ There are 8 basic data types in JavaScript.
     - `symbol` for unique identifiers.
 - And one non-primitive data type:
     - `object` for more complex data structures.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-The `typeof` operator allows us to see which type is stored in a variable.
+`typeof` operator ช่วยให้เราสามารถตรวจสอบชนิดข้อมูลที่ถูกเก็บอยู่ในตัวแปรได้
 
-- Usually used as `typeof x`, but `typeof(x)` is also possible.
-- Returns a string with the name of the type, like `"string"`.
-- For `null` returns `"object"` -- this is an error in the language, it's not actually an object.
+- โดยทั่วไปใช้ในรูปแบบ `typeof x` แต่ `typeof(x)` ก็สามารถใช้ได้เช่นกัน
+- คืนค่าเป็น string ที่ระบุชื่อชนิดข้อมูล เช่น `"string"`
+- สำหรับ `null` จะคืนค่าเป็น `"object"` ซึ่งถือเป็นข้อผิดพลาดในภาษา เพราะจริง ๆ แล้ว `null` ไม่ใช่ object
 
-In the next chapters, we'll concentrate on primitive values and once we're familiar with them, we'll move on to objects.
+ในบทต่อ ๆ ไป เราจะมุ่งเน้นไปที่ค่า primitive และเมื่อเราคุ้นเคยกับมันแล้ว เราจะเริ่มศึกษาเกี่ยวกับ object ต่อไป
\ No newline at end of file
diff --git a/1-js/02-first-steps/06-alert-prompt-confirm/article.md b/1-js/02-first-steps/06-alert-prompt-confirm/article.md
index ef0f333cb..426e5e506 100644
--- a/1-js/02-first-steps/06-alert-prompt-confirm/article.md
+++ b/1-js/02-first-steps/06-alert-prompt-confirm/article.md
@@ -1,44 +1,44 @@
-# Interaction: alert, prompt, confirm
+# การโต้ตอบ: alert, prompt, confirm
 
-As we'll be using the browser as our demo environment, let's see a couple of functions to interact with the user: `alert`, `prompt` and `confirm`.
+เนื่องจากเราจะใช้เบราว์เซอร์เป็นสภาพแวดล้อมในการสาธิต เรามาดูฟังก์ชันสองสามตัวที่ใช้ในการโต้ตอบกับผู้ใช้กัน ได้แก่ `alert`, `prompt` และ `confirm`
 
 ## alert
 
-This one we've seen already. It shows a message and waits for the user to press "OK".
+เราเคยเห็น `alert` มาแล้ว มันใช้ในการแสดงข้อความและรอให้ผู้ใช้กดปุ่ม "OK" 
 
-For example:
+ตัวอย่างเช่น:
 
 ```js run
 alert("Hello");
 ```
 
-The mini-window with the message is called a *modal window*. The word "modal" means that the visitor can't interact with the rest of the page, press other buttons, etc, until they have dealt with the window. In this case -- until they press "OK".
+หน้าต่างขนาดเล็กที่แสดงข้อความนี้เรียกว่า *modal window* คำว่า "modal" หมายความว่าผู้ใช้จะไม่สามารถโต้ตอบกับส่วนอื่นๆ ของหน้าเว็บ กดปุ่มอื่นๆ หรือทำอย่างอื่นได้ จนกว่าจะจัดการกับหน้าต่างนี้เสร็จ ในกรณีนี้คือจนกว่าจะกดปุ่ม "OK"
 
 ## prompt
 
-The function `prompt` accepts two arguments:
+ฟังก์ชัน `prompt` รับอาร์กิวเมนต์สองตัว:
 
 ```js no-beautify
 result = prompt(title, [default]);
 ```
 
-It shows a modal window with a text message, an input field for the visitor, and the buttons OK/Cancel.
+มันจะแสดง modal window ที่มีข้อความ ช่องให้ผู้ใช้กรอกข้อมูล และปุ่ม OK/Cancel
 
 `title`
-: The text to show the visitor.
+: ข้อความที่จะแสดงให้ผู้ใช้เห็น
 
 `default`
-: An optional second parameter, the initial value for the input field.
+: อาร์กิวเมนต์ที่สองซึ่งเป็นตัวเลือก ใช้เป็นค่าเริ่มต้นสำหรับช่องกรอกข้อมูล
 
-```smart header="The square brackets in syntax `[...]`"
-The square brackets around `default` in the syntax above denote that the parameter is optional, not required.
+```smart header="วงเล็บในไวยากรณ์ `[...]`"
+วงเล็บรอบๆ `default` ในไวยากรณ์ด้านบนหมายความว่าพารามิเตอร์นี้เป็นตัวเลือก ไม่จำเป็นต้องใส่ก็ได้
 ```
 
-The visitor can type something in the prompt input field and press OK. Then we get that text in the `result`. Or they can cancel the input by pressing Cancel or hitting the `key:Esc` key, then we get `null` as the `result`.
+ผู้ใช้สามารถพิมพ์ข้อความลงในช่อง prompt แล้วกดปุ่ม OK จากนั้นเราจะได้ข้อความนั้นใน `result` หรือผู้ใช้อาจยกเลิกการป้อนข้อมูลได้โดยกดปุ่ม Cancel หรือกดปุ่ม `Esc` ซึ่งในกรณีนี้ `result` จะมีค่าเป็น `null`
 
-The call to `prompt` returns the text from the input field or `null` if the input was canceled.
+การเรียกใช้ `prompt` จะคืนค่าเป็นข้อความจากช่องกรอกข้อมูล หรือเป็น `null` หากมีการยกเลิกการป้อนข้อมูล
 
-For instance:
+ตัวอย่างเช่น:
 
 ```js run
 let age = prompt('How old are you?', 100);
@@ -46,60 +46,60 @@ let age = prompt('How old are you?', 100);
 alert(`You are ${age} years old!`); // You are 100 years old!
 ```
 
-````warn header="In IE: always supply a `default`"
-The second parameter is optional, but if we don't supply it, Internet Explorer will insert the text `"undefined"` into the prompt.
+```warn header="ใน IE: ควรระบุ `default` เสมอ"
+อาร์กิวเมนต์ที่สองเป็นตัวเลือก แต่หากเราไม่ระบุมัน Internet Explorer จะแทรกข้อความ `"undefined"` ลงในช่อง prompt
 
-Run this code in Internet Explorer to see:
+ลองรันโค้ดนี้ใน Internet Explorer เพื่อดู:
 
 ```js run
 let test = prompt("Test");
 ```
 
-So, for prompts to look good in IE, we recommend always providing the second argument:
+ดังนั้น เพื่อให้ prompt แสดงผลได้ถูกต้องใน IE เราแนะนำให้ระบุอาร์กิวเมนต์ที่สองเสมอ:
 
 ```js run
-let test = prompt("Test", ''); // <-- for IE
+let test = prompt("Test", ''); // <-- สำหรับ IE
+```
 ```
-````
 
 ## confirm
 
-The syntax:
+ไวยากรณ์:
 
 ```js
 result = confirm(question);
 ```
 
-The function `confirm` shows a modal window with a `question` and two buttons: OK and Cancel.
+ฟังก์ชัน `confirm` จะแสดง modal window ที่มี `question` และปุ่มสองปุ่มคือ OK และ Cancel
 
-The result is `true` if OK is pressed and `false` otherwise.
+ผลลัพธ์จะเป็น `true` หากกดปุ่ม OK และเป็น `false` หากกดปุ่มอื่น
 
-For example:
+ตัวอย่างเช่น:
 
 ```js run
 let isBoss = confirm("Are you the boss?");
 
-alert( isBoss ); // true if OK is pressed
+alert( isBoss ); // true ถ้ากด OK
 ```
 
-## Summary
+## สรุป
 
-We covered 3 browser-specific functions to interact with visitors:
+เราได้กล่าวถึงฟังก์ชันเฉพาะของเบราว์เซอร์ 3 ตัวที่ใช้ในการโต้ตอบกับผู้ใช้:
 
 `alert`
-: shows a message.
+: แสดงข้อความ
 
 `prompt`
-: shows a message asking the user to input text. It returns the text or, if Cancel button or `key:Esc` is clicked, `null`.
+: แสดงข้อความขอให้ผู้ใช้ป้อนข้อความ คืนค่าเป็นข้อความนั้น หรือคืนค่า `null` หากกดปุ่ม Cancel หรือ `Esc`
 
-`confirm`
-: shows a message and waits for the user to press "OK" or "Cancel". It returns `true` for OK and `false` for Cancel/`key:Esc`.
+`confirm`  
+: แสดงข้อความและรอให้ผู้ใช้กดปุ่ม "OK" หรือ "Cancel" คืนค่า `true` สำหรับปุ่ม OK และ `false` สำหรับปุ่ม Cancel หรือ `Esc`
 
-All these methods are modal: they pause script execution and don't allow the visitor to interact with the rest of the page until the window has been dismissed.
+เมธอดทั้งหมดนี้เป็น modal: พวกมันจะหยุดการทำงานของสคริปต์และไม่อนุญาตให้ผู้ใช้โต้ตอบกับส่วนที่เหลือของหน้าจนกว่าจะปิดหน้าต่างนั้นไป 
 
-There are two limitations shared by all the methods above:
+มีข้อจำกัดสองอย่างที่ใช้กับทุกเมธอดข้างต้น:
 
-1. The exact location of the modal window is determined by the browser. Usually, it's in the center.
-2. The exact look of the window also depends on the browser. We can't modify it.
+1. ตำแหน่งที่แน่นอนของ modal window จะถูกกำหนดโดยเบราว์เซอร์ โดยปกติจะอยู่ตรงกลาง
+2. รูปลักษณ์ที่แน่นอนของหน้าต่างก็ขึ้นอยู่กับเบราว์เซอร์เช่นกัน เราไม่สามารถปรับแต่งได้
 
-That is the price for simplicity. There are other ways to show nicer windows and richer interaction with the visitor, but if "bells and whistles" do not matter much, these methods work just fine.
+นั่นคือราคาของความเรียบง่าย มีวิธีอื่นในการแสดงหน้าต่างที่สวยงามและการโต้ตอบกับผู้ใช้ที่ซับซ้อนกว่านี้ แต่หากฟีเจอร์พิเศษไม่ใช่สิ่งสำคัญ เมธอดเหล่านี้ก็ใช้งานได้ดีเช่นกัน
\ No newline at end of file
diff --git a/1-js/02-first-steps/07-type-conversions/article.md b/1-js/02-first-steps/07-type-conversions/article.md
index 329556141..2b691e8cb 100644
--- a/1-js/02-first-steps/07-type-conversions/article.md
+++ b/1-js/02-first-steps/07-type-conversions/article.md
@@ -1,102 +1,116 @@
-# Type Conversions
+# การแปลงชนิดข้อมูล
 
-Most of the time, operators and functions automatically convert the values given to them to the right type.
+โดยทั่วไปแล้ว ตัวดำเนินการและฟังก์ชันจะแปลงค่าที่ส่งเข้ามาให้เป็นชนิดข้อมูลที่ถูกต้องโดยอัตโนมัติ
 
-For example, `alert` automatically converts any value to a string to show it. Mathematical operations convert values to numbers.
+ยกตัวอย่างเช่น `alert` จะแปลงค่าเป็น string โดยอัตโนมัติเพื่อนำไปแสดงผล ในขณะที่การดำเนินการทางคณิตศาสตร์จะแปลงค่าเป็นตัวเลข 
 
-There are also cases when we need to explicitly convert a value to the expected type.
+อย่างไรก็ตาม มีบางกรณีที่เราจำเป็นต้องแปลงค่าเป็นชนิดข้อมูลที่ต้องการ
 
+<<<<<<< HEAD
+```smart header="ยังไม่กล่าวถึง object"
+ในบทนี้เรายังไม่ครอบคลุมถึง object เราจะพูดถึงแค่ค่า primitive เท่านั้น
+=======
 ```smart header="Not talking about objects yet"
 In this chapter, we won't cover objects. For now, we'll just be talking about primitives.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-Later, after we learn about objects, in the chapter <info:object-toprimitive> we'll see how objects fit in.
+หลังจากที่เราได้เรียนรู้เรื่อง object แล้ว ในบท <info:object-toprimitive> เราจะได้เห็นว่า object เข้ามาเกี่ยวข้องอย่างไร
 ```
 
-## String Conversion
+## การแปลงเป็น String
 
-String conversion happens when we need the string form of a value.
+การแปลงเป็น string จะเกิดขึ้นเมื่อเราต้องการแสดงค่าในรูปแบบ string  
 
-For example, `alert(value)` does it to show the value.
+ยกตัวอย่างเช่น `alert(value)` จะแปลงค่าเป็น string เพื่อนำไปแสดงผล
 
-We can also call the `String(value)` function to convert a value to a string:
+เรายังสามารถเรียกใช้ฟังก์ชัน `String(value)` เพื่อแปลงค่าเป็น string ได้:
 
 ```js run
 let value = true;
 alert(typeof value); // boolean
 
 *!*
-value = String(value); // now value is a string "true"
+value = String(value); // ตอนนี้ value เป็น string "true"
 alert(typeof value); // string
 */!*
 ```
 
-String conversion is mostly obvious. A `false` becomes `"false"`, `null` becomes `"null"`, etc.
+การแปลงเป็น string โดยทั่วไปมักจะตรงไปตรงมาอยู่แล้ว เช่น `false` กลายเป็น `"false"`, `null` กลายเป็น `"null"` เป็นต้น
 
-## Numeric Conversion
+## การแปลงเป็นตัวเลข
 
+<<<<<<< HEAD
+การแปลงเป็นตัวเลขที่เกิดขึ้นในฟังก์ชันและนิพจน์ทางคณิตศาสตร์จะดำเนินการโดยอัตโนมัติ
+=======
 Numeric conversion in mathematical functions and expressions happens automatically.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-For example, when division `/` is applied to non-numbers:
+ยกตัวอย่างเช่น เมื่อมีการหาร `/` กับสิ่งที่ไม่ใช่ตัวเลข:
 
 ```js run
-alert( "6" / "2" ); // 3, strings are converted to numbers
+alert( "6" / "2" ); // 3, string ถูกแปลงเป็นตัวเลข  
 ```
 
-We can use the `Number(value)` function to explicitly convert a `value` to a number:
+เราสามารถใช้ฟังก์ชัน `Number(value)` เพื่อแปลง `value` เป็นตัวเลขได้:
 
 ```js run
 let str = "123";
 alert(typeof str); // string
 
-let num = Number(str); // becomes a number 123
+let num = Number(str); // กลายเป็นตัวเลข 123
 
 alert(typeof num); // number
 ```
 
-Explicit conversion is usually required when we read a value from a string-based source like a text form but expect a number to be entered.
+โดยทั่วไปแล้วการแปลงเป็นตัวเลขอย่างชัดเจนจะจำเป็นเมื่อเราอ่านค่าจากแหล่งที่เก็บเป็น string เช่น ฟอร์มข้อความ แต่คาดหวังว่าค่าที่กรอกเข้ามาจะเป็นตัวเลข
 
-If the string is not a valid number, the result of such a conversion is `NaN`. For instance:
+ถ้า string ไม่ใช่ตัวเลขที่ถูกต้อง ผลลัพธ์จากการแปลงจะได้เป็น `NaN` ตัวอย่างเช่น:
 
 ```js run
 let age = Number("an arbitrary string instead of a number");
 
-alert(age); // NaN, conversion failed
+alert(age); // NaN, การแปลงล้มเหลว
 ```
 
-Numeric conversion rules:
+กฎการแปลงเป็นตัวเลข:
 
-| Value |  Becomes... |
+| ค่า |  จะกลายเป็น... |
 |-------|-------------|
 |`undefined`|`NaN`|
 |`null`|`0`|
+<<<<<<< HEAD
+|<code>true&nbsp;และ&nbsp;false</code> | `1` และ `0` |
+| `string` | ช่องว่าง (รวมถึงเว้นวรรค, tab `\t`, ขึ้นบรรทัดใหม่ `\n` เป็นต้น) ที่จุดเริ่มต้นและสิ้นสุดจะถูกละเว้น ถ้า string ที่เหลือว่างเปล่า ผลลัพธ์จะเป็น `0` มิฉะนั้นตัวเลขจะถูก "อ่าน" จาก string เมื่อเกิด error จะได้เป็น `NaN` |
+=======
 |<code>true&nbsp;and&nbsp;false</code> | `1` and `0` |
 | `string` | Whitespaces (includes spaces, tabs `\t`, newlines `\n` etc.) from the start and end are removed. If the remaining string is empty, the result is `0`. Otherwise, the number is "read" from the string. An error gives `NaN`. |
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-Examples:
+ตัวอย่าง:
 
 ```js run
 alert( Number("   123   ") ); // 123
-alert( Number("123z") );      // NaN (error reading a number at "z")
+alert( Number("123z") );      // NaN (เกิด error ตอนอ่านตัวเลขที่ "z")
 alert( Number(true) );        // 1
 alert( Number(false) );       // 0
 ```
 
-Please note that `null` and `undefined` behave differently here: `null` becomes zero while `undefined` becomes `NaN`.
+โปรดสังเกตว่า `null` และ `undefined` มีพฤติกรรมที่แตกต่างกันในที่นี้: `null` จะกลายเป็นศูนย์ ในขณะที่ `undefined` จะกลายเป็น `NaN`
 
-Most mathematical operators also perform such conversion, we'll see that in the next chapter.
+ตัวดำเนินการทางคณิตศาสตร์ส่วนใหญ่ก็จะทำการแปลงค่าในลักษณะนี้เช่นกัน ซึ่งเราจะได้เห็นในบทถัดไป
 
-## Boolean Conversion
+## การแปลงเป็น Boolean
 
-Boolean conversion is the simplest one.
+การแปลงเป็น boolean เป็นการแปลงที่ง่ายที่สุด
 
-It happens in logical operations (later we'll meet condition tests and other similar things) but can also be performed explicitly with a call to `Boolean(value)`.
+มันจะเกิดขึ้นในการดำเนินการเชิงตรรกะ (ต่อไปเราจะได้เจอกับการทดสอบเงื่อนไขและสิ่งที่คล้ายคลึงกัน) แต่ก็สามารถทำได้อย่างชัดเจนด้วยการเรียกใช้ `Boolean(value)`
 
-The conversion rule:
+กฎการแปลง:
 
-- Values that are intuitively "empty", like `0`, an empty string, `null`, `undefined`, and `NaN`, become `false`.
-- Other values become `true`.
+- ค่าที่ "ว่างเปล่า" ตามความเข้าใจทั่วไป เช่น `0`, string เปล่า, `null`, `undefined` และ `NaN` จะกลายเป็น `false`
+- ค่าอื่นๆ จะกลายเป็น `true`
 
-For instance:
+ตัวอย่างเช่น:
 
 ```js run
 alert( Boolean(1) ); // true
@@ -106,45 +120,49 @@ alert( Boolean("hello") ); // true
 alert( Boolean("") ); // false
 ```
 
-````warn header="Please note: the string with zero `\"0\"` is `true`"
-Some languages (namely PHP) treat `"0"` as `false`. But in JavaScript, a non-empty string is always `true`.
+```warn header="โปรดสังเกต: string ที่มีเลขศูนย์ `\"0\"` จะเป็น `true`"
+ในบางภาษา (โดยเฉพาะ PHP) `"0"` จะถูกพิจารณาว่าเป็น `false` แต่ใน JavaScript string ที่ไม่ว่างเปล่าจะเป็น `true` เสมอ
 
 ```js run
-alert( Boolean("0") ); // true
-alert( Boolean(" ") ); // spaces, also true (any non-empty string is true)
+alert( Boolean("0") ); // true 
+alert( Boolean(" ") ); // เว้นวรรค ก็เป็น true (string ที่ไม่ว่างเปล่าทั้งหมดจะเป็น true)
+```
 ```
-````
 
-## Summary
+## สรุป
 
-The three most widely used type conversions are to string, to number, and to boolean.
+การแปลงชนิดข้อมูลที่พบบ่อยที่สุดมี 3 ประเภท ได้แก่ การแปลงเป็น string, การแปลงเป็นตัวเลข และการแปลงเป็น boolean
 
-**`String Conversion`** -- Occurs when we output something. Can be performed with `String(value)`. The conversion to string is usually obvious for primitive values.
+**`การแปลงเป็น String`** -- เกิดขึ้นเมื่อเราแสดงผลอะไรบางอย่าง สามารถทำได้ด้วย `String(value)` โดยทั่วไปการแปลงเป็น string มักจะชัดเจนอยู่แล้วสำหรับค่า primitive
 
-**`Numeric Conversion`** -- Occurs in math operations. Can be performed with `Number(value)`.
+**`การแปลงเป็นตัวเลข`** -- เกิดขึ้นในการดำเนินการทางคณิตศาสตร์ สามารถทำได้ด้วย `Number(value)`
 
-The conversion follows the rules:
+การแปลงจะเป็นไปตามกฎ:
 
-| Value |  Becomes... |
+| ค่า |  จะกลายเป็น... |
 |-------|-------------|
 |`undefined`|`NaN`|
 |`null`|`0`|
 |<code>true&nbsp;/&nbsp;false</code> | `1 / 0` |
+<<<<<<< HEAD
+| `string` | string จะถูกอ่าน "ตามที่เป็น" ส่วนช่องว่าง (รวมถึงเว้นวรรค tab `\t` ขึ้นบรรทัดใหม่ `\n` เป็นต้น) ที่ทั้งสองฝั่งจะถูกละเว้น string เปล่าจะกลายเป็น `0` เมื่อเกิด error จะได้เป็น `NaN` |
+=======
 | `string` | The string is read "as is", whitespaces (includes spaces, tabs `\t`, newlines `\n` etc.) from both sides are ignored. An empty string becomes `0`. An error gives `NaN`. |
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-**`Boolean Conversion`** -- Occurs in logical operations. Can be performed with `Boolean(value)`.
+**`การแปลงเป็น Boolean`** -- เกิดขึ้นในการดำเนินการเชิงตรรกะ สามารถทำได้ด้วย `Boolean(value)`
 
-Follows the rules:
+ทำตามกฎ:
 
-| Value |  Becomes... |
+| ค่า |  จะกลายเป็น... |
 |-------|-------------|
 |`0`, `null`, `undefined`, `NaN`, `""` |`false`|
-|any other value| `true` |
+|ค่าอื่นๆ| `true` |
 
 
-Most of these rules are easy to understand and memorize. The notable exceptions where people usually make mistakes are:
+กฎส่วนใหญ่เหล่านี้เข้าใจและจดจำได้ง่าย ข้อยกเว้นที่ควรทราบเพราะมักทำให้เกิดความสับสน ได้แก่:
 
-- `undefined` is `NaN` as a number, not `0`.
-- `"0"` and space-only strings like `"   "` are true as a boolean.
+- `undefined` จะเป็น `NaN` ในรูปแบบตัวเลข ไม่ใช่ `0` 
+- `"0"` และ string ที่มีแต่เว้นวรรคอย่าง `"   "` จะเป็น true ในรูปแบบ boolean
 
-Objects aren't covered here. We'll return to them later in the chapter <info:object-toprimitive> that is devoted exclusively to objects after we learn more basic things about JavaScript.
+ในที่นี้ยังไม่ได้ครอบคลุมถึง object เราจะกลับมาพูดถึงเรื่องนี้อีกครั้งในบท <info:object-toprimitive> ซึ่งอุทิศให้กับ object โดยเฉพาะ หลังจากที่เราได้เรียนรู้เรื่องพื้นฐานของ JavaScript เพิ่มเติมแล้ว
\ No newline at end of file
diff --git a/1-js/02-first-steps/08-operators/1-increment-order/solution.md b/1-js/02-first-steps/08-operators/1-increment-order/solution.md
index 8a44d798e..ea425ce76 100644
--- a/1-js/02-first-steps/08-operators/1-increment-order/solution.md
+++ b/1-js/02-first-steps/08-operators/1-increment-order/solution.md
@@ -1,5 +1,5 @@
 
-The answer is:
+คำตอบคือ:
 
 - `a = 2`
 - `b = 2`
@@ -9,10 +9,10 @@ The answer is:
 ```js run no-beautify
 let a = 1, b = 1;
 
-alert( ++a ); // 2, prefix form returns the new value
-alert( b++ ); // 1, postfix form returns the old value
+alert( ++a ); // 2, prefix form ส่งค่าใหม่กลับ
+alert( b++ ); // 1, postfix form ส่งค่าเก่ากลับ
 
-alert( a ); // 2, incremented once
-alert( b ); // 2, incremented once
+alert( a ); // 2, เพิ่มมา 1
+alert( b ); // 2, เพิ่มมา 1
 ```
 
diff --git a/1-js/02-first-steps/08-operators/1-increment-order/task.md b/1-js/02-first-steps/08-operators/1-increment-order/task.md
index 7db092389..d482f395d 100644
--- a/1-js/02-first-steps/08-operators/1-increment-order/task.md
+++ b/1-js/02-first-steps/08-operators/1-increment-order/task.md
@@ -2,9 +2,9 @@ importance: 5
 
 ---
 
-# The postfix and prefix forms
+# postfix และ prefix forms
 
-What are the final values of all variables `a`, `b`, `c` and `d` after the code below?
+อะไรคือผลลัพธ์สุดท้ายของตัสแปร `a`, `b`, `c` และ `d` จากโค้ดด้านล่าง
 
 ```js
 let a = 1, b = 1;
diff --git a/1-js/02-first-steps/08-operators/2-assignment-result/solution.md b/1-js/02-first-steps/08-operators/2-assignment-result/solution.md
index e3113b4cd..1d96247c0 100644
--- a/1-js/02-first-steps/08-operators/2-assignment-result/solution.md
+++ b/1-js/02-first-steps/08-operators/2-assignment-result/solution.md
@@ -1,5 +1,5 @@
-The answer is:
+คำตอบคือ:
 
-- `a = 4` (multiplied by 2)
-- `x = 5` (calculated as 1 + 4)
+- `a = 4` (คูณด้วย 2)
+- `x = 5` (เหมือนกับ 1 + 4)
 
diff --git a/1-js/02-first-steps/08-operators/2-assignment-result/task.md b/1-js/02-first-steps/08-operators/2-assignment-result/task.md
index 5345c9485..b8d789ce8 100644
--- a/1-js/02-first-steps/08-operators/2-assignment-result/task.md
+++ b/1-js/02-first-steps/08-operators/2-assignment-result/task.md
@@ -2,9 +2,9 @@ importance: 3
 
 ---
 
-# Assignment result
+# กำหนดค่าแล้วได้อะไร
 
-What are the values of `a` and `x` after the code below?
+อะไรคืือค่าของ `a` และ `x` จากโค้ดด้านล่าง?
 
 ```js
 let a = 2;
diff --git a/1-js/02-first-steps/08-operators/3-primitive-conversions-questions/solution.md b/1-js/02-first-steps/08-operators/3-primitive-conversions-questions/solution.md
index 7370b66af..26ee8185c 100644
--- a/1-js/02-first-steps/08-operators/3-primitive-conversions-questions/solution.md
+++ b/1-js/02-first-steps/08-operators/3-primitive-conversions-questions/solution.md
@@ -16,6 +16,15 @@ undefined + 1 = NaN // (6)
 " \t \n" - 2 = -2 // (7)
 ```
 
+<<<<<<< HEAD
+1. การบวกสตริงว่างกับเลขหนึ่ง `"" + 1` จะแปลงเลข `1` ให้เป็นสตริง : `"" + 1 = "1"` และ เราก็มี `"1" + 0` ต่อ ก็จะใช้กฎเดียวกัน
+2. การลบ `-` (จะเหมือนกับดำเนินการทางคณิตฯอื่นๆ) จะทำงานกับตัวเลขเท่านั้น ดังนั้นจะมันจึงแปลงสตริงว่างให้เป็นเลข `0`
+3. การบวกกับสตริง จะต่อท้ายเลข `5` กับสตริง
+4. การลบจะแปลงทุกอย่างเป็นตัวเลขเสมอ ดังนั้น `"  -9  "` จึงได้เลข `-9` (จะแปลงโดยที่ไม่สนใจ spaces ที่อยู่รอบเลขลบเก้าเลย)
+5. `null` จะกลายเป็นเลข `0` หากถูกแปลงเป็นตัวเลข
+6. `undefined` จะเป็นกลายเป็น `NaN` หากถูกแปลงเป็นตัวเลข
+ึึ7. space หน้าและหลังจะถูกตัดออก หากแปลงสตริงเป็นตัวเลข หากสตริงมีอักขระพิเศษอย่าง `\t`, `\n` และตามด้วย space ด้านหน้าและหลัง การแปลงเป็นตัวเลขจะตัด space หน้าและหลังออก ส่วน `\t`, `\n` จะกลายเป็นเลข `0`
+=======
 1. The addition with a string `"" + 1` converts `1` to a string: `"" + 1 = "1"`, and then we have `"1" + 0`, the same rule is applied.
 2. The subtraction `-` (like most math operations) only works with numbers, it converts an empty string `""` to `0`.
 3. The addition with a string appends the number `5` to the string.
@@ -23,3 +32,4 @@ undefined + 1 = NaN // (6)
 5. `null` becomes `0` after the numeric conversion.
 6. `undefined` becomes `NaN` after the numeric conversion.
 7. Space characters are trimmed off string start and end when a string is converted to a number. Here the whole string consists of space characters, such as `\t`, `\n` and a "regular" space between them. So, similarly to an empty string, it becomes `0`.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
diff --git a/1-js/02-first-steps/08-operators/3-primitive-conversions-questions/task.md b/1-js/02-first-steps/08-operators/3-primitive-conversions-questions/task.md
index 068420c7d..e963dfbcc 100644
--- a/1-js/02-first-steps/08-operators/3-primitive-conversions-questions/task.md
+++ b/1-js/02-first-steps/08-operators/3-primitive-conversions-questions/task.md
@@ -2,9 +2,9 @@ importance: 5
 
 ---
 
-# Type conversions
+# การแปลงชนิดข้อมูล
 
-What are results of these expressions?
+มาเดาผลลัพธ์จาก expression เหล่านี้กัน
 
 ```js no-beautify
 "" + 1 + 0
@@ -23,4 +23,4 @@ undefined + 1
 " \t \n" - 2
 ```
 
-Think well, write down and then compare with the answer.
+คิดให้ดีๆ เขียนลงในกระดาษแล้วลองเทียบกับเฉลยดูสิ
diff --git a/1-js/02-first-steps/08-operators/4-fix-prompt/solution.md b/1-js/02-first-steps/08-operators/4-fix-prompt/solution.md
index 209a0702c..40fa1d6cb 100644
--- a/1-js/02-first-steps/08-operators/4-fix-prompt/solution.md
+++ b/1-js/02-first-steps/08-operators/4-fix-prompt/solution.md
@@ -1,6 +1,6 @@
-The reason is that prompt returns user input as a string.
+เหตุผลคือพรอมต์จะส่งค่าอะไรที่ผู้ใช้กรอกมาเป็นสตริง
 
-So variables have values `"1"` and `"2"` respectively.
+ดังนั้น ตัวแปรทั้งสองจึงมีค่า `"1"` และ `"2"` ตามลำดับ
 
 ```js run
 let a = "1"; // prompt("First number?", 1);
@@ -8,10 +8,9 @@ let b = "2"; // prompt("Second number?", 2);
 
 alert(a + b); // 12
 ```
+เราควรที่จะแปลงสตริงให้เป็นตัวเลขเสียก่อนด้วยเติม `+` ไปข้างหน้ส หรือใช้ `Number()` แทนได้
 
-What we should do is to convert strings to numbers before `+`. For example, using `Number()` or prepending them with `+`.
-
-For example, right before `prompt`:
+ตัวอย่างใส่ก่อน `prompt`
 
 ```js run
 let a = +prompt("First number?", 1);
@@ -20,7 +19,7 @@ let b = +prompt("Second number?", 2);
 alert(a + b); // 3
 ```
 
-Or in the `alert`:
+หรือจะเป็นใน `alert`:
 
 ```js run
 let a = prompt("First number?", 1);
@@ -29,4 +28,4 @@ let b = prompt("Second number?", 2);
 alert(+a + +b); // 3
 ```
 
-Using both unary and binary `+` in the latest code. Looks funny, doesn't it?
+การใช้ทั้ง unary และ binary `+` ในโค้ดบรรทัดล่างสุด ดูตลกดีไหม?
diff --git a/1-js/02-first-steps/08-operators/4-fix-prompt/task.md b/1-js/02-first-steps/08-operators/4-fix-prompt/task.md
index b3ea4a3a3..07e851ffa 100644
--- a/1-js/02-first-steps/08-operators/4-fix-prompt/task.md
+++ b/1-js/02-first-steps/08-operators/4-fix-prompt/task.md
@@ -2,13 +2,13 @@ importance: 5
 
 ---
 
-# Fix the addition
+# ช่วยแก้ให้บวกถูกที
 
-Here's a code that asks the user for two numbers and shows their sum.
+นี่คือโค้ด ที่จะให้ผู้ใช้กรอกตัวเลขสองตัว แล้วจะโชว์ผลลัพธ์ของเลขทั้งสอง
 
-It works incorrectly. The output in the example below is `12` (for default prompt values).
+โค้ดชุดนี้ทำงานไม่ถูก ผลลัพธ์ดันเป็น `12`
 
-Why? Fix it. The result should be `3`.
+ทำไมล่ะ? ช่วยแก้ที ผลลัพธ์ควรจะเป็น `3` นะ
 
 ```js run
 let a = prompt("First number?", 1);
diff --git a/1-js/02-first-steps/08-operators/article.md b/1-js/02-first-steps/08-operators/article.md
index d52c37a17..a649e75b8 100644
--- a/1-js/02-first-steps/08-operators/article.md
+++ b/1-js/02-first-steps/08-operators/article.md
@@ -1,140 +1,157 @@
-# Basic operators, maths
+# ตัวดำเนินการพื้นฐานและคณิตศาสตร์
 
-We know many operators from school. They are things like addition `+`, multiplication `*`, subtraction `-`, and so on.
+หลายคนคุ้นเคยกับตัวดำเนินการทางคณิตศาสตร์มาตั้งแต่สมัยเรียนแล้ว ไม่ว่าจะเป็นการบวก `+` การคูณ `*` การลบ `-` และอื่นๆ อีกมากมาย 
 
-In this chapter, we’ll start with simple operators, then concentrate on JavaScript-specific aspects, not covered by school arithmetic.
+ในบทนี้ เราจะเริ่มต้นด้วยตัวดำเนินการพื้นฐาน จากนั้นจะเจาะลึกไปที่ลักษณะเฉพาะของ JavaScript ซึ่งไม่ได้เรียนกันในวิชาคณิตศาสตร์ทั่วไป
 
-## Terms: "unary", "binary", "operand"
+## ศัพท์น่ารู้: "unary", "binary", "operand" 
 
-Before we move on, let's grasp some common terminology.
+ก่อนจะเริ่มเรื่องต่อไป เรามาทำความเข้าใจศัพท์ที่ใช้กันทั่วไปเสียก่อน
 
-- *An operand* -- is what operators are applied to. For instance, in the multiplication of `5 * 2` there are two operands: the left operand is `5` and the right operand is `2`. Sometimes, people call these "arguments" instead of "operands".
-- An operator is *unary* if it has a single operand. For example, the unary negation `-` reverses the sign of a number:
+- _ตัวถูกดำเนินการ (operand)_ คือสิ่งที่ถูกนำไปคำนวณด้วยตัวดำเนินการนั่นเอง ยกตัวอย่างเช่น ในการคูณ `5 * 2` จะมีตัวถูกดำเนินการสองตัว ได้แก่ `5` ที่อยู่ทางซ้าย และ `2` ที่อยู่ทางขวา บางครั้งอาจเรียกตัวถูกดำเนินการว่า "อาร์กิวเมนต์ (argument)" แทนก็ได้
 
-    ```js run
-    let x = 1;
+- ตัวดำเนินการจะเป็นแบบ _unary_ หากมีตัวถูกดำเนินการเพียงตัวเดียว อย่างเช่น การกลับเครื่องหมาย `-` ที่จะกลับเครื่องหมายของตัวเลข:
 
-    *!*
-    x = -x;
-    */!*
-    alert( x ); // -1, unary negation was applied
-    ```
-- An operator is *binary* if it has two operands. The same minus exists in binary form as well:
+```js run
+<<<<<<< HEAD
+let x = 1;
 
-    ```js run no-beautify
-    let x = 1, y = 3;
-    alert( y - x ); // 2, binary minus subtracts values
-    ```
+*!*
+x = -x;
+*/!*
+
+alert( x ); // -1, มีการใช้ unary negation
+=======
+alert( 5 % 2 ); // 1, the remainder of 5 divided by 2
+alert( 8 % 3 ); // 2, the remainder of 8 divided by 3
+alert( 8 % 4 ); // 0, the remainder of 8 divided by 4
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
+```
+
+- ตัวดำเนินการจะเป็นแบบ _binary_ หากมีตัวถูกดำเนินการสองตัว เครื่องหมายลบก็มีในรูปแบบ binary ด้วยเช่นกัน:
 
-    Formally, in the examples above we have two different operators that share the same symbol: the negation operator, a unary operator that reverses the sign, and the subtraction operator, a binary operator that subtracts one number from another.
+```js run no-beautify
+let x = 1, y = 3;
+alert( y - x ); // 2, binary minus ใช้ลบค่าทั้งสองออกจากกัน  
+```
+
+ถ้าพูดอย่างเป็นทางการ ในตัวอย่างด้านบนมีตัวดำเนินการสองตัวที่ใช้สัญลักษณ์เดียวกัน นั่นคือ ตัวดำเนินการ negation ซึ่งเป็น unary ที่กลับเครื่องหมาย และตัวดำเนินการลบ ซึ่งเป็น binary ที่ลบจำนวนหนึ่งออกจากอีกจำนวนหนึ่ง
 
-## Maths
+## คณิตศาสตร์
 
-The following math operations are supported:
+JavaScript รองรับการดำเนินการทางคณิตศาสตร์ต่อไปนี้
 
-- Addition `+`,
-- Subtraction `-`,
-- Multiplication `*`,
-- Division `/`,
-- Remainder `%`,
-- Exponentiation `**`.
+- บวก `+`
+- ลบ `-`
+- คูณ `*` 
+- หาร `/`
+- หารเอาเศษ `%`
+- ยกกำลัง `**`
 
-The first four are straightforward, while `%` and `**` need a few words about them.
+สี่ตัวดำเนินการแรกนั้นไม่ต้องอธิบายอะไรมาก ส่วน `%` และ `**` ขออธิบายเพิ่มเติมสักนิด
 
-### Remainder %
+### การหารเอาเศษ %
 
-The remainder operator `%`, despite its appearance, is not related to percents.
+แม้จะดูคล้ายเปอร์เซ็นต์ แต่ตัวดำเนินการ `%` ไม่ได้เกี่ยวข้องกับเปอร์เซ็นต์เลย 
 
-The result of `a % b` is the [remainder](https://en.wikipedia.org/wiki/Remainder) of the integer division of `a` by `b`.
+ผลลัพธ์ของ `a % b` คือ [เศษ](https://en.wikipedia.org/wiki/Remainder) ที่ได้จากการหาร `a` ด้วย `b` แบบจำนวนเต็ม
 
-For instance:
+ยกตัวอย่างเช่น
 
 ```js run
-alert( 5 % 2 ); // 1, the remainder of 5 divided by 2
-alert( 8 % 3 ); // 2, the remainder of 8 divided by 3
-alert( 8 % 4 ); // 0, the remainder of 8 divided by 4
+alert( 5 % 2 ); // 1, เศษของ 5 หาร 2
+alert( 8 % 3 ); // 2, เศษของ 8 หาร 3
+alert( 8 % 4 ); // 0, เศษของ 8 หาร 4
 ```
 
-### Exponentiation **
+### การยกกำลัง **
 
-The exponentiation operator `a ** b` raises `a` to the power of `b`.
+ตัวดำเนินการยกกำลัง `a ** b` จะยกค่า `a` ด้วยเลขชี้กำลัง `b`
 
-In school maths, we write that as a<sup>b</sup>.
+ในวิชาคณิตศาสตร์ เราจะเขียนสิ่งนี้เป็น a<sup>b</sup>
 
-For instance:
+ยกตัวอย่างเช่น
 
 ```js run
 alert( 2 ** 2 ); // 2² = 4
 alert( 2 ** 3 ); // 2³ = 8
-alert( 2 ** 4 ); // 2⁴ = 16
+alert( 2 ** 4 ); // 2⁴ = 16 
 ```
 
+<<<<<<< HEAD
+เหมือนในคณิตศาสตร์ ตัวดำเนินการยกกำลังใช้กับจำนวนที่ไม่ใช่จำนวนเต็มได้ด้วย
+=======
 Just like in maths, the exponentiation operator is defined for non-integer numbers as well.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-For example, a square root is an exponentiation by ½:
+อย่างเช่น การหารากกำลังสองก็คือการยกกำลังด้วย ½
 
 ```js run
-alert( 4 ** (1/2) ); // 2 (power of 1/2 is the same as a square root)
-alert( 8 ** (1/3) ); // 2 (power of 1/3 is the same as a cubic root)
+alert( 4 ** (1/2) ); // 2 (ยกกำลัง 1/2 เท่ากับหารากกำลังสอง)
+alert( 8 ** (1/3) ); // 2 (ยกกำลัง 1/3 เท่ากับหารากกำลังสาม)
 ```
 
+## การต่อสตริงด้วย binary +
 
-## String concatenation with binary +
+ลองมาดูคุณสมบัติของตัวดำเนินการใน JavaScript ที่นอกเหนือจากคณิตศาสตร์ในห้องเรียนกันหน่อย
 
+<<<<<<< HEAD
+ปกติแล้ว ตัวดำเนินการบวก `+` ใช้สำหรับบวกตัวเลข
+=======
 Let's meet the features of JavaScript operators that are beyond school arithmetics.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-Usually, the plus operator `+` sums numbers.
-
-But, if the binary `+` is applied to strings, it merges (concatenates) them:
+แต่ถ้าใช้ `+` แบบ binary กับสตริง มันจะเชื่อม (ต่อ) สตริงเข้าด้วยกัน
 
 ```js
 let s = "my" + "string";
 alert(s); // mystring
 ```
 
-Note that if any of the operands is a string, then the other one is converted to a string too.
+ข้อสังเกตคือ ถ้าตัวถูกดำเนินการตัวใดตัวหนึ่งเป็นสตริง ตัวอื่นก็จะถูกแปลงเป็นสตริงเช่นกัน
 
-For example:
+ยกตัวอย่างเช่น
 
 ```js run
 alert( '1' + 2 ); // "12"
 alert( 2 + '1' ); // "21"
 ```
 
-See, it doesn't matter whether the first operand is a string or the second one.
+จะเห็นว่าไม่สำคัญว่าสตริงจะอยู่ตัวถูกดำเนินการตัวแรกหรือตัวที่สองก็ตาม
 
-Here's a more complex example:
+ลองดูตัวอย่างที่ซับซ้อนขึ้นอีกนิด
 
 ```js run
-alert(2 + 2 + '1' ); // "41" and not "221"
+alert(2 + 2 + '1' ); // "41" ไม่ใช่ "221"
 ```
 
-Here, operators work one after another. The first `+` sums two numbers, so it returns `4`, then the next `+` adds the string `1` to it, so it's like `4 + '1' = '41'`.
+ในที่นี้ ตัวดำเนินการจะทำงานทีละตัว `+` ตัวแรกจะบวกเลขสองจำนวน ได้ผลเป็น `4`, จากนั้น `+` ตัวถัดไปก็นำ `4` ไปต่อกับสตริง `'1'` เหมือนกับการเขียน `4 + '1' = '41'`
 
 ```js run
-alert('1' + 2 + 2); // "122" and not "14"
+alert('1' + 2 + 2); // "122" ไม่ใช่ "14"
 ```
-Here, the first operand is a string, the compiler treats the other two operands as strings too. The `2` gets concatenated to `'1'`, so it's like `'1' + 2 = "12"` and `"12" + 2 = "122"`.
 
-The binary `+` is the only operator that supports strings in such a way. Other arithmetic operators work only with numbers and always convert their operands to numbers.
+ในตัวอย่างนี้ ตัวถูกดำเนินการตัวแรกเป็นสตริง ตัวแปลภาษาจึงมองว่าตัวถูกดำเนินการอีกสองตัวเป็นสตริงด้วย `2` จะถูกเชื่อมต่อท้าย `'1'` เหมือนการเขียน `'1' + 2 = "12"` และ `"12" + 2 = "122"`
+
+`+` แบบ binary เป็นตัวดำเนินการตัวเดียวที่รองรับการทำงานกับสตริงในลักษณะนี้ ส่วนตัวดำเนินการคณิตศาสตร์อื่นๆ จะทำงานกับตัวเลขเท่านั้น และจะแปลงค่าตัวถูกดำเนินการเป็นตัวเลขเสมอ
 
-Here's the demo for subtraction and division:
+ต่อไปนี้คือตัวอย่างของการลบและการหาร
 
 ```js run
-alert( 6 - '2' ); // 4, converts '2' to a number
-alert( '6' / '2' ); // 3, converts both operands to numbers
+alert( 6 - '2' ); // 4, แปลง '2' เป็นตัวเลข
+alert( '6' / '2' ); // 3, แปลงตัวถูกดำเนินการทั้งสองตัวเป็นตัวเลข
 ```
 
-## Numeric conversion, unary +
+## การแปลงเป็นตัวเลข, unary +
 
-The plus `+` exists in two forms: the binary form that we used above and the unary form.
+เครื่องหมาย `+` มีสองรูปแบบคือ แบบ binary ที่ใช้ข้างบน และแบบ unary
 
-The unary plus or, in other words, the plus operator `+` applied to a single value, doesn't do anything to numbers. But if the operand is not a number, the unary plus converts it into a number.
+unary plus หรือพูดอีกอย่างคือ ตัวดำเนินการบวก `+` ที่ใช้กับค่าเดี่ยว จะไม่ส่งผลอะไรกับตัวเลข แต่ถ้าตัวถูกดำเนินการไม่ใช่ตัวเลข unary plus จะแปลงให้เป็นตัวเลข
 
-For example:
+ตัวอย่างเช่น
 
 ```js run
-// No effect on numbers
+// ไม่มีผลกับตัวเลข
 let x = 1;
 alert( +x ); // 1
 
@@ -142,62 +159,66 @@ let y = -2;
 alert( +y ); // -2
 
 *!*
-// Converts non-numbers
+// แปลงสิ่งที่ไม่ใช่ตัวเลข
 alert( +true ); // 1
 alert( +"" );   // 0
 */!*
 ```
 
-It actually does the same thing as `Number(...)`, but is shorter.
+โดยทำงานเหมือนกับ `Number(...)` เลย แต่เขียนได้สั้นกว่า
 
-The need to convert strings to numbers arises very often. For example, if we are getting values from HTML form fields, they are usually strings. What if we want to sum them?
+เรามักจำเป็นต้องแปลงสตริงเป็นตัวเลขอยู่บ่อยๆ เช่น เวลารับค่าจากช่องกรอกข้อมูลใน HTML ค่าเหล่านั้นมักอยู่ในรูปสตริง แล้วถ้าเราต้องการบวกมันเข้าด้วยกันล่ะ?
 
-The binary plus would add them as strings:
+binary plus จะเอาสตริงมาต่อกัน
 
 ```js run
 let apples = "2";
 let oranges = "3";
 
-alert( apples + oranges ); // "23", the binary plus concatenates strings
+alert( apples + oranges ); // "23", binary plus ต่อสตริงเข้าด้วยกัน
 ```
 
-If we want to treat them as numbers, we need to convert and then sum them:
+หากต้องการให้เป็นตัวเลข ต้องแปลงค่าก่อนแล้วจึงบวกกัน
 
 ```js run
 let apples = "2";
 let oranges = "3";
 
 *!*
-// both values converted to numbers before the binary plus
+// ค่าทั้งสองถูกแปลงเป็นตัวเลขก่อนใช้ binary plus
 alert( +apples + +oranges ); // 5
 */!*
 
-// the longer variant
+// หรือเขียนแบบยาวๆ ก็ได้
 // alert( Number(apples) + Number(oranges) ); // 5
 ```
 
-From a mathematician's standpoint, the abundance of pluses may seem strange. But from a programmer's standpoint, there's nothing special: unary pluses are applied first, they convert strings to numbers, and then the binary plus sums them up.
+มองในแง่ของนักคณิตศาสตร์ เครื่องหมายบวกที่เยอะแยะอาจดูแปลกๆ แต่สำหรับโปรแกรมเมอร์แล้วไม่มีอะไรพิเศษ unary plus จะถูกใช้กับค่าก่อน เพื่อแปลงสตริงเป็นตัวเลข จากนั้น binary plus จึงเอาตัวเลขมาบวกกัน
 
-Why are unary pluses applied to values before the binary ones? As we're going to see, that's because of their *higher precedence*.
+ทำไม unary plus ถึงถูกใช้กับค่าก่อน binary plus? อย่างที่เราจะได้เห็นต่อไป นั่นเป็นเพราะว่ามันมี *ลำดับความสำคัญ (precedence) ที่สูงกว่า*
 
-## Operator precedence
+## ลำดับความสำคัญของตัวดำเนินการ
 
-If an expression has more than one operator, the execution order is defined by their *precedence*, or, in other words, the default priority order of operators.
+หากนิพจน์มีตัวดำเนินการมากกว่าหนึ่งตัว ลำดับการประมวลผลจะถูกกำหนดโดย *ลำดับความสำคัญ* หรือพูดอีกนัยหนึ่งคือ ลำดับความสำคัญเริ่มต้นของตัวดำเนินการนั่นเอง
 
-From school, we all know that the multiplication in the expression `1 + 2 * 2` should be calculated before the addition. That's exactly the precedence thing. The multiplication is said to have *a higher precedence* than the addition.
+พวกเราทุกคนเรียนรู้ตั้งแต่สมัยอยู่ในโรงเรียนแล้วว่าในนิพจน์ `1 + 2 * 2` ต้องคำนวณการคูณก่อนการบวก นั่นแหละคือสิ่งที่เรียกว่าลำดับความสำคัญ การคูณถือว่ามี *ลำดับความสำคัญสูงกว่า* การบวก
 
-Parentheses override any precedence, so if we're not satisfied with the default order, we can use them to change it. For example, write `(1 + 2) * 2`.
+วงเล็บสามารถแทนที่ลำดับความสำคัญใดๆ ก็ได้ ดังนั้นหากเราไม่พอใจกับลำดับเริ่มต้น เราก็สามารถใช้วงเล็บเพื่อเปลี่ยนแปลงได้ เช่น เขียนเป็น `(1 + 2) * 2`
 
-There are many operators in JavaScript. Every operator has a corresponding precedence number. The one with the larger number executes first. If the precedence is the same, the execution order is from left to right.
+JavaScript มีตัวดำเนินการอยู่มากมาย แต่ละตัวจะมีตัวเลขลำดับความสำคัญของตัวเอง ตัวที่มีค่ามากกว่าจะถูกประมวลผลก่อน หากลำดับความสำคัญเท่ากัน ลำดับการประมวลผลจะเป็นจากซ้ายไปขวา
 
-Here's an extract from the [precedence table](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence) (you don't need to remember this, but note that unary operators are higher than corresponding binary ones):
+ต่อไปนี้คือข้อมูลบางส่วนจาก[ตารางลำดับความสำคัญ](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence) (คุณไม่จำเป็นต้องจำ แต่ให้สังเกตว่า unary operator จะสูงกว่า binary operator ที่เทียบเท่ากัน):
 
-| Precedence | Name | Sign |
+| ลำดับความสำคัญ | ชื่อ | เครื่องหมาย |
 |------------|------|------|
 | ... | ... | ... |
 | 14 | unary plus | `+` |
 | 14 | unary negation | `-` |
+<<<<<<< HEAD
+| 13 | exponentiation | `**` |  
+=======
 | 13 | exponentiation | `**` |
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 | 12 | multiplication | `*` |
 | 12 | division | `/` |
 | 11 | addition | `+` |
@@ -206,13 +227,17 @@ Here's an extract from the [precedence table](https://developer.mozilla.org/en-U
 | 2 | assignment | `=` |
 | ... | ... | ... |
 
+<<<<<<< HEAD
+ดังที่เห็น "unary plus" มีลำดับความสำคัญ `14` ซึ่งสูงกว่า "addition" (binary plus) ที่มีค่า `11` นั่นจึงเป็นเหตุผลว่าทำไมในนิพจน์ `"+apples + +oranges"` unary plus จึงทำงานก่อน addition
+=======
 As we can see, the "unary plus" has a priority of `14` which is higher than the `11` of "addition" (binary plus). That's why, in the expression `"+apples + +oranges"`, unary pluses work before the addition.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-## Assignment
+## การกำหนดค่า (Assignment)
 
-Let's note that an assignment `=` is also an operator. It is listed in the precedence table with the very low priority of `2`.
+เราขอเน้นย้ำว่า assignment `=` ก็ถือเป็นตัวดำเนินการเช่นกัน มันปรากฏอยู่ในตารางลำดับความสำคัญด้วยค่าที่ต่ำมากคือ `2`
 
-That's why, when we assign a variable, like `x = 2 * 2 + 1`, the calculations are done first and then the `=` is evaluated, storing the result in `x`.
+นั่นจึงเป็นเหตุผลว่าทำไมเวลาที่เรากำหนดค่าให้กับตัวแปร เช่น `x = 2 * 2 + 1` การคำนวณจะเสร็จสิ้นก่อน แล้วจึงเริ่มประเมิน `=` และเก็บผลลัพธ์ไว้ใน `x`
 
 ```js
 let x = 2 * 2 + 1;
@@ -220,15 +245,15 @@ let x = 2 * 2 + 1;
 alert( x ); // 5
 ```
 
-### Assignment = returns a value
+### Assignment = คืนค่ากลับ
 
-The fact of `=` being an operator, not a "magical" language construct has an interesting implication.
+ข้อเท็จจริงที่ว่า `=` เป็นตัวดำเนินการ ไม่ใช่ส่วนประกอบ "วิเศษ" ของภาษา มีนัยยะบางอย่างที่น่าสนใจ
 
-All operators in JavaScript return a value. That's obvious for `+` and `-`, but also true for `=`.
+ตัวดำเนินการทุกตัวใน JavaScript จะคืนค่ากลับเสมอ ซึ่งชัดเจนสำหรับ `+` และ `-` รวมถึงเป็นความจริงสำหรับ `=` ด้วย
 
-The call `x = value` writes the `value` into `x` *and then returns it*.
+การเรียก `x = value` จะเขียน `value` ลงใน `x` *แล้วคืนค่านั้นกลับมา*
 
-Here's a demo that uses an assignment as part of a more complex expression:
+นี่คือตัวอย่างที่ใช้ assignment เป็นส่วนหนึ่งของนิพจน์ที่ซับซ้อนกว่า:
 
 ```js run
 let a = 1;
@@ -240,17 +265,17 @@ let c = 3 - (a = b + 1);
 
 alert( a ); // 3
 alert( c ); // 0
-```
+```  
 
-In the example above, the result of expression `(a = b + 1)` is the value which was assigned to `a` (that is `3`). It is then used for further evaluations.
+ในตัวอย่างข้างต้น ผลลัพธ์ของนิพจน์ `(a = b + 1)` คือค่าที่ถูก assign ให้ `a` (นั่นก็คือ `3`) ซึ่งถูกนำไปใช้ในการประเมินค่าต่อไป
 
-Funny code, isn't it? We should understand how it works, because sometimes we see it in JavaScript libraries.
+โค้ดนี้ดูตลกไปหน่อยนะ เราควรเข้าใจว่ามันทำงานอย่างไร เพราะบางครั้งเราจะเห็นมันในไลบรารี JavaScript
 
-Although, please don't write the code like that. Such tricks definitely don't make code clearer or readable.
+อย่างไรก็ตาม โปรดอย่าเขียนโค้ดแบบนั้นเลย เล่ห์เหลี่ยมเช่นนี้ไม่ได้ช่วยให้โค้ดชัดเจนหรืออ่านง่ายขึ้นแน่นอน
 
-### Chaining assignments
+### การต่อ assignment แบบลูกโซ่
 
-Another interesting feature is the ability to chain assignments:
+อีกฟีเจอร์ที่น่าสนใจคือความสามารถในการต่อ assignment แบบลูกโซ่:  
 
 ```js run
 let a, b, c;
@@ -264,90 +289,94 @@ alert( b ); // 4
 alert( c ); // 4
 ```
 
-Chained assignments evaluate from right to left. First, the rightmost expression `2 + 2` is evaluated and then assigned to the variables on the left: `c`, `b` and `a`. At the end, all the variables share a single value.
+assignment แบบลูกโซ่จะถูกประเมินจากขวาไปซ้าย แรกสุด นิพจน์ `2 + 2` ทางขวาสุดจะถูกประเมิน แล้วจึง assign ให้กับตัวแปรทางซ้าย ได้แก่ `c`, `b` และ `a` ตามลำดับ ในท้ายที่สุด ตัวแปรทุกตัวจะมีค่าเดียวกัน
 
-Once again, for the purposes of readability it's better to split such code into few lines:
+อีกครั้ง เพื่อความง่ายต่อการอ่าน เราควรแยกโค้ดแบบนี้ออกเป็นสองสามบรรทัด:
 
 ```js
 c = 2 + 2;
 b = c;
 a = c;
 ```
-That's easier to read, especially when eye-scanning the code fast.
 
-## Modify-in-place
+แบบนี้อ่านง่ายกว่า โดยเฉพาะเวลาที่เรากวาดตามองโค้ดอย่างเร็วๆ
+
+## การปรับค่าในตัวแปรโดยตรง
 
-We often need to apply an operator to a variable and store the new result in that same variable.
+เรามักจะต้องนำตัวดำเนินการไปใช้กับตัวแปรและเก็บผลลัพธ์ใหม่ลงในตัวแปรนั้นเอง
 
-For example:
+ตัวอย่างเช่น:
 
 ```js
 let n = 2;
 n = n + 5;
-n = n * 2;
+n = n * 2;  
 ```
 
-This notation can be shortened using the operators `+=` and `*=`:
+เราสามารถเขียนโค้ดข้างต้นให้สั้นลงได้โดยใช้ตัวดำเนินการ `+=` และ `*=`:
 
 ```js run
 let n = 2;
-n += 5; // now n = 7 (same as n = n + 5)
-n *= 2; // now n = 14 (same as n = n * 2)
+n += 5; // ตอนนี้ n = 7 (เหมือนกับการเขียน n = n + 5)
+n *= 2; // ตอนนี้ n = 14 (เหมือนกับการเขียน n = n * 2)
 
-alert( n ); // 14
+alert( n ); // 14  
 ```
 
-Short "modify-and-assign" operators exist for all arithmetical and bitwise operators: `/=`, `-=`, etc.
+ตัวดำเนินการ "ปรับค่าและกำหนดค่า" แบบสั้นๆ นี้มีให้ใช้งานสำหรับตัวดำเนินการทางคณิตศาสตร์และระดับบิต (Bitwise) ทุกตัว เช่น `/=`, `-=` เป็นต้น
 
-Such operators have the same precedence as a normal assignment, so they run after most other calculations:
+ตัวดำเนินการเหล่านี้จะมีลำดับความสำคัญเท่ากับการกำหนดค่าปกติ ดังนั้นพวกมันจะทำงานหลังจากการคำนวณส่วนอื่นๆ เสร็จสิ้นแล้ว:
 
 ```js run
 let n = 2;
 
+<<<<<<< HEAD
+n *= 3 + 5; // คำนวณทางด้านขวาก่อน เหมือนกับการเขียน n *= 8
+=======
 n *= 3 + 5; // right part evaluated first, same as n *= 8
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
 alert( n ); // 16
 ```
 
-## Increment/decrement
+## การเพิ่ม/ลดค่า
 
-<!-- Can't use -- in title, because the built-in parser turns it into a 'long dash' – -->
+การเพิ่มหรือลดค่าตัวเลขทีละ 1 ถือเป็นหนึ่งในการดำเนินการทางตัวเลขที่ใช้บ่อยที่สุด 
 
-Increasing or decreasing a number by one is among the most common numerical operations.
+ดังนั้น จึงมีตัวดำเนินการพิเศษสำหรับกรณีนี้:
 
-So, there are special operators for it:
-
-- **Increment** `++` increases a variable by 1:
+- **Increment** `++` ใช้เพิ่มค่าตัวแปรขึ้นทีละ 1:
 
     ```js run no-beautify
     let counter = 2;
-    counter++;        // works the same as counter = counter + 1, but is shorter
+    counter++;        // ทำงานเหมือนกับ counter = counter + 1 แต่เขียนสั้นกว่า
     alert( counter ); // 3
     ```
-- **Decrement** `--` decreases a variable by 1:
+
+- **Decrement** `--` ใช้ลดค่าตัวแปรลงทีละ 1:
 
     ```js run no-beautify
     let counter = 2;
-    counter--;        // works the same as counter = counter - 1, but is shorter
+    counter--;        // ทำงานเหมือนกับ counter = counter - 1 แต่เขียนสั้นกว่า  
     alert( counter ); // 1
     ```
 
 ```warn
-Increment/decrement can only be applied to variables. Trying to use it on a value like `5++` will give an error.
+Increment/decrement สามารถใช้ได้กับตัวแปรเท่านั้น หากพยายามใช้กับค่าตรงๆ เช่น `5++` จะทำให้เกิด error
 ```
 
-The operators `++` and `--` can be placed either before or after a variable.
+ตัวดำเนินการ `++` และ `--` สามารถวางไว้ด้านหน้าหรือด้านหลังตัวแปรก็ได้
 
-- When the operator goes after the variable, it is in "postfix form": `counter++`.
-- The "prefix form" is when the operator goes before the variable: `++counter`.
+- เมื่อตัวดำเนินการอยู่หลังตัวแปร เรียกว่ารูปแบบ "postfix": `counter++`
+- รูปแบบ "prefix" คือเมื่อตัวดำเนินการอยู่หน้าตัวแปร: `++counter` 
 
-Both of these statements do the same thing: increase `counter` by `1`.
+ทั้งสองแบบทำงานเหมือนกันคือเพิ่มค่า `counter` ขึ้น `1`
 
-Is there any difference? Yes, but we can only see it if we use the returned value of `++/--`.
+แล้วมีความแตกต่างกันไหม? มี แต่เราจะเห็นได้ก็ต่อเมื่อนำค่าที่ส่งกลับจาก `++/--` ไปใช้เท่านั้น
 
-Let's clarify. As we know, all operators return a value. Increment/decrement is no exception. The prefix form returns the new value while the postfix form returns the old value (prior to increment/decrement).
+เรามาทำความเข้าใจให้ชัดเจนกัน อย่างที่ทราบกันว่าตัวดำเนินการทุกตัวจะส่งค่ากลับ Increment/decrement ก็เช่นกัน รูปแบบ prefix จะส่งค่าใหม่กลับ ส่วนรูปแบบ postfix จะส่งค่าเดิมก่อนการเพิ่ม/ลดค่ากลับ
 
-To see the difference, here's an example:
+ลองดูตัวอย่างนี้เพื่อให้เห็นความแตกต่าง:
 
 ```js run
 let counter = 1;
@@ -356,79 +385,80 @@ let a = ++counter; // (*)
 alert(a); // *!*2*/!*
 ```
 
-In the line `(*)`, the *prefix* form `++counter` increments `counter` and returns the new value, `2`. So, the `alert` shows `2`.
+ในบรรทัด `(*)` รูปแบบ *prefix* `++counter` จะเพิ่มค่า `counter` ก่อนแล้วส่งค่าใหม่ `2` กลับ ดังนั้น `alert` จึงแสดงเลข `2`
 
-Now, let's use the postfix form:
+ทีนี้ลองใช้รูปแบบ postfix ดูบ้าง:
 
 ```js run
 let counter = 1;
-let a = counter++; // (*) changed ++counter to counter++
+let a = counter++; // (*) เปลี่ยนจาก ++counter เป็น counter++
 
 alert(a); // *!*1*/!*
 ```
 
-In the line `(*)`, the *postfix* form `counter++` also increments `counter` but returns the *old* value (prior to increment). So, the `alert` shows `1`.
+ในบรรทัด `(*)` รูปแบบ *postfix* `counter++` ก็เพิ่มค่า `counter` เหมือนกัน แต่จะส่งค่า *เดิม* ก่อนการเพิ่มค่ากลับ ดังนั้น `alert` จึงแสดงเลข `1`
 
-To summarize:
+สรุปได้ดังนี้:
 
-- If the result of increment/decrement is not used, there is no difference in which form to use:
+- ถ้าไม่ได้นำผลลัพธ์ของ increment/decrement ไปใช้ต่อ ไม่ว่าจะใช้รูปแบบไหนก็ไม่ต่างกัน:
 
     ```js run
     let counter = 0;
     counter++;
     ++counter;
-    alert( counter ); // 2, the lines above did the same
+    alert( counter ); // 2, บรรทัดข้างบนให้ผลเหมือนกัน
     ```
-- If we'd like to increase a value *and* immediately use the result of the operator, we need the prefix form:
 
-    ```js run
+- ถ้าต้องการเพิ่มค่า *และ* นำผลลัพธ์ของตัวดำเนินการไปใช้ทันที ต้องใช้รูปแบบ prefix:
+
+    ```js run  
     let counter = 0;
     alert( ++counter ); // 1
     ```
-- If we'd like to increment a value but use its previous value, we need the postfix form:
+
+- ถ้าต้องการเพิ่มค่า แต่นำค่าก่อนหน้าไปใช้ ต้องใช้รูปแบบ postfix:
 
     ```js run
     let counter = 0;
-    alert( counter++ ); // 0
+    alert( counter++ ); // 0  
     ```
 
-````smart header="Increment/decrement among other operators"
-The operators `++/--` can be used inside expressions as well. Their precedence is higher than most other arithmetical operations.
+```smart header="Increment/decrement ท่ามกลางตัวดำเนินการอื่นๆ"
+ตัวดำเนินการ `++/--` สามารถใช้ภายในนิพจน์ได้ด้วย ลำดับความสำคัญของมันสูงกว่าการดำเนินการทางคณิตศาสตร์ส่วนใหญ่
 
-For instance:
+ตัวอย่างเช่น:
 
 ```js run
 let counter = 1;
 alert( 2 * ++counter ); // 4
 ```
 
-Compare with:
+เปรียบเทียบกับ:
 
 ```js run
 let counter = 1;
-alert( 2 * counter++ ); // 2, because counter++ returns the "old" value
+alert( 2 * counter++ ); // 2, เพราะ counter++ ส่งค่า "เดิม" กลับ  
 ```
 
-Though technically okay, such notation usually makes code less readable. One line does multiple things -- not good.
+ถึงแม้ในแง่เทคนิคจะใช้ได้ แต่การเขียนแบบนี้มักจะทำให้โค้ดอ่านเข้าใจยากขึ้น เพราะทำหลายอย่างในบรรทัดเดียว ซึ่งไม่ค่อยดีนัก
 
-While reading code, a fast "vertical" eye-scan can easily miss something like `counter++` and it won't be obvious that the variable increased.
+ระหว่างอ่านโค้ด การสแกนตามแนวดิ่งอย่างรวดเร็วอาจมองข้าม `counter++` ไปได้ง่าย และมันก็ไม่ชัดเจนว่าค่าตัวแปรเพิ่มขึ้น
 
-We advise a style of "one line -- one action":
+เราแนะนำให้เขียนแบบ "หนึ่งบรรทัด -- หนึ่งการกระทำ":
 
 ```js run
 let counter = 1;
 alert( 2 * counter );
 counter++;
 ```
-````
 
-## Bitwise operators
+## ตัวดำเนินการระดับบิต (Bitwise)
 
-Bitwise operators treat arguments as 32-bit integer numbers and work on the level of their binary representation.
+ตัวดำเนินการระดับบิต (Bitwise) จะปฏิบัติต่ออาร์กิวเมนต์เป็นจำนวนเต็ม 32 บิต และดำเนินการในระดับการแสดงผลเป็นเลขฐานสอง
 
-These operators are not JavaScript-specific. They are supported in most programming languages.
+ตัวดำเนินการเหล่านี้ไม่ได้เฉพาะเจาะจงกับ JavaScript แต่รองรับในภาษาโปรแกรมส่วนใหญ่
 
-The list of operators:
+ตัวดำเนินการมีดังนี้:
 
 - AND ( `&` )
 - OR ( `|` )
@@ -438,43 +468,47 @@ The list of operators:
 - RIGHT SHIFT ( `>>` )
 - ZERO-FILL RIGHT SHIFT ( `>>>` )
 
+<<<<<<< HEAD
+ตัวดำเนินการเหล่านี้ใช้น้อยมาก เว้นแต่เมื่อเราต้องจัดการกับตัวเลขในระดับ bitwise โดยเฉพาะ เราอาจจะไม่ต้องใช้มันในเร็วๆ นี้ เนื่องจากการพัฒนาเว็บแทบจะไม่ได้ประยุกต์ใช้ แต่ในบางด้านเช่น การเข้ารหัสลับ พวกมันก็ยังมีประโยชน์ คุณสามารถอ่านบท [Bitwise Operators](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Expressions_and_Operators#bitwise_operators) บน MDN เมื่อจำเป็นต้องใช้
+=======
 These operators are used very rarely, when we need to fiddle with numbers on the very lowest (bitwise) level. We won't need these operators any time soon, as web development has little use of them, but in some special areas, such as cryptography, they are useful. You can read the [Bitwise Operators](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Expressions_and_Operators#bitwise_operators) chapter on MDN when a need arises.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-## Comma
+## ตัวดำเนินการเครื่องหมายจุลภาค (Comma)
 
-The comma operator `,` is one of the rarest and most unusual operators. Sometimes, it's used to write shorter code, so we need to know it in order to understand what's going on.
+ตัวดำเนินการเครื่องหมายจุลภาค `,` เป็นหนึ่งในตัวดำเนินการที่พบได้ยากและแปลกประหลาดที่สุด บางครั้งคนใช้มันเพื่อเขียนโค้ดให้สั้นลง เราจึงจำเป็นต้องรู้จักไว้เพื่อให้เข้าใจว่าโค้ดกำลังทำอะไร
 
-The comma operator allows us to evaluate several expressions, dividing them with a comma `,`. Each of them is evaluated but only the result of the last one is returned.
+ตัวดำเนินการเครื่องหมายจุลภาคทำให้เราสามารถประเมินนิพจน์ได้หลายตัว โดยคั่นด้วยเครื่องหมายจุลภาค `,` แต่ละนิพจน์จะถูกประเมินผล แต่จะส่งเฉพาะผลลัพธ์ของนิพจน์ตัวสุดท้ายกลับมา
 
-For example:
+ตัวอย่างเช่น:
 
 ```js run
 *!*
 let a = (1 + 2, 3 + 4);
 */!*
 
-alert( a ); // 7 (the result of 3 + 4)
+alert( a ); // 7 (ผลลัพธ์จาก 3 + 4)
 ```
 
-Here, the first expression `1 + 2` is evaluated and its result is thrown away. Then, `3 + 4` is evaluated and returned as the result.
+ในตัวอย่างนี้ นิพจน์แรก `1 + 2` จะถูกประเมินผลแต่ทิ้งผลลัพธ์ไป จากนั้น `3 + 4` จึงถูกประเมินและส่งค่ากลับมาเป็นผลลัพธ์
 
-```smart header="Comma has a very low precedence"
-Please note that the comma operator has very low precedence, lower than `=`, so parentheses are important in the example above.
+```smart header="เครื่องหมายจุลภาคมีลำดับความสำคัญต่ำมาก"
+โปรดสังเกตว่าตัวดำเนินการเครื่องหมายจุลภาคมีระดับความสำคัญต่ำมาก ต่ำกว่า `=` ดังนั้นวงเล็บจึงสำคัญในตัวอย่างข้างต้น
 
-Without them: `a = 1 + 2, 3 + 4` evaluates `+` first, summing the numbers into `a = 3, 7`, then the assignment operator `=` assigns `a = 3`, and the rest is ignored. It's like `(a = 1 + 2), 3 + 4`.
+หากไม่ใส่วงเล็บ: `a = 1 + 2, 3 + 4` จะประเมิน `+` ก่อน รวมผลเป็น `a = 3, 7` จากนั้นตัวดำเนินการ `=` จะกำหนดค่า `a = 3` และเพิกเฉยต่อส่วนที่เหลือ เสมือนเขียนเป็น `(a = 1 + 2), 3 + 4` 
 ```
 
-Why do we need an operator that throws away everything except the last expression?
+แล้วทำไมเราถึงต้องการตัวดำเนินการที่ทิ้งทุกอย่างยกเว้นนิพจน์ตัวสุดท้าย?
 
-Sometimes, people use it in more complex constructs to put several actions in one line.
+บางครั้งคนใช้มันในโครงสร้างที่ซับซ้อนกว่า เพื่อรวมหลายการกระทำไว้ในบรรทัดเดียว
 
-For example:
+ตัวอย่างเช่น:
 
 ```js
-// three operations in one line
+// รวมสามการกระทำในบรรทัดเดียว
 for (*!*a = 1, b = 3, c = a * b*/!*; a < 10; a++) {
- ...
+ ...  
 }
 ```
 
-Such tricks are used in many JavaScript frameworks. That's why we're mentioning them. But usually they don't improve code readability so we should think well before using them.
+เทคนิคเช่นนี้ถูกใช้ในหลายเฟรมเวิร์กของ JavaScript นั่นเป็นเหตุผลที่เรากล่าวถึงมัน แต่โดยทั่วไปแล้วมันไม่ได้ช่วยให้โค้ดอ่านง่ายขึ้นเลย เราควรคิดให้ดีก่อนนำมาใช้
\ No newline at end of file
diff --git a/1-js/02-first-steps/09-comparison/1-comparison-questions/solution.md b/1-js/02-first-steps/09-comparison/1-comparison-questions/solution.md
index 632b1cf4e..90432456d 100644
--- a/1-js/02-first-steps/09-comparison/1-comparison-questions/solution.md
+++ b/1-js/02-first-steps/09-comparison/1-comparison-questions/solution.md
@@ -10,12 +10,12 @@ null == "\n0\n" → false
 null === +"\n0\n" → false
 ```
 
-Some of the reasons:
+เฉลย:
 
-1. Obviously, true.
-2. Dictionary comparison, hence false. `"a"` is smaller than `"p"`.
-3. Again, dictionary comparison, first char `"2"` is greater than the first char `"1"`.
-4. Values `null` and `undefined` equal each other only.
-5. Strict equality is strict. Different types from both sides lead to false.
-6. Similar to `(4)`, `null` only equals `undefined`.
-7. Strict equality of different types.
+1. ได้ true แน่นอน
+2. การเปรียบเทียบตามลำดับ Unicode ดังนั้น `"a"` น้อยกว่า `"p"`
+3. การเปรียบเทียบตามลำดับ Unicode ดังนั้น `"2"` มากกว่า `"1"`.
+4. ค่า `null` และ `undefined` เท่ากันเสมอ เมื่อเทียบด้วย `==`
+5. Strict equality นั้นเข้มงวด มันจะตรวจสอบชนิดของข้อมูลด้วย หากชนิดไม่เหมือนกัน ก็ได้จะ false
+6. เหมือนกับข้อ `(4)` `null` จะเท่ากับ `undefined` เท่านั้น
+7. เหมือนกับข้อ `(5)`
diff --git a/1-js/02-first-steps/09-comparison/1-comparison-questions/task.md b/1-js/02-first-steps/09-comparison/1-comparison-questions/task.md
index be7f75ddd..818807231 100644
--- a/1-js/02-first-steps/09-comparison/1-comparison-questions/task.md
+++ b/1-js/02-first-steps/09-comparison/1-comparison-questions/task.md
@@ -2,9 +2,9 @@ importance: 5
 
 ---
 
-# Comparisons
+# การเปรียบเทียบ
 
-What will be the result for these expressions?
+มาเดาผลลัพธ์ที่เกิดจากนิพจน์ด้านล่างกัน
 
 ```js no-beautify
 5 > 4
diff --git a/1-js/02-first-steps/09-comparison/article.md b/1-js/02-first-steps/09-comparison/article.md
index a24af5688..4c0db2e87 100644
--- a/1-js/02-first-steps/09-comparison/article.md
+++ b/1-js/02-first-steps/09-comparison/article.md
@@ -1,216 +1,224 @@
-# Comparisons
+# การเปรียบเทียบ
 
-We know many comparison operators from maths.
+เรารู้จักเครื่องหมายเปรียบเทียบ9y;อย่างจากคณิตศาสตร์
 
-In JavaScript they are written like this:
+ใน JavaScript เขียนได้ดังนี้:
 
-- Greater/less than: <code>a &gt; b</code>, <code>a &lt; b</code>.
-- Greater/less than or equals: <code>a &gt;= b</code>, <code>a &lt;= b</code>.
-- Equals: `a == b`, please note the double equality sign `==` means the equality test, while a single one `a = b` means an assignment.
-- Not equals: In maths the notation is <code>&ne;</code>, but in JavaScript it's written as <code>a != b</code>.
+- มากกว่า/น้อยกว่า: <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>
 
-In this article we'll learn more about different types of comparisons, how JavaScript makes them, including important peculiarities.
+ในบทความนี้ เราจะเรียนรู้เพิ่มเติมเกี่ยวกับการเปรียบเทียบแบบต่างๆ วิธีที่ JavaScript เปรียบเทียบ รวมถึงข้อควรระวังสำคัญ 
 
-At the end you'll find a good recipe to avoid "JavaScript quirks"-related issues.
+ท้ายบทความมีเคล็ดลับดีๆ ในการหลีกเลี่ยงปัญหาที่มักพบใน JavaScript
 
-## Boolean is the result
+## ผลลัพธ์เป็น Boolean
 
-All comparison operators return a boolean value:
+ผลการเปรียบเทียบทั้งหมดจะให้ค่า boolean:
 
-- `true` -- means "yes", "correct" or "the truth".
-- `false` -- means "no", "wrong" or "not the truth".
+- `true` หมายถึง "ใช่" "ถูกต้อง" หรือ "จริง"
+- `false` หมายถึง "ไม่" "ไม่ถูกต้อง" หรือ "ไม่จริง" 
 
-For example:
+ตัวอย่างเช่น:
 
 ```js run
-alert( 2 > 1 );  // true (correct)
-alert( 2 == 1 ); // false (wrong)
-alert( 2 != 1 ); // true (correct)
+alert( 2 > 1 );  // true (ถูก)
+alert( 2 == 1 ); // false (ไม่ถูก)
+alert( 2 != 1 ); // true (ถูก)
 ```
 
-A comparison result can be assigned to a variable, just like any value:
+ผลการเปรียบเทียบสามารถเก็บในตัวแปรได้ เหมือนกับค่าอื่นๆ:
 
 ```js run
-let result = 5 > 4; // assign the result of the comparison
+let result = 5 > 4; // เก็บผลการเปรียบเทียบ
 alert( result ); // true
 ```
 
-## String comparison
+## การเปรียบเทียบ string
 
-To see whether a string is greater than another, JavaScript uses the so-called "dictionary" or "lexicographical" order.
+ในการเช็คว่า string อันหนึ่งมากกว่าอีกอันหรือไม่ JavaScript ใช้การเรียงลำดับแบบ "พจนานุกรม" หรือ "ตามตัวอักษร"
 
-In other words, strings are compared letter-by-letter.
+หรือพูดง่ายๆ คือเปรียบเทียบ string ทีละตัวอักษร
 
-For example:
+ตัวอย่างเช่น:
 
 ```js run
 alert( 'Z' > 'A' ); // true
 alert( 'Glow' > 'Glee' ); // true
-alert( 'Bee' > 'Be' ); // true
+alert( 'Bee' > 'Be' ); // true 
 ```
 
-The algorithm to compare two strings is simple:
+ขั้นตอนในการเปรียบเทียบ string สองอันมีดังนี้:
 
-1. Compare the first character of both strings.
-2. If the first character from the first string is greater (or less) than the other string's, then the first string is greater (or less) than the second. We're done.
-3. Otherwise, if both strings' first characters are the same, compare the second characters the same way.
-4. Repeat until the end of either string.
-5. If both strings end at the same length, then they are equal. Otherwise, the longer string is greater.
+1. เปรียบเทียบตัวอักษรตัวแรกของ string ทั้งสองอัน
+2. ถ้าตัวอักษรตัวแรกจาก string แรกมากกว่า (หรือน้อยกว่า) string ที่สอง แสดงว่า string แรกมากกว่า (หรือน้อยกว่า) string ที่สอง จบการทำงาน
+3. ถ้าตัวอักษรตัวแรกของ string ทั้งสองเหมือนกัน ให้เปรียบเทียบตัวอักษรที่สองแบบเดียวกัน  
+4. ทำซ้ำไปเรื่อยๆ จนกว่าจะเจอตัวอักษรที่แตกต่างกันหรือจนหมด string
+5. ถ้าหมด string พร้อมกันที่ความยาวเท่ากัน แปลว่าเท่ากัน ไม่อย่างนั้น string ที่ยาวกว่าจะมากกว่า
 
-In the first example above, the comparison `'Z' > 'A'` gets to a result at the first step.
+ในตัวอย่างแรกข้างบน การเปรียบเทียบ `'Z' > 'A'` ให้ผลลัพธ์ตั้งแต่ขั้นตอนแรก
 
-The second comparison `'Glow'` and `'Glee'` needs more steps as strings are compared character-by-character:
+การเปรียบเทียบที่สองระหว่าง `'Glow'` กับ `'Glee'` ต้องใช้หลายขั้นตอนมากกว่า โดยเปรียบเทียบตัวอักษรทีละตัว:
 
-1. `G` is the same as `G`.
-2. `l` is the same as `l`.
-3. `o` is greater than `e`. Stop here. The first string is greater.
+1. `G` เท่ากับ `G`
+2. `l` เท่ากับ `l`
+3. `o` มากกว่า `e` หยุดตรงนี้ string แรกมากกว่า
 
-```smart header="Not a real dictionary, but Unicode order"
-The comparison algorithm given above is roughly equivalent to the one used in dictionaries or phone books, but it's not exactly the same.
+```smart header="ไม่ใช่พจนานุกรมจริงๆ แต่เป็นลำดับ Unicode"
+ขั้นตอนการเปรียบเทียบข้างต้นคล้ายกับที่ใช้ในพจนานุกรมหรือสมุดโทรศัพท์ แต่ไม่เหมือนกันทีเดียว
 
-For instance, case matters. A capital letter `"A"` is not equal to the lowercase `"a"`. Which one is greater? The lowercase `"a"`. Why? Because the lowercase character has a greater index in the internal encoding table JavaScript uses (Unicode). We'll get back to specific details and consequences of this in the chapter <info:string>.
+เช่น ตัวพิมพ์ใหญ่เล็กมีผล `"A"` ไม่เท่ากับ `"a"` ตัวไหนมากกว่า? `"a"` เพราะมันมีค่าดัชนีที่สูงกว่าในตารางเข้ารหัสภายใน (Unicode) ที่ JavaScript ใช้ เราจะกลับมาดูรายละเอียดและผลที่ตามมาในบท <info:string>
 ```
 
-## Comparison of different types
+## การเปรียบเทียบข้อมูลต่างชนิด
 
-When comparing values of different types, JavaScript converts the values to numbers.
+เมื่อเปรียบเทียบค่าที่มีชนิดต่างกัน JavaScript จะแปลงค่าเป็นตัวเลขก่อน
 
-For example:
+ตัวอย่างเช่น:
 
 ```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
 ```
 
-For boolean values, `true` becomes `1` and `false` becomes `0`.
+สำหรับค่า boolean `true` จะกลายเป็น `1` และ `false` จะกลายเป็น `0`
 
-For example:
+ตัวอย่างเช่น:
 
 ```js run
-alert( true == 1 ); // true
+alert( true == 1 ); // true  
 alert( false == 0 ); // true
 ```
 
-````smart header="A funny consequence"
-It is possible that at the same time:
+````smart header="ผลลัพธ์ที่แปลกประหลาด"
+มันเป็นไปได้ว่าในเวลาเดียวกัน:
 
-- Two values are equal.
-- One of them is `true` as a boolean and the other one is `false` as a boolean.
+- สองค่านั้นเท่ากัน
+- แต่ค่าหนึ่งเป็น `true` เมื่อแปลงเป็น boolean ส่วนอีกค่าเป็น `false` เมื่อแปลงเป็น boolean
 
-For example:
+ตัวอย่างเช่น:
 
 ```js run
 let a = 0;
 alert( Boolean(a) ); // false
 
-let b = "0";
+let b = "0"; 
 alert( Boolean(b) ); // true
 
 alert(a == b); // true!
 ```
 
-From JavaScript's standpoint, this result is quite normal. An equality check converts values using the numeric conversion (hence `"0"` becomes `0`), while the explicit `Boolean` conversion uses another set of rules.
+จากมุมมองของ JavaScript ผลลัพธ์นี้ถือว่าปกติ การเช็คความเท่ากันจะแปลงค่าโดยใช้การแปลงเป็นตัวเลข (ทำให้ `"0"` เป็น `0`) ในขณะที่การแปลงเป็น `Boolean` โดยตรงใช้ชุดกฎที่แตกต่างกัน
 ````
 
-## Strict equality
+## ความเท่าเทียมกันอย่างเข้มงวด
 
-A regular equality check `==` has a problem. It cannot differentiate `0` from `false`:
+การตรวจสอบความเท่าเทียมกันแบบปกติด้วย `==` มีปัญหาคือไม่สามารถแยกแยะความแตกต่างระหว่าง `0` กับ `false` ได้:
 
 ```js run
 alert( 0 == false ); // true
 ```
 
-The same thing happens with an empty string:
+เหตุการณ์เดียวกันนี้เกิดขึ้นกับ string ว่างด้วย:
 
-```js run
+```js run 
 alert( '' == false ); // true
 ```
 
-This happens because operands of different types are converted to numbers by the equality operator `==`. An empty string, just like `false`, becomes a zero.
+สิ่งนี้เกิดขึ้นเพราะเมื่อเปรียบเทียบข้อมูลคนละชนิดด้วยเครื่องหมาย `==` JavaScript จะแปลงชนิดข้อมูลเป็นตัวเลขก่อน ทั้ง string ว่างและ `false` จะถูกแปลงเป็นศูนย์
 
-What to do if we'd like to differentiate `0` from `false`?
+แล้วถ้าเราอยากแยกแยะความแตกต่างระหว่าง `0` กับ `false` ล่ะ จะทำอย่างไร?
 
-**A strict equality operator `===` checks the equality without type conversion.**
+**เครื่องหมายเท่ากันอย่างเข้มงวด `===` จะเปรียบเทียบความเท่าเทียมกันโดยไม่แปลงชนิดข้อมูล**
 
-In other words, if `a` and `b` are of different types, then `a === b` immediately returns `false` without an attempt to convert them.
+อีกนัยหนึ่ง ถ้า `a` และ `b` เป็นคนละชนิดกัน `a === b` จะคืนค่า `false` ทันที โดยไม่พยายามแปลงชนิดข้อมูล
 
-Let's try it:
+ลองดูตัวอย่าง:
 
 ```js run
-alert( 0 === false ); // false, because the types are different
+alert( 0 === false ); // false เพราะเป็นคนละชนิดกัน  
 ```
 
-There is also a "strict non-equality" operator `!==` analogous to `!=`.
+นอกจากนี้ยังมีเครื่องหมาย "ไม่เท่ากันอย่างเข้มงวด" `!==` ที่คล้ายกับ `!=` ด้วย
 
-The strict equality operator is a bit longer to write, but makes it obvious what's going on and leaves less room for errors.
+การใช้เครื่องหมายเท่ากันแบบเข้มงวดอาจเขียนยาวขึ้นหน่อย แต่จะทำให้เห็นชัดเจนว่าเกิดอะไรขึ้นและลดโอกาสเกิดข้อผิดพลาดได้มากกว่า
 
-## Comparison with null and undefined
+## การเปรียบเทียบกับ null และ undefined
 
-There's a non-intuitive behavior when `null` or `undefined` are compared to other values.
+เมื่อ `null` หรือ `undefined` ถูกนำมาเปรียบเทียบกับค่าอื่นๆ อาจเกิดพฤติกรรมที่ไม่ตรงกับความคาดหมายเสมอไป
 
-For a strict equality check `===`
-: These values are different, because each of them is a different type.
+สำหรับการตรวจสอบความเท่ากันอย่างเข้มงวดด้วย `===`:
+: ค่าเหล่านี้แตกต่างกัน เพราะแต่ละค่ามีประเภทข้อมูลต่างกัน
 
-    ```js run
-    alert( null === undefined ); // false
-    ```
+```js run
+alert( null === undefined ); // false
+```
 
-For a non-strict check `==`
-: There's a special rule. These two are a "sweet couple": they equal each other (in the sense of `==`), but not any other value.
+สำหรับการตรวจสอบความเท่ากันแบบไม่เข้มงวดด้วย `==`:
+: มีกฎพิเศษ ค่าทั้งสองนี้เป็น "คู่รักในฝัน" คือเท่ากันในแง่ของ `==` แต่ไม่เท่ากับค่าอื่นใด
 
-    ```js run
-    alert( null == undefined ); // true
-    ```
+```js run
+alert( null == undefined ); // true
+```  
 
-For maths and other comparisons `< > <= >=`
-: `null/undefined` are converted to numbers: `null` becomes `0`, while `undefined` becomes `NaN`.
+สำหรับการคำนวณทางคณิตศาสตร์และการเปรียบเทียบอื่นๆ `< > <= >=`:
+: `null/undefined` จะถูกแปลงเป็นตัวเลข โดย `null` เป็น `0` และ `undefined` เป็น `NaN` 
 
-Now let's see some funny things that happen when we apply these rules. And, what's more important, how to not fall into a trap with them.
+เรามาดูเหตุการณ์แปลกๆ ที่เกิดขึ้นเมื่อใช้กฎเหล่านี้ และที่สำคัญกว่านั้น คือเราจะหลีกเลี่ยงกับดักเหล่านี้ได้อย่างไร
 
-### Strange result: null vs 0
+### ผลลัพธ์ประหลาด: null เทียบกับ 0
 
-Let's compare `null` with a zero:
+ลองเปรียบเทียบ `null` กับศูนย์ดู:
 
 ```js run
 alert( null > 0 );  // (1) false
 alert( null == 0 ); // (2) false
-alert( null >= 0 ); // (3) *!*true*/!*
+alert( null >= 0 ); // (3) *!*true*/!*  
 ```
 
-Mathematically, that's strange. The last result states that "`null` is greater than or equal to zero", so in one of the comparisons above it must be `true`, but they are both false.
+ทางคณิตศาสตร์แล้วมันแปลกมาก ผลลัพธ์สุดท้ายบอกว่า "`null` มากกว่าหรือเท่ากับศูนย์" ดังนั้นในการเปรียบเทียบข้างต้นต้องมีอย่างน้อยหนึ่งค่าเป็น `true` แต่กลับเป็น false ทั้งคู่
 
-The reason is that an equality check `==` and comparisons `> < >= <=` work differently. Comparisons convert `null` to a number, treating it as `0`. That's why (3) `null >= 0` is true and (1) `null > 0` is false.
+สาเหตุคือ การตรวจสอบความเท่ากันด้วย `==` และการเปรียบเทียบ `> < >= <=` ทำงานต่างกัน การเปรียบเทียบจะแปลง `null` เป็นตัวเลขและถือว่าเป็น `0` นั่นเป็นเหตุผลที่ (3) `null >= 0` เป็น true และ (1) `null > 0` เป็น false
 
-On the other hand, the equality check `==` for `undefined` and `null` is defined such that, without any conversions, they equal each other and don't equal anything else. That's why (2) `null == 0` is false.
+ในทางกลับกัน การตรวจสอบความเท่ากันด้วย `==` ระหว่าง `undefined` กับ `null` นั้นถูกกำหนดไว้ว่า หากไม่มีการแปลงประเภท มันจะเท่ากันเองเท่านั้นและไม่เท่ากับค่าอื่นใด นั่นเป็นเหตุผลที่ (2) `null == 0` เป็น false
 
-### An incomparable undefined
+### undefined ไม่สามารถเปรียบเทียบได้
 
-The value `undefined` shouldn't be compared to other values:
+เราไม่ควรนำค่า `undefined` ไปเปรียบเทียบกับค่าอื่นๆ:
 
 ```js run
 alert( undefined > 0 ); // false (1)
-alert( undefined < 0 ); // false (2)
+alert( undefined < 0 ); // false (2) 
 alert( undefined == 0 ); // false (3)
 ```
 
-Why does it dislike zero so much? Always false!
+ทำไม `undefined` ถึงเกลียดศูนย์ขนาดนั้น จนเป็น false ตลอด!
 
-We get these results because:
+เพราะว่า:
 
-- Comparisons `(1)` and `(2)` return `false` because `undefined` gets converted to `NaN` and `NaN` is a special numeric value which returns `false` for all comparisons.
-- The equality check `(3)` returns `false` because `undefined` only equals `null`, `undefined`, and no other value.
+- การเปรียบเทียบ `(1)` และ `(2)` ให้ค่า `false` เพราะ `undefined` ถูกแปลงเป็น `NaN` ซึ่ง `NaN` เป็นค่าตัวเลขพิเศษที่ให้ผลเป็น `false` เสมอเมื่อเปรียบเทียบ
+- การตรวจสอบความเท่ากัน `(3)` ให้ค่า `false` เพราะ `undefined` จะเท่ากับ `null` และ `undefined` เท่านั้น ไม่เท่ากับค่าอื่น
 
-### Avoid problems
+### หลีกเลี่ยงปัญหา
 
-Why did we go over these examples? Should we remember these peculiarities all the time? Well, not really. Actually, these tricky things will gradually become familiar over time, but there's a solid way to avoid problems with them:
+ทำไมเราถึงยกตัวอย่างเหล่านี้? เราจำเป็นต้องจำความพิเศษเหล่านี้ตลอดเวลาหรือ? ไม่จำเป็นหรอก จริงๆ แล้วสิ่งที่ดูยุ่งยากเหล่านี้จะค่อยๆ คุ้นเคยไปเองตามเวลา แต่มีวิธีที่ดีกว่าในการหลีกเลี่ยงปัญหาพวกนี้:
 
-- Treat any comparison with `undefined/null` except the strict equality `===` with exceptional care.
-- Don't use comparisons `>= > < <=` with a variable which may be `null/undefined`, unless you're really sure of what you're doing. If a variable can have these values, check for them separately.
+- ระมัดระวังเป็นพิเศษเมื่อเปรียบเทียบกับ `undefined/null` ยกเว้นการตรวจสอบความเท่ากันแบบเข้มงวดด้วย `===`
+- อย่าใช้การเปรียบเทียบ `>= > < <=` กับตัวแปรที่อาจเป็น `null/undefined` เว้นแต่คุณจะมั่นใจว่าตัวเองกำลังทำอะไร ถ้าตัวแปรอาจมีค่าเหล่านี้ได้ ให้ตรวจสอบ `null/undefined` แยกต่างหาก
 
-## Summary
+## สรุป
 
+<<<<<<< HEAD
+- ตัวดำเนินการเปรียบเทียบให้ค่าเป็น boolean
+- การเปรียบเทียบ string จะเปรียบเทียบทีละตัวอักษรตามลำดับ "พจนานุกรม"
+- เมื่อเปรียบเทียบค่าต่างประเภทกัน ค่าจะถูกแปลงเป็นตัวเลข (ยกเว้นการตรวจสอบความเท่ากันอย่างเข้มงวด) 
+- ค่า `null` และ `undefined` เท่ากันเฉพาะเมื่อใช้ `==` และไม่เท่ากับค่าอื่นใดทั้งสิ้น
+- ระมัดระวังเมื่อใช้การเปรียบเทียบ เช่น `>` หรือ `<` กับตัวแปรที่อาจเป็น `null/undefined` ได้ บางครั้งการตรวจสอบ `null/undefined` แยกต่างหากถือเป็นแนวทางที่ดี
+=======
 - Comparison operators return a boolean value.
 - Strings are compared letter-by-letter in the "dictionary" order.
 - When values of different types are compared, they get converted to numbers (with the exclusion of a strict equality check).
 - The values `null` and `undefined` are equal `==` to themselves and each other, but do not equal any other value.
 - Be careful when using comparisons like `>` or `<` with variables that can occasionally be `null/undefined`. Checking for `null/undefined` separately is a good idea.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
diff --git a/1-js/02-first-steps/10-ifelse/1-if-zero-string/solution.md b/1-js/02-first-steps/10-ifelse/1-if-zero-string/solution.md
index 51f1d4680..a0783893c 100644
--- a/1-js/02-first-steps/10-ifelse/1-if-zero-string/solution.md
+++ b/1-js/02-first-steps/10-ifelse/1-if-zero-string/solution.md
@@ -1,8 +1,8 @@
-**Yes, it will.**
+**ใช่ alert จะโชว์**
 
-Any string except an empty one (and `"0"` is not empty) becomes `true` in the logical context.
+สตริงใดๆ ยกเว้นสตริงว่าง (และสตริง "0" ไม่ใช่สตริงเปล่า) จะกลายเป็น "จริง" ในบริบททางตรรกะ
 
-We can run and check:
+เราสามรถเรียกใช้เพื่อตรวจสอบได้:
 
 ```js run
 if ("0") {
diff --git a/1-js/02-first-steps/10-ifelse/1-if-zero-string/task.md b/1-js/02-first-steps/10-ifelse/1-if-zero-string/task.md
index 5f16cda85..a838f144b 100644
--- a/1-js/02-first-steps/10-ifelse/1-if-zero-string/task.md
+++ b/1-js/02-first-steps/10-ifelse/1-if-zero-string/task.md
@@ -2,9 +2,9 @@ importance: 5
 
 ---
 
-# if (a string with zero)
+# if (ศูนย์เป็นสตริง)
 
-Will `alert` be shown?
+หลังจากรันโค้ดนี้คิดว่า `alert` จะโชว์ขึ้นมาหรือไม่
 
 ```js
 if ("0") {
diff --git a/1-js/02-first-steps/10-ifelse/2-check-standard/task.md b/1-js/02-first-steps/10-ifelse/2-check-standard/task.md
index 4305584fa..1ef523413 100644
--- a/1-js/02-first-steps/10-ifelse/2-check-standard/task.md
+++ b/1-js/02-first-steps/10-ifelse/2-check-standard/task.md
@@ -2,11 +2,11 @@ importance: 2
 
 ---
 
-# The name of JavaScript
+# ชื่ออันแท้จริงของ JavaScript
 
-Using the `if..else` construct, write the code which asks: 'What is the "official" name of JavaScript?'
+ใช้รูปโยค `if..else` เขียนโค้ดที่ถามว่า: 'What is the "official" name of JavaScript?'
 
-If the visitor enters "ECMAScript", then output "Right!", otherwise -- output: "You don't know? ECMAScript!"
+หากผู้เยี่ยมชมป้อน "ECMAScript" ให้ส่งออกเป็น "Right!" มิฉะนั้น -- ให้ออกเป็น: "You don't know? ECMAScript!"
 
 ![](ifelse_task2.svg)
 
diff --git a/1-js/02-first-steps/10-ifelse/3-sign/task.md b/1-js/02-first-steps/10-ifelse/3-sign/task.md
index 0c5d0e008..8984bd5b8 100644
--- a/1-js/02-first-steps/10-ifelse/3-sign/task.md
+++ b/1-js/02-first-steps/10-ifelse/3-sign/task.md
@@ -2,14 +2,14 @@ importance: 2
 
 ---
 
-# Show the sign
+# จงแสดงสัญญาณ
 
-Using `if..else`, write the code which gets a number via `prompt` and then shows in `alert`:
+ใช้ if..else เขียนโค้ดที่ได้รับตัวเลขผ่าน `prompt` แล้วแสดงใน `alert`:
 
-- `1`, if the value is greater than zero,
-- `-1`, if less than zero,
-- `0`, if equals zero.
+- แสดง `1` ถ้าค่ามากกว่าศูนย์
+- แสดง `-1`, ถ้าค่าน้อยกว่าศูนย์
+- แสดง `0` ถ้าค่าเท่ากับศูนย์
 
-In this task we assume that the input is always a number.
+เราถือว่าอินพุตเป็นตัวเลขเสมอ
 
 [demo src="if_sign"]
diff --git a/1-js/02-first-steps/10-ifelse/5-rewrite-if-question/task.md b/1-js/02-first-steps/10-ifelse/5-rewrite-if-question/task.md
index 6bdf8453e..de56d4277 100644
--- a/1-js/02-first-steps/10-ifelse/5-rewrite-if-question/task.md
+++ b/1-js/02-first-steps/10-ifelse/5-rewrite-if-question/task.md
@@ -2,9 +2,9 @@ importance: 5
 
 ---
 
-# Rewrite 'if' into '?'
+# เขียน 'if' ให้เป็น '?'
 
-Rewrite this `if` using the conditional operator `'?'`:
+เขียน `if` นี้ใหม่โดยใช้ตัวดำเนินการตามเงื่อนไข `'?'`:
 
 ```js
 let result;
diff --git a/1-js/02-first-steps/10-ifelse/6-rewrite-if-else-question/task.md b/1-js/02-first-steps/10-ifelse/6-rewrite-if-else-question/task.md
index 4f7d994a2..240ae0712 100644
--- a/1-js/02-first-steps/10-ifelse/6-rewrite-if-else-question/task.md
+++ b/1-js/02-first-steps/10-ifelse/6-rewrite-if-else-question/task.md
@@ -2,11 +2,11 @@ importance: 5
 
 ---
 
-# Rewrite 'if..else' into '?'
+# เขียน 'if..else' ให้เป็น '?'
 
-Rewrite `if..else` using multiple ternary operators `'?'`.
+เขียน `if..else` นี้ใหม่โดยใช้ตัวดำเนินการตามเงื่อนไข `'?'`
 
-For readability, it's recommended to split the code into multiple lines.
+เพื่อให้โค้ดอ่านง่ายขึ้น ขอแนะนำให้แยกโค้ดออกเป็นหลายบรรทัด
 
 ```js
 let message;
diff --git a/1-js/02-first-steps/10-ifelse/article.md b/1-js/02-first-steps/10-ifelse/article.md
index 82e8800b9..1daa1531d 100644
--- a/1-js/02-first-steps/10-ifelse/article.md
+++ b/1-js/02-first-steps/10-ifelse/article.md
@@ -1,239 +1,250 @@
-# Conditional branching: if, '?'
+# การกระโดดแบบมีเงื่อนไข: if, '?'
 
-Sometimes, we need to perform different actions based on different conditions.
+บ่อยครั้งที่เราต้องทำการต่างๆ ตามเงื่อนไขที่แตกต่างกัน
 
-To do that, we can use the `if` statement and the conditional operator `?`, that's also called a "question mark" operator.
+เพื่อทำเช่นนั้น เราสามารถใช้คำสั่ง `if` และตัวดำเนินการแบบมีเงื่อนไข `?` ซึ่งมีอีกชื่อหนึ่งว่า "เครื่องหมายคำถาม"
 
-## The "if" statement
+## คำสั่ง "if"
 
-The `if(...)` statement evaluates a condition in parentheses and, if the result is `true`, executes a block of code.
+คำสั่ง `if(...)` จะประเมินเงื่อนไขในวงเล็บ ถ้าผลลัพธ์เป็น `true` จะดำเนินการโค้ดในบล็อก
 
-For example:
+ตัวอย่างเช่น:
 
 ```js run
-let year = prompt('In which year was ECMAScript-2015 specification published?', '');
+let year = prompt('มาตรฐาน ECMAScript-2015 เผยแพร่ในปีใด?', '');
 
 *!*
-if (year == 2015) alert( 'You are right!' );
+if (year == 2015) alert('คุณตอบถูก!');
 */!*
 ```
 
-In the example above, the condition is a simple equality check (`year == 2015`), but it can be much more complex.
+ในตัวอย่างข้างต้น เงื่อนไขคือการตรวจสอบความเท่ากันแบบง่าย (`year == 2015`) แต่มันอาจซับซ้อนกว่านั้นได้มาก
 
-If we want to execute more than one statement, we have to wrap our code block inside curly braces:
+ถ้าเราต้องการรันคำสั่งมากกว่าหนึ่งคำสั่ง เราต้องครอบโค้ดของเราด้วยวงเล็บปีกกา:
 
 ```js
 if (year == 2015) {
-  alert( "That's correct!" );
-  alert( "You're so smart!" );
-}
+  alert("ถูกต้อง!");
+  alert("คุณเก่งมาก!");
+}  
 ```
 
-We recommend wrapping your code block with curly braces `{}` every time you use an `if` statement, even if there is only one statement to execute. Doing so improves readability.
+แนะนำให้ครอบโค้ดของคุณด้วยวงเล็บปีกกา `{}` ทุกครั้งที่ใช้คำสั่ง `if` แม้จะมีเพียงหนึ่งคำสั่งก็ตาม การทำเช่นนี้ช่วยให้อ่านโค้ดง่ายขึ้น 
 
-## Boolean conversion
+## การแปลงเป็น boolean 
 
-The `if (…)` statement evaluates the expression in its parentheses and converts the result to a boolean.
+คำสั่ง `if(...)` จะประเมินนิพจน์ในวงเล็บและแปลงผลลัพธ์เป็น boolean
 
-Let's recall the conversion rules from the chapter <info:type-conversions>:
+ลองมาทบทวนกฎการแปลงประเภทจากบท <info:type-conversions> กัน:
 
-- A number `0`, an empty string `""`, `null`, `undefined`, and `NaN` all become `false`. Because of that they are called "falsy" values.
-- Other values become `true`, so they are called "truthy".
+- ตัวเลข `0`, string ว่าง `""`, `null`, `undefined` และ `NaN` จะกลายเป็น `false` ทั้งหมด เรียกค่าเหล่านี้ว่า "falsy"
+- ค่าอื่นๆ จะกลายเป็น `true` เรียกว่า "truthy"
 
-So, the code under this condition would never execute:
+ดังนั้น โค้ดภายใต้เงื่อนไขนี้จะไม่ถูกรัน:
 
 ```js
-if (0) { // 0 is falsy
+if (0) { // 0 เป็น falsy
   ...
 }
 ```
 
-...and inside this condition -- it always will:
+...แต่ภายในเงื่อนไขนี้ จะรันเสมอ:
 
 ```js
-if (1) { // 1 is truthy
+if (1) { // 1 เป็น truthy
   ...
 }
 ```
 
-We can also pass a pre-evaluated boolean value to `if`, like this:
+เรายังสามารถส่งค่า boolean ที่ประเมินไว้แล้วเข้าไปใน `if` ได้ด้วย แบบนี้:
 
-```js
-let cond = (year == 2015); // equality evaluates to true or false
+```js  
+let cond = (year == 2015); // ตรวจสอบความเท่ากัน ได้ค่า true หรือ false
 
 if (cond) {
-  ...
+  ... 
 }
 ```
 
-## The "else" clause
+## กรณี "else"
 
+<<<<<<< HEAD
+คำสั่ง `if` อาจมีบล็อก `else` เพิ่มเติมได้ ซึ่งจะทำงานเมื่อเงื่อนไขเป็น falsy (เท็จ)
+=======
 The `if` statement may contain an optional `else` block. It executes when the condition is falsy.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-For example:
+ตัวอย่างเช่น:
 ```js run
-let year = prompt('In which year was the ECMAScript-2015 specification published?', '');
+let year = prompt('ECMAScript-2015 เผยแพร่ในปีใด?', '');
 
 if (year == 2015) {
-  alert( 'You guessed it right!' );
+  alert('คุณตอบถูกต้อง!');
 } else {
-  alert( 'How can you be so wrong?' ); // any value except 2015
+  alert('คุณจำผิดแล้ว'); // สำหรับค่าอื่นๆ ที่ไม่ใช่ 2015
 }
 ```
 
-## Several conditions: "else if"
+## หลายเงื่อนไข: "else if"
 
-Sometimes, we'd like to test several variants of a condition. The `else if` clause lets us do that.
+บางครั้งเราอยากทดสอบเงื่อนไขหลายรูปแบบ กรณี `else if` ช่วยให้เราทำแบบนั้นได้
 
-For example:
+ตัวอย่างเช่น:
 
 ```js run
-let year = prompt('In which year was the ECMAScript-2015 specification published?', '');
+let year = prompt('ECMAScript-2015 เผยแพร่ในปีใด?', '');
 
 if (year < 2015) {
-  alert( 'Too early...' );
+  alert('เร็วไป...');
 } else if (year > 2015) {
-  alert( 'Too late' );
+  alert('ช้าไป');  
 } else {
-  alert( 'Exactly!' );
+  alert('ถูกต้อง!');
 }
 ```
 
-In the code above, JavaScript first checks `year < 2015`. If that is falsy, it goes to the next condition `year > 2015`. If that is also falsy, it shows the last `alert`.
+ในโค้ดข้างต้น JavaScript จะตรวจสอบ `year < 2015` ก่อน ถ้าเป็น falsy จะไปเช็คเงื่อนไขถัดไปคือ `year > 2015` ถ้านั่นก็เป็น falsy ก็จะแสดง `alert` สุดท้าย
 
-There can be more `else if` blocks. The final `else` is optional.
+เราสามารถมีบล็อก `else if` ได้หลายบล็อก ส่วน `else` ตัวสุดท้ายเป็นตัวเลือกเสริม ไม่บังคับ
 
-## Conditional operator '?'
+## ตัวดำเนินการแบบมีเงื่อนไข '?'
 
-Sometimes, we need to assign a variable depending on a condition.
+บางครั้งเราต้องการกำหนดค่าให้ตัวแปรตามเงื่อนไขบางอย่าง
 
-For instance:
+ยกตัวอย่างเช่น:
 
 ```js run no-beautify
 let accessAllowed;
-let age = prompt('How old are you?', '');
+let age = prompt('อายุเท่าไหร่?', '');
 
 *!*
 if (age > 18) {
   accessAllowed = true;
 } else {
-  accessAllowed = false;
+  accessAllowed = false;  
 }
 */!*
 
 alert(accessAllowed);
 ```
 
-The so-called "conditional" or "question mark" operator lets us do that in a shorter and simpler way.
+ตัวดำเนินการที่เรียกว่า "แบบมีเงื่อนไข" หรือ "เครื่องหมายคำถาม" ช่วยให้เราเขียนโค้ดแบบนี้ได้สั้นและง่ายขึ้น
 
-The operator is represented by a question mark `?`. Sometimes it's called "ternary", because the operator has three operands. It is actually the one and only operator in JavaScript which has that many.
+ตัวดำเนินการนี้แทนด้วยเครื่องหมายคำถาม `?` บางครั้งเรียกว่า "ternary" เพราะมี 3 operand ซึ่งเป็นตัวดำเนินการเดียวใน JavaScript ที่มีจำนวน operand มากขนาดนี้
 
-The syntax is:
+รูปแบบไวยากรณ์คือ:
 ```js
 let result = condition ? value1 : value2;
 ```
 
-The `condition` is evaluated: if it's truthy then `value1` is returned, otherwise -- `value2`.
+`condition` จะถูกประเมิน ถ้าเป็น truthy จะคืนค่า `value1` ไม่อย่างนั้นจะคืนค่า `value2`
 
-For example:
+ตัวอย่างเช่น:
 
 ```js
 let accessAllowed = (age > 18) ? true : false;
 ```
 
-Technically, we can omit the parentheses around `age > 18`. The question mark operator has a low precedence, so it executes after the comparison `>`.
+ในทางเทคนิค เราสามารถละวงเล็บรอบ `age > 18` ได้ เพราะตัวดำเนินการ ? มีลำดับความสำคัญต่ำกว่า (precedence) จึงรันหลังเครื่องหมาย `>` 
 
-This example will do the same thing as the previous one:
+ตัวอย่างนี้จะทำงานเหมือนกับตัวอย่างก่อนหน้า:
 
 ```js
-// the comparison operator "age > 18" executes first anyway
-// (no need to wrap it into parentheses)
+// การเปรียบเทียบ "age > 18" รันก่อนอยู่แล้ว
+// (ไม่ต้องครอบด้วยวงเล็บก็ได้)
 let accessAllowed = age > 18 ? true : false;
 ```
 
-But parentheses make the code more readable, so we recommend using them.
+แต่การใส่วงเล็บช่วยให้โค้ดอ่านง่ายขึ้น จึงแนะนำให้ใส่ไว้
 
 ````smart
-In the example above, you can avoid using the question mark operator because the comparison itself returns `true/false`:
+ในตัวอย่างข้างต้น จริงๆ แล้วไม่จำเป็นต้องใช้ ? ก็ได้นะ เพราะการเปรียบเทียบเองให้ค่า `true/false` อยู่แล้ว:
 
 ```js
-// the same
+// เหมือนกัน
 let accessAllowed = age > 18;
-```
+``` 
 ````
 
-## Multiple '?'
+## เครื่องหมายคำถามหลายตัว '?'
 
-A sequence of question mark operators `?` can return a value that depends on more than one condition.
+การใช้เครื่องหมายคำถาม `?` ต่อเนื่องกันหลายตัว สามารถคืนค่าที่ขึ้นอยู่กับเงื่อนไขมากกว่าหนึ่งอย่างได้
 
-For instance:
+ตัวอย่างเช่น:
 ```js run
-let age = prompt('age?', 18);
+let age = prompt('อายุเท่าไหร่?', 18);
 
-let message = (age < 3) ? 'Hi, baby!' :
-  (age < 18) ? 'Hello!' :
-  (age < 100) ? 'Greetings!' :
-  'What an unusual age!';
+let message = (age < 3) ? 'สวัสดีจ้าหนู!' :
+  (age < 18) ? 'สวัสดีจ้า!' :
+  (age < 100) ? 'สวัสดีครับ/ค่ะ!' : 
+  'อายุแปลกๆ นะ!';
 
-alert( message );
+alert( message );  
 ```
 
-It may be difficult at first to grasp what's going on. But after a closer look, we can see that it's just an ordinary sequence of tests:
+อาจดูงงในตอนแรกว่าเกิดอะไรขึ้น แต่ถ้ามองให้ดี จะเห็นว่ามันเป็นเพียงการทดสอบเงื่อนไขทีละข้อตามลำดับ:
 
+<<<<<<< HEAD
+1. `?` ตัวแรกตรวจสอบว่า `age < 3` หรือไม่
+2. ถ้าใช่ -- คืนค่า `'สวัสดีจ้าหนู!'` ถ้าไม่ใช่ มันจะไปเช็คเงื่อนไขถัดจากโคลอน ":" คือ `age < 18`
+3. ถ้าเงื่อนไขนั้นเป็นจริง -- คืนค่า `'สวัสดีจ้า!'` ถ้าไม่จริง ก็จะไปเช็คเงื่อนไขถัดจากโคลอนถัดไป ":" คือ `age < 100`
+4. ถ้านั่นเป็นจริง -- คืนค่า `'สวัสดีครับ/ค่ะ!'` ไม่อย่างนั้นจะไปที่เงื่อนไขสุดท้ายหลังโคลอนตัวสุดท้าย ":" และคืนค่า `'อายุแปลกๆ นะ!'`
+=======
 1. The first question mark checks whether `age < 3`.
 2. If true -- it returns `'Hi, baby!'`. Otherwise, it continues to the expression after the colon ":", checking `age < 18`.
 3. If that's true -- it returns `'Hello!'`. Otherwise, it continues to the expression after the next colon ":", checking `age < 100`.
 4. If that's true -- it returns `'Greetings!'`. Otherwise, it continues to the expression after the last colon ":", returning `'What an unusual age!'`.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-Here's how this looks using `if..else`:
+นี่คือการเขียนโค้ดข้างต้นโดยใช้ `if..else`:
 
 ```js
 if (age < 3) {
-  message = 'Hi, baby!';
+  message = 'สวัสดีจ้าหนู!';
 } else if (age < 18) {
-  message = 'Hello!';
+  message = 'สวัสดีจ้า!';  
 } else if (age < 100) {
-  message = 'Greetings!';
+  message = 'สวัสดีครับ/ค่ะ!';
 } else {
-  message = 'What an unusual age!';
+  message = 'อายุแปลกๆ นะ!'; 
 }
 ```
 
-## Non-traditional use of '?'
+## การใช้เครื่องหมายคำถาม '?' แบบไม่เป็นไปตามแบบแผน
 
-Sometimes the question mark `?` is used as a replacement for `if`:
+บางครั้งมีการใช้เครื่องหมายคำถาม `?` แทนคำสั่ง `if`:
 
 ```js run no-beautify
-let company = prompt('Which company created JavaScript?', '');
+let company = prompt('บริษัทใดเป็นผู้สร้าง JavaScript?', '');
 
 *!*
 (company == 'Netscape') ?
-   alert('Right!') : alert('Wrong.');
+   alert('ถูกต้อง!') : alert('ผิดแล้ว');
 */!*
 ```
 
-Depending on the condition `company == 'Netscape'`, either the first or the second expression after the `?` gets executed and shows an alert.
+ขึ้นอยู่กับเงื่อนไข `company == 'Netscape'` ถ้าเป็นจริงก็จะรันนิพจน์แรกหลัง `?` แต่ถ้าเป็นเท็จจะรันนิพจน์ที่สอง แล้วแสดง alert ออกมา
 
-We don't assign a result to a variable here. Instead, we execute different code depending on the condition.
+สังเกตว่าเราไม่ได้กำหนดผลลัพธ์ให้กับตัวแปร แต่เรารันโค้ดที่แตกต่างกันไปตามเงื่อนไข
 
-**It's not recommended to use the question mark operator in this way.**
+**ไม่แนะนำให้ใช้เครื่องหมายคำถามในลักษณะนี้นะ**
 
-The notation is shorter than the equivalent `if` statement, which appeals to some programmers. But it is less readable.
+การเขียนแบบนี้จะสั้นกว่าใช้คำสั่ง `if` จึงมีนักพัฒนาบางคนชอบ แต่จริงๆ แล้วมันอ่านทำความเข้าใจยากกว่า
 
-Here is the same code using `if` for comparison:
+เปรียบเทียบกับการใช้ `if` ในโค้ดเดียวกัน:
 
 ```js run no-beautify
-let company = prompt('Which company created JavaScript?', '');
+let company = prompt('บริษัทใดเป็นผู้สร้าง JavaScript?', '');
 
-*!*
+*!*  
 if (company == 'Netscape') {
-  alert('Right!');
+  alert('ถูกต้อง!');
 } else {
-  alert('Wrong.');
+  alert('ผิดแล้ว');  
 }
 */!*
 ```
 
-Our eyes scan the code vertically. Code blocks which span several lines are easier to understand than a long, horizontal instruction set.
+สายตาเราจะอ่านโค้ดจากบนลงล่าง บล็อกโค้ดที่มีหลายบรรทัดจะเข้าใจง่ายกว่าคำสั่งแบบยาวๆ บรรทัดเดียว
 
-The purpose of the question mark operator `?` is to return one value or another depending on its condition. Please use it for exactly that. Use `if` when you need to execute different branches of code.
+จุดประสงค์หลักของเครื่องหมาย `?` คือการคืนค่าอย่างใดอย่างหนึ่งตามเงื่อนไข ควรใช้เพื่อวัตถุประสงค์นั้นโดยเฉพาะ ส่วนถ้าต้องการรันคำสั่งแตกต่างกันตามเงื่อนไข ให้ใช้ `if` จะดีกว่า
\ No newline at end of file
diff --git a/1-js/02-first-steps/11-logical-operators/1-alert-null-2-undefined/solution.md b/1-js/02-first-steps/11-logical-operators/1-alert-null-2-undefined/solution.md
index 8869d32e6..0c73b435c 100644
--- a/1-js/02-first-steps/11-logical-operators/1-alert-null-2-undefined/solution.md
+++ b/1-js/02-first-steps/11-logical-operators/1-alert-null-2-undefined/solution.md
@@ -1,4 +1,4 @@
-The answer is `2`, that's the first truthy value.
+คำตอบคือ `2` เพราะว่าเป็นค่า truthy ตัวแรก
 
 ```js run
 alert( null || 2 || undefined );
diff --git a/1-js/02-first-steps/11-logical-operators/1-alert-null-2-undefined/task.md b/1-js/02-first-steps/11-logical-operators/1-alert-null-2-undefined/task.md
index a7c9addfc..d48008d44 100644
--- a/1-js/02-first-steps/11-logical-operators/1-alert-null-2-undefined/task.md
+++ b/1-js/02-first-steps/11-logical-operators/1-alert-null-2-undefined/task.md
@@ -2,9 +2,9 @@ importance: 5
 
 ---
 
-# What's the result of OR?
+# ทายผลลัพธ์ของ OR จากโค้ดต่อไปนี้
 
-What is the code below going to output?
+คิดว่าอะไรจะแสดงที่ออกมาจากฟังก์ชั่น `alert`
 
 ```js
 alert( null || 2 || undefined );
diff --git a/1-js/02-first-steps/11-logical-operators/2-alert-or/solution.md b/1-js/02-first-steps/11-logical-operators/2-alert-or/solution.md
index f85b56366..fa3128b63 100644
--- a/1-js/02-first-steps/11-logical-operators/2-alert-or/solution.md
+++ b/1-js/02-first-steps/11-logical-operators/2-alert-or/solution.md
@@ -1,13 +1,13 @@
-The answer: first `1`, then `2`.
+คำตอบคือ: `alert` แสดง `1` ก่อน ตามด้วย `2`
 
 ```js run
 alert( alert(1) || 2 || alert(3) );
 ```
 
-The call to `alert` does not return a value. Or, in other words, it returns `undefined`.
+การเรียกใช้ฟังก์ชั่น `alert` จะไม่คืนค่าอะไรออกมา หรือก็คือ มันคืน `undefined` มา
 
-1. The first OR `||` evaluates its left operand `alert(1)`. That shows the first message with `1`.
-2. The `alert` returns `undefined`, so OR goes on to the second operand searching for a truthy value.
-3. The second operand `2` is truthy, so the execution is halted, `2` is returned and then shown by the outer alert.
+1. OR `||` ตัวแรกประเมินฟังก์ชั่น `alert(1)` และแสดง `1` ออกมา
+2. ฟังก์ชัน `alert` ส่ง `undefined` ซึ่งเป็นค่า falsy กลับดังนั้น OR จะไปประเมินตัวที่สองต่อเพื่อหาค่า truthy
+3. ตัวที่สอง `2` เป็นค่า truthy สิ้นสุดการทำงาน เลข `2` ถูกส่งกลับ และแสดงออกมาผ่านฟังก์ชัน `alert` ตัวนอกก
 
-There will be no `3`, because the evaluation does not reach `alert(3)`.
+ไม่มีเลข `3` แสดงออกมาเพราะว่าตามการทำงานไปไม่ถึงฟังก์ชั่น `alert(3)`
diff --git a/1-js/02-first-steps/11-logical-operators/2-alert-or/task.md b/1-js/02-first-steps/11-logical-operators/2-alert-or/task.md
index 3908fa2ec..6dee8a964 100644
--- a/1-js/02-first-steps/11-logical-operators/2-alert-or/task.md
+++ b/1-js/02-first-steps/11-logical-operators/2-alert-or/task.md
@@ -2,9 +2,9 @@ importance: 3
 
 ---
 
-# What's the result of OR'ed alerts?
+# ทายผลลัพธ์ของ OR จากโค้ดต่อไปนี้
 
-What will the code below output?
+อะไรคือจะแสดงออกมาจากฟังก์ชั่น `alert`
 
 ```js
 alert( alert(1) || 2 || alert(3) );
diff --git a/1-js/02-first-steps/11-logical-operators/3-alert-1-null-2/solution.md b/1-js/02-first-steps/11-logical-operators/3-alert-1-null-2/solution.md
index 368b59409..f9e11642a 100644
--- a/1-js/02-first-steps/11-logical-operators/3-alert-1-null-2/solution.md
+++ b/1-js/02-first-steps/11-logical-operators/3-alert-1-null-2/solution.md
@@ -1,4 +1,4 @@
-The answer: `null`, because it's the first falsy value from the list.
+คำตอบคือ `null` เพราะว่า มันเป็นค่าที่เป็น falsy แรกที่เจอ
 
 ```js run
 alert(1 && null && 2);
diff --git a/1-js/02-first-steps/11-logical-operators/3-alert-1-null-2/task.md b/1-js/02-first-steps/11-logical-operators/3-alert-1-null-2/task.md
index 043d431e4..c67bdb855 100644
--- a/1-js/02-first-steps/11-logical-operators/3-alert-1-null-2/task.md
+++ b/1-js/02-first-steps/11-logical-operators/3-alert-1-null-2/task.md
@@ -2,9 +2,9 @@ importance: 5
 
 ---
 
-# What is the result of AND?
+# ทายผลลัพธ์ของ AND จากโค้ดต่อไปนี้?
 
-What is this code going to show?
+คิดว่าอะไรจะแสดงที่ออกมาจากฟังก์ชั่น `alert`
 
 ```js
 alert( 1 && null && 2 );
diff --git a/1-js/02-first-steps/11-logical-operators/4-alert-and/solution.md b/1-js/02-first-steps/11-logical-operators/4-alert-and/solution.md
index b6fb10d72..4053549a1 100644
--- a/1-js/02-first-steps/11-logical-operators/4-alert-and/solution.md
+++ b/1-js/02-first-steps/11-logical-operators/4-alert-and/solution.md
@@ -1,10 +1,10 @@
-The answer: `1`, and then `undefined`.
+คำตอบคือ `1` ตามด้วย `undefined`.
 
 ```js run
 alert( alert(1) && alert(2) );
 ```
 
-The call to `alert` returns `undefined` (it just shows a message, so there's no meaningful return).
+เรียกฟังก์ชั่น `alert` จะส่ง `undefined` กลับ (ตัวฟังก์ชั่นมีหน้าที่เพียงแสดงข้อความ ดังนั้นจึงไม่จำเป็นส่งค่าใดๆกลับไป)
 
-Because of that, `&&` evaluates the left operand (outputs `1`), and immediately stops, because `undefined` is a falsy value. And `&&` looks for a falsy value and returns it, so it's done.
+เพราะเหตุนี้ `&&` จึงประเมินตัวถูกดำเนินการทางซ้าย (เอาท์พุท `1`) และหยุดทำงานทันที เพราะ `undefined` เป็นค่า falsy และ `&&` จะหาค่า falsy ตัวแรกที่เจอ และส่งค่านั้นกลับไป เป็นอันเสร็จสิ้นการทำงาน
 
diff --git a/1-js/02-first-steps/11-logical-operators/4-alert-and/task.md b/1-js/02-first-steps/11-logical-operators/4-alert-and/task.md
index 69f877b95..96de618de 100644
--- a/1-js/02-first-steps/11-logical-operators/4-alert-and/task.md
+++ b/1-js/02-first-steps/11-logical-operators/4-alert-and/task.md
@@ -2,9 +2,9 @@ importance: 3
 
 ---
 
-# What is the result of AND'ed alerts?
+# ทายผลลัพธ์ของ AND จากโค้ดต่อไปนี้?
 
-What will this code show?
+คิดว่าอะไรจะแสดงที่ออกมาจากฟังก์ชั่น alert
 
 ```js
 alert( alert(1) && alert(2) );
diff --git a/1-js/02-first-steps/11-logical-operators/5-alert-and-or/solution.md b/1-js/02-first-steps/11-logical-operators/5-alert-and-or/solution.md
index 25e3568f8..00cc59b47 100644
--- a/1-js/02-first-steps/11-logical-operators/5-alert-and-or/solution.md
+++ b/1-js/02-first-steps/11-logical-operators/5-alert-and-or/solution.md
@@ -1,16 +1,16 @@
-The answer: `3`.
+คำตออบคือ `3`
 
 ```js run
 alert( null || 2 && 3 || 4 );
 ```
 
-The precedence of AND `&&` is higher than `||`, so it executes first.
+AND `&&` จะทำงานก่อน `||` เสมอ
 
-The result of `2 && 3 = 3`, so the expression becomes:
+ดังนั้นผลลัพธ์ของ `2 && 3 = 3`จากนิพจน์ข้างต้นจึงได้ว่า
 
 ```
 null || 3 || 4
 ```
 
-Now the result is the first truthy value: `3`.
+ตอนนี้ค่า truthy แรกที่เจอก็คือ `3`
 
diff --git a/1-js/02-first-steps/11-logical-operators/5-alert-and-or/task.md b/1-js/02-first-steps/11-logical-operators/5-alert-and-or/task.md
index b18bb9c51..5881a1796 100644
--- a/1-js/02-first-steps/11-logical-operators/5-alert-and-or/task.md
+++ b/1-js/02-first-steps/11-logical-operators/5-alert-and-or/task.md
@@ -2,9 +2,9 @@ importance: 5
 
 ---
 
-# The result of OR AND OR
+# ทายผลลัพธ์ของ OR AND OR จากโค้ดต่อไปนี้?
 
-What will the result be?
+คิดว่าอะไรจะแสดงที่ออกมาจากฟังก์ชั่น alert
 
 ```js
 alert( null || 2 && 3 || 4 );
diff --git a/1-js/02-first-steps/11-logical-operators/6-check-if-in-range/task.md b/1-js/02-first-steps/11-logical-operators/6-check-if-in-range/task.md
index fc9e336c1..17b0ffa71 100644
--- a/1-js/02-first-steps/11-logical-operators/6-check-if-in-range/task.md
+++ b/1-js/02-first-steps/11-logical-operators/6-check-if-in-range/task.md
@@ -2,8 +2,8 @@ importance: 3
 
 ---
 
-# Check the range between
+# เขียน if ตรวจสอบช่วงตัวเลข
 
-Write an `if` condition to check that `age` is between `14` and `90` inclusively.
+เขียนเงื่อนไขแบบ `if` เพื่อตรวจสอบว่า `age` อยู่ระหว่าง `14` ถึง `90` หรือไม่
 
-"Inclusively" means that `age` can reach the edges `14` or `90`.
+โดยรวมอายุ `14` และ `90` ด้วย
diff --git a/1-js/02-first-steps/11-logical-operators/7-check-if-out-range/task.md b/1-js/02-first-steps/11-logical-operators/7-check-if-out-range/task.md
index 9b947d00f..b10acdc4d 100644
--- a/1-js/02-first-steps/11-logical-operators/7-check-if-out-range/task.md
+++ b/1-js/02-first-steps/11-logical-operators/7-check-if-out-range/task.md
@@ -2,8 +2,8 @@ importance: 3
 
 ---
 
-# Check the range outside
+# เขียน if ตรวจสอบช่วงตัวเลข
 
-Write an `if` condition to check that `age` is NOT between `14` and `90` inclusively.
+เขียนเงื่อนไขแบบ `if` เพื่อตรวจสอบว่า `age` อยู่ไม่ระหว่าง `14` และ `90`
 
-Create two variants: the first one using NOT `!`, the second one -- without it.
+เขียนสองเงื่อนไข: โดยตัวแรกใช้ NOT `!` และตัวที่สองไม่ใช้ NOT `!`
diff --git a/1-js/02-first-steps/11-logical-operators/8-if-question/solution.md b/1-js/02-first-steps/11-logical-operators/8-if-question/solution.md
index 210509758..b9aac2b42 100644
--- a/1-js/02-first-steps/11-logical-operators/8-if-question/solution.md
+++ b/1-js/02-first-steps/11-logical-operators/8-if-question/solution.md
@@ -1,20 +1,20 @@
-The answer: the first and the third will execute.
+คำตอบคือ "if" ตัวแรกและตัวที่สามจะทำงาน
 
-Details:
+คำอธิบาย:
 
 ```js run
-// Runs.
-// The result of -1 || 0 = -1, truthy
+// คำสั่งนี้ทำงาน
+// ผลลัพธ์คือ -1 || 0 = -1 เป็นค่า truthy
 if (-1 || 0) alert( 'first' );
 
-// Doesn't run
-// -1 && 0 = 0, falsy
+// คำสั่งนี้ไม่ทำงาน
+// -1 && 0 = 0 เป็นค่า falsy
 if (-1 && 0) alert( 'second' );
 
-// Executes
-// Operator && has a higher precedence than ||
-// so -1 && 1 executes first, giving us the chain:
-// null || -1 && 1  ->  null || 1  ->  1
+// คำสั่งนี้ทำงาน
+// ตัวดำเนินการ && จะทำงานก่อน || เสมอ
+// ดังนั้น -1 && 1 ทำงานเสร็จ ก็จะทำงานส่วนที่เหลือต่อ
+// null || -1 && 1  จะเป็น  null || 1  จะเป็น  1
 if (null || -1 && 1) alert( 'third' );
 ```
 
diff --git a/1-js/02-first-steps/11-logical-operators/8-if-question/task.md b/1-js/02-first-steps/11-logical-operators/8-if-question/task.md
index 55987121b..2f31c0c2b 100644
--- a/1-js/02-first-steps/11-logical-operators/8-if-question/task.md
+++ b/1-js/02-first-steps/11-logical-operators/8-if-question/task.md
@@ -2,11 +2,11 @@ importance: 5
 
 ---
 
-# A question about "if"
+# ปัญหาของ "if"
 
-Which of these `alert`s are going to execute?
+จากคำสั่ง "if" ทั้งสาม `alert` ตัวไหนจะทำงานบ้าง
 
-What will the results of the expressions be inside `if(...)`?
+และผลลัพธ์สุดท้ายภายใน `if(...)` จะเป็นอะไร
 
 ```js
 if (-1 || 0) alert( 'first' );
diff --git a/1-js/02-first-steps/11-logical-operators/9-check-login/solution.md b/1-js/02-first-steps/11-logical-operators/9-check-login/solution.md
index 604606259..128866c27 100644
--- a/1-js/02-first-steps/11-logical-operators/9-check-login/solution.md
+++ b/1-js/02-first-steps/11-logical-operators/9-check-login/solution.md
@@ -22,4 +22,4 @@ if (userName === 'Admin') {
 }
 ```
 
-Note the vertical indents inside the `if` blocks. They are technically not required, but make the code more readable.
+สังเกตการระยะห่างแนวตั้งภายในบล็อก `if` ในทางเทคนิคไม่จำเป็นต้องมีก็ได้ โค้ดก็ทำงานเหมือนเดิม เราเติมช่องว่างเข้าไปเพื่อให้โค้ดอ่านง่ายขึ้น
diff --git a/1-js/02-first-steps/11-logical-operators/9-check-login/task.md b/1-js/02-first-steps/11-logical-operators/9-check-login/task.md
index 290a52642..7e8f7e840 100644
--- a/1-js/02-first-steps/11-logical-operators/9-check-login/task.md
+++ b/1-js/02-first-steps/11-logical-operators/9-check-login/task.md
@@ -2,24 +2,24 @@ importance: 3
 
 ---
 
-# Check the login
+# มาเริ่มสร้างฟอร์มล็อคอินผ่าน prompt
 
-Write the code which asks for a login with `prompt`.
+สร้างฟอร์มล็อคอินด้วยฟังก์ชั่น `prompt`
 
-If the visitor enters `"Admin"`, then `prompt` for a password, if the input is an empty line or `key:Esc` -- show "Canceled", if it's another string -- then show "I don't know you".
+หากผู้เยี่ยมชมป้อน `"Admin"` ให้ใช้ฟังก์ชั่น `prompt` ถามรหัสผ่าน หากป้อนสตริงว่าง หรือกด `key:Esc` ให้แสดงคำว่า "Canceled" และหากป้อนสตริงอื่นให้แสดงคำว่า "I don't know you"
 
-The password is checked as follows:
+กฎการตรวจสอบรหัสผ่านคือดังนี้:
 
-- If it equals "TheMaster", then show "Welcome!",
-- Another string -- show "Wrong password",
-- For an empty string or cancelled input, show "Canceled"
+- หากรหัสผ่านเท่ากับ "TheMaster" ให้แสดงคำว่า "Welcome!",
+- หากไม่ใช่ให้แสดงคำว่า "Wrong password",
+- หากป้อนสตริงว่าง หรือกด `key:Esc` ให้แสดงคำว่า "Canceled"
 
-The schema:
+Schema:
 
 ![](ifelse_task.svg)
 
-Please use nested `if` blocks. Mind the overall readability of the code.
+โปรดใช้บล็อค `if` ให้คำนึงถึงความอ่านง่ายของโค้ด
 
-Hint:  passing an empty input to a prompt returns an empty string `''`. Pressing `key:ESC` during a prompt returns `null`.
+คำใบ้:  หากไม่ใส่อะไรลงในช่องอินพุทมันจะส่งสตริงเปล่ากลับมา `''` หากกด `key:ESC` มันจะส่ง `null` กลับมา
 
 [demo]
diff --git a/1-js/02-first-steps/11-logical-operators/article.md b/1-js/02-first-steps/11-logical-operators/article.md
index 78c4fd2f1..8e2418a51 100644
--- a/1-js/02-first-steps/11-logical-operators/article.md
+++ b/1-js/02-first-steps/11-logical-operators/article.md
@@ -1,47 +1,47 @@
-# Logical operators
+# ตัวดำเนินการตรรกะ 
 
-There are four logical operators in JavaScript: `||` (OR), `&&` (AND), `!` (NOT), `??` (Nullish Coalescing). Here we cover the first three, the `??` operator is in the next article.
+ใน JavaScript มีตัวดำเนินการตรรกะ 4 ตัว ได้แก่ `||` (OR), `&&` (AND), `!` (NOT) และ `??` (Nullish Coalescing) ในที่นี้จะอธิบายเฉพาะ 3 ตัวแรก ส่วนตัว `??` จะอยู่ในบทความถัดไป
 
-Although they are called "logical", they can be applied to values of any type, not only boolean. Their result can also be of any type.
+แม้จะเรียกว่า "ตรรกะ" แต่ก็สามารถใช้กับค่าประเภทอื่นๆ นอกเหนือจาก boolean ได้ และผลลัพธ์ที่ออกมาก็เป็นประเภทอะไรก็ได้เช่นกัน
 
-Let's see the details.
+มาดูรายละเอียดกัน
 
 ## || (OR)
 
-The "OR" operator is represented with two vertical line symbols:
+เครื่องหมาย "OR" จะแทนด้วยสัญลักษณ์เส้นตั้งคู่ `||` แบบนี้:
 
 ```js
 result = a || b;
 ```
 
-In classical programming, the logical OR is meant to manipulate boolean values only. If any of its arguments are `true`, it returns `true`, otherwise it returns `false`.
+โดยทั่วไปแล้ว OR ตรรกะมีไว้ใช้กับค่า boolean เท่านั้น ถ้ามี argument ตัวใดเป็น `true` ก็จะคืนค่า `true` ถ้าไม่มีเลยจะคืนค่า `false`
 
-In JavaScript, the operator is a little bit trickier and more powerful. But first, let's see what happens with boolean values.
+แต่ใน JavaScript นั้นตัวดำเนินการ OR มีความซับซ้อนและมีพลังมากกว่านั้นหน่อย แต่ก่อนอื่นมาดูว่าเกิดอะไรขึ้นกับค่า boolean ก่อน
 
-There are four possible logical combinations:
+จะมีเคสที่เป็นไปได้ 4 แบบ:
 
 ```js run
 alert( true || true );   // true
 alert( false || true );  // true
 alert( true || false );  // true
-alert( false || false ); // false
+alert( false || false ); // false  
 ```
 
-As we can see, the result is always `true` except for the case when both operands are `false`.
+จะเห็นว่าผลลัพธ์จะเป็น `true` เสมอ ยกเว้นกรณีที่ operand ทั้งสองข้างเป็น `false`
 
-If an operand is not a boolean, it's converted to a boolean for the evaluation.
+ถ้า operand ไม่ใช่ boolean จะถูกแปลงเป็น boolean ก่อนแล้วค่อยประเมิน
 
-For instance, the number `1` is treated as `true`, the number `0` as `false`:
+เช่น ตัวเลข `1` จะถือเป็น `true` ส่วนตัวเลข `0` จะเป็น `false`:
 
 ```js run
-if (1 || 0) { // works just like if( true || false )
-  alert( 'truthy!' );
+if (1 || 0) { // จะทำงานเหมือน if (true || false)
+  alert('truthy!');
 }
 ```
 
-Most of the time, OR `||` is used in an `if` statement to test if *any* of the given conditions is `true`.
+ส่วนใหญ่แล้ว OR `||` จะใช้ในคำสั่ง `if` เพื่อตรวจว่ามีเงื่อนไขใดเป็น `true` บ้าง
 
-For example:
+ตัวอย่างเช่น:
 
 ```js run
 let hour = 9;
@@ -49,102 +49,102 @@ let hour = 9;
 *!*
 if (hour < 10 || hour > 18) {
 */!*
-  alert( 'The office is closed.' );
+  alert('ออฟฟิศปิดแล้ว');  
 }
 ```
 
-We can pass more conditions:
+เราสามารถเพิ่มเงื่อนไขได้อีก:
 
 ```js run
 let hour = 12;
 let isWeekend = true;
 
 if (hour < 10 || hour > 18 || isWeekend) {
-  alert( 'The office is closed.' ); // it is the weekend
+  alert('ออฟฟิศปิดแล้ว'); // เพราะเป็นวันหยุดสุดสัปดาห์  
 }
 ```
 
-## OR "||" finds the first truthy value [#or-finds-the-first-truthy-value]
+## OR "||" จะหาค่า truthy ตัวแรก
 
-The logic described above is somewhat classical. Now, let's bring in the "extra" features of JavaScript.
+ตรรกะที่อธิบายไว้ข้างต้นค่อนข้างเป็นแบบดั้งเดิม ทีนี้มาดูความสามารถ "พิเศษ" ของ JavaScript กัน
 
-The extended algorithm works as follows.
+อัลกอริทึมที่ขยายออกไปจะทำงานดังนี้
 
-Given multiple OR'ed values:
+เมื่อมีหลายค่ามา OR กัน:
 
 ```js
 result = value1 || value2 || value3;
 ```
 
-The OR `||` operator does the following:
+ตัวดำเนินการ OR `||` จะทำดังนี้:
 
-- Evaluates operands from left to right.
-- For each operand, converts it to boolean. If the result is `true`, stops and returns the original value of that operand.
-- If all operands have been evaluated (i.e. all were `false`), returns the last operand.
+- ประเมิน operand จากซ้ายไปขวา
+- สำหรับแต่ละ operand จะแปลงเป็น boolean ถ้าผลลัพธ์เป็น `true` จะหยุดและคืนค่าเดิมของ operand นั้นทันที
+- ถ้าประเมิน operand ทั้งหมดแล้ว (คือทุกตัวเป็น `false`) จะคืนค่า operand ตัวสุดท้าย
 
-A value is returned in its original form, without the conversion.
+จะคืนค่าในรูปแบบเดิม โดยไม่มีการแปลงใดๆ
 
-In other words, a chain of OR `||` returns the first truthy value or the last one if no truthy value is found.
+อีกนัยหนึ่ง การเชื่อม OR `||` หลายตัวจะคืนค่า truthy ตัวแรกเสมอ หรือถ้าไม่เจอค่า truthy เลยจะคืนตัวสุดท้าย
 
-For instance:
+ตัวอย่างเช่น:
 
 ```js run
-alert( 1 || 0 ); // 1 (1 is truthy)
+alert( 1 || 0 ); // 1 (1 เป็น truthy)
 
-alert( null || 1 ); // 1 (1 is the first truthy value)
-alert( null || 0 || 1 ); // 1 (the first truthy value)
+alert( null || 1 ); // 1 (1 เป็นค่า truthy ตัวแรก)
+alert( null || 0 || 1 ); // 1 (ค่า truthy ตัวแรก)
 
-alert( undefined || null || 0 ); // 0 (all falsy, returns the last value)
+alert( undefined || null || 0 ); // 0 (ทั้งหมดเป็น falsy จึงคืนค่าตัวสุดท้าย)
 ```
 
-This leads to some interesting usage compared to a "pure, classical, boolean-only OR".
+พฤติกรรมนี้ทำให้มีวิธีใช้ OR ที่น่าสนใจเมื่อเทียบกับการใช้ OR แบบบูลีนอย่างเดียวทั่วไป
 
-1. **Getting the first truthy value from a list of variables or expressions.**
+1. **การหาค่า truthy ตัวแรกจาก list ของตัวแปรหรือนิพจน์ต่างๆ**
 
-    For instance, we have `firstName`, `lastName` and `nickName` variables, all optional (i.e. can be undefined or have falsy values).
+   เช่น สมมติเรามีตัวแปร `firstName`, `lastName` และ `nickName` ซึ่งล้วนแต่เป็นออปชันที่อาจจะเป็น undefined หรือมีค่า falsy ได้
 
-    Let's use OR `||` to choose the one that has the data and show it (or `"Anonymous"` if nothing set):
+   เราสามารถใช้ OR `||` เพื่อเลือกเอาค่าที่เซ็ตข้อมูลแล้วมาแสดง (หรือถ้าไม่มีจะแสดง `"Anonymous"`):
 
-    ```js run
-    let firstName = "";
-    let lastName = "";
-    let nickName = "SuperCoder";
+   ```js run
+   let firstName = "";
+   let lastName = "";
+   let nickName = "SuperCoder";
 
-    *!*
-    alert( firstName || lastName || nickName || "Anonymous"); // SuperCoder
-    */!*
-    ```
+   *!*
+   alert( firstName || lastName || nickName || "Anonymous"); // SuperCoder
+   */!*
+   ```
 
-    If all variables were falsy, `"Anonymous"` would show up.
+   ถ้าทุกตัวแปรเป็น falsy ก็จะแสดง `"Anonymous"`
 
-2. **Short-circuit evaluation.**
+2. **การประเมินแบบตัดตอนสั้น (short-circuit)**
 
-    Another feature of OR `||` operator is the so-called "short-circuit" evaluation.
+   อีกความสามารถของตัวดำเนินการ OR `||` คือเรียกว่า "short-circuit evaluation" 
+   
+   มันหมายความว่า `||` จะประมวลผลอาร์กิวเมนต์จนกว่าจะเจอค่า truthy ตัวแรก แล้วจะคืนค่านั้นทันทีเลย โดยไม่แตะอาร์กิวเมนต์ตัวถัดไปเลย
 
-    It means that `||` processes its arguments until the first truthy value is reached, and then the value is returned immediately, without even touching the other argument.
+   ความสำคัญของความสามารถนี้จะเห็นได้ชัดเจน ถ้า operand ไม่ใช่แค่ค่าธรรมดา แต่เป็นนิพจน์ที่มี side-effect อย่างเช่นการกำหนดค่าตัวแปรหรือเรียกใช้ฟังก์ชัน
 
-    The importance of this feature becomes obvious if an operand isn't just a value, but an expression with a side effect, such as a variable assignment or a function call.
+   ในตัวอย่างด้านล่าง จะพิมพ์แค่ข้อความที่สองเท่านั้น:
+   
+   ```js run no-beautify
+   *!*true*/!* || alert("จะไม่พิมพ์");
+   *!*false*/!* || alert("จะพิมพ์");
+   ```
 
-    In the example below, only the second message is printed:
+   ในบรรทัดแรก ตัว OR `||` จะหยุดประเมินทันทีที่เจอ `true` ดังนั้น `alert` จึงไม่ถูกเรียก
 
-    ```js run no-beautify
-    *!*true*/!* || alert("not printed");
-    *!*false*/!* || alert("printed");
-    ```
-
-    In the first line, the OR `||` operator stops the evaluation immediately upon seeing `true`, so the `alert` isn't run.
-
-    Sometimes, people use this feature to execute commands only if the condition on the left part is falsy.
+   บางครั้งก็มีคนใช้ความสามารถนี้เพื่อรันคำสั่งก็ต่อเมื่อเงื่อนไขทางซ้ายมือเป็น falsy ด้วย
 
 ## && (AND)
 
-The AND operator is represented with two ampersands `&&`:
+เครื่องหมาย AND ใช้สัญลักษณ์ & สองตัวติดกัน `&&` แบบนี้:
 
 ```js
 result = a && b;
 ```
 
-In classical programming, AND returns `true` if both operands are truthy and `false` otherwise:
+โดยปกติในการเขียนโปรแกรม AND จะคืนค่า `true` ถ้า operand ทั้งสองเป็น truthy และคืน `false` ในกรณีอื่นๆ:
 
 ```js run
 alert( true && true );   // true
@@ -153,137 +153,135 @@ alert( true && false );  // false
 alert( false && false ); // false
 ```
 
-An example with `if`:
+ตัวอย่างการใช้กับ `if`:
 
 ```js run
 let hour = 12;
 let minute = 30;
 
 if (hour == 12 && minute == 30) {
-  alert( 'The time is 12:30' );
-}
+  alert( 'ขณะนี้เวลา 12:30 น.' );
+}  
 ```
 
-Just as with OR, any value is allowed as an operand of AND:
+เหมือนกับ OR นั่นคือ operand ของ AND จะเป็นค่าอะไรก็ได้:
 
 ```js run
-if (1 && 0) { // evaluated as true && false
-  alert( "won't work, because the result is falsy" );
+if (1 && 0) { // ประเมินเป็น true && false
+  alert( "จะไม่ทำงาน เพราะผลลัพธ์เป็น falsy" );
 }
 ```
 
+## AND "&&" จะหาค่า falsy ตัวแรก
 
-## AND "&&" finds the first falsy value
-
-Given multiple AND'ed values:
+ถ้ามีหลายค่ามา AND กัน:
 
 ```js
 result = value1 && value2 && value3;
 ```
 
-The AND `&&` operator does the following:
+ตัวดำเนินการ AND `&&` จะทำงานดังนี้:
 
-- Evaluates operands from left to right.
-- For each operand, converts it to a boolean. If the result is `false`, stops and returns the original value of that operand.
-- If all operands have been evaluated (i.e. all were truthy), returns the last operand.
+- ประเมิน operand จากซ้ายไปขวา
+- สำหรับแต่ละ operand จะแปลงเป็น boolean ถ้าผลลัพธ์เป็น `false` จะหยุดและคืนค่าเดิมของ operand นั้นทันที
+- ถ้าประเมิน operand ทั้งหมดแล้ว (คือทุกตัวเป็น truthy) จะคืนค่า operand ตัวสุดท้าย
 
-In other words, AND returns the first falsy value or the last value if none were found.
+อีกนัยหนึ่ง AND จะคืนค่า falsy ตัวแรกที่เจอ หรือถ้าไม่เจอเลยจะคืนค่าตัวสุดท้าย
 
-The rules above are similar to OR. The difference is that AND returns the first *falsy* value while OR returns the first *truthy* one.
+กฎข้างต้นคล้ายกับ OR ต่างกันตรงที่ AND คืนค่า *falsy* ตัวแรก ส่วน OR คืนค่า *truthy* ตัวแรก
 
-Examples:
+ตัวอย่าง:
 
 ```js run
-// if the first operand is truthy,
-// AND returns the second operand:
+// ถ้า operand ตัวแรกเป็น truthy
+// AND จะคืนค่า operand ตัวที่สอง:
 alert( 1 && 0 ); // 0
 alert( 1 && 5 ); // 5
 
-// if the first operand is falsy,
-// AND returns it. The second operand is ignored
+// ถ้า operand ตัวแรกเป็น falsy 
+// AND จะคืนค่านั้นเลย โดยไม่สนใจ operand ตัวที่สอง
 alert( null && 5 ); // null
-alert( 0 && "no matter what" ); // 0
+alert( 0 && "ไม่สำคัญ" ); // 0
 ```
 
-We can also pass several values in a row. See how the first falsy one is returned:
+เราสามารถส่งหลายค่าต่อกันได้ ลองดูว่าค่า falsy ตัวแรกจะถูกคืนออกมา:
 
 ```js run
 alert( 1 && 2 && null && 3 ); // null
 ```
 
-When all values are truthy, the last value is returned:
+ถ้าค่าทั้งหมดเป็น truthy ค่าตัวสุดท้ายจะถูกคืน:
 
 ```js run
-alert( 1 && 2 && 3 ); // 3, the last one
+alert( 1 && 2 && 3 ); // 3, ตัวสุดท้าย  
 ```
 
-````smart header="Precedence of AND `&&` is higher than OR `||`"
-The precedence of AND `&&` operator is higher than OR `||`.
+````smart header="AND `&&` มีลำดับความสำคัญสูงกว่า OR `||`"
+ตัวดำเนินการ AND `&&` จะมี precedence สูงกว่า OR `||`
 
-So the code `a && b || c && d` is essentially the same as if the `&&` expressions were in parentheses: `(a && b) || (c && d)`.
+ดังนั้นโค้ด `a && b || c && d` ก็เหมือนกับการเขียนนิพจน์ `&&` อยู่ในวงเล็บ: `(a && b) || (c && d)`
 ````
 
-````warn header="Don't replace `if` with `||` or `&&`"
-Sometimes, people use the AND `&&` operator as a "shorter way to write `if`".
+````warn header="อย่าใช้ `||` หรือ `&&` แทนคำสั่ง `if`"
+บางครั้งมีคนใช้ตัวดำเนินการ AND `&&` เพื่อ "เขียน `if` ให้สั้นลง"
 
-For instance:
+เช่น:
 
 ```js run
 let x = 1;
 
-(x > 0) && alert( 'Greater than zero!' );
+(x > 0) && alert( 'มากกว่าศูนย์!' );
 ```
 
-The action in the right part of `&&` would execute only if the evaluation reaches it. That is, only if `(x > 0)` is true.
+การกระทำทางขวาของ `&&` จะรันก็ต่อเมื่อการประเมินทำไปถึงจุดนั้น ซึ่งก็คือเมื่อ `(x > 0)` เป็นจริง
 
-So we basically have an analogue for:
+ดังนั้นมันจะเหมือนกับการเขียนแบบนี้:
 
 ```js run
 let x = 1;
 
-if (x > 0) alert( 'Greater than zero!' );
+if (x > 0) alert( 'มากกว่าศูนย์!' );  
 ```
 
-Although, the variant with `&&` appears shorter, `if` is more obvious and tends to be a little bit more readable. So we recommend using every construct for its purpose: use `if` if we want `if` and use `&&` if we want AND.
+ถึงแม้การใช้ `&&` จะดูสั้นกว่า แต่ `if` จะชัดเจนและอ่านเข้าใจง่ายกว่า แนะนำให้ใช้แต่ละแบบตามวัตถุประสงค์ที่มันถูกสร้างมา ใช้ `if` ถ้าต้องการเงื่อนไข if และใช้ `&&` ถ้าต้องการตรรกะ AND
 ````
 
-
 ## ! (NOT)
 
-The boolean NOT operator is represented with an exclamation sign `!`.
+ตัวดำเนินการตรรกะ NOT ใช้สัญลักษณ์อัศเจรีย์ `!` 
 
-The syntax is pretty simple:
+รูปแบบการใช้งานค่อนข้างง่าย:
 
 ```js
 result = !value;
 ```
 
-The operator accepts a single argument and does the following:
+โดยตัวดำเนินการจะรับ operand เดียว และทำงานดังนี้:
 
-1. Converts the operand to boolean type: `true/false`.
-2. Returns the inverse value.
+1. แปลง operand ให้เป็นประเภท boolean: `true/false`
+2. คืนค่าตรงข้าม (invert)
 
-For instance:
+ตัวอย่างเช่น:
 
 ```js run
 alert( !true ); // false
 alert( !0 ); // true
 ```
 
-A double NOT `!!` is sometimes used for converting a value to boolean type:
+การใช้ NOT สองตัวติดกัน `!!` บางครั้งใช้เพื่อแปลงค่าให้เป็นประเภท boolean:
 
 ```js run
 alert( !!"non-empty string" ); // true
-alert( !!null ); // false
+alert( !!null ); // false  
 ```
 
-That is, the first NOT converts the value to boolean and returns the inverse, and the second NOT inverses it again. In the end, we have a plain value-to-boolean conversion.
+นั่นคือ NOT ตัวแรกจะแปลงค่าเป็น boolean และคืนค่าตรงข้าม จากนั้น NOT ตัวที่สองก็จะ invert อีกครั้ง ในท้ายที่สุดเราจะได้การแปลงค่าเป็น boolean อย่างง่ายๆ
 
-There's a little more verbose way to do the same thing -- a built-in `Boolean` function:
+มีอีกวิธีที่อ่านเข้าใจง่ายกว่าในการทำแบบเดียวกัน คือใช้ฟังก์ชันในตัว `Boolean`:
 
 ```js run
 alert( Boolean("non-empty string") ); // true
 alert( Boolean(null) ); // false
 ```
 
-The precedence of NOT `!` is the highest of all logical operators, so it always executes first, before `&&` or `||`.
+ตัวดำเนินการ NOT `!` จะมีลำดับความสำคัญ (precedence) สูงสุดในบรรดาตัวดำเนินการตรรกะทั้งหมด ดังนั้นมันจะถูกประมวลผลก่อนเสมอ ก่อนที่จะไปประมวลผล `&&` หรือ `||`
\ No newline at end of file
diff --git a/1-js/02-first-steps/12-nullish-coalescing-operator/article.md b/1-js/02-first-steps/12-nullish-coalescing-operator/article.md
index 0b2f092ab..854002bc0 100644
--- a/1-js/02-first-steps/12-nullish-coalescing-operator/article.md
+++ b/1-js/02-first-steps/12-nullish-coalescing-operator/article.md
@@ -1,94 +1,122 @@
-# Nullish coalescing operator '??'
+# ตัวดำเนินการรวม Nullish '??'
 
 [recent browser="new"]
 
-The nullish coalescing operator is written as two question marks `??`.
+ตัวดำเนินการรวม nullish เขียนด้วยเครื่องหมายคำถามสองตัวติดกัน `??` 
 
+<<<<<<< HEAD
+ในบทความนี้เราจะใช้ศัพท์เฉพาะ เนื่องจาก `null` และ `undefined` ถูกจัดการในลักษณะคล้ายกัน เพื่อให้กระชับ เราจะเรียกว่าค่าหนึ่ง "ถูกกำหนด" เมื่อไม่ใช่ทั้ง `null` และ `undefined`
+=======
 As it treats `null` and `undefined` similarly, we'll use a special term here, in this article. For brevity, we'll say that a value is "defined" when it's neither `null` nor `undefined`.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-The result of `a ?? b` is:
-- if `a` is defined, then `a`,
-- if `a` isn't defined, then `b`.
+ผลลัพธ์ของ `a ?? b` จะเป็น:
+- ถ้า `a` ถูกกำหนด ผลลัพธ์คือ `a`
+- ถ้า `a` ไม่ถูกกำหนด ผลลัพธ์คือ `b`
 
-In other words, `??` returns the first argument if it's not `null/undefined`. Otherwise, the second one.
+อีกนัยหนึ่ง `??` จะคืนอาร์กิวเมนต์ตัวแรก ถ้าไม่ใช่ `null/undefined` ไม่เช่นนั้นจะคืนตัวที่สอง
 
-The nullish coalescing operator isn't anything completely new. It's just a nice syntax to get the first "defined" value of the two.
+ตัวดำเนินการรวม nullish ไม่ใช่เรื่องใหม่ เป็นเพียงไวยากรณ์ที่สะดวกในการหาค่าแรกที่ "ถูกกำหนด" จากสองค่า
 
-We can rewrite `result = a ?? b` using the operators that we already know, like this:
+เราสามารถเขียน `result = a ?? b` ใหม่โดยใช้ตัวดำเนินการที่คุ้นเคยแล้วได้ดังนี้:
 
 ```js
 result = (a !== null && a !== undefined) ? a : b;
 ```
 
-Now it should be absolutely clear what `??` does. Let's see where it helps.
+ตอนนี้น่าจะชัดเจนแล้วว่า `??` ทำอะไร มาดูกันว่ามันมีประโยชน์อย่างไรบ้าง
 
+<<<<<<< HEAD
+กรณีใช้งานทั่วไปของ `??` คือการกำหนดค่าเริ่มต้น (default)
+
+ตัวอย่างเช่น ตรงนี้เราจะแสดง `user` ถ้าค่าไม่ใช่ `null/undefined` ไม่อย่างนั้นจะแสดง `Anonymous`:
+=======
 The common use case for `??` is to provide a default value.
 
 For example, here we show `user` if its value isn't `null/undefined`, otherwise `Anonymous`:
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
 ```js run
 let user;
 
+<<<<<<< HEAD
+alert(user ?? "Anonymous"); // Anonymous (user เป็น undefined)
+=======
 alert(user ?? "Anonymous"); // Anonymous (user is undefined)
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 ```
 
-Here's the example with `user` assigned to a name:
+นี่คือตัวอย่างที่กำหนด `user` เป็นชื่อ:
 
 ```js run
 let user = "John";
 
+<<<<<<< HEAD
+alert(user ?? "Anonymous"); // John (user ไม่ใช่ null/undefined)
+=======
 alert(user ?? "Anonymous"); // John (user is not null/undefined)
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 ```
 
-We can also use a sequence of `??` to select the first value from a list that isn't `null/undefined`.
+เรายังสามารถใช้ `??` หลายตัวต่อกัน เพื่อเลือกค่าแรกจาก list ที่ไม่ใช่ `null/undefined` ได้ด้วย
+
+<<<<<<< HEAD
+สมมติเรามีข้อมูลผู้ใช้ในตัวแปร `firstName`, `lastName` หรือ `nickName` ซึ่งอาจไม่ถูกกำหนดค่า หากผู้ใช้ไม่ได้กรอกข้อมูลที่เกี่ยวข้อง
 
+เราต้องการแสดงชื่อผู้ใช้จากตัวแปรเหล่านี้ตัวใดตัวหนึ่ง หรือแสดง "Anonymous" ถ้าทุกตัวเป็น `null/undefined`
+=======
 Let's say we have a user's data in variables `firstName`, `lastName` or `nickName`. All of them may be not defined, if the user decided not to fill in the corresponding values.
 
 We'd like to display the user name using one of these variables, or show "Anonymous" if all of them are `null/undefined`.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-Let's use the `??` operator for that:
+มาใช้ตัวดำเนินการ `??` กันเลย:
 
 ```js run
 let firstName = null;
 let lastName = null;
 let nickName = "Supercoder";
 
-// shows the first defined value:
+// แสดงค่าแรกที่ถูกกำหนด:
 *!*
 alert(firstName ?? lastName ?? nickName ?? "Anonymous"); // Supercoder
-*/!*
+*/!*  
 ```
 
-## Comparison with ||
+## เปรียบเทียบกับ ||
 
-The OR `||` operator can be used in the same way as `??`, as it was described in the [previous chapter](info:logical-operators#or-finds-the-first-truthy-value).
+ตัวดำเนินการ OR `||` สามารถใช้ได้ในทำนองเดียวกับ `??` ตามที่อธิบายไว้ใน[บทก่อนหน้า](info:logical-operators#or-finds-the-first-truthy-value)
 
-For example, in the code above we could replace `??` with `||` and still get the same result:
+เช่น ในโค้ดข้างต้น เราสามารถแทนที่ `??` ด้วย `||` โดยยังได้ผลลัพธ์เหมือนเดิม:
 
 ```js run
 let firstName = null;
 let lastName = null;
 let nickName = "Supercoder";
 
-// shows the first truthy value:
+// แสดงค่า truthy ตัวแรก:
 *!*
 alert(firstName || lastName || nickName || "Anonymous"); // Supercoder
 */!*
 ```
 
+<<<<<<< HEAD
+ย้อนไปในอดีต ตัวดำเนินการ OR `||` มีมาก่อนตั้งแต่ JavaScript เริ่มต้น นักพัฒนาจึงใช้มันเพื่อวัตถุประสงค์แบบนี้มานาน
+=======
 Historically, the OR `||` operator was there first. It's been there since the beginning of JavaScript, so developers were using it for such purposes for a long time.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-On the other hand, the nullish coalescing operator `??` was added to JavaScript only recently, and the reason for that was that people weren't quite happy with `||`.
+ในทางกลับกัน ตัวดำเนินการรวม nullish `??` เพิ่งถูกเพิ่มเข้ามาใน JavaScript ไม่นานมานี้ สาเหตุเพราะคนไม่ค่อยพอใจกับ `||` นัก
 
-The important difference between them is that:
-- `||` returns the first *truthy* value.
-- `??` returns the first *defined* value.
+ความแตกต่างสำคัญระหว่างสองตัวนี้คือ:
+- `||` คืนค่า *truthy* ตัวแรก  
+- `??` คืนค่าแรกที่ *ถูกกำหนด*
 
-In other words, `||` doesn't distinguish between `false`, `0`, an empty string `""` and `null/undefined`. They are all the same -- falsy values. If any of these is the first argument of `||`, then we'll get the second argument as the result.
+อีกนัยหนึ่ง `||` ไม่ได้แยกความแตกต่างระหว่าง `false`, `0`, string ว่าง `""` และ `null/undefined` มันถือว่าทั้งหมดเป็นค่า falsy เหมือนกัน ถ้าตัวใดตัวหนึ่งเป็น argument ตัวแรกของ `||` เราจะได้ argument ตัวที่สองเป็นผลลัพธ์
 
-In practice though, we may want to use default value only when the variable is `null/undefined`. That is, when the value is really unknown/not set.
+แต่ในทางปฏิบัติ เราอาจต้องการใช้ค่าเริ่มต้นก็ต่อเมื่อตัวแปรเป็น `null/undefined` นั่นคือเมื่อไม่รู้ค่าจริงๆ/ไม่ได้ถูกกำหนด
 
-For example, consider this:
+ตัวอย่างเช่น พิจารณาโค้ดนี้:
 
 ```js run
 let height = 0;
@@ -97,73 +125,85 @@ alert(height || 100); // 100
 alert(height ?? 100); // 0
 ```
 
-- The `height || 100` checks `height` for being a falsy value, and it's `0`, falsy indeed.
-    - so the result of `||` is the second argument, `100`.
-- The `height ?? 100` checks `height` for being `null/undefined`, and it's not,
-    - so the result is `height` "as is", that is `0`.
+- `height || 100` ตรวจสอบว่า `height` เป็นค่า falsy หรือไม่ ซึ่ง `0` ก็ถือเป็น falsy จริงๆ
+    - ดังนั้นผลลัพธ์ของ `||` คือ argument ตัวที่สอง `100`
+- `height ?? 100` ตรวจสอบว่า `height` เป็น `null/undefined` หรือไม่ ซึ่งไม่ใช่
+    - ดังนั้นผลลัพธ์คือ `height` "ตามที่เป็น" คือ `0`
 
-In practice, the zero height is often a valid value, that shouldn't be replaced with the default. So `??` does just the right thing.
+ในทางปฏิบัติ ความสูงเป็นศูนย์มักเป็นค่าที่ถูกต้อง ไม่ควรถูกแทนที่ด้วยค่าเริ่มต้น ดังนั้น `??` จึงให้ผลลัพธ์ที่ถูกต้องพอดี
 
-## Precedence
+## ลำดับความสำคัญ
 
+<<<<<<< HEAD
+ตัวดำเนินการ `??` มีลำดับความสำคัญเท่ากับ `||` ทั้งคู่มีค่าเท่ากับ `3` ในตาราง [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence#Table)
+=======
 The precedence of the `??` operator is the same as `||`. They both equal `3` in the [MDN table](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence#Table).
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-That means that, just like `||`, the nullish coalescing operator `??` is evaluated before `=` and `?`, but after most other operations, such as `+`, `*`.
+นั่นหมายความว่า เช่นเดียวกับ `||` ตัวดำเนินการรวม nullish `??` จะถูกประเมินก่อน `=` และ `?` แต่หลังการดำเนินการอื่นๆ ส่วนใหญ่ เช่น `+`, `*`
 
+<<<<<<< HEAD
+ดังนั้นในนิพจน์แบบนี้ เราอาจต้องใส่วงเล็บเพิ่ม:
+=======
 So we may need to add parentheses in expressions like this:
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
 ```js run
 let height = null;
 let width = null;
 
-// important: use parentheses
+// สำคัญ: ใช้วงเล็บ
 let area = (height ?? 100) * (width ?? 50);
 
 alert(area); // 5000
 ```
 
-Otherwise, if we omit parentheses, then as `*` has the higher precedence than `??`, it would execute first, leading to incorrect results.
+ไม่เช่นนั้น ถ้าเราละวงเล็บ เนื่องจาก `*` มีลำดับความสำคัญสูงกว่า `??` มันจะถูกประเมินก่อน ทำให้ได้ผลลัพธ์ไม่ถูกต้อง
 
 ```js
-// without parentheses
+// ไม่มีวงเล็บ
 let area = height ?? 100 * width ?? 50;
 
+<<<<<<< HEAD
+// ...ทำงานแบบนี้ (ไม่ใช่สิ่งที่เราต้องการ):
+=======
 // ...works this way (not what we want):
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 let area = height ?? (100 * width) ?? 50;
 ```
 
-### Using ?? with && or ||
+### การใช้ ?? ร่วมกับ && หรือ ||
 
-Due to safety reasons, JavaScript forbids using `??` together with `&&` and `||` operators, unless the precedence is explicitly specified with parentheses.
+ด้วยเหตุผลด้านความปลอดภัย JavaScript ไม่อนุญาตให้ใช้ `??` ร่วมกับตัวดำเนินการ `&&` และ `||` นอกจากจะระบุลำดับความสำคัญชัดเจนด้วยวงเล็บ
 
-The code below triggers a syntax error:
+โค้ดด้านล่างจะทำให้เกิด syntax error:
 
 ```js run
 let x = 1 && 2 ?? 3; // Syntax error
 ```
 
-The limitation is surely debatable, it was added to the language specification with the purpose to avoid programming mistakes, when people start to switch from `||` to `??`.
+ข้อจำกัดนี้อาจโต้แย้งได้ แต่ถูกเพิ่มเข้ามาในข้อกำหนดภาษา เพื่อหลีกเลี่ยงข้อผิดพลาดในการเขียนโปรแกรม เมื่อคนเริ่มเปลี่ยนจาก `||` มาใช้ `??`  
 
-Use explicit parentheses to work around it:
+ใช้วงเล็บให้ชัดเจนเพื่อแก้ปัญหา:
 
 ```js run
 *!*
-let x = (1 && 2) ?? 3; // Works
+let x = (1 && 2) ?? 3; // ใช้ได้
 */!*
 
 alert(x); // 2
 ```
 
-## Summary
+## สรุป
 
-- The nullish coalescing operator `??` provides a short way to choose the first "defined" value from a list.
+- ตัวดำเนินการรวม nullish `??` ให้วิธีที่กระชับในการเลือกค่าแรกที่ "ถูกกำหนด" จาก list
 
-    It's used to assign default values to variables:
+  มันมักถูกใช้เพื่อกำหนดค่าเริ่มต้นให้ตัวแปร:
 
-    ```js
-    // set height=100, if height is null or undefined
-    height = height ?? 100;
-    ```
+  ```js
+  // กำหนด height=100 ถ้า height เป็น null หรือ undefined
+  height = height ?? 100;
+  ```
 
-- The operator `??` has a very low precedence, only a bit higher than `?` and `=`, so consider adding parentheses when using it in an expression.
-- It's forbidden to use it with `||` or `&&` without explicit parentheses.
+- ตัวดำเนินการ `??` มีลำดับความสำคัญต่ำมาก สูงกว่า `?` และ `=` เพียงเล็กน้อย ดังนั้นควรใส่วงเล็บเมื่อใช้ในนิพจน์
+- ห้ามใช้ร่วมกับ `||` หรือ `&&` โดยไม่ใส่วงเล็บให้ชัดเจน
\ No newline at end of file
diff --git a/1-js/02-first-steps/13-while-for/1-loop-last-value/solution.md b/1-js/02-first-steps/13-while-for/1-loop-last-value/solution.md
index 43ee4aad3..ffc37a316 100644
--- a/1-js/02-first-steps/13-while-for/1-loop-last-value/solution.md
+++ b/1-js/02-first-steps/13-while-for/1-loop-last-value/solution.md
@@ -1,4 +1,4 @@
-The answer: `1`.
+คำตอบก็คือ `1`.
 
 ```js run
 let i = 3;
@@ -8,18 +8,18 @@ while (i) {
 }
 ```
 
-Every loop iteration decreases `i` by `1`. The check `while(i)` stops the loop when `i = 0`.
+การวนซ้ำแต่ละครั้งค่าของตัวแปร `i` จะลดลงทีละ `1` ฉะนั้น `while (i)` จะหยุดเมื่อ `i = 0`
 
-Hence, the steps of the loop form the following sequence ("loop unrolled"):
+ดังนั้นขั้นตอนการทำงานจึงเป็นไปตามด้านล่างนี้ ("loop unrolled")
 
 ```js
 let i = 3;
 
-alert(i--); // shows 3, decreases i to 2
+alert(i--); // แสดง 3 ลด i เป็น 2
 
-alert(i--) // shows 2, decreases i to 1
+alert(i--) // แสดง 2 ลด i เป็น 1
 
-alert(i--) // shows 1, decreases i to 0
+alert(i--) // แสดง 1 ลด i เป็น 0
 
-// done, while(i) check stops the loop
+// จบการทำงาน
 ```
diff --git a/1-js/02-first-steps/13-while-for/1-loop-last-value/task.md b/1-js/02-first-steps/13-while-for/1-loop-last-value/task.md
index 3b847dfa2..bb5c9b337 100644
--- a/1-js/02-first-steps/13-while-for/1-loop-last-value/task.md
+++ b/1-js/02-first-steps/13-while-for/1-loop-last-value/task.md
@@ -2,9 +2,9 @@ importance: 3
 
 ---
 
-# Last loop value
+# ทายเลขตัวสุดท้าย
 
-What is the last value alerted by this code? Why?
+คิดว่าเลขตัวสุดท้ายที่จะแสดงผลจากฟังก์ชัน `alert` คือเลขอะไร
 
 ```js
 let i = 3;
diff --git a/1-js/02-first-steps/13-while-for/2-which-value-while/solution.md b/1-js/02-first-steps/13-while-for/2-which-value-while/solution.md
index 495359876..6611b0348 100644
--- a/1-js/02-first-steps/13-while-for/2-which-value-while/solution.md
+++ b/1-js/02-first-steps/13-while-for/2-which-value-while/solution.md
@@ -1,30 +1,30 @@
-The task demonstrates how postfix/prefix forms can lead to different results when used in comparisons.
+วิธีนี้จะช่วยให้เห็นว่าการเติม postfix/prefix สามารถให้ผลลัพธ์ที่แตกต่างกันได้ หากใช้ในการเปรียบเทียบ
 
-1. **From 1 to 4**
+1. **จาก 1 ไป 4**
 
     ```js run
     let i = 0;
     while (++i < 5) alert( i );
     ```
 
-    The first value is `i = 1`, because `++i` first increments `i` and then returns the new value. So the first comparison is `1 < 5` and the `alert` shows `1`.
+    ค่าแรกคือ `i = 1`, การ prefix `++i` คือบวกเพิ่มทีละหนึ่งก่อนค่อยส่งค่า**ใหม่**กลับ ดังนั้นเมื่อเทียบเงื่อนไขก็จะเป็น `1 < 5` ฟังก์ชัน `alert` จึงแสดงเลข `1`
 
-    Then follow `2, 3, 4…` -- the values show up one after another. The comparison always uses the incremented value, because `++` is before the variable.
+    จากนั้นตามด้วย `2, 3, 4…` ค่าจะแสดงเพิ่มขึ้นทีละ 1 ในขณะเดียวกัน 
 
-    Finally, `i = 4` is incremented to `5`, the comparison `while(5 < 5)` fails, and the loop stops. So `5` is not shown.
-2. **From 1 to 5**
+    จนไปถึง `i = 4` ค่าถูกเพิ่มไปที่ `5` เมื่อเทียบเปรียบจะได้ `while(5 < 5)` ซึ่งเป็นเท็จ ลูบจะหยุดทำงาน เลข `5` จึงไม่แสดงออกมา
+2. **จาก 1 ไป 5**
 
     ```js run
     let i = 0;
     while (i++ < 5) alert( i );
     ```
 
-    The first value is again `i = 1`. The postfix form of `i++` increments `i` and then returns the *old* value, so the comparison `i++ < 5` will use `i = 0` (contrary to `++i < 5`).
+    ค่าแรกคือ `i = 1` การ postfix `i++` คือบวก `i` เพิ่มทีละหนึ่งแต่กลับค่า**เก่า**กลับ ดังนั้นเมื่อเทียบเงื่อนไข `i++ < 5` ก็จะเป็น `i = 0` (ตรงข้ามกับ `++i < 5`)
 
-    But the `alert` call is separate. It's another statement which executes after the increment and the comparison. So it gets the current `i = 1`.
+    แต่ฟังก์ชัน `alert` ถูกเรียกแยกตะหาก มันเป็นอีกคำสั่งหนึ่งซึ่งถูกเรียกหลังจากที่ตัวแปร `i` ถูกบวกค่าเพิ่มเข้าไปแล้ว จึงทำให้ตอนนี้ตัวแปร `i = 1`
 
-    Then follow `2, 3, 4…`
+    จากนั้นก็ตามด้วย `2, 3, 4…`
 
-    Let's stop on `i = 4`. The prefix form `++i` would increment it and use `5` in the comparison. But here we have the postfix form `i++`. So it increments `i` to `5`, but returns the old value. Hence the comparison is actually `while(4 < 5)` -- true, and the control goes on to `alert`.
+    มาหยุดตรงที่ตอน `i = 4` ไปก่อน เราเห็นจากข้างบนแล้วว่าการเติม prefix `++i` เพิ่มค่าให้ `i` ทีละหนึ่งซึ่งจะทำให้ใช้เลข `5` เป็นตัวเทียบเปรียบ แต่สำหรับการเติม postfix `i++` มันก็ทำงานแบบเดียวกันคือตัวแปร `i` เป็น `5` แต่มันจะส่งค่าเก่ากลับไป ดังนั้นเมื่อเปรียบเทียบจึงกลายเป็น  `while(4 < 5)` -- ซึ่งเงื่อนไขเป็นจริง ทำให้ลูบทำงานต่อ
 
-    The value `i = 5` is the last one, because on the next step `while(5 < 5)` is false.
+    จนวนกลับมาอีกรอบทีนี้ `i = 5` แล้ว เงื่อนไข `while(5 < 5)` จึงเป็นเท็จ ลูบจึงหยุดทำงาน
diff --git a/1-js/02-first-steps/13-while-for/2-which-value-while/task.md b/1-js/02-first-steps/13-while-for/2-which-value-while/task.md
index 298213237..3d082b10f 100644
--- a/1-js/02-first-steps/13-while-for/2-which-value-while/task.md
+++ b/1-js/02-first-steps/13-while-for/2-which-value-while/task.md
@@ -2,19 +2,19 @@ importance: 4
 
 ---
 
-# Which values does the while loop show?
+# ทายกันว่าจะมีเลขอะไรออกมาบ้าง
 
-For every loop iteration, write down which value it outputs and then compare it with the solution.
+ลองหยิบกระดาศขึ้นมาหนึ่งแผ่น เขียนตัวเลขที่คิดว่าจะแสดงผลออกมาจากโค้ดด้านล่าง และตอบคำถามด้านล่าง
 
-Both loops `alert` the same values, or not?
+ทั้งสองลูบแสดงผลลัพธ์เดียวกันหรือไม่
 
-1. The prefix form `++i`:
+1. เติม prefix `++i`:
 
     ```js
     let i = 0;
     while (++i < 5) alert( i );
     ```
-2. The postfix form `i++`
+2. เติม postfix `i++`
 
     ```js
     let i = 0;
diff --git a/1-js/02-first-steps/13-while-for/3-which-value-for/solution.md b/1-js/02-first-steps/13-while-for/3-which-value-for/solution.md
index e2e28e75b..f997c4d2b 100644
--- a/1-js/02-first-steps/13-while-for/3-which-value-for/solution.md
+++ b/1-js/02-first-steps/13-while-for/3-which-value-for/solution.md
@@ -1,4 +1,4 @@
-**The answer: from `0` to `4` in both cases.**
+**คำตอบ: แสดงจาก `0` ถึง `4` ทั้งสองกรณี**
 
 ```js run
 for (let i = 0; i < 5; ++i) alert( i );
@@ -6,12 +6,12 @@ for (let i = 0; i < 5; ++i) alert( i );
 for (let i = 0; i < 5; i++) alert( i );
 ```
 
-That can be easily deducted from the algorithm of `for`:
+มาดูวิธีการทำงานของลูบ `for` กัน:
 
-1. Execute once `i = 0` before everything (begin).
-2. Check the condition `i < 5`
-3. If `true` -- execute the loop body `alert(i)`, and then `i++`
+1. มันทำงานเริ่มจากให้ `i = 0` ก่อน
+2. จากนั่นก็ไปตรวจสอบเงื่อนไข `i < 5`
+3. ถ้าเป็น `true` -- โค้ดที่อยู่ข้างในลูบจะทำงาน `alert(i)` และตามด้วย `i++`
 
-The increment `i++` is separated from the condition check (2). That's just another statement.
+จะเห็นว่าการเพิ่มทีละหนึ่ง `i++` ทำงานทีหลังการตรวจสอบเงื่อนไข  (2). มันเป็นอีกหนึ่งคำสั่ง
 
-The value returned by the increment is not used here, so there's no difference between `i++` and `++i`.
+ดังนั้นค่าที่คืนมาจากการเพิ่มละหนึ่งไม่ว่าแบบ `postfix` หรือ `prefix` ไม่ได้ถูกใช้ ดังนั้นจึงไม่มีความแตกต่างกันระหว่าง `i++` และ `++i`
diff --git a/1-js/02-first-steps/13-while-for/3-which-value-for/task.md b/1-js/02-first-steps/13-while-for/3-which-value-for/task.md
index bfefa63f5..3ee1947e1 100644
--- a/1-js/02-first-steps/13-while-for/3-which-value-for/task.md
+++ b/1-js/02-first-steps/13-while-for/3-which-value-for/task.md
@@ -2,18 +2,18 @@ importance: 4
 
 ---
 
-# Which values get shown by the "for" loop?
+# ทายผลลัพธ์อะไรที่จะแสดงออกจากลูบ "for"
 
-For each loop write down which values it is going to show. Then compare with the answer.
+ลองมาเขียนผลลัพธ์ที่จะแสดงออกมาในแต่ละรอบการทำงานกัน
 
-Both loops `alert` same values or not?
+ทั้งสองลูบฟังก์ชัน `alert` จะแสดงค่าออกมาเหมือนกันหรือไม่
 
-1. The postfix form:
+1. แบบ postfix:
 
     ```js
     for (let i = 0; i < 5; i++) alert( i );
     ```
-2. The prefix form:
+2. แบบ prefix:
 
     ```js
     for (let i = 0; i < 5; ++i) alert( i );
diff --git a/1-js/02-first-steps/13-while-for/4-for-even/solution.md b/1-js/02-first-steps/13-while-for/4-for-even/solution.md
index e8e66bb47..b1c4a0e6c 100644
--- a/1-js/02-first-steps/13-while-for/4-for-even/solution.md
+++ b/1-js/02-first-steps/13-while-for/4-for-even/solution.md
@@ -8,4 +8,4 @@ for (let i = 2; i <= 10; i++) {
 }
 ```
 
-We use the "modulo" operator `%` to get the remainder and check for the evenness here.
+เราใช้ตัวดำเนินการ "modulo" หรือ `%` เพื่อดูเศษที่เหลือจากการหาร ในทีนี้คือ สองหาร `i` เหลือเศษเป็น `0` หรือไม่ หากเป็นจริงฟังก์ชัน `alert` จะทำงาน
diff --git a/1-js/02-first-steps/13-while-for/4-for-even/task.md b/1-js/02-first-steps/13-while-for/4-for-even/task.md
index ff34e7e40..7f9ac2e15 100644
--- a/1-js/02-first-steps/13-while-for/4-for-even/task.md
+++ b/1-js/02-first-steps/13-while-for/4-for-even/task.md
@@ -2,8 +2,8 @@ importance: 5
 
 ---
 
-# Output even numbers in the loop
+# มาลองเขียนลูบที่แสดงผลเฉพาะเลขคู่กัน
 
-Use the `for` loop to output even numbers from `2` to `10`.
+มาลองเขียนลูบ `for` ที่แสดงผลจากเลข `2` ไป `10` กัน
 
 [demo]
diff --git a/1-js/02-first-steps/13-while-for/5-replace-for-while/task.md b/1-js/02-first-steps/13-while-for/5-replace-for-while/task.md
index 0c69d9c2d..745013bf0 100644
--- a/1-js/02-first-steps/13-while-for/5-replace-for-while/task.md
+++ b/1-js/02-first-steps/13-while-for/5-replace-for-while/task.md
@@ -2,9 +2,9 @@ importance: 5
 
 ---
 
-# Replace "for" with "while"
+# มาลองเปลี่ยนจากลูบ "for" เป็นลูบ "while" กัน
 
-Rewrite the code changing the `for` loop to `while` without altering its behavior (the output should stay same).
+มาลองเขียนโค้ดใหม่จากลูบ "for" ด้านล่างให้มาเป็นลูบ "while" กัน โดยที่ผลลัพธ์ควรเหมือนเดิม
 
 ```js run
 for (let i = 0; i < 3; i++) {
diff --git a/1-js/02-first-steps/13-while-for/6-repeat-until-correct/solution.md b/1-js/02-first-steps/13-while-for/6-repeat-until-correct/solution.md
index c7de5f09b..5ef93f4b8 100644
--- a/1-js/02-first-steps/13-while-for/6-repeat-until-correct/solution.md
+++ b/1-js/02-first-steps/13-while-for/6-repeat-until-correct/solution.md
@@ -7,9 +7,9 @@ do {
 } while (num <= 100 && num);
 ```
 
-The loop `do..while` repeats while both checks are truthy:
+เราใช้ลูบ `do..while` เพื่อให้มันทำงานจนกว่าเงื่อนไขจะเป็นเท็จ
 
-1. The check for `num <= 100` -- that is, the entered value is still not greater than `100`.
-2. The check `&& num` is false when `num` is `null` or an empty string. Then the `while` loop stops too.
+1. ตรวจสอบว่า `num <= 100`
+2. ตรวจสอบอีกชั้นด้วย `&& num` หาก `num` เป็น falsy value เช่น `null` หรือสตริงเปล่า ลูบ `while` ก็จะหยุดทำงาน
 
-P.S. If `num` is `null` then `num <= 100` is `true`, so without the 2nd check the loop wouldn't stop if the user clicks CANCEL. Both checks are required.
+ปล. หากตัวแปร `num` เป็น `null` เมื่อเทียบว่า `num <= 100` จะเป็นจริง `true` นั่นก็เพราะว่า หากเป็นการเปรียบเทียบ `null` จะถูกแปลงเป็นตัวเลขซึ่งก็คือศูนย์ ดูคุ้นๆไหม ดังนั้นหากเราไม่มีการตรวจสอบ 2 ชั้น ลูบจะไม่หยุดทำงานจนกว่าผู้ใช้จะกด CANCEL เราจึงจำเป็นต้องมีการตรวจสอบชั้น 2 ด้วย
diff --git a/1-js/02-first-steps/13-while-for/6-repeat-until-correct/task.md b/1-js/02-first-steps/13-while-for/6-repeat-until-correct/task.md
index 0788ee76e..d488cce56 100644
--- a/1-js/02-first-steps/13-while-for/6-repeat-until-correct/task.md
+++ b/1-js/02-first-steps/13-while-for/6-repeat-until-correct/task.md
@@ -2,12 +2,12 @@ importance: 5
 
 ---
 
-# Repeat until the input is correct
+# มาลองเขียนลูบที่ถามผู้ใช้ไปเรื่อยๆจนกว่าจะป้อนข้อความที่ถูกต้องกัน
 
-Write a loop which prompts for a number greater than `100`. If the visitor enters another number -- ask them to input again.
+เขียนลูบที่ให้ผู้ใช้ป้อนตัวเลขมากกว่า `100` หากผู้ใช้ป้อนตัวเลขที่ต่ำกว่าก็ให้ถามผู้ใช้ไปเรื่อยๆจนกว่าจะป้อนถูก
 
-The loop must ask for a number until either the visitor enters a number greater than `100` or cancels the input/enters an empty line.
+ลูบจะต้องวนซ้ำไปเรื่อยๆจนกว่าผู้ใช้จะป้อนตัวเลขมากกว่า `100` หรือยกเลิกการป้อนข้อมูลหรือป้อนบรรทัดว่าง
 
-Here we can assume that the visitor only inputs numbers. There's no need to implement a special handling for a non-numeric input in this task.
+เราจะให้ผู้ใช้ป้อนเฉพาะตัวเลขเท่านั้น ดังนั้นไม่จำเป็นต้องเขียนแปลงชนิดของข้อมูลอื่นๆให้เป็นตัวเลข
 
 [demo]
diff --git a/1-js/02-first-steps/13-while-for/7-list-primes/solution.md b/1-js/02-first-steps/13-while-for/7-list-primes/solution.md
index b4b64b6fa..1a233404b 100644
--- a/1-js/02-first-steps/13-while-for/7-list-primes/solution.md
+++ b/1-js/02-first-steps/13-while-for/7-list-primes/solution.md
@@ -1,6 +1,6 @@
-There are many algorithms for this task.
+สำหรับการบ้านนี้เราสามารถทำได้หลากหลายวิธี
 
-Let's use a nested loop:
+ลองมาเริ่มจากใช้ลูบซ้อนลูบก่อน:
 
 ```js
 For each i in the interval {
@@ -10,7 +10,7 @@ For each i in the interval {
 }
 ```
 
-The code using a label:
+ลองใช้ label:
 
 ```js run
 let n = 10;
@@ -19,11 +19,11 @@ nextPrime:
 for (let i = 2; i <= n; i++) { // for each i...
 
   for (let j = 2; j < i; j++) { // look for a divisor..
-    if (i % j == 0) continue nextPrime; // not a prime, go next i
+    if (i % j == 0) continue nextPrime; // หากไม่เป็นจำนวนเฉพาะ ไป i ตัวต่อไป
   }
 
-  alert( i ); // a prime
+  alert( i ); // ตรงนี้จะได้จำนวนเฉพาะ
 }
 ```
 
-There's a lot of space to optimize it. For instance, we could look for the divisors from `2` to square root of `i`. But anyway, if we want to be really efficient for large intervals, we need to change the approach and rely on advanced maths and complex algorithms like [Quadratic sieve](https://en.wikipedia.org/wiki/Quadratic_sieve), [General number field sieve](https://en.wikipedia.org/wiki/General_number_field_sieve) etc.
+มีวิธีมากมายที่ช่วยเพิ่มประสิทธิภาพให้กับโค้ดชุดนี้ เมื่อ `n` ใหญ่ขึ้น เช่น เราสามารถมองหาตัวหารจาก `2` ถึงรากที่สองของ `i` แต่อย่างไรก็ตามหาก `n` ของเราใหญ่มากๆ เราก็จำเป้นที่จะต้องใช้วิธีการที่ซับซ้อนมากขึ้น เพื่อให้โปรแกรมทำงานได้มีประสิทธิภาพสูงสุด โดยอาศัยหลักการทางคณิตศาสตร์และอัลกอรึทึ่มเข้าช่วยเช่น [Quadratic sieve](https://en.wikipedia.org/wiki/Quadratic_sieve), [General number field sieve](https://en.wikipedia.org/wiki/General_number_field_sieve) และอื่นๆ
diff --git a/1-js/02-first-steps/13-while-for/7-list-primes/task.md b/1-js/02-first-steps/13-while-for/7-list-primes/task.md
index 6344b9f6f..f0a7a00dd 100644
--- a/1-js/02-first-steps/13-while-for/7-list-primes/task.md
+++ b/1-js/02-first-steps/13-while-for/7-list-primes/task.md
@@ -2,16 +2,16 @@ importance: 3
 
 ---
 
-# Output prime numbers
+# แสดงจำนวนเฉพาะ (prime numbers) 
 
-An integer number greater than `1` is called a [prime](https://en.wikipedia.org/wiki/Prime_number) if it cannot be divided without a remainder by anything except `1` and itself.
+เราจะเรียกจำนวนเต็มที่มากกว่า `1` และไม่สามารถหารเลขอื่นลงตัวได้ (ไม่มีเศษ) ยกเว้น `1` กับตัวมันเองว่า[จำนวนเฉพาะ](https://en.wikipedia.org/wiki/Prime_number)
 
-In other words, `n > 1` is a prime if it can't be evenly divided by anything except `1` and `n`.
+หรือก็คือเมื่อ `n > 1` จะเป็นจำนวนเฉพาะหาก `n` ไม่สามารถหารเลขอื่นลงตัวได้ ยกเว้น `1` กับ `n`
 
-For example, `5` is a prime, because it cannot be divided without a remainder by `2`, `3` and `4`.
+ตัวอย่าง `5` เป็นจำนวนเฉพาะ เพราะว่า `5` ไม่สามารถหาร `2`, `3` และ `4` ลงตัวได้
 
-**Write the code which outputs prime numbers in the interval from `2` to `n`.**
+**จงเขียนโค้ดที่แสดงจำนวนเฉพาะจาก `2` ถึง `n`**
 
-For `n = 10` the result will be `2,3,5,7`.
+หาก `n = 10` ผลลัพธ์ที่ได้ควรเป็น `2,3,5,7`.
 
-P.S. The code should work for any `n`, not be hard-tuned for any fixed value.
+ปล. โค้ดที่เขียนควรใช้ได้กับ `n` ที่เป็นเลขจำนวนเต็มใดๆก็ได้
diff --git a/1-js/02-first-steps/13-while-for/article.md b/1-js/02-first-steps/13-while-for/article.md
index d1b749888..e25cce768 100644
--- a/1-js/02-first-steps/13-while-for/article.md
+++ b/1-js/02-first-steps/13-while-for/article.md
@@ -1,11 +1,15 @@
-# Loops: while and for
+# ลูป: while และ for
 
-We often need to repeat actions.
+เราต้องทำซ้ำการกระทำบางอย่างบ่อยๆ 
 
-For example, outputting goods from a list one after another or just running the same code for each number from 1 to 10.
+ตัวอย่างเช่น แสดงผลสินค้าจากรายการทีละชิ้น หรืออาจเป็นแค่การรันโค้ดเดิมซ้ำๆ สำหรับทุกตัวเลขตั้งแต่ 1 ถึง 10
 
-*Loops* are a way to repeat the same code multiple times.
+*ลูป* คือวิธีการทำให้โค้ดทำงานซ้ำหลายรอบ
 
+<<<<<<< HEAD
+````smart header="ลูป for..of และ for..in"
+ข้อความสำหรับผู้อ่านระดับสูงเล็กน้อย
+=======
 ```smart header="The for..of and for..in loops"
 A small announcement for advanced readers.
 
@@ -20,60 +24,72 @@ Otherwise, please read on.
 ```
 
 ## The "while" loop
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-The `while` loop has the following syntax:
+บทความนี้จะกล่าวถึงเฉพาะลูปพื้นฐาน ได้แก่ `while`, `do..while` และ `for(..;..;..)`
+
+หากคุณมาที่บทความนี้เพื่อหาข้อมูลเกี่ยวกับลูปประเภทอื่นๆ สามารถดูได้จาก:
+
+- [for..in](info:object#forin) สำหรับการวนลูปเพื่อเข้าถึงพร็อพเพอร์ตี้ของออบเจ็กต์
+- [for..of](info:array#loops) และ [iterable](info:iterable) สำหรับการวนลูปอาร์เรย์และออบเจ็กต์ที่สามารถวนซ้ำได้ (iterable objects)
+
+หากไม่ใช่ กรุณาอ่านต่อไปได้เลยครับ
+````
+
+## ลูป "while"
+
+ลูป `while` มีไวยากรณ์ดังนี้:
 
 ```js
 while (condition) {
-  // code
-  // so-called "loop body"
+  // โค้ด
+  // เรียกว่า "loop body"
 }
 ```
 
-While the `condition` is truthy, the `code` from the loop body is executed.
+ตราบใดที่ `condition` เป็นจริง `code` ใน loop body จะถูกประมวลผล
 
-For instance, the loop below outputs `i` while `i < 3`:
+ยกตัวอย่างเช่น ลูปด้านล่างจะแสดงค่า `i` ตราบเท่าที่ `i < 3`:
 
 ```js run
 let i = 0;
-while (i < 3) { // shows 0, then 1, then 2
+while (i < 3) { // แสดง 0, แล้ว 1, แล้ว 2
   alert( i );
   i++;
 }
 ```
 
-A single execution of the loop body is called *an iteration*. The loop in the example above makes three iterations.
+การประมวลผล loop body หนึ่งรอบเรียกว่า *การวนซ้ำ (iteration)* ลูปในตัวอย่างข้างต้นทำการวนซ้ำสามรอบ
 
-If `i++` was missing from the example above, the loop would repeat (in theory) forever. In practice, the browser provides ways to stop such loops, and in server-side JavaScript, we can kill the process.
+หากไม่มีคำสั่ง `i++` ในตัวอย่างข้างต้น ลูปจะทำซ้ำ (ในทางทฤษฎี) ไปเรื่อยๆ ในทางปฏิบัติ เบราว์เซอร์จะมีวิธีหยุดลูปเช่นนี้ และใน JavaScript ฝั่งเซิร์ฟเวอร์ เราสามารถยุติกระบวนการได้
 
-Any expression or variable can be a loop condition, not just comparisons: the condition is evaluated and converted to a boolean by `while`.
+เงื่อนไขลูปสามารถเป็นนิพจน์หรือตัวแปรใดๆ ก็ได้ ไม่จำเป็นต้องเป็นการเปรียบเทียบเท่านั้น: `while` จะประเมินเงื่อนไขและแปลงเป็นบูลีน
 
-For instance, a shorter way to write `while (i != 0)` is `while (i)`:
+ตัวอย่างเช่น วิธีที่สั้นกว่าในการเขียน `while (i != 0)` คือ `while (i)`:
 
 ```js run
 let i = 3;
 *!*
-while (i) { // when i becomes 0, the condition becomes falsy, and the loop stops
+while (i) { // เมื่อ i เป็น 0, เงื่อนไขจะเป็นเท็จ และลูปจะหยุด
 */!*
   alert( i );
   i--;
 }
 ```
 
-````smart header="Curly braces are not required for a single-line body"
-If the loop body has a single statement, we can omit the curly braces `{…}`:
+````smart header="ไม่จำเป็นต้องใช้วงเล็บปีกกาสำหรับ loop body ที่มีคำสั่งเดียว"
+หาก loop body มีเพียงคำสั่งเดียว เราสามารถละวงเล็บปีกกา `{…}` ได้:
 
 ```js run
 let i = 3;
 *!*
 while (i) alert(i--);
 */!*
-```
 ````
 
-## The "do..while" loop
+## ลูป "do..while"
 
-The condition check can be moved *below* the loop body using the `do..while` syntax:
+เราสามารถย้ายการตรวจสอบเงื่อนไขไปอยู่*ด้านล่าง*ของ loop body ได้ด้วยการใช้ไวยากรณ์ `do..while`:
 
 ```js
 do {
@@ -81,9 +97,9 @@ do {
 } while (condition);
 ```
 
-The loop will first execute the body, then check the condition, and, while it's truthy, execute it again and again.
+ลูปจะทำการประมวลผล body ก่อน จากนั้นจึงตรวจสอบเงื่อนไข และหากเงื่อนไขเป็นจริง ก็จะประมวลผลซ้ำไปเรื่อยๆ
 
-For example:
+ตัวอย่างเช่น:
 
 ```js run
 let i = 0;
@@ -93,13 +109,13 @@ do {
 } while (i < 3);
 ```
 
-This form of syntax should only be used when you want the body of the loop to execute **at least once** regardless of the condition being truthy. Usually, the other form is preferred: `while(…) {…}`.
+ไวยากรณ์ในรูปแบบนี้ควรใช้เฉพาะเมื่อต้องการให้ body ของลูปทำงาน**อย่างน้อยหนึ่งครั้ง** โดยไม่คำนึงว่าเงื่อนไขจะเป็นจริงหรือไม่ โดยทั่วไปแล้วมักจะนิยมใช้รูปแบบอื่นมากกว่า เช่น `while(…) {…}`
 
-## The "for" loop
+## ลูป "for"
 
-The `for` loop is more complex, but it's also the most commonly used loop.
+ลูป `for` มีความซับซ้อนกว่า แต่ก็เป็นลูปที่ใช้บ่อยที่สุดเช่นกัน
 
-It looks like this:
+รูปแบบของมันเป็นดังนี้:
 
 ```js
 for (begin; condition; step) {
@@ -107,24 +123,24 @@ for (begin; condition; step) {
 }
 ```
 
-Let's learn the meaning of these parts by example. The loop below runs `alert(i)` for `i` from `0` up to (but not including) `3`:
+มาทำความเข้าใจความหมายของแต่ละส่วนผ่านตัวอย่างกัน ลูปด้านล่างจะรัน `alert(i)` สำหรับ `i` ตั้งแต่ `0` ถึง (แต่ไม่รวม) `3`:
 
 ```js run
-for (let i = 0; i < 3; i++) { // shows 0, then 1, then 2
+for (let i = 0; i < 3; i++) { // แสดง 0, แล้ว 1, แล้ว 2
   alert(i);
 }
 ```
 
-Let's examine the `for` statement part-by-part:
+มาดูประโยค `for` ทีละส่วนกัน:
 
-| part  |          |                                                                            |
+| ส่วน  |          |                                                                            |
 |-------|----------|----------------------------------------------------------------------------|
-| begin | `let i = 0`    | Executes once upon entering the loop.                                      |
-| condition | `i < 3`| Checked before every loop iteration. If false, the loop stops.              |
-| body | `alert(i)`| Runs again and again while the condition is truthy.                         |
-| step| `i++`      | Executes after the body on each iteration. |
+| begin | `let i = 0`    | ทำงานครั้งเดียวเมื่อเริ่มเข้าลูป                                             |
+| condition | `i < 3`| ตรวจสอบก่อนการวนลูปทุกรอบ ถ้าเป็นเท็จ ลูปจะหยุด                             |
+| body | `alert(i)`| ทำซ้ำไปเรื่อยๆ ตราบเท่าที่เงื่อนไขเป็นจริง                                     |
+| step| `i++`      | ทำงานหลัง body ในแต่ละรอบ |
 
-The general loop algorithm works like this:
+ขั้นตอนการทำงานของลูปโดยทั่วไปเป็นดังนี้:
 
 ```
 Run begin
@@ -134,11 +150,11 @@ Run begin
 → ...
 ```
 
-That is, `begin` executes once, and then it iterates: after each `condition` test, `body` and `step` are executed.
+นั่นคือ `begin` จะถูกรันครั้งเดียว จากนั้นจะเริ่มวนลูป: หลังจากตรวจสอบ `condition` แต่ละครั้ง `body` และ `step` จะถูกประมวลผล
 
-If you are new to loops, it could help to go back to the example and reproduce how it runs step-by-step on a piece of paper.
+ถ้าคุณเพิ่งเริ่มเรียนรู้เรื่องลูป การย้อนกลับไปดูตัวอย่างและลองเขียนเองทีละขั้นตอนบนกระดาษอาจช่วยทำความเข้าใจได้ดีขึ้น
 
-Here's exactly what happens in our case:
+ต่อไปนี้คือสิ่งที่เกิดขึ้นจริงๆ ในกรณีของเรา:
 
 ```js
 // for (let i = 0; i < 3; i++) alert(i)
@@ -154,46 +170,51 @@ if (i < 3) { alert(i); i++ }
 // ...finish, because now i == 3
 ```
 
-````smart header="Inline variable declaration"
-Here, the "counter" variable `i` is declared right in the loop. This is called an "inline" variable declaration. Such variables are visible only inside the loop.
+```smart header="การประกาศตัวแปรอินไลน์"
+ในที่นี้ ตัวแปร "ตัวนับ" `i` ถูกประกาศภายในลูปโดยตรง เรียกว่าการประกาศตัวแปรแบบ "อินไลน์" ตัวแปรแบบนี้จะมองเห็นได้เฉพาะภายในลูปเท่านั้น
 
 ```js run
 for (*!*let*/!* i = 0; i < 3; i++) {
   alert(i); // 0, 1, 2
 }
-alert(i); // error, no such variable
+alert(i); // error, ไม่มีตัวแปรนี้
 ```
 
-Instead of defining a variable, we could use an existing one:
+แทนที่จะประกาศตัวแปรใหม่ เราสามารถใช้ตัวแปรที่มีอยู่แล้วก็ได้:
 
 ```js run
 let i = 0;
 
-for (i = 0; i < 3; i++) { // use an existing variable
+for (i = 0; i < 3; i++) { // ใช้ตัวแปรที่มีอยู่
   alert(i); // 0, 1, 2
 }
 
-alert(i); // 3, visible, because declared outside of the loop
+alert(i); // 3, มองเห็นได้ เพราะประกาศไว้นอกลูป
 ```
-````
+<<<<<<< HEAD
 
-### Skipping parts
+### การข้ามบางส่วน
 
-Any part of `for` can be skipped.
+ส่วนใดๆ ของ `for` ก็ข้ามได้
 
-For example, we can omit `begin` if we don't need to do anything at the loop start.
+ตัวอย่างเช่น เราสามารถละส่วน `begin` ได้ถ้าไม่จำเป็นต้องทำอะไรตอนเริ่มลูป
+=======
+````
 
-Like here:
+### Skipping parts
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
+
+แบบนี้:
 
 ```js run
-let i = 0; // we have i already declared and assigned
+let i = 0; // เรามีการประกาศและกำหนดค่า i อยู่แล้ว
 
-for (; i < 3; i++) { // no need for "begin"
+for (; i < 3; i++) { // ไม่ต้องมีส่วน "begin"
   alert( i ); // 0, 1, 2
 }
 ```
 
-We can also remove the `step` part:
+เราสามารถเอาส่วน `step` ออกได้ด้วย:
 
 ```js run
 let i = 0;
@@ -203,25 +224,25 @@ for (; i < 3;) {
 }
 ```
 
-This makes the loop identical to `while (i < 3)`.
+ลูปแบบนี้จะเหมือนกับ `while (i < 3)`
 
-We can actually remove everything, creating an infinite loop:
+จริงๆ แล้วเราสามารถเอาทุกอย่างออกได้ เพื่อสร้างลูปไม่รู้จบ:
 
 ```js
 for (;;) {
-  // repeats without limits
+  // วนซ้ำไม่มีที่สิ้นสุด
 }
 ```
 
-Please note that the two `for` semicolons `;` must be present. Otherwise, there would be a syntax error.
+โปรดสังเกตว่าจะต้องมีอัฒภาค `;` ทั้งสองตัวของ `for` อยู่เสมอ ไม่เช่นนั้นจะเกิด syntax error
 
-## Breaking the loop
+## การออกจากลูป
 
-Normally, a loop exits when its condition becomes falsy.
+โดยปกติแล้ว ลูปจะจบลงเมื่อเงื่อนไขเป็นเท็จ
 
-But we can force the exit at any time using the special `break` directive.
+แต่เราสามารถบังคับให้ออกจากลูปได้ทุกเมื่อด้วยการใช้คำสั่งพิเศษ `break`
 
-For example, the loop below asks the user for a series of numbers, "breaking" when no number is entered:
+ยกตัวอย่างเช่น ลูปด้านล่างจะถามผู้ใช้ให้ป้อนตัวเลขเป็นชุด และจะ "break" เมื่อไม่มีการป้อนตัวเลข:
 
 ```js run
 let sum = 0;
@@ -240,32 +261,32 @@ while (true) {
 alert( 'Sum: ' + sum );
 ```
 
-The `break` directive is activated at the line `(*)` if the user enters an empty line or cancels the input. It stops the loop immediately, passing control to the first line after the loop. Namely, `alert`.
+คำสั่ง `break` จะทำงานที่บรรทัด `(*)` ถ้าผู้ใช้ป้อนบรรทัดว่างหรือกด cancel มันจะหยุดลูปทันที โดยส่งการควบคุมไปที่บรรทัดแรกหลังลูป นั่นคือไปที่ `alert`
 
-The combination "infinite loop + `break` as needed" is great for situations when a loop's condition must be checked not in the beginning or end of the loop, but in the middle or even in several places of its body.
+การใช้ "ลูปไม่รู้จบ + `break` เมื่อต้องการ" นั้นเหมาะมากสำหรับสถานการณ์ที่ต้องตรวจสอบเงื่อนไขของลูป ไม่ใช่ที่จุดเริ่มต้นหรือจุดสิ้นสุดของลูป แต่อยู่ตรงกลางหรือแม้กระทั่งหลายๆ จุดในตัวลูปเอง
 
-## Continue to the next iteration [#continue]
+## การข้ามไปยังรอบถัดไป [#continue]
 
-The `continue` directive is a "lighter version" of `break`. It doesn't stop the whole loop. Instead, it stops the current iteration and forces the loop to start a new one (if the condition allows).
+คำสั่ง `continue` เป็น "เวอร์ชันที่เบากว่า" ของ `break` มันไม่ได้หยุดลูปทั้งหมด แต่จะหยุดเฉพาะรอบปัจจุบันและบังคับให้ลูปเริ่มรอบใหม่แทน (ถ้าเงื่อนไขอนุญาต)
 
-We can use it if we're done with the current iteration and would like to move on to the next one.
+เราสามารถใช้มันได้ถ้าเราเสร็จสิ้นกับการประมวลผลในรอบปัจจุบันแล้วและต้องการข้ามไปยังรอบถัดไป
 
-The loop below uses `continue` to output only odd values:
+ลูปด้านล่างใช้ `continue` เพื่อแสดงผลเฉพาะค่าที่เป็นเลขคี่:
 
 ```js run no-beautify
 for (let i = 0; i < 10; i++) {
 
-  // if true, skip the remaining part of the body
+  // ถ้าเป็นจริง ข้ามส่วนที่เหลือของ body
   *!*if (i % 2 == 0) continue;*/!*
 
-  alert(i); // 1, then 3, 5, 7, 9
+  alert(i); // 1, แล้วก็ 3, 5, 7, 9
 }
 ```
 
-For even values of `i`, the `continue` directive stops executing the body and passes control to the next iteration of `for` (with the next number). So the `alert` is only called for odd values.
+สำหรับค่า `i` ที่เป็นเลขคู่ คำสั่ง `continue` จะหยุดการประมวลผล body และส่งการควบคุมไปยังรอบถัดไปของ `for` (กับตัวเลขถัดไป) ดังนั้น `alert` จะถูกเรียกเฉพาะกับค่าที่เป็นเลขคี่เท่านั้น
 
-````smart header="The `continue` directive helps decrease nesting"
-A loop that shows odd values could look like this:
+````smart header="คำสั่ง `continue` ช่วยลดความซับซ้อนของโค้ด"
+ลูปที่แสดงค่าที่เป็นเลขคี่อาจเขียนได้แบบนี้:
 
 ```js run
 for (let i = 0; i < 10; i++) {
@@ -277,15 +298,19 @@ for (let i = 0; i < 10; i++) {
 }
 ```
 
-From a technical point of view, this is identical to the example above. Surely, we can just wrap the code in an `if` block instead of using `continue`.
+ในแง่เทคนิค โค้ดนี้เหมือนกับตัวอย่างด้านบนทุกประการ เราสามารถห่อโค้ดไว้ในบล็อก `if` แทนการใช้ `continue` ก็ได้
 
+<<<<<<< HEAD
+แต่ผลข้างเคียงคือ มันจะสร้างระดับความซับซ้อนของโค้ดเพิ่มขึ้นอีกหนึ่งชั้น (การเรียก `alert` อยู่ภายในวงเล็บปีกกา) ถ้าโค้ดภายใน `if` ยาวกว่าสองสามบรรทัด มันอาจลดความสามารถในการอ่านโค้ดโดยรวมได้
+=======
 But as a side effect, this created one more level of nesting (the `alert` call inside the curly braces). If the code inside of `if` is longer than a few lines, that may decrease the overall readability.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 ````
 
-````warn header="No `break/continue` to the right side of '?'"
-Please note that syntax constructs that are not expressions cannot be used with the ternary operator `?`. In particular, directives such as `break/continue` aren't allowed there.
+````warn header="ไม่มี `break/continue` ที่ด้านขวาของ '?'"
+โปรดสังเกตว่า โครงสร้างทางไวยากรณ์ที่ไม่ใช่นิพจน์ จะไม่สามารถใช้กับตัวดำเนินการแบบ 3 พารามิเตอร์ `?` ได้ โดยเฉพาะอย่างยิ่ง คำสั่งอย่างเช่น `break/continue` จะไม่ได้รับอนุญาตให้ใช้ในตำแหน่งนั้น
 
-For example, if we take this code:
+ตัวอย่างเช่น ถ้าเรามีโค้ดแบบนี้:
 
 ```js
 if (i > 5) {
@@ -295,22 +320,26 @@ if (i > 5) {
 }
 ```
 
+<<<<<<< HEAD
+...แล้วเขียนใหม่โดยใช้เครื่องหมายคำถาม:
+=======
 ...and rewrite it using a question mark:
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
 ```js no-beautify
-(i > 5) ? alert(i) : *!*continue*/!*; // continue isn't allowed here
+(i > 5) ? alert(i) : *!*continue*/!*; // continue ไม่ได้รับอนุญาตที่นี่
 ```
 
-...it stops working: there's a syntax error.
+...มันจะหยุดทำงาน: เกิด syntax error ขึ้น
 
-This is just another reason not to use the question mark operator `?` instead of `if`.
+นี่เป็นอีกเหตุผลหนึ่งที่ไม่ควรใช้ตัวดำเนินการแบบ 3 พารามิเตอร์ `?` แทน `if`
 ````
 
-## Labels for break/continue
+## Labels สำหรับ break/continue
 
-Sometimes we need to break out from multiple nested loops at once.
+บางครั้งเราอาจต้องออกจากลูปที่ซ้อนกันหลายชั้นในคราวเดียว
 
-For example, in the code below we loop over `i` and `j`, prompting for the coordinates `(i, j)` from `(0,0)` to `(2,2)`:
+ตัวอย่างเช่น ในโค้ดด้านล่าง เราวนลูปด้วย `i` และ `j` เพื่อถามหาค่าที่พิกัด `(i, j)` ตั้งแต่ `(0,0)` ถึง `(2,2)`:
 
 ```js run no-beautify
 for (let i = 0; i < 3; i++) {
@@ -319,26 +348,31 @@ for (let i = 0; i < 3; i++) {
 
     let input = prompt(`Value at coords (${i},${j})`, '');
 
-    // what if we want to exit from here to Done (below)?
+    // จะทำอย่างไรถ้าเราต้องการออกจากที่นี่ไปสู่ Done (ด้านล่าง)?
   }
 }
 
 alert('Done!');
 ```
 
-We need a way to stop the process if the user cancels the input.
+เราต้องการวิธีหยุดกระบวนการนี้ถ้าผู้ใช้ยกเลิกการป้อนข้อมูล
+
+การใช้ `break` ธรรมดาหลังจาก `input` จะออกจากลูปชั้นในเท่านั้น ซึ่งยังไม่เพียงพอ -- labels จะมาช่วยได้!
 
-The ordinary `break` after `input` would only break the inner loop. That's not sufficient -- labels, come to the rescue!
+*label* คือตัวระบุที่มีเครื่องหมายโคลอนอยู่ข้างหน้าลูป:
 
+<<<<<<< HEAD
+=======
 A *label* is an identifier with a colon before a loop:
 
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 ```js
 labelName: for (...) {
   ...
 }
 ```
 
-The `break <labelName>` statement in the loop below breaks out to the label:
+คำสั่ง `break <labelName>` ในลูปด้านล่างจะออกไปสู่ label:
 
 ```js run no-beautify
 *!*outer:*/!* for (let i = 0; i < 3; i++) {
@@ -347,65 +381,74 @@ The `break <labelName>` statement in the loop below breaks out to the label:
 
     let input = prompt(`Value at coords (${i},${j})`, '');
 
-    // if an empty string or canceled, then break out of both loops
+    // ถ้าเป็นสตริงว่างหรือกด cancel ให้ออกจากลูปทั้งสอง
     if (!input) *!*break outer*/!*; // (*)
 
-    // do something with the value...
+    // ทำอะไรบางอย่างกับค่าที่ได้...
   }
 }
 
 alert('Done!');
 ```
 
-In the code above, `break outer` looks upwards for the label named `outer` and breaks out of that loop.
+ในโค้ดด้านบน `break outer` จะมองหา label ชื่อ `outer` ขึ้นไป แล้วออกจากลูปนั้น
 
-So the control goes straight from `(*)` to `alert('Done!')`.
+ดังนั้นการควบคุมจะข้ามจาก `(*)` ไปสู่ `alert('Done!')` โดยตรง
 
-We can also move the label onto a separate line:
+เราสามารถย้าย label ไปอยู่บนบรรทัดแยกต่างหากได้ด้วย:
 
 ```js no-beautify
 outer:
 for (let i = 0; i < 3; i++) { ... }
 ```
 
-The `continue` directive can also be used with a label. In this case, code execution jumps to the next iteration of the labeled loop.
+คำสั่ง `continue` ก็สามารถใช้ร่วมกับ label ได้เช่นกัน ในกรณีนี้ การประมวลผลโค้ดจะข้ามไปยังรอบถัดไปของลูปที่มี label กำกับ
+
+````warn header="Labels ไม่อนุญาตให้ \"กระโดด\" ไปที่ใดก็ได้"
+Labels ไม่ได้อนุญาตให้เรากระโดดไปยังตำแหน่งใดๆ ก็ได้ในโค้ด
 
-````warn header="Labels do not allow to \"jump\" anywhere"
-Labels do not allow us to jump into an arbitrary place in the code.
+ตัวอย่างเช่น เราไม่สามารถทำแบบนี้ได้:
 
+<<<<<<< HEAD
+=======
 For example, it is impossible to do this:
 
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 ```js
-break label; // jump to the label below (doesn't work)
+break label; // กระโดดไปสู่ label ด้านล่าง (ใช้ไม่ได้)
 
 label: for (...)
 ```
 
+<<<<<<< HEAD
+คำสั่ง `break` ต้องอยู่ภายในบล็อกโค้ด ในทางเทคนิค บล็อกโค้ดใดๆ ที่มี label กำกับก็ใช้ได้ เช่น:
+=======
 A `break` directive must be inside a code block. Technically, any labelled code block will do, e.g.:
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
 ```js
 label: {
   // ...
-  break label; // works
+  break label; // ใช้ได้
   // ...
 }
 ```
 
-...Although, 99.9% of the time `break` is used inside loops, as we've seen in the examples above.
+...อย่างไรก็ตาม ในความเป็นจริง 99.9% ของเวลา `break` จะถูกใช้ภายในลูป เหมือนที่เราเห็นในตัวอย่างด้านบน
 
-A `continue` is only possible from inside a loop.
+ส่วน `continue` จะใช้ได้เฉพาะภายในลูปเท่านั้น
 ````
 
-## Summary
+## สรุป
 
-We covered 3 types of loops:
+เราได้ครอบคลุมลูป 3 ประเภท:
 
-- `while` -- The condition is checked before each iteration.
-- `do..while` -- The condition is checked after each iteration.
-- `for (;;)` -- The condition is checked before each iteration, additional settings available.
+- `while` -- ตรวจสอบเงื่อนไขก่อนการวนลูปแต่ละรอบ
+- `do..while` -- ตรวจสอบเงื่อนไขหลังการวนลูปแต่ละรอบ
+- `for (;;)` -- ตรวจสอบเงื่อนไขก่อนการวนลูปแต่ละรอบ สามารถกำหนดค่าเริ่มต้นและปรับแต่งเพิ่มเติมได้
 
-To make an "infinite" loop, usually the `while(true)` construct is used. Such a loop, just like any other, can be stopped with the `break` directive.
+ในการสร้างลูป "ไม่มีที่สิ้นสุด" มักจะใช้โครงสร้าง `while(true)` ลูปลักษณะนี้ เช่นเดียวกับลูปอื่นๆ สามารถหยุดได้ด้วยคำสั่ง `break` 
 
-If we don't want to do anything in the current iteration and would like to forward to the next one, we can use the `continue` directive.
+หากเราไม่ต้องการทำอะไรในรอบปัจจุบัน และต้องการข้ามไปยังรอบถัดไป เราสามารถใช้คำสั่ง `continue`
 
-`break/continue` support labels before the loop. A label is the only way for `break/continue` to escape a nested loop to go to an outer one.
+`break/continue` รองรับการใช้ label ที่อยู่ข้างหน้าลูป label เป็นวิธีเดียวที่ `break/continue` จะสามารถออกจากลูปที่ซ้อนกันเพื่อไปยังลูปชั้นนอกได้
diff --git a/1-js/02-first-steps/14-switch/1-rewrite-switch-if-else/solution.md b/1-js/02-first-steps/14-switch/1-rewrite-switch-if-else/solution.md
index d3e397434..91c1626c5 100644
--- a/1-js/02-first-steps/14-switch/1-rewrite-switch-if-else/solution.md
+++ b/1-js/02-first-steps/14-switch/1-rewrite-switch-if-else/solution.md
@@ -1,6 +1,6 @@
-To precisely match the functionality of `switch`, the `if` must use a strict comparison `'==='`.
+เพื่อที่จะให้ตรงกับการทำงานของคำสั่ง `switch`, คำสั่ง `if` จึงต้องให้ `'==='`
 
-For given strings though, a simple `'=='` works too.
+ตามสตริงที่ให้มา `'=='` ก็ใช้ได้งานตามที่คาดหวังเช่นกัน
 
 ```js no-beautify
 if(browser == 'Edge') {
@@ -15,6 +15,6 @@ if(browser == 'Edge') {
 }
 ```
 
-Please note: the construct `browser == 'Chrome' || browser == 'Firefox' …` is split into multiple lines for better readability.
+โปรดทราบ: รูปประโยค `browser == 'Chrome' || browser == 'Firefox' …` ควรแบ่งเป็นหลายๆบรรทัดเพื่อให้อ่านง่ายขึ้น
 
-But the `switch` construct is still cleaner and more descriptive.
+แต่อย่างไรก็ตาม ในกรณีนี้คำสั่ง `switch` ก็ดูสะอาดและเข้าใจง่ายกว่า
diff --git a/1-js/02-first-steps/14-switch/1-rewrite-switch-if-else/task.md b/1-js/02-first-steps/14-switch/1-rewrite-switch-if-else/task.md
index f4dc0e5f1..20b050482 100644
--- a/1-js/02-first-steps/14-switch/1-rewrite-switch-if-else/task.md
+++ b/1-js/02-first-steps/14-switch/1-rewrite-switch-if-else/task.md
@@ -2,9 +2,9 @@ importance: 5
 
 ---
 
-# Rewrite the "switch" into an "if"
+# ลองมาแปลงคำสั่งจาก "switch" เป็น "if"
 
-Write the code using `if..else` which would correspond to the following `switch`:
+เขียนโค้ดโดยใช้ `if..else` โดยให้สอดคล้องกับ `switch` ด้านล่าง:
 
 ```js
 switch (browser) {
diff --git a/1-js/02-first-steps/14-switch/2-rewrite-if-switch/solution.md b/1-js/02-first-steps/14-switch/2-rewrite-if-switch/solution.md
index ed87dd94b..55fc36243 100644
--- a/1-js/02-first-steps/14-switch/2-rewrite-if-switch/solution.md
+++ b/1-js/02-first-steps/14-switch/2-rewrite-if-switch/solution.md
@@ -1,4 +1,4 @@
-The first two checks turn into two `case`. The third check is split into two cases:
+ขั้นแรกมาเปลี่ยน if ตัวสองแรกเป็น `case` กันก่อน เพราะว่า if ตัวที่สามเราต้องใช้แยกออกมาเป็นสอง `case`:
 
 ```js run
 let a = +prompt('a?', '');
@@ -21,6 +21,6 @@ switch (a) {
 }
 ```
 
-Please note: the `break` at the bottom is not required. But we put it to make the code future-proof.
+โปรดจำจงไว้: คำสั่ง `break` ที่บรรทัดล่างสุดไม่จำเป็นต้องใส่ก็ได้ แต่ทางเราเขียนไว้เผื่ออนาคต
 
-In the future, there is a chance that we'd want to add one more `case`, for example `case 4`. And if we forget to add a break before it, at the end of `case 3`, there will be an error. So that's a kind of self-insurance.
+เพราะว่าอนาคต มีโอกาสที่เราจะเพิ่ม `case` ขึ้นมาอีก ตัวอย่างเช่น `case 4` และเราลืมใส่คำสั่ง `break` ไว้ท้าย `case 3` ซึ่งจะทำให้เกิดผลลัพธ์ที่ไม่คาดหวัง ดังนั้นเพื่อรับประกันว่าโค้ดทุกอย่างยังคงทำงานอย่างถูกต้อง เราจึงใส่ไว้นั่นเอง
diff --git a/1-js/02-first-steps/14-switch/2-rewrite-if-switch/task.md b/1-js/02-first-steps/14-switch/2-rewrite-if-switch/task.md
index ec99d098d..697867b5b 100644
--- a/1-js/02-first-steps/14-switch/2-rewrite-if-switch/task.md
+++ b/1-js/02-first-steps/14-switch/2-rewrite-if-switch/task.md
@@ -2,9 +2,9 @@ importance: 4
 
 ---
 
-# Rewrite "if" into "switch"
+# ลองมาแปลงคำสั่งจาก "if" เป็น "switch"
 
-Rewrite the code below using a single `switch` statement:
+ลองเขียนโค้ดด้านล่างใหม่โดยใช้คำสั่ง `switch` กัน:
 
 ```js run
 let a = +prompt('a?', '');
diff --git a/1-js/02-first-steps/14-switch/article.md b/1-js/02-first-steps/14-switch/article.md
index d86babcec..7845b6bd3 100644
--- a/1-js/02-first-steps/14-switch/article.md
+++ b/1-js/02-first-steps/14-switch/article.md
@@ -1,22 +1,22 @@
-# The "switch" statement
+# คำสั่ง "switch"
 
-A `switch` statement can replace multiple `if` checks.
+คำสั่ง `switch` สามารถใช้แทนการตรวจสอบด้วย `if` หลายๆ ครั้งได้
 
-It gives a more descriptive way to compare a value with multiple variants.
+มันให้วิธีเปรียบเทียบค่ากับตัวเลือกหลายๆ ตัวอย่างเข้าใจง่ายกว่า
 
-## The syntax
+## ไวยากรณ์
 
-The `switch` has one or more `case` blocks and an optional default.
+`switch` จะมีหนึ่งหรือหลายบล็อก `case` และมี `default` เป็นตัวเลือกเสริม
 
-It looks like this:
+มีรูปแบบดังนี้:
 
 ```js no-beautify
 switch(x) {
-  case 'value1':  // if (x === 'value1')
+  case 'value1':  // ถ้า (x === 'value1')
     ...
     [break]
 
-  case 'value2':  // if (x === 'value2')
+  case 'value2':  // ถ้า (x === 'value2')
     ...
     [break]
 
@@ -26,71 +26,71 @@ switch(x) {
 }
 ```
 
-- The value of `x` is checked for a strict equality to the value from the first `case` (that is, `value1`) then to the second (`value2`) and so on.
-- If the equality is found, `switch` starts to execute the code starting from the corresponding `case`, until the nearest `break` (or until the end of `switch`).
-- If no case is matched then the `default` code is executed (if it exists).
+- ค่าของ `x` จะถูกตรวจสอบความเท่าเทียมกันอย่างเข้มงวดกับค่าจาก `case` แรก (คือ `value1`) จากนั้นเป็น `case` ที่สอง (`value2`) และต่อไปเรื่อยๆ
+- ถ้าพบความเท่ากัน `switch` จะเริ่มรันโค้ดจาก `case` ที่ตรงกัน จนกว่าจะเจอ `break` ที่ใกล้ที่สุด (หรือจนจบ `switch`)
+- ถ้าไม่ตรงกับ `case` ใด โค้ดใน `default` จะถูกรัน (ถ้ามี)
 
-## An example
+## ตัวอย่าง
 
-An example of `switch` (the executed code is highlighted):
+ตัวอย่างของ `switch` (โค้ดที่ถูกรันจะเน้นให้เห็น):
 
 ```js run
 let a = 2 + 2;
 
 switch (a) {
   case 3:
-    alert( 'Too small' );
+    alert( 'เล็กไป' );
     break;
 *!*
   case 4:
-    alert( 'Exactly!' );
+    alert( 'ถูกต้อง!' );
     break;
 */!*
   case 5:
-    alert( 'Too big' );
+    alert( 'ใหญ่ไป' );
     break;
   default:
-    alert( "I don't know such values" );
+    alert( "ไม่รู้จักค่านี้" );
 }
 ```
 
-Here the `switch` starts to compare `a` from the first `case` variant that is `3`. The match fails.
+ที่นี่ `switch` จะเริ่มเปรียบเทียบ `a` กับ `case` แรกคือ `3` ซึ่งไม่ตรงกัน
 
-Then `4`. That's a match, so the execution starts from `case 4` until the nearest `break`.
+จากนั้นเป็น `4` ซึ่งตรงกัน ดังนั้นโค้ดจะเริ่มรันจาก `case 4` จนกว่าจะเจอ `break`
 
-**If there is no `break` then the execution continues with the next `case` without any checks.**
+**ถ้าไม่มี `break` โค้ดจะรันต่อไปยัง `case` ถัดไปเลยโดยไม่ตรวจสอบอะไร**  
 
-An example without `break`:
+ตัวอย่างที่ไม่มี `break`:
 
 ```js run
 let a = 2 + 2;
 
 switch (a) {
   case 3:
-    alert( 'Too small' );
+    alert( 'เล็กไป' );
 *!*
   case 4:
-    alert( 'Exactly!' );
+    alert( 'ถูกต้อง!' );
   case 5:
-    alert( 'Too big' );
-  default:
-    alert( "I don't know such values" );
+    alert( 'ใหญ่ไป' );
+  default:  
+    alert( "ไม่รู้จักค่านี้" );
 */!*
 }
 ```
 
-In the example above we'll see sequential execution of three `alert`s:
+ในตัวอย่างข้างบน จะเห็น `alert` สามอันทำงานต่อเนื่องกัน:
 
 ```js
-alert( 'Exactly!' );
-alert( 'Too big' );
-alert( "I don't know such values" );
+alert( 'ถูกต้อง!' );
+alert( 'ใหญ่ไป' );
+alert( "ไม่รู้จักค่านี้" );  
 ```
 
-````smart header="Any expression can be a `switch/case` argument"
-Both `switch` and `case` allow arbitrary expressions.
+````smart header="นิพจน์อะไรก็ใช้เป็นอาร์กิวเมนต์ของ `switch/case` ได้"
+ทั้ง `switch` และ `case` สามารถใช้นิพจน์อะไรก็ได้
 
-For example:
+เช่น:
 
 ```js run
 let a = "1";
@@ -99,74 +99,78 @@ let b = 0;
 switch (+a) {
 *!*
   case b + 1:
-    alert("this runs, because +a is 1, exactly equals b+1");
+    alert("นี่ทำงาน เพราะ +a เป็น 1 ซึ่งเท่ากับ b+1");
     break;
 */!*
 
   default:
-    alert("this doesn't run");
+    alert("นี่ไม่ทำงาน");
 }
 ```
-Here `+a` gives `1`, that's compared with `b + 1` in `case`, and the corresponding code is executed.
+ที่นี่ `+a` ให้ค่า `1` ซึ่งจะถูกเปรียบเทียบกับ `b + 1` ใน `case` และโค้ดที่สอดคล้องจะถูกรัน
 ````
 
-## Grouping of "case"
+## การจัดกลุ่ม "case"
 
-Several variants of `case` which share the same code can be grouped.
+`case` หลายๆ แบบที่รันโค้ดเดียวกัน สามารถจัดกลุ่มรวมกันได้
 
-For example, if we want the same code to run for `case 3` and `case 5`:
+ตัวอย่างเช่น ถ้าเราต้องการให้โค้ดเดียวกันทำงานทั้งใน `case 3` และ `case 5`:
 
 ```js run no-beautify
 let a = 3;
 
 switch (a) {
   case 4:
-    alert('Right!');
+    alert('ถูกต้อง!');
     break;
 
 *!*
-  case 3: // (*) grouped two cases
+  case 3: // (*) จัดกลุ่มสอง case ไว้ด้วยกัน
   case 5:
-    alert('Wrong!');
-    alert("Why don't you take a math class?");
+    alert('ผิด!');
+    alert("ลองไปเรียนคณิตหน่อยไหม");
     break;
 */!*
 
   default:
-    alert('The result is strange. Really.');
+    alert('ผลลัพธ์แปลกมากเลย');
 }
 ```
 
-Now both `3` and `5` show the same message.
+ตอนนี้ทั้ง `3` และ `5` จะแสดงข้อความเดียวกัน
 
+<<<<<<< HEAD
+ความสามารถในการ "จัดกลุ่ม" `case` เป็นผลข้างเคียงของวิธีการทำงานของ `switch/case` เมื่อไม่มี `break` ในที่นี้ `case 3` จะเริ่มรันโค้ดจากบรรทัด `(*)` และรันผ่าน `case 5` ไปเลย เพราะไม่มี `break`
+=======
 The ability to "group" cases is a side effect of how `switch/case` works without `break`. Here the execution of `case 3` starts from the line `(*)` and goes through `case 5`, because there's no `break`.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-## Type matters
+## ชนิดข้อมูลมีความสำคัญ
 
-Let's emphasize that the equality check is always strict. The values must be of the same type to match.
+ขอเน้นว่าการตรวจสอบความเท่ากันจะเป็นแบบเข้มงวดเสมอ ค่าต้องเป็นชนิดเดียวกันจึงจะตรงกัน
 
-For example, let's consider the code:
+ตัวอย่างเช่น ลองพิจารณาโค้ดนี้:
 
 ```js run
-let arg = prompt("Enter a value?");
+let arg = prompt("ใส่ค่ามา");
 switch (arg) {
   case '0':
   case '1':
-    alert( 'One or zero' );
+    alert( 'ศูนย์หรือหนึ่ง' );
     break;
 
   case '2':
-    alert( 'Two' );
+    alert( 'สอง' );
     break;
 
   case 3:
-    alert( 'Never executes!' );
+    alert( 'จะไม่มีทางรันเลย!' );  
     break;
   default:
-    alert( 'An unknown value' );
+    alert( 'ค่าที่ไม่รู้จัก' );
 }
 ```
 
-1. For `0`, `1`, the first `alert` runs.
-2. For `2` the second `alert` runs.
-3. But for `3`, the result of the `prompt` is a string `"3"`, which is not strictly equal `===` to the number `3`. So we've got a dead code in `case 3`! The `default` variant will execute.
+1. สำหรับ `0`, `1` จะแสดง `alert` แรก
+2. สำหรับ `2` จะแสดง `alert` ที่สอง
+3. แต่สำหรับ `3` ผลลัพธ์จาก `prompt` จะเป็น string `"3"` ซึ่งไม่เท่ากันอย่างเข้มงวด `===` กับตัวเลข `3` ดังนั้นเราจะมีโค้ดที่ไม่มีทางรันได้ใน `case 3`! แต่ `default` จะถูกรันแทน
\ No newline at end of file
diff --git a/1-js/02-first-steps/15-function-basics/1-if-else-required/solution.md b/1-js/02-first-steps/15-function-basics/1-if-else-required/solution.md
index e3a0df77c..2a6efeddc 100644
--- a/1-js/02-first-steps/15-function-basics/1-if-else-required/solution.md
+++ b/1-js/02-first-steps/15-function-basics/1-if-else-required/solution.md
@@ -1,3 +1,7 @@
+<<<<<<< HEAD
+ไม่มีความแตกต่าง
+=======
 No difference!
 
-In both cases, `return confirm('Did parents allow you?')` executes exactly when the `if` condition is falsy.
\ No newline at end of file
+In both cases, `return confirm('Did parents allow you?')` executes exactly when the `if` condition is falsy.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
diff --git a/1-js/02-first-steps/15-function-basics/1-if-else-required/task.md b/1-js/02-first-steps/15-function-basics/1-if-else-required/task.md
index 4f69a5c8c..0ba7985e2 100644
--- a/1-js/02-first-steps/15-function-basics/1-if-else-required/task.md
+++ b/1-js/02-first-steps/15-function-basics/1-if-else-required/task.md
@@ -2,11 +2,11 @@ importance: 4
 
 ---
 
-# Is "else" required?
+# จำเป็นต้องมี "else" หรือไม่?
 
-The following function returns `true` if the parameter `age` is greater than `18`.
+ฟังก์ชั่นด้านล่างจะส่งคืนค่า `true` หากพารามิเตอร์์ `age` มีค่ามากกว่า `18`
 
-Otherwise it asks for a confirmation and returns its result:
+มิเช่นนั้น ฟังก์ชั่น `confirm` จะทำงานแล้ว ส่งคืนผลลัพธ์ที่ผู้ใช้กรอกมา
 
 ```js
 function checkAge(age) {
@@ -21,7 +21,7 @@ function checkAge(age) {
 }
 ```
 
-Will the function work differently if `else` is removed?
+ฟังก์ชั่นจะทำงานต่างออกไปหรือไม่หากไม่มี `else`
 
 ```js
 function checkAge(age) {
@@ -35,4 +35,4 @@ function checkAge(age) {
 }
 ```
 
-Is there any difference in the behavior of these two variants?
+อะไรคือความต่างกันของทั้งสองตัว
diff --git a/1-js/02-first-steps/15-function-basics/article.md b/1-js/02-first-steps/15-function-basics/article.md
index 415fed3e0..038472fcf 100644
--- a/1-js/02-first-steps/15-function-basics/article.md
+++ b/1-js/02-first-steps/15-function-basics/article.md
@@ -1,64 +1,68 @@
-# Functions
+# ฟังก์ชัน
 
-Quite often we need to perform a similar action in many places of the script.
+บ่อยครั้งที่เราต้องทำการกระทำที่คล้ายๆ กันในหลายๆ ที่ของสคริปต์
 
-For example, we need to show a nice-looking message when a visitor logs in, logs out and maybe somewhere else.
+เช่น เราอาจต้องแสดงข้อความที่ดูดีเมื่อผู้ใช้ล็อกอิน ล็อกเอาท์ หรือที่อื่นๆ
 
-Functions are the main "building blocks" of the program. They allow the code to be called many times without repetition.
+ฟังก์ชันคือ "บล็อกสร้าง" หลักของโปรแกรม มันทำให้เราเรียกใช้โค้ดได้หลายครั้งโดยไม่ต้องเขียนซ้ำ
 
-We've already seen examples of built-in functions, like `alert(message)`, `prompt(message, default)` and `confirm(question)`. But we can create functions of our own as well.
+เราเคยเห็นตัวอย่างฟังก์ชันที่มีมาในตัวแล้ว เช่น `alert(message)`, `prompt(message, default)` และ `confirm(question)` แต่เราก็สามารถสร้างฟังก์ชันของตัวเองได้ด้วย
 
-## Function Declaration
+## การประกาศฟังก์ชัน
 
-To create a function we can use a *function declaration*.
+ในการสร้างฟังก์ชัน เราสามารถใช้ *การประกาศฟังก์ชัน*
 
-It looks like this:
+ซึ่งมีรูปแบบดังนี้:
 
 ```js
 function showMessage() {
-  alert( 'Hello everyone!' );
+  alert( 'สวัสดีทุกคน!' );
 }
 ```
 
-The `function` keyword goes first, then goes the *name of the function*, then a list of *parameters* between the parentheses (comma-separated, empty in the example above, we'll see examples later) and finally the code of the function, also named "the function body", between curly braces.
+ใช้คีย์เวิร์ด `function` ก่อน ตามด้วย*ชื่อฟังก์ชัน* แล้วก็รายการ *parameter* ในวงเล็บ (คั่นด้วยเครื่องหมายจุลภาค ในตัวอย่างข้างบนจะเว้นว่าง เดี๋ยวจะมีตัวอย่างอีกทีหลัง) สุดท้ายคือโค้ดของฟังก์ชันระหว่างปีกกาปิดเปิด ที่เรียกว่า "ตัวฟังก์ชัน" หรือ "function body" 
 
 ```js
 function name(parameter1, parameter2, ... parameterN) {
+<<<<<<< HEAD
+  // ตัวฟังก์ชัน
+=======
  // body
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 }
 ```
 
-Our new function can be called by its name: `showMessage()`.
+ฟังก์ชันใหม่ของเราสามารถเรียกใช้ได้ด้วยชื่อของมัน เช่น: `showMessage()`
 
-For instance:
+ดังตัวอย่าง:
 
 ```js run
 function showMessage() {
-  alert( 'Hello everyone!' );
+  alert( 'สวัสดีทุกคน!' );
 }
 
 *!*
 showMessage();
 showMessage();
-*/!*
+*/!*  
 ```
 
-The call `showMessage()` executes the code of the function. Here we will see the message two times.
+เมื่อเรียก `showMessage()` ก็จะรันโค้ดในตัวฟังก์ชัน ในที่นี้เราจะเห็นข้อความถูกแสดงสองครั้ง
 
-This example clearly demonstrates one of the main purposes of functions: to avoid code duplication.
+ตัวอย่างนี้แสดงให้เห็นวัตถุประสงค์หลักอย่างหนึ่งของฟังก์ชัน นั่นคือเพื่อหลีกเลี่ยงการเขียนโค้ดซ้ำ
 
-If we ever need to change the message or the way it is shown, it's enough to modify the code in one place: the function which outputs it.
+ถ้าเราต้องการเปลี่ยนข้อความหรือวิธีแสดงผล ก็แค่แก้ไขโค้ดในที่เดียว นั่นคือในตัวฟังก์ชันที่ทำการแสดงผลมัน
 
-## Local variables
+## ตัวแปรภายในฟังก์ชัน (Local variables)
 
-A variable declared inside a function is only visible inside that function.
+ตัวแปรที่ประกาศภายในฟังก์ชัน จะมองเห็นได้เฉพาะภายในฟังก์ชันนั้นเท่านั้น
 
-For example:
+ตัวอย่างเช่น:
 
 ```js run
 function showMessage() {
 *!*
-  let message = "Hello, I'm JavaScript!"; // local variable
+  let message = "Hello, I'm JavaScript!"; // ตัวแปรภายในฟังก์ชัน
 */!*
 
   alert( message );
@@ -66,12 +70,12 @@ function showMessage() {
 
 showMessage(); // Hello, I'm JavaScript!
 
-alert( message ); // <-- Error! The variable is local to the function
+alert( message ); // <-- Error! ตัวแปรอยู่ภายในฟังก์ชัน ไม่สามารถเข้าถึงจากภายนอกได้
 ```
 
-## Outer variables
+## ตัวแปรภายนอก (Outer variables)
 
-A function can access an outer variable as well, for example:
+ฟังก์ชันสามารถเข้าถึงตัวแปรภายนอกได้ด้วย เช่น:
 
 ```js run no-beautify
 let *!*userName*/!* = 'John';
@@ -84,65 +88,65 @@ function showMessage() {
 showMessage(); // Hello, John
 ```
 
-The function has full access to the outer variable. It can modify it as well.
+ฟังก์ชันสามารถเข้าถึงตัวแปรภายนอกได้อย่างเต็มที่ และยังสามารถแก้ไขค่าได้ด้วย
 
-For instance:
+ตัวอย่างเช่น:
 
 ```js run
 let *!*userName*/!* = 'John';
 
 function showMessage() {
-  *!*userName*/!* = "Bob"; // (1) changed the outer variable
+  *!*userName*/!* = "Bob"; // (1) เปลี่ยนค่าตัวแปรภายนอก
 
   let message = 'Hello, ' + *!*userName*/!*;
   alert(message);
 }
 
-alert( userName ); // *!*John*/!* before the function call
+alert( userName ); // *!*John*/!* ก่อนเรียกฟังก์ชัน
 
 showMessage();
 
-alert( userName ); // *!*Bob*/!*, the value was modified by the function
+alert( userName ); // *!*Bob*/!*, ค่าถูกเปลี่ยนโดยฟังก์ชัน  
 ```
 
-The outer variable is only used if there's no local one.
+ตัวแปรภายนอกจะถูกใช้ก็ต่อเมื่อไม่มีตัวแปรภายในฟังก์ชั่นที่ชื่อเดียวกัน
 
-If a same-named variable is declared inside the function then it *shadows* the outer one. For instance, in the code below the function uses the local `userName`. The outer one is ignored:
+ถ้ามีการประกาศตัวแปรที่ชื่อซ้ำกันภายในฟังก์ชัน มันจะ *บดบัง* ตัวแปรภายนอก เช่น ในโค้ดด้านล่าง ฟังก์ชันจะใช้ `userName` ภายในของตัวเอง ส่วนตัวภายนอกจะถูกมองข้าม:
 
 ```js run
 let userName = 'John';
 
 function showMessage() {
 *!*
-  let userName = "Bob"; // declare a local variable
+  let userName = "Bob"; // ประกาศตัวแปรภายในฟังก์ชัน
 */!*
 
   let message = 'Hello, ' + userName; // *!*Bob*/!*
   alert(message);
 }
 
-// the function will create and use its own userName
+// ฟังก์ชันจะสร้างและใช้ userName ของตัวเอง
 showMessage();
 
-alert( userName ); // *!*John*/!*, unchanged, the function did not access the outer variable
+alert( userName ); // *!*John*/!*, ไม่เปลี่ยนแปลง เพราะฟังก์ชันไม่ได้เข้าถึงตัวแปรภายนอก
 ```
 
-```smart header="Global variables"
-Variables declared outside of any function, such as the outer `userName` in the code above, are called *global*.
+```smart header="ตัวแปรโกลบอล (Global variables)"
+ตัวแปรที่ประกาศนอกฟังก์ชันใดๆ เช่น `userName` ภายนอกในตัวอย่างข้างต้น เรียกว่า *ตัวแปรโกลบอล* 
 
-Global variables are visible from any function (unless shadowed by locals).
+ตัวแปรโกลบอลจะมองเห็นได้จากทุกฟังก์ชัน (ยกเว้นถูกบดบังโดยตัวแปรภายในฟังก์ชั่น)
 
-It's a good practice to minimize the use of global variables. Modern code has few or no globals. Most variables reside in their functions. Sometimes though, they can be useful to store project-level data.
+เป็นแนวทางปฏิบัติที่ดีที่จะลดการใช้ตัวแปรโกลบอล โค้ดสมัยใหม่มักมีตัวแปรโกลบอลน้อยมากหรือไม่มีเลย ตัวแปรส่วนใหญ่จะอยู่ภายในฟังก์ชันของตัวเอง อย่างไรก็ตาม บางครั้งตัวแปรโกลบอลก็มีประโยชน์ในการเก็บข้อมูลระดับโปรเจกต์
 ```
 
-## Parameters
+## พารามิเตอร์ (Parameters)
 
-We can pass arbitrary data to functions using parameters.
+เราสามารถส่งผ่านข้อมูลใดๆ ไปยังฟังก์ชันโดยใช้พารามิเตอร์ได้
 
-In the example below, the function has two parameters: `from` and `text`.
+ในตัวอย่างด้านล่าง ฟังก์ชันมีพารามิเตอร์สองตัวคือ `from` และ `text`
 
 ```js run
-function showMessage(*!*from, text*/!*) { // parameters: from, text
+function showMessage(*!*from, text*/!*) { // พารามิเตอร์: from, text
   alert(from + ': ' + text);
 }
 
@@ -150,15 +154,15 @@ function showMessage(*!*from, text*/!*) { // parameters: from, text
 *!*showMessage('Ann', "What's up?");*/!* // Ann: What's up? (**)
 ```
 
-When the function is called in lines `(*)` and `(**)`, the given values are copied to local variables `from` and `text`. Then the function uses them.
+เมื่อฟังก์ชันถูกเรียกในบรรทัด `(*)` และ `(**)` ค่าที่ส่งเข้าไปจะถูกคัดลอกไปยังตัวแปรภายในฟังก์ชั่น `from` และ `text` จากนั้นฟังก์ชันก็จะใช้ตัวแปรเหล่านั้น
 
-Here's one more example: we have a variable `from` and pass it to the function. Please note: the function changes `from`, but the change is not seen outside, because a function always gets a copy of the value:
+นี่คืออีกตัวอย่าง: เรามีตัวแปร `from` และส่งผ่านมันเข้าไปในฟังก์ชัน สังเกตว่า ฟังก์ชันเปลี่ยนค่า `from` แต่การเปลี่ยนแปลงนั้นจะไม่ปรากฏภายนอก เพราะฟังก์ชันจะได้รับสำเนาของค่าเสมอ:
 
 ```js run
 function showMessage(from, text) {
 
 *!*
-  from = '*' + from + '*'; // make "from" look nicer
+  from = '*' + from + '*'; // ทำให้ "from" ดูสวยงามขึ้น
 */!*
 
   alert( from + ': ' + text );
@@ -168,35 +172,39 @@ let from = "Ann";
 
 showMessage(from, "Hello"); // *Ann*: Hello
 
-// the value of "from" is the same, the function modified a local copy
-alert( from ); // Ann
+// ค่าของ "from" ยังเหมือนเดิม ฟังก์ชันแก้ไขสำเนาในตัวเอง
+alert( from ); // Ann  
 ```
 
-When a value is passed as a function parameter, it's also called an *argument*.
+เมื่อค่าถูกส่งผ่านเข้าไปเป็นพารามิเตอร์ของฟังก์ชัน เราเรียกค่านั้นว่า *อาร์กิวเมนต์ (argument)*
 
-In other words, to put these terms straight:
+หรือพูดอีกอย่างคือ เพื่อให้เข้าใจคำศัพท์ชัดเจน:
 
+<<<<<<< HEAD
+- พารามิเตอร์ คือตัวแปรที่ระบุในวงเล็บตอนประกาศฟังก์ชัน (เป็นคำศัพท์ช่วงประกาศ)
+- อาร์กิวเมนต์ คือค่าที่ส่งผ่านเข้าไปในฟังก์ชันตอนเรียกใช้ (เป็นคำศัพท์ช่วงเรียกใช้)
+=======
 - A parameter is the variable listed inside the parentheses in the function declaration (it's a declaration time term).
 - An argument is the value that is passed to the function when it is called (it's a call time term).
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-We declare functions listing their parameters, then call them passing arguments.
-
-In the example above, one might say: "the function `showMessage` is declared with two parameters, then called with two arguments: `from` and `"Hello"`".
+เราประกาศฟังก์ชันโดยระบุพารามิเตอร์ของมัน จากนั้นเรียกใช้มันโดยส่งผ่านอาร์กิวเมนต์เข้าไป
 
+ในตัวอย่างข้างบน เราอาจพูดว่า: "ฟังก์ชัน `showMessage` ถูกประกาศด้วยพารามิเตอร์สองตัว จากนั้นถูกเรียกใช้ด้วยอาร์กิวเมนต์สองตัวคือ `from` และ `"Hello"`"
 
-## Default values
+## ค่าเริ่มต้น (Default values)
 
-If a function is called, but an argument is not provided, then the corresponding value becomes `undefined`.
+หากฟังก์ชันถูกเรียกใช้แต่ไม่ได้ส่งอาร์กิวเมนต์มาด้วย ค่าที่สอดคล้องกันจะเป็น `undefined`
 
-For instance, the aforementioned function `showMessage(from, text)` can be called with a single argument:
+ยกตัวอย่างเช่น ฟังก์ชัน `showMessage(from, text)` ที่กล่าวถึงก่อนหน้า สามารถเรียกใช้ด้วยอาร์กิวเมนต์เพียงตัวเดียวได้:
 
 ```js
 showMessage("Ann");
 ```
 
-That's not an error. Such a call would output `"*Ann*: undefined"`. As the value for `text` isn't passed, it becomes `undefined`.
+นี่ไม่ใช่ข้อผิดพลาด การเรียกแบบนี้จะแสดงผลเป็น `"*Ann*: undefined"` เนื่องจากไม่ได้ส่งค่าให้กับพารามิเตอร์ `text` จึงมีค่าเป็น `undefined`
 
-We can specify the so-called "default" (to use if omitted) value for a parameter in the function declaration, using `=`:
+เราสามารถระบุค่าที่เรียกว่า "ค่าเริ่มต้น" (ใช้เมื่อไม่ได้ส่งค่ามา) สำหรับพารามิเตอร์ในการประกาศฟังก์ชันได้ โดยใช้ `=`:
 
 ```js run
 function showMessage(from, *!*text = "no text given"*/!*) {
@@ -206,6 +214,9 @@ function showMessage(from, *!*text = "no text given"*/!*) {
 showMessage("Ann"); // Ann: no text given
 ```
 
+<<<<<<< HEAD
+ตอนนี้ถ้าไม่ได้ส่งพารามิเตอร์ `text` มา มันจะมีค่าเป็น `"no text given"`
+=======
 Now if the `text` parameter is not passed, it will get the value `"no text given"`.
 
 The default value also jumps in if the parameter exists, but strictly equals `undefined`, like this:
@@ -213,24 +224,37 @@ The default value also jumps in if the parameter exists, but strictly equals `un
 ```js
 showMessage("Ann", undefined); // Ann: no text given
 ```
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-Here `"no text given"` is a string, but it can be a more complex expression, which is only evaluated and assigned if the parameter is missing. So, this is also possible:
+ค่าเริ่มต้นจะถูกนำมาใช้ด้วย ถ้าพารามิเตอร์มีอยู่แต่ค่าเป็น `undefined` อย่างเคร่งครัด เช่นนี้:
+
+```js
+showMessage("Ann", undefined); // Ann: no text given
+```
+
+ในที่นี้ `"no text given"` เป็น string แต่มันสามารถเป็นนิพจน์ที่ซับซ้อนกว่านั้นได้ ซึ่งจะถูกประเมินค่าและกำหนดให้เฉพาะเมื่อไม่ได้ส่งพารามิเตอร์มาเท่านั้น ดังนั้นสิ่งนี้ก็เป็นไปได้:
 
 ```js run
 function showMessage(from, text = anotherFunction()) {
-  // anotherFunction() only executed if no text given
-  // its result becomes the value of text
+  // anotherFunction() จะถูกเรียกใช้เฉพาะเมื่อไม่ได้ส่ง text มา
+  // ผลลัพธ์ของมันจะกลายเป็นค่าของ text
 }
 ```
 
-```smart header="Evaluation of default parameters"
-In JavaScript, a default parameter is evaluated every time the function is called without the respective parameter.
+```smart header="การประเมินค่าพารามิเตอร์เริ่มต้น"
+ใน JavaScript พารามิเตอร์เริ่มต้นจะถูกประเมินค่าทุกครั้งที่เรียกใช้ฟังก์ชันโดยไม่ส่งพารามิเตอร์ที่เกี่ยวข้อง
 
-In the example above, `anotherFunction()` isn't called at all, if the `text` parameter is provided.
+ในตัวอย่างข้างต้น `anotherFunction()` จะไม่ถูกเรียกใช้เลย ถ้าส่งพารามิเตอร์ `text` มา
 
-On the other hand, it's independently called every time when `text` is missing.
+ในทางกลับกัน มันจะถูกเรียกใช้แยกต่างหากทุกครั้งที่ไม่ได้ส่ง `text` มา
 ```
 
+<<<<<<< HEAD
+````smart header="พารามิเตอร์เริ่มต้นในโค้ด JavaScript เก่า"
+เมื่อหลายปีก่อน JavaScript ไม่รองรับไวยากรณ์ของพารามิเตอร์เริ่มต้น ดังนั้นคนจึงใช้วิธีอื่นในการระบุค่าเริ่มต้น
+
+ปัจจุบันเราอาจพบเจอสิ่งเหล่านี้ในสคริปต์เก่าๆ 
+=======
 ````smart header="Default parameters in old JavaScript code"
 Several years ago, JavaScript didn't support the syntax for default parameters. So people used other ways to specify them.
 
@@ -266,53 +290,84 @@ function showMessage(from, text) {
 ### Alternative default parameters
 
 Sometimes it makes sense to assign default values for parameters at a later stage after the function declaration.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
+
+เช่น การตรวจสอบ `undefined` อย่างชัดเจน:
+
+```js
+function showMessage(from, text) {
+*!*
+  if (text === undefined) {
+    text = 'no text given';
+  }
+*/!*
+
+  alert( from + ": " + text );
+}
+```
+
+...หรือใช้ตัวดำเนินการ `||`:
+
+```js  
+function showMessage(from, text) {
+  // ถ้าค่าของ text เป็น falsy ให้กำหนดค่าเริ่มต้น
+  // ซึ่งสมมติว่า text == "" เหมือนกับไม่มี text เลย
+  text = text || 'no text given';
+  ...
+}
+```
+````
+
+### พารามิเตอร์เริ่มต้นทางเลือก
 
-We can check if the parameter is passed during the function execution, by comparing it with `undefined`:
+บางครั้งการกำหนดค่าเริ่มต้นให้พารามิเตอร์ในภายหลัง หลังจากประกาศฟังก์ชันไปแล้ว ก็มีเหตุผลเช่นกัน
+
+เราสามารถตรวจสอบว่ามีการส่งพารามิเตอร์มาหรือไม่ระหว่างการทำงานของฟังก์ชัน โดยเปรียบเทียบกับ `undefined`:
 
 ```js run
 function showMessage(text) {
   // ...
 
 *!*
-  if (text === undefined) { // if the parameter is missing
-    text = 'empty message';
+  if (text === undefined) { // ถ้าไม่มีพารามิเตอร์ส่งมา
+    text = 'ข้อความว่าง';  
   }
 */!*
 
   alert(text);
 }
 
-showMessage(); // empty message
+showMessage(); // ข้อความว่าง
 ```
 
-...Or we could use the `||` operator:
+...หรือเราสามารถใช้ตัวดำเนินการ `||`:
 
 ```js
 function showMessage(text) {
-  // if text is undefined or otherwise falsy, set it to 'empty'
+  // ถ้า text เป็น undefined หรือ falsy อื่นๆ ให้กำหนดเป็น 'empty'
   text = text || 'empty';
-  ...
+  ...  
 }
 ```
 
-Modern JavaScript engines support the [nullish coalescing operator](info:nullish-coalescing-operator) `??`, it's better when most falsy values, such as `0`, should be considered "normal":
+JavaScript เอนจินสมัยใหม่รองรับ[ตัวดำเนินการรวม nullish](info:nullish-coalescing-operator) `??` ซึ่งจะเหมาะกว่าเมื่อต้องการให้ค่า falsy ส่วนใหญ่ เช่น `0` ถือเป็นค่า "ปกติ":
 
 ```js run
 function showCount(count) {
-  // if count is undefined or null, show "unknown"
+  // ถ้า count เป็น undefined หรือ null ให้แสดง "unknown"
   alert(count ?? "unknown");
 }
 
 showCount(0); // 0
-showCount(null); // unknown
+showCount(null); // unknown 
 showCount(); // unknown
 ```
 
-## Returning a value
+## การส่งคืนค่า (Returning a value)
 
-A function can return a value back into the calling code as the result.
+ฟังก์ชันสามารถส่งคืนค่ากลับไปยังโค้ดที่เรียกใช้เป็นผลลัพธ์ได้
 
-The simplest example would be a function that sums two values:
+ตัวอย่างง่ายๆ คือฟังก์ชันที่รวมผลบวกของสองค่า:
 
 ```js run no-beautify
 function sum(a, b) {
@@ -323,9 +378,9 @@ let result = sum(1, 2);
 alert( result ); // 3
 ```
 
-The directive `return` can be in any place of the function. When the execution reaches it, the function stops, and the value is returned to the calling code (assigned to `result` above).
+คำสั่ง `return` สามารถอยู่ที่ไหนก็ได้ในฟังก์ชัน เมื่อการทำงานมาถึงมัน ฟังก์ชันจะหยุดและส่งคืนค่าไปยังโค้ดที่เรียกใช้ (กำหนดให้กับ `result` ในตัวอย่างข้างต้น)  
 
-There may be many occurrences of `return` in a single function. For instance:
+ในฟังก์ชันเดียวอาจมีหลายจุดที่ใช้ `return` ได้ เช่น:
 
 ```js run
 function checkAge(age) {
@@ -335,23 +390,23 @@ function checkAge(age) {
 */!*
   } else {
 *!*
-    return confirm('Do you have permission from your parents?');
+    return confirm('คุณได้รับอนุญาตจากผู้ปกครองหรือไม่?');
 */!*
   }
 }
 
-let age = prompt('How old are you?', 18);
+let age = prompt('คุณอายุเท่าไหร่?', 18);
 
 if ( checkAge(age) ) {
-  alert( 'Access granted' );
+  alert('อนุญาตให้เข้าใช้งาน');
 } else {
-  alert( 'Access denied' );
+  alert('ไม่อนุญาตให้เข้าใช้งาน');
 }
 ```
 
-It is possible to use `return` without a value. That causes the function to exit immediately.
+เราสามารถใช้ `return` โดยไม่มีค่าก็ได้ ซึ่งจะทำให้ฟังก์ชันจบการทำงานทันที
 
-For example:
+ตัวอย่างเช่น:
 
 ```js
 function showMovie(age) {
@@ -361,25 +416,25 @@ function showMovie(age) {
 */!*
   }
 
-  alert( "Showing you the movie" ); // (*)
+  alert("กำลังแสดงภาพยนตร์ให้ชม"); // (*)
   // ...
 }
 ```
 
-In the code above, if `checkAge(age)` returns `false`, then `showMovie` won't proceed to the `alert`.
+ในโค้ดข้างต้น ถ้า `checkAge(age)` คืนค่า `false` ฟังก์ชัน `showMovie` จะไม่ทำงานต่อไปที่ `alert`
 
-````smart header="A function with an empty `return` or without it returns `undefined`"
-If a function does not return a value, it is the same as if it returns `undefined`:
+````smart header="ฟังก์ชันที่มี `return` ว่างหรือไม่มี `return` จะคืนค่า `undefined`"
+ถ้าฟังก์ชันไม่มีการคืนค่า มันจะเหมือนกับการคืนค่า `undefined`:
 
 ```js run
-function doNothing() { /* empty */ }
+function doNothing() { /* ว่าง */ }
 
 alert( doNothing() === undefined ); // true
 ```
 
-An empty `return` is also the same as `return undefined`:
+`return` ว่างก็เหมือนกับ `return undefined`:
 
-```js run
+```js run  
 function doNothing() {
   return;
 }
@@ -388,23 +443,23 @@ alert( doNothing() === undefined ); // true
 ```
 ````
 
-````warn header="Never add a newline between `return` and the value"
-For a long expression in `return`, it might be tempting to put it on a separate line, like this:
+````warn header="อย่าขึ้นบรรทัดใหม่ระหว่าง `return` กับค่าที่คืน"
+สำหรับนิพจน์ยาวๆ ใน `return` อาจเย้ายวนใจให้แยกเป็นบรรทัดใหม่ แบบนี้:
 
 ```js
 return
  (some + long + expression + or + whatever * f(a) + f(b))
 ```
-That doesn't work, because JavaScript assumes a semicolon after `return`. That'll work the same as:
+นั่นจะไม่ทำงาน เพราะ JavaScript จะสันนิษฐานว่ามีเครื่องหมายอัฒภาคหลัง `return` ซึ่งจะทำงานเหมือนกับ:
 
-```js
+```js  
 return*!*;*/!*
  (some + long + expression + or + whatever * f(a) + f(b))
 ```
 
-So, it effectively becomes an empty return.
+ดังนั้นมันจะกลายเป็น return เปล่าๆ อย่างมีประสิทธิภาพ 
 
-If we want the returned expression to wrap across multiple lines, we should start it at the same line as `return`. Or at least put the opening parentheses there as follows:
+ถ้าเราต้องการให้นิพจน์ที่คืนค่าขึ้นบรรทัดใหม่ เราควรเริ่มต้นในบรรทัดเดียวกับ `return` หรืออย่างน้อยควรใส่วงเล็บเปิดเอาไว้ที่นั่น แบบนี้:
 
 ```js
 return (
@@ -413,67 +468,72 @@ return (
   whatever * f(a) + f(b)
   )
 ```
-And it will work just as we expect it to.
+
+และมันจะทำงานตามที่เราคาดหวัง
 ````
 
-## Naming a function [#function-naming]
+## การตั้งชื่อฟังก์ชัน [#function-naming]
 
-Functions are actions. So their name is usually a verb. It should be brief, as accurate as possible and describe what the function does, so that someone reading the code gets an indication of what the function does.
+ฟังก์ชันคือการกระทำ ดังนั้นชื่อของมันมักจะเป็นคำกริยา ชื่อควรสั้นกระชับ ตรงประเด็นที่สุดเท่าที่จะเป็นไปได้ และบ่งบอกว่าฟังก์ชันทำอะไร เพื่อให้คนที่อ่านโค้ดเข้าใจได้ทันทีว่าฟังก์ชันนั้นทำหน้าที่อะไร
 
-It is a widespread practice to start a function with a verbal prefix which vaguely describes the action. There must be an agreement within the team on the meaning of the prefixes.
+เป็นแนวปฏิบัติที่แพร่หลายในการขึ้นต้นชื่อฟังก์ชันด้วยคำกริยาเพื่ออธิบายการกระทำคร่าวๆ ทีมงานควรตกลงกันเรื่องความหมายของคำนำหน้าเหล่านี้ให้ชัดเจน
 
-For instance, functions that start with `"show"` usually show something.
+ตัวอย่างเช่น ฟังก์ชันที่ขึ้นต้นด้วย `"show"` มักจะแสดงบางอย่าง
 
-Function starting with...
+ฟังก์ชันที่ขึ้นต้นด้วย...
 
-- `"get…"` -- return a value,
-- `"calc…"` -- calculate something,
-- `"create…"` -- create something,
-- `"check…"` -- check something and return a boolean, etc.
+- `"get…"` -- คืนค่าบางอย่าง
+- `"calc…"` -- คำนวณบางอย่าง  
+- `"create…"` -- สร้างบางอย่าง
+- `"check…"` -- ตรวจสอบบางอย่างและคืนค่าบูลีน ฯลฯ
 
-Examples of such names:
+ตัวอย่างชื่อฟังก์ชันเหล่านี้:
 
 ```js no-beautify
-showMessage(..)     // shows a message
-getAge(..)          // returns the age (gets it somehow)
-calcSum(..)         // calculates a sum and returns the result
-createForm(..)      // creates a form (and usually returns it)
-checkPermission(..) // checks a permission, returns true/false
+showMessage(..)     // แสดงข้อความ
+getAge(..)          // คืนค่าอายุ (ได้ค่ามาด้วยวิธีใดวิธีหนึ่ง)
+calcSum(..)         // คำนวณผลรวมและคืนผลลัพธ์  
+createForm(..)      // สร้างฟอร์ม (และมักจะคืนค่าฟอร์มนั้น)
+checkPermission(..) // ตรวจสอบสิทธิ์ คืนค่า true/false
 ```
 
-With prefixes in place, a glance at a function name gives an understanding what kind of work it does and what kind of value it returns.
+เมื่อใช้คำนำหน้าแล้ว เพียงแค่มองชื่อฟังก์ชันก็พอจะเข้าใจได้ว่ามันทำงานแบบไหนและคืนค่าประเภทใด
 
-```smart header="One function -- one action"
-A function should do exactly what is suggested by its name, no more.
+```smart header="หนึ่งฟังก์ชัน -- หนึ่งการกระทำ"
+ฟังก์ชันควรทำในสิ่งที่ชื่อของมันบอกไว้ ไม่มากไปกว่านั้น
 
-Two independent actions usually deserve two functions, even if they are usually called together (in that case we can make a 3rd function that calls those two).
+การกระทำสองอย่างที่เป็นอิสระจากกัน มักสมควรแยกเป็นสองฟังก์ชัน แม้ว่าปกติจะถูกเรียกใช้ด้วยกัน (ในกรณีนั้นเราอาจสร้างฟังก์ชันที่สามเพื่อเรียกใช้ทั้งสองฟังก์ชันนั้น)
 
-A few examples of breaking this rule:
+ตัวอย่างที่ละเมิดกฎข้อนี้:
 
-- `getAge` -- would be bad if it shows an `alert` with the age (should only get).
-- `createForm` -- would be bad if it modifies the document, adding a form to it (should only create it and return).
-- `checkPermission` -- would be bad if it displays the `access granted/denied` message (should only perform the check and return the result).
+- `getAge` -- จะไม่ดีถ้ามันแสดง `alert` บอกอายุด้วย (ควรแค่ดึงค่าอายุเท่านั้น)
+- `createForm` -- จะไม่ดีถ้ามันแก้ไขเอกสารด้วยการเพิ่มฟอร์มเข้าไป (ควรแค่สร้างฟอร์มและคืนค่า)  
+- `checkPermission` -- จะไม่ดีถ้ามันแสดงข้อความ `อนุญาต/ไม่อนุญาตให้เข้าถึง` (ควรแค่ตรวจสอบและคืนผลลัพธ์)
 
-These examples assume common meanings of prefixes. You and your team are free to agree on other meanings, but usually they're not much different. In any case, you should have a firm understanding of what a prefix means, what a prefixed function can and cannot do. All same-prefixed functions should obey the rules. And the team should share the knowledge.
+ตัวอย่างเหล่านี้สมมติความหมายทั่วไปของคำนำหน้า คุณและทีมสามารถตกลงกันถึงความหมายอื่นๆ ได้ แต่โดยปกติมักจะไม่ค่อยแตกต่างกันมาก ไม่ว่าอย่างไร คุณควรเข้าใจชัดเจนว่าคำนำหน้าหมายถึงอะไร ฟังก์ชันที่มีคำนำหน้าสามารถและไม่ควรทำอะไรได้บ้าง ฟังก์ชันที่มีคำนำหน้าเดียวกันทั้งหมดควรปฏิบัติตามกฎเดียวกัน และทีมควรแบ่งปันความรู้นี้ร่วมกัน
 ```
 
-```smart header="Ultrashort function names"
-Functions that are used *very often* sometimes have ultrashort names.
+```smart header="ชื่อฟังก์ชันที่สั้นมากๆ"
+ฟังก์ชันที่ถูกใช้ *บ่อยมากๆ* บางครั้งอาจมีชื่อที่สั้นมากๆ
 
+<<<<<<< HEAD
+เช่น เฟรมเวิร์ค [jQuery](https://jquery.com/) กำหนดฟังก์ชันชื่อ `$` ส่วนไลบรารี [Lodash](https://lodash.com/) มีฟังก์ชันหลักชื่อ `_`
+=======
 For example, the [jQuery](https://jquery.com/) framework defines a function with `$`. The [Lodash](https://lodash.com/) library has its core function named `_`.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-These are exceptions. Generally function names should be concise and descriptive.
+แต่สิ่งเหล่านี้เป็นข้อยกเว้น โดยทั่วไปแล้วชื่อฟังก์ชันควรกระชับและบ่งบอกความหมายได้ชัดเจน
 ```
 
-## Functions == Comments
+## ฟังก์ชัน == คอมเมนต์
 
-Functions should be short and do exactly one thing. If that thing is big, maybe it's worth it to split the function into a few smaller functions. Sometimes following this rule may not be that easy, but it's definitely a good thing.
+ฟังก์ชันควรสั้นและทำเพียงหนึ่งสิ่งอย่างชัดเจน ถ้าสิ่งนั้นใหญ่เกินไป อาจคุ้มค่าที่จะแยกฟังก์ชันออกเป็นฟังก์ชันเล็กๆ สองสามอัน บางครั้งอาจไม่ง่ายนักที่จะทำตามกฎนี้ แต่มันเป็นสิ่งที่ดีอย่างแน่นอน
 
-A separate function is not only easier to test and debug -- its very existence is a great comment!
+ฟังก์ชันที่แยกออกมา นอกจากจะทดสอบและดีบักได้ง่ายกว่าแล้ว การมีอยู่ของมันยังเป็นคอมเมนต์ที่ดีเยี่ยมอีกด้วย!
 
-For instance, compare the two functions `showPrimes(n)` below. Each one outputs [prime numbers](https://en.wikipedia.org/wiki/Prime_number) up to `n`.
+ยกตัวอย่างเช่น เปรียบเทียบฟังก์ชัน `showPrimes(n)` สองอันด้านล่าง แต่ละอันแสดงผล [จำนวนเฉพาะ](https://en.wikipedia.org/wiki/Prime_number) จนถึง `n`
 
-The first variant uses a label:
+แบบแรกใช้ label:
 
 ```js
 function showPrimes(n) {
@@ -483,12 +543,12 @@ function showPrimes(n) {
       if (i % j == 0) continue nextPrime;
     }
 
-    alert( i ); // a prime
+    alert( i ); // จำนวนเฉพาะ
   }
 }
 ```
 
-The second variant uses an additional function `isPrime(n)` to test for primality:
+แบบที่สองใช้ฟังก์ชันเสริม `isPrime(n)` เพื่อตรวจสอบว่าเป็นจำนวนเฉพาะหรือไม่:
 
 ```js
 function showPrimes(n) {
@@ -496,7 +556,7 @@ function showPrimes(n) {
   for (let i = 2; i < n; i++) {
     *!*if (!isPrime(i)) continue;*/!*
 
-    alert(i);  // a prime
+    alert(i);  // จำนวนเฉพาะ
   }
 }
 
@@ -508,32 +568,36 @@ function isPrime(n) {
 }
 ```
 
-The second variant is easier to understand, isn't it? Instead of the code piece we see a name of the action (`isPrime`). Sometimes people refer to such code as *self-describing*.
+แบบที่สองเข้าใจง่ายกว่าใช่ไหม? แทนที่จะเห็นส่วนโค้ด เราเห็นชื่อการกระทำ (`isPrime`) บางครั้งผู้คนเรียกโค้ดแบบนี้ว่า *อธิบายตัวเอง* 
 
-So, functions can be created even if we don't intend to reuse them. They structure the code and make it readable.
+ดังนั้นเราสามารถสร้างฟังก์ชันได้แม้ไม่ได้ตั้งใจจะนำมาใช้ซ้ำ มันจัดโครงสร้างโค้ดและทำให้อ่านง่ายขึ้น
 
-## Summary
+## สรุป
 
-A function declaration looks like this:
+การประกาศฟังก์ชันมีหน้าตาแบบนี้:
 
 ```js
 function name(parameters, delimited, by, comma) {
   /* code */
-}
+}  
 ```
 
-- Values passed to a function as parameters are copied to its local variables.
-- A function may access outer variables. But it works only from inside out. The code outside of the function doesn't see its local variables.
-- A function can return a value. If it doesn't, then its result is `undefined`.
+- ค่าที่ส่งเข้าไปในฟังก์ชันผ่านพารามิเตอร์จะถูกคัดลอกไปเป็นตัวแปรภายในฟังก์ชั่น
+- ฟังก์ชันสามารถเข้าถึงตัวแปรภายนอกได้ แต่มันจะทำงานจากด้านในออกไปด้านนอกเท่านั้น โค้ดภายนอกฟังก์ชันจะไม่เห็นตัวแปรภายในฟังก์ชั่นของมัน
+- ฟังก์ชันสามารถคืนค่าได้ ถ้าไม่คืนค่า ผลลัพธ์จะเป็น `undefined`
 
-To make the code clean and easy to understand, it's recommended to use mainly local variables and parameters in the function, not outer variables.
+เพื่อให้โค้ดสะอาดและเข้าใจง่าย แนะนำให้ใช้ตัวแปรภายในฟังก์ชั่นและพารามิเตอร์ในฟังก์ชันเป็นหลัก ไม่ใช้ตัวแปรภายนอก
 
+<<<<<<< HEAD
+การทำความเข้าใจฟังก์ชันที่รับพารามิเตอร์ ทำงานกับมัน และคืนผลลัพธ์จะง่ายกว่าฟังก์ชันที่ไม่รับพารามิเตอร์แต่ไปแก้ไขตัวแปรภายนอก ซึ่งถือเป็นผลข้างเคียง
+=======
 It is always easier to understand a function which gets parameters, works with them and returns a result than a function which gets no parameters, but modifies outer variables as a side effect.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-Function naming:
+การตั้งชื่อฟังก์ชัน:
 
-- A name should clearly describe what the function does. When we see a function call in the code, a good name instantly gives us an understanding what it does and returns.
-- A function is an action, so function names are usually verbal.
-- There exist many well-known function prefixes like `create…`, `show…`, `get…`, `check…` and so on. Use them to hint what a function does.
+- ชื่อควรบอกชัดเจนว่าฟังก์ชันทำอะไร เมื่อเห็นการเรียกฟังก์ชันในโค้ด ชื่อที่ดีจะให้ความเข้าใจในทันทีว่ามันทำอะไรและคืนค่าอะไร
+- ฟังก์ชันคือการกระทำ ดังนั้นชื่อฟังก์ชันมักเป็นคำกริยา  
+- มีคำนำหน้าฟังก์ชันที่ใช้กันแพร่หลายเช่น `create…`, `show…`, `get…`, `check…` เป็นต้น ให้ใช้เป็นตัวบอกใบ้ว่าฟังก์ชันทำอะไร
 
-Functions are the main building blocks of scripts. Now we've covered the basics, so we actually can start creating and using them. But that's only the beginning of the path. We are going to return to them many times, going more deeply into their advanced features.
+ฟังก์ชันเป็นบล็อกสำคัญในการสร้างสคริปต์ ตอนนี้เราได้เรียนรู้พื้นฐานแล้ว เราจึงสามารถเริ่มสร้างและใช้มันได้จริงๆ แต่นี่เป็นเพียงจุดเริ่มต้นของเส้นทาง เรายังจะกลับมาที่ฟังก์ชันอีกหลายครั้งเพื่อศึกษาฟีเจอร์ขั้นสูงต่างๆ ให้ลึกซึ้งยิ่งขึ้น
\ No newline at end of file
diff --git a/1-js/02-first-steps/16-function-expressions/article.md b/1-js/02-first-steps/16-function-expressions/article.md
index c6dd891bd..8834ae51a 100644
--- a/1-js/02-first-steps/16-function-expressions/article.md
+++ b/1-js/02-first-steps/16-function-expressions/article.md
@@ -1,8 +1,8 @@
-# Function expressions
+# นิพจน์ฟังก์ชัน
 
-In JavaScript, a function is not a "magical language structure", but a special kind of value.
+ใน JavaScript ฟังก์ชันไม่ใช่ "โครงสร้างพิเศษทางภาษา" แต่เป็นค่าชนิดหนึ่งที่มีลักษณะเฉพาะ
 
-The syntax that we used before is called a *Function Declaration*:
+รูปแบบที่เราใช้ก่อนหน้านี้เรียกว่า *การประกาศฟังก์ชัน* (Function Declaration):
 
 ```js
 function sayHi() {
@@ -10,11 +10,11 @@ function sayHi() {
 }
 ```
 
-There is another syntax for creating a function that is called a *Function Expression*.
+มีอีกวิธีหนึ่งในการสร้างฟังก์ชันที่เรียกว่า *นิพจน์ฟังก์ชัน* (Function Expression)
 
-It allows us to create a new function in the middle of any expression.
+ซึ่งช่วยให้เราสามารถสร้างฟังก์ชันใหม่ได้ในทุกๆ นิพจน์ (expression)
 
-For example:
+ตัวอย่างเช่น:
 
 ```js
 let sayHi = function() {
@@ -22,21 +22,21 @@ let sayHi = function() {
 };
 ```
 
-Here we can see a variable `sayHi` getting a value, the new function, created as `function() { alert("Hello"); }`.
+ในที่นี้เราเห็นตัวแปร `sayHi` ได้รับค่าเป็นฟังก์ชันใหม่ที่สร้างขึ้นด้วย `function() { alert("Hello"); }`
 
-As the function creation happens in the context of the assignment expression (to the right side of `=`), this is a *Function Expression*.
+เนื่องจากการสร้างฟังก์ชันเกิดขึ้นในบริบทของนิพจน์การกำหนดค่า (ทางขวาของเครื่องหมาย `=`) จึงเป็นนิพจน์ฟังก์ชัน
 
-Please note, there's no name after the `function` keyword. Omitting a name is allowed for Function Expressions.
+โปรดสังเกตว่าไม่มีชื่อหลังคำสำคัญ `function` การละเว้นชื่อนั้นอนุญาตสำหรับนิพจน์ฟังก์ชัน
 
-Here we immediately assign it to the variable, so the meaning of these code samples is the same: "create a function and put it into the variable `sayHi`".
+ในที่นี้เรากำหนดค่าให้กับตัวแปรทันที ดังนั้นความหมายของตัวอย่างโค้ดเหล่านี้จึงเหมือนกันคือ "สร้างฟังก์ชันและเก็บลงในตัวแปร `sayHi`"
 
-In more advanced situations, that we'll come across later, a function may be created and immediately called or scheduled for a later execution, not stored anywhere, thus remaining anonymous.
+ในสถานการณ์ที่ซับซ้อนขึ้นซึ่งเราจะเจอในภายหลัง ฟังก์ชันอาจถูกสร้างขึ้นและเรียกใช้ทันที หรือกำหนดเวลาเพื่อใช้ในภายหลัง โดยไม่เก็บไว้ที่ใดเลย จึงไม่มีชื่อ (anonymous)
 
-## Function is a value
+## ฟังก์ชันคือค่า
 
-Let's reiterate: no matter how the function is created, a function is a value. Both examples above store a function in the `sayHi` variable.
+ขอย้ำอีกครั้ง: ไม่ว่าฟังก์ชันจะถูกสร้างมาอย่างไร มันคือค่าชนิดหนึ่ง ตัวอย่างทั้งสองด้านบนเก็บฟังก์ชันไว้ในตัวแปร `sayHi`
 
-We can even print out that value using `alert`:
+เราสามารถแสดงค่านั้นผ่าน `alert` ได้ด้วย:
 
 ```js run
 function sayHi() {
@@ -44,41 +44,41 @@ function sayHi() {
 }
 
 *!*
-alert( sayHi ); // shows the function code
+alert( sayHi ); // แสดงโค้ดฟังก์ชัน
 */!*
 ```
 
-Please note that the last line does not run the function, because there are no parentheses after `sayHi`. There are programming languages where any mention of a function name causes its execution, but JavaScript is not like that.
+โปรดสังเกตว่าบรรทัดสุดท้ายไม่ได้เรียกใช้ฟังก์ชัน เพราะไม่มีวงเล็บหลัง `sayHi` มีภาษาโปรแกรมบางภาษาที่เมื่อพูดถึงชื่อฟังก์ชันจะทำให้เกิดการเรียกใช้ทันที แต่ JavaScript ไม่เป็นเช่นนั้น
 
-In JavaScript, a function is a value, so we can deal with it as a value. The code above shows its string representation, which is the source code.
+ใน JavaScript ฟังก์ชันเป็นค่าประเภทหนึ่ง เราจึงสามารถจัดการกับมันเหมือนกับค่าประเภทอื่นๆ โค้ดด้านบนแสดงการแปลงเป็นสตริง ซึ่งก็คือซอร์สโค้ดนั่นเอง
 
-Surely, a function is a special value, in the sense that we can call it like `sayHi()`.
+แน่นอนว่าฟังก์ชันเป็นค่าพิเศษ ตรงที่เราสามารถเรียกใช้มันได้ เช่น `sayHi()`
 
-But it's still a value. So we can work with it like with other kinds of values.
+แต่มันก็ยังคงเป็นค่าอยู่ เราจึงทำงานกับมันได้เหมือนกับค่าประเภทอื่นๆ
 
-We can copy a function to another variable:
+เราสามารถคัดลอกฟังก์ชันไปยังตัวแปรอื่นได้:
 
 ```js run no-beautify
-function sayHi() {   // (1) create
+function sayHi() {   // (1) สร้าง
   alert( "Hello" );
 }
 
-let func = sayHi;    // (2) copy
+let func = sayHi;    // (2) คัดลอก
 
-func(); // Hello     // (3) run the copy (it works)!
-sayHi(); // Hello    //     this still works too (why wouldn't it)
+func(); // Hello     // (3) เรียกใช้สำเนา (ใช้ได้)!
+sayHi(); // Hello    //     ตัวต้นฉบับยังใช้ได้เหมือนเดิม (แน่นอน)
 ```
 
-Here's what happens above in detail:
+นี่คือสิ่งที่เกิดขึ้นในรายละเอียด:
 
-1. The Function Declaration `(1)` creates the function and puts it into the variable named `sayHi`.
-2. Line `(2)` copies it into the variable `func`. Please note again: there are no parentheses after `sayHi`. If there were, then `func = sayHi()` would write  *the result of the call* `sayHi()` into `func`, not *the function* `sayHi` itself.
-3. Now the function can be called as both `sayHi()` and `func()`.
+1. การประกาศฟังก์ชัน `(1)` สร้างฟังก์ชันและเก็บไว้ในตัวแปรชื่อ `sayHi`
+2. บรรทัด `(2)` คัดลอกมันไปยังตัวแปร `func` โปรดสังเกตอีกครั้ง: ไม่มีวงเล็บหลัง `sayHi` ถ้ามี `func = sayHi()` จะเขียน *ผลลัพธ์จากการเรียกใช้* `sayHi()` ลงใน `func` ไม่ใช่เขียน *ฟังก์ชัน* `sayHi` เอง
+3. ตอนนี้ฟังก์ชันสามารถเรียกได้ทั้งในชื่อ `sayHi()` และ `func()`
 
-We could also have used a Function Expression to declare `sayHi`, in the first line:
+เราสามารถใช้นิพจน์ฟังก์ชันเพื่อประกาศ `sayHi` ในบรรทัดแรกก็ได้:
 
 ```js
-let sayHi = function() { // (1) create
+let sayHi = function() { // (1) สร้าง
   alert( "Hello" );
 };
 
@@ -86,11 +86,16 @@ let func = sayHi;  //(2)
 // ...
 ```
 
-Everything would work the same.
+ทุกอย่างจะทำงานเหมือนเดิม
 
+<<<<<<< HEAD
+```smart header="ทำไมต้องมีเครื่องหมายอัฒภาคตามหลัง?"
+คุณอาจสงสัยว่าทำไมนิพจน์ฟังก์ชันถึงต้องมีเครื่องหมายอัฒภาค `;` ท้ายประโยค แต่การประกาศฟังก์ชันไม่ต้องมี:
+=======
 
 ````smart header="Why is there a semicolon at the end?"
 You might wonder, why do Function Expressions have a semicolon `;` at the end, but Function Declarations do not:
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
 ```js
 function sayHi() {
@@ -102,27 +107,26 @@ let sayHi = function() {
 }*!*;*/!*
 ```
 
-The answer is simple: a Function Expression is created here as `function(…) {…}` inside the assignment statement: `let sayHi = …;`. The semicolon `;` is recommended at the end of the statement, it's not a part of the function syntax.
+คำตอบคือ: นิพจน์ฟังก์ชันถูกสร้างขึ้นในรูปแบบ `function(…) {…}` ภายในประโยคการกำหนดค่า: `let sayHi = …;` ควรมีเครื่องหมายอัฒภาค `;` ท้ายประโยค มันไม่ใช่ส่วนหนึ่งของไวยากรณ์ฟังก์ชัน
 
-The semicolon would be there for a simpler assignment, such as `let sayHi = 5;`, and it's also there for a function assignment.
-````
+เครื่องหมายอัฒภาคจะอยู่ในการกำหนดค่าทั่วไป เช่น `let sayHi = 5;` และอยู่ในการกำหนดค่าฟังก์ชันเช่นกัน
 
-## Callback functions
+## ฟังก์ชันคอลแบ็ก
 
-Let's look at more examples of passing functions as values and using function expressions.
+มาดูตัวอย่างเพิ่มเติมเกี่ยวกับการส่งฟังก์ชันเป็นค่า และการใช้นิพจน์ฟังก์ชันกัน
 
-We'll write a function `ask(question, yes, no)` with three parameters:
+เราจะเขียนฟังก์ชัน `ask(question, yes, no)` ที่มีสามพารามิเตอร์:
 
 `question`
-: Text of the question
+: ข้อความของคำถาม
 
 `yes`
-: Function to run if the answer is "Yes"
+: ฟังก์ชันที่จะรันหากคำตอบคือ "ใช่"
 
 `no`
-: Function to run if the answer is "No"
+: ฟังก์ชันที่จะรันหากคำตอบคือ "ไม่"
 
-The function should ask the `question` and, depending on the user's answer, call `yes()` or `no()`:
+ฟังก์ชันควรถาม `question` และเรียกใช้ `yes()` หรือ `no()` ตามคำตอบของผู้ใช้:
 
 ```js run
 *!*
@@ -140,17 +144,25 @@ function showCancel() {
   alert( "You canceled the execution." );
 }
 
-// usage: functions showOk, showCancel are passed as arguments to ask
+// การใช้งาน: ส่งฟังก์ชัน showOk, showCancel เป็นอาร์กิวเมนต์ให้ ask
 ask("Do you agree?", showOk, showCancel);
 ```
 
+<<<<<<< HEAD
+ในทางปฏิบัติ ฟังก์ชันเหล่านี้มีประโยชน์มาก ความแตกต่างหลักระหว่าง `ask` ในชีวิตจริงกับตัวอย่างข้างต้นคือ ฟังก์ชันในชีวิตจริงใช้วิธีที่ซับซ้อนกว่าในการโต้ตอบกับผู้ใช้ นอกเหนือจากการใช้ `confirm` ธรรมดา ในเบราว์เซอร์ ฟังก์ชันเหล่านี้มักสร้างหน้าต่างคำถามที่สวยงาม แต่นั่นเป็นอีกเรื่องหนึ่ง
+=======
 In practice, such functions are quite useful. The major difference between a real-life `ask` and the example above is that real-life functions use more complex ways to interact with the user than a simple `confirm`. In the browser, such functions usually draw a nice-looking question window. But that's another story.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-**The arguments `showOk` and `showCancel` of `ask` are called *callback functions* or just *callbacks*.**
+**อาร์กิวเมนต์ `showOk` และ `showCancel` ของ `ask` เรียกว่า *ฟังก์ชันคอลแบ็ก* หรือ *คอลแบ็ก***
 
-The idea is that we pass a function and expect it to be "called back" later if necessary. In our case, `showOk` becomes the callback for "yes" answer, and `showCancel` for "no" answer.
+แนวคิดคือ เราส่งฟังก์ชันไป และคาดหวังว่ามันจะถูก "เรียกกลับ (called back)" ในภายหลังหากจำเป็น ในกรณีของเรา `showOk` เป็นคอลแบ็กสำหรับคำตอบ "ใช่" และ `showCancel` สำหรับคำตอบ "ไม่"
 
+<<<<<<< HEAD
+เราสามารถใช้นิพจน์ฟังก์ชันเพื่อเขียนฟังก์ชันเทียบเท่าที่สั้นกว่าได้:
+=======
 We can use Function Expressions to write an equivalent, shorter function:
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
 ```js run no-beautify
 function ask(question, yes, no) {
@@ -167,59 +179,68 @@ ask(
 */!*
 ```
 
-Here, functions are declared right inside the `ask(...)` call. They have no name, and so are called *anonymous*. Such functions are not accessible outside of `ask` (because they are not assigned to variables), but that's just what we want here.
+ในที่นี้ ฟังก์ชันถูกประกาศขึ้นภายในการเรียก `ask(...)` โดยตรง โดยไม่มีการระบุชื่อ จึงเรียกว่า *anonymous (ไม่มีชื่อ)* ฟังก์ชันเหล่านี้ไม่สามารถเข้าถึงได้จากภายนอกของ `ask` (เพราะไม่ได้กำหนดให้กับตัวแปร) แต่นั่นแหละคือสิ่งที่เราต้องการในที่นี้
 
-Such code appears in our scripts very naturally, it's in the spirit of JavaScript.
+โค้ดลักษณะนี้ปรากฏในสคริปต์ของเราได้อย่างเป็นธรรมชาติ มันเป็นไปตามหลักการของภาษา JavaScript
 
-```smart header="A function is a value representing an \"action\""
-Regular values like strings or numbers represent the *data*.
+```smart header="ฟังก์ชันคือค่าที่แทนการ \"กระทำ\""   
+ค่าปกติ เช่น สตริงหรือตัวเลข แสดงถึง *ข้อมูล*
 
-A function can be perceived as an *action*.
+สามารถมองฟังก์ชันเป็น *การกระทำ* ได้
 
-We can pass it between variables and run when we want.
+เราสามารถส่งผ่านมันไประหว่างตัวแปร และสั่งให้ทำงานเมื่อใดก็ได้ที่ต้องการ
 ```
 
+## นิพจน์ฟังก์ชัน (Function Expression) กับ การประกาศฟังก์ชัน (Function Declaration)
 
-## Function Expression vs Function Declaration
+มาสรุปความแตกต่างสำคัญระหว่างการประกาศฟังก์ชันและนิพจน์ฟังก์ชันกัน
 
-Let's formulate the key differences between Function Declarations and Expressions.
+ประการแรก ในแง่วากยสัมพันธ์: วิธีแยกแยะทั้งสองแบบในโค้ด
 
+<<<<<<< HEAD
+- *การประกาศฟังก์ชัน:* ฟังก์ชันที่ประกาศเป็นประโยคแยกต่างหาก ในเนื้อหาหลักของโค้ด:
+=======
 First, the syntax: how to differentiate between them in the code.
 
 - *Function Declaration:* a function, declared as a separate statement, in the main code flow:
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
     ```js
-    // Function Declaration
+    // การประกาศฟังก์ชัน
     function sum(a, b) {
       return a + b;
     }
     ```
+<<<<<<< HEAD
+- *นิพจน์ฟังก์ชัน:* ฟังก์ชันที่ถูกสร้างภายในนิพจน์ หรือภายในโครงสร้างไวยากรณ์อื่นๆ ในที่นี้ ฟังก์ชันถูกสร้างขึ้นทางด้านขวาของ "นิพจน์การกำหนดค่า" `=`:
+=======
 - *Function Expression:* a function, created inside an expression or inside another syntax construct. Here, the function is created on the right side of the "assignment expression" `=`:
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
     ```js
-    // Function Expression
+    // นิพจน์ฟังก์ชัน
     let sum = function(a, b) {
       return a + b;
     };
     ```
 
-The more subtle difference is *when* a function is created by the JavaScript engine.
+ความแตกต่างที่ละเอียดอ่อนกว่าคือ เวลาที่ฟังก์ชันถูกสร้างโดยเอนจินของ JavaScript *เมื่อใด*
 
-**A Function Expression is created when the execution reaches it and is usable only from that moment.**
+**นิพจน์ฟังก์ชัน ถูกสร้างเมื่อการประมวลผลมาถึงมัน และใช้งานได้ตั้งแต่จุดนั้นเป็นต้นไป**
 
-Once the execution flow passes to the right side of the assignment `let sum = function…` -- here we go, the function is created and can be used (assigned, called, etc. ) from now on.
+เมื่อโฟลว์การประมวลผลผ่านไปถึงทางด้านขวาของการกำหนดค่า `let sum = function…` -- ฟังก์ชันก็จะถูกสร้างขึ้น และสามารถใช้งานได้ตั้งแต่ตอนนี้เป็นต้นไป (กำหนดค่า เรียกใช้ ฯลฯ) 
 
-Function Declarations are different.
+การประกาศฟังก์ชันนั้นแตกต่างออกไป
 
-**A Function Declaration can be called earlier than it is defined.**
+**การประกาศฟังก์ชันสามารถเรียกใช้ได้ก่อนที่จะมีการประกาศ**
 
-For example, a global Function Declaration is visible in the whole script, no matter where it is.
+ยกตัวอย่างเช่น การประกาศฟังก์ชันระดับโกลบอลจะมองเห็นได้ทั่วทั้งสคริปต์ ไม่ว่าจะอยู่ตรงไหน
 
-That's due to internal algorithms. When JavaScript prepares to run the script, it first looks for global Function Declarations in it and creates the functions. We can think of it as an "initialization stage".
+นั่นเป็นเพราะอัลกอริทึมภายใน เมื่อ JavaScript เตรียมตัวที่จะรันสคริปต์ มันจะมองหา การประกาศฟังก์ชันระดับโกลบอลก่อนเป็นอันดับแรก แล้วทำการสร้างฟังก์ชันเหล่านั้นขึ้น เราอาจมองเป็น "ขั้นตอนการเตรียมการ"
 
-And after all Function Declarations are processed, the code is executed. So it has access to these functions.
+และหลังจากประมวลผล การประกาศฟังก์ชันทั้งหมดแล้ว จึงค่อยประมวลผลโค้ดตามปกติ ดังนั้นโค้ดจึงสามารถเข้าถึงฟังก์ชันเหล่านั้นได้
 
-For example, this works:
+ตัวอย่างเช่น โค้ดนี้สามารถทำงานได้:
 
 ```js run refresh untrusted
 *!*
@@ -231,34 +252,34 @@ function sayHi(name) {
 }
 ```
 
-The Function Declaration `sayHi` is created when JavaScript is preparing to start the script and is visible everywhere in it.
+การประกาศฟังก์ชัน `sayHi` ถูกสร้างขึ้นตอนที่ JavaScript กำลังเตรียมจะเริ่มสคริปต์ และมองเห็นได้ทั่วทั้งสคริปต์
 
-...If it were a Function Expression, then it wouldn't work:
+...แต่ถ้าเป็น นิพจน์ฟังก์ชันก็จะใช้งานไม่ได้:
 
 ```js run refresh untrusted
 *!*
 sayHi("John"); // error!
 */!*
 
-let sayHi = function(name) {  // (*) no magic any more
+let sayHi = function(name) {  // (*) ไม่มีเวทมนต์อีกต่อไป
   alert( `Hello, ${name}` );
 };
 ```
 
-Function Expressions are created when the execution reaches them. That would happen only in the line `(*)`. Too late.
+นิพจน์ฟังก์ชันจะถูกสร้างก็ต่อเมื่อการประมวลผลมาถึงมัน ซึ่งจะเกิดขึ้นที่บรรทัด `(*)` เท่านั้น ช้าไปแล้ว
 
-Another special feature of Function Declarations is their block scope.
+อีกคุณสมบัติพิเศษของ การประกาศฟังก์ชันคือขอบเขตแบบบล็อก
 
-**In strict mode, when a Function Declaration is within a code block, it's visible everywhere inside that block. But not outside of it.**
+**ในโหมดเข้มงวด เมื่อการประกาศฟังก์ชันอยู่ภายในบล็อกโค้ด มันจะมองเห็นได้ทั่วภายในบล็อกนั้น แต่มองไม่เห็นภายนอกบล็อก**
 
-For instance, let's imagine that we need to declare a function `welcome()` depending on the `age` variable that we get during runtime. And then we plan to use it some time later.
+ยกตัวอย่าง สมมติเราต้องการประกาศฟังก์ชัน `welcome()` โดยขึ้นอยู่กับค่าตัวแปร `age` ที่ได้มาระหว่างรันไทม์ และเราวางแผนจะใช้มันในภายหลัง
 
-If we use Function Declaration, it won't work as intended:
+หากใช้ การประกาศฟังก์ชันมันจะไม่ทำงานตามที่ตั้งใจ:
 
 ```js run
 let age = prompt("What is your age?", 18);
 
-// conditionally declare a function
+// ประกาศฟังก์ชันตามเงื่อนไข
 if (age < 18) {
 
   function welcome() {
@@ -273,16 +294,19 @@ if (age < 18) {
 
 }
 
-// ...use it later
+// ...ใช้ในภายหลัง
 *!*
 welcome(); // Error: welcome is not defined
 */!*
 ```
 
-That's because a Function Declaration is only visible inside the code block in which it resides.
+เราจะทำอย่างไรเพื่อให้ `welcome` มองเห็นได้จากภายนอก `if`?
 
-Here's another example:
+วิธีที่ถูกต้องคือการใช้นิพจน์ฟังก์ชันและกำหนดค่า `welcome` ให้กับตัวแปรที่ประกาศไว้นอก `if` ซึ่งมีการมองเห็นที่เหมาะสม
 
+<<<<<<< HEAD
+โค้ดนี้ทำงานตามที่ตั้งใจไว้:
+=======
 ```js run
 let age = 16; // take 16 as an example
 
@@ -319,6 +343,7 @@ What can we do to make `welcome` visible outside of `if`?
 The correct approach would be to use a Function Expression and assign `welcome` to the variable that is declared outside of `if` and has the proper visibility.
 
 This code works as intended:
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
 ```js run
 let age = prompt("What is your age?", 18);
@@ -340,11 +365,11 @@ if (age < 18) {
 }
 
 *!*
-welcome(); // ok now
+welcome(); // ตอนนี้ใช้ได้แล้ว
 */!*
 ```
 
-Or we could simplify it even further using a question mark operator `?`:
+หรือเราสามารถทำให้มันเรียบง่ายขึ้นอีกโดยใช้ตัวดำเนินการเครื่องหมายคำถาม `?`:
 
 ```js run
 let age = prompt("What is your age?", 18);
@@ -354,27 +379,32 @@ let welcome = (age < 18) ?
   function() { alert("Greetings!"); };
 
 *!*
-welcome(); // ok now
+welcome(); // ตอนนี้ใช้ได้แล้ว
 */!*
 ```
 
 
+<<<<<<< HEAD
+```smart header="เมื่อไหร่ควรเลือกใช้การประกาศฟังก์ชัน หรือนิพจน์ฟังก์ชัน?"
+โดยหลักการทั่วไป เมื่อเราต้องการประกาศฟังก์ชัน สิ่งแรกที่ควรพิจารณาคือใช้ไวยากรณ์แบบการประกาศฟังก์ชัน เพราะมันให้อิสระในการจัดวางโค้ดมากกว่า เนื่องจากเราสามารถเรียกใช้ฟังก์ชันเหล่านั้นได้ก่อนที่จะมีการประกาศ
+=======
 ```smart header="When to choose Function Declaration versus Function Expression?"
 As a rule of thumb, when we need to declare a function, the first thing to consider is Function Declaration syntax. It gives more freedom in how to organize our code, because we can call such functions before they are declared.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-That's also better for readability, as it's easier to look up `function f(…) {…}` in the code than `let f = function(…) {…};`. Function Declarations are more "eye-catching".
+นอกจากนี้ยังอ่านทำความเข้าใจง่ายกว่า เพราะมองหา `function f(…) {…}` ในโค้ดได้ง่ายกว่า `let f = function(…) {…};` การประกาศฟังก์ชันนั้น "โดดเด่นมากกว่า"
 
-...But if a Function Declaration does not suit us for some reason, or we need a conditional declaration (we've just seen an example), then Function Expression should be used.
+...แต่ถ้าการประกาศฟังก์ชันไม่เหมาะสมกับเราด้วยเหตุผลบางประการ หรือเราต้องการประกาศแบบมีเงื่อนไข (เราเพิ่งเห็นตัวอย่างไป) ควรใช้นิพจน์ฟังก์ชันแทน
 ```
 
-## Summary
+## สรุป
 
-- Functions are values. They can be assigned, copied or declared in any place of the code.
-- If the function is declared as a separate statement in the main code flow, that's called a "Function Declaration".
-- If the function is created as a part of an expression, it's called a "Function Expression".
-- Function Declarations are processed before the code block is executed. They are visible everywhere in the block.
-- Function Expressions are created when the execution flow reaches them.
+- ฟังก์ชันคือค่า สามารถกำหนดค่า คัดลอก หรือประกาศไว้ที่ใดก็ได้ในโค้ด
+- ถ้าฟังก์ชันถูกประกาศเป็นประโยคแยกต่างหากในลำดับการทำงานหลักของโค้ด เรียกว่า "การประกาศฟังก์ชัน"
+- ถ้าฟังก์ชันถูกสร้างขึ้นเป็นส่วนหนึ่งของนิพจน์ เรียกว่า "นิพจน์ฟังก์ชัน"
+- การประกาศฟังก์ชัน (Function Declaration) จะถูกประมวลผลก่อนที่บล็อกโค้ดจะเริ่มทำงาน ทำให้มองเห็นได้ทั่วทั้งบล็อก  
+- นิพจน์ฟังก์ชัน (Function Expression) จะถูกสร้างขึ้นเมื่อลำดับการทำงานมาถึงจุดที่มันอยู่
 
-In most cases when we need to declare a function, a Function Declaration is preferable, because it is visible prior to the declaration itself. That gives us more flexibility in code organization, and is usually more readable.
+ในเกือบทุกกรณีที่เราต้องการประกาศฟังก์ชัน (Function Declaration) เป็นตัวเลือกที่เหมาะสมกว่า เพราะมันมองเห็นได้ก่อนการประกาศจริงๆ ทำให้เรามีความยืดหยุ่นในการจัดวางโค้ดมากขึ้น และมักจะอ่านเข้าใจง่ายกว่า
 
-So we should use a Function Expression only when a Function Declaration is not fit for the task. We've seen a couple of examples of that in this chapter, and will see more in the future.
+ดังนั้นเราควรใช้นิพจน์ฟังก์ชันเฉพาะเมื่อการประกาศฟังก์ชันไม่เหมาะสมกับงาน เราได้เห็นตัวอย่างไปบ้างแล้วในบทนี้ และจะเห็นเพิ่มเติมในอนาคต
diff --git a/1-js/02-first-steps/17-arrow-functions-basics/article.md b/1-js/02-first-steps/17-arrow-functions-basics/article.md
index 50c0d475d..1ef3a3e1b 100644
--- a/1-js/02-first-steps/17-arrow-functions-basics/article.md
+++ b/1-js/02-first-steps/17-arrow-functions-basics/article.md
@@ -1,16 +1,16 @@
-# Arrow functions, the basics
+# ฟังก์ชันลูกศร (Arrow functions) ข้อมูลพื้นฐาน
 
-There's another very simple and concise syntax for creating functions, that's often better than Function Expressions.
+มีไวยากรณ์ที่เรียบง่ายและกระชับอีกแบบหนึ่งในการสร้างฟังก์ชัน ซึ่งมักจะดีกว่า Function Expression
 
-It's called "arrow functions", because it looks like this:
+เรียกว่า "ฟังก์ชันลูกศร" เพราะมันดูแบบนี้:
 
 ```js
 let func = (arg1, arg2, ..., argN) => expression;
 ```
 
-This creates a function `func` that accepts arguments `arg1..argN`, then evaluates the `expression` on the right side with their use and returns its result.
+นี่จะสร้างฟังก์ชัน `func` ที่รับอาร์กิวเมนต์ `arg1..argN` จากนั้นจะประเมินค่า `expression` ทางด้านขวาโดยใช้อาร์กิวเมนต์เหล่านั้น แล้วส่งคืนผลลัพธ์
 
-In other words, it's the shorter version of:
+อีกนัยหนึ่ง มันคือเวอร์ชันที่สั้นกว่าของ:
 
 ```js
 let func = function(arg1, arg2, ..., argN) {
@@ -18,12 +18,12 @@ let func = function(arg1, arg2, ..., argN) {
 };
 ```
 
-Let's see a concrete example:
+มาดูตัวอย่างที่เป็นรูปธรรมกัน:
 
 ```js run
 let sum = (a, b) => a + b;
 
-/* This arrow function is a shorter form of:
+/* ฟังก์ชันลูกศรนี้เป็นรูปแบบสั้นกว่าของ:
 
 let sum = function(a, b) {
   return a + b;
@@ -33,22 +33,26 @@ let sum = function(a, b) {
 alert( sum(1, 2) ); // 3
 ```
 
-As you can see, `(a, b) => a + b` means a function that accepts two arguments named `a` and `b`. Upon the execution, it evaluates the expression `a + b` and returns the result.
+ดังที่เห็น `(a, b) => a + b` หมายถึงฟังก์ชันที่รับอาร์กิวเมนต์สองตัว ชื่อ `a` และ `b` เมื่อรันฟังก์ชัน มันจะประเมินนิพจน์ `a + b` และส่งคืนผลลัพธ์
 
-- If we have only one argument, then parentheses around parameters can be omitted, making that even shorter.
+- ถ้าเรามีอาร์กิวเมนต์เพียงตัวเดียว วงเล็บล้อมรอบพารามิเตอร์สามารถละได้ ทำให้มันสั้นลงไปอีก
 
-    For example:
+    ยกตัวอย่างเช่น:
 
     ```js run
     *!*
     let double = n => n * 2;
-    // roughly the same as: let double = function(n) { return n * 2 }
+    // คล้ายๆ กับ: let double = function(n) { return n * 2 }
     */!*
 
     alert( double(3) ); // 6
     ```
 
+<<<<<<< HEAD
+- ถ้าไม่มีอาร์กิวเมนต์เลย วงเล็บจะว่างเปล่า แต่ต้องใส่ไว้:
+=======
 - If there are no arguments, parentheses are empty, but they must be present:
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
     ```js run
     let sayHi = () => alert("Hello!");
@@ -56,9 +60,9 @@ As you can see, `(a, b) => a + b` means a function that accepts two arguments na
     sayHi();
     ```
 
-Arrow functions can be used in the same way as Function Expressions.
+ฟังก์ชันลูกศรสามารถใช้ได้ในลักษณะเดียวกับ Function Expression
 
-For instance, to dynamically create a function:
+ยกตัวอย่างเช่น สำหรับการสร้างฟังก์ชันแบบไดนามิก:
 
 ```js run
 let age = prompt("What is your age?", 18);
@@ -70,42 +74,55 @@ let welcome = (age < 18) ?
 welcome();
 ```
 
-Arrow functions may appear unfamiliar and not very readable at first, but that quickly changes as the eyes get used to the structure.
+ฟังก์ชันลูกศรอาจดูไม่คุ้นตาและอ่านยากในตอนแรก แต่พอตาชินกับโครงสร้างแล้ว ก็จะเปลี่ยนไปอย่างรวดเร็ว
 
-They are very convenient for simple one-line actions, when we're just too lazy to write many words.
+มันสะดวกมากสำหรับการทำงานง่ายๆ บรรทัดเดียว ในยามที่เรารู้สึกขี้เกียจเขียนโค้ดยาวๆ
 
-## Multiline arrow functions
+## ฟังก์ชันลูกศรแบบหลายบรรทัด
 
+<<<<<<< HEAD
+ฟังก์ชันลูกศรที่เราเห็นมาจนถึงตอนนี้ค่อนข้างเรียบง่าย โดยรับอาร์กิวเมนต์จากด้านซ้ายของ `=>` ประเมินค่า และส่งคืนนิพจน์ทางขวาโดยใช้อาร์กิวเมนต์เหล่านั้น
+
+บางครั้งเราต้องการฟังก์ชันที่ซับซ้อนกว่านั้น ที่มีหลายนิพจน์และประโยค ในกรณีนี้ เราสามารถครอบมันด้วยวงเล็บปีกกาได้ ความแตกต่างหลักคือ การใช้วงเล็บปีกกาต้องมีคำสั่ง `return` ภายในเพื่อส่งค่ากลับ (เหมือนฟังก์ชันปกติ)
+=======
 The arrow functions that we've seen so far were very simple. They took arguments from the left of `=>`, evaluated and returned the right-side expression with them.
 
 Sometimes we need a more complex function, with multiple expressions and statements. In that case, we can enclose them in curly braces. The major difference is that curly braces require a `return` within them to return a value (just like a regular function does).
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-Like this:
+ตัวอย่างเช่น:
 
 ```js run
-let sum = (a, b) => {  // the curly brace opens a multiline function
+let sum = (a, b) => {  // วงเล็บปีกกาเปิดฟังก์ชันแบบหลายบรรทัด
   let result = a + b;
 *!*
-  return result; // if we use curly braces, then we need an explicit "return"
+  return result; // ถ้าเราใช้วงเล็บปีกกา ต้องใส่ "return" อย่างชัดเจน
 */!*
 };
 
 alert( sum(1, 2) ); // 3
 ```
 
-```smart header="More to come"
-Here we praised arrow functions for brevity. But that's not all!
+```smart header="ยังมีอีกมากมาย"
+ที่ผ่านมาเราชื่นชมฟังก์ชันลูกศรในเรื่องความกระชับ แต่นั่นไม่ใช่ทั้งหมด!
 
-Arrow functions have other interesting features.
+ฟังก์ชันลูกศรยังมีคุณสมบัติที่น่าสนใจอื่นๆ อีก
 
-To study them in-depth, we first need to get to know some other aspects of JavaScript, so we'll return to arrow functions later in the chapter <info:arrow-functions>.
+เพื่อศึกษาสิ่งเหล่านั้นอย่างลึกซึ้ง เราจำเป็นต้องมีความรู้เกี่ยวกับแง่มุมอื่นๆ ของ JavaScript ก่อน ดังนั้นเราจะกลับมาพูดถึงฟังก์ชันลูกศรอีกครั้งในบท <info:arrow-functions>
 
-For now, we can already use arrow functions for one-line actions and callbacks.
+สำหรับตอนนี้ เราสามารถใช้ฟังก์ชันลูกศรกับการทำงานแบบบรรทัดเดียวและฟังก์ชันคอลแบ็กได้แล้ว
 ```
 
-## Summary
+## สรุป
+
+<<<<<<< HEAD
+ฟังก์ชันลูกศรนั้นใช้สะดวกสำหรับการกระทำง่ายๆ โดยเฉพาะอย่างยิ่งแบบบรรทัดเดียว มีสองรูปแบบดังนี้:
 
+1. ไม่มีวงเล็บปีกกา: `(...args) => expression` -- ทางขวาเป็นนิพจน์: ฟังก์ชันจะประเมินค่าและส่งคืนผลลัพธ์ สามารถละวงเล็บได้ถ้ามีอาร์กิวเมนต์เพียงตัวเดียว เช่น `n => n*2`
+2. มีวงเล็บปีกกา: `(...args) => { body }` -- วงเล็บปีกกาช่วยให้เราเขียนหลายคำสั่งภายในฟังก์ชันได้ แต่เราต้องใส่ `return` อย่างชัดเจนเพื่อส่งอะไรบางอย่างกลับ
+=======
 Arrow functions are handy for simple actions, especially for one-liners. They come in two flavors:
 
 1. Without curly braces: `(...args) => expression` -- the right side is an expression: the function evaluates it and returns the result. Parentheses can be omitted, if there's only a single argument, e.g. `n => n*2`.
 2. With curly braces: `(...args) => { body }` -- brackets allow us to write multiple statements inside the function, but we need an explicit `return` to return something.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
diff --git a/1-js/02-first-steps/18-javascript-specials/article.md b/1-js/02-first-steps/18-javascript-specials/article.md
index e7ddacac4..d84eb77e0 100644
--- a/1-js/02-first-steps/18-javascript-specials/article.md
+++ b/1-js/02-first-steps/18-javascript-specials/article.md
@@ -1,23 +1,23 @@
-# JavaScript specials
+# ความพิเศษของ JavaScript
 
-This chapter briefly recaps the features of JavaScript that we've learned by now, paying special attention to subtle moments.
+บทนี้จะสรุปย่อคุณลักษณะของ JavaScript ที่เราได้เรียนมาจนถึงตอนนี้ โดยให้ความสนใจเป็นพิเศษกับจุดละเอียดอ่อน
 
-## Code structure
+## โครงสร้างโค้ด
 
-Statements are delimited with a semicolon:
+คำสั่งจะถูกคั่นด้วยเครื่องหมายอัฒภาค (semicolon):
 
 ```js run no-beautify
 alert('Hello'); alert('World');
 ```
 
-Usually, a line-break is also treated as a delimiter, so that would also work:
+โดยทั่วไปแล้ว การขึ้นบรรทัดใหม่ก็ถือเป็นตัวคั่นเช่นกัน ดังนั้นแบบนี้ก็ใช้ได้เช่นกัน:
 
 ```js run no-beautify
 alert('Hello')
 alert('World')
 ```
 
-That's called "automatic semicolon insertion". Sometimes it doesn't work, for instance:
+เรียกว่า "การแทรกเครื่องหมายอัฒภาคอัตโนมัติ" แต่บางครั้งก็ไม่ทำงาน ยกตัวอย่างเช่น:
 
 ```js run
 alert("There will be an error after this message")
@@ -25,27 +25,27 @@ alert("There will be an error after this message")
 [1, 2].forEach(alert)
 ```
 
-Most codestyle guides agree that we should put a semicolon after each statement.
+คู่มือรูปแบบการเขียนโค้ดส่วนใหญ่เห็นพ้องกันว่า เราควรใส่เครื่องหมายอัฒภาคหลังแต่ละคำสั่ง
 
-Semicolons are not required after code blocks `{...}` and syntax constructs with them like loops:
+ไม่จำเป็นต้องใช้เครื่องหมายอัฒภาคหลังบล็อกโค้ด `{...}` และโครงสร้างทางไวยากรณ์ที่มีบล็อกเหล่านั้น เช่น ลูป:
 
 ```js
 function f() {
-  // no semicolon needed after function declaration
+  // ไม่ต้องใส่เครื่องหมายอัฒภาคหลังการประกาศฟังก์ชัน
 }
 
 for(;;) {
-  // no semicolon needed after the loop
+  // ไม่ต้องใส่เครื่องหมายอัฒภาคหลังลูป
 }
 ```
 
-...But even if we can put an "extra" semicolon somewhere, that's not an error. It will be ignored.
+...แต่แม้ว่าเราจะใส่เครื่องหมายอัฒภาค "เพิ่มเติม" ไว้ที่ใดสักแห่ง ก็ไม่ถือเป็นข้อผิดพลาด มันจะถูกละเว้น
 
-More in: <info:structure>.
+อ่านเพิ่มเติมได้ที่: <info:structure>
 
-## Strict mode
+## โหมดเข้มงวด (Strict mode)
 
-To fully enable all features of modern JavaScript, we should start scripts with `"use strict"`.
+เพื่อเปิดใช้งานคุณลักษณะทั้งหมดของ JavaScript สมัยใหม่อย่างเต็มที่ เราควรเริ่มต้นสคริปต์ด้วย `"use strict"`
 
 ```js
 'use strict';
@@ -53,57 +53,70 @@ To fully enable all features of modern JavaScript, we should start scripts with
 ...
 ```
 
-The directive must be at the top of a script or at the beginning of a function body.
+คำสั่งนี้จะต้องอยู่ที่ด้านบนสุดของสคริปต์ หรือที่จุดเริ่มต้นของ function body
 
+<<<<<<< HEAD
+หากไม่มี `"use strict"` ทุกอย่างก็ยังคงทำงานได้ แต่คุณลักษณะบางอย่างจะทำงานในแบบเก่าๆ "แบบเข้ากันได้" โดยทั่วไปเรามักจะต้องการพฤติกรรมแบบสมัยใหม่มากกว่า
+=======
 Without `"use strict"`, everything still works, but some features behave in the old-fashioned, "compatible" way. We'd generally prefer the modern behavior.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-Some modern features of the language (like classes that we'll study in the future) enable strict mode implicitly.
+คุณลักษณะสมัยใหม่บางอย่างของภาษา (เช่น คลาส ซึ่งเราจะศึกษาในอนาคต) จะเปิดใช้งานโหมดเข้มงวดโดยอัตโนมัติ 
 
-More in: <info:strict-mode>.
+อ่านเพิ่มเติมได้ที่: <info:strict-mode>
 
-## Variables
+## ตัวแปร
 
-Can be declared using:
+สามารถประกาศตัวแปรได้โดยใช้:
 
 - `let`
-- `const` (constant, can't be changed)
-- `var` (old-style, will see later)
+- `const` (ค่าคงที่ ไม่สามารถเปลี่ยนแปลงได้)
+- `var` (แบบเก่า จะได้เห็นในภายหลัง)
 
-A variable name can include:
-- Letters and digits, but the first character may not be a digit.
-- Characters `$` and `_` are normal, on par with letters.
-- Non-Latin alphabets and hieroglyphs are also allowed, but commonly not used.
+ชื่อตัวแปรสามารถประกอบด้วย:
+- ตัวอักษรและตัวเลข แต่ตัวแรกจะต้องไม่ใช่ตัวเลข
+- อักขระ `$` และ `_` เป็นอักขระปกติ เทียบเท่ากับตัวอักษร
+- ตัวอักษรที่ไม่ใช่ละตินและอักษรอียิปต์โบราณก็สามารถใช้ได้ แต่ไม่ค่อยนิยมใช้
 
-Variables are dynamically typed. They can store any value:
+ตัวแปรมีการกำหนดชนิดข้อมูลแบบไดนามิก สามารถเก็บค่าใดๆ ก็ได้:
 
 ```js
 let x = 5;
 x = "John";
 ```
 
-There are 8 data types:
+มีชนิดข้อมูลทั้งหมด 8 ชนิด:
 
-- `number` for both floating-point and integer numbers,
-- `bigint` for integer numbers of arbitrary length,
-- `string` for strings,
-- `boolean` for logical values: `true/false`,
-- `null` -- a type with a single value `null`, meaning "empty" or "does not exist",
-- `undefined` -- a type with a single value `undefined`, meaning "not assigned",
-- `object` and `symbol` -- for complex data structures and unique identifiers, we haven't learnt them yet.
+- `number` สำหรับตัวเลขทั้งจำนวนจริงและจำนวนเต็ม
+- `bigint` สำหรับจำนวนเต็มที่มีความยาวตามต้องการ
+- `string` สำหรับข้อความ
+- `boolean` สำหรับค่าตรรกะ: `true/false`
+- `null` -- ชนิดข้อมูลที่มีค่าเดียวคือ `null` หมายถึง "ว่างเปล่า" หรือ "ไม่มีอยู่"
+- `undefined` -- ชนิดข้อมูลที่มีค่าเดียวคือ `undefined` หมายถึง "ยังไม่ได้กำหนดค่า"
+- `object` และ `symbol` -- สำหรับโครงสร้างข้อมูลที่ซับซ้อน และตัวระบุที่ไม่ซ้ำกัน เรายังไม่ได้เรียนรู้เกี่ยวกับสิ่งเหล่านี้
 
-The `typeof` operator returns the type for a value, with two exceptions:
+ตัวดำเนินการ `typeof` จะคืนค่าชนิดข้อมูลของค่านั้นๆ โดยมีข้อยกเว้นสองกรณี:
 ```js
-typeof null == "object" // error in the language
-typeof function(){} == "function" // functions are treated specially
+typeof null == "object" // ข้อผิดพลาดในภาษา
+typeof function(){} == "function" // ฟังก์ชันจะถูกจัดการเป็นพิเศษ
 ```
 
-More in: <info:variables> and <info:types>.
+อ่านเพิ่มเติมได้ที่: <info:variables> และ <info:types>
 
-## Interaction
+## การโต้ตอบ
 
-We're using a browser as a working environment, so basic UI functions will be:
+เนื่องจากเรากำลังใช้เบราว์เซอร์เป็นสภาพแวดล้อมในการทำงาน ฟังก์ชัน UI พื้นฐานจึงประกอบด้วย:
 
 [`prompt(question, [default])`](https://developer.mozilla.org/en-US/docs/Web/API/Window/prompt)
+<<<<<<< HEAD
+: ถาม `question` และคืนค่าสิ่งที่ผู้ใช้ป้อนเข้ามา หรือ `null` หากผู้ใช้คลิก "ยกเลิก"
+
+[`confirm(question)`](https://developer.mozilla.org/en-US/docs/Web/API/Window/confirm)
+: ถาม `question` และแนะนำให้เลือกระหว่าง ตกลง และ ยกเลิก ทางเลือกจะถูกส่งคืนเป็น `true/false`
+
+[`alert(message)`](https://developer.mozilla.org/en-US/docs/Web/API/Window/alert)
+: แสดงผล `message`
+=======
 : Ask a `question`, and return either what the visitor entered or `null` if they clicked "cancel".
 
 [`confirm(question)`](https://developer.mozilla.org/en-US/docs/Web/API/Window/confirm)
@@ -111,10 +124,11 @@ We're using a browser as a working environment, so basic UI functions will be:
 
 [`alert(message)`](https://developer.mozilla.org/en-US/docs/Web/API/Window/alert)
 : Output a `message`.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-All these functions are *modal*, they pause the code execution and prevent the visitor from interacting with the page until they answer.
+ฟังก์ชันเหล่านี้ทั้งหมดเป็นแบบ *modal* หมายความว่าจะหยุดการทำงานของโค้ด และป้องกันไม่ให้ผู้ใช้โต้ตอบกับหน้าเว็บจนกว่าจะตอบคำถาม
 
-For instance:
+ตัวอย่างเช่น:
 
 ```js run
 let userName = prompt("Your name?", "Alice");
@@ -124,61 +138,66 @@ alert( "Visitor: " + userName ); // Alice
 alert( "Tea wanted: " + isTeaWanted ); // true
 ```
 
-More in: <info:alert-prompt-confirm>.
+อ่านเพิ่มเติมได้ที่: <info:alert-prompt-confirm>
 
-## Operators
+## ตัวดำเนินการ (Operators)
 
-JavaScript supports the following operators:
+JavaScript รองรับตัวดำเนินการดังต่อไปนี้:
 
-Arithmetical
-: Regular: `* + - /`, also `%` for the remainder and `**` for power of a number.
+ทางคณิตศาสตร์
+: ปกติ: `* + - /` รวมถึง `%` สำหรับการหารเอาเศษ และ `**` สำหรับการยกกำลัง
 
-    The binary plus `+` concatenates strings. And if any of the operands is a string, the other one is converted to string too:
+    ตัวดำเนินการบวก `+` แบบสองตัวถูกกระทำจะเชื่อมต่อสตริง และถ้าตัวใดตัวหนึ่งเป็นสตริง อีกตัวก็จะถูกแปลงเป็นสตริงด้วยเช่นกัน:
 
     ```js run
     alert( '1' + 2 ); // '12', string
     alert( 1 + '2' ); // '12', string
     ```
 
-Assignments
-: There is a simple assignment: `a = b` and combined ones like `a *= 2`.
+การกำหนดค่า
+: มีการกำหนดค่าธรรมดา: `a = b` และแบบรวมต่างๆ เช่น `a *= 2`
 
+<<<<<<< HEAD
+การดำเนินการระดับบิต  
+: ตัวดำเนินการระดับบิตจะทำงานกับจำนวนเต็ม 32 บิตที่ระดับบิตต่ำสุด: ดูที่ [docs](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Expressions_and_Operators#bitwise_operators) เมื่อต้องการ
+=======
 Bitwise
 : Bitwise operators work with 32-bit integers at the lowest, bit-level: see the [docs](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Expressions_and_Operators#bitwise_operators) when they are needed.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-Conditional
-: The only operator with three parameters: `cond ? resultA : resultB`. If `cond` is truthy, returns `resultA`, otherwise `resultB`.
+แบบมีเงื่อนไข
+: ตัวดำเนินการเพียงตัวเดียวที่มีสามพารามิเตอร์: `cond ? resultA : resultB` ถ้า `cond` เป็น truthy จะคืนค่า `resultA` ไม่เช่นนั้นจะคืน `resultB`
 
-Logical operators
-: Logical AND `&&` and OR `||` perform short-circuit evaluation and then return the value where it stopped (not necessary `true`/`false`). Logical NOT `!` converts the operand to boolean type and returns the inverse value.
+ตัวดำเนินการทางตรรกะ
+: AND ตรรกะ `&&` และ OR ตรรกะ `||` จะทำการประเมินแบบลัดวงจรและคืนค่าที่มันหยุด (ไม่จำเป็นต้องเป็น `true/false`) NOT ตรรกะ `!` แปลงตัวถูกกระทำเป็น boolean และคืนค่าตรงข้าม
 
-Nullish coalescing operator
-: The `??` operator provides a way to choose a defined value from a list of variables. The result of `a ?? b` is `a` unless it's `null/undefined`, then `b`.
+ตัวดำเนินการ Nullish coalescing  
+: ตัวดำเนินการ `??` ให้วิธีเลือกค่าที่ถูกกำหนดจากรายการตัวแปร ผลลัพธ์ของ `a ?? b` คือ `a` เว้นแต่มันจะเป็น `null/undefined` จึงจะเป็น `b`
 
-Comparisons
-: Equality check `==` for values of different types converts them to a number (except `null` and `undefined` that equal each other and nothing else), so these are equal:
+การเปรียบเทียบ
+: การตรวจสอบความเท่ากัน `==` สำหรับค่าที่มีชนิดต่างกันจะแปลงเป็นตัวเลข (ยกเว้น `null` และ `undefined` ซึ่งเท่ากันและไม่เท่ากับอะไรอื่น) ดังนั้นพวกนี้จึงเท่ากัน:
 
     ```js run
     alert( 0 == false ); // true
     alert( 0 == '' ); // true
     ```
 
-    Other comparisons convert to a number as well.
+    การเปรียบเทียบอื่นๆ ก็จะแปลงเป็นตัวเลขด้วยเช่นกัน
 
-    The strict equality operator `===` doesn't do the conversion: different types always mean different values for it.
+    ตัวดำเนินการเปรียบเทียบความเท่ากันแบบเข้มงวด `===` จะไม่แปลงค่า: ชนิดที่ต่างกันเสมอไปจะถือว่าค่าไม่เท่ากัน
 
-    Values `null` and `undefined` are special: they equal `==` each other and don't equal anything else.
+    ค่า `null` และ `undefined` เป็นพิเศษ: พวกมันเท่ากับ `==` กันเองและไม่เท่ากับอะไรอื่น
 
-    Greater/less comparisons compare strings character-by-character, other types are converted to a number.
+    การเปรียบเทียบมากกว่า/น้อยกว่าจะเปรียบเทียบสตริงทีละอักขระ ส่วนชนิดอื่นจะแปลงเป็นตัวเลข
 
-Other operators
-: There are few others, like a comma operator.
+ตัวดำเนินการอื่นๆ
+: มีอีกไม่กี่ตัว เช่น comma operator
 
-More in: <info:operators>, <info:comparison>, <info:logical-operators>, <info:nullish-coalescing-operator>.
+อ่านเพิ่มเติมได้ที่: <info:operators>, <info:comparison>, <info:logical-operators>, <info:nullish-coalescing-operator>
 
-## Loops
+## ลูป
 
-- We covered 3 types of loops:
+- เราได้ครอบคลุมลูป 3 ประเภท:
 
     ```js
     // 1
@@ -197,25 +216,25 @@ More in: <info:operators>, <info:comparison>, <info:logical-operators>, <info:nu
     }
     ```
 
-- The variable declared in `for(let...)` loop is visible only inside the loop. But we can also omit `let` and reuse an existing variable.
-- Directives `break/continue` allow to exit the whole loop/current iteration. Use labels to break nested loops.
+- ตัวแปรที่ประกาศในลูป `for(let...)` จะมองเห็นได้เฉพาะภายในลูปเท่านั้น แต่เราสามารถละเว้น `let` และนำตัวแปรที่มีอยู่แล้วมาใช้ซ้ำได้
+- คำสั่ง `break/continue` ช่วยให้ออกจากลูปทั้งหมด/ออกจากรอบปัจจุบัน ใช้ label เพื่อออกจากลูปที่ซ้อนกันได้
 
-Details in: <info:while-for>.
+รายละเอียดใน: <info:while-for>
 
-Later we'll study more types of loops to deal with objects.
+ในภายหลังเราจะศึกษาลูปชนิดอื่นๆ เพิ่มเติมเพื่อจัดการกับออบเจ็กต์
 
-## The "switch" construct
+## โครงสร้าง "switch" 
 
-The "switch" construct can replace multiple `if` checks. It uses `===` (strict equality) for comparisons.
+โครงสร้าง "switch" สามารถใช้แทนการตรวจสอบ `if` หลายครั้งได้ มันใช้ `===` (ตรวจสอบความเท่ากันแบบเข้มงวด) ในการเปรียบเทียบ
 
-For instance:
+ตัวอย่างเช่น:
 
 ```js run
 let age = prompt('Your age?', 18);
 
 switch (age) {
   case 18:
-    alert("Won't work"); // the result of prompt is a string, not a number
+    alert("Won't work"); // ผลลัพธ์จาก prompt เป็นสตริง ไม่ใช่ตัวเลข
     break;
 
   case "18":
@@ -227,13 +246,13 @@ switch (age) {
 }
 ```
 
-Details in: <info:switch>.
+รายละเอียดใน: <info:switch>
 
-## Functions
+## ฟังก์ชัน
 
-We covered three ways to create a function in JavaScript:
+เราได้ครอบคลุมวิธีการสร้างฟังก์ชันใน JavaScript สามแบบ:
 
-1. Function Declaration: the function in the main code flow
+1. Function Declaration: ฟังก์ชันในลำดับการทำงานหลักของโค้ด
 
     ```js
     function sum(a, b) {
@@ -243,7 +262,7 @@ We covered three ways to create a function in JavaScript:
     }
     ```
 
-2. Function Expression: the function in the context of an expression
+2. Function Expression: ฟังก์ชันในบริบทของนิพจน์
 
     ```js
     let sum = function(a, b) {
@@ -256,29 +275,32 @@ We covered three ways to create a function in JavaScript:
 3. Arrow functions:
 
     ```js
+<<<<<<< HEAD
+    // นิพจน์ทางด้านขวา
+=======
     // expression on the right side
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
     let sum = (a, b) => a + b;
 
-    // or multi-line syntax with { ... }, need return here:
+    // หรือใช้ไวยากรณ์แบบหลายบรรทัดด้วย { ... }, ต้องใส่ return ที่นี่:
     let sum = (a, b) => {
       // ...
       return a + b;
     }
 
-    // without arguments
+    // ไม่มีอาร์กิวเมนต์
     let sayHi = () => alert("Hello");
 
-    // with a single argument
+    // มีอาร์กิวเมนต์เดียว
     let double = n => n * 2;
     ```
 
+- ฟังก์ชันอาจมีตัวแปรภายใน (local variables): คือตัวแปรที่ประกาศภายในบอดี้หรือในรายการพารามิเตอร์ของมัน ตัวแปรเหล่านี้จะมองเห็นได้เฉพาะภายในฟังก์ชัน
+- พารามิเตอร์สามารถกำหนดค่าเริ่มต้นได้: `function sum(a = 1, b = 2) {...}`
+- ฟังก์ชันจะคืนค่าอะไรบางอย่างเสมอ หากไม่มีประโยค `return` ผลลัพธ์จะเป็น `undefined`
 
-- Functions may have local variables: those declared inside its body or its parameter list. Such variables are only visible inside the function.
-- Parameters can have default values: `function sum(a = 1, b = 2) {...}`.
-- Functions always return something. If there's no `return` statement, then the result is `undefined`.
-
-Details: see <info:function-basics>, <info:arrow-functions-basics>.
+รายละเอียด: ดูที่ <info:function-basics>, <info:arrow-functions-basics>
 
-## More to come
+## ในอนาคตยังมีอีกมาก
 
-That was a brief list of JavaScript features. As of now we've studied only basics. Further in the tutorial you'll find more specials and advanced features of JavaScript.
+นี่เป็นเพียงรายการโดยย่อของคุณลักษณะต่างๆ ของ JavaScript ณ ตอนนี้เราได้ศึกษาเฉพาะพื้นฐานเท่านั้น ในบทเรียนต่อๆ ไปคุณจะได้เจอกับคุณสมบัติพิเศษและขั้นสูงของ JavaScript เพิ่มเติม
\ No newline at end of file
diff --git a/1-js/02-first-steps/index.md b/1-js/02-first-steps/index.md
index 31281656f..614444a00 100644
--- a/1-js/02-first-steps/index.md
+++ b/1-js/02-first-steps/index.md
@@ -1,3 +1,3 @@
-# JavaScript Fundamentals
+# พื้นฐานจาวาสคริปต์
 
-Let's learn the fundamentals of script building.
\ No newline at end of file
+มาเริ่มเรียนรู้การเขียนจาวาสคริปต์กัน
diff --git a/1-js/03-code-quality/01-debugging-chrome/article.md b/1-js/03-code-quality/01-debugging-chrome/article.md
index 4f50fb428..91aaaeae3 100644
--- a/1-js/03-code-quality/01-debugging-chrome/article.md
+++ b/1-js/03-code-quality/01-debugging-chrome/article.md
@@ -1,195 +1,279 @@
-# Debugging in the browser
+# การดีบักใน Browser
 
-Before writing more complex code, let's talk about debugging.
+ก่อนที่เราจะเขียนโค้ดที่ซับซ้อนกว่านี้ มาคุยกันเรื่องการดีบักกันสักหน่อย
 
-[Debugging](https://en.wikipedia.org/wiki/Debugging) is the process of finding and fixing errors within a script. All modern browsers and most other environments support debugging tools -- a special UI in developer tools that makes debugging much easier. It also allows to trace the code step by step to see what exactly is going on.
+[Debugging](https://en.wikipedia.org/wiki/Debugging) คือกระบวนการค้นหาและแก้ไขข้อผิดพลาดภายในสคริปต์ เบราว์เซอร์สมัยใหม่ทั้งหมดและสภาพแวดล้อมส่วนใหญ่รองรับเครื่องมือสำหรับดีบัก -- พวก UI พิเศษในเครื่องมือนักพัฒนาที่ช่วยให้การดีบักง่ายขึ้นมาก นอกจากนี้ยังช่วยให้สามารถติดตามการทำงานของโค้ดได้ทีละขั้นตอน เพื่อดูว่าเกิดอะไรขึ้นกันแน่ 
 
-We'll be using Chrome here, because it has enough features, most other browsers have a similar process.
+เราจะใช้ Chrome ที่นี่เพราะมันมีฟีเจอร์ที่เพียงพอ ส่วนเบราว์เซอร์อื่นๆ ส่วนใหญ่ก็มีขั้นตอนคล้ายๆ กัน
 
-## The "Sources" panel
+## แผง "Sources"
 
-Your Chrome version may look a little bit different, but it still should be obvious what's there.
+Chrome เวอร์ชันที่คุณใช้อาจมีหน้าตาแตกต่างกันไปเล็กน้อย แต่ก็น่าจะเห็นได้ชัดเจนว่ามีอะไรอยู่ที่นั่นบ้าง
 
-- Open the [example page](debugging/index.html) in Chrome.
-- Turn on developer tools with `key:F12` (Mac: `key:Cmd+Opt+I`).
-- Select the `Sources` panel.
+- เปิด[หน้าตัวอย่าง](debugging/index.html) ใน Chrome
+- เปิดเครื่องมือนักพัฒนาด้วย `key:F12` (Mac: `key:Cmd+Opt+I`)
+- เลือกแผง `Sources`
 
-Here's what you should see if you are doing it for the first time:
+นี่คือสิ่งที่คุณควรเห็น ถ้าเป็นครั้งแรกที่ทำ:
 
 ![](chrome-open-sources.svg)
 
-The toggler button <span class="devtools" style="background-position:-172px -98px"></span> opens the tab with files.
+ปุ่มสลับ <span class="devtools" style="background-position:-172px -98px"></span> จะเปิดแท็บที่มีไฟล์ต่างๆ
 
-Let's click it and select `hello.js` in the tree view. Here's what should show up:
+ลองคลิกที่มันแล้วเลือก `hello.js` ในมุมมองแบบต้นไม้ นี่คือสิ่งที่น่าจะปรากฏขึ้น:
 
 ![](chrome-tabs.svg)
 
-The Sources panel has 3 parts:
+แผง Sources ประกอบด้วย 3 ส่วน: 
 
-1. The **File Navigator** pane lists HTML, JavaScript, CSS and other files, including images that are attached to the page. Chrome extensions may appear here too.
-2. The **Code Editor** pane shows the source code.
-3. The **JavaScript Debugging** pane is for debugging, we'll explore it soon.
+1. บานหน้าต่าง **File Navigator** จะแสดงรายการไฟล์ HTML, JavaScript, CSS และอื่นๆ รวมถึงรูปภาพที่แนบมากับหน้าเว็บด้วย ส่วนขยายของ Chrome ก็อาจปรากฏที่นี่เช่นกัน
+2. บานหน้าต่าง **Code Editor** จะแสดงซอร์สโค้ด
+3. บานหน้าต่าง **JavaScript Debugging** ใช้สำหรับดีบัก เราจะมาดูมันกันในอีกสักครู่
 
-Now you could click the same toggler <span class="devtools" style="background-position:-172px -122px"></span> again to hide the resources list and give the code some space.
+ตอนนี้คุณสามารถคลิกที่ปุ่มสลับ <span class="devtools" style="background-position:-172px -122px"></span> อีกครั้งเพื่อซ่อนรายการทรัพยากรและเพิ่มพื้นที่ให้กับส่วนแสดงโค้ด
 
 ## Console
 
-If we press `key:Esc`, then a console opens below. We can type commands there and press `key:Enter` to execute.
+หากเรากด `key:Esc` คอนโซลจะเปิดขึ้นมาด้านล่าง เราสามารถพิมพ์คำสั่งลงไปที่นั่นแล้วกด `key:Enter` เพื่อให้มันทำงาน
 
-After a statement is executed, its result is shown below.
+หลังจากคำสั่งถูกประมวลผลแล้ว ผลลัพธ์ก็จะแสดงอยู่ด้านล่าง
 
+<<<<<<< HEAD
+ตัวอย่างเช่น ในที่นี้ `1+2` ให้ผลลัพธ์เป็น `3` ในขณะที่การเรียก function `hello("debugger")` ไม่ได้ส่งค่าใดๆ กลับมา ดังนั้นผลลัพธ์ที่ได้คือ `undefined`:
+=======
 For example, here `1+2` results in `3`, while the function call `hello("debugger")` returns nothing, so the result is `undefined`:
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
 ![](chrome-sources-console.svg)
 
 ## Breakpoints
 
-Let's examine what's going on within the code of the [example page](debugging/index.html). In `hello.js`, click at line number `4`. Yes, right on the `4` digit, not on the code.
+มาดูกันว่ามีอะไรเกิดขึ้นในโค้ดของ[หน้าตัวอย่าง](debugging/index.html) บ้าง ใน `hello.js` ให้คลิกที่เลขบรรทัดที่ `4` ใช่ คลิกที่ตัวเลข `4` เลย ไม่ใช่ที่โค้ด
 
-Congratulations! You've set a breakpoint. Please also click on the number for line `8`.
+ยินดีด้วย! คุณได้ตั้ง breakpoint แล้ว กรุณาคลิกที่เลขบรรทัดที่ `8` ด้วย
 
-It should look like this (blue is where you should click):
+มันควรจะมีหน้าตาแบบนี้ (สีน้ำเงินคือตำแหน่งที่คุณควรคลิก):
 
 ![](chrome-sources-breakpoint.svg)
 
-A *breakpoint* is a point of code where the debugger will automatically pause the JavaScript execution.
+*breakpoint* คือจุดในโค้ดที่ตัวดีบักเกอร์จะหยุดการทำงานของ JavaScript โดยอัตโนมัติ
 
-While the code is paused, we can examine current variables, execute commands in the console etc. In other words, we can debug it.
+ในขณะที่โค้ดหยุดอยู่ เราสามารถตรวจสอบค่าตัวแปรในปัจจุบัน รันคำสั่งในคอนโซล หรือทำอย่างอื่นได้ หรือพูดอีกอย่างคือ เราสามารถดีบักโค้ดตรงนั้นได้
 
-We can always find a list of breakpoints in the right panel. That's useful when we have many breakpoints in various files. It allows us to:
-- Quickly jump to the breakpoint in the code (by clicking on it in the right panel).
-- Temporarily disable the breakpoint by unchecking it.
-- Remove the breakpoint by right-clicking and selecting Remove.
-- ...And so on.
+เราสามารถดูรายการ breakpoint ทั้งหมดได้ที่แผงด้านขวาเสมอ ซึ่งมีประโยชน์มากเวลาเรามี breakpoint หลายจุดในหลายๆ ไฟล์ มันช่วยให้เรา:
+- ข้ามไปยัง breakpoint ในโค้ดได้อย่างรวดเร็ว (โดยคลิกที่มันในแผงด้านขวา)
+- ปิดการทำงานของ breakpoint ชั่วคราวโดยการเอาเครื่องหมายถูกออก
+- ลบ breakpoint โดยคลิกขวาแล้วเลือก Remove
+- ...และอื่นๆ
 
 ```smart header="Conditional breakpoints"
+<<<<<<< HEAD
+การ *คลิกขวา* บนเลขบรรทัดจะช่วยให้สร้าง breakpoint *แบบมีเงื่อนไข* ได้ มันจะทำงานก็ต่อเมื่อนิพจน์ที่กำหนดไว้ตอนสร้าง (ซึ่งคุณต้องใส่เอง) มีค่าเป็นจริงเท่านั้น
+=======
 *Right click* on the line number allows to create a *conditional* breakpoint. It only triggers when the given expression, that you should provide when you create it, is truthy.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-That's handy when we need to stop only for a certain variable value or for certain function parameters.
+นี่เป็นประโยชน์มากเวลาที่เราอยากจะหยุดเฉพาะตอนที่ค่าตัวแปรบางตัว หรือพารามิเตอร์ของฟังก์ชันบางตัวมีค่าตามที่ระบุไว้เท่านั้น 
 ```
 
+<<<<<<< HEAD
+## คำสั่ง "debugger"
+=======
 ## The command "debugger"
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-We can also pause the code by using the `debugger` command in it, like this:
+นอกจากนี้เรายังสามารถหยุดการทำงานของโค้ดได้โดยใช้คำสั่ง `debugger` ในโค้ดโดยตรง แบบนี้:
 
 ```js
 function hello(name) {
   let phrase = `Hello, ${name}!`;
 
 *!*
-  debugger;  // <-- the debugger stops here
+  debugger;  // <-- ตัวดีบักเกอร์จะหยุดที่ตรงนี้
 */!*
 
   say(phrase);
 }
 ```
 
+<<<<<<< HEAD
+คำสั่งลักษณะนี้จะทำงานก็ต่อเมื่อเครื่องมือนักพัฒนากำลังเปิดอยู่เท่านั้น ไม่เช่นนั้นเบราว์เซอร์จะข้ามมันไป
+
+## จุดหยุด (Breakpoints)
+=======
 Such command works only when the development tools are open, otherwise the browser ignores it.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
+
+มาดูกันว่ามีอะไรเกิดขึ้นในโค้ดของ [example page](debugging/index.html) บ้าง ใน `hello.js` ให้คลิกที่เลขบรรทัดที่ `4` ใช่ คลิกที่ตัวเลข `4` เลย ไม่ใช่ที่โค้ด
+
+ยินดีด้วย! คุณได้ตั้ง breakpoint แล้ว กรุณาคลิกที่เลขบรรทัดที่ `8` ด้วย
+
+มันควรจะมีหน้าตาแบบนี้ (สีน้ำเงินคือตำแหน่งที่คุณควรคลิก):
+
+![](chrome-sources-breakpoint.svg)
+
+*breakpoint* คือจุดในโค้ดที่ตัวดีบักเกอร์จะหยุดการทำงานของ JavaScript โดยอัตโนมัติ
+
+ในขณะที่โค้ดหยุดอยู่ เราสามารถตรวจสอบค่าตัวแปรในปัจจุบัน รันคำสั่งในคอนโซล หรือทำอย่างอื่นได้ หรือพูดอีกอย่างคือ เราสามารถดีบักโค้ดตรงนั้นได้
+
+เราสามารถดูรายการ breakpoint ทั้งหมดได้ที่แผงด้านขวาเสมอ ซึ่งมีประโยชน์มากเวลาเรามี breakpoint หลายจุดในหลายๆ ไฟล์ มันช่วยให้เรา:
+- ข้ามไปยัง breakpoint ในโค้ดได้อย่างรวดเร็ว (โดยคลิกที่มันในแผงด้านขวา)
+- ปิดการทำงานของ breakpoint ชั่วคราวโดยการเอาเครื่องหมายถูกออก
+- ลบ breakpoint โดยคลิกขวาแล้วเลือก Remove
+- ...และอื่นๆ
+
+```smart header="Conditional breakpoints"
+การ *คลิกขวา* บนเลขบรรทัดจะช่วยให้สร้าง breakpoint *แบบมีเงื่อนไข* ได้ มันจะทำงานก็ต่อเมื่อนิพจน์ที่กำหนดไว้ตอนสร้าง (ซึ่งคุณต้องใส่เอง) มีค่าเป็นจริงเท่านั้น
+
+นี่เป็นประโยชน์มากเวลาที่เราอยากจะหยุดเฉพาะตอนที่ค่าตัวแปรบางตัว หรือพารามิเตอร์ของฟังก์ชันบางตัวมีค่าตามที่ระบุไว้เท่านั้น 
+```
+
+## คำสั่ง "debugger"
+
+นอกจากนี้เรายังสามารถหยุดการทำงานของโค้ดได้โดยใช้คำสั่ง `debugger` ในโค้ดโดยตรง แบบนี้:
 
-## Pause and look around
+```js
+function hello(name) {
+  let phrase = `Hello, ${name}!`;
 
-In our example, `hello()` is called during the page load, so the easiest way to activate the debugger (after we've set the breakpoints) is to reload the page. So let's press `key:F5` (Windows, Linux) or `key:Cmd+R` (Mac).
+*!*
+  debugger;  // <-- ตัวดีบักเกอร์จะหยุดที่ตรงนี้
+*/!*
 
-As the breakpoint is set, the execution pauses at the 4th line:
+  say(phrase);
+}
+```
+
+คำสั่งลักษณะนี้จะทำงานก็ต่อเมื่อเครื่องมือนักพัฒนากำลังเปิดอยู่เท่านั้น ไม่เช่นนั้นเบราว์เซอร์จะข้ามมันไป
+
+## หยุดแล้วสำรวจดูรอบๆ 
+
+ในตัวอย่างของเรา `hello()` ถูกเรียกใช้ระหว่างการโหลดหน้าเว็บ ดังนั้นวิธีที่ง่ายที่สุดในการเปิดใช้งานตัวดีบักเกอร์ (หลังจากตั้ง breakpoint แล้ว) คือการโหลดหน้าเว็บใหม่ ดังนั้นมากดปุ่ม `key:F5` (Windows, Linux) หรือ `key:Cmd+R` (Mac) กัน
+
+เนื่องจากมีการตั้ง breakpoint ไว้ การทำงานของโปรแกรมจะหยุดที่บรรทัดที่ 4:
 
 ![](chrome-sources-debugger-pause.svg)
 
-Please open the informational dropdowns to the right (labeled with arrows). They allow you to examine the current code state:
+กรุณาเปิดดรอปดาวน์ที่แสดงข้อมูลด้านขวา (ที่มีลูกศรชี้อยู่) มันจะช่วยให้คุณสามารถตรวจสอบสถานะของโค้ดในปัจจุบันได้:
 
-1. **`Watch` -- shows current values for any expressions.**
+1. **`Watch` -- แสดงค่าปัจจุบันของนิพจน์ต่างๆ**
 
+<<<<<<< HEAD
+    คุณสามารถคลิกที่เครื่องหมายบวก `+` แล้วใส่นิพจน์เข้าไป ตัวดีบักเกอร์จะแสดงค่าของนิพจน์นั้น โดยจะคำนวณใหม่โดยอัตโนมัติในระหว่างการประมวลผล
+=======
     You can click the plus `+` and input an expression. The debugger will show its value, automatically recalculating it in the process of execution.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-2. **`Call Stack` -- shows the nested calls chain.**
+2. **`Call Stack` -- แสดงลำดับการเรียกฟังก์ชันที่ซ้อนกัน**
 
-    At the current moment the debugger is inside `hello()` call, called by a script in `index.html` (no function there, so it's called "anonymous").
+    ในตอนนี้ตัวดีบักเกอร์กำลังอยู่ในการเรียกฟังก์ชัน `hello()` ซึ่งถูกเรียกโดยสคริปต์ใน `index.html` (ไม่มีฟังก์ชันที่นั่น จึงเรียกว่า "anonymous")
 
-    If you click on a stack item (e.g. "anonymous"), the debugger jumps to the corresponding code, and all its variables can be examined as well.
-3. **`Scope` -- current variables.**
+    ถ้าคุณคลิกที่รายการใน call stack (เช่น "anonymous") ตัวดีบักเกอร์จะข้ามไปยังโค้ดส่วนนั้น และคุณก็สามารถตรวจสอบค่าตัวแปรทั้งหมดที่นั่นได้เช่นกัน
+3. **`Scope` -- ตัวแปรในขอบเขตปัจจุบัน**
 
-    `Local` shows local function variables. You can also see their values highlighted right over the source.
+    `Local` จะแสดงตัวแปรภายในในฟังก์ชัน คุณจะเห็นค่าของพวกมันถูกไฮไลต์อยู่เหนือโค้ดด้วย
 
-    `Global` has global variables (out of any functions).
+    `Global` จะแสดงตัวแปรระดับโกลบอล (ที่อยู่นอกฟังก์ชันใดๆ)
 
-    There's also `this` keyword there that we didn't study yet, but we'll do that soon.
+    นอกจากนี้ยังมีคีย์เวิร์ด `this` ที่เรายังไม่ได้ศึกษา แต่เราจะได้เรียนรู้เร็วๆ นี้แหละ
 
-## Tracing the execution
+## การติดตามการประมวลผล
 
-Now it's time to *trace* the script.
+ตอนนี้ถึงเวลา *ติดตาม* การทำงานของสคริปต์แล้ว
 
-There are buttons for it at the top of the right panel. Let's engage them.
+มีปุ่มสำหรับการติดตามอยู่ที่ด้านบนของแผงด้านขวา มาลองใช้กันเลย
 <!-- https://github.com/ChromeDevTools/devtools-frontend/blob/master/front_end/Images/src/largeIcons.svg -->
-<span class="devtools" style="background-position:-146px -168px"></span> -- "Resume": continue the execution, hotkey `key:F8`.
-: Resumes the execution. If there are no additional breakpoints, then the execution just continues and the debugger loses control.
+<span class="devtools" style="background-position:-146px -168px"></span> -- "Resume": ดำเนินการประมวลผลต่อ, ปุ่มลัด `key:F8`
+: ดำเนินการประมวลผลโค้ดต่อไป ถ้าไม่มี breakpoint เพิ่มเติม การประมวลผลจะดำเนินต่อเรื่อยๆ และตัวดีบักเกอร์จะหยุดควบคุมการทำงาน
 
-    Here's what we can see after a click on it:
+    นี่คือสิ่งที่เราจะเห็นหลังจากคลิกที่ปุ่มนี้:
 
     ![](chrome-sources-debugger-trace-1.svg)
 
-    The execution has resumed, reached another breakpoint inside `say()` and paused there. Take a look at the "Call Stack" at the right. It has increased by one more call. We're inside `say()` now.
+    การประมวลผลได้ดำเนินต่อไปแล้ว ไปถึง breakpoint อีกจุดหนึ่งภายในฟังก์ชัน `say()` และหยุดอยู่ที่นั่น ลองดูที่ "Call Stack" ทางด้านขวา จะเห็นว่ามีการเรียกเพิ่มขึ้นมาอีกหนึ่งชั้น ตอนนี้เรากำลังอยู่ภายในฟังก์ชัน `say()`
 
-<span class="devtools" style="background-position:-200px -190px"></span> -- "Step": run the next command, hotkey `key:F9`.
-: Run the next statement. If we click it now, `alert` will be shown.
+<span class="devtools" style="background-position:-200px -190px"></span> -- "Step": ดำเนินคำสั่งถัดไป, ปุ่มลัด `key:F9`
+: ดำเนินการตามคำสั่งถัดไป ถ้าเราคลิกตอนนี้ จะมี `alert` ปรากฏขึ้น
 
-    Clicking this again and again will step through all script statements one by one.
+    คลิกแบบนี้ซ้ำๆ จะทำให้ผ่านคำสั่งต่างๆ ในสคริปต์ไปทีละคำสั่ง
 
+<<<<<<< HEAD
+<span class="devtools" style="background-position:-62px -192px"></span> -- "Step over": ดำเนินคำสั่งถัดไป แต่ *ไม่ต้องเข้าไปในฟังก์ชัน*, ปุ่มลัด `key:F10`
+: คล้ายกับคำสั่ง "Step" ก่อนหน้า แต่จะทำงานแตกต่างกันถ้าคำสั่งถัดไปเป็นการเรียกฟังก์ชัน (ไม่ใช่ฟังก์ชันในตัว เช่น `alert` แต่เป็นฟังก์ชันที่เราสร้างเอง)
+
+    ถ้าเปรียบเทียบกัน คำสั่ง "Step" จะเข้าไปในการเรียกฟังก์ชันซ้อน และหยุดการประมวลผลที่บรรทัดแรกของฟังก์ชันนั้น แต่ "Step over" จะประมวลผลการเรียกฟังก์ชันซ้อนโดยที่เราไม่เห็น ข้ามการทำงานภายในฟังก์ชันไป
+
+    จากนั้นการประมวลผลจะหยุดทันทีหลังจบการเรียกฟังก์ชันนั้น
+=======
 <span class="devtools" style="background-position:-62px -192px"></span> -- "Step over": run the next command, but *don't go into a function*, hotkey `key:F10`.
 : Similar to the previous "Step" command, but behaves differently if the next statement is a function call (not a built-in, like `alert`, but a function of our own).
 
     If we compare them, the "Step" command goes into a nested function call and pauses the execution at its first line, while "Step over" executes the nested function call invisibly to us, skipping the function internals.
 
     The execution is then paused immediately after that function call.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-    That's good if we're not interested to see what happens inside the function call.
+    นี่จะมีประโยชน์ถ้าเราไม่สนใจที่จะดูว่ามีอะไรเกิดขึ้นภายในฟังก์ชันนั้นบ้าง
 
-<span class="devtools" style="background-position:-4px -194px"></span> -- "Step into", hotkey `key:F11`.
-: That's similar to "Step", but behaves differently in case of asynchronous function calls. If you're only starting to learn JavaScript, then you can ignore the difference, as we don't have asynchronous calls yet.
+<span class="devtools" style="background-position:-4px -194px"></span> -- "Step into", ปุ่มลัด `key:F11`
+: คล้ายกับ "Step" แต่จะทำงานต่างกันกรณีการเรียกฟังก์ชันแบบอะซิงโครนัส ถ้าคุณเพิ่งเริ่มเรียน JavaScript คุณสามารถข้ามส่วนนี้ไปก่อนได้ เพราะเรายังไม่มีการเรียกแบบอะซิงโครนัส
 
-    For the future, just note that "Step" command ignores async actions, such as `setTimeout` (scheduled function call), that execute later. The "Step into" goes into their code, waiting for them if necessary. See [DevTools manual](https://developers.google.com/web/updates/2018/01/devtools#async) for more details.
+    แค่จำไว้ว่าคำสั่ง "Step" จะข้ามการทำงานแบบ async เช่น `setTimeout` (การเรียกฟังก์ชันตามเวลาที่กำหนด) ที่จะประมวลผลภายหลัง ส่วน "Step into" จะเข้าไปในโค้ดส่วนนั้น รอจนกว่ามันจะเสร็จถ้าจำเป็น อ่านรายละเอียดเพิ่มเติมได้ใน [คู่มือ DevTools](https://developers.google.com/web/updates/2018/01/devtools#async)
 
-<span class="devtools" style="background-position:-32px -194px"></span> -- "Step out": continue the execution till the end of the current function, hotkey `key:Shift+F11`.
-: Continue the execution and stop it at the very last line of the current function. That's handy when we accidentally entered a nested call using <span class="devtools" style="background-position:-200px -190px"></span>, but it does not interest us, and we want to continue to its end as soon as possible.
+<span class="devtools" style="background-position:-32px -194px"></span> -- "Step out": ดำเนินการประมวลผลต่อจนจบฟังก์ชันปัจจุบัน, ปุ่มลัด `key:Shift+F11`
+: ดำเนินการประมวลผลโค้ดต่อไปจนถึงบรรทัดสุดท้ายของฟังก์ชันปัจจุบัน ใช้เมื่อเราเข้าไปในฟังก์ชันซ้อนโดยไม่ได้ตั้งใจโดยใช้ <span class="devtools" style="background-position:-200px -190px"></span> แต่ไม่ได้สนใจการทำงานในนั้น และอยากให้มันจบโดยเร็ว
 
-<span class="devtools" style="background-position:-61px -74px"></span> -- enable/disable all breakpoints.
-: That button does not move the execution. Just a mass on/off for breakpoints.
+<span class="devtools" style="background-position:-61px -74px"></span> -- เปิด/ปิดใช้งาน breakpoint ทั้งหมด
+: ปุ่มนี้ไม่ได้เลื่อนการประมวลผล แต่เป็นการเปิด/ปิด breakpoint ทั้งหมดพร้อมกัน
 
+<<<<<<< HEAD
+<span class="devtools" style="background-position:-90px -146px"></span> -- เปิด/ปิดการหยุดอัตโนมัติเมื่อมีข้อผิดพลาด
+: เมื่อเปิดใช้งาน หากเครื่องมือนักพัฒนากำลังเปิดอยู่ เวลามีข้อผิดพลาดเกิดขึ้นระหว่างการประมวลผลสคริปต์ มันจะหยุดทำงานทันที ซึ่งเราสามารถใช้ตรวจสอบค่าตัวแปรต่างๆ ในตัวดีบักเกอร์เพื่อดูว่ามีอะไรผิดปกติ ดังนั้นถ้าสคริปต์ของเราหยุดการทำงานเพราะข้อผิดพลาด เราสามารถเปิดตัวดีบักเกอร์ เปิดใช้งานตัวเลือกนี้ แล้วโหลดหน้าเว็บใหม่เพื่อดูว่ามันหยุดที่ตรงไหน และสถานะตอนนั้นเป็นยังไง
+=======
 <span class="devtools" style="background-position:-90px -146px"></span> -- enable/disable automatic pause in case of an error.
 : When enabled, if the developer tools is open, an error during the script execution automatically pauses it. Then we can analyze variables in the debugger to see what went wrong. So if our script dies with an error, we can open debugger, enable this option and reload the page to see where it dies and what's the context at that moment.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
 ```smart header="Continue to here"
-Right click on a line of code opens the context menu with a great option called "Continue to here".
+คลิกขวาที่บรรทัดโค้ดจะเปิดเมนูบริบท ซึ่งมีตัวเลือกที่ดีมากอย่าง "Continue to here"  
 
-That's handy when we want to move multiple steps forward to the line, but we're too lazy to set a breakpoint.
+นี่จะมีประโยชน์เมื่อเราอยากข้ามไปหลายขั้นตอนจนถึงบรรทัดนั้น แต่ขี้เกียจตั้ง breakpoint
 ```
 
-## Logging
+## การเก็บล็อก
 
-To output something to console from our code, there's `console.log` function.
+เพื่อแสดงผลบางอย่างไปยังคอนโซลจากโค้ดของเรา เราสามารถใช้ฟังก์ชัน `console.log`
 
-For instance, this outputs values from `0` to `4` to console:
+ตัวอย่างเช่น โค้ดนี้จะแสดงค่าตั้งแต่ `0` ถึง `4` ไปที่คอนโซล:
 
 ```js run
-// open console to see
+// เปิดคอนโซลเพื่อดูผลลัพธ์
 for (let i = 0; i < 5; i++) {
   console.log("value,", i);
 }
 ```
 
-Regular users don't see that output, it is in the console. To see it, either open the Console panel of developer tools or press `key:Esc` while in another panel: that opens the console at the bottom.
+ผู้ใช้ทั่วไปจะไม่เห็นผลลัพธ์นี้ เพราะมันอยู่ในคอนโซล หากต้องการดู ให้เปิดแผง Console ในเครื่องมือสำหรับนักพัฒนา หรือกด `key:Esc` ในขณะที่อยู่ในแผงอื่น ซึ่งจะเปิดคอนโซลขึ้นมาที่ด้านล่างของหน้าจอ
 
-If we have enough logging in our code, then we can see what's going on from the records, without the debugger.
+ถ้าเรามีการล็อกในโค้ดมากพอ เราจะสามารถติดตามได้ว่ากำลังเกิดอะไรขึ้นจากข้อมูลที่ถูกบันทึกไว้ โดยไม่จำเป็นต้องใช้ตัวดีบักเกอร์
 
-## Summary
+ข้อความสรุปนี้อธิบายวิธีการหยุดการทำงานของสคริปต์และการใช้งานเครื่องมือนักพัฒนาได้ดีมากครับ ภาษาที่ใช้ก็ชัดเจนเข้าใจง่าย
 
-As we can see, there are three main ways to pause a script:
-1. A breakpoint.
-2. The `debugger` statements.
-3. An error (if dev tools are open and the button <span class="devtools" style="background-position:-90px -146px"></span> is "on").
+## สรุป
 
+<<<<<<< HEAD
+อย่างที่เราเห็น มีสามวิธีหลักในการหยุดการทำงานของสคริปต์:
+1. จุดหยุด (breakpoint)
+2. คำสั่ง `debugger`
+3. ข้อผิดพลาด (ถ้าเครื่องมือนักพัฒนากำลังเปิดอยู่และปุ่ม <span class="devtools" style="background-position:-90px -146px"></span> อยู่ในสถานะ "เปิด")
+=======
 When paused, we can debug: examine variables and trace the code to see where the execution goes wrong.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
+
+เมื่อหยุดแล้ว เราสามารถดีบักได้โดยการตรวจสอบค่าตัวแปรและติดตามการทำงานของโค้ด เพื่อดูว่าการประมวลผลผิดพลาดตรงจุดไหน
 
-There are many more options in developer tools than covered here. The full manual is at <https://developers.google.com/web/tools/chrome-devtools>.
+เครื่องมือนักพัฒนามีตัวเลือกอีกมากมายนอกเหนือจากที่กล่าวถึงที่นี่ สามารถอ่านคู่มือฉบับเต็มได้ที่ <https://developers.google.com/web/tools/chrome-devtools>
 
-The information from this chapter is enough to begin debugging, but later, especially if you do a lot of browser stuff, please go there and look through more advanced capabilities of developer tools.
+ข้อมูลในบทความนี้เพียงพอสำหรับการเริ่มต้นดีบัก แต่ในภายหลัง โดยเฉพาะถ้าคุณต้องทำงานกับเบราว์เซอร์บ่อยๆ แนะนำให้ไปศึกษาเพิ่มเติมเกี่ยวกับความสามารถขั้นสูงของเครื่องมือนักพัฒนา
 
-Oh, and also you can click at various places of dev tools and just see what's showing up. That's probably the fastest route to learn dev tools. Don't forget about the right click and context menus!
+อ้อ แล้วก็คุณสามารถคลิกที่ส่วนต่างๆ ของเครื่องมือนักพัฒนา แล้วสังเกตดูว่ามีอะไรปรากฏขึ้นบ้าง นี่น่าจะเป็นวิธีที่เร็วที่สุดในการเรียนรู้การใช้งานเครื่องมือนักพัฒนา และอย่าลืมลองคลิกขวาเพื่อเปิดเมนูบริบทดูด้วยล่ะ!
\ No newline at end of file
diff --git a/1-js/03-code-quality/02-coding-style/1-style-errors/solution.md b/1-js/03-code-quality/02-coding-style/1-style-errors/solution.md
index 4facc8b29..11f43159a 100644
--- a/1-js/03-code-quality/02-coding-style/1-style-errors/solution.md
+++ b/1-js/03-code-quality/02-coding-style/1-style-errors/solution.md
@@ -1,29 +1,29 @@
 
-You could note the following:
+คุณสามารถจดบันทึกต่อไปนี้ได้:
 
 ```js no-beautify
-function pow(x,n)  // <- no space between arguments
-{  // <- figure bracket on a separate line
-  let result=1;   // <- no spaces before or after =
-  for(let i=0;i<n;i++) {result*=x;}   // <- no spaces
-  // the contents of { ... } should be on a new line
+function pow(x,n)  // <- ไม่มีช่องว่างระหว่างอาร์กิวเมนต์
+{  // <- เครื่องหมายวงเล็บของภาพหรือตารางอยู่บนบรรทัดแยกต่างหาก
+  let result=1;   // <- ไม่มีช่องว่างก่อนหรือหลังเครื่องหมาย =
+  for(let i=0;i<n;i++) {result*=x;}   // <- ไม่มีช่องว่าง
+  // the contents of { ... } ควรขึ้นบรรทัดใหม่
   return result;
 }
 
-let x=prompt("x?",''), n=prompt("n?",'') // <-- technically possible,
-// but better make it 2 lines, also there's no spaces and missing ;
-if (n<=0)  // <- no spaces inside (n <= 0), and should be extra line above it
-{   // <- figure bracket on a separate line
-  // below - long lines can be split into multiple lines for improved readability
+let x=prompt("x?",''), n=prompt("n?",'') // <-- เทคนิคการเขียนเป็นไปได้
+// จะเขียนในบรรทัดเดียวได้ แต่ควรเขียนให้เป็น 2 บรรทัดเพื่อให้อ่านง่ายขึ้น นอกจากนี้ไม่ควรมีช่องว่าง และต้องมีเครื่องหมาย ; ต่อท้ายด้วย
+if (n<=0)  // <- ควรมีบรรทัดว่างเพิ่มเติมด้านบนและไม่ควรมีช่องว่างภายใน (n <= 0)
+{   // <- เครื่องหมายวงเล็บของภาพหรือตารางอยู่บนบรรทัดแยกต่างหาก
+  // สำหรับบรรทัดที่ยาว สามารถแบ่งเป็นหลายบรรทัดเพื่อเพิ่มความอ่านง่ายขึ้นได้
   alert(`Power ${n} is not supported, please enter an integer number greater than zero`);
 }
-else // <- could write it on a single line like "} else {"
+else // <- สามารถเขียนเป็นบรรทัดเดียวได้ เช่น "} else {"
 {
-  alert(pow(x,n))  // no spaces and missing ;
+  alert(pow(x,n))  // ไม่ควรมีช่องว่างและต้องมีเครื่องหมาย ; ต่อท้ายด้วย
 }
 ```
 
-The fixed variant:
+ตัวแก้ไขแบบถูกต้อง:
 
 ```js
 function pow(x, n) {
diff --git a/1-js/03-code-quality/02-coding-style/1-style-errors/task.md b/1-js/03-code-quality/02-coding-style/1-style-errors/task.md
index b750962c9..e04465fc2 100644
--- a/1-js/03-code-quality/02-coding-style/1-style-errors/task.md
+++ b/1-js/03-code-quality/02-coding-style/1-style-errors/task.md
@@ -2,9 +2,9 @@ importance: 4
 
 ---
 
-# Bad style
+# รูปแบบการเขียนที่ไม่ดี
 
-What's wrong with the code style below?
+มีอะไรไม่เหมาะสมกับรูปแบบการเขียนโค้ดด้านล่างนี้หรือเปล่า?
 
 ```js no-beautify
 function pow(x,n)
@@ -25,4 +25,4 @@ else
 }
 ```
 
-Fix it.
+แก้ให้ที
diff --git a/1-js/03-code-quality/02-coding-style/article.md b/1-js/03-code-quality/02-coding-style/article.md
index 904f0a939..3bf7072f6 100644
--- a/1-js/03-code-quality/02-coding-style/article.md
+++ b/1-js/03-code-quality/02-coding-style/article.md
@@ -1,12 +1,12 @@
-# Coding Style
+# แนวทางการเขียนโค้ด
 
-Our code must be as clean and easy to read as possible.
+โค้ดของเราต้องเขียนให้สะอาดและอ่านง่ายที่สุดเท่าที่จะเป็นไปได้
 
-That is actually the art of programming -- to take a complex task and code it in a way that is both correct and human-readable. A good code style greatly assists in that.  
+นั่นคือศิลปะของการเขียนโปรแกรม -- การเขียนโค้ดสำหรับงานที่ซับซ้อนในลักษณะที่ถูกต้องและมนุษย์อ่านเข้าใจได้ การมีสไตล์การเขียนโค้ดที่ดีจะช่วยในเรื่องนี้ได้มาก
 
-## Syntax
+## รูปแบบไวยากรณ์
 
-Here is a cheat sheet with some suggested rules (see below for more details):
+ต่อไปนี้คือตารางสรุปกฎที่แนะนำ (ดูรายละเอียดเพิ่มเติมด้านล่าง):
 
 ![](code-style.svg)
 <!--
@@ -25,8 +25,8 @@ let x = prompt("x?", "");
 let n = prompt("n?", "");
 
 if (n < 0) {
-  alert(`Power ${n} is not supported,
-    please enter a non-negative integer number`);
+  alert(`เลขยกกำลัง ${n} ไม่รองรับ,
+    กรุณาใส่จำนวนเต็มที่ไม่ติดลบ`);
 } else {
   alert( pow(x, n) );
 }
@@ -34,93 +34,93 @@ if (n < 0) {
 
 -->
 
-Now let's discuss the rules and reasons for them in detail.
+ทีนี้มาคุยถึงกฎและเหตุผลของกฎเหล่านี้อย่างละเอียดกันดีกว่า 
 
-```warn header="There are no \"you must\" rules"
-Nothing is set in stone here. These are style preferences, not religious dogmas.
+```warn header="ไม่มีกฎ \"ต้องทำ\" ตายตัว"
+ไม่มีอะไรที่ตายตัวที่นี่ ข้อเสนอแนะเหล่านี้เป็นแค่รสนิยมในการจัดรูปแบบโค้ด ไม่ใช่หลักคำสอนทางศาสนา
 ```
 
-### Curly Braces
+### วงเล็บปีกกา
 
-In most JavaScript projects curly braces are written in "Egyptian" style with the opening brace on the same line as the corresponding keyword -- not on a new line. There should also be a space before the opening bracket, like this:
+ในโปรเจ็กต์ JavaScript ส่วนใหญ่ วงเล็บปีกกาจะเขียนในสไตล์ "อียิปต์" โดยวงเปิดจะอยู่บรรทัดเดียวกันกับคีย์เวิร์ดที่เกี่ยวข้อง -- ไม่ใช่บรรทัดใหม่ และควรมีช่องว่างก่อนวงเปิดด้วย แบบนี้:
 
 ```js
 if (condition) {
-  // do this
-  // ...and that
-  // ...and that
+  // ทำอันนี้
+  // ...แล้วก็อันนั้น
+  // ...แล้วก็อันนู่น 
 }
 ```
 
-A single-line construct, such as `if (condition) doSomething()`, is an important edge case. Should we use braces at all?
-
-Here are the annotated variants so you can judge their readability for yourself:
-
-1. 😠 Beginners sometimes do that. Bad! Curly braces are not needed:
-    ```js
-    if (n < 0) *!*{*/!*alert(`Power ${n} is not supported`);*!*}*/!*
-    ```
-2. 😠 Split to a separate line without braces. Never do that, easy to make an error when adding new lines:
-    ```js
-    if (n < 0)
-      alert(`Power ${n} is not supported`);
-    ```
-3. 😏 One line without braces - acceptable, if it's short:
-    ```js
-    if (n < 0) alert(`Power ${n} is not supported`);
-    ```
-4. 😃 The best variant:
-    ```js
-    if (n < 0) {
-      alert(`Power ${n} is not supported`);
-    }
-    ```
-
-For a very brief code, one line is allowed, e.g. `if (cond) return null`. But a code block (the last variant) is usually more readable.
-
-### Line Length
-
-No one likes to read a long horizontal line of code. It's best practice to split them.
-
-For example:
+กรณีพิเศษที่สำคัญคือประโยคบรรทัดเดียว เช่น `if (condition) doSomething()` เราควรใช้วงเล็บปีกกาหรือไม่?
+
+ต่อไปนี้คือตัวเลือกพร้อมคำอธิบาย เพื่อให้คุณตัดสินความสามารถในการอ่านทำความเข้าใจด้วยตัวเอง:
+
+1. 😠 มือใหม่บางคนทำแบบนี้ ไม่ดีเลย! ไม่จำเป็นต้องใช้วงเล็บปีกกา:
+   ```js
+   if (n < 0) *!*{*/!*alert(`เลขยกกำลัง ${n} ไม่รองรับ`);*!*}*/!*
+   ``` 
+2. 😠 แยกเป็นบรรทัดใหม่โดยไม่ใช้วงเล็บปีกกา อย่าทำแบบนี้เลย เพราะจะผิดพลาดง่ายเวลาเพิ่มบรรทัดใหม่:
+   ```js
+   if (n < 0)
+     alert(`เลขยกกำลัง ${n} ไม่รองรับ`);
+   ```
+3. 😏 เขียนบรรทัดเดียวโดยไม่ใช้วงเล็บปีกกา - ยอมรับได้ถ้าสั้น:
+   ```js
+   if (n < 0) alert(`เลขยกกำลัง ${n} ไม่รองรับ`);
+   ```
+4. 😃 ตัวเลือกที่ดีที่สุด: 
+   ```js
+   if (n < 0) {
+     alert(`เลขยกกำลัง ${n} ไม่รองรับ`); 
+   }
+   ```
+
+สำหรับโค้ดที่สั้นมากๆ อนุญาตให้เขียนบรรทัดเดียวได้ เช่น `if (cond) return null` แต่โดยทั่วไปแล้วการเขียนเป็นบล็อกโค้ด (ตัวเลือกสุดท้าย) จะอ่านเข้าใจง่ายกว่า
+
+### ความยาวบรรทัด
+
+ไม่มีใครชอบอ่านบรรทัดโค้ดยาวๆ ในแนวนอน ถือเป็นแนวปฏิบัติที่ดีที่จะตัดแบ่งบรรทัดพวกนั้น
+
+ยกตัวอย่างเช่น:
 ```js
-// backtick quotes ` allow to split the string into multiple lines
+// เครื่องหมาย backtick ` ทำให้แบ่งสตริงเป็นหลายบรรทัดได้
 let str = `
-  ECMA International's TC39 is a group of JavaScript developers,
-  implementers, academics, and more, collaborating with the community
-  to maintain and evolve the definition of JavaScript.
+  ECMA International's TC39 เป็นกลุ่มนักพัฒนา JavaScript,
+  ผู้ทำระบบ, นักวิชาการ และอีกมากมาย ที่ร่วมกันดูแลรักษากับชุมชน  
+  เพื่อปรับปรุงและพัฒนานิยามของ JavaScript
 `;
 ```
 
-And, for `if` statements:
+และสำหรับประโยค `if`:
 
 ```js
 if (
   id === 123 &&
-  moonPhase === 'Waning Gibbous' &&
+  moonPhase === 'Waning Gibbous' && 
   zodiacSign === 'Libra'
 ) {
   letTheSorceryBegin();
 }
 ```
 
-The maximum line length should be agreed upon at the team-level. It's usually 80 or 120 characters.
+ความยาวสูงสุดของบรรทัดควรตกลงกันในระดับทีมงาน ปกติแล้วมักเป็น 80 หรือ 120 ตัวอักษร
 
-### Indents
+### การเยื้องบรรทัด
 
-There are two types of indents:
+มี 2 วิธีในการเยื้องบรรทัด:
 
-- **Horizontal indents: 2 or 4 spaces.**
+- **การเยื้องในแนวนอน: เว้นวรรค 2 หรือ 4 ช่อง**
 
-    A horizontal indentation is made using either 2 or 4 spaces or the horizontal tab symbol (key `key:Tab`). Which one to choose is an old holy war. Spaces are more common nowadays.
+    การเยื้องในแนวนอนทำได้โดยใช้การเว้นวรรค 2 หรือ 4 ช่อง หรือใช้สัญลักษณ์แท็บ (ปุ่ม `key:Tab`) ที่จะเลือกใช้แบบไหนเป็นประเด็นถกเถียงกันมานาน ปัจจุบันนิยมใช้การเว้นวรรคมากกว่า
 
-    One advantage of spaces over tabs is that spaces allow more flexible configurations of indents than the tab symbol.
+    ข้อดีของการเว้นวรรคเหนือแท็บคือ สามารถกำหนดระยะการเยื้องได้ยืดหยุ่นกว่าการใช้สัญลักษณ์แท็บ
 
-    For instance, we can align the parameters with the opening bracket, like this:
+    ตัวอย่างเช่น เราสามารถจัดตำแหน่งพารามิเตอร์ให้ตรงกับวงเล็บเปิดได้ แบบนี้:
 
     ```js no-beautify
     show(parameters,
-         aligned, // 5 spaces padding at the left  
+         aligned, // เว้นวรรค 5 ช่องจากทางซ้าย
          one,
          after,
          another
@@ -129,9 +129,9 @@ There are two types of indents:
     }
     ```
 
-- **Vertical indents: empty lines for splitting code into logical blocks.**
+- **การเว้นบรรทัดในแนวตั้ง: เว้นบรรทัดว่างเพื่อแบ่งโค้ดเป็นกลุ่มย่อยตามลำดับขั้นตอน**
 
-    Even a single function can often be divided into logical blocks. In the example below, the initialization of variables, the main loop and returning the result are split vertically:
+    แม้แต่ฟังก์ชันเดียวก็มักแบ่งเป็นกลุ่มย่อยตามลำดับขั้นตอนได้ ในตัวอย่างด้านล่างนี้ มีการแบ่งแยกส่วนการกำหนดค่าตัวแปรเริ่มต้น, ลูปหลัก และการส่งค่ากลับ ออกจากกันในแนวตั้ง:
 
     ```js
     function pow(x, n) {
@@ -145,51 +145,51 @@ There are two types of indents:
     }
     ```
 
-    Insert an extra newline where it helps to make the code more readable. There should not be more than nine lines of code without a vertical indentation.
+    เพิ่มบรรทัดว่างในจุดที่ช่วยให้อ่านโค้ดเข้าใจง่ายขึ้น ไม่ควรมีโค้ดยาวเกิน 9 บรรทัดโดยไม่มีการเว้นบรรทัดในแนวตั้ง
 
-### Semicolons
+### เครื่องหมายอัฒภาค (semicolon)
 
-A semicolon should be present after each statement, even if it could possibly be skipped.
+ควรมีอัฒภาคปิดท้ายแต่ละประโยคเสมอ แม้ในบางกรณีจะละเว้นได้ก็ตาม
 
-There are languages where a semicolon is truly optional and it is rarely used. In JavaScript, though, there are cases where a line break is not interpreted as a semicolon, leaving the code vulnerable to errors. See more about that in the chapter <info:structure#semicolon>.
+บางภาษามีอัฒภาคเป็นตัวเลือกล้วนๆ และแทบไม่เห็นใช้เลย แต่ในภาษา JavaScript มีบางกรณีที่ตัวขึ้นบรรทัดใหม่ไม่ได้ถูกตีความเป็นอัฒภาค ทำให้โค้ดมีความเสี่ยงเกิดข้อผิดพลาดได้ อ่านรายละเอียดเพิ่มเติมในบท <info:structure#semicolon>
 
-If you're an experienced JavaScript programmer, you may choose a no-semicolon code style like [StandardJS](https://standardjs.com/). Otherwise, it's best to use semicolons to avoid possible pitfalls. The majority of developers put semicolons.
+หากคุณเป็นโปรแกรมเมอร์ JavaScript ที่มีประสบการณ์สูง คุณอาจเลือกใช้สไตล์การเขียนโค้ดแบบไม่ใส่อัฒภาค เช่น [StandardJS](https://standardjs.com/) ได้ มิฉะนั้นแล้ว แนะนำให้ใส่อัฒภาคเสมอจะดีกว่า เพื่อหลีกเลี่ยงปัญหาที่อาจเกิดขึ้น นักพัฒนาส่วนใหญ่ใส่อัฒภาคในโค้ดเป็นปกติอยู่แล้ว
 
-### Nesting Levels
+### ระดับความลึกของการซ้อนโค้ด
 
-Try to avoid nesting code too many levels deep.
+พยายามหลีกเลี่ยงการซ้อนโค้ดลึกเกินไปหลายชั้น
 
-For example, in the loop, it's sometimes a good idea to use the [`continue`](info:while-for#continue) directive to avoid extra nesting.
+ยกตัวอย่างเช่น ในลูป บางครั้งการใช้คำสั่ง [`continue`](info:while-for#continue) เพื่อข้ามการซ้อนโค้ดเพิ่มเติมเป็นวิธีที่ดี
 
-For example, instead of adding a nested `if` conditional like this:
+เช่น แทนที่จะเพิ่มเงื่อนไข `if` ซ้อนกันแบบนี้:
 
 ```js
 for (let i = 0; i < 10; i++) {
   if (cond) {
-    ... // <- one more nesting level
+    ... // <- ซ้อนลึกลงไปอีกชั้น
   }
 }
 ```
 
-We can write:
+เราสามารถเขียนเป็น:
 
 ```js
 for (let i = 0; i < 10; i++) {
   if (!cond) *!*continue*/!*;
-  ...  // <- no extra nesting level
+  ...  // <- ไม่ต้องซ้อนลึกลงไปอีกชั้น
 }
 ```
 
-A similar thing can be done with `if/else` and `return`.
+สามารถทำแบบเดียวกันได้กับ `if/else` และ `return`
 
-For example, two constructs below are identical.
+ตัวอย่างเช่น โครงสร้างสองแบบด้านล่างนี้ให้ผลลัพธ์เหมือนกัน
 
-Option 1:
+แบบที่ 1:
 
 ```js
 function pow(x, n) {
   if (n < 0) {
-    alert("Negative 'n' not supported");
+    alert("ไม่รองรับ 'n' ติดลบ");
   } else {
     let result = 1;
 
@@ -202,12 +202,12 @@ function pow(x, n) {
 }
 ```
 
-Option 2:
+แบบที่ 2:
 
 ```js
 function pow(x, n) {
   if (n < 0) {
-    alert("Negative 'n' not supported");
+    alert("ไม่รองรับ 'n' ติดลบ");
     return;
   }
 
@@ -221,102 +221,104 @@ function pow(x, n) {
 }
 ```
 
-The second one is more readable because the "special case" of `n < 0` is handled early on. Once the check is done we can move on to the "main" code flow without the need for additional nesting.
+แบบที่สองอ่านเข้าใจง่ายกว่า เพราะจัดการ "กรณีพิเศษ" ที่ `n < 0` ตั้งแต่เนิ่นๆ เมื่อตรวจสอบผ่านแล้ว เราก็สามารถไปต่อที่โค้ดส่วนหลักได้เลย โดยไม่ต้องซ้อนโค้ดลึกลงไปอีก
 
-## Function Placement
+## การจัดวางตำแหน่งฟังก์ชัน
 
-If you are writing several "helper" functions and the code that uses them, there are three ways to organize the functions.
+หากคุณกำลังเขียนฟังก์ชัน "ผู้ช่วย" หลายๆ ฟังก์ชัน และโค้ดที่เรียกใช้ฟังก์ชันเหล่านั้น มีวิธีจัดวางฟังก์ชัน 3 แบบดังนี้
 
-1. Declare the functions *above* the code that uses them:
+1. ประกาศฟังก์ชัน *ก่อน* โค้ดที่เรียกใช้:
 
-    ```js
-    // *!*function declarations*/!*
-    function createElement() {
-      ...
-    }
+   ```js
+   // *!*ประกาศฟังก์ชัน*/!*
+   function createElement() {
+     ...
+   }
 
-    function setHandler(elem) {
-      ...
-    }
+   function setHandler(elem) {
+     ...
+   }
 
-    function walkAround() {
-      ...
-    }
+   function walkAround() {
+     ...
+   }
 
-    // *!*the code which uses them*/!*
-    let elem = createElement();
-    setHandler(elem);
-    walkAround();
-    ```
-2. Code first, then functions
+   // *!*โค้ดที่เรียกใช้ฟังก์ชัน*/!*
+   let elem = createElement();
+   setHandler(elem);
+   walkAround();
+   ```
 
-    ```js
-    // *!*the code which uses the functions*/!*
-    let elem = createElement();
-    setHandler(elem);
-    walkAround();
-
-    // --- *!*helper functions*/!* ---
-    function createElement() {
-      ...
-    }
+2. เขียนโค้ดที่เรียกใช้ฟังก์ชันก่อน จากนั้นตามด้วยฟังก์ชัน
 
-    function setHandler(elem) {
-      ...
-    }
+   ```js
+   // *!*โค้ดที่เรียกใช้ฟังก์ชัน*/!*
+   let elem = createElement();
+   setHandler(elem);
+   walkAround();
 
-    function walkAround() {
-      ...
-    }
-    ```
-3. Mixed: a function is declared where it's first used.
+   // --- *!*ฟังก์ชันผู้ช่วย*/!* ---  
+   function createElement() {
+     ...
+   }
+
+   function setHandler(elem) {
+     ...
+   }
+
+   function walkAround() {
+     ...
+   }
+   ```
+
+3. ผสมกันระหว่างสองแบบข้างต้น: ประกาศฟังก์ชันในตำแหน่งที่มีการเรียกใช้ครั้งแรก
 
-Most of time, the second variant is preferred.
+โดยส่วนใหญ่แล้ว นิยมใช้แบบที่ 2 มากกว่า
 
-That's because when reading code, we first want to know *what it does*. If the code goes first, then it becomes clear from the start. Then, maybe we won't need to read the functions at all, especially if their names are descriptive of what they actually do.
+เพราะเวลาอ่านโค้ด เราต้องการทราบก่อนว่า *โค้ดทำอะไร* ถ้าเขียนโค้ดไว้ข้างบนสุด ความตั้งใจของโค้ดจะชัดเจนตั้งแต่แรก และในบางครั้งเราอาจไม่จำเป็นต้องอ่านฟังก์ชันเลยก็ได้ โดยเฉพาะอย่างยิ่งเมื่อชื่อฟังก์ชันบ่งบอกหน้าที่ของมันได้ดีอยู่แล้ว
 
-## Style Guides
+## คู่มือสไตล์การเขียนโค้ด
 
-A style guide contains general rules about "how to write" code, e.g. which quotes to use, how many spaces to indent, the maximal line length, etc. A lot of minor things.
+คู่มือสไตล์ประกอบด้วยกฎทั่วไปเกี่ยวกับ "วิธีเขียน" โค้ด เช่น ควรใช้เครื่องหมายคำพูดแบบไหน เว้นย่อหน้ากี่ช่อง ความยาวสูงสุดของบรรทัดคือเท่าไร เป็นต้น ซึ่งเป็นรายละเอียดเล็กๆ น้อยๆ จำนวนมาก
 
-When all members of a team use the same style guide, the code looks uniform, regardless of which team member wrote it.
+เมื่อสมาชิกทุกคนในทีมใช้คู่มือสไตล์ชุดเดียวกัน โค้ดจะมีรูปแบบที่เป็นเอกภาพ ไม่ว่าจะเขียนโดยสมาชิกคนไหนก็ตาม
 
-Of course, a team can always write their own style guide, but usually there's no need to. There are many existing guides to choose from.
+แน่นอนว่า ทีมสามารถเขียนคู่มือสไตล์เป็นของตัวเองได้เสมอ แต่โดยทั่วไปแล้วมักไม่จำเป็น เพราะมีคู่มือสำเร็จรูปให้เลือกใช้อยู่แล้วมากมาย
 
-Some popular choices:
+ตัวเลือกยอดนิยมบางส่วน ได้แก่:
 
 - [Google JavaScript Style Guide](https://google.github.io/styleguide/jsguide.html)
 - [Airbnb JavaScript Style Guide](https://github.com/airbnb/javascript)
 - [Idiomatic.JS](https://github.com/rwaldron/idiomatic.js)
 - [StandardJS](https://standardjs.com/)
-- (plus many more)
+- (และอีกมากมาย)
 
-If you're a novice developer, start with the cheat sheet at the beginning of this chapter. Then you can browse other style guides to pick up more ideas and decide which one you like best.
+สำหรับนักพัฒนามือใหม่ แนะนำให้เริ่มต้นจากตารางสรุปที่หัวข้อแรกของบทนี้ จากนั้นค่อยๆ ศึกษาคู่มือสไตล์อื่นๆ เพื่อเก็บเกี่ยวไอเดียเพิ่มเติม แล้วตัดสินใจเลือกสไตล์ที่ถูกใจที่สุด
 
-## Automated Linters
+## เครื่องมือตรวจสอบโค้ดอัตโนมัติ (Automated Linters)
 
-Linters are tools that can automatically check the style of your code and make improving suggestions.
+Linter คือเครื่องมือที่ช่วยตรวจสอบสไตล์โค้ดให้โดยอัตโนมัติ และเสนอแนะจุดที่ควรปรับปรุงแก้ไข
 
-The great thing about them is that style-checking can also find some bugs, like typos in variable or function names. Because of this feature, using a linter is recommended even if you don't want to stick to one particular "code style".
+ข้อดีคือ การตรวจสอบสไตล์ยังสามารถช่วยค้นพบบั๊กบางอย่างได้ด้วย เช่น การสะกดชื่อตัวแปรหรือฟังก์ชันผิด ด้วยเหตุนี้ จึงแนะนำให้ใช้ linter แม้คุณจะไม่อยากยึดติดกับ "สไตล์โค้ด" แบบใดแบบหนึ่งโดยเฉพาะก็ตาม
 
-Here are some well-known linting tools:
+ต่อไปนี้คือเครื่องมือ linting ที่มีชื่อเสียง:
 
-- [JSLint](https://www.jslint.com/) -- one of the first linters.
-- [JSHint](https://jshint.com/) -- more settings than JSLint.
-- [ESLint](https://eslint.org/) -- probably the newest one.
+- [JSLint](https://www.jslint.com/) -- หนึ่งใน linter รุ่นแรกๆ
+- [JSHint](https://jshint.com/) -- มีตัวเลือกการตั้งค่ามากกว่า JSLint
+- [ESLint](https://eslint.org/) -- น่าจะเป็นตัวล่าสุด
 
-All of them can do the job. The author uses [ESLint](https://eslint.org/).
+ทั้งหมดนี้ใช้งานได้เหมือนกัน ผู้เขียนเองใช้ [ESLint](https://eslint.org/)
 
-Most linters are integrated with many popular editors: just enable the plugin in the editor and configure the style.
+Linter ส่วนใหญ่ผสานรวมอยู่ในเครื่องมือแก้ไขโค้ดหลายตัวที่นิยมใช้กัน: เพียงเปิดใช้ปลั๊กอินในตัวแก้ไขโค้ด แล้วกำหนดค่าสไตล์ที่ต้องการ
 
-For instance, for ESLint you should do the following:
+ยกตัวอย่างสำหรับ ESLint ให้ทำตามขั้นตอนต่อไปนี้:
 
-1. Install [Node.js](https://nodejs.org/).
-2. Install ESLint with the command `npm install -g eslint` (npm is a JavaScript package installer).
-3. Create a config file named `.eslintrc` in the root of your JavaScript project (in the folder that contains all your files).
-4. Install/enable the plugin for your editor that integrates with ESLint. The majority of editors have one.
+1. ติดตั้ง [Node.js](https://nodejs.org/)
+2. ติดตั้ง ESLint ด้วยคำสั่ง `npm install -g eslint` (npm คือตัวจัดการแพ็คเกจของ JavaScript)
+3. สร้างไฟล์กำหนดค่าชื่อ `.eslintrc` ไว้ที่ root ของโปรเจ็กต์ JavaScript (ในโฟลเดอร์ที่เก็บไฟล์ทั้งหมด)
+4. ติดตั้ง/เปิดใช้ปลั๊กอินสำหรับเครื่องมือแก้ไขโค้ดที่เชื่อมต่อกับ ESLint โดยทั่วไปเครื่องมือแก้ไขโค้ดส่วนใหญ่จะมีปลั๊กอินนี้
 
-Here's an example of an `.eslintrc` file:
+ตัวอย่างไฟล์ `.eslintrc` เป็นดังนี้:
 
 ```js
 {
@@ -333,16 +335,16 @@ Here's an example of an `.eslintrc` file:
 }
 ```
 
-Here the directive `"extends"` denotes that the configuration is based on the "eslint:recommended" set of settings. After that, we specify our own.
+ในที่นี้ คำสั่ง `"extends"` หมายถึงใช้การกำหนดค่าพื้นฐานจากชุด "eslint:recommended" จากนั้นเราก็ปรับแต่งเพิ่มเติมเอง
 
-It is also possible to download style rule sets from the web and extend them instead. See <https://eslint.org/docs/user-guide/getting-started> for more details about installation.
+นอกจากนี้ยังดาวน์โหลดชุดกฎสไตล์จากเว็บมาต่อยอดได้ด้วย ดูข้อมูลเพิ่มเติมเกี่ยวกับการติดตั้งได้ที่ <https://eslint.org/docs/user-guide/getting-started>
 
-Also certain IDEs have built-in linting, which is convenient but not as customizable as ESLint.
+IDE บางตัวก็มี linter ติดตั้งมาในตัวแล้ว ซึ่งสะดวกแต่ปรับแต่งได้ไม่เท่า ESLint
 
-## Summary
+## สรุป
 
-All syntax rules described in this chapter (and in the style guides referenced) aim to increase the readability of your code. All of them are debatable.
+กฎไวยากรณ์ทั้งหมดที่กล่าวถึงในบทนี้ (และในคู่มือสไตล์ที่อ้างถึง) ล้วนมีเป้าหมายเพื่อเพิ่มความสามารถในการอ่านทำความเข้าใจโค้ดของคุณ และทุกกฎก็สามารถถกเถียงได้
 
-When we think about writing "better" code, the questions we should ask ourselves are: "What makes the code more readable and easier to understand?" and "What can help us avoid errors?" These are the main things to keep in mind when choosing and debating code styles.
+เมื่อเราคิดถึงการเขียนโค้ดให้ "ดีขึ้น" คำถามที่ควรถามตัวเองคือ "อะไรที่ช่วยให้โค้ดอ่านง่ายและทำความเข้าใจได้มากขึ้น" และ "อะไรที่ช่วยให้เราหลีกเลี่ยงข้อผิดพลาด" นี่คือสิ่งสำคัญที่ต้องคำนึงถึงเวลาเลือกหรือโต้แย้งสไตล์โค้ด
 
-Reading popular style guides will allow you to keep up to date with the latest ideas about code style trends and best practices.
+การอ่านคู่มือสไตล์ยอดนิยมจะช่วยให้คุณอัพเดตแนวคิดล่าสุดเกี่ยวกับเทรนด์และแนวปฏิบัติที่ดีที่สุดในการจัดสไตล์โค้ดได้
\ No newline at end of file
diff --git a/1-js/03-code-quality/03-comments/article.md b/1-js/03-code-quality/03-comments/article.md
index af3a06c80..6b92f2032 100644
--- a/1-js/03-code-quality/03-comments/article.md
+++ b/1-js/03-code-quality/03-comments/article.md
@@ -1,38 +1,38 @@
-# Comments
+# คอมเมนต์
 
-As we know from the chapter <info:structure>, comments can be single-line: starting with `//` and multiline: `/* ... */`.
+ดังที่เราได้เรียนรู้จากบท <info:structure> แล้วว่า คอมเมนต์สามารถเป็นบรรทัดเดียว: เริ่มต้นด้วย `//` หรือหลายบรรทัด: `/* ... */`
 
-We normally use them to describe how and why the code works.
+โดยปกติเราใช้คอมเมนต์เพื่ออธิบายว่าโค้ดทำงานอย่างไรและทำไมถึงทำงานแบบนั้น
 
-At first sight, commenting might be obvious, but novices in programming often use them wrongly.
+ในทีแรกการเขียนคอมเมนต์อาจดูเป็นเรื่องง่าย แต่มือใหม่ในการเขียนโปรแกรมมักใช้คอมเมนต์ในทางที่ผิด
 
-## Bad comments
+## คอมเมนต์ที่ไม่ดี
 
-Novices tend to use comments to explain "what is going on in the code". Like this:
+มือใหม่มักใช้คอมเมนต์เพื่ออธิบาย "สิ่งที่กำลังเกิดขึ้นในโค้ด" แบบนี้:
 
 ```js
-// This code will do this thing (...) and that thing (...)
-// ...and who knows what else...
+// โค้ดนี้จะทำสิ่งนี้ (...) และสิ่งนั้น (...)
+// ...และใครจะรู้ว่ามันยังทำอะไรอีก...
 very;
 complex;
 code;
 ```
 
-But in good code, the amount of such "explanatory" comments should be minimal. Seriously, the code should be easy to understand without them.
+แต่ในโค้ดที่ดี ปริมาณของคอมเมนต์ "อธิบาย" แบบนี้ควรมีให้น้อยที่สุด จริงๆ แล้ว โค้ดควรอ่านเข้าใจได้ง่ายโดยไม่ต้องพึ่งคอมเมนต์
 
-There's a great rule about that: "if the code is so unclear that it requires a comment, then maybe it should be rewritten instead".
+มีกฎสำคัญเกี่ยวกับเรื่องนี้: "ถ้าโค้ดไม่ชัดเจนจนต้องใช้คอมเมนต์ บางทีอาจควรเขียนโค้ดใหม่แทน"
 
-### Recipe: factor out functions
+### เคล็ดลับ: แยกโค้ดออกมาเป็นฟังก์ชัน
 
-Sometimes it's beneficial to replace a code piece with a function, like here:
+บางครั้งการแทนที่ส่วนหนึ่งของโค้ดด้วยฟังก์ชันก็มีประโยชน์ เหมือนในตัวอย่างนี้:
 
 ```js
 function showPrimes(n) {
   nextPrime:
   for (let i = 2; i < n; i++) {
-
+  
 *!*
-    // check if i is a prime number
+    // ตรวจสอบว่า i เป็นจำนวนเฉพาะหรือไม่
     for (let j = 2; j < i; j++) {
       if (i % j == 0) continue nextPrime;
     }
@@ -43,8 +43,7 @@ function showPrimes(n) {
 }
 ```
 
-The better variant, with a factored out function `isPrime`:
-
+โค้ดที่ดีกว่า โดยการแยกเป็นฟังก์ชัน `isPrime` คือ:
 
 ```js
 function showPrimes(n) {
@@ -52,7 +51,7 @@ function showPrimes(n) {
   for (let i = 2; i < n; i++) {
     *!*if (!isPrime(i)) continue;*/!*
 
-    alert(i);  
+    alert(i);
   }
 }
 
@@ -65,21 +64,21 @@ function isPrime(n) {
 }
 ```
 
-Now we can understand the code easily. The function itself becomes the comment. Such code is called *self-descriptive*.
+ตอนนี้เราสามารถเข้าใจโค้ดได้ง่ายขึ้น ฟังก์ชันเองก็กลายเป็นคอมเมนต์ โค้ดแบบนี้เรียกว่า *อธิบายตัวเอง (self-descriptive)*
 
-### Recipe: create functions
+### เคล็ดลับ: สร้างฟังก์ชัน
 
-And if we have a long "code sheet" like this:
+หากเรามี "แผ่นโค้ด" ยาวๆ แบบนี้:
 
 ```js
-// here we add whiskey
+// ตรงนี้เติมวิสกี้
 for(let i = 0; i < 10; i++) {
   let drop = getWhiskey();
   smell(drop);
   add(drop, glass);
 }
 
-// here we add juice
+// ตรงนี้เติมน้ำผลไม้ 
 for(let t = 0; t < 3; t++) {
   let tomato = getTomato();
   examine(tomato);
@@ -87,10 +86,10 @@ for(let t = 0; t < 3; t++) {
   add(juice, glass);
 }
 
-// ...
+// ...  
 ```
 
-Then it might be a better variant to refactor it into functions like:
+การ refactor ให้เป็นฟังก์ชันแบบนี้อาจดีกว่า:
 
 ```js
 addWhiskey(glass);
@@ -108,73 +107,77 @@ function addJuice(container) {
     let tomato = getTomato();
     //...
   }
-}
+}  
 ```
 
-Once again, functions themselves tell what's going on. There's nothing to comment. And also the code structure is better when split. It's clear what every function does, what it takes and what it returns.
+อีกครั้ง ตัวฟังก์ชันเองบอกเลยว่ากำลังเกิดอะไรขึ้น ไม่ต้องใช้คอมเมนต์อธิบาย และโครงสร้างโค้ดก็ดีขึ้นเมื่อแยกส่วนออกมา มองชัดเจนว่าแต่ละฟังก์ชันทำอะไร รับอะไรเข้ามา และส่งอะไรออกไป
 
-In reality, we can't totally avoid "explanatory" comments. There are complex algorithms. And there are smart "tweaks" for purposes of optimization. But generally we should try to keep the code simple and self-descriptive.
+ในความเป็นจริง เราไม่สามารถหลีกเลี่ยงคอมเมนต์ "อธิบาย" ได้ทั้งหมด มีอัลกอริธึมที่ซับซ้อน และมี "กลเม็ด" ที่ชาญฉลาดที่ใช้เพื่อปรับปรุงประสิทธิภาพโค้ด แต่โดยทั่วไปแล้ว เราควรพยายามรักษาให้โค้ดเรียบง่ายและอธิบายตัวเองได้มากที่สุด
 
-## Good comments
+## คอมเมนต์ที่ดี
 
-So, explanatory comments are usually bad. Which comments are good?
+ดังนั้น คอมเมนต์ที่เป็นคำอธิบายมักจะไม่ดี แล้วคอมเมนต์แบบไหนถึงจะดีล่ะ?
 
-Describe the architecture
-: Provide a high-level overview of components, how they interact, what's the control flow in various situations... In short -- the bird's eye view of the code. There's a special language [UML](http://wikipedia.org/wiki/Unified_Modeling_Language) to build high-level architecture diagrams explaining the code. Definitely worth studying.
+อธิบายสถาปัตยกรรม
+: ให้ภาพรวมในระดับสูงของส่วนประกอบต่างๆ ว่ามีปฏิสัมพันธ์กันอย่างไร อะไรคือลำดับการควบคุมในสถานการณ์ต่างๆ สั้นๆ ก็คือมุมสูงของโค้ด มีภาษาพิเศษอย่าง [UML](http://wikipedia.org/wiki/Unified_Modeling_Language) ที่ใช้สร้างแผนภาพสถาปัตยกรรมในระดับสูงเพื่ออธิบายโค้ด ซึ่งแน่นอนว่าคุ้มค่าแก่การศึกษา
 
-Document function parameters and usage
-: There's a special syntax [JSDoc](http://en.wikipedia.org/wiki/JSDoc) to document a function: usage, parameters, returned value.
+บันทึกพารามิเตอร์และการใช้งานฟังก์ชัน
+: มีไวยากรณ์พิเศษอย่าง [JSDoc](http://en.wikipedia.org/wiki/JSDoc) สำหรับบันทึกข้อมูลฟังก์ชัน: วิธีใช้งาน พารามิเตอร์ ค่าที่ส่งคืน
 
-For instance:
+ตัวอย่างเช่น:
 ```js
 /**
- * Returns x raised to the n-th power.
+ * ส่งคืน x ยกกำลัง n
  *
- * @param {number} x The number to raise.
- * @param {number} n The power, must be a natural number.
- * @return {number} x raised to the n-th power.
+ * @param {number} x เลขที่ต้องการยกกำลัง
+ * @param {number} n เลขชี้กำลัง ต้องเป็นจำนวนนับ
+ * @return {number} x ยกกำลัง n
  */
 function pow(x, n) {
   ...
 }
 ```
 
-Such comments allow us to understand the purpose of the function and use it the right way without looking in its code.
+คอมเมนต์แบบนี้ช่วยให้เราเข้าใจวัตถุประสงค์ของฟังก์ชันและใช้งานอย่างถูกต้องโดยไม่ต้องดูที่โค้ด
 
-By the way, many editors like [WebStorm](https://www.jetbrains.com/webstorm/) can understand them as well and use them to provide autocomplete and some automatic code-checking.
+ในทางกลับกัน เครื่องมือแก้ไขโค้ดหลายตัวเช่น [WebStorm](https://www.jetbrains.com/webstorm/) ก็สามารถอ่านคอมเมนต์เหล่านี้และใช้เพื่อช่วยเติมโค้ดอัตโนมัติและตรวจสอบโค้ดบางอย่างโดยอัตโนมัติได้
 
+<<<<<<< HEAD
+และยังมีเครื่องมืออย่าง [JSDoc 3](https://github.com/jsdoc/jsdoc) ที่สามารถสร้างเอกสาร HTML จากคอมเมนต์ คุณสามารถอ่านข้อมูลเพิ่มเติมเกี่ยวกับ JSDoc ได้ที่ <https://jsdoc.app>
+=======
 Also, there are tools like [JSDoc 3](https://github.com/jsdoc/jsdoc) that can generate HTML-documentation from the comments. You can read more information about JSDoc at <https://jsdoc.app>.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-Why is the task solved this way?
-: What's written is important. But what's *not* written may be even more important to understand what's going on. Why is the task solved exactly this way? The code gives no answer.
+ทำไมปัญหาถึงได้รับการแก้ไขด้วยวิธีนี้?
+: สิ่งที่เขียนไว้นั้นสำคัญ แต่สิ่งที่ *ไม่ได้* เขียนอาจจะสำคัญยิ่งกว่าในการทำความเข้าใจว่ากำลังเกิดอะไรขึ้น ทำไมปัญหาถึงถูกแก้ไขด้วยวิธีนี้พอดี? โค้ดไม่ได้ให้คำตอบ
 
-    If there are many ways to solve the task, why this one? Especially when it's not the most obvious one.
+  ถ้ามีหลายวิธีในการแก้ปัญหา ทำไมถึงเลือกวิธีนี้? โดยเฉพาะอย่างยิ่งเมื่อมันไม่ใช่ทางเลือกที่ชัดเจนที่สุด
 
-    Without such comments the following situation is possible:
-    1. You (or your colleague) open the code written some time ago, and see that it's "suboptimal".
-    2. You think: "How stupid I was then, and how much smarter I'm now", and rewrite using the "more obvious and correct" variant.
-    3. ...The urge to rewrite was good. But in the process you see that the "more obvious" solution is actually lacking. You even dimly remember why, because you already tried it long ago. You revert to the correct variant, but the time was wasted.
+  หากไม่มีคอมเมนต์ดังกล่าว สถานการณ์ต่อไปนี้อาจเกิดขึ้นได้:
+  1. คุณ (หรือเพื่อนร่วมงาน) เปิดโค้ดที่เขียนไว้เมื่อสักพักก่อน แล้วเห็นว่ามัน "ไม่เหมาะสมที่สุด"
+  2. คุณคิดว่า "ตอนนั้นโง่จัง ส่วนตอนนี้ฉันฉลาดขึ้นมากแล้ว" และเขียนใหม่ด้วยทางเลือกที่ "ตรงไปตรงมาและถูกต้องกว่า"
+  3. ...แรงผลักดันที่จะเขียนใหม่เป็นสิ่งที่ดี แต่ระหว่างนั้นคุณเห็นว่าวิธีที่ "ตรงไปตรงมา" นั้นจริงๆ แล้วไม่ครบถ้วน คุณพอจำได้เลือนราง ว่าทำไมถึงเป็นแบบนั้น เพราะเคยลองทำไปแล้วเมื่อนานมาแล้ว คุณเปลี่ยนกลับมาใช้วิธีที่ถูกต้อง แต่ก็เสียเวลาไปแล้ว
 
-    Comments that explain the solution are very important. They help to continue development the right way.
+  คอมเมนต์ที่อธิบายวิธีแก้ปัญหานั้นสำคัญมาก ช่วยให้พัฒนาต่อไปในทิศทางที่ถูกต้อง
 
-Any subtle features of the code? Where they are used?
-: If the code has anything subtle and counter-intuitive, it's definitely worth commenting.
+โค้ดมีจุดอ่อนหรือเทคนิคพิเศษซ่อนอยู่ไหม? ใช้แบบนี้ที่ไหนบ้าง?
+: ถ้าโค้ดมีอะไรที่ละเอียดอ่อนและขัดกับสัญชาตญาณ ก็ควรคอมเมนต์ไว้อย่างยิ่ง
 
-## Summary
+## สรุป
 
-An important sign of a good developer is comments: their presence and even their absence.
+สัญญาณสำคัญของนักพัฒนาที่ดีคือคอมเมนต์: ทั้งการมีและการไม่มีของมัน
 
-Good comments allow us to maintain the code well, come back to it after a delay and use it more effectively.
+คอมเมนต์ที่ดีช่วยให้เรารักษาโค้ดไว้ได้ดี กลับมาดูอีกครั้งหลังจากผ่านไประยะหนึ่ง และใช้งานได้อย่างมีประสิทธิภาพยิ่งขึ้น
 
-**Comment this:**
+**ควรเขียนคอมเมนต์เรื่อง:**
 
-- Overall architecture, high-level view.
-- Function usage.
-- Important solutions, especially when not immediately obvious.
+- สถาปัตยกรรมโดยรวม, มุมมองภาพกว้าง
+- วิธีใช้ฟังก์ชัน
+- วิธีแก้ปัญหาที่สำคัญ โดยเฉพาะเมื่อไม่เห็นได้ชัดในทันที
 
-**Avoid comments:**
+**หลีกเลี่ยงคอมเมนต์ที่:**
 
-- That tell "how code works" and "what it does".
-- Put them in only if it's impossible to make the code so simple and self-descriptive that it doesn't require them.
+- บอก "โค้ดทำงานอย่างไร" และ "ทำอะไร" 
+- ใส่คอมเมนต์เฉพาะเมื่อทำให้โค้ดเรียบง่ายและอธิบายตัวเองจนไม่จำเป็นต้องใช้คอมเมนต์แล้วไม่ได้
 
-Comments are also used for auto-documenting tools like JSDoc3: they read them and generate HTML-docs (or docs in another format).
+คอมเมนต์ยังถูกใช้โดยเครื่องมือสร้างเอกสารอัตโนมัติอย่าง JSDoc3: อ่านคอมเมนต์และสร้างเอกสาร HTML (หรือเอกสารในรูปแบบอื่น) จากมัน
\ No newline at end of file
diff --git a/1-js/03-code-quality/04-ninja-code/article.md b/1-js/03-code-quality/04-ninja-code/article.md
index 96fdf4143..ef0b8dfd6 100644
--- a/1-js/03-code-quality/04-ninja-code/article.md
+++ b/1-js/03-code-quality/04-ninja-code/article.md
@@ -1,185 +1,182 @@
-# Ninja code
+# โค้ดนินจา
 
-
-```quote author="Confucius (Analects)"
-Learning without thought is labor lost; thought without learning is perilous.
+```quote author="ขงจื๊อ (วจนะ)"
+เรียนไร้คิดเหนื่อยเปล่าดุจดั่งฝัน คิดไร้เรียนอันตรายใช่น้อยเลย
 ```
 
-Programmer ninjas of the past used these tricks to sharpen the mind of code maintainers.
-
-Code review gurus look for them in test tasks.
+โปรแกรมเมอร์นินจาในอดีตใช้กลเม็ดเหล่านี้เพื่อลับสมองของผู้ดูแลโค้ด
 
-Novice developers sometimes use them even better than programmer ninjas.
+ผู้เชี่ยวชาญการรีวิวโค้ดมองหากลเม็ดเหล่านี้ในการทดสอบงาน
 
-Read them carefully and find out who you are -- a ninja, a novice, or maybe a code reviewer?
+บางครั้งนักพัฒนามือใหม่ใช้กลเม็ดเหล่านี้ได้ดีกว่าโปรแกรมเมอร์นินจาเสียอีก
 
+อ่านอย่างละเอียดแล้วลองดูว่าคุณเป็นใคร -- นินจา, มือใหม่, หรืออาจเป็นผู้รีวิวโค้ด?
 
-```warn header="Irony detected"
-Many try to follow ninja paths. Few succeed.
+```warn header="พบการเสียดสี"
+มากมายมุ่งวิถีนินจา น้อยนักล่วงพ้นถึงจุดหมาย
 ```
 
+## ความกระชับคือหัวใจของปัญญา
 
-## Brevity is the soul of wit
+เขียนโค้ดให้สั้นที่สุดเท่าที่จะทำได้ เพื่อแสดงความฉลาดของคุณ
 
-Make the code as short as possible. Show how smart you are.
+ให้คุณลักษณะภาษาที่ซับซ้อนเป็นตัวนำทาง
 
-Let subtle language features guide you.
-
-For instance, take a look at this ternary operator `'?'`:
+ยกตัวอย่างเช่น ลองดูตัวดำเนินการแบบ 3 ทาง (ternary) `'?'` นี้:
 
 ```js
-// taken from a well-known javascript library
+// มาจากไลบรารี JavaScript ที่มีชื่อเสียง
 i = i ? i < 0 ? Math.max(0, len + i) : i : 0;
 ```
 
-Cool, right? If you write like that, a developer who comes across this line and tries to understand what is the value of `i` is going to have a merry time. Then come to you, seeking for an answer.
+เจ๋งใช่ไหม? ถ้าคุณเขียนแบบนี้ นักพัฒนาที่เจอบรรทัดนี้และพยายามทำความเข้าใจว่า `i` มีค่าเท่าไหร่ คงจะได้เพลิดเพลิน จากนั้นก็มาหาคุณเพื่อขอคำตอบ
 
-Tell them that shorter is always better. Initiate them into the paths of ninja.
+บอกพวกเขาว่าสั้นกว่าดีกว่าเสมอ แนะนำพวกเขาสู่วิถีแห่งนินจา
 
-## One-letter variables
+## ตัวแปรตัวอักษรเดียว
 
-```quote author="Laozi (Tao Te Ching)"
-The Dao hides in wordlessness. Only the Dao is well begun and well
-completed.
+```quote author="เล่าจื๊อ (เต๋าเต๋อจิง)"
+เต๋าซ่อนในความเงียบไร้คำ เริ่มต้นและจบลงอย่างสมบูรณ์
 ```
 
-Another way to code shorter is to use single-letter variable names everywhere. Like `a`, `b` or `c`.
+อีกวิธีหนึ่งที่จะเขียนโค้ดให้สั้นลงคือการใช้ชื่อตัวแปรเพียงตัวอักษรเดียวทุกที่ เช่น `a`, `b` หรือ `c`
 
-A short variable disappears in the code like a real ninja in the forest. No one will be able to find it using "search" of the editor. And even if someone does, they won't be able to "decipher" what the name `a` or `b` means.
+ตัวแปรที่สั้นจะหายไปในโค้ดเหมือนนินจาในป่า ไม่มีใครสามารถหาเจอได้ด้วยฟีเจอร์ "ค้นหา" ของเครื่องมือแก้ไขโค้ด และถึงแม้ใครจะเจอ พวกเขาก็คงไม่สามารถ "ถอดรหัส" ได้ว่า `a` หรือ `b` หมายถึงอะไร
 
-...But there's an exception. A real ninja will never use `i` as the counter in a `"for"` loop. Anywhere, but not here. Look around, there are many more exotic letters. For instance, `x` or `y`.
+...แต่มีข้อยกเว้น นินจาตัวจริงจะไม่มีวันใช้ `i` เป็นตัวนับในลูป `"for"` ยกเว้นตรงนี้ที่ไหนก็ได้ มองหารอบๆ ดู มีตัวอักษรแปลกๆ อีกมากมาย เช่น `x` หรือ `y`
 
-An exotic variable as a loop counter is especially cool if the loop body takes 1-2 pages (make it longer if you can). Then if someone looks deep inside the loop, they won't be able to quickly figure out that the variable named `x` is the loop counter.
+ใช้ตัวแปรแปลกตาเป็นตัวนับลูปนี่เจ๋งสุดๆ โดยเฉพาะถ้าภายในลูปยาว 1-2 หน้า (ยิ่งยาวยิ่งดี) เพราะถ้ามีใครมาดูโค้ดข้างในลูป พวกเขาจะไม่สามารถเดาได้ในทันทีว่าตัวแปรชื่อ `x` คือตัวนับลูป
 
-## Use abbreviations
 
-If the team rules forbid the use of one-letter and vague names -- shorten them, make abbreviations.
+## ใช้คำย่อ
 
-Like this:
+หากกฎของทีมห้ามใช้ชื่อที่เป็นตัวอักษรเดียวหรือคลุมเครือ -- ก็ให้ย่อมัน สร้างคำย่อขึ้นมา
 
-- `list` -> `lst`.
-- `userAgent` -> `ua`.
-- `browser` -> `brsr`.
-- ...etc
+แบบนี้:
 
-Only the one with truly good intuition will be able to understand such names. Try to shorten everything. Only a worthy person should be able to uphold the development of your code.
+- `list` -> `lst`
+- `userAgent` -> `ua`
+- `browser` -> `brsr` 
+- ...ฯลฯ
 
-## Soar high. Be abstract.
+มีเพียงคนที่มีสัญชาตญาณดีเยี่ยมเท่านั้นที่จะเข้าใจชื่อแบบนี้ได้ พยายามย่อทุกอย่าง มีแต่คนที่เหมาะสมเท่านั้นที่จะสามารถดูแลพัฒนาโค้ดของคุณต่อได้
 
-```quote author="Laozi (Tao Te Ching)"
-The great square is cornerless<br>
-The great vessel is last complete,<br>
-The great note is rarified sound,<br>
-The great image has no form.
-```
+## โบยบินสูงส่ง ดั่งนามธรรม
 
-While choosing a name try to use the most abstract word. Like `obj`, `data`, `value`, `item`, `elem` and so on.
+```quote author="เล่าจื๊อ (เต๋าเต๋อจิง)"
+สี่เหลี่ยมใหญ่ไร้มุมแหลมคม
+ภาชนะยิ่งใหญ่เสร็จสิ้นท้ายสุด
+เสียงอันไพเราะคือความเบาบาง
+ภาพอันยิ่งใหญ่ไร้รูปทรง
+```
 
-- **The ideal name for a variable is `data`.** Use it everywhere you can. Indeed, every variable holds *data*, right?
+ในการตั้งชื่อ พยายามเลือกใช้คำที่เป็นนามธรรมที่สุด เช่น `obj`, `data`, `value`, `item`, `elem` และอื่นๆ
 
-    ...But what to do if `data` is already taken? Try `value`, it's also universal. After all, a variable eventually gets a *value*.
+- **`data` คือชื่อตัวแปรในอุดมคติ** ใช้มันทุกที่ที่ทำได้ เพราะตัวแปรทุกตัวมี *ข้อมูล* จริงไหม?
 
-- **Name a variable by its type: `str`, `num`...**
+    ...แต่ถ้า `data` ถูกใช้ไปแล้วล่ะ? ลองใช้ `value` แทน เพราะมันก็เป็นคำสากลเหมือนกัน ท้ายที่สุดตัวแปรก็มี *ค่า* อยู่ดี
 
-    Give them a try. A young initiate may wonder -- are such names really useful for a ninja? Indeed, they are!
+- **ตั้งชื่อตัวแปรตามชนิดข้อมูล: `str`, `num`...**
 
-    Sure, the variable name still means something. It says what's inside the variable: a string, a number or something else. But when an outsider tries to understand the code, they'll be surprised to see that there's actually no information at all! And will ultimately fail to alter your well-thought code.
+    ลองใช้ดู มือใหม่อาจสงสัยว่าชื่อแบบนั้นมีประโยชน์จริงหรือสำหรับนินจา? แน่นอน มีประโยชน์จริงๆ!
 
-    The value type is easy to find out by debugging. But what's the meaning of the variable? Which string/number does it store?
+    ชื่อตัวแปรก็ยังพอบอกอะไรได้บ้าง มันบอกว่าข้างในเก็บอะไร: สตริง, ตัวเลข หรืออย่างอื่น แต่ถ้าคนนอกพยายามอ่านโค้ด เขาจะแปลกใจเมื่อพบว่ามันไม่ได้ให้ข้อมูลอะไรเลย! และก็จะแก้โค้ดที่คุณคิดมาอย่างดีไม่ได้สักที
 
-    There's just no way to figure out without a good meditation!
+    หาชนิดข้อมูลได้ง่ายโดยการดีบัก แต่ความหมายของตัวแปรล่ะ? มันเก็บสตริง/ตัวเลขอะไรกันแน่?
 
-- **...But what if there are no more such names?** Just add a number: `data1, item2, elem5`...
+    ไม่มีทางรู้ได้เลย นอกจากจะทำสมาธิให้ดี!
 
-## Attention test
+- **...แล้วถ้าชื่อแบบนั้นไม่เหลือแล้วล่ะ?** ก็แค่เติมตัวเลขต่อท้าย: `data1, item2, elem5`...
 
-Only a truly attentive programmer should be able to understand your code. But how to check that?
+## ทดสอบความใส่ใจ
 
-**One of the ways -- use similar variable names, like `date` and `data`.**
+มีแค่โปรแกรมเมอร์ที่ใส่ใจจริงๆ เท่านั้นถึงจะเข้าใจโค้ดของคุณได้ แต่จะตรวจสอบได้ยังไง?
 
-Mix them where you can.
+**หนึ่งในวิธีคือใช้ชื่อตัวแปรที่คล้ายกัน เช่น `date` กับ `data`**
 
-A quick read of such code becomes impossible. And when there's a typo... Ummm... We're stuck for long, time to drink tea.
+ใช้สลับกันไปมาตามที่ทำได้ 
 
+การอ่านโค้ดผ่านๆ จะเป็นไปไม่ได้เลย แล้วถ้ามีการพิมพ์ผิดอีก... อืม... คงได้ติดอยู่กับมันนาน ถึงเวลาไปดื่มชากันแล้ว
 
-## Smart synonyms
+## คำพ้องความหมาย
 
-```quote author="Laozi (Tao Te Ching)"
-The Tao that can be told is not the eternal Tao. The name that can be named is not the eternal name.
+```quote author="เล่าจื๊อ (เต๋าเต๋อจิง)"  
+เต๋าที่กล่าวได้มิใช่เต๋านิรันดร์ นามที่เอ่ยได้มิใช่นามอมตะ
 ```
 
-Using *similar* names for *same* things makes life more interesting and shows your creativity to the public.
+การใช้ชื่อ *คล้ายๆ กัน* กับสิ่งที่ *เหมือนๆ กัน* ทำให้ชีวิตสนุกขึ้น และแสดงความคิดสร้างสรรค์ของคุณให้คนอื่นเห็น
 
-For instance, consider function prefixes. If a function shows a message on the screen -- start it with `display…`, like `displayMessage`. And then if another function shows on the screen something else, like a user name, start it with `show…` (like `showName`).
+เช่น คำนำหน้าฟังก์ชัน ถ้าฟังก์ชันแสดงข้อความบนจอ ให้ขึ้นต้นด้วย `display...` อย่าง `displayMessage` แล้วถ้ามีอีกฟังก์ชันที่แสดงอย่างอื่นบนจอ เช่นชื่อผู้ใช้ ก็ขึ้นต้นด้วย `show...` แทน (อย่าง `showName`)
 
-Insinuate that there's a subtle difference between such functions, while there is none.
+ทำให้รู้สึกเหมือนมันมีความต่างแบบประณีต ทั้งที่จริงๆ ไม่ได้ต่างกันเลย
 
-Make a pact with fellow ninjas of the team: if John starts "showing" functions with `display...` in his code, then Peter could use `render..`, and Ann -- `paint...`. Note how much more interesting and diverse the code became.
+ทำสัญญากับเพื่อนนินจาในทีมว่า ถ้าจอห์นเริ่มฟังก์ชัน "แสดง" ด้วย `display...` ในโค้ดของเขา ปีเตอร์จะใช้ `render...` ส่วนแอนใช้ `paint...` สังเกตว่าโค้ดจะน่าสนใจและหลากหลายมากขึ้นแค่ไหน
 
-...And now the hat trick!
+...แล้วนี่คือไม้เด็ด!
 
-For two functions with important differences -- use the same prefix!
+สำหรับสองฟังก์ชันที่แตกต่างกันชัดเจน ให้ใช้คำนำหน้าเดียวกัน!
 
-For instance, the function `printPage(page)` will use a printer. And the function `printText(text)` will put the text on-screen. Let an unfamiliar reader think well over similarly named function `printMessage`: "Where does it put the message? To a printer or on the screen?". To make it really shine, `printMessage(message)` should output it in the new window!
+อย่างเช่น ฟังก์ชัน `printPage(page)` จะส่งไปเครื่องพิมพ์ ส่วน `printText(text)` จะแสดงข้อความบนจอ ให้คนอ่านที่ไม่คุ้นคิดหนักกับฟังก์ชัน `printMessage` ที่มีชื่อคล้ายๆ กันว่า "มันส่งข้อความไปไหนนะ เครื่องพิมพ์หรือบนจอ?" จะเจ๋งขึ้นไปอีกถ้า `printMessage(message)` แสดงผลในหน้าต่างใหม่!
 
-## Reuse names
+## ใช้ชื่อซ้ำ 
 
-```quote author="Laozi (Tao Te Ching)"
-Once the whole is divided, the parts<br>
-need names.<br>
-There are already enough names.<br>
-One must know when to stop.
+```quote author="เล่าจื๊อ (เต๋าเต๋อจิง)"
+เมื่อแบ่งสรรพสิ่งออกเป็นส่วนย่อย
+แต่ละส่วนล้วนต้องการชื่อเรียกขาน
+นามทั้งหลายมีอยู่มากมายแล้ว
+รู้จักพอคือคุณูปการอันล้ำค่า
 ```
 
-Add a new variable only when absolutely necessary.
+อย่าเพิ่มตัวแปรใหม่ถ้าไม่จำเป็นจริงๆ 
 
-Instead, reuse existing names. Just write new values into them.
+แทนที่จะทำแบบนั้น ให้นำชื่อที่มีอยู่แล้วมาใช้ใหม่ แค่เขียนค่าใหม่ลงไปแทนที่ค่าเดิม
 
-In a function try to use only variables passed as parameters.
+ภายในฟังก์ชัน พยายามใช้เฉพาะตัวแปรที่ส่งเข้ามาเป็นพารามิเตอร์เท่านั้น
 
-That would make it really hard to identify what's exactly in the variable *now*. And also where it comes from. The purpose is to develop the intuition and memory of a person reading the code. A person with weak intuition would have to analyze the code line-by-line and track the changes through every code branch.
+วิธีนี้จะทำให้แทบเป็นไปไม่ได้เลยที่จะระบุได้ว่าอะไรอยู่ในตัวแปร *ตอนนี้* และมาจากไหน จุดประสงค์คือเพื่อฝึกสัญชาตญาณและความจำของคนที่อ่านโค้ด คนที่สัญชาตญาณไม่ดีจะต้องวิเคราะห์โค้ดทีละบรรทัดและติดตามการเปลี่ยนแปลงข้ามทุกการแตกแขนงของโค้ด
 
-**An advanced variant of the approach is to covertly (!) replace the value with something alike in the middle of a loop or a function.**
+**รูปแบบขั้นสูงของวิธีนี้คือการแอบ (!) เปลี่ยนค่าเป็นอย่างอื่นที่คล้ายๆ กันระหว่างวนลูปหรือทำงานในฟังก์ชัน**
 
-For instance:
+ตัวอย่างเช่น:
 
 ```js
 function ninjaFunction(elem) {
-  // 20 lines of code working with elem
+  // 20 บรรทัดโค้ดที่ทำงานกับ elem 
 
   elem = clone(elem);
 
-  // 20 more lines, now working with the clone of the elem!
+  // อีก 20 บรรทัด ตอนนี้ทำงานกับ clone ของ elem!
 }
 ```
 
-A fellow programmer who wants to work with `elem` in the second half of the function will be surprised... Only during the debugging, after examining the code they will find out that they're working with a clone!
-
-Seen in code regularly. Deadly effective even against an experienced ninja.
+โปรแกรมเมอร์ที่ต้องการทำงานกับ `elem` ในครึ่งหลังของฟังก์ชันจะงงแน่ๆ... จนกว่าจะลองดีบักและไล่ดูโค้ด ถึงจะรู้ว่ากำลังทำงานกับตัวโคลนอยู่!
 
-## Underscores for fun
+เจอแบบนี้ในโค้ดบ่อยมาก ได้ผลดีถึงตายแม้กับนินจาจอมเก๋า
 
-Put underscores `_` and `__` before variable names. Like `_name` or `__value`. It would be great if only you knew their meaning. Or, better, add them just for fun, without particular meaning at all. Or different meanings in different places.
+## ใช้ underscore ให้สนุก
 
-You kill two rabbits with one shot. First, the code becomes longer and less readable, and the second, a fellow developer may spend a long time trying to figure out what the underscores mean.
+ใส่ underscore `_` และ `__` ข้างหน้าชื่อตัวแปร เช่น `_name` หรือ `__value` ถ้ามีแค่คุณที่รู้ความหมายคงจะดีมาก หรือดีกว่านั้น ใส่มันลงไปเพื่อความสนุกเฉยๆ โดยไม่มีความหมายพิเศษอะไรเลย หรือมีความหมายต่างกันในแต่ละที่ก็ได้
 
-A smart ninja puts underscores at one spot of code and evades them at other places. That makes the code even more fragile and increases the probability of future errors.
+คุณจะฆ่าสองนกในหินก้อนเดียว หนึ่ง โค้ดจะยาวขึ้นและอ่านยากขึ้น และสอง เพื่อนนักพัฒนาอาจเสียเวลาไปเยอะกับการพยายามหาว่า underscore หมายถึงอะไร 
 
-## Show your love
+นินจาเก๋าจะวาง underscore ไว้ที่หนึ่งในโค้ด แล้วไม่ใส่อีกที่นึง นั่นจะยิ่งทำให้โค้ดเปราะบางและเพิ่มโอกาสเกิดข้อผิดพลาดในอนาคต
 
-Let everyone see how magnificent your entities are! Names like `superElement`, `megaFrame` and `niceItem` will definitely enlighten a reader.
+## แสดงความรัก
 
-Indeed, from one hand, something is written: `super..`, `mega..`, `nice..` But from the other hand -- that brings no details. A reader may decide to look for a hidden meaning and meditate for an hour or two of their paid working time.
+ให้ทุกคนได้เห็นความวิเศษของ entity ต่างๆ ของคุณ! ชื่อเช่น `superElement`, `megaFrame` และ `niceItem` จะทำให้ผู้อ่านรู้สึกเปล่งประกายแน่ๆ
 
+ก็จริงอยู่ มีอะไรบางอย่างถูกเขียนไว้: `super..`, `mega..`, `nice..` แต่ในอีกแง่หนึ่ง มันก็ไม่ได้ให้รายละเอียดอะไรเลย ผู้อ่านอาจตัดสินใจค้นหาความหมายที่ซ่อนอยู่และนั่งสมาธิสักชั่วโมงสองชั่วโมงในเวลางานที่ได้ค่าจ้าง
 
-## Overlap outer variables
+## ใช้ชื่อซ้ำกับตัวแปรด้านนอก
 
-```quote author="Guan Yin Zi"
-When in the light, can't see anything in the darkness.<br>
-When in the darkness, can see everything in the light.
+```quote author="กวนอินจื้อ"
+ท่ามกลางแสงมืดมิดไร้ภาพ
+ในความมืดกลับประจักษ์แสงสว่าง
+สองขั้วต่างพึ่งพาอาศัย
+เผยนัยลึกล้ำแห่งสรรพสิ่ง
 ```
 
-Use same names for variables inside and outside a function. As simple. No efforts to invent new names.
+ใช้ชื่อเดียวกันสำหรับตัวแปรทั้งในและนอกฟังก์ชัน แค่นี้แหละ ไม่ต้องพยายามคิดชื่อใหม่
 
 ```js
 let *!*user*/!* = authenticateUser();
@@ -187,54 +184,52 @@ let *!*user*/!* = authenticateUser();
 function render() {
   let *!*user*/!* = anotherValue();
   ...
-  ...many lines...
+  ...หลายบรรทัด...
   ...
-  ... // <-- a programmer wants to work with user here and...
+  ... // <-- โปรแกรมเมอร์อยากทำงานกับ user ตรงนี้และ... 
   ...
 }
 ```
 
-A programmer who jumps inside the `render` will probably fail to notice that there's a local `user` shadowing the outer one.
-
-Then they'll try to work with `user` assuming that it's the external variable, the result of `authenticateUser()`... The trap is sprung! Hello, debugger...
-
+โปรแกรมเมอร์ที่ข้ามเข้ามาใน `render` อาจไม่ทันสังเกตว่ามี `user` ในฟังก์ชันกำลังบดบัง `user` ด้านนอกอยู่
 
-## Side-effects everywhere!
+แล้วเขาจะพยายามทำงานกับ `user` โดยคิดว่ามันคือตัวแปรจากภายนอก ซึ่งเป็นผลลัพธ์จาก `authenticateUser()` ... กับดักถูกปล่อยแล้ว! สวัสดี debugger ...
 
-There are functions that look like they don't change anything. Like `isReady()`, `checkPermission()`, `findTags()`... They are assumed to carry out calculations, find and return the data, without changing anything outside of them. In other words, without "side-effects".
+## ผลข้างเคียงได้ทุกที่!
 
-**A really beautiful trick is to add a "useful" action to them, besides the main task.**
+มีฟังก์ชันบางอย่างที่ดูเหมือนไม่ได้เปลี่ยนแปลงอะไรเลย เช่น `isReady()`, `checkPermission()`, `findTags()` ... มักคาดหวังว่าฟังก์ชันพวกนี้จะคำนวณ ค้นหา และคืนข้อมูล โดยไม่แปรเปลี่ยนสิ่งใดภายนอก หรือก็คือ ไม่มี "ผลข้างเคียง"
 
-An expression of dazed surprise on the face of your colleague when they see a function named `is..`, `check..` or `find...` changing something -- will definitely broaden your boundaries of reason.
+**กลเม็ดสุดเจ๋งคือแอบใส่การกระทำที่ "มีประโยชน์" เข้าไป นอกเหนือจากงานหลัก**
 
-**Another way to surprise is to return a non-standard result.**
+สีหน้าประหลาดใจงงงวยของเพื่อนร่วมงาน เมื่อเห็นฟังก์ชันชื่อ `is..`, `check..` หรือ `find...` ที่ดันไปเปลี่ยนแปลงอะไรบางอย่าง จะช่วยขยายขอบเขตความคิดของคุณแน่นอน
 
-Show your original thinking! Let the call of `checkPermission` return not `true/false`, but a complex object with the results of the check.
+**อีกวิธีที่จะสร้างความประหลาดใจคือส่งคืนผลลัพธ์แบบไม่ปกติ**
 
-Those developers who try to write `if (checkPermission(..))`, will wonder why it doesn't work. Tell them: "Read the docs!". And give this article.
+แสดงความคิดริเริ่มของคุณ! ให้ `checkPermission` คืนค่าไม่ใช่แค่ `true/false` แต่เป็นอ็อบเจ็กต์ที่ซับซ้อนพร้อมผลการตรวจสอบ
 
+นักพัฒนาที่พยายามเขียน `if (checkPermission(..))` จะสงสัยว่าทำไมมันถึงใช้ไม่ได้ บอกพวกเขาไปเลยว่า "อ่านเอกสารกำกับสิ!" แล้วก็ส่งลิงก์บทความนี้ให้
 
-## Powerful functions!
+## ฟังก์ชันอันทรงพลัง!
 
-```quote author="Laozi (Tao Te Ching)"
-The great Tao flows everywhere,<br>
-both to the left and to the right.
+```quote author="เล่าจื๊อ (เต๋าเต๋อจิง)"
+มหาเต๋าไหลทั่วทุกหนแห่ง
+ทั้งซ้ายขวาล้วนซึมซาบ
 ```
 
-Don't limit the function by what's written in its name. Be broader.
+อย่าจำกัดฟังก์ชันด้วยสิ่งที่เขียนไว้ในชื่อของมัน จงมองให้กว้างไกลกว่านั้น
 
-For instance, a function `validateEmail(email)` could (besides checking the email for correctness) show an error message and ask to re-enter the email.
+ยกตัวอย่างเช่น ฟังก์ชัน `validateEmail(email)` อาจแสดงข้อผิดพลาดและขอให้กรอกอีเมลใหม่ด้วย (นอกเหนือจากการตรวจสอบความถูกต้องของอีเมล)
 
-Additional actions should not be obvious from the function name. A true ninja coder will make them not obvious from the code as well.
+การกระทำเพิ่มเติมไม่ควรชัดเจนจากชื่อฟังก์ชัน นินจาเขียนโค้ดตัวจริงจะทำให้มองไม่ออกจากในโค้ดเช่นกัน
 
-**Joining several actions into one protects your code from reuse.**
+**การรวมหลายการกระทำเข้าด้วยกันจะปกป้องโค้ดของคุณจากการนำไปใช้ซ้ำ**
 
-Imagine, another developer wants only to check the email, and not output any message. Your function  `validateEmail(email)` that does both will not suit them. So they won't break your meditation by asking anything about it.
+สมมติว่ามีนักพัฒนาอีกคนต้องการแค่เช็คอีเมลเฉยๆ โดยไม่ต้องแสดงข้อความใดๆ ฟังก์ชัน `validateEmail(email)` ของคุณที่ทำงานทั้งสองอย่างจะไม่เหมาะกับเขา แบบนี้เขาจะไม่มารบกวนสมาธิของคุณด้วยการมาถามคำถามใดๆ เกี่ยวกับมัน
 
-## Summary
+## สรุป
 
-All "pieces of advice" above are from the real code... Sometimes, written by experienced developers. Maybe even more experienced than you are ;)
+"เคล็ดลับ" ข้างต้นทั้งหมดมาจากโค้ดของจริง... บางครั้งเขียนโดยนักพัฒนาผู้มากประสบการณ์ บางทีอาจจะมากกว่าคุณด้วยซ้ำ ;)
 
-- Follow some of them, and your code will become full of surprises.
-- Follow many of them, and your code will become truly yours, no one would want to change it.
-- Follow all, and your code will become a valuable lesson for young developers looking for enlightenment.
+- ทำตามบางข้อ และโค้ดของคุณจะเต็มไปด้วยเรื่องน่าประหลาดใจ
+- ทำตามหลายๆ ข้อ และโค้ดจะกลายเป็นของคุณโดยแท้จริง ไม่มีใครอยากเปลี่ยนแปลงมัน
+- ทำตามทุกข้อ และโค้ดของคุณจะกลายเป็นบทเรียนอันล้ำค่าสำหรับนักพัฒนาหน้าใหม่ผู้แสวงหาการรู้แจ้ง
diff --git a/1-js/03-code-quality/05-testing-mocha/article.md b/1-js/03-code-quality/05-testing-mocha/article.md
index 4c2b1aa5e..2e6c01305 100644
--- a/1-js/03-code-quality/05-testing-mocha/article.md
+++ b/1-js/03-code-quality/05-testing-mocha/article.md
@@ -1,72 +1,86 @@
-# Automated testing with Mocha
+# การทดสอบอัตโนมัติด้วย Mocha
 
-Automated testing will be used in further tasks, and it's also widely used in real projects.
+ในงานต่อๆ ไปจะมีการใช้การทดสอบอัตโนมัติ ซึ่งเป็นสิ่งที่ใช้กันอย่างแพร่หลายในโปรเจ็กต์จริงด้วย
 
-## Why do we need tests?
+## ทำไมต้องมีการทดสอบ?
 
-When we write a function, we can usually imagine what it should do: which parameters give which results.
+เวลาเขียนฟังก์ชัน เรามักจะจินตนาการได้ว่ามันควรจะทำงานอย่างไร พารามิเตอร์แบบไหนให้ผลลัพธ์แบบไหน
 
-During development, we can check the function by running it and comparing the outcome with the expected one. For instance, we can do it in the console.
+ระหว่างพัฒนา เราตรวจสอบฟังก์ชันได้โดยการรันและเปรียบเทียบผลลัพธ์กับสิ่งที่คาดหวังไว้ เช่น อาจทำในคอนโซล
 
-If something is wrong -- then we fix the code, run again, check the result -- and so on till it works.
+ถ้ามีอะไรผิดพลาด ก็แก้โค้ด รันใหม่ เช็คผลลัพธ์ วนไปแบบนี้จนกว่าจะใช้ได้
 
-But such manual "re-runs" are imperfect.
+แต่การ "รันซ้ำ" ด้วยมือแบบนั้นยังไม่สมบูรณ์แบบ
 
-**When testing a code by manual re-runs, it's easy to miss something.**
+**เมื่อทดสอบโค้ดโดยการรันซ้ำเอง มักจะมีบางอย่างหลุดไปได้ง่าย**
 
-For instance, we're creating a function `f`. Wrote some code, testing: `f(1)` works, but `f(2)` doesn't work. We fix the code and now `f(2)` works. Looks complete? But we forgot to re-test `f(1)`. That may lead to an error.
+ยกตัวอย่างเช่น สมมติเรากำลังเขียนฟังก์ชัน `f` เขียนโค้ดนิดหน่อย ลองทดสอบดู `f(1)` ใช้ได้ แต่ `f(2)` ไม่ทำงาน เราแก้โค้ดแล้วตอนนี้ `f(2)` ก็ใช้ได้แล้ว ดูเหมือนจะครบแล้วใช่ไหม แต่เราลืมย้อนกลับไปเทสต์ `f(1)` ใหม่ ซึ่งอาจจะมีข้อผิดพลาดโผล่ขึ้นมาก็ได้
 
-That's very typical. When we develop something, we keep a lot of possible use cases in mind. But it's hard to expect a programmer to check all of them manually after every change. So it becomes easy to fix one thing and break another one.
+นี่เป็นเรื่องปกติมาก ตอนที่เรากำลังพัฒนาอะไรบางอย่าง มักจะมีหลายกรณีการใช้งานที่เราต้องคำนึงถึง แต่การที่จะให้โปรแกรมเมอร์มานั่งเช็คทุกกรณีด้วยตัวเองทุกครั้งที่มีการเปลี่ยนแปลง เป็นเรื่องยาก เลยกลายเป็นว่าแก้ไขอย่างหนึ่ง แล้วไปทำให้อีกอย่างพังได้ง่าย
 
-**Automated testing means that tests are written separately, in addition to the code. They run our functions in various ways and compare results with the expected.**
+**การทดสอบอัตโนมัติหมายถึงการเขียนเทสต์แยกออกมาต่างหาก เป็นส่วนเสริมของโค้ด เทสต์เหล่านั้นจะรันฟังก์ชันของเราในหลากหลายวิธี และเปรียบเทียบผลลัพธ์กับสิ่งที่คาดหวัง**
 
 ## Behavior Driven Development (BDD)
 
-Let's start with a technique named [Behavior Driven Development](http://en.wikipedia.org/wiki/Behavior-driven_development) or, in short, BDD.
+เรามาเริ่มต้นด้วยเทคนิคที่เรียกว่า [Behavior Driven Development](http://en.wikipedia.org/wiki/Behavior-driven_development) หรือเรียกสั้นๆ ว่า BDD กัน
 
-**BDD is three things in one: tests AND documentation AND examples.**
+**BDD คือ 3 สิ่งในหนึ่งเดียว ทั้งเทสต์ เอกสาร และตัวอย่างการใช้งาน**
 
-To understand BDD, we'll examine a practical case of development.
+เพื่อทำความเข้าใจ BDD เราจะมาดูตัวอย่างกรณีศึกษาในการพัฒนาซอฟต์แวร์กัน
 
-## Development of "pow": the spec
+## การพัฒนา "pow": ข้อกำหนด
 
-Let's say we want to make a function `pow(x, n)` that raises `x` to an integer power `n`. We assume that `n≥0`.
+สมมติว่าเราอยากเขียนฟังก์ชัน `pow(x, n)` ที่คืนค่า `x` ยกกำลังด้วยเลขชี้กำลังจำนวนเต็ม `n` โดยเราสมมติว่า `n≥0`
 
-That task is just an example: there's the `**` operator in JavaScript that can do that, but here we concentrate on the development flow that can be applied to more complex tasks as well.
+จริงๆ แล้วนี่เป็นแค่ตัวอย่าง เพราะในจาวาสคริปต์มีตัวดำเนินการ `**` ที่ทำแบบนี้ได้อยู่แล้ว แต่ตรงนี้เราจะมุ่งเน้นไปที่วิธีการพัฒนาที่สามารถนำไปประยุกต์ใช้กับงานที่ซับซ้อนกว่านี้ได้ด้วย
 
-Before creating the code of `pow`, we can imagine what the function should do and describe it.
+ก่อนจะเขียนโค้ดของ `pow` เราสามารถจินตนาการถึงสิ่งที่ฟังก์ชันควรจะทำและบรรยายมันไว้ก่อนได้
 
-Such description is called a *specification* or, in short, a spec, and contains descriptions of use cases together with tests for them, like this:
+คำบรรยายแบบนี้เรียกว่า *ข้อกำหนด (specification)* หรือเรียกสั้นๆ ว่า spec ซึ่งจะประกอบด้วยรายละเอียดกรณีการใช้งานต่างๆ ร่วมกับเทสต์สำหรับกรณีเหล่านั้น ดังนี้
 
 ```js
 describe("pow", function() {
 
-  it("raises to n-th power", function() {
+  it("ยกกำลัง n", function() {
     assert.equal(pow(2, 3), 8);
   });
 
 });
 ```
 
-A spec has three main building blocks that you can see above:
+spec มีองค์ประกอบหลัก 3 ส่วนตามที่เห็นข้างบน
 
+<<<<<<< HEAD
+`describe("ชื่อหัวข้อ", function() { ... })`
+: เรากำลังอธิบายฟังก์ชันอะไร? ในกรณีนี้คือฟังก์ชัน `pow` ใช้เพื่อจัดกลุ่มบล็อก `it` ที่เป็น "ผู้ทำงาน"
+=======
 `describe("title", function() { ... })`
 : What functionality we're describing? In our case we're describing the function `pow`. Used to group "workers" -- the `it` blocks.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-`it("use case description", function() { ... })`
-: In the title of `it` we *in a human-readable way* describe the particular use case, and the second argument is a function that tests it.
+`it("คำอธิบายกรณีการใช้งาน", function() { ... })`  
+: ในชื่อของ `it` จะบรรยาย *ในรูปแบบที่คนอ่านแล้วเข้าใจ* ถึงกรณีการใช้งานเฉพาะ และอาร์กิวเมนต์ตัวที่สองก็จะเป็นฟังก์ชันที่ทดสอบกรณีดังกล่าว
 
 `assert.equal(value1, value2)`
-: The code inside `it` block, if the implementation is correct, should execute without errors.
+: โค้ดภายในบล็อก `it` ถ้าอิมพลีเมนต์ถูกต้อง ควรจะรันได้โดยไม่เกิดข้อผิดพลาด
 
-    Functions `assert.*` are used to check whether `pow` works as expected. Right here we're using one of them -- `assert.equal`, it compares arguments and yields an error if they are not equal. Here it checks that the result of `pow(2, 3)` equals `8`. There are other types of comparisons and checks, that we'll add later.
+  ฟังก์ชัน `assert.*` ถูกใช้เพื่อเช็คว่า `pow` ทำงานได้ตามที่คาดหวังหรือไม่ ตรงนี้เราใช้ตัวหนึ่งในนั้นคือ `assert.equal` มันจะเปรียบเทียบอาร์กิวเมนต์และโยนข้อผิดพลาดถ้าไม่เท่ากัน ซึ่งตรงนี้เช็คว่าผลลัพธ์ของ `pow(2, 3)` เท่ากับ `8` รึเปล่า นอกจากนี้ยังมีชนิดอื่นๆ ของการเปรียบเทียบและตรวจสอบด้วย ซึ่งเราจะมาเพิ่มภายหลัง
 
-The specification can be executed, and it will run the test specified in `it` block. We'll see that later.
+spec นี้สามารถรันได้ และมันจะไปรันเทสต์ที่อยู่ในบล็อก `it` เราจะมาดูเรื่องนี้กันในภายหลัง
 
-## The development flow
+## ขั้นตอนการพัฒนา
 
-The flow of development usually looks like this:
+ขั้นตอนการพัฒนามักจะเป็นแบบนี้:
 
+<<<<<<< HEAD
+1. เขียนข้อกำหนด (spec) เบื้องต้น พร้อมกับเทสต์สำหรับฟังก์ชันที่พื้นฐานที่สุด
+2. สร้างการอิมพลีเมนต์เบื้องต้น
+3. เพื่อตรวจสอบว่ามันใช้ได้ไหม เราจะรันเฟรมเวิร์กการทดสอบ [Mocha](https://mochajs.org/) (จะมีรายละเอียดเพิ่มเติมเร็วๆ นี้) ที่จะรันข้อกำหนด ถ้าฟังก์ชันยังไม่ครบถ้วน ข้อผิดพลาดก็จะถูกแสดง เราจะทยอยแก้ไขจนกว่าทุกอย่างจะทำงาน
+4. ตอนนี้เรามีการอิมพลีเมนต์เบื้องต้นที่ใช้ได้จริงพร้อมกับเทสต์แล้ว
+5. เราเพิ่มกรณีการใช้งานเข้าไปในข้อกำหนด ซึ่งอาจยังไม่ได้รองรับโดยการอิมพลีเมนต์ เทสต์เริ่มล้มเหลว
+6. กลับไปทำข้อ 3 ปรับแก้การอิมพลีเมนต์จนกระทั่งเทสต์ไม่มีข้อผิดพลาด
+7. ทำข้อ 3-6 ซ้ำไปเรื่อยๆ จนกระทั่งฟังก์ชันลิตี้เสร็จสมบูรณ์
+=======
 1. An initial spec is written, with tests for the most basic functionality.
 2. An initial implementation is created.
 3. To check whether it works, we run the testing framework [Mocha](https://mochajs.org/) (more details soon) that runs the spec. While the functionality is not complete, errors are displayed. We make corrections until everything works.
@@ -74,119 +88,131 @@ The flow of development usually looks like this:
 5. We add more use cases to the spec, probably not yet supported by the implementations. Tests start to fail.
 6. Go to 3, update the implementation till tests give no errors.
 7. Repeat steps 3-6 till the functionality is ready.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-So, the development is *iterative*. We write the spec, implement it, make sure tests pass, then write more tests, make sure they work etc. At the end we have both a working implementation and tests for it.
+ดังนั้น การพัฒนาจึงเป็นแบบ *วนซ้ำ (iterative)* เราเขียนข้อกำหนด อิมพลีเมนต์มัน ตรวจสอบให้แน่ใจว่าเทสต์ผ่าน จากนั้นเขียนเทสต์เพิ่ม ตรวจว่าเทสต์ทำงานไหม แล้วก็ทำแบบนี้ต่อไป ท้ายที่สุดเราจะได้ทั้งการอิมพลีเมนต์ที่ใช้งานได้จริง พร้อมกับเทสต์สำหรับมัน
 
-Let's see this development flow in our practical case.
+มาดูกระบวนการพัฒนานี้ในกรณีของเราเป็นรูปธรรมกันดีกว่า
 
+<<<<<<< HEAD
+ตอนนี้เราทำขั้นตอนแรกเสร็จแล้ว คือมีข้อกำหนดเบื้องต้นของ `pow` ซึ่งก่อนจะลงมือเขียนอิมพลีเมนต์ เรามาลองใช้ไลบรารี JavaScript บางตัวเพื่อรันเทสต์ดู แค่เพื่อจะได้เห็นว่าเทสต์เหล่านั้นทำงานอยู่ (ตอนนี้เทสต์ทั้งหมดน่าจะล้มเหลว)
+=======
 The first step is already complete: we have an initial spec for `pow`. Now, before making the implementation, let's use a few JavaScript libraries to run the tests, just to see that they are working (they will all fail).
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-## The spec in action
+## ข้อกำหนดที่ใช้งานจริง
 
-Here in the tutorial we'll be using the following JavaScript libraries for tests:
+ในบทเรียนนี้ เราจะใช้ไลบรารี JavaScript ต่อไปนี้ในการทดสอบ:
 
+<<<<<<< HEAD
+- [Mocha](https://mochajs.org/) -- เป็นเฟรมเวิร์กหลัก ให้ฟังก์ชันทดสอบทั่วไปต่างๆ รวมทั้ง `describe` และ `it` ตลอดจนฟังก์ชันหลักที่ใช้รันการทดสอบ
+- [Chai](https://www.chaijs.com/) -- ไลบรารีที่มี assertions มากมาย ช่วยให้ใช้ assertions หลากหลายแบบได้ สำหรับตอนนี้เราต้องการแค่ `assert.equal` 
+- [Sinon](https://sinonjs.org/) -- ไลบรารีที่ใช้เฝ้าดูฟังก์ชัน จำลองการทำงานของฟังก์ชันในตัว และอื่นๆ เราจะต้องใช้มันในภายหลัง
+=======
 - [Mocha](https://mochajs.org/) -- the core framework: it provides common testing functions including `describe` and `it` and the main function that runs tests.
 - [Chai](https://www.chaijs.com/) -- the library with many assertions. It allows to use a lot of different assertions, for now we need only `assert.equal`.
 - [Sinon](https://sinonjs.org/) -- a library to spy over functions, emulate built-in functions and more, we'll need it much later.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-These libraries are suitable for both in-browser and server-side testing. Here we'll consider the browser variant.
+ไลบรารีเหล่านี้สามารถใช้ทดสอบได้ทั้งฝั่งเบราว์เซอร์และเซิร์ฟเวอร์ แต่ที่นี่เราจะพูดถึงกรณีบนเบราว์เซอร์
 
-The full HTML page with these frameworks and `pow` spec:
+หน้า HTML เต็มรูปแบบที่มีเฟรมเวิร์กเหล่านี้พร้อมกับข้อกำหนดของ `pow`:
 
 ```html src="index.html"
 ```
 
-The page can be divided into five parts:
+หน้านี้ประกอบด้วย 5 ส่วน:
 
-1. The `<head>` -- add third-party libraries and styles for tests.
-2. The `<script>` with the function to test, in our case -- with the code for `pow`.
-3. The tests -- in our case an external script `test.js` that has `describe("pow", ...)` from above.
-4. The HTML element `<div id="mocha">` will be used by Mocha to output results.
-5. The tests are started by the command `mocha.run()`.
+1. ส่วน `<head>` -- เพิ่มไลบรารีจากภายนอกและสไตล์สำหรับเทสต์
+2. แท็ก `<script>` ที่มีฟังก์ชันที่เราต้องการทดสอบ ในกรณีนี้ก็คือโค้ดของ `pow`
+3. เทสต์ -- ของเราอยู่ในสคริปต์ภายนอกชื่อ `test.js` ที่มี `describe("pow", ...)` ดังเช่นที่เห็นด้านบน
+4. อิลีเมนต์ HTML `<div id="mocha">` จะถูกใช้โดย Mocha เพื่อแสดงผลลัพธ์
+5. เทสต์จะเริ่มทำงานด้วยคำสั่ง `mocha.run()`
 
-The result:
+ผลที่ได้:
 
 [iframe height=250 src="pow-1" border=1 edit]
 
-As of now, the test fails, there's an error. That's logical: we have an empty function code in `pow`, so `pow(2,3)` returns `undefined` instead of `8`.
+ณ ตอนนี้ เทสต์ล้มเหลว มีข้อผิดพลาดเกิดขึ้น ซึ่งก็สมเหตุสมผล เพราะเรามีโค้ดฟังก์ชันที่ว่างเปล่าใน `pow` ดังนั้น `pow(2,3)` จึงคืนค่า `undefined` แทนที่จะเป็น `8`
 
-For the future, let's note that there are more high-level test-runners, like [karma](https://karma-runner.github.io/) and others, that make it easy to autorun many different tests.
+เผื่อในอนาคต ขอบอกไว้ก่อนว่ายังมี test runner ระดับสูงกว่านี้อีก เช่น [karma](https://karma-runner.github.io/) และอื่นๆ อีกมากมาย ซึ่งช่วยให้รันเทสต์หลายๆ อันได้ง่ายขึ้น
 
-## Initial implementation
+## การเขียนอิมพลีเมนต์เบื้องต้น
 
-Let's make a simple implementation of `pow`, for tests to pass:
+มาเขียนอิมพลีเมนต์อย่างง่ายๆ ของ `pow` เพื่อให้เทสต์ผ่านกัน:
 
 ```js
 function pow(x, n) {
-  return 8; // :) we cheat!
+  return 8; // :) เราโกงนะ!
 }
 ```
 
-Wow, now it works!
+ว้าว! ตอนนี้มันทำงานแล้ว!
 
 [iframe height=250 src="pow-min" border=1 edit]
 
-## Improving the spec
+## ปรับปรุงข้อกำหนด
 
-What we've done is definitely a cheat. The function does not work: an attempt to calculate `pow(3,4)` would give an incorrect result, but tests pass.
+สิ่งที่เราทำไปนั่นถือเป็นการโกงอย่างแน่นอน ฟังก์ชันไม่ได้ทำงานจริง: หากลองคำนวณ `pow(3,4)` จะได้ผลลัพธ์ที่ไม่ถูกต้อง แต่การทดสอบกลับผ่าน
 
-...But the situation is quite typical, it happens in practice. Tests pass, but the function works wrong. Our spec is imperfect. We need to add more use cases to it.
+...แต่สถานการณ์แบบนี้ก็พบได้บ่อยในทางปฏิบัติ การทดสอบผ่าน แต่ฟังก์ชันทำงานผิด แสดงว่าข้อกำหนดของเรายังไม่ครบถ้วน เราต้องเพิ่มกรณีการใช้งานเข้าไปอีก
 
-Let's add one more test to check that `pow(3, 4) = 81`.
+มาเพิ่มการทดสอบอีกหนึ่งอันเพื่อตรวจสอบว่า `pow(3, 4) = 81` กัน
 
-We can select one of two ways to organize the test here:
+เราสามารถเลือกจัดการทดสอบตรงนี้ได้สองแบบ:
 
-1. The first variant -- add one more `assert` into the same `it`:
+1. แบบแรก -- เพิ่ม `assert` อีกอันเข้าไปใน `it` อันเดิม:
 
-    ```js
-    describe("pow", function() {
+   ```js
+   describe("pow", function() {
 
-      it("raises to n-th power", function() {
-        assert.equal(pow(2, 3), 8);
-    *!*
-        assert.equal(pow(3, 4), 81);
-    */!*
-      });
+     it("ยกกำลัง n", function() {
+       assert.equal(pow(2, 3), 8);
+   *!*
+       assert.equal(pow(3, 4), 81);
+   */!*
+     });
 
-    });
-    ```
-2. The second -- make two tests:
+   });
+   ```
 
-    ```js
-    describe("pow", function() {
+2. แบบที่สอง -- แยกเป็นสองการทดสอบ:
 
-      it("2 raised to power 3 is 8", function() {
-        assert.equal(pow(2, 3), 8);
-      });
+   ```js
+   describe("pow", function() {
 
-      it("3 raised to power 4 is 81", function() {
-        assert.equal(pow(3, 4), 81);
-      });
+     it("2 ยกกำลัง 3 เท่ากับ 8", function() {
+       assert.equal(pow(2, 3), 8);
+     });
 
-    });
-    ```
+     it("3 ยกกำลัง 4 เท่ากับ 81", function() {
+       assert.equal(pow(3, 4), 81);
+     });
+
+   });
+   ```
 
-The principal difference is that when `assert` triggers an error, the `it` block immediately terminates. So, in the first variant if the first `assert` fails, then we'll never see the result of the second `assert`.
+ความแตกต่างหลักคือ เมื่อ `assert` ทำให้เกิดข้อผิดพลาด บล็อก `it` จะจบลงทันที ดังนั้นในแบบแรก ถ้า `assert` แรกล้มเหลว เราจะไม่เห็นผลของ `assert` ตัวที่สองเลย
 
-Making tests separate is useful to get more information about what's going on, so the second variant is better.
+การแยกเทสต์ออกจากกันมีประโยชน์ในการให้ข้อมูลเพิ่มเติมว่ากำลังเกิดอะไรขึ้น ดังนั้นแบบที่สองจึงดีกว่า
 
-And besides that, there's one more rule that's good to follow.
+และนอกจากนั้น ยังมีอีกกฎหนึ่งที่ควรปฏิบัติตาม
 
-**One test checks one thing.**
+**หนึ่งการทดสอบตรวจสอบหนึ่งสิ่ง**
 
-If we look at the test and see two independent checks in it, it's better to split it into two simpler ones.
+ถ้าเรามองดูการทดสอบแล้วเห็นการตรวจสอบสองอย่างแยกจากกันอยู่ในนั้น การแยกมันออกเป็นสองการทดสอบที่เรียบง่ายกว่าจะดีกว่า
 
-So let's continue with the second variant.
+ดังนั้นเรามาใช้แบบที่สองกันต่อเลย
 
-The result:
+ผลลัพธ์:
 
 [iframe height=250 src="pow-2" edit border="1"]
 
-As we could expect, the second test failed. Sure, our function always returns `8`, while the `assert` expects `81`.
+อย่างที่เราคาดไว้ การทดสอบที่สองล้มเหลว แน่นอน ฟังก์ชันของเราคืนค่า `8` เสมอ ในขณะที่ `assert` คาดหวัง `81`
 
-## Improving the implementation
+## ปรับปรุงการอิมพลีเมนต์
 
-Let's write something more real for tests to pass:
+มาลองเขียนอะไรที่เป็นจริงมากขึ้นเพื่อให้ผ่านเทสต์กัน: 
 
 ```js
 function pow(x, n) {
@@ -200,14 +226,14 @@ function pow(x, n) {
 }
 ```
 
-To be sure that the function works well, let's test it for more values. Instead of writing `it` blocks manually, we can generate them in `for`:
+เพื่อให้มั่นใจว่าฟังก์ชันทำงานได้ถูกต้อง เรามาทดสอบกับค่าเพิ่มเติมอีก แทนที่จะเขียนบล็อก `it` ด้วยมือ เราสามารถใช้ลูป `for` ช่วยสร้างมันได้:
 
 ```js
 describe("pow", function() {
 
   function makeTest(x) {
     let expected = x * x * x;
-    it(`${x} in the power 3 is ${expected}`, function() {
+    it(`${x} ยกกำลัง 3 เท่ากับ ${expected}`, function() {
       assert.equal(pow(x, 3), expected);
     });
   }
@@ -219,26 +245,26 @@ describe("pow", function() {
 });
 ```
 
-The result:
+ผลลัพธ์:
 
 [iframe height=250 src="pow-3" edit border="1"]
 
-## Nested describe
+## การซ้อน describe
 
-We're going to add even more tests. But before that let's note that the helper function `makeTest` and `for` should be grouped together. We won't need `makeTest` in other tests, it's needed only in `for`: their common task is to check how `pow` raises into the given power.
+เรากำลังจะเพิ่มเทสต์อีกหลายอย่าง แต่ก่อนอื่นให้สังเกตว่าฟังก์ชันตัวช่วย `makeTest` และ `for` ควรถูกจัดกลุ่มไว้ด้วยกัน เราจะไม่ต้องใช้ `makeTest` ในเทสต์อื่นๆ มันจำเป็นแค่ใน `for` เท่านั้น: หน้าที่หลักร่วมกันของพวกมันคือตรวจสอบว่า `pow` ยกกำลังตามเลขชี้กำลังที่กำหนดได้อย่างไร
 
-Grouping is done with a nested `describe`:
+การจัดกลุ่มทำได้โดยใช้ `describe` ที่ซ้อนกัน:
 
 ```js
 describe("pow", function() {
 
 *!*
-  describe("raises x to power 3", function() {
+  describe("ยก x กำลัง 3", function() {
 */!*
 
     function makeTest(x) {
       let expected = x * x * x;
-      it(`${x} in the power 3 is ${expected}`, function() {
+      it(`${x} ยกกำลัง 3 เท่ากับ ${expected}`, function() {
         assert.equal(pow(x, 3), expected);
       });
     }
@@ -251,29 +277,29 @@ describe("pow", function() {
   });
 */!*
 
-  // ... more tests to follow here, both describe and it can be added
+  // ... เทสต์อื่นๆ จะต่อท้ายที่นี่ โดยเพิ่มทั้ง describe และ it ได้
 });
 ```
 
-The nested `describe` defines a new "subgroup" of tests. In the output we can see the titled indentation:
+`describe` ที่ซ้อนกันจะกำหนด "กลุ่มย่อย" ใหม่ของเทสต์ ในผลลัพธ์เราจะเห็นการเยื้องที่มีหัวข้อกำกับ:
 
 [iframe height=250 src="pow-4" edit border="1"]
 
-In the future we can add more `it` and `describe` on the top level with helper functions of their own, they won't see `makeTest`.
+ในอนาคตเราสามารถเพิ่ม `it` และ `describe` เพิ่มเติมในระดับบนสุดพร้อมฟังก์ชันช่วยเหลือของตัวเอง โดยที่พวกมันจะไม่เห็น `makeTest`
 
-````smart header="`before/after` and `beforeEach/afterEach`"
-We can setup `before/after` functions that execute before/after running tests, and also `beforeEach/afterEach` functions that execute before/after *every* `it`.
+```smart header="`before/after` และ `beforeEach/afterEach`"
+เราสามารถตั้งค่าฟังก์ชัน `before/after` ที่จะทำงานก่อน/หลังการรันเทสต์ และฟังก์ชัน `beforeEach/afterEach` ที่จะทำงานก่อน/หลัง `it` *ทุกครั้ง*
 
-For instance:
+ตัวอย่างเช่น:
 
 ```js no-beautify
 describe("test", function() {
 
-  before(() => alert("Testing started – before all tests"));
-  after(() => alert("Testing finished – after all tests"));
+  before(() => alert("เริ่มการทดสอบ – ก่อนเทสต์ทั้งหมด"));
+  after(() => alert("การทดสอบเสร็จสิ้น – หลังเทสต์ทั้งหมด"));
 
-  beforeEach(() => alert("Before a test – enter a test"));
-  afterEach(() => alert("After a test – exit a test"));
+  beforeEach(() => alert("ก่อนเทสต์ – เข้าสู่เทสต์"));
+  afterEach(() => alert("หลังเทสต์ – ออกจากเทสต์"));
 
   it('test 1', () => alert(1));
   it('test 2', () => alert(2));
@@ -281,46 +307,46 @@ describe("test", function() {
 });
 ```
 
-The running sequence will be:
+ลำดับการทำงานจะเป็นดังนี้:
 
 ```
-Testing started – before all tests (before)
-Before a test – enter a test (beforeEach)
+เริ่มการทดสอบ – ก่อนเทสต์ทั้งหมด (before)
+ก่อนเทสต์ – เข้าสู่เทสต์ (beforeEach)
 1
-After a test – exit a test   (afterEach)
-Before a test – enter a test (beforeEach)
-2
-After a test – exit a test   (afterEach)
-Testing finished – after all tests (after)
+หลังเทสต์ – ออกจากเทสต์   (afterEach)
+ก่อนเทสต์ – เข้าสู่เทสต์ (beforeEach)
+2 
+หลังเทสต์ – ออกจากเทสต์   (afterEach)
+การทดสอบเสร็จสิ้น – หลังเทสต์ทั้งหมด (after)
 ```
 
-[edit src="beforeafter" title="Open the example in the sandbox."]
+[edit src="beforeafter" title="เปิดตัวอย่างใน sandbox"]
 
-Usually, `beforeEach/afterEach` and `before/after` are used to perform initialization, zero out counters or do something else between the tests (or test groups).
+โดยทั่วไปแล้ว `beforeEach/afterEach` และ `before/after` มักใช้ในการเตรียมสภาพแวดล้อม, รีเซ็ตตัวนับ หรือทำอย่างอื่นระหว่างเทสต์ (หรือระหว่างกลุ่มเทสต์)
 ````
 
-## Extending the spec
+## ขยายข้อกำหนด
 
-The basic functionality of `pow` is complete. The first iteration of the development is done. When we're done celebrating and drinking champagne -- let's go on and improve it.
+ฟังก์ชันหลักของ `pow` เสร็จสมบูรณ์แล้ว การพัฒนารอบแรกจบลงแล้ว เมื่อเราฉลองและดื่มแชมเปญเสร็จ ก็ถึงเวลาพัฒนาต่อและปรับปรุงมันกัน
 
-As it was said, the function `pow(x, n)` is meant to work with positive integer values `n`.
+อย่างที่บอกไป ฟังก์ชัน `pow(x, n)` มีไว้สำหรับใช้กับค่า `n` ที่เป็นจำนวนเต็มบวก
 
-To indicate a mathematical error, JavaScript functions usually return `NaN`. Let's do the same for invalid values of `n`.
+เพื่อระบุข้อผิดพลาดทางคณิตศาสตร์ ฟังก์ชันใน JavaScript มักจะคืนค่า `NaN` เรามาทำแบบเดียวกันสำหรับค่า `n` ที่ไม่ถูกต้องกัน
 
-Let's first add the behavior to the spec(!):
+อย่างแรกเรามาเพิ่มพฤติกรรมนี้ลงในข้อกำหนด (!):
 
 ```js
 describe("pow", function() {
 
   // ...
 
-  it("for negative n the result is NaN", function() {
+  it("สำหรับ n ติดลบ ผลลัพธ์คือ NaN", function() {
 *!*
     assert.isNaN(pow(2, -1));
 */!*
   });
 
-  it("for non-integer n the result is NaN", function() {
+  it("สำหรับ n ที่ไม่ใช่จำนวนเต็ม ผลลัพธ์คือ NaN", function() {
 *!*
     assert.isNaN(pow(2, 1.5));    
 */!*
@@ -329,15 +355,25 @@ describe("pow", function() {
 });
 ```
 
-The result with new tests:
+ผลลัพธ์กับเทสต์ใหม่:
 
 [iframe height=530 src="pow-nan" edit border="1"]
 
-The newly added tests fail, because our implementation does not support them. That's how BDD is done: first we write failing tests, and then make an implementation for them.
+เทสต์ที่เพิ่มเข้ามาใหม่ล้มเหลว เพราะการอิมพลีเมนต์ของเรายังไม่รองรับกรณีเหล่านี้ นี่แหละคือวิธีการทำงานของ BDD: อย่างแรกเราเขียนเทสต์ที่ล้มเหลวก่อน แล้วค่อยไปเขียนอิมพลีเมนต์ให้มันผ่าน
+
+```smart header="Assertion อื่นๆ"
+สังเกตการใช้ assertion `assert.isNaN`: มันตรวจสอบค่า `NaN`
 
-```smart header="Other assertions"
-Please note the assertion `assert.isNaN`: it checks for `NaN`.
+<<<<<<< HEAD
+ใน [Chai](https://www.chaijs.com/) ยังมี assertion อื่นๆ อีกด้วย เช่น:
 
+- `assert.equal(value1, value2)` -- ตรวจสอบความเท่ากัน `value1 == value2`
+- `assert.strictEqual(value1, value2)` -- ตรวจสอบความเท่ากันแบบเข้มงวด `value1 === value2`
+- `assert.notEqual`, `assert.notStrictEqual` -- ตรวจสอบแบบตรงข้ามกับด้านบน
+- `assert.isTrue(value)` -- ตรวจสอบว่า `value === true`
+- `assert.isFalse(value)` -- ตรวจสอบว่า `value === false`
+- ...ดูรายการทั้งหมดได้ใน [เอกสาร](https://www.chaijs.com/api/assert/)
+=======
 There are other assertions in [Chai](https://www.chaijs.com/) as well, for instance:
 
 - `assert.equal(value1, value2)` -- checks the equality  `value1 == value2`.
@@ -346,9 +382,10 @@ There are other assertions in [Chai](https://www.chaijs.com/) as well, for insta
 - `assert.isTrue(value)` -- checks that `value === true`
 - `assert.isFalse(value)` -- checks that `value === false`
 - ...the full list is in the [docs](https://www.chaijs.com/api/assert/)
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 ```
 
-So we should add a couple of lines to `pow`:
+ดังนั้นเราควรเพิ่มโค้ดอีกสองสามบรรทัดใน `pow`:
 
 ```js
 function pow(x, n) {
@@ -367,43 +404,43 @@ function pow(x, n) {
 }
 ```
 
-Now it works, all tests pass:
+ตอนนี้มันใช้ได้แล้ว เทสต์ทั้งหมดผ่าน:
 
 [iframe height=300 src="pow-full" edit border="1"]
 
-[edit src="pow-full" title="Open the full final example in the sandbox."]
+[edit src="pow-full" title="เปิดตัวอย่างสมบูรณ์ใน sandbox"]
 
-## Summary
+## สรุป
 
-In BDD, the spec goes first, followed by implementation. At the end we have both the spec and the code.
+ใน BDD ข้อกำหนดจะมาก่อน ตามด้วยการอิมพลีเมนต์ ท้ายที่สุดเราจะได้ทั้งข้อกำหนดและโค้ด
 
-The spec can be used in three ways:
+ข้อกำหนดสามารถใช้ประโยชน์ได้ 3 ทาง:
 
-1. As **Tests** - they guarantee that the code works correctly.
-2. As **Docs** -- the titles of `describe` and `it` tell what the function does.
-3. As **Examples** -- the tests are actually working examples showing how a function can be used.
+1. เป็น **เทสต์** - รับรองว่าโค้ดทำงานถูกต้อง
+2. เป็น **เอกสาร** -- ชื่อของ `describe` และ `it` จะบอกว่าฟังก์ชันทำอะไร
+3. เป็น **ตัวอย่าง** -- เทสต์จริงๆ แล้วคือตัวอย่างการใช้งานที่แสดงวิธีใช้ฟังก์ชัน
 
-With the spec, we can safely improve, change, even rewrite the function from scratch and make sure it still works right.
+เมื่อมีข้อกำหนด เราสามารถปรับปรุง เปลี่ยนแปลง หรือแม้แต่เขียนฟังก์ชันใหม่ทั้งหมดได้อย่างมั่นใจ และแน่ใจว่ามันยังทำงานได้ถูกต้อง
 
-That's especially important in large projects when a function is used in many places. When we change such a function, there's just no way to manually check if every place that uses it still works right.
+สิ่งนี้สำคัญมากโดยเฉพาะในโปรเจ็กต์ขนาดใหญ่ที่มีการเรียกใช้ฟังก์ชันในหลายๆ ที่ เมื่อเราแก้ไขฟังก์ชันเหล่านั้น ไม่มีทางเลยที่จะตรวจสอบด้วยมือได้ว่าทุกที่ที่ใช้มันยังทำงานถูกต้องอยู่หรือเปล่า
 
-Without tests, people have two ways:
+หากไม่มีเทสต์ ผู้คนมีทางเลือกอยู่สองทาง:
 
-1. To perform the change, no matter what. And then our users meet bugs, as we probably fail to check something manually.
-2. Or, if the punishment for errors is harsh, as there are no tests, people become afraid to modify such functions, and then the code becomes outdated, no one wants to get into it. Not good for development.
+1. ทำการเปลี่ยนแปลงโดยไม่คิดอะไรมาก แล้วผู้ใช้ของเราก็จะเจอบั๊ก เพราะเราอาจพลาดไม่ได้เช็คบางอย่างด้วยตนเอง
+2. หรือถ้าการลงโทษข้อผิดพลาดรุนแรง เนื่องจากไม่มีเทสต์ คนก็จะกลัวที่จะแก้ไขฟังก์ชันพวกนั้น ทำให้โค้ดกลายเป็นตัวล้าหลัง ไม่มีใครอยากยุ่งด้วย ไม่เป็นผลดีต่อการพัฒนา
 
-**Automatic testing helps to avoid these problems!**
+**การทดสอบอัตโนมัติช่วยหลีกเลี่ยงปัญหาเหล่านี้!**
 
-If the project is covered with tests, there's just no such problem. After any changes, we can run tests and see a lot of checks made in a matter of seconds.
+ถ้าโปรเจ็กต์มีเทสต์ที่ครอบคลุม ก็จะไม่มีปัญหาแบบนี้เกิดขึ้น หลังจากมีการเปลี่ยนแปลงใดๆ เราสามารถรันเทสต์และเห็นการตรวจสอบจำนวนมากทำเสร็จภายในไม่กี่วินาที
 
-**Besides, a well-tested code has better architecture.**
+**อีกทั้ง โค้ดที่ผ่านการทดสอบอย่างดีมักจะมีสถาปัตยกรรมที่ดีกว่าด้วย**
 
-Naturally, that's because auto-tested code is easier to modify and improve. But there's also another reason.
+แน่นอนว่าเป็นเพราะโค้ดที่ผ่านการทดสอบอัตโนมัติจะแก้ไขและปรับปรุงได้ง่ายกว่า แต่ก็มีอีกเหตุผลหนึ่ง
 
-To write tests, the code should be organized in such a way that every function has a clearly described task, well-defined input and output. That means a good architecture from the beginning.
+การจะเขียนเทสต์ โค้ดจะต้องถูกจัดการให้ฟังก์ชันแต่ละตัวมีหน้าที่ที่ระบุชัดเจน พร้อมอินพุตเอาต์พุตที่กำหนดไว้ดี นั่นหมายถึงการมีสถาปัตยกรรมที่ดีตั้งแต่แรก
 
-In real life that's sometimes not that easy. Sometimes it's difficult to write a spec before the actual code, because it's not yet clear how it should behave. But in general writing tests makes development faster and more stable.
+ในชีวิตจริง บางครั้งการเขียนข้อกำหนดก่อนเขียนโค้ดจริงก็ไม่ง่ายเสมอไป เพราะอาจยังไม่แน่ชัดว่ามันควรจะทำงานอย่างไร แต่โดยรวมแล้ว การเขียนเทสต์ทำให้การพัฒนาเร็วขึ้นและมั่นคงขึ้น
 
-Later in the tutorial you will meet many tasks with tests baked-in. So you'll see more practical examples.
+ในบทเรียนต่อๆ ไป คุณจะได้พบกับหลายๆ แบบฝึกหัดที่มีเทสต์แนบมาด้วย ดังนั้นคุณจะได้เห็นตัวอย่างเชิงปฏิบัติมากขึ้น
 
-Writing tests requires good JavaScript knowledge. But we're just starting to learn it. So, to settle down everything, as of now you're not required to write tests, but you should already be able to read them even if they are a little bit more complex than in this chapter.
+การเขียนเทสต์ต้องอาศัยความรู้ JavaScript ที่ดี แต่เรากำลังเพิ่งเริ่มต้นเรียนรู้มัน ดังนั้น เพื่อให้ทุกอย่างเข้าที่เข้าทาง ตอนนี้ยังไม่บังคับให้คุณต้องเขียนเทสต์ แต่ควรอ่านเทสต์ออกบ้างแล้ว ถึงแม้มันจะซับซ้อนกว่าในบทนี้สักหน่อยก็ตาม
\ No newline at end of file
diff --git a/1-js/03-code-quality/06-polyfills/article.md b/1-js/03-code-quality/06-polyfills/article.md
index 5ca123908..9d0dcd4d9 100644
--- a/1-js/03-code-quality/06-polyfills/article.md
+++ b/1-js/03-code-quality/06-polyfills/article.md
@@ -1,82 +1,114 @@
+# Polyfills และ Transpilers
 
-# Polyfills and transpilers
+ภาษา JavaScript มีวิวัฒนาการอย่างต่อเนื่อง มีข้อเสนอใหม่ๆ สำหรับภาษานี้เกิดขึ้นเป็นประจำ โดยจะมีการวิเคราะห์และพิจารณาว่าข้อเสนอใดมีคุณค่าเพียงพอที่จะเพิ่มเข้าไปในรายการที่ <https://tc39.github.io/ecma262/> จากนั้นจะค่อยๆ ผ่านเข้าสู่[ข้อกำหนด](https://www.ecma-international.org/publications-and-standards/standards/ecma-262/)
 
+<<<<<<< HEAD
+ทีมงานที่อยู่เบื้องหลังเอนจิ้น JavaScript มีแนวคิดของตัวเองว่าจะเริ่มใช้อะไรก่อน พวกเขาอาจตัดสินใจใช้ข้อเสนอที่ยังอยู่ในร่างและเลื่อนสิ่งที่อยู่ในข้อกำหนดแล้วออกไป เพราะมันน่าสนใจน้อยกว่าหรือยากกว่าที่จะทำ
+=======
 The JavaScript language steadily evolves. New proposals to the language appear regularly, they are analyzed and, if considered worthy, are appended to the list at <https://tc39.github.io/ecma262/> and then progress to the [specification](https://www.ecma-international.org/publications-and-standards/standards/ecma-262/).
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-Teams behind JavaScript engines have their own ideas about what to implement first. They may decide to implement proposals that are in draft and postpone things that are already in the spec, because they are less interesting or just harder to do.
+ดังนั้นจึงเป็นเรื่องปกติที่เอนจิ้นจะใช้งานแค่บางส่วนของมาตรฐานเท่านั้น
 
+<<<<<<< HEAD
+เว็บเพจที่ดีในการดูสถานะปัจจุบันของการรองรับฟีเจอร์ภาษาคือ <https://compat-table.github.io/compat-table/es6/> (มันใหญ่มาก เรายังมีอีกหลายอย่างที่ต้องศึกษา)
+
+ในฐานะโปรแกรมเมอร์ เราอยากใช้ฟีเจอร์ล่าสุด ยิ่งมีของดีๆ มากเท่าไหร่ก็ยิ่งดี!
+=======
 So it's quite common for an engine to implement only part of the standard.
 
 A good page to see the current state of support for language features is <https://compat-table.github.io/compat-table/es6/> (it's big, we have a lot to study yet).
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-As programmers, we'd like to use most recent features. The more good stuff - the better!
-
-On the other hand, how to make our modern code work on older engines that don't understand recent features yet?
+ในทางกลับกัน จะทำอย่างไรให้โค้ดสมัยใหม่ของเราทำงานได้บนเอนจิ้นเก่าๆ ที่ยังไม่เข้าใจฟีเจอร์ใหม่ๆ
 
-There are two tools for that:
+มีเครื่องมือสองอย่างสำหรับเรื่องนี้:
 
-1. Transpilers.
-2. Polyfills.
+1. Transpilers
+2. Polyfills
 
-Here, in this chapter, our purpose is to get the gist of how they work, and their place in web development.
+ที่นี่ในบทนี้ จุดประสงค์ของเราคือการทำความเข้าใจเบื้องต้นว่าพวกมันทำงานอย่างไร และบทบาทของมันในการพัฒนาเว็บ
 
 ## Transpilers
 
-A [transpiler](https://en.wikipedia.org/wiki/Source-to-source_compiler) is a special piece of software that translates source code to another source code. It can parse ("read and understand") modern code and rewrite it using older syntax constructs, so that it'll also work in outdated engines.
+[Transpiler](https://en.wikipedia.org/wiki/Source-to-source_compiler) เป็นซอฟต์แวร์พิเศษที่แปลโค้ดต้นฉบับอันหนึ่งเป็นโค้ดต้นฉบับอีกชุดหนึ่ง มันสามารถแยกวิเคราะห์ ("อ่านและทำความเข้าใจ") โค้ดสมัยใหม่ และเขียนใหม่โดยใช้โครงสร้างไวยากรณ์แบบเก่า เพื่อให้ทำงานได้แม้กับเอนจิ้นที่ล้าสมัย
 
-E.g. JavaScript before year 2020 didn't have the "nullish coalescing operator" `??`. So, if a visitor uses an outdated browser, it may fail to understand the code like `height = height ?? 100`.
+ยกตัวอย่างเช่น JavaScript ก่อนปี 2020 ไม่มี "ตัวดำเนินการ nullish coalescing" `??` ดังนั้น หากผู้ใช้ใช้เบราว์เซอร์รุ่นเก่า มันอาจล้มเหลวในการทำความเข้าใจโค้ดอย่างเช่น `height = height ?? 100`
 
-A transpiler would analyze our code and rewrite `height ?? 100` into `(height !== undefined && height !== null) ? height : 100`.
+Transpiler จะวิเคราะห์โค้ดของเราและเขียน `height ?? 100` ใหม่เป็น `(height !== undefined && height !== null) ? height : 100`
 
 ```js
-// before running the transpiler
+// ก่อนรัน transpiler
 height = height ?? 100;
 
-// after running the transpiler
+// หลังรัน transpiler  
 height = (height !== undefined && height !== null) ? height : 100;
 ```
 
-Now the rewritten code is suitable for older JavaScript engines.
+ตอนนี้โค้ดที่เขียนใหม่ก็เหมาะสมกับเอนจิ้น JavaScript รุ่นเก่าแล้ว
+
+โดยปกติแล้ว นักพัฒนาจะรัน transpiler บนคอมพิวเตอร์ของตัวเอง แล้วจากนั้นจึงนำโค้ดที่ผ่านการ transpile แล้วไปใช้บนเซิร์ฟเวอร์
 
-Usually, a developer runs the transpiler on their own computer, and then deploys the transpiled code to the server.
+<<<<<<< HEAD
+พูดถึงชื่อ [Babel](https://babeljs.io) ถือเป็นหนึ่งใน transpiler ที่โดดเด่นที่สุดในตอนนี้
 
+ระบบสร้างโปรเจ็กต์สมัยใหม่ เช่น [webpack](https://webpack.js.org/) มีวิธีให้รัน transpiler อัตโนมัติทุกครั้งที่มีการเปลี่ยนแปลงโค้ด ทำให้ง่ายต่อการรวมเข้ากับกระบวนการพัฒนา
+=======
 Speaking of names, [Babel](https://babeljs.io) is one of the most prominent transpilers out there.
 
 Modern project build systems, such as [webpack](https://webpack.js.org/), provide a means to run a transpiler automatically on every code change, so it's very easy to integrate into the development process.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
 ## Polyfills
 
-New language features may include not only syntax constructs and operators, but also built-in functions.
+คุณสมบัติใหม่ของภาษาอาจไม่ได้รวมเฉพาะโครงสร้างไวยากรณ์และตัวดำเนินการเท่านั้น แต่ยังรวมถึงฟังก์ชันที่มีในตัวด้วย
 
-For example, `Math.trunc(n)` is a function that "cuts off" the decimal part of a number, e.g `Math.trunc(1.23)` returns `1`.
+ยกตัวอย่างเช่น `Math.trunc(n)` เป็นฟังก์ชันที่ "ตัดทอน" ส่วนทศนิยมของตัวเลข เช่น `Math.trunc(1.23)` จะคืนค่า `1`
 
-In some (very outdated) JavaScript engines, there's no `Math.trunc`, so such code will fail.
+ในเอนจิ้น JavaScript บางตัวที่ล้าสมัยมาก อาจไม่มี `Math.trunc` ดังนั้นโค้ดดังกล่าวจะทำงานไม่ได้
 
-As we're talking about new functions, not syntax changes, there's no need to transpile anything here. We just need to declare the missing function.
+เนื่องจากเรากำลังพูดถึงฟังก์ชันใหม่ ไม่ใช่การเปลี่ยนแปลงไวยากรณ์ จึงไม่จำเป็นต้อง transpile อะไรตรงนี้ เพียงแค่ต้องประกาศฟังก์ชันที่ขาดหายไปเท่านั้น
 
-A script that updates/adds new functions is called "polyfill". It "fills in" the gap and adds missing implementations.
+สคริปต์ที่อัปเดตหรือเพิ่มฟังก์ชันใหม่ เรียกว่า "polyfill" มันจะ "เติมเต็ม" ช่องว่างและเพิ่มการนำไปใช้งานที่ขาดหายไป
 
-For this particular case, the polyfill for `Math.trunc` is a script that implements it, like this:
+สำหรับกรณีนี้โดยเฉพาะ polyfill สำหรับ `Math.trunc` คือสคริปต์ที่เพิ่มการนำไปใช้งานให้ ดังนี้:
 
 ```js
-if (!Math.trunc) { // if no such function
-  // implement it
+if (!Math.trunc) { // ถ้าไม่มีฟังก์ชันดังกล่าว
+  // ให้นำไปใช้งาน
   Math.trunc = function(number) {
-    // Math.ceil and Math.floor exist even in ancient JavaScript engines
-    // they are covered later in the tutorial
+    // Math.ceil และ Math.floor มีอยู่แม้ในเอนจิ้น JavaScript โบราณ
+    // จะมีการอธิบายเพิ่มเติมในบทเรียนถัดไป
     return number < 0 ? Math.ceil(number) : Math.floor(number);
   };
 }
 ```
 
+<<<<<<< HEAD
+JavaScript เป็นภาษาที่มีพลวัตสูงมาก สคริปต์สามารถเพิ่ม/แก้ไขฟังก์ชันใดๆ ก็ได้ แม้แต่ฟังก์ชันในตัว
+
+มีไลบรารี polyfill ที่น่าสนใจสองแห่งคือ:
+- [core js](https://github.com/zloirock/core-js) ที่รองรับฟีเจอร์เป็นจำนวนมาก โดยสามารถเลือกใช้เฉพาะฟีเจอร์ที่ต้องการได้
+- บริการ [polyfill.io](https://polyfill.io/) ที่จัดเตรียมสคริปต์พร้อม polyfills ตามคุณสมบัติและเบราว์เซอร์ของผู้ใช้
+
+## สรุป
+=======
 JavaScript is a highly dynamic language. Scripts may add/modify any function, even built-in ones.
 
 One interesting polyfill library is [core-js](https://github.com/zloirock/core-js), which supports a wide range of features and allows you to include only the ones you need.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
+
+ในบทนี้เราต้องการจูงใจให้คุณศึกษาคุณสมบัติภาษาที่ทันสมัยและแม้กระทั่งที่อยู่ในระหว่างพัฒนา แม้ว่าตอนนี้เอนจิ้น JavaScript จะยังรองรับได้ไม่ดีนัก
 
-## Summary
+อย่าลืมใช้ transpiler (ถ้าใช้ไวยากรณ์หรือตัวดำเนินการใหม่) และ polyfills (เพื่อเพิ่มฟังก์ชันที่อาจขาดหายไป) พวกมันจะช่วยให้มั่นใจได้ว่าโค้ดจะทำงาน
 
-In this chapter we'd like to motivate you to study modern and even "bleeding-edge" language features, even if they aren't yet well-supported by JavaScript engines.
+<<<<<<< HEAD
+ตัวอย่างเช่น ในภายหลังเมื่อคุณคุ้นเคยกับ JavaScript แล้ว คุณสามารถตั้งค่าระบบการสร้างโค้ดที่อิงกับ [webpack](https://webpack.js.org/) ร่วมกับปลั๊กอิน [babel-loader](https://github.com/babel/babel-loader)
 
+แหล่งข้อมูลดีๆ ที่แสดงสถานะปัจจุบันของการรองรับคุณสมบัติต่างๆ ได้แก่:
+- <https://compat-table.github.io/compat-table/es6/> - สำหรับ JavaScript แท้ๆ
+- <https://caniuse.com/> - สำหรับฟังก์ชันที่เกี่ยวข้องกับเบราว์เซอร์
+=======
 Just don't forget to use a transpiler (if using modern syntax or operators) and polyfills (to add functions that may be missing). They'll ensure that the code works.
 
 For example, later when you're familiar with JavaScript, you can setup a code build system based on [webpack](https://webpack.js.org/) with the [babel-loader](https://github.com/babel/babel-loader) plugin.
@@ -86,4 +118,6 @@ Good resources that show the current state of support for various features:
 - <https://caniuse.com/> - for browser-related functions.
 
 P.S. Google Chrome is usually the most up-to-date with language features, try it if a tutorial demo fails. Most tutorial demos work with any modern browser though.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
+ป.ล. Google Chrome มักจะอัปเดตการรองรับคุณสมบัติภาษาใหม่ๆ ได้ทันสมัยที่สุด ลองใช้ Chrome ดูหากเดโมในบทเรียนไม่ทำงาน แต่โดยทั่วไปแล้วเดโมในบทเรียนส่วนใหญ่น่าจะทำงานได้กับเบราว์เซอร์สมัยใหม่ทุกตัว
\ No newline at end of file
diff --git a/1-js/03-code-quality/index.md b/1-js/03-code-quality/index.md
index 2ef64fa69..a7d8fa7cb 100644
--- a/1-js/03-code-quality/index.md
+++ b/1-js/03-code-quality/index.md
@@ -1,3 +1,3 @@
-# Code quality
+# คุณภาพของโค้ด
 
-This chapter explains coding practices that we'll use further in the development. 
+บทนี้อธิบายเกี่ยวกับวิธีการเขียนโค้ดที่เราจะนำไปใช้ในกระบวนการพัฒนาต่อไป โดยเน้นไปที่คุณภาพของโค้ด โดยเฉพาะเรื่องการเขียนโค้ดที่มีความสะอาด และการเขียนโค้ดที่มีความเข้าใจง่าย
diff --git a/1-js/04-object-basics/01-object/2-hello-object/task.md b/1-js/04-object-basics/01-object/2-hello-object/task.md
index 2841a058f..07912157b 100644
--- a/1-js/04-object-basics/01-object/2-hello-object/task.md
+++ b/1-js/04-object-basics/01-object/2-hello-object/task.md
@@ -4,11 +4,10 @@ importance: 5
 
 # Hello, object
 
-Write the code, one line for each action:
-
-1. Create an empty object `user`.
-2. Add the property `name` with the value `John`.
-3. Add the property `surname` with the value `Smith`.
-4. Change the value of the `name` to `Pete`.
-5. Remove the property `name` from the object.
+ให้เขียนโค้ดเพื่อทำงานตามข้างล่างนี้ โดยแต่ละข้อให้เขียนได้เพียง 1 บรรทัดเท่านั้น:
 
+1. สรา้ง object ชื่อว่า `user`
+2. เพิ่ม property `name` มี value เป็น `John`
+3. เพิ่ม property `surname` มี value เป็น `Smith`
+4. เปลี่ยนค่าของ `name` เป็น `Pete`
+5. ลบ property `name` ออกจาก object
diff --git a/1-js/04-object-basics/01-object/3-is-empty/solution.md b/1-js/04-object-basics/01-object/3-is-empty/solution.md
index b876973b5..a49662019 100644
--- a/1-js/04-object-basics/01-object/3-is-empty/solution.md
+++ b/1-js/04-object-basics/01-object/3-is-empty/solution.md
@@ -1 +1 @@
-Just loop over the object and `return false` immediately if there's at least one property.
+ทดสอบด้วยการวนลูป object แล้ว `return false` ทันทีที่พบ propperty อย่างน้อย 1 ตัว
diff --git a/1-js/04-object-basics/01-object/3-is-empty/task.md b/1-js/04-object-basics/01-object/3-is-empty/task.md
index c438d36a2..3fd9e66eb 100644
--- a/1-js/04-object-basics/01-object/3-is-empty/task.md
+++ b/1-js/04-object-basics/01-object/3-is-empty/task.md
@@ -2,19 +2,18 @@ importance: 5
 
 ---
 
-# Check for emptiness
+# ตรวจสอบ object ว่าง
 
-Write the function `isEmpty(obj)` which returns `true` if the object has no properties, `false` otherwise.
+เขียน function `isEmpty(obj)` ที่จะตอบกลับ `true` เมื่อ object ไม่มี property ใดๆ เลย ตอบกลับ `false` หากเป็นอย่างอื่น
 
-Should work like that:
+ควรทำงานได้ทำนองนี้:
 
 ```js
 let schedule = {};
 
-alert( isEmpty(schedule) ); // true
+alert( isEmpty(schedule) ); // ตอบ true
 
 schedule["8:30"] = "get up";
 
-alert( isEmpty(schedule) ); // false
+alert( isEmpty(schedule) ); // ตอบ false
 ```
-
diff --git a/1-js/04-object-basics/01-object/5-sum-object/task.md b/1-js/04-object-basics/01-object/5-sum-object/task.md
index 7e3e048d0..8789796ea 100644
--- a/1-js/04-object-basics/01-object/5-sum-object/task.md
+++ b/1-js/04-object-basics/01-object/5-sum-object/task.md
@@ -2,9 +2,9 @@ importance: 5
 
 ---
 
-# Sum object properties
+# หาผลรวมของ property ใน object
 
-We have an object storing salaries of our team:
+เรามี object เก็บค่าเงินเดือนของสมาชิกในทีมดังนี้:
 
 ```js
 let salaries = {
@@ -14,6 +14,6 @@ let salaries = {
 }
 ```
 
-Write the code to sum all salaries and store in the variable `sum`. Should be `390` in the example above.
+เขียนโค้ดเพื่อหาผลรวมโดยเก็บไว้ในตัวแปร `sum` โดยจากข้อมูลข้างบนต้องได้ค่า 390
 
-If `salaries` is empty, then the result must be `0`.
\ No newline at end of file
+ถ้า `salaries` เป็น object ว่างให้ตอบ `0`
\ No newline at end of file
diff --git a/1-js/04-object-basics/01-object/8-multiply-numeric/task.md b/1-js/04-object-basics/01-object/8-multiply-numeric/task.md
index 6878ca088..234258e33 100644
--- a/1-js/04-object-basics/01-object/8-multiply-numeric/task.md
+++ b/1-js/04-object-basics/01-object/8-multiply-numeric/task.md
@@ -2,14 +2,14 @@ importance: 3
 
 ---
 
-# Multiply numeric property values by 2
+# คูณค่าของ property ทุกตัวที่มี value ป็นค่าเชิงตัวเลขด้วย 2
 
-Create a function `multiplyNumeric(obj)` that multiplies all numeric property values of `obj` by `2`.
+สร้าง function `multiplyNumeric(obj)` ที่จะทำการคูณค่าของ property ทุกตัวใน `obj` ที่มี value เป็นค่าเชิงตัวเลขด้วย `2`
 
-For instance:
+ตัวอย่างเช่น:
 
 ```js
-// before the call
+// ก่อนเรียกใช้ function
 let menu = {
   width: 200,
   height: 300,
@@ -18,7 +18,7 @@ let menu = {
 
 multiplyNumeric(menu);
 
-// after the call
+// หลังเรียกใช้ function
 menu = {
   width: 400,
   height: 600,
@@ -26,8 +26,6 @@ menu = {
 };
 ```
 
-Please note that `multiplyNumeric` does not need to return anything. It should modify the object in-place.
-
-P.S. Use `typeof` to check for a number here.
-
+โปรดทราบว่า `multiplyNumeric` ไม่จำเป็นต้องตอบกลับ แต่ทำการเปลี่ยนค่าของ object
 
+ป.ล. ใช้ `typeof` เพื่อทดสอบว่าเป็นค่าเชิงตัวเลข
diff --git a/1-js/04-object-basics/01-object/article.md b/1-js/04-object-basics/01-object/article.md
index 0fe5979fa..513c83233 100644
--- a/1-js/04-object-basics/01-object/article.md
+++ b/1-js/04-object-basics/01-object/article.md
@@ -1,17 +1,17 @@
 
-# Objects
+# Object
 
-As we know from the chapter <info:types>, there are eight data types in JavaScript. Seven of them are called "primitive", because their values contain only a single thing (be it a string or a number or whatever).
+ตามที่เราได้รู้จากบท <info:types> แล้วว่า JavaScript มีข้อมูลอยู่ 8 ชนิดด้วยกัน โดยจะมี 7 ชนิดที่เป็นข้อมูลแบบ "primitive" เนื่องจากเก็บค่าข้อมูลเพียงหน่วยเดียวเท่านั้น (อาจเป็นข้อความสตริงหรือตัวเลขหรืออะไรก็ตาม)
 
-In contrast, objects are used to store keyed collections of various data and more complex entities. In JavaScript, objects penetrate almost every aspect of the language. So we must understand them first before going in-depth anywhere else.
+ในทางกลับกันข้อมูลชนิดที่ 8 คือ objects เป็นชนิดของข้อมูลที่เก็บกลุ่มข้อมูลที่ประกอบด้วยข้อมูลประเภทต่างๆ และข้อมูลที่มีความซับซ้อนมากขึ้น (โดยมี key เป็นตัวอ้างอิงถึงข้อมูลแต่ละตัวใน object) ในภาษา JavaScript มีการใช้แนวคิดของ object อยู่เต็มไปหมด ดังนั้นเราต้องเข้าใจหลักการของ object ให้ดีเสียก่อนที่จะศึกษาเรื่องอื่นๆ ของ JavaScript แบบลงลึกได้
 
-An object can be created with figure brackets `{…}` with an optional list of *properties*. A property is a "key: value" pair, where `key` is a string (also called a "property name"), and `value` can be anything.
+เราสามารถสร้าง object ขึ้นมาได้ด้วยการสร้างวงเล็บปีกกา `{…}` โดยภายในวงเล็บปีกกา จะมีรายชื่อของ *property* ต่างๆ ที่อยู่ภายใน object นั้น โดย object หนึ่ง จะมี property กี่ตัวก็ได้ หรือไม่มีเลยสักตัวก็ได้  โดยโครงสร้าง property แต่ละตัวจะอยู่ในรูปคู่อันดับของ "key: value" มี `key` เป็นข้อความสตริง (เรียกว่า "property name") และ `value` จะเป็นข้อมูลประเภทใดก็ได้
 
-We can imagine an object as a cabinet with signed files. Every piece of data is stored in its file by the key. It's easy to find a file by its name or add/remove a file.
+เราอาจคิดเสียว่า object ก็เหมือนกับตู้ใส่เอกสารที่เก็บแฟ้มตู้หนึ่ง โดยที่แต่ละแฟ้มนั้นจะมีป้ายชื่อกำกับไว้ ในแต่ละแฟ้มก็จะมีข้อมูลเก็บอยู่โดยมี key กำกับไว้ เฟื่อให้ผู้ที่ต้องการใช้สามารถค้นหา หรือ เพิ่ม/ลบ แฟ้มได้โดยง่าย
 
 ![](object.svg)
 
-An empty object ("empty cabinet") can be created using one of two syntaxes:
+เราสามารถสร้าง object ว่างๆ ขึ้นมาตัวหนึ่ง ("object ว่างๆ ก็เหมือนกับตู้เอกสารที่ยังไม่มีเอกสารอะไรเก็บอยู่เลย") ได้ด้วยการประกาศ object ซึ่งมีด้วยกันสองวิธี โดยใช้ syntax แบบใดแบบหนึ่งก็ได้จาก 2 แบบนี้:
 
 ```js
 let user = new Object(); // "object constructor" syntax
@@ -20,41 +20,45 @@ let user = {};  // "object literal" syntax
 
 ![](object-user-empty.svg)
 
-Usually, the figure brackets `{...}` are used. That declaration is called an *object literal*.
+โดยทั่วไปจะใช้วิธีที่มีวงเล็บปีกกา `{...}` กันมากกว่า จะมีชื่อเรียกของการประกาศ object ด้วยวิธีนี้ว่า *object literal*
 
-## Literals and properties
+## Literal และ property
 
-We can immediately put some properties into `{...}` as "key: value" pairs:
+เราสามารถระบุ property ของ object ตอนที่เราประกาศ object นั้นเลยก็ได้ ด้วยการใส่ property เข้าไประหว่างปีกกาสองอัน `{...}` โดย property ที่ใส่จะต้องอยู่รูปแบบคู่อันดับของ "key: value":
 
 ```js
-let user = {     // an object
-  name: "John",  // by key "name" store value "John"
-  age: 30        // by key "age" store value 30
+let user = {     // object
+  name: "John",  // key ชื่อ "name" เก็บค่า "John"
+  age: 30        // key ชื่อ "age" เก็บค่า 30
 };
 ```
 
-A property has a key (also known as "name" or "identifier") before the colon `":"` and a value to the right of it.
+property แต่ละตัวจะมี key (หรือบางทีก็เรียกกันว่า "name" หรือ "identifier" ก็ได้) เขียนก่อนเครื่องหมาย colon `":"` และมี value เขียนอยู่ฝั่งขวาของเครื่องหมาย colon
 
-In the `user` object, there are two properties:
+object ชื่อ `user` ที่เราสร้างขึ้นมาประกอบไปด้วย property 2 ตัว:
 
-1. The first property has the name `"name"` and the value `"John"`.
-2. The second one has the name `"age"` and the value `30`.
+1. property ตัวแรกมี key ชื่อว่า `"name"` และมี value เป็น String ที่มีข้อความว่า `"John"`
+2. property ตัวที่สองมี key ชื่อว่า `"age"` แบะมี value เป็นเลขมีค่าเท่ากับ `30`
 
-The resulting `user` object can be imagined as a cabinet with two signed files labeled "name" and "age".
+ทำให้เราสามารถเปรียบ object ที่ชื่อ `user` ที่มี property สองตัวนี้ เสมือนกับตู้เอกสาร และที่ประกอบไปด้วยแฟ้ม 2 แฟ้มที่มีป้ายชื่อกำกับไว้ว่า "name" และ "age"
 
 ![user object](object-user.svg)
 
+<<<<<<< HEAD
+เราสามารถ เพิ่ม ลบและอ่านแฟ้มในตู้นี้ได้ตลอดเวลา
+=======
 We can add, remove and read files from it at any time.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-Property values are accessible using the dot notation:
+โดยเราเรียกใช้ value ของ property (ก็คือข้อมูลในแฟ้มเอกสาร) โดยการใช้ dot notation ดังนี้:
 
 ```js
-// get property values of the object:
+// alert ค่า value ของ property ใน object:
 alert( user.name ); // John
 alert( user.age ); // 30
 ```
 
-The value can be of any type. Let's add a boolean one:
+ข้อมูลที่เก็บในแฟ้มจะเป็นข้อมูลชนิดไหนก็ได้ ทีนี้เราจะลองเพิ่มข้อมูลชนิด boolean เข้าไป 1 ตัว:
 
 ```js
 user.isAdmin = true;
@@ -62,7 +66,11 @@ user.isAdmin = true;
 
 ![user object 2](object-user-isadmin.svg)
 
+<<<<<<< HEAD
+ถ้าต้องการลบ property ตัวใดตัวหนึ่งออกจาก `object` เราสามารถใช้คำสั่ง delete เพื่อลบ property ตัวนั้นออกไป:
+=======
 To remove a property, we can use the `delete` operator:
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
 ```js
 delete user.age;
@@ -70,70 +78,70 @@ delete user.age;
 
 ![user object 3](object-user-delete.svg)
 
-We can also use multiword property names, but then they must be quoted:
+เราสามารถตั้งชื่อของ property เป็นชื่อแบบ  multiword ก็คือชื่อที่มีคำหลายๆ คำที่แยกกันด้วยช่องว่างได้ แต่ทุกคำที่เป็นชื่อนั้นจะต้องอยู่ในเครื่องหมายคำพูดเดียวกัน:
 
 ```js
 let user = {
   name: "John",
   age: 30,
-  "likes birds": true  // multiword property name must be quoted
+  "likes birds": true  // ชื่อ property แบบ multiword ต้องอยู่ในเครื่องหมายคำพูด
 };
 ```
 
 ![](object-user-props.svg)
 
 
-The last property in the list may end with a comma:
+เราสามารถใส่เครื่องหมาย comma ตามหลัง property ตัวสุดท้ายก็ได้:
 ```js
 let user = {
   name: "John",
   age: 30*!*,*/!*
 }
 ```
-That is called a "trailing" or "hanging" comma. Makes it easier to add/remove/move around properties, because all lines become alike.
+เครื่องหมาย comma ที่ปิดท้าย property ตัวหลังสุดเรียกว่า "trailing" หรือ "hanging" comma ทำให้เรา เพิ่ม/ลบ/ย้ายลำดับ propperty ได้ง่ายขึ้น เนื่องจากแต่ละบรรทัดจะมีเครื่องหมาย comma ปิดท้ายเหมือนกันทุกบรรทัด
 
 ## Square brackets
 
-For multiword properties, the dot access doesn't work:
+เราไม่สามารถใช้ dot notation เรียกใช้ property แบบ multiword ได้:
 
 ```js run
-// this would give a syntax error
+// เกิด syntax error
 user.likes birds = true
 ```
 
-JavaScript doesn't understand that. It thinks that we address `user.likes`, and then gives a syntax error when comes across unexpected `birds`.
+JavaScript ไม่เข้าใจคำสั่งนี้ เนื่องจาก JavaScript จะเข้าใจไปว่าเราต้องการใช้ค่าข้อมูลจาก `user.likes` ทำให้เกิด syntax error เมื่อพบคำว่า `birds` ซึ่งเป็นข้อความที่ทำให้โปรแกรมไม่สามารถแปลภาษาต่อไปได้
 
-The dot requires the key to be a valid variable identifier. That implies: contains no spaces, doesn't start with a digit and doesn't include special characters (`$` and `_` are allowed).
+การใช้ dot notation เพื่อเข้าถึง property ต่างๆ ของ object หลังจากชื่อ objct และเครื่องหมาย dot จะต้องต่อด้วย key ของ property ที่ถูกต้องตามรูปแบบของการตั้งชื่อตัวแปร กล่าวคือ: ห้ามมีวรรค ไม่ขึ้นต้นด้วยตัวเลข และไม่มีอักขระพิเศษ (ยกเว้นเครื่องหมาย `$` กับ `_` สองตัวที่สามารถมีได้)
 
-There's an alternative "square bracket notation" that works with any string:
+ด้วยเหตุนี้ จึงมีอีกวิธีในการเข้าถึง property ของ object ก็คือใช้วงเล็บเหลี่ยม หรือ "square bracket notation" โดยวิธีนี้สามารถใช้ได้กับชื่อ property แบบ multiword:
 
 ```js run
 let user = {};
 
-// set
+// กำหนดค่า
 user["likes birds"] = true;
 
-// get
+// อ่านค่า
 alert(user["likes birds"]); // true
 
-// delete
+// ลบ
 delete user["likes birds"];
 ```
 
-Now everything is fine. Please note that the string inside the brackets is properly quoted (any type of quotes will do).
+ถึงตอนนี้เราก็สามารถเรียกใช้งาน property ทีมีชื่อเป็น multiword ได้แล้ว ต้องระวังว่า ข้อความสตริงในวงเล็บเหลี่ยมนี้จะต้องต้องอยู่ภายในระหว่างเครื่องหมายคำพูดหรือเครื่องหมายอัญประกาศ (จะใช้เครื่องหมายคำพูดแบบฟันเดี่ยว-single quoe หรือแบบฟันคู่-doule quoteก็ได้)
 
-Square brackets also provide a way to obtain the property name as the result of any expression -- as opposed to a literal string -- like from a variable as follows:
+นอกจากนี้เรายังสามารถใช้วงเล็บเหลี่ยมเพื่ออ้างถึงชื่อของ property จากผลลัพธ์ของกระบวนการอะไรสักอย่างได้ แทนที่ใส่ชื่อเป็นข้อความตัวอักษรตายตัว คล้ายๆ กับว่าเราตั้งตัวแปรตัวหนึ่งขึ้นมาเพื่ออ้างถึงชื่อของ property ดังตัวอย่างข้างล่างนี้:
 
 ```js
 let key = "likes birds";
 
-// same as user["likes birds"] = true;
+// เหมือนกันกับ user["likes birds"] = true;
 user[key] = true;
 ```
 
-Here, the variable `key` may be calculated at run-time or depend on the user input. And then we use it to access the property. That gives us a great deal of flexibility.
+ตามตัวอย่างข้างบนนี้ ตัวแปร `key` อาจถูกกำหนดค่าขึ้นมาตอน run-time หรือจะเป็นการรับค่าจาก user ใส่เข้ามาก็ได้  จากนั้นก็ใช้ค่าของตัวแปรเพื่อเข้าถึง property คุณสมบัติที่ว่ามานี้ทำให้เกิดความยึดหยุ่นในการใช้งานมากทีเดียว
 
-For instance:
+ตัวอย่างเช่น:
 
 ```js run
 let user = {
@@ -141,13 +149,13 @@ let user = {
   age: 30
 };
 
-let key = prompt("What do you want to know about the user?", "name");
+let key = prompt("คุณต้องการทราบข้อมูลใดของ user?", "name");
 
-// access by variable
-alert( user[key] ); // John (if enter "name")
+// เข้าถึงข้อมูลด้วยตัวแปร
+alert( user[key] ); // John (กรณีที่ผู้ใช้งานป้อนค่า "name")
 ```
 
-The dot notation cannot be used in a similar way:
+แต่การนำตัวแปรมาใช้แทนชื่อของ property นี้ จะใช้ในวิธีแบบ dot notation ไม่ได้:
 
 ```js run
 let user = {
@@ -159,40 +167,40 @@ let key = "name";
 alert( user.key ) // undefined
 ```
 
-### Computed properties
+### Computed property
 
-We can use square brackets in an object literal, when creating an object. That's called *computed properties*.
+ตอนที่ประกาศ object เราสามารถใช้วงเล็บเหลี่ยมใน object literal ได้ เรียกว่า *computed propertiy*
 
-For instance:
+ตัวอย่างเช่น:
 
 ```js run
-let fruit = prompt("Which fruit to buy?", "apple");
+let fruit = prompt("ซื้อผลไม้อะไรดี?", "apple");
 
 let bag = {
 *!*
-  [fruit]: 5, // the name of the property is taken from the variable fruit
+  [fruit]: 5, // ชื่อของ property จะรับมาจาก ตัวแปร fruit
 */!*
 };
 
-alert( bag.apple ); // 5 if fruit="apple"
+alert( bag.apple ); // 5 กรณีที่ fruit="apple"
 ```
 
-The meaning of a computed property is simple: `[fruit]` means that the property name should be taken from `fruit`.
+การใช้งาน computed property ในลักษณะนี้ก็เข้าใจได้ไม่ยาก: `[fruit]` หมายถึง ชื่อของ property ซึ่งชื่อนี้จะถูกตั้งตามค่าของตัวแปร `fruit` ที่รับค่าเข้ามา
 
-So, if a visitor enters `"apple"`, `bag` will become `{apple: 5}`.
+ดังนั้นเมื่อผู้เยี่ยมชมเว็บไซต์ป้อนข้อมูลว่า `"apple"` ค่าของ `bag` จะเป็น `{apple: 5}`
 
-Essentially, that works the same as:
+หลักๆ แล้ว การทำงานจะเป็นไปตามนี้:
 ```js run
 let fruit = prompt("Which fruit to buy?", "apple");
 let bag = {};
 
-// take property name from the fruit variable
+// ใช้ชื่อ property จากตั้วแปร fruit
 bag[fruit] = 5;
 ```
 
-...But looks nicer.
+...แต่ดูดีกว่า
 
-We can use more complex expressions inside square brackets:
+เราสามารถเขียนนิพจน์ที่ซับซ้อนในวงเล็บเหลี่ยมได้ด้วย:
 
 ```js
 let fruit = 'apple';
@@ -201,22 +209,30 @@ let bag = {
 };
 ```
 
+<<<<<<< HEAD
+เราสามารถใช้งานวิธีแบบที่มีวงเล็บเหลี่ยมได้หลายแบบกว่าวิธีการ dot notation ทำให้เราสามารถตั้งชื่อ property และชื่อตัวแปรอย่างไรก็ได้ แต่การเขียนด้วยวิธีแบบวงเล็บเหลี่ยมมีความยุ่งยากมากกว่า
+=======
 Square brackets are much more powerful than dot notation. They allow any property names and variables. But they are also more cumbersome to write.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-So most of the time, when property names are known and simple, the dot is used. And if we need something more complex, then we switch to square brackets.
+ดังนั้น หากชื่อ property เป็นชื่อตายตัวที่ทราบอยู่ก่อนแล้วและเป็นชื่อที่ไม่มีช่องว่าง เราจะใช้ dot เกือบจะทุกครั้ง แต่เมื่อไรก็ตามที่การอ้างอิงชื่อมีความซับซ้อนมากขึ้นเกินกว่าที่จะยังคงใช้แบบ dot ได้ เราก็จะเปลี่ยนมาใช้แบบวงเล็บเหลี่ยมแทน
 
 ## Property value shorthand
 
+<<<<<<< HEAD
+ในการเขียนโค้ดจริง เรามักใช้ชื่อตัวแปรสำหรับค่าของ property เป็นชื่อเดียวกันกับชื่อของ propperty นั้น
+=======
 In real code, we often use existing variables as values for property names.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-For instance:
+ตัวอย่างเช่น:
 
 ```js run
 function makeUser(name, age) {
   return {
     name: name,
     age: age,
-    // ...other properties
+    // ...property อื่นๆ
   };
 }
 
@@ -224,40 +240,44 @@ let user = makeUser("John", 30);
 alert(user.name); // John
 ```
 
-In the example above, properties have the same names as variables. The use-case of making a property from a variable is so common, that there's a special *property value shorthand* to make it shorter.
+จากตัวอย่างข้างบน จะเห็นว่าชื่อของ property เป็นชื่อเดียวกันกับชื่อของตัวแปร ลักษณะการใช้งานที่สร้าง property ขึ้นจากตัวแปรนี้พบได้ทั่วไป จนทำให้มีวิธีการเขียน property แบบย่อขึ้นมาเป็นการเฉพาะ เรียกว่า *property value shorthand*
 
-Instead of `name:name` we can just write `name`, like this:
+แทนที่จะเขียนว่า `name:name` เราสามารถเขียนแค่ `name` ตามนี้:
 
 ```js
 function makeUser(name, age) {
 *!*
   return {
-    name, // same as name: name
-    age,  // same as age: age
+    name, // เหมือนกับเขียนว่า name: name
+    age,  // เหมือนกับเขียนว่า age: age
     // ...
   };
 */!*
 }
 ```
 
-We can use both normal properties and shorthands in the same object:
+เราสามารถเขียน property แบบปรกติและแบบ shorthands ใน object เดียวกันได้:
 
 ```js
 let user = {
-  name,  // same as name:name
+  name,  // เหมือนกับเขียนว่า name:name
   age: 30
 };
 ```
 
 
-## Property names limitations
+## ข้อจำกัดการตั้งชื่อ property
 
+<<<<<<< HEAD
+เราได้ทราบกันดีแล้วว่า เราไม่สามารถตั้งชื่อตัวแปรให้เหมือนกับ reserved words คำใดๆ ของภาษาได้ เช่น คำว่า "for" "let" "return" เป็นต้น
+=======
 As we already know, a variable cannot have a name equal to one of the language-reserved words like "for", "let", "return" etc.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-But for an object property, there's no such restriction:
+แต่ข้อห้ามเหล่านี้ ไม่ได้ใช้ห้ามในการตั้งชื่อ property ของ object:
 
 ```js run
-// these properties are all right
+// สามารถตั้งชื่อ property เหล่านี้ได้
 let obj = {
   for: 1,
   let: 2,
@@ -267,107 +287,115 @@ let obj = {
 alert( obj.for + obj.let + obj.return );  // 6
 ```
 
-In short, there are no limitations on property names. They can be any strings or symbols (a special type for identifiers, to be covered later).
+โดยสรุป ไม่มีข้อจำกัดในการตั้งชื่อ property สามารถใช้เป็นข้อความสตริงหรือสัญลักษณ์ (identifier ชนิดพิเศษซึ่งจะกล่าวถึงภายหลัง) ก็ได้
 
-Other types are automatically converted to strings.
+หากใช้ข้อมูลชนิดอื่นเป็นชื่อ จะถูกแปลงเป็นข้อความสริงอัตโนมัติ
 
-For instance, a number `0` becomes a string `"0"` when used as a property key:
+ตั้วอย่างเช่น ตัวเลข `0` จะกลายเป็นข้อความสตริง `"0"` เมื่อถูกใช้เป็น key ของ property:
 
 ```js run
 let obj = {
   0: "test" // same as "0": "test"
 };
 
-// both alerts access the same property (the number 0 is converted to string "0")
+// function alert ทั้ง 2 เข้าถึง property เดียวกัน (ตัวเลข 0 ถูกแปลงเป็นข้อความสตริง "0")
 alert( obj["0"] ); // test
-alert( obj[0] ); // test (same property)
+alert( obj[0] ); // test (ได้ property เดียวกัน)
 ```
 
-There's a minor gotcha with a special property named `__proto__`. We can't set it to a non-object value:
+มีข้อห้ามเล็กน้อยกับชื่อ property กรณีพิศษ ได้แก่ชื่อ `__proto__` โดยเราไม่สามารถใส่ค่าที่ไม่เป็น object ให้กับ property ตัวนี้ได้:
 
 ```js run
 let obj = {};
-obj.__proto__ = 5; // assign a number
-alert(obj.__proto__); // [object Object] - the value is an object, didn't work as intended
+obj.__proto__ = 5; // กำหนดค่าเป็นตัวเลข
+alert(obj.__proto__); // [object Object] - ได้ค่าออกมาเป็น object ไม่ตรงกับที่ตั้งใจไว้
 ```
 
-As we see from the code, the assignment to a primitive `5` is ignored.
+จากโค้ดจะเห็นว่า กำหนดค่าให้เป็น primitive `5` แต่ไม่เป็นผลสำเร็จ
 
-We'll cover the special nature of `__proto__` in [subsequent chapters](info:prototype-inheritance), and suggest the [ways to fix](info:prototype-methods) such behavior.
+เราจะกล่าวถึงความพิเศษของ `__proto__` ในบท [subsequent chapters](info:prototype-inheritance) และ [วิธีแก้](info:prototype-methods) ปัญหานี้
 
-## Property existence test, "in" operator
+## การทดสอบ Property ด้วยตัวกำเนินการ "in"
 
-A notable feature of objects in JavaScript, compared to many other languages, is that it's possible to access any property. There will be no error if the property doesn't exist!
+คุณลักษณะหนึ่งของ object ในภาษา JavaScript ซึ่งไม่เหมือนกับในอีกหลายๆ   ภาษาที่ควรหมายเหตุไว้ได้แก่การที่สามารถเข้าถึง property ใดก็ได้ โดยที่จะไม่เกิด error ขึ้นแม้ว่า property นั้นไม่ถูกประกาศไว้ก่อนก็ตาม!
 
-Reading a non-existing property just returns `undefined`. So we can easily test whether the property exists:
+เราจะได้ค่า `undefined` เมื่ออ่านค่า property ที่ไม่มีอยู่ ดังนั้นเราสามารถทดสอบการมีอยู่ของ property ได้อย่างง่ายดังนี้:
 
 ```js run
 let user = {};
 
-alert( user.noSuchProperty === undefined ); // true means "no such property"
+alert( user.noSuchProperty === undefined ); // หากได้ค่า true หมายถึง "object user ไม่มี property ชื่อ noSuchProperty"
 ```
 
-There's also a special operator `"in"` for that.
+หรือจะเขียนโดยใช้ตัวกำเนินการ `"in"` ก็ได้
 
-The syntax is:
+ดังนี้:
 ```js
 "key" in object
 ```
 
-For instance:
+ตัวอย่างเช่น:
 
 ```js run
 let user = { name: "John", age: 30 };
 
-alert( "age" in user ); // true, user.age exists
-alert( "blabla" in user ); // false, user.blabla doesn't exist
+alert( "age" in user ); // ได้ true เพราะ object user มี age
+alert( "blabla" in user ); // ได้ false เพราะ object user ไม่มี blabla
 ```
 
-Please note that on the left side of `in` there must be a *property name*. That's usually a quoted string.
+โปรดทราบว่า ข้อมูลฝั่งซ้ายของ `in` ต้องเป็นชื่อของ property ซึ่งโดยปรกติแล้วจะเป็นข้อความสตริงอยู่ในเครื่องหมายคำพูด
 
+<<<<<<< HEAD
+หรือถ้าไม่เขียนแบบมีเครื่องหมายคำพูด ค่านั้นจะต้องเป็นตัวแปรซึ่งเก็บชื่อที่เราต้องการทดสอบ ตัวอย่างเช่น:
+=======
 If we omit quotes, that means a variable should contain the actual name to be tested. For instance:
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
 ```js run
 let user = { age: 30 };
 
 let key = "age";
-alert( *!*key*/!* in user ); // true, property "age" exists
+alert( *!*key*/!* in user ); // ได้ true เพราะ object user มี property "age"
 ```
 
-Why does the `in` operator exist? Isn't it enough to compare against `undefined`?
+เพราะเหตุใดจึงยังต้องมีตัวดำเนินการ `in` ให้ใช้อีก การเปรียบเทียบด้วยค่า `undefined` นั้นไม่เพียงพอหรืออย่างไร?
 
-Well, most of the time the comparison with `undefined` works fine. But there's a special case when it fails, but `"in"` works correctly.
+การเทียบด้วย `undefined` นั้นจะใช้ได้ในเกือบทุกกรณี แต่มีกรณีพิเศษที่ให้ผลไม่ถูกต้องจะต้องใช้ `"in"` แทน
 
-It's when an object property exists, but stores `undefined`:
+ได้แก่ เมื่อ object มี property ที่เก็บค่าเป็น `undefined`:
 
 ```js run
 let obj = {
   test: undefined
 };
 
-alert( obj.test ); // it's undefined, so - no such property?
+alert( obj.test ); // ได้ undefined แล้วจะสรุปว่าไม่มี property test ได้หรือไม่?
 
-alert( "test" in obj ); // true, the property does exist!
+alert( "test" in obj ); // ได้ true obj มี property test!
 ```
 
-In the code above, the property `obj.test` technically exists. So the `in` operator works right.
+ในโค้ดด้านบน property `obj.test` นั้นมีอยู่จริง ซึ่งกรณีนี้ตัวดำเนินการ `in` ทำงานได้ถูกต้อง
 
-Situations like this happen very rarely, because `undefined` should not be explicitly assigned. We mostly use `null` for "unknown" or "empty" values. So the `in` operator is an exotic guest in the code.
+สถานการณ์เช่นนี้เกิดขึ้นน้อยมาก เนื่องจากค่า `undefined` นั้นไม่ควรที่จะกำหนดให้โดยตรง เราควรใช้ `null` ในการกำหนดสิ่งที่ยังไม่ทราบค่าหรือค่าว่าง ดังนั้นตัวดำเนินการ `in` จึงถูกใช้ในโค้ดน้อยมาก
 
 
+<<<<<<< HEAD
+## "for..in" ลูป
+=======
 ## The "for..in" loop [#forin]
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-To walk over all keys of an object, there exists a special form of the loop: `for..in`. This is a completely different thing from the `for(;;)` construct that we studied before.
+กรณีที่ต้องการวนลูปแต่ละ key ของ object เราใช้ลูปในรูปพิเศษได้แก่: `for..in` ซึ่งต่างกันกับลูปในรูปของ for ลูป `for(;;)` ที่เราได้เรียนรู้มาก่อนหน้านี้
 
-The syntax:
+syntax ดังนี้:
 
 ```js
 for (key in object) {
-  // executes the body for each key among object properties
+  // ทำทุก key ของ property ใน object
 }
 ```
 
-For instance, let's output all properties of `user`:
+ตัวอย่าง แสดงทุก property ของ `user`:
 
 ```js run
 let user = {
@@ -377,24 +405,24 @@ let user = {
 };
 
 for (let key in user) {
-  // keys
-  alert( key );  // name, age, isAdmin
-  // values for the keys
-  alert( user[key] ); // John, 30, true
+  // แสดง key
+  alert( key );  // ได้ name age และ isAdmin ตามลำดับ
+  // แสดงค่าของแต่ละ key
+  alert( user[key] ); // ได้ John 30 และ true ตามลำดับ
 }
 ```
 
-Note that all "for" constructs allow us to declare the looping variable inside the loop, like `let key` here.
+โปรดทราบว่า "for" ทุกแบบอนุญาตให้เราประกาศตัวแปรในลูปได้ จากตัวอย่างข้างบนได้แก่ `let key`
 
-Also, we could use another variable name here instead of `key`. For instance, `"for (let prop in obj)"` is also widely used.
+ดังนั้นเราจึงสามารถตั้งชื่อตัวแปรลูปเป็นอย่างอื่นนอกจาก `key` ก็ได้ เช่น `"for (let prop in obj)"` เป็นปบบที่ใช้กันอย่างกว้างขวาง
 
-### Ordered like an object
+### การเรียงลำดับของ object
 
-Are objects ordered? In other words, if we loop over an object, do we get all properties in the same order they were added? Can we rely on this?
+เมื่อทำการลูป object เราจะได้ property ตามลำดับที่เราประกาศไว้หรือไม่?
 
-The short answer is: "ordered in a special fashion": integer properties are sorted, others appear in creation order. The details follow.
+คำตอบอย่างสั้นคือ: "จะเรียงลำดับแบบพิเศษ": โดย interger property หรือ property ที่มี key เป็นค่าจำนวนเต็มจะถูกเรียงลำดับ ส่วน property ที่เหลือจะเรียงตามลำดับที่สร้าง
 
-As an example, let's consider an object with the phone codes:
+ตัวอย่าง พิจารณา object ที่เก็บค่ารหัสโทรศัพท์:
 
 ```js run
 let codes = {
@@ -407,23 +435,36 @@ let codes = {
 
 *!*
 for (let code in codes) {
-  alert(code); // 1, 41, 44, 49
+  alert(code); // จะได้ 1, 41, 44, 49 ตามลำดับ
 }
 */!*
 ```
 
+<<<<<<< HEAD
+object ด้านบนอาจถูกใช้เก็บตัวเลือกให้ user เลือก สมมติเรากำลังทำเว็บสำหรับชาวเยอรมันเป็นหลัก เราย่อมต้องการให้ `49` แสดงเป็นตัวเลือกแรก
+=======
 The object may be used to suggest a list of options to the user. If we're making a site mainly for a German audience then we probably want `49` to be the first.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-But if we run the code, we see a totally different picture:
+แต่เมื่อเรารันโค้ดเรากลับได้ผลลำดับที่แตกต่างกันกับตอนประกาศอย่างสิ้นเชิง ดังนี้:
 
-- USA (1) goes first
-- then Switzerland (41) and so on.
+- USA (1) มาก่อน
+- ตามด้วย Switzerland (41) และอื่นๆ ตามลำดับ
 
-The phone codes go in the ascending sorted order, because they are integers. So we see `1, 41, 44, 49`.
+เนื่องมาจากรหัสโทรศัพท์มีค่าเป็นจำนวนเต็มถึงถูกเรียงลำดับจากน้อยไปมาก ดังนี้ `1, 41, 44, 49`
 
 ````smart header="Integer properties? What's that?"
-The "integer property" term here means a string that can be converted to-and-from an integer without a change.
+คำว่า "integer property" ในที่นี้หมายถึงข้อความสตริงที่สามารถ แปลงเป็นและแปลงจาก จำนวนเต็มได้โดยค่าไม่เปลี่ยนไป
+
+<<<<<<< HEAD
+"49" เป็น key ชนิด integer property เพราะไม่ว่าจะแปลงไปหรือแปลงกลับก็จะได้ค่าเดิม แต่สำหรับ "+49" and "1.2" นั้นเมื่อแปลงไปมา จะไม่ได้ค่าเดิม ดังนี้:
 
+```js run
+// Math.trunc เป็น built-in function ใช้ตัดส่วนทศนิยมออก
+alert( String(Math.trunc(Number("49"))) ); // ได้ "49" เหมือนเดิม เป็น integer property
+alert( String(Math.trunc(Number("+49"))) ); // ได้ "49" ไม่เท่ากับ "+49" ⇒ ไม่เป็น integer property
+alert( String(Math.trunc(Number("1.2"))) ); // ได้ "1" ไม่เท่ากับ "1.2" ⇒ ไม่เป็น integer property
+=======
 So, `"49"` is an integer property name, because when it's transformed to an integer number and back, it's still the same. But `"+49"` and `"1.2"` are not:
 
 ```js run
@@ -432,27 +473,28 @@ So, `"49"` is an integer property name, because when it's transformed to an inte
 alert( String(Math.trunc(Number("49"))) ); // "49", same, integer property
 alert( String(Math.trunc(Number("+49"))) ); // "49", not same "+49" ⇒ not integer property
 alert( String(Math.trunc(Number("1.2"))) ); // "1", not same "1.2" ⇒ not integer property
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 ```
 ````
 
-...On the other hand, if the keys are non-integer, then they are listed in the creation order, for instance:
+...ในทางกลับกัน หาก key เป็นชนิด non-integer หรือก็คือไม่เป็นจำนวนเต็ม จะถูกเรียงตามลำดับของการประกาศ ตัวอย่างเช่น:
 
 ```js run
 let user = {
   name: "John",
   surname: "Smith"
 };
-user.age = 25; // add one more
+user.age = 25; // เพิ่ม property
 
 *!*
-// non-integer properties are listed in the creation order
+// key ของ property เป็น non-integer จะถูกเรียงตามลำดับการประกาศ
 */!*
 for (let prop in user) {
-  alert( prop ); // name, surname, age
+  alert( prop ); // ได้ name surname และ age ตามลำดับ
 }
 ```
 
-So, to fix the issue with the phone codes, we can "cheat" by making the codes non-integer. Adding a plus `"+"` sign before each code is enough.
+ดังนั้น เพื่อแก้ปัญหากรณีรหัสโทรศัพท์ เราสามารถ "โกง" ด้วยการทำให้ key เป็น non-integer โดยการเติมเครื่องหมายบวก `"+"` เข้าไป
 
 Like this:
 
@@ -466,38 +508,44 @@ let codes = {
 };
 
 for (let code in codes) {
-  alert( +code ); // 49, 41, 44, 1
+  alert( +code ); // ได้ 49 41 44 และ 1 เป็นลำดับตามการประกาศ
 }
 ```
 
-Now it works as intended.
+ได้โค้ดที่ทำงานตามตั้งใจแล้ว
 
-## Summary
+## สรุป
 
-Objects are associative arrays with several special features.
+Object เป็น associative array พร้อมด้วยคุณลักษณะพิเศษหลายอย่าง
 
-They store properties (key-value pairs), where:
-- Property keys must be strings or symbols (usually strings).
-- Values can be of any type.
+ใช้เก็บค่า property (ในรูปแบบคู่ของ key-value) ดังนี้:
+- key ของ property ต้องเป็น ข้อความสตริงหรือสัญลักษณ์ (ปรกติจะเป็นข้อความสตริง)
+- value เป็นค่าชนิดใดก็ได้
 
+<<<<<<< HEAD
+เราสามารถเข้าถึง property โดยการใช้งาน:
+- dot notation: `obj.property`.
+- วงเล็บเหลี่ยม `obj["property"]` ซึ่งยังอนุญาตให้เราแทนค่า key จากตัวแปร เช่น `obj[varWithKey]` ได้ด้วย
+=======
 To access a property, we can use:
 - The dot notation: `obj.property`.
 - Square brackets notation `obj["property"]`. Square brackets allow taking the key from a variable, like `obj[varWithKey]`.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-Additional operators:
-- To delete a property: `delete obj.prop`.
-- To check if a property with the given key exists: `"key" in obj`.
-- To iterate over an object: `for (let key in obj)` loop.
+ตัวดำเนินการเพิ่มเติม:
+- ลบ property ด้วยตัวกำเนินการ delete: `delete obj.prop`.
+- ทดสอบว่ามี property ที่เราสนใจใน object หรือไม่ด้วยตัวดำเนินการ in: `"key" in obj`.
+- วนลูปด้วย property ใน object: `for (let key in obj)`
 
-What we've studied in this chapter is called a "plain object", or just `Object`.
+สิ่งที่เราได้ศึกษากันในบทนี้เรียกว่า "plain object" หรือแค่ `Object` เฉยๆ ก็ได้
 
-There are many other kinds of objects in JavaScript:
+ยังมี object อยู่อีกหลายชนิดใน JavaScript:
 
-- `Array` to store ordered data collections,
-- `Date` to store the information about the date and time,
-- `Error` to store the information about an error.
-- ...And so on.
+- `Array` สำหรับเก็บข้อมูลเป็นชุดตามลำดับ
+- `Date` สำหรับเก็บข้อมูลของวันที่และเวลา
+- `Error` สำหรับเก็บข้อมูลของ error
+- ...และอื่นๆ อีก
 
-They have their special features that we'll study later. Sometimes people say something like "Array type" or "Date type", but formally they are not types of their own, but belong to a single "object" data type. And they extend it in various ways.
+โดยแต่ละชนิดจะมีคุณลักษณะพิเศษที่เราจะศึกษากันต่อไป ในบางครั้งที่มีการพูดถึง "ข้อมูลชนิด array" "ข้อมูลชนิด date" นั้น โดยแท้จริงแล้วไม่ได้มีชนิดข้อมูลเหลานี้แต่อย่างใดแต่เป็นข้อมูลชนิดเดียวกันก็คือ object ซึ่งแต่ละแบบก็ต่อขยายคุณลักษณะเพิ่มเติมแตกต่างกันไป
 
-Objects in JavaScript are very powerful. Here we've just scratched the surface of a topic that is really huge. We'll be closely working with objects and learning more about them in further parts of the tutorial.
+Object ใน JavaScript มีประโยชน์มาก เราเพิ่งจะได้เรียนรู้หัวข้อที่มีขนาดใหญ่นี้เพียงผิวเผินเท่านั้น เราจะได้ใช้งาน object อยู่ตลอดและจะได้เรียนรู้เพิ่มเติมในส่วนอื่นๆ ของ tutorial ชุดนี้ต่อไปในภายหน้า
diff --git a/1-js/04-object-basics/02-object-copy/article.md b/1-js/04-object-basics/02-object-copy/article.md
index e80f748ab..1e5c1699b 100644
--- a/1-js/04-object-basics/02-object-copy/article.md
+++ b/1-js/04-object-basics/02-object-copy/article.md
@@ -1,29 +1,29 @@
-# Object references and copying
+# การอ้างอิงและการคัดลอกออบเจ็กต์
 
-One of the fundamental differences of objects versus primitives is that objects are stored and copied "by reference", whereas primitive values: strings, numbers, booleans, etc -- are always copied "as a whole value".
+หนึ่งในความแตกต่างสำคัญระหว่างออบเจ็กต์กับข้อมูลพื้นฐาน คือออบเจ็กต์ถูกจัดเก็บและคัดลอก "โดยการอ้างอิง" ในขณะที่ค่าพื้นฐานอย่างเช่น string, number, boolean เป็นต้น จะถูกคัดลอกเป็น "ค่าทั้งหมด" เสมอ
 
-That's easy to understand if we look a bit under the hood of what happens when we copy a value.
+เราจะเข้าใจได้ง่ายขึ้นหากดูลึกลงไปว่ามีอะไรเกิดขึ้นเมื่อเราคัดลอกค่า
 
-Let's start with a primitive, such as a string.
+เริ่มต้นด้วยข้อมูลพื้นฐาน เช่น string
 
-Here we put a copy of `message` into `phrase`:
+ที่นี่เราคัดลอก `message` ใส่ในตัวแปร `phrase`:
 
 ```js
 let message = "Hello!";
 let phrase = message;
 ```
 
-As a result we have two independent variables, each one storing the string `"Hello!"`.
+ผลลัพธ์คือเรามีสองตัวแปรที่เป็นอิสระต่อกัน แต่ละตัวเก็บค่า string `"Hello!"` 
 
 ![](variable-copy-value.svg)
 
-Quite an obvious result, right?
+ผลลัพธ์ค่อนข้างชัดเจน ใช่ไหม?
 
-Objects are not like that.
+แต่ออบเจ็กต์ไม่เป็นแบบนั้น
 
-**A variable assigned to an object stores not the object itself, but its "address in memory" -- in other words "a reference" to it.**
+**ตัวแปรที่กำหนดให้กับออบเจ็กต์จะไม่ได้เก็บตัวออบเจ็กต์เอง แต่จะเก็บ "ที่อยู่ในหน่วยความจำ" หรือพูดอีกอย่างคือ "การอ้างอิง" ไปยังออบเจ็กต์นั้น**
 
-Let's look at an example of such a variable:
+มาดูตัวอย่างของตัวแปรแบบนี้:
 
 ```js
 let user = {
@@ -31,35 +31,39 @@ let user = {
 };
 ```
 
-And here's how it's actually stored in memory:
+และนี่คือวิธีที่มันถูกเก็บในหน่วยความจำจริงๆ:
 
 ![](variable-contains-reference.svg)
 
-The object is stored somewhere in memory (at the right of the picture), while the `user` variable (at the left) has a "reference" to it.
+ออบเจ็กต์จะถูกเก็บไว้ที่ใดที่หนึ่งในหน่วยความจำ (ทางขวาของภาพ) ในขณะที่ตัวแปร `user` (ทางซ้าย) มี "การอ้างอิง" ไปยังมัน
 
+<<<<<<< HEAD
+เราอาจมองตัวแปรออบเจ็กต์อย่าง `user` เหมือนกระดาษแผ่นหนึ่งที่มีที่อยู่ของออบเจ็กต์เขียนอยู่
+=======
 We may think of an object variable, such as `user`, like a sheet of paper with the address of the object on it.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-When we perform actions with the object, e.g. take a property `user.name`, the JavaScript engine looks at what's at that address and performs the operation on the actual object.
+เมื่อเราดำเนินการกับออบเจ็กต์ เช่น เข้าถึงพร็อพเพอร์ตี้ `user.name` เอนจิ้น JavaScript จะไปดูที่ที่อยู่นั้นและดำเนินการกับออบเจ็กต์ที่เก็บอยู่จริง
 
-Now here's why it's important.
+ตอนนี้เราจะเข้าใจความสำคัญของเรื่องนี้
 
-**When an object variable is copied, the reference is copied, but the object itself is not duplicated.**
+**เมื่อตัวแปรออบเจ็กต์ถูกคัดลอก การอ้างอิงจะถูกคัดลอก แต่ตัวออบเจ็กต์เองจะไม่ถูกทำสำเนา**
 
-For instance:
+ตัวอย่างเช่น:
 
 ```js no-beautify
 let user = { name: "John" };
 
-let admin = user; // copy the reference
+let admin = user; // คัดลอกการอ้างอิง
 ```
 
-Now we have two variables, each storing a reference to the same object:
+ตอนนี้เรามีสองตัวแปร แต่ละตัวเก็บการอ้างอิงไปยังออบเจ็กต์เดียวกัน:
 
 ![](variable-copy-reference.svg)
 
-As you can see, there's still one object, but now with two variables that reference it.
+อย่างที่เห็น ยังคงมีแค่ออบเจ็กต์เดียว แต่ตอนนี้มีสองตัวแปรที่อ้างอิงถึงมัน
 
-We can use either variable to access the object and modify its contents:
+เราสามารถใช้ตัวแปรใดก็ได้เพื่อเข้าถึงออบเจ็กต์และแก้ไขเนื้อหาของมัน:
 
 ```js run
 let user = { name: 'John' };
@@ -67,43 +71,50 @@ let user = { name: 'John' };
 let admin = user;
 
 *!*
-admin.name = 'Pete'; // changed by the "admin" reference
+admin.name = 'Pete'; // เปลี่ยนโดยใช้การอ้างอิง "admin"
 */!*
 
-alert(*!*user.name*/!*); // 'Pete', changes are seen from the "user" reference
+alert(*!*user.name*/!*); // 'Pete', การเปลี่ยนแปลงจะเห็นได้จากการอ้างอิง "user" ด้วย
 ```
 
-It's as if we had a cabinet with two keys and used one of them (`admin`) to get into it and make changes. Then, if we later use another key (`user`), we are still opening the same cabinet and can access the changed contents.
+เปรียบเหมือนเรามีตู้ตั้งอยู่และมีกุญแจสองดอก แล้วเราใช้กุญแจดอกหนึ่ง (`admin`) ในการเข้าไปเปลี่ยนแปลงข้างใน จากนั้นถ้าเราใช้กุญแจอีกดอก (`user`) เราก็ยังคงเปิดตู้ใบเดิมและสามารถเข้าถึงข้อมูลที่ถูกเปลี่ยนไปได้
 
-## Comparison by reference
+## การเปรียบเทียบโดยใช้การอ้างอิง
 
-Two objects are equal only if they are the same object.
+สองออบเจ็กต์จะเท่ากันก็ต่อเมื่อมันเป็นออบเจ็กต์เดียวกันเท่านั้น
 
-For instance, here `a` and `b` reference the same object, thus they are equal:
+ตัวอย่างเช่น ในกรณีนี้ `a` และ `b` อ้างอิงถึงออบเจ็กต์เดียวกัน ดังนั้นจึงเท่ากัน:
 
 ```js run
 let a = {};
-let b = a; // copy the reference
+let b = a; // คัดลอกการอ้างอิง
 
-alert( a == b ); // true, both variables reference the same object
+alert( a == b ); // true, ตัวแปรทั้งสองอ้างอิงถึงออบเจ็กต์เดียวกัน
 alert( a === b ); // true
 ```
 
-And here two independent objects are not equal, even though they look alike (both are empty):
+และในกรณีนี้ ออบเจ็กต์สองตัวที่เป็นอิสระจากกัน ไม่เท่ากัน แม้ว่าจะดูเหมือนกัน (เป็นออบเจ็กต์ว่างทั้งคู่):
 
 ```js run
 let a = {};
-let b = {}; // two independent objects
+let b = {}; // ออบเจ็กต์สองตัวที่แยกจากกัน
 
 alert( a == b ); // false
 ```
 
-For comparisons like `obj1 > obj2` or for a comparison against a primitive `obj == 5`, objects are converted to primitives. We'll study how object conversions work very soon, but to tell the truth, such comparisons are needed very rarely -- usually they appear as a result of a programming mistake.
+สำหรับการเปรียบเทียบอย่างเช่น `obj1 > obj2` หรือการเปรียบเทียบกับค่าพื้นฐานอย่าง `obj == 5` ออบเจ็กต์จะถูกแปลงเป็นค่าพื้นฐาน เราจะศึกษาวิธีการแปลงออบเจ็กต์ในเร็วๆ นี้ แต่ตามความเป็นจริงแล้ว การเปรียบเทียบลักษณะนั้นมักไม่ค่อยจำเป็น -- โดยส่วนใหญ่มักเกิดจากข้อผิดพลาดในการเขียนโปรแกรม
+
+<<<<<<< HEAD
+````smart header="ออบเจ็กต์ const ยังสามารถแก้ไขได้"
+ผลข้างเคียงสำคัญของการเก็บออบเจ็กต์แบบอ้างอิงคือ ออบเจ็กต์ที่ประกาศเป็น `const` *สามารถ* ถูกแก้ไขได้
 
+ตัวอย่างเช่น:
+=======
 ````smart header="Const objects can be modified"
 An important side effect of storing objects as references is that an object declared as `const` *can* be modified.
 
 For instance:
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
 ```js run
 const user = {
@@ -117,13 +128,16 @@ user.name = "Pete"; // (*)
 alert(user.name); // Pete
 ```
 
-It might seem that the line `(*)` would cause an error, but it does not. The value of `user` is constant, it must always reference the same object, but properties of that object are free to change.
+ดูเหมือนว่าบรรทัดที่ `(*)` น่าจะทำให้เกิดข้อผิดพลาด แต่จริงๆ แล้วไม่ ค่าของ `user` ยังคงไม่เปลี่ยนแปลง มันยังอ้างอิงถึงออบเจ็กต์เดิม แต่คุณสมบัติของออบเจ็กต์นั้นสามารถเปลี่ยนแปลงได้โดยอิสระ
 
-In other words, the `const user` gives an error only if we try to set `user=...` as a whole.
+อีกนัยหนึ่ง `const user` จะให้ข้อผิดพลาดก็ต่อเมื่อเราพยายามกำหนด `user=...` ใหม่ทั้งหมด
 
-That said, if we really need to make constant object properties, it's also possible, but using totally different methods. We'll mention that in the chapter <info:property-descriptors>.
+อย่างไรก็ตาม หากเราต้องการทำให้คุณสมบัติของออบเจ็กต์คงที่จริงๆ ก็สามารถทำได้ แต่ต้องใช้วิธีที่แตกต่างออกไป เราจะกล่าวถึงเรื่องนี้ในบท <info:property-descriptors>
 ````
 
+<<<<<<< HEAD
+## การโคลนและการรวมออบเจ็กต์ด้วย Object.assign [#cloning-and-merging-object-assign]
+=======
 ## Cloning and merging, Object.assign [#cloning-and-merging-object-assign]
 
 So, copying an object variable creates one more reference to the same object.
@@ -317,9 +331,205 @@ Function properties aren't supported.
 To handle such complex cases we may need to use a combination of cloning methods, write custom code or, to not reinvent the wheel, take an existing implementation, for instance [_.cloneDeep(obj)](https://lodash.com/docs#cloneDeep) from the JavaScript library [lodash](https://lodash.com).
 
 ## Summary
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
+
+ดังนั้น การคัดลอกตัวแปรออบเจ็กต์จะสร้างการอ้างอิงเพิ่มอีกอันไปยังออบเจ็กต์เดียวกัน
+
+แต่ถ้าเราต้องการทำสำเนาออบเจ็กต์ล่ะ?
+
+<<<<<<< HEAD
+เราสามารถสร้างออบเจ็กต์ใหม่และทำซ้ำโครงสร้างของออบเจ็กต์เดิมได้ โดยการวนลูปผ่านคุณสมบัติทั้งหมดของมัน แล้วคัดลอกค่าพื้นฐานของแต่ละคุณสมบัติ
+
+แบบนี้:
+
+```js run
+let user = {
+  name: "John",
+  age: 30
+};
+
+*!*
+let clone = {}; // ออบเจ็กต์เปล่าใหม่
+
+// คัดลอกคุณสมบัติทั้งหมดของ user ใส่ในออบเจ็กต์ clone
+for (let key in user) {
+  clone[key] = user[key];
+}
+*/!*
+
+// ตอนนี้ clone เป็นออบเจ็กต์ที่เป็นอิสระอย่างสมบูรณ์แล้ว แต่มีเนื้อหาเหมือนกับ user
+clone.name = "Pete"; // เปลี่ยนข้อมูลใน clone
+
+alert( user.name ); // ในออบเจ็กต์ต้นฉบับยังคงเป็น John อยู่
+```
+
+เรายังสามารถใช้เมท็อด [Object.assign](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign) ได้ด้วย
+
+รูปแบบการใช้งานคือ:
+
+```js
+Object.assign(dest, ...sources)
+```
+
+- อาร์กิวเมนต์แรก `dest` คือออบเจ็กต์ปลายทาง (target)
+- อาร์กิวเมนต์ถัดๆ ไปคือรายการออบเจ็กต์ต้นทาง (sources)
+
+มันจะคัดลอกคุณสมบัติทั้งหมดจากออบเจ็กต์ต้นทางไปใส่ในออบเจ็กต์ปลายทาง `dest` แล้วคืนค่า `dest` เป็นผลลัพธ์
+
+ตัวอย่างเช่น สมมติเรามีออบเจ็กต์ `user` ลองเพิ่มสิทธิ์การเข้าถึง (permissions) สองอย่างให้กับมัน:
+
+```js run
+let user = { name: "John" };
+
+let permissions1 = { canView: true };
+let permissions2 = { canEdit: true };
+
+*!*
+// คัดลอกคุณสมบัติทั้งหมดจาก permissions1 และ permissions2 ไปใส่ใน user
+Object.assign(user, permissions1, permissions2);
+*/!*
+
+// ตอนนี้ user = { name: "John", canView: true, canEdit: true }
+alert(user.name); // John
+alert(user.canView); // true
+alert(user.canEdit); // true
+```
+
+ถ้าชื่อคุณสมบัติที่คัดลอกซ้ำกับที่มีอยู่แล้ว ค่าจะถูกเขียนทับ:
+
+```js run
+let user = { name: "John" };
+
+Object.assign(user, { name: "Pete" });
+
+alert(user.name); // ตอนนี้ user = { name: "Pete" }
+```
+
+เรายังสามารถใช้ `Object.assign` เพื่อโคลนออบเจ็กต์อย่างง่ายๆ ได้ด้วย:
+
+```js run
+let user = {
+  name: "John",
+  age: 30
+};
+
+*!*
+let clone = Object.assign({}, user);
+*/!*
+
+alert(clone.name); // John
+alert(clone.age); // 30
+```
+
+ตรงนี้มันจะคัดลอกคุณสมบัติทั้งหมดของ `user` ไปใส่ในออบเจ็กต์เปล่า แล้วคืนออบเจ็กต์นั้นเป็นผลลัพธ์
+
+มีวิธีอื่นๆ ในการโคลนออบเจ็กต์ด้วย เช่น การใช้ [spread syntax](info:rest-parameters-spread) `clone = {...user}` ซึ่งเราจะกล่าวถึงในภายหลังของบทเรียน
+
+## การโคลนแบบซ้อน (Nested cloning)
+
+จนถึงตอนนี้ เราสมมติว่าคุณสมบัติทั้งหมดของ `user` เป็นข้อมูลพื้นฐาน แต่ในความเป็นจริง คุณสมบัติสามารถเป็นการอ้างอิงไปยังออบเจ็กต์อื่นก็ได้
+
+ตัวอย่างเช่น:
+```js run
+let user = {
+  name: "John",
+  sizes: {
+    height: 182,
+    width: 50
+  }
+};
+
+alert( user.sizes.height ); // 182
+```
+
+ตอนนี้ การคัดลอกแบบ `clone.sizes = user.sizes` ไม่เพียงพออีกต่อไป เพราะ `user.sizes` เป็นออบเจ็กต์ และจะถูกคัดลอกแบบอ้างอิง ทำให้ `clone` กับ `user` จะใช้ออบเจ็กต์ sizes ร่วมกัน:
+
+```js run
+let user = {
+  name: "John",
+  sizes: {
+    height: 182,
+    width: 50
+  }
+};
+
+let clone = Object.assign({}, user);
+
+alert( user.sizes === clone.sizes ); // true, เป็นออบเจ็กต์ตัวเดียวกัน
+
+// user กับ clone ใช้ sizes ร่วมกัน
+user.sizes.width = 60;    // เปลี่ยนค่าจากที่ user
+alert(clone.sizes.width); // 60, ผลลัพธ์เปลี่ยนตามใน clone ด้วย
+```
+
+เพื่อแก้ปัญหานี้และทำให้ `user` กับ `clone` เป็นออบเจ็กต์ที่แยกจากกันจริงๆ เราควรใช้ลูปการโคลน ที่จะตรวจสอบค่าของ `user[key]` แต่ละตัว และถ้าเป็นออบเจ็กต์ ก็ให้ทำซ้ำ (replicate) โครงสร้างของมันด้วย นี่เรียกว่า "deep cloning" หรือ "structured cloning" ซึ่งมีเมท็อด [structuredClone](https://developer.mozilla.org/en-US/docs/Web/API/structuredClone) ที่ทำ deep cloning ให้
+
+### structuredClone
+
+การเรียก `structuredClone(object)` จะโคลน `object` พร้อมกับคุณสมบัติซ้อนทั้งหมด
+
+นี่คือวิธีการใช้ในตัวอย่างของเรา:
+
+```js run
+let user = {
+  name: "John",
+  sizes: {
+    height: 182,
+    width: 50
+  }
+};
+
+*!*
+let clone = structuredClone(user);
+*/!*
+
+alert( user.sizes === clone.sizes ); // false, ออบเจ็กต์คนละตัวกันแล้ว
+
+// ตอนนี้ user กับ clone ไม่เกี่ยวข้องกันเลย
+user.sizes.width = 60;    // เปลี่ยนค่าที่ user
+alert(clone.sizes.width); // 50, ไม่กระทบ clone
+```
+
+เมท็อด `structuredClone` สามารถโคลนข้อมูลได้หลากหลายประเภท เช่น objects, arrays, primitive values
+
+นอกจากนี้ยังรองรับการอ้างอิงวนกลับ (circular references) ด้วย เช่นเมื่อคุณสมบัติของออบเจ็กต์อ้างอิงกลับไปที่ตัวออบเจ็กต์เอง (ทั้งโดยตรง หรือผ่านลูกโซ่การอ้างอิง)
+
+ตัวอย่างเช่น:
+
+```js run
+let user = {};
+// สร้างการอ้างอิงวนกลับ:
+// user.me อ้างอิงกลับไปที่ user เอง
+user.me = user;
+
+let clone = structuredClone(user);
+alert(clone.me === clone); // true
+```
+
+อย่างที่เห็น `clone.me` อ้างอิงถึง `clone` ไม่ใช่ `user`! ดังนั้นการอ้างอิงวนกลับก็ถูกโคลนอย่างถูกต้องเช่นกัน
+
+อย่างไรก็ตาม มีบางกรณีที่ `structuredClone` ล้มเหลว
+
+ตัวอย่างเช่น เมื่อออบเจ็กต์มีคุณสมบัติที่เป็นฟังก์ชัน:
+
+```js run
+// error
+structuredClone({
+  f: function() {}
+});
+```
+
+คุณสมบัติที่เป็นฟังก์ชันไม่ได้รับการสนับสนุน
+
+ในการจัดการกับเคสที่ซับซ้อนแบบนี้ เราอาจต้องใช้วิธีผสมผสานการโคลนหลายแบบ เขียนโค้ดเอง หรือเพื่อไม่ต้องเขียนโค้ดใหม่ทั้งหมดเอง อาจใช้การอิมพลีเมนต์ที่มีอยู่แล้ว เช่น [_.cloneDeep(obj)](https://lodash.com/docs#cloneDeep) จากไลบรารี JavaScript อย่าง [lodash](https://lodash.com)
+
+## สรุป
 
-Objects are assigned and copied by reference. In other words, a variable stores not the "object value", but a "reference" (address in memory) for the value. So copying such a variable or passing it as a function argument copies that reference, not the object itself.
+ออบเจ็กต์ถูกกำหนดและคัดลอกแบบอ้างอิง (by reference) กล่าวคือ ตัวแปรไม่ได้เก็บ "ค่าของออบเจ็กต์" แต่เก็บ "การอ้างอิง" (ที่อยู่ในหน่วยความจำ) ของค่านั้นแทน ดังนั้นการคัดลอกตัวแปรหรือส่งมันเป็น argument ของฟังก์ชัน จะเป็นการคัดลอกการอ้างอิงนั้น ไม่ใช่ตัวออบเจ็กต์เอง
 
-All operations via copied references (like adding/removing properties) are performed on the same single object.
+การดำเนินการใดๆ ผ่านการอ้างอิงที่คัดลอกมา (เช่นการเพิ่ม/ลบ property) จะเกิดขึ้นบนออบเจ็กต์อันเดียวกันทั้งหมด
 
+ในการสร้าง "สำเนาจริงๆ" (clone) เราสามารถใช้ `Object.assign` สำหรับ "shallow copy" (ออบเจ็กต์ซ้อนจะถูกคัดลอกแบบอ้างอิง) หรือใช้ฟังก์ชัน "deep cloning" อย่าง `structuredClone` หรือเขียนอิมพลีเมนต์การโคลนเอง เช่น [_.cloneDeep(obj)](https://lodash.com/docs#cloneDeep)
+=======
 To make a "real copy" (a clone) we can use `Object.assign` for the so-called "shallow copy" (nested objects are copied by reference) or a "deep cloning" function `structuredClone` or use a custom cloning implementation, such as [_.cloneDeep(obj)](https://lodash.com/docs#cloneDeep).
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
diff --git a/1-js/04-object-basics/03-garbage-collection/article.md b/1-js/04-object-basics/03-garbage-collection/article.md
index 1b576d629..6f599d7dc 100644
--- a/1-js/04-object-basics/03-garbage-collection/article.md
+++ b/1-js/04-object-basics/03-garbage-collection/article.md
@@ -1,38 +1,38 @@
-# Garbage collection
+# การเก็บขยะ
 
-Memory management in JavaScript is performed automatically and invisibly to us. We create primitives, objects, functions... All that takes memory.
+การจัดการหน่วยความจำใน JavaScript เป็นไปโดยอัตโนมัติและเกิดขึ้นแบบไม่เปิดเผย เมื่อเราสร้าง primitives, objects, functions ฯลฯ ทั้งหมดนั้นใช้หน่วยความจำ
 
-What happens when something is not needed any more? How does the JavaScript engine discover it and clean it up?
+แล้วเกิดอะไรขึ้นเมื่อมีสิ่งที่ไม่จำเป็นต้องใช้อีกต่อไป? JavaScript engine จะพบและทำความสะอาดได้อย่างไร?
 
-## Reachability
+## ความสามารถในการเข้าถึง
 
-The main concept of memory management in JavaScript is *reachability*.
+แนวคิดหลักของการจัดการหน่วยความจำใน JavaScript คือ *ความสามารถในการเข้าถึง (reachability)*
 
-Simply put, "reachable" values are those that are accessible or usable somehow. They are guaranteed to be stored in memory.
+อย่างง่ายๆ คือ ค่าที่ "เข้าถึงได้" หมายถึงค่าที่สามารถเรียกใช้หรือใช้งานได้ในทางใดทางหนึ่ง มีการรับประกันว่าจะถูกเก็บไว้ในหน่วยความจำ
 
-1. There's a base set of inherently reachable values, that cannot be deleted for obvious reasons.
+1. มีชุดพื้นฐานของค่าที่สามารถเข้าถึงได้โดยธรรมชาติ ซึ่งไม่สามารถถูกลบได้ด้วยเหตุผลที่ชัดเจน
 
-    For instance:
+    ตัวอย่างเช่น:
 
-    - The currently executing function, its local variables and parameters.
-    - Other functions on the current chain of nested calls, their local variables and parameters.
-    - Global variables.
-    - (there are some other, internal ones as well)
+    - ฟังก์ชันที่กำลังทำงานอยู่ ตัวแปรท้องถิ่น (local) และพารามิเตอร์ของมัน
+    - ฟังก์ชันอื่นๆ บนสายการเรียกแบบซ้อนกันในปัจจุบัน ตัวแปรท้องถิ่นและพารามิเตอร์ของมัน 
+    - ตัวแปรโกลบอล
+    - (และอื่นๆ อีกบางอย่างที่ซ่อนอยู่)
 
-    These values are called *roots*.
+    ค่าเหล่านี้เรียกว่า *roots*
 
-2. Any other value is considered reachable if it's reachable from a root by a reference or by a chain of references.
+2. ค่าอื่นๆ ถือว่าเข้าถึงได้ หากมันสามารถเข้าถึงได้จาก root โดยการอ้างอิงหรือสายของการอ้างอิง
 
-    For instance, if there's an object in a global variable, and that object has a property referencing another object, *that* object is considered reachable. And those that it references are also reachable. Detailed examples to follow.
+    ยกตัวอย่างเช่น หากมีออบเจ็กต์อยู่ในตัวแปรโกลบอล และออบเจ็กต์นั้นมีคุณสมบัติที่อ้างอิงไปยังออบเจ็กต์อื่น ออบเจ็กต์ *นั้น* ก็ถือว่าเข้าถึงได้ และออบเจ็กต์ที่มันอ้างอิงถึงก็เข้าถึงได้เช่นกัน ตัวอย่างโดยละเอียดจะอธิบายต่อไป
 
-There's a background process in the JavaScript engine that is called [garbage collector](https://en.wikipedia.org/wiki/Garbage_collection_(computer_science)). It monitors all objects and removes those that have become unreachable.
+มีกระบวนการที่ทำงานอยู่เบื้องหลังใน JavaScript engine ที่เรียกว่า [garbage collector](https://en.wikipedia.org/wiki/Garbage_collection_(computer_science)) มันคอยตรวจสอบออบเจ็กต์ทั้งหมด และลบทิ้งออบเจ็กต์ที่กลายเป็นขยะ ไม่สามารถเข้าถึงได้อีกต่อไป
 
-## A simple example
+## ตัวอย่างง่ายๆ 
 
-Here's the simplest example:
+นี่คือตัวอย่างที่เรียบง่ายที่สุด:
 
 ```js
-// user has a reference to the object
+// user มีการอ้างอิงไปยังออบเจ็กต์
 let user = {
   name: "John"
 };
@@ -40,9 +40,9 @@ let user = {
 
 ![](memory-user-john.svg)
 
-Here the arrow depicts an object reference. The global variable `"user"` references the object `{name: "John"}` (we'll call it John for brevity). The `"name"` property of John stores a primitive, so it's painted inside the object.
+ที่นี่ลูกศรหมายถึงการอ้างอิงออบเจ็กต์ ตัวแปรโกลบอล `"user"` อ้างอิงไปยัง ออบเจ็กต์ `{name: "John"}` (เราจะเรียกมันสั้นๆ ว่า John) ส่วนคุณสมบัติ `"name"` ของ John เก็บค่า primitive ไว้ จึงถูกแสดงอยู่ภายในออบเจ็กต์
 
-If the value of `user` is overwritten, the reference is lost:
+ถ้าค่าของ `user` ถูกเขียนทับ การอ้างอิงจะหายไป:
 
 ```js
 user = null;
@@ -50,14 +50,14 @@ user = null;
 
 ![](memory-user-john-lost.svg)
 
-Now John becomes unreachable. There's no way to access it, no references to it. Garbage collector will junk the data and free the memory.
+ตอนนี้ John ไม่สามารถเข้าถึงได้อีกต่อไป ไม่มีทางเข้าถึงมันได้ ไม่มีการอ้างอิงใดๆ ถึงมันแล้ว Garbage collector จะเก็บข้อมูลขยะและคืนหน่วยความจำ
 
-## Two references
+## การอ้างอิงสองรายการ
 
-Now let's imagine we copied the reference from `user` to `admin`:
+ลองจินตนาการว่าเราได้คัดลอกการอ้างอิงจาก `user` ไปยัง `admin`:
 
 ```js
-// user has a reference to the object
+// user มีการอ้างอิงไปยังออบเจ็กต์
 let user = {
   name: "John"
 };
@@ -69,16 +69,20 @@ let admin = user;
 
 ![](memory-user-john-admin.svg)
 
-Now if we do the same:
+ตอนนี้ถ้าเราทำแบบเดิม:
 ```js
 user = null;
 ```
 
+<<<<<<< HEAD
+...แล้วออบเจ็กต์ก็ยังคงเข้าถึงได้ผ่านตัวแปรโกลบอล `admin` ดังนั้นจึงต้องยังคงอยู่ในหน่วยความจำ แต่ถ้าเราเขียนทับ `admin` ด้วย มันก็สามารถถูกลบทิ้งได้
+=======
 ...Then the object is still reachable via `admin` global variable, so it must stay in memory. If we overwrite `admin` too, then it can be removed.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-## Interlinked objects
+## ออบเจ็กต์ที่เชื่อมโยงกัน
 
-Now a more complex example. The family:
+ตอนนี้เป็นตัวอย่างที่ซับซ้อนกว่าเดิมเล็กน้อย ออบเจ็กต์ครอบครัว:
 
 ```js
 function marry(man, woman) {
@@ -98,15 +102,15 @@ let family = marry({
 });
 ```
 
-Function `marry` "marries" two objects by giving them references to each other and returns a new object that contains them both.
+ฟังก์ชัน `marry` "แต่งงาน" ให้ออบเจ็กต์สองตัว โดยให้มีการอ้างอิงถึงกันและกัน และคืนออบเจ็กต์ใหม่ที่มีทั้งสองอยู่ด้วย
 
-The resulting memory structure:
+โครงสร้างหน่วยความจำที่ได้:
 
 ![](family.svg)
 
-As of now, all objects are reachable.
+ณ ตอนนี้ ออบเจ็กต์ทั้งหมดเข้าถึงได้
 
-Now let's remove two references:
+มาลองลบการอ้างอิงสองรายการ:
 
 ```js
 delete family.father;
@@ -115,98 +119,130 @@ delete family.mother.husband;
 
 ![](family-delete-refs.svg)
 
-It's not enough to delete only one of these two references, because all objects would still be reachable.
+การลบแค่หนึ่งในสองรายการยังไม่เพียงพอ เพราะออบเจ็กต์ทั้งหมดจะยังคงเข้าถึงได้อยู่
 
-But if we delete both, then we can see that John has no incoming reference any more:
+แต่ถ้าเราลบทั้งสองรายการ จะเห็นว่า John ไม่มีการอ้างอิงมาหามันอีกต่อไป:
 
 ![](family-no-father.svg)
 
-Outgoing references do not matter. Only incoming ones can make an object reachable. So, John is now unreachable and will be removed from the memory with all its data that also became unaccessible.
+การอ้างอิงขาออกไม่มีความสำคัญ มีเพียงการอ้างอิงขาเข้าเท่านั้นที่สามารถทำให้ออบเจ็กต์เข้าถึงได้ ดังนั้นตอนนี้ John จึงไม่สามารถเข้าถึงได้ และจะถูกลบทิ้งพร้อมกับข้อมูลทั้งหมดที่ไม่สามารถเข้าถึงได้อีก
 
-After garbage collection:
+หลังจากการเก็บขยะ:
 
 ![](family-no-father-2.svg)
 
-## Unreachable island
+## เกาะที่เข้าถึงไม่ถึง
 
-It is possible that the whole island of interlinked objects becomes unreachable and is removed from the memory.
+มันเป็นไปได้ที่เกาะทั้งเกาะของออบเจ็กต์ที่เชื่อมโยงกันจะกลายเป็นสิ่งที่เข้าถึงไม่ได้และถูกลบออกจากหน่วยความจำ
 
-The source object is the same as above. Then:
+ออบเจ็กต์ต้นทางคือออบเจ็กต์เดิมเหมือนข้างบน จากนั้นเมื่อ:
 
 ```js
 family = null;
 ```
 
-The in-memory picture becomes:
+สถานการณ์ในหน่วยความจำจะเป็น:
 
 ![](family-no-family.svg)
 
-This example demonstrates how important the concept of reachability is.
+ตัวอย่างนี้แสดงให้เห็นว่าแนวคิดเรื่องความสามารถในการเข้าถึงนั้นสำคัญขนาดไหน
 
-It's obvious that John and Ann are still linked, both have incoming references. But that's not enough.
+มันเป็นที่ชัดเจนว่า John และ Ann ยังคงเชื่อมโยงกันอยู่ ทั้งคู่ยังมีการอ้างอิงขาเข้า แต่นั่นยังไม่เพียงพอ
 
-The former `"family"` object has been unlinked from the root, there's no reference to it any more, so the whole island becomes unreachable and will be removed.
+ออบเจ็กต์ `"family"` ที่เคยมีได้ถูกยกเลิกการเชื่อมโยงจาก root ไม่มีการอ้างอิงใดๆ ถึงมันอีกแล้ว ดังนั้นเกาะทั้งหมดจึงกลายเป็นสิ่งที่เข้าถึงไม่ได้และจะถูกลบทิ้ง
 
-## Internal algorithms
+## อัลกอริธึมภายใน
 
-The basic garbage collection algorithm is called "mark-and-sweep".
+อัลกอริธึมการเก็บขยะแบบพื้นฐานเรียกว่า "mark-and-sweep"
 
-The following "garbage collection" steps are regularly performed:
+ขั้นตอนการ "เก็บขยะ" ต่อไปนี้จะถูกดำเนินการเป็นระยะ:
 
-- The garbage collector takes roots and "marks" (remembers) them.
-- Then it visits and "marks" all references from them.
-- Then it visits marked objects and marks *their* references. All visited objects are remembered, so as not to visit the same object twice in the future.
-- ...And so on until every reachable (from the roots) references are visited.
-- All objects except marked ones are removed.
+- Garbage collector รวบรวม roots และ "ทำเครื่องหมาย" (จดจำไว้)
+- จากนั้นมันจะเยี่ยมและทำเครื่องหมายการอ้างอิงทั้งหมดจาก roots
+- แล้วจะไปยังออบเจ็กต์ที่ถูกทำเครื่องหมายและทำเครื่องหมาย *การอ้างอิง* ของพวกมัน ออบเจ็กต์ทั้งหมดที่ไปเยี่ยมจะถูกจดจำไว้ เพื่อไม่ให้ไปที่ออบเจ็กต์เดิมซ้ำ 
+- ...และทำแบบนี้ต่อไปเรื่อยๆ จนกว่าทุกการอ้างอิงที่เข้าถึงได้ (จาก roots) จะถูกไปเยี่ยมแล้ว
+- ออบเจ็กต์ทั้งหมด ยกเว้นที่มีเครื่องหมาย จะถูกลบทิ้ง
 
-For instance, let our object structure look like this:
+ยกตัวอย่างเช่น สมมติว่าโครงสร้างออบเจ็กต์ของเราเป็นแบบนี้:
 
 ![](garbage-collection-1.svg)
 
-We can clearly see an "unreachable island" to the right side. Now let's see how "mark-and-sweep" garbage collector deals with it.
+เราเห็นได้ชัดว่ามี "เกาะที่เข้าถึงไม่ได้" ที่ด้านขวา มาดูกันว่า garbage collector แบบ "mark-and-sweep" จัดการกับมันอย่างไร 
 
-The first step marks the roots:
+ขั้นแรกคือการทำเครื่องหมายที่ roots:
 
 ![](garbage-collection-2.svg)
 
+<<<<<<< HEAD
+จากนั้นเราก็ไปตามการอ้างอิงของพวกมันและทำเครื่องหมายออบเจ็กต์ที่ถูกอ้างอิงถึง:
+
+![](garbage-collection-3.svg)
+
+...และทำต่อไปเรื่อยๆ จนไม่มีออบเจ็กต์ให้ทำเครื่องหมายต่อ:
+=======
 Then we follow their references and mark referenced objects:
 
 ![](garbage-collection-3.svg)
 
 ...And continue to follow further references, while possible:
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
 ![](garbage-collection-4.svg)
 
-Now the objects that could not be visited in the process are considered unreachable and will be removed:
+ในตอนนี้ ออบเจ็กต์ที่ไม่มีการไปเยี่ยมระหว่างขั้นตอนจะถือว่าเข้าถึงไม่ได้แล้วและจะถูกลบทิ้งไป:
 
 ![](garbage-collection-5.svg)
 
-We can also imagine the process as spilling a huge bucket of paint from the roots, that flows through all references and marks all reachable objects. The unmarked ones are then removed.
+เราจะจินตนาการว่ากระบวนการทำงานเหมือนการใช้ถังสีขนาดใหญ่ราดจากจุด roots สีจะไหลไปตามการอ้างอิงทั้งหมดและทำเครื่องหมายที่ออบเจ็กต์ทุกตัวที่เข้าถึงได้ ส่วนที่ไม่มีเครื่องหมายก็จะถูกลบทิ้ง
 
+<<<<<<< HEAD
+นี่คือแนวคิดพื้นฐานของการทำงานของ garbage collection JavaScript engines มีการใช้เทคนิคปรับปรุงประสิทธิภาพหลายอย่างเพื่อให้มันทำงานได้เร็วขึ้นและไม่ทำให้เกิดความล่าช้าในการประมวลผลโค้ด
+=======
 That's the concept of how garbage collection works. JavaScript engines apply many optimizations to make it run faster and not introduce any delays into the code execution.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-Some of the optimizations:
+บางส่วนของเทคนิคเหล่านี้ได้แก่:
 
+<<<<<<< HEAD
+- **Generational collection** -- ออบเจ็กต์จะถูกแบ่งเป็นสองชุด: "ออบเจ็กต์ใหม่" และ "ออบเจ็กต์เก่า" ในโค้ดทั่วไป ออบเจ็กต์หลายตัวจะมีช่วงชีวิตสั้น: พวกมันถูกสร้างขึ้น ทำหน้าที่ และหายไปอย่างรวดเร็ว ดังนั้นจึงมีเหตุผลที่จะติดตามออบเจ็กต์ใหม่และคืนหน่วยความจำจากพวกมัน หากกรณีเป็นเช่นนั้นจริงๆ ส่วนที่อยู่นานพอจะกลายเป็น "ออบเจ็กต์เก่า" และถูกตรวจสอบน้อยลง
+- **Incremental collection** -- หากมีออบเจ็กต์จำนวนมาก และเราพยายามที่จะวนรอบและทำเครื่องหมายทีเดียวให้หมด อาจจะใช้เวลาพอสมควรและทำให้เกิดความล่าช้าที่สังเกตได้ชัดในการทำงาน ดังนั้น engine จะแบ่งชุดออบเจ็กต์ทั้งหมดที่มีอยู่ออกเป็นหลายส่วน แล้วค่อยๆ เก็บแต่ละส่วนทีละนิด จะมีการเก็บขยะหลายครั้งแบบเล็กๆ แทนที่จะเก็บครั้งเดียวทั้งหมด ซึ่งจำเป็นต้องมีการจัดการพิเศษระหว่างการเก็บแต่ละครั้งเพื่อติดตามการเปลี่ยนแปลง แต่ด้วยวิธีนี้เราจะเจอความล่าช้าเล็กน้อยหลายครั้ง แทนที่จะเป็นความล่าช้ามากๆ ครั้งใหญ่ครั้งเดียว
+- **Idle-time collection** -- garbage collector จะพยายามทำงานเฉพาะในช่วงที่ CPU ว่างเท่านั้น เพื่อลดผลกระทบต่อการทำงานของโปรแกรมให้มากที่สุด 
+=======
 - **Generational collection** -- objects are split into two sets: "new ones" and "old ones". In typical code, many objects have a short life span: they appear, do their job and die fast, so it makes sense to track new objects and clear the memory from them if that's the case. Those that survive for long enough, become "old" and are examined less often.
 - **Incremental collection** -- if there are many objects, and we try to walk and mark the whole object set at once, it may take some time and introduce visible delays in the execution. So the engine splits the whole set of existing objects into multiple parts. And then clear these parts one after another. There are many small garbage collections instead of a total one. That requires some extra bookkeeping between them to track changes, but we get many tiny delays instead of a big one.
 - **Idle-time collection** -- the garbage collector tries to run only while the CPU is idle, to reduce the possible effect on the execution.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-There exist other optimizations and flavours of garbage collection algorithms. As much as I'd like to describe them here, I have to hold off, because different engines implement different tweaks and techniques. And, what's even more important, things change as engines develop, so studying deeper "in advance", without a real need is probably not worth that. Unless, of course, it is a matter of pure interest, then there will be some links for you below.
+ยังมีการปรับแต่งและอัลกอริธึมการเก็บขยะในรูปแบบอื่นๆ อีกมากมาย ถึงแม้ผมอยากจะอธิบายถึงพวกมันที่นี่ก็ตาม แต่คงต้องยับยั้งไว้ก่อน เพราะแต่ละ engine จะมีเทคนิคและรายละเอียดปลีกย่อยที่แตกต่างกัน และที่สำคัญไปกว่านั้น สิ่งต่างๆ มักจะเปลี่ยนแปลงไปเมื่อ engine ถูกพัฒนา ดังนั้นการศึกษาเชิงลึก "ล่วงหน้า" โดยไม่มีความจำเป็นจริงๆ อาจจะไม่คุ้มค่านัก เว้นเสียแต่ว่ามันเป็นเรื่องที่คุณสนใจจริงๆ ซึ่งในกรณีนั้นจะมีลิงก์สำหรับอ่านเพิ่มเติมให้ด้านล่างนี้
 
-## Summary
+## สรุป
 
-The main things to know:
+สิ่งสำคัญที่ควรรู้มีดังนี้:
 
+<<<<<<< HEAD
+- Garbage collection เกิดขึ้นโดยอัตโนมัติ เราไม่สามารถบังคับให้มันทำงานหรือป้องกันมันได้
+- ออบเจ็กต์จะยังคงอยู่ในหน่วยความจำตราบเท่าที่ยังเข้าถึงได้
+- การถูกอ้างอิงไม่เท่ากับการเข้าถึงได้ (จาก root): หมู่ออบเจ็กต์ที่เชื่อมต่อกันอาจกลายเป็นสิ่งที่เข้าถึงไม่ได้ทั้งหมด เหมือนอย่างในตัวอย่างข้างต้น
+=======
 - Garbage collection is performed automatically. We cannot force or prevent it.
 - Objects are retained in memory while they are reachable.
 - Being referenced is not the same as being reachable (from a root): a pack of interlinked objects can become unreachable as a whole, as we've seen in the example above.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
+
+JavaScript engines สมัยใหม่ได้นำอัลกอริธึมขั้นสูงมาใช้ในการเก็บขยะ
+
+หนังสือทั่วไปเล่มหนึ่งชื่อ "The Garbage Collection Handbook: The Art of Automatic Memory Management" (R. Jones et al) ได้อธิบายถึงอัลกอริธึมบางส่วนเหล่านี้
 
-Modern engines implement advanced algorithms of garbage collection.
+<<<<<<< HEAD
+หากคุณมีความรู้เกี่ยวกับการเขียนโปรแกรมระดับต่ำ (low-level programming) ข้อมูลเพิ่มเติมโดยละเอียดเกี่ยวกับ garbage collector ของ V8 มีอยู่ในบทความ [A tour of V8: Garbage Collection](https://jayconrod.com/posts/55/a-tour-of-v8-garbage-collection)
 
-A general book "The Garbage Collection Handbook: The Art of Automatic Memory Management" (R. Jones et al) covers some of them.
+[บล็อกของ V8](https://v8.dev/) เองก็มีการเผยแพร่บทความเกี่ยวกับการเปลี่ยนแปลงในการจัดการหน่วยความจำเป็นระยะๆ แน่นอนว่าในการเรียนรู้เพิ่มเติมเกี่ยวกับ garbage collection คุณควรเตรียมพื้นฐานเกี่ยวกับการทำงานภายในของ V8 โดยทั่วไปก่อน และอ่านบล็อกของ [Vyacheslav Egorov](https://mrale.ph) ผู้ซึ่งเคยเป็นหนึ่งในทีมวิศวกรของ V8 ที่ผมพูดถึง "V8" เพราะมันเป็น engine ที่มีบทความเกี่ยวกับมันมากที่สุดในอินเทอร์เน็ต สำหรับ engine อื่นๆ หลายแนวคิดก็คล้ายคลึงกัน แต่การเก็บขยะจะมีความแตกต่างกันในรายละเอียดหลายอย่าง
 
+การมีความรู้เชิงลึกเกี่ยวกับ engine จะเป็นประโยชน์อย่างมากเมื่อคุณต้องการปรับแต่งประสิทธิภาพในระดับต่ำ (low-level optimizations) มันจะเป็นการฉลาดหากจะวางแผนศึกษาเรื่องนี้ในขั้นต่อไป หลังจากที่คุณมีความคุ้นเคยกับภาษาเป็นอย่างดีแล้ว
+=======
 If you are familiar with low-level programming, more detailed information about V8's garbage collector is in the article [A tour of V8: Garbage Collection](https://jayconrod.com/posts/55/a-tour-of-v8-garbage-collection).
 
 The [V8 blog](https://v8.dev/) also publishes articles about changes in memory management from time to time. Naturally, to learn more about garbage collection, you'd better prepare by learning about V8 internals in general and read the blog of [Vyacheslav Egorov](https://mrale.ph) who worked as one of the V8 engineers. I'm saying: "V8", because it is best covered by articles on the internet. For other engines, many approaches are similar, but garbage collection differs in many aspects.
 
 In-depth knowledge of engines is good when you need low-level optimizations. It would be wise to plan that as the next step after you're familiar with the language.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
diff --git a/1-js/04-object-basics/04-object-methods/article.md b/1-js/04-object-basics/04-object-methods/article.md
index cea2b6a70..073398504 100644
--- a/1-js/04-object-basics/04-object-methods/article.md
+++ b/1-js/04-object-basics/04-object-methods/article.md
@@ -1,6 +1,6 @@
-# Object methods, "this"
+# วิธีการของอ็อบเจ็กต์ และ "this"
 
-Objects are usually created to represent entities of the real world, like users, orders and so on:
+อ็อบเจ็กต์มักถูกสร้างขึ้นเพื่อเป็นตัวแทนของสิ่งต่างๆ ในโลกความเป็นจริง เช่น ผู้ใช้ ใบสั่งซื้อ และอื่นๆ:
 
 ```js
 let user = {
@@ -9,13 +9,13 @@ let user = {
 };
 ```
 
-And, in the real world, a user can *act*: select something from the shopping cart, login, logout etc.
+และในโลกความเป็นจริง ผู้ใช้สามารถ *กระทำ* สิ่งต่างๆ ได้: เลือกสินค้าจากตะกร้า เข้าสู่ระบบ ออกจากระบบ ฯลฯ 
 
-Actions are represented in JavaScript by functions in properties.
+การกระทำในจาวาสคริปต์จะถูกแทนที่ด้วยฟังก์ชันในคุณสมบัติ (properties)
 
-## Method examples
+## ตัวอย่างเมท็อด
 
-For a start, let's teach the `user` to say hello:
+ลองเริ่มจากการสอนให้ `user` พูดทักทาย:
 
 ```js run
 let user = {
@@ -32,15 +32,15 @@ user.sayHi = function() {
 user.sayHi(); // Hello!
 ```
 
-Here we've just used a Function Expression to create a function and assign it to the property `user.sayHi` of the object.
+ที่นี่เราใช้ฟังก์ชันนิพจน์ (Function Expression) เพื่อสร้างฟังก์ชันและกำหนดให้กับคุณสมบัติ `user.sayHi` ของอ็อบเจ็กต์
 
-Then we can call it as `user.sayHi()`. The user can now speak!
+จากนั้นเราก็เรียกมันด้วย `user.sayHi()` ตอนนี้ผู้ใช้สามารถพูดได้แล้ว!
 
-A function that is a property of an object is called its *method*.
+ฟังก์ชันที่เป็นคุณสมบัติของอ็อบเจ็กต์เรียกว่า *เมท็อด*
 
-So, here we've got a method `sayHi` of the object `user`.
+ดังนั้น ที่นี่เรามีเมท็อด `sayHi` ของอ็อบเจ็กต์ `user`
 
-Of course, we could use a pre-declared function as a method, like this:
+แน่นอนว่าเราสามารถใช้ฟังก์ชันที่ประกาศไว้ก่อนหน้าเป็นเมท็อดได้ เช่น:
 
 ```js run
 let user = {
@@ -48,29 +48,30 @@ let user = {
 };
 
 *!*
-// first, declare
+// ประกาศฟังก์ชันก่อน
 function sayHi() {
   alert("Hello!");
 }
 
-// then add as a method
+// จากนั้นเพิ่มเป็นเมท็อด
 user.sayHi = sayHi;
 */!*
 
 user.sayHi(); // Hello!
 ```
 
-```smart header="Object-oriented programming"
-When we write our code using objects to represent entities, that's called [object-oriented programming](https://en.wikipedia.org/wiki/Object-oriented_programming), in short: "OOP".
+```smart header="การเขียนโปรแกรมเชิงวัตถุ"
+เมื่อเราเขียนโค้ดโดยใช้อ็อบเจ็กต์เพื่อเป็นตัวแทนของสิ่งต่างๆ นั่นเรียกว่า [การเขียนโปรแกรมเชิงวัตถุ](https://en.wikipedia.org/wiki/Object-oriented_programming) หรือย่อว่า "OOP"
 
-OOP is a big thing, an interesting science of its own. How to choose the right entities? How to organize the interaction between them? That's architecture, and there are great books on that topic, like "Design Patterns: Elements of Reusable Object-Oriented Software" by E. Gamma, R. Helm, R. Johnson, J. Vissides or "Object-Oriented Analysis and Design with Applications" by G. Booch, and more.
+OOP เป็นเรื่องใหญ่และเป็นศาสตร์ที่น่าสนใจในตัวของมันเอง คำถามอย่างเช่น จะเลือกอ็อบเจ็กต์ที่เหมาะสมได้อย่างไร? จะจัดระเบียบการปฏิสัมพันธ์ระหว่างพวกมันยังไง? นี่คือเรื่องของสถาปัตยกรรม และมีหนังสือดีๆ เกี่ยวกับหัวข้อนี้มากมาย เช่น "Design Patterns: Elements of Reusable Object-Oriented Software" โดย E. Gamma, R. Helm, R. Johnson, J. Vissides หรือ "Object-Oriented Analysis and Design with Applications" โดย G. Booch เป็นต้น
 ```
-### Method shorthand
 
-There exists a shorter syntax for methods in an object literal:
+### เมท็อดแบบย่อ
+
+มีวิธีเขียนแบบย่อสำหรับเมท็อดใน object literal:
 
 ```js
-// these objects do the same
+// อ็อบเจ็กต์เหล่านี้ทำงานเหมือนกัน
 
 user = {
   sayHi: function() {
@@ -78,31 +79,35 @@ user = {
   }
 };
 
-// method shorthand looks better, right?
+// เมท็อดแบบย่อดูดีกว่าใช่ไหม?
 user = {
 *!*
-  sayHi() { // same as "sayHi: function(){...}"
+  sayHi() { // เหมือนกับ "sayHi: function(){...}"
 */!*
     alert("Hello");
   }
 };
 ```
 
-As demonstrated, we can omit `"function"` and just write `sayHi()`.
+อย่างที่เห็น เราสามารถละ `"function"` ทิ้งไปได้และเขียนแค่ `sayHi()`
 
+<<<<<<< HEAD
+จริงๆ แล้วสองแบบนี้ไม่ได้เหมือนกันทีเดียว มันมีความแตกต่างเล็กน้อยที่เกี่ยวข้องกับการสืบทอดของอ็อบเจ็กต์ (จะกล่าวถึงต่อไป) แต่ตอนนี้ยังไม่มีผลอะไร ในเกือบทุกกรณี แบบย่อจะเป็นที่นิยมมากกว่า
+=======
 To tell the truth, the notations are not fully identical. There are subtle differences related to object inheritance (to be covered later), but for now they do not matter. In almost all cases, the shorter syntax is preferred.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-## "this" in methods
+## "this" ในเมท็อด
 
-It's common that an object method needs to access the information stored in the object to do its job.
+เป็นเรื่องปกติที่เมท็อดของอ็อบเจ็กต์จำเป็นต้องเข้าถึงข้อมูลที่อยู่ในอ็อบเจ็กต์เพื่อทำหน้าที่ของมัน
 
-For instance, the code inside `user.sayHi()` may need the name of the `user`.
+ตัวอย่างเช่น โค้ดภายใน `user.sayHi()` อาจจำเป็นต้องใช้ชื่อของ `user`
 
-**To access the object, a method can use the `this` keyword.**
+**เมท็อดสามารถใช้คีย์เวิร์ด `this` เพื่อเข้าถึงอ็อบเจ็กต์**
 
-The value of `this` is the object "before dot", the one used to call the method.
+ค่าของ `this` คืออ็อบเจ็กต์ "ก่อนจุด" ที่ถูกใช้ในการเรียกเมท็อด
 
-For instance:
+เช่น:
 
 ```js run
 let user = {
@@ -111,7 +116,7 @@ let user = {
 
   sayHi() {
 *!*
-    // "this" is the "current object"
+    // "this" คืออ็อบเจ็กต์ "ปัจจุบัน"
     alert(this.name);
 */!*
   }
@@ -121,9 +126,9 @@ let user = {
 user.sayHi(); // John
 ```
 
-Here during the execution of `user.sayHi()`, the value of `this` will be `user`.
+ที่นี่ในระหว่างการประมวลผล `user.sayHi()` ค่าของ `this` จะเป็น `user`
 
-Technically, it's also possible to access the object without `this`, by referencing it via the outer variable:
+ในทางเทคนิคแล้ว เราสามารถเข้าถึงอ็อบเจ็กต์ได้โดยไม่ใช้ `this` ผ่านการอ้างอิงโดยตัวแปรภายนอก:
 
 ```js
 let user = {
@@ -132,16 +137,16 @@ let user = {
 
   sayHi() {
 *!*
-    alert(user.name); // "user" instead of "this"
+    alert(user.name); // ใช้ "user" แทน "this"
 */!*
   }
 
 };
 ```
 
-...But such code is unreliable. If we decide to copy `user` to another variable, e.g. `admin = user` and overwrite `user` with something else, then it will access the wrong object.
+...แต่โค้ดแบบนี้ไม่น่าเชื่อถือ หากเราตัดสินใจที่จะคัดลอก `user` ไปยังตัวแปรอื่น เช่น `admin = user` และเขียนทับ `user` ด้วยค่าอื่น มันจะเข้าถึงอ็อบเจ็กต์ผิดตัว
 
-That's demonstrated below:
+แสดงให้เห็นด้านล่าง:
 
 ```js run
 let user = {
@@ -150,7 +155,7 @@ let user = {
 
   sayHi() {
 *!*
-    alert( user.name ); // leads to an error
+    alert( user.name ); // ทำให้เกิด error  
 */!*
   }
 
@@ -158,20 +163,20 @@ let user = {
 
 
 let admin = user;
-user = null; // overwrite to make things obvious
+user = null; // เขียนทับเพื่อให้เห็นชัดเจน
 
 *!*
-admin.sayHi(); // TypeError: Cannot read property 'name' of null
+admin.sayHi(); // TypeError: ไม่สามารถอ่านคุณสมบัติ 'name' ของ null ได้
 */!*
 ```
 
-If we used `this.name` instead of `user.name` inside the `alert`, then the code would work.
+หากเราใช้ `this.name` แทน `user.name` ภายใน `alert` โค้ดก็จะทำงาน
 
-## "this" is not bound
+## "this" ไม่ถูกผูกไว้
 
-In JavaScript, keyword `this` behaves unlike most other programming languages. It can be used in any function, even if it's not a method of an object.
+ในจาวาสคริปต์ คีย์เวิร์ด `this` จะแตกต่างจากภาษาโปรแกรมส่วนใหญ่ มันสามารถใช้ในฟังก์ชันใดก็ได้ ถึงแม้ว่ามันจะไม่ใช่เมท็อดของอ็อบเจ็กต์ก็ตาม
 
-There's no syntax error in the following example:
+ในตัวอย่างต่อไปนี้ไม่มี syntax error:
 
 ```js
 function sayHi() {
@@ -179,9 +184,9 @@ function sayHi() {
 }
 ```
 
-The value of `this` is evaluated during the run-time, depending on the context.
+ค่าของ `this` จะถูกประเมินในช่วงเวลารันไทม์ (run-time) ขึ้นอยู่กับบริบท (context)
 
-For instance, here the same function is assigned to two different objects and has different "this" in the calls:
+ตัวอย่างเช่น ที่นี่ฟังก์ชันเดียวกันถูกกำหนดให้กับสองอ็อบเจ็กต์ที่ต่างกัน และมี "this" ที่แตกต่างกันในการเรียก:
 
 ```js run
 let user = { name: "John" };
@@ -192,23 +197,23 @@ function sayHi() {
 }
 
 *!*
-// use the same function in two objects
+// ใช้ฟังก์ชันเดียวกันในอ็อบเจ็กต์สองตัว
 user.f = sayHi;
 admin.f = sayHi;
 */!*
 
-// these calls have different this
-// "this" inside the function is the object "before the dot"
+// การเรียกเหล่านี้มี this ต่างกัน
+// "this" ภายในฟังก์ชันคืออ็อบเจ็กต์ "ก่อนจุด"
 user.f(); // John  (this == user)
 admin.f(); // Admin  (this == admin)
 
-admin['f'](); // Admin (dot or square brackets access the method – doesn't matter)
+admin['f'](); // Admin (การเข้าถึงด้วยจุดหรือวงเล็บก็ไม่ต่างกัน)
 ```
 
-The rule is simple: if `obj.f()` is called, then `this` is `obj` during the call of `f`. So it's either `user` or `admin` in the example above.
+กฎง่ายๆ คือ: ถ้ามีการเรียก `obj.f()` เมื่อนั้น `this` จะเป็น `obj` ในระหว่างการเรียก `f` ดังนั้นจะเป็น `user` หรือ `admin` ในตัวอย่างข้างต้น
 
-````smart header="Calling without an object: `this == undefined`"
-We can even call the function without an object at all:
+````smart header="การเรียกโดยไม่มีอ็อบเจ็กต์: `this == undefined`"
+เราสามารถเรียกฟังก์ชันได้โดยไม่มีอ็อบเจ็กต์เลยด้วย:
 
 ```js run
 function sayHi() {
@@ -218,28 +223,28 @@ function sayHi() {
 sayHi(); // undefined
 ```
 
-In this case `this` is `undefined` in strict mode. If we try to access `this.name`, there will be an error.
+ในกรณีนี้ `this` จะเป็น `undefined` ในโหมดเข้มงวด (strict mode) หากเราพยายามเข้าถึง `this.name` จะเกิด error
 
-In non-strict mode the value of `this` in such case will be the *global object* (`window` in a browser, we'll get to it later in the chapter [](info:global-object)). This is a historical behavior that `"use strict"` fixes.
+ในโหมดไม่เข้มงวด (non-strict mode) ค่าของ `this` ในกรณีนี้จะเป็น *global object* (`window` ในเบราว์เซอร์ เราจะเรียนรู้เพิ่มเติมในบท [](info:global-object)) นี่คือพฤติกรรมดั้งเดิมที่ `"use strict"` แก้ไข
 
-Usually such call is a programming error. If there's `this` inside a function, it expects to be called in an object context.
+โดยปกติแล้วการเรียกเช่นนี้เป็นข้อผิดพลาดในการเขียนโปรแกรม หากมี `this` อยู่ในฟังก์ชัน ย่อมหมายความว่ามันควรถูกเรียกในบริบทของอ็อบเจ็กต์
 ````
 
-```smart header="The consequences of unbound `this`"
-If you come from another programming language, then you are probably used to the idea of a "bound `this`", where methods defined in an object always have `this` referencing that object.
+````smart header="ผลที่ตามมาของ `this` ที่ไม่ได้ถูกผูกไว้"
+ถ้าคุณมาจากภาษาโปรแกรมอื่น คุณคงคุ้นเคยกับแนวคิดของ "`this` ที่ถูกผูกไว้แล้ว" ที่เมท็อดซึ่งประกาศภายในอ็อบเจ็กต์จะมี `this` อ้างถึงอ็อบเจ็กต์นั้นเสมอ 
 
-In JavaScript `this` is "free", its value is evaluated at call-time and does not depend on where the method was declared, but rather on what object is "before the dot".
+ในจาวาสคริปต์ `this` มีลักษณะ "อิสระ" ค่าของมันจะถูกประเมินในช่วงเวลาเรียก (call-time) และไม่ได้ขึ้นอยู่กับว่าเมท็อดถูกประกาศที่ไหน แต่จะขึ้นกับว่าอ็อบเจ็กต์ใดอยู่ "ก่อนจุด"
 
-The concept of run-time evaluated `this` has both pluses and minuses. On the one hand, a function can be reused for different objects. On the other hand, the greater flexibility creates more possibilities for mistakes.
+แนวคิดของ `this` ที่ถูกประเมินในช่วงรันไทม์ (run-time) มีทั้งข้อดีและข้อเสีย ในแง่หนึ่ง ฟังก์ชันสามารถนำไปใช้ซ้ำกับอ็อบเจ็กต์ต่างๆ ได้ แต่ในอีกแง่หนึ่ง ความยืดหยุ่นที่มากขึ้นก็ทำให้มีโอกาสเกิดข้อผิดพลาดได้มากขึ้นด้วย
 
-Here our position is not to judge whether this language design decision is good or bad. We'll understand how to work with it, how to get benefits and avoid problems.
-```
+ที่นี่เราไม่ได้ตัดสินว่าการออกแบบภาษานี้ดีหรือไม่ดี เราจะเข้าใจวิธีการทำงานกับมัน เพื่อใช้ประโยชน์และหลีกเลี่ยงปัญหา
+````
 
-## Arrow functions have no "this"
+## Arrow functions ไม่มี "this"
 
-Arrow functions are special: they don't have their "own" `this`. If we reference `this` from such a function, it's taken from the outer "normal" function.
+Arrow functions มีลักษณะพิเศษ: พวกมันไม่มี `this` "ของตัวเอง" หากใช้ `this` จากฟังก์ชันแบบนี้ ค่าจะถูกนำมาจากฟังก์ชัน "ปกติ" ด้านนอก
 
-For instance, here `arrow()` uses `this` from the outer `user.sayHi()` method:
+ตัวอย่างเช่น ที่นี่ `arrow()` ใช้ `this` จากเมท็อด `user.sayHi()` ภายนอก:
 
 ```js run
 let user = {
@@ -253,18 +258,17 @@ let user = {
 user.sayHi(); // Ilya
 ```
 
-That's a special feature of arrow functions, it's useful when we actually do not want to have a separate `this`, but rather to take it from the outer context. Later in the chapter <info:arrow-functions> we'll go more deeply into arrow functions.
-
+นี่คือลักษณะพิเศษของ arrow functions มันมีประโยชน์เมื่อเราไม่ต้องการให้มี `this` แยกต่างหาก แต่ต้องการนำเอา `this` มาจากบริบทภายนอก เราจะศึกษา arrow functions เพิ่มเติมในบท <info:arrow-functions>
 
-## Summary
+## สรุป
 
-- Functions that are stored in object properties are called "methods".
-- Methods allow objects to "act" like `object.doSomething()`.
-- Methods can reference the object as `this`.
+- ฟังก์ชันที่ถูกจัดเก็บในคุณสมบัติของอ็อบเจ็กต์เรียกว่า "เมท็อด"
+- เมท็อดช่วยให้อ็อบเจ็กต์ "ทำอะไรบางอย่าง" ได้ เช่น `object.doSomething()`
+- เมท็อดสามารถอ้างอิงอ็อบเจ็กต์ด้วย `this` ได้ 
 
-The value of `this` is defined at run-time.
-- When a function is declared, it may use `this`, but that `this` has no value until the function is called.
-- A function can be copied between objects.
-- When a function is called in the "method" syntax: `object.method()`, the value of `this` during the call is `object`.
+ค่าของ `this` ถูกกำหนดในช่วงรันไทม์
+- เมื่อประกาศฟังก์ชัน มันอาจใช้ `this` ได้ แต่ `this` จะยังไม่มีค่าจนกว่าฟังก์ชันจะถูกเรียก
+- ฟังก์ชันสามารถถูกคัดลอกระหว่างอ็อบเจ็กต์ได้
+- เมื่อฟังก์ชันถูกเรียกในรูปแบบ "เมท็อด": `object.method()` ค่าของ `this` ในระหว่างการเรียกคือ `object`
 
-Please note that arrow functions are special: they have no `this`. When `this` is accessed inside an arrow function, it is taken from outside.
+โปรดทราบว่า arrow functions มีลักษณะพิเศษ: มันไม่มี `this` เมื่อมีการเข้าถึง `this` ภายใน arrow function ค่าจะถูกนำมาจากภายนอก
\ No newline at end of file
diff --git a/1-js/04-object-basics/06-constructor-new/3-accumulator/task.md b/1-js/04-object-basics/06-constructor-new/3-accumulator/task.md
index c2c44881e..e6636fe9b 100644
--- a/1-js/04-object-basics/06-constructor-new/3-accumulator/task.md
+++ b/1-js/04-object-basics/06-constructor-new/3-accumulator/task.md
@@ -2,26 +2,27 @@ importance: 5
 
 ---
 
-# Create new Accumulator
+# สร้างตัวสะสมค่า (Accumulator) ใหม่
 
-Create a constructor function `Accumulator(startingValue)`.
+เรามาลองสร้างฟังก์ชันคอนสตรัคเตอร์ที่ชื่อว่า `Accumulator(startingValue)` กันเถอะ ซึ่งจะใช้สำหรับสร้างออบเจ็กต์ที่มีความสามารถในการสะสมค่าตัวเลข
 
-Object that it creates should:
+ออบเจ็กต์ที่สร้างขึ้นจาก `Accumulator` ควรมีคุณสมบัติดังนี้:
 
-- Store the "current value" in the property `value`. The starting value is set to the argument of the constructor `startingValue`.
-- The `read()` method should use `prompt` to read a new number and add it to `value`.
+- มีพร็อพเพอร์ตี้ `value` ที่ใช้ในการเก็บ "ค่าปัจจุบัน" โดยค่าเริ่มต้นของ `value` จะเท่ากับอาร์กิวเมนต์ `startingValue` ที่ส่งเข้ามาตอนเรียกใช้งานคอนสตรัคเตอร์เพื่อสร้างออบเจ็กต์
 
-In other words, the `value` property is the sum of all user-entered values with the initial value  `startingValue`.
+- มีเมท็อด `read()` ที่ใช้ `prompt` เพื่อรับค่าตัวเลขใหม่จากผู้ใช้ แล้วนำค่าตัวเลขใหม่นั้นไปบวกเพิ่มเข้ากับค่าปัจจุบันใน `value`
 
-Here's the demo of the code:
+หรือพูดอีกอย่างก็คือ พร็อพเพอร์ตี้ `value` จะเก็บผลรวมของค่าเริ่มต้น `startingValue` และค่าตัวเลขทั้งหมดที่ผู้ใช้ป้อนเข้ามาผ่านเมท็อด `read()`
+
+นี่คือตัวอย่างการทำงานของโค้ดที่ใช้ `Accumulator`:
 
 ```js
-let accumulator = new Accumulator(1); // initial value 1
+let accumulator = new Accumulator(1); // กำหนดค่าเริ่มต้นเป็น 1
 
-accumulator.read(); // adds the user-entered value
-accumulator.read(); // adds the user-entered value
+accumulator.read(); // รับค่าจากผู้ใช้ แล้วนำไปบวกเพิ่มเข้ากับค่าใน value
+accumulator.read(); // รับค่าจากผู้ใช้อีกครั้ง แล้วนำไปบวกเพิ่มเข้ากับค่าใน value อีกรอบ
 
-alert(accumulator.value); // shows the sum of these values
+alert(accumulator.value); // แสดงผลรวมของค่าเริ่มต้น และค่าที่ผู้ใช้ป้อนเข้ามาทั้งหมด
 ```
 
 [demo]
diff --git a/1-js/04-object-basics/06-constructor-new/article.md b/1-js/04-object-basics/06-constructor-new/article.md
index a335464f1..e8d69209c 100644
--- a/1-js/04-object-basics/06-constructor-new/article.md
+++ b/1-js/04-object-basics/06-constructor-new/article.md
@@ -1,17 +1,17 @@
-# Constructor, operator "new"
+# Constructor และตัวดำเนินการ "new"
 
-The regular `{...}` syntax allows us to create one object. But often we need to create many similar objects, like multiple users or menu items and so on.
+การใช้ `{...}` ช่วยให้เราสร้างออบเจ็กต์ได้ แต่ในกรณีที่ต้องการสร้างออบเจ็กต์หลายๆ ตัวที่มีลักษณะคล้ายกัน เช่น ผู้ใช้หลายคน, เมนูหลายรายการ ฯลฯ การใช้ `{...}` ซ้ำๆ อาจไม่ใช่วิธีที่ดี 
 
-That can be done using constructor functions and the `"new"` operator.
+ในกรณีนี้เราสามารถใช้ฟังก์ชัน constructor ร่วมกับตัวดำเนินการ `"new"` ได้
 
-## Constructor function
+## ฟังก์ชัน Constructor
 
-Constructor functions technically are regular functions. There are two conventions though:
+โดยปกติแล้ว ฟังก์ชัน constructor เป็นฟังก์ชันธรรมดา แต่มีข้อตกลงสองประการ:
 
-1. They are named with capital letter first.
-2. They should be executed only with `"new"` operator.
+1. ชื่อฟังก์ชันจะขึ้นต้นด้วยตัวพิมพ์ใหญ่เสมอ
+2. ควรเรียกใช้งานผ่านตัวดำเนินการ `"new"` เท่านั้น
 
-For instance:
+ตัวอย่างเช่น:
 
 ```js run
 function User(name) {
@@ -27,31 +27,31 @@ alert(user.name); // Jack
 alert(user.isAdmin); // false
 ```
 
-When a function is executed with `new`, it does the following steps:
+เมื่อฟังก์ชันถูกเรียกผ่าน `new` จะเกิดขั้นตอนดังนี้:
 
-1. A new empty object is created and assigned to `this`.
-2. The function body executes. Usually it modifies `this`, adds new properties to it.
-3. The value of `this` is returned.
+1. มีการสร้างออบเจ็กต์ใหม่ขึ้นมาเปล่าๆ และกำหนดให้เป็น `this`
+2. ทำงานในส่วนบอดี้ของฟังก์ชัน ซึ่งมักจะมีการปรับแต่ง `this` และเพิ่มคุณสมบัติใหม่ๆ เข้าไป
+3. คืนค่า `this`
 
-In other words, `new User(...)` does something like:
+กล่าวอีกนัยหนึ่ง `new User(...)` สามารถเทียบได้กับ:
 
 ```js
 function User(name) {
 *!*
-  // this = {};  (implicitly)
+  // this = {};  (โดยนัยยะ)
 */!*
 
-  // add properties to this
+  // เพิ่มคุณสมบัติลงใน this
   this.name = name;
   this.isAdmin = false;
 
 *!*
-  // return this;  (implicitly)
+  // return this;  (โดยนัยยะ)
 */!*
 }
 ```
 
-So `let user = new User("Jack")` gives the same result as:
+ดังนั้น `let user = new User("Jack")` จะให้ผลลัพธ์เหมือนกับ:
 
 ```js
 let user = {
@@ -60,135 +60,139 @@ let user = {
 };
 ```
 
-Now if we want to create other users, we can call `new User("Ann")`, `new User("Alice")` and so on. Much shorter than using literals every time, and also easy to read.
+ซึ่งหากเราต้องการสร้าง user อื่นๆ เพิ่มเติม ก็เรียกใช้ `new User("Ann")`, `new User("Alice")` เป็นต้น โดยจะสั้นกว่าและอ่านง่ายกว่าการใช้ออบเจ็กต์ลิเทอรัลซ้ำๆ มากๆ
 
-That's the main purpose of constructors -- to implement reusable object creation code.
+จึงสรุปได้ว่า จุดประสงค์หลักของ constructor คือ การนำโค้ดที่ใช้ในการสร้างออบเจ็กต์มาใช้ซ้ำได้ง่ายขึ้น
 
-Let's note once again -- technically, any function (except arrow functions, as they don't have `this`) can be used as a constructor. It can be run with `new`, and it will execute the algorithm above. The "capital letter first" is a common agreement, to make it clear that a function is to be run with `new`.
+กลับมาเน้นย้ำอีกครั้ง -- ในแง่หลักการแล้ว ฟังก์ชันอะไรก็ตาม (ยกเว้น arrow function ที่ไม่มี `this`) สามารถนำมาเป็น constructor ได้ สามารถเรียกใช้งานผ่าน `new` และจะดำเนินการตามขั้นตอนข้างต้น การตั้งชื่อให้ขึ้นต้นด้วยตัวอักษรพิมพ์ใหญ่เป็นแค่ข้อตกลงร่วมกัน เพื่อให้ชัดเจนว่าฟังก์ชันนี้ควรเรียกใช้ผ่าน `new` เท่านั้น
 
 ````smart header="new function() { ... }"
-If we have many lines of code all about creation of a single complex object, we can wrap them in an immediately called constructor function, like this:
+กรณีที่การสร้างออบเจ็กต์ที่ซับซ้อนมีโค้ดหลายบรรทัด เราสามารถครอบมันด้วย constructor function และเรียกใช้ทันทีได้ ดังนี้:
 
 ```js
-// create a function and immediately call it with new
-let user = new function() { 
+// สร้างฟังก์ชันและทันทีเรียกใช้ผ่าน new
+let user = new function() {
   this.name = "John";
   this.isAdmin = false;
 
-  // ...other code for user creation
-  // maybe complex logic and statements
-  // local variables etc
+  // ...โค้ดอื่นๆ ในการสร้าง user
+  // อาจมีตรรกะและคำสั่งที่ซับซ้อน
+  // มีตัวแปรภายใน ฯลฯ
 };
 ```
 
-This constructor can't be called again, because it is not saved anywhere, just created and called. So this trick aims to encapsulate the code that constructs the single object, without future reuse.
+Constructor ดังกล่าวไม่สามารถเรียกใช้ซ้ำได้อีก เนื่องจากไม่ได้ถูกเก็บไว้ที่ใดเลย ถูกสร้างและเรียกใช้ในทันที เทคนิคนี้ใช้เพื่อห่อหุ้มกระบวนการสร้างออบเจ็กต์ที่ซับซ้อนไว้ด้วยกัน และไม่มีแผนจะนำมาใช้ซ้ำอีกในอนาคต
 ````
 
-## Constructor mode test: new.target
+## ทดสอบโหมด Constructor: new.target
 
-```smart header="Advanced stuff"
-The syntax from this section is rarely used, skip it unless you want to know everything.
+```smart header="แนวคิดขั้นสูง"
+ไวยากรณ์ในส่วนนี้ไม่ค่อยถูกใช้ สามารถข้ามไปได้หากไม่สนใจเนื้อหาโดยลึก
 ```
 
-Inside a function, we can check whether it was called with `new` or without it, using a special `new.target` property.
+ในฟังก์ชัน เราสามารถตรวจสอบได้ว่า มันถูกเรียกผ่าน `new` หรือไม่ โดยใช้ `new.target`
 
-It is undefined for regular calls and equals the function if called with `new`:
+ในกรณีการเรียกปกติ `new.target` จะเป็น `undefined` แต่หากเรียกผ่าน `new` ค่าของมันจะเป็นฟังก์ชันนั้นเอง:
 
 ```js run
 function User() {
   alert(new.target);
 }
 
-// without "new":
+// ไม่ใช้ new
 *!*
 User(); // undefined
 */!*
 
-// with "new":
+// ใช้ new
 *!*
-new User(); // function User { ... }
+new User(); // ฟังก์ชัน User {...}
 */!*
 ```
 
-That can be used inside the function to know whether it was called with `new`, "in constructor mode", or without it, "in regular mode".
+สิ่งนี้สามารถนำไปใช้ในการตรวจสอบภายในฟังก์ชันว่า ถูกเรียกในโหมด "constructor" ด้วย `new` หรือโหมด "ปกติ"
 
-We can also make both `new` and regular calls to do the same, like this:
+เราสามารถทำให้การเรียกแบบใช้และไม่ใช้ `new` ทำงานเหมือนกันได้ เช่น:
 
 ```js run
 function User(name) {
-  if (!new.target) { // if you run me without new
-    return new User(name); // ...I will add new for you
+  if (!new.target) { // ถ้าคุณเรียกใช้ฉันโดยไม่มี new
+    return new User(name); // ...ฉันจะใส่ new ให้เอง
   }
 
   this.name = name;
 }
 
-let john = User("John"); // redirects call to new User
+let john = User("John"); // เปลี่ยนทางไปเรียกใช้ new User
 alert(john.name); // John
 ```
 
-This approach is sometimes used in libraries to make the syntax more flexible. So that people may call the function with or without `new`, and it still works.
+ซึ่งพบเห็นได้บ้างในไลบรารีต่างๆ ที่ต้องการให้ไวยากรณ์ยืดหยุ่น จะเรียกด้วย `new` หรือไม่ก็ได้ ฟังก์ชันจะยังทำงานได้ปกติ
 
-Probably not a good thing to use everywhere though, because omitting `new` makes it a bit less obvious what's going on. With `new` we all know that the new object is being created.
+แต่ไม่ควรนำไปใช้กับทุกฟังก์ชัน เพราะการไม่ใส่ `new` อาจทำให้สิ่งที่เกิดขึ้นคลุมเครือไปหน่อย เมื่อเราใช้ `new` ทุกคนจะเข้าใจว่าเรากำลังสร้างออบเจ็กต์ใหม่
 
-## Return from constructors
+## การ return จาก constructor
 
-Usually, constructors do not have a `return` statement. Their task is to write all necessary stuff into `this`, and it automatically becomes the result.
+ปกติแล้ว constructor จะไม่มีการใช้คำสั่ง `return` หน้าที่ของมันคือการเขียนข้อมูลที่จำเป็นทั้งหมดลงใน `this` ซึ่ง `this` จะกลายเป็นผลลัพธ์โดยอัตโนมัติอยู่แล้ว
 
-But if there is a `return` statement, then the rule is simple:
+แต่ถ้าหากมีการใช้คำสั่ง `return` ก็จะมีกฎง่ายๆ ดังนี้:
 
-- If `return` is called with an object, then the object is returned instead of `this`.
-- If `return` is called with a primitive, it's ignored.
+- หาก `return` ด้วยออบเจ็กต์ ออบเจ็กต์นั้นจะถูกคืนค่ากลับมาแทน `this`
+- หาก `return` ด้วยค่าพื้นฐาน (primitive) จะเกิดการเพิกเฉยต่อค่านั้น
 
-In other words, `return` with an object returns that object, in all other cases `this` is returned.
+หรือกล่าวอีกนัยหนึ่งคือ `return` ด้วยออบเจ็กต์จะคืนออบเจ็กต์นั้นกลับมา แต่ในกรณีอื่นทั้งหมด `this` จะถูกคืนกลับมาเป็นผลลัพธ์
 
-For instance, here `return` overrides `this` by returning an object:
+ยกตัวอย่างเช่น ในที่นี่ `return` จะเขียนทับ `this` โดยคืนออบเจ็กต์ออกมา:
 
 ```js run
 function BigUser() {
 
   this.name = "John";
 
-  return { name: "Godzilla" };  // <-- returns this object
+  return { name: "Godzilla" };  // <-- คืนออบเจ็กต์นี้
 }
 
-alert( new BigUser().name );  // Godzilla, got that object
+alert( new BigUser().name );  // Godzilla ออบเจ็กต์ถูกคืนกลับมา
 ```
 
-And here's an example with an empty `return` (or we could place a primitive after it, doesn't matter):
+ส่วนในนี้คือตัวอย่างการ `return` เปล่าๆ (หรืออาจใส่ค่าพื้นฐานหลังจากนั้นก็ได้ ไม่สำคัญ):
 
 ```js run
 function SmallUser() {
 
   this.name = "John";
 
-  return; // <-- returns this
+  return; // <-- คืนค่า this
 }
 
 alert( new SmallUser().name );  // John
 ```
 
-Usually constructors don't have a `return` statement. Here we mention the special behavior with returning objects mainly for the sake of completeness.
+โดยทั่วไปแล้ว constructor มักจะไม่มีคำสั่ง `return` ในที่นี้เราพูดถึงพฤติกรรมพิเศษ ในการคืนค่าเป็นออบเจ็กต์ เพื่อให้ข้อมูลครบถ้วนสมบูรณ์
 
+<<<<<<< HEAD
+````smart header="ละวงเล็บ"
+ที่จริงแล้ว เราสามารถละวงเล็บต่อท้าย `new` ได้ ถ้าไม่มีอาร์กิวเมนต์:
+=======
 ````smart header="Omitting parentheses"
 By the way, we can omit parentheses after `new`:
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
 ```js
-let user = new User; // <-- no parentheses
-// same as
-let user = new User();
+let user = new User; // <-- ไม่มีวงเล็บ
+// เหมือนกับ let user = new User();
 ```
 
-Omitting parentheses here is not considered a "good style", but the syntax is permitted by specification.
+การไม่ใส่วงเล็บแบบนี้ไม่ใช่ "แบบแผนที่ดี" แต่ไวยากรณ์ของภาษาก็อนุญาตให้ทำได้
 ````
 
-## Methods in constructor
+## เมท็อดใน constructor
 
-Using constructor functions to create objects gives a great deal of flexibility. The constructor function may have parameters that define how to construct the object, and what to put in it.
+ฟังก์ชัน constructor ช่วยให้การสร้างออบเจ็กต์มีความยืดหยุ่นมากขึ้น เพราะเราสามารถกำหนดพารามิเตอร์ที่ระบุว่าจะสร้างออบเจ็กต์อย่างไร และจะใส่อะไรลงไปได้
 
-Of course, we can add to `this` not only properties, but methods as well.
+แน่นอนว่าเราสามารถเพิ่มเติมไม่เพียงแต่ property เท่านั้น แต่ยังรวมถึงเมท็อดต่างๆ ให้กับ `this` ด้วย
 
-For instance, `new User(name)` below creates an object with the given `name` and the method `sayHi`:
+ยกตัวอย่างเช่น `new User(name)` ด้านล่างนี้จะสร้างออบเจ็กต์ที่มี `name` และเมท็อด `sayHi`:
 
 ```js run
 function User(name) {
@@ -213,19 +217,19 @@ john = {
 */
 ```
 
-To create complex objects, there's a more advanced syntax, [classes](info:classes), that we'll cover later.
+ในการสร้างออบเจ็กต์ที่ซับซ้อนกว่านี้ จะมีไวยากรณ์ขั้นสูงอย่างเช่น [classes](info:classes) ซึ่งเราจะได้เรียนรู้ในภายหลัง
 
-## Summary
+## สรุป
 
-- Constructor functions or, briefly, constructors, are regular functions, but there's a common agreement to name them with capital letter first.
-- Constructor functions should only be called using `new`. Such a call implies a creation of empty `this` at the start and returning the populated one at the end.
+- ฟังก์ชัน constructor หรือเรียกสั้นๆ ว่า constructor ก็คือฟังก์ชันปกติ แต่มีข้อตกลงว่าจะตั้งชื่อโดยขึ้นต้นด้วยตัวพิมพ์ใหญ่
+- ฟังก์ชัน constructor ควรเรียกใช้ผ่านตัวดำเนินการ `new` เท่านั้น การเรียกแบบนั้นจะหมายความว่า จะมีการสร้าง `this` เปล่าๆ ขึ้นมาตอนเริ่ม และคืน `this` ที่มีข้อมูลกลับไปตอนจบ
 
-We can use constructor functions to make multiple similar objects.
+เราสามารถใช้ฟังก์ชัน constructor ในการสร้างออบเจ็กต์ที่มีลักษณะคล้ายๆ กันหลายๆ ตัว
 
-JavaScript provides constructor functions for many built-in language objects: like `Date` for dates, `Set` for sets and others that we plan to study.
+JavaScript มี constructor สำหรับออบเจ็กต์ในตัวของภาษา เช่น `Date` สำหรับวันที่ `Set` สำหรับเซ็ต และอื่นๆ อีกมากมายที่เราจะได้เรียนรู้ในบทต่อๆ ไป
 
-```smart header="Objects, we'll be back!"
-In this chapter we only cover the basics about objects and constructors. They are essential for learning more about data types and functions in the next chapters.
+````smart header="ออบเจ็กต์ เรามีอะไรต้องคุยอีกมาก!"
+ในบทนี้เราได้เรียนรู้เพียงแค่พื้นฐานเกี่ยวกับออบเจ็กต์และ constructor ซึ่งมีความจำเป็นในการไปต่อเพื่อทำความเข้าใจเกี่ยวกับชนิดข้อมูลและฟังก์ชันต่างๆ ให้ลึกซึ้งยิ่งขึ้น
 
-After we learn that, we return to objects and cover them in-depth in the chapters <info:prototypes> and <info:classes>.
-```
+หลังจากนั้น เมื่อเราเคยชินกับพื้นฐานเหล่านี้แล้ว เราจะย้อนกลับมาศึกษาออบเจ็กต์อีกครั้งในบทเรียน <info:prototypes> และ <info:classes> ซึ่งจะกล่าวถึงรายละเอียดที่น่าสนใจมากขึ้น
+````
\ No newline at end of file
diff --git a/1-js/04-object-basics/07-optional-chaining/article.md b/1-js/04-object-basics/07-optional-chaining/article.md
index 4c6029423..40b5025b5 100644
--- a/1-js/04-object-basics/07-optional-chaining/article.md
+++ b/1-js/04-object-basics/07-optional-chaining/article.md
@@ -1,42 +1,41 @@
-
-# Optional chaining '?.'
+# Optional Chaining '?.'
 
 [recent browser="new"]
 
-The optional chaining `?.` is a safe way to access nested object properties, even if an intermediate property doesn't exist.
-
-## The "non-existing property" problem
-
-If you've just started to read the tutorial and learn JavaScript, maybe the problem hasn't touched you yet, but it's quite common.
+Optional chaining หรือ `?.` เป็นวิธีที่ปลอดภัยในการเข้าถึงคุณสมบัติแบบซ้อนของออบเจ็กต์ แม้ว่าคุณสมบัติระหว่างทางจะไม่มีอยู่ก็ตาม
 
-As an example, let's say we have `user` objects that hold the information about our users.
+## ปัญหาเมื่อเข้าถึงคุณสมบัติที่ไม่มีอยู่
 
-Most of our users have addresses in `user.address` property, with the street `user.address.street`, but some did not provide them.
+ยกตัวอย่างเช่น สมมติเรามีออบเจ็กต์ `user` ที่เก็บข้อมูลผู้ใช้ โดยผู้ใช้ส่วนใหญ่มีที่อยู่อยู่ใน `user.address` ซึ่งภายในมี `user.address.street` เก็บชื่อถนน แต่ผู้ใช้บางคนอาจไม่ได้ระบุที่อยู่ไว้
 
-In such case, when we attempt to get `user.address.street`, and the user happens to be without an address, we get an error:
+เมื่อเราพยายามเข้าถึง `user.address.street` โดยที่ผู้ใช้ไม่มีที่อยู่ จะเกิดข้อผิดพลาดแบบนี้:
 
 ```js run
-let user = {}; // a user without "address" property
+let user = {}; // ผู้ใช้ที่ไม่มีคุณสมบัติ "address"
 
-alert(user.address.street); // Error!
+alert(user.address.street); // เกิด Error!
 ```
 
-That's the expected result. JavaScript works like this. As `user.address` is `undefined`, an attempt to get `user.address.street` fails with an error.
+นั่นคือผลลัพธ์ปกติของ JavaScript เพราะ `user.address` เป็น `undefined` การเข้าถึง `user.address.street` จึงล้มเหลว
 
-In many practical cases we'd prefer to get `undefined` instead of an error here (meaning "no street").
+ในความเป็นจริง หลายครั้งเราอาจต้องการให้คืนค่า `undefined` กลับมาแทนข้อผิดพลาด (เช่น หมายถึง "ไม่มีถนน") 
 
-...and another example. In Web development, we can get an object that corresponds to a web page element using a special method call, such as `document.querySelector('.elem')`, and it returns `null` when there's no such element.
+อีกตัวอย่างคือเมื่อเรียกใช้ `document.querySelector('.elem')` เพื่อหาองค์ประกอบใน HTML ถ้าไม่เจอจะคืนค่า `null` กลับมา แล้วเมื่อเราพยายามเข้าถึง property ของมัน อย่าง `.innerHTML` ก็จะเกิด error เช่นกัน:
 
 ```js run
-// document.querySelector('.elem') is null if there's no element
-let html = document.querySelector('.elem').innerHTML; // error if it's null
+// document.querySelector('.elem') จะเป็น null ถ้าไม่เจอ element นั้น
+let html = document.querySelector('.elem').innerHTML; // เกิด Error ถ้าเป็น null 
 ```
 
+<<<<<<< HEAD
+อีกครั้ง ในหลายกรณีที่ไม่เจอ element ก็ถือเป็นเรื่องปกติ เราอาจต้องการให้คืนค่า `html` เป็น `null` แทนที่จะเกิด error
+=======
 Once again, if the element doesn't exist, we'll get an error accessing `.innerHTML` property of `null`. And in some cases, when the absence of the element is normal, we'd like to avoid the error and just accept `html = null` as the result.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-How can we do this?
+## วิธีแก้ไขเดิมก่อนมี Optional Chaining
 
-The obvious solution would be to check the value using `if` or the conditional operator `?`, before accessing its property, like this:
+ก่อนที่จะมี optional chaining `?.` เราต้องเช็คค่าด้วย `if` หรือ `&&` ก่อนที่จะเข้าถึง property ต่อๆ ไป เช่น:
 
 ```js
 let user = {};
@@ -44,6 +43,15 @@ let user = {};
 alert(user.address ? user.address.street : undefined);
 ```
 
+<<<<<<< HEAD
+หรือในกรณี `document.querySelector`:
+
+```js run
+let html = document.querySelector('.elem') ? document.querySelector('.elem').innerHTML : null;
+```
+
+ใช้ได้ แต่ดูยุ่งเหยิงและต้องเช็คซ้ำๆ โดยเฉพาะกับ property ที่ซ้อนกันหลายชั้น เช่น `user.address.street.name`
+=======
 It works, there's no error... But it's quite inelegant. As you can see, the `"user.address"` appears twice in the code.
 
 Here's how the same would look for `document.querySelector`:
@@ -57,49 +65,61 @@ We can see that the element search `document.querySelector('.elem')` is actually
 For more deeply nested properties, it becomes even uglier, as more repetitions are required.
 
 E.g. let's get `user.address.street.name` in a similar fashion.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
 ```js
-let user = {}; // user has no address
+let user = {}; // ผู้ใช้ไม่มีที่อยู่
 
 alert(user.address ? user.address.street ? user.address.street.name : null : null);
 ```
 
+<<<<<<< HEAD
+อีกวิธีที่ดูดีกว่าเล็กน้อยคือใช้ `&&`:
+=======
 That's just awful, one may even have problems understanding such code.
 
 There's a little better way to write it, using the `&&` operator:
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
 ```js run
-let user = {}; // user has no address
+let user = {}; // ผู้ใช้ไม่มีที่อยู่
 
-alert( user.address && user.address.street && user.address.street.name ); // undefined (no error)
+alert( user.address && user.address.street && user.address.street.name ); // undefined (ไม่เกิด error)
 ```
 
-AND'ing the whole path to the property ensures that all components exist (if not, the evaluation stops), but also isn't ideal.
+แต่ก็ยังต้องเช็ค property ซ้ำๆ อยู่ดี
 
-As you can see, property names are still duplicated in the code. E.g. in the code above, `user.address` appears three times.
+นี่จึงเป็นที่มาของ optional chaining `?.` เพื่อแก้ปัญหานี้ครั้งเดียวจบ!
 
-That's why the optional chaining `?.` was added to the language. To solve this problem once and for all!
+## Optional Chaining กับ Property: `?.`
 
-## Optional chaining
+Optional chaining `?.` จะหยุดการทำงานทันที ถ้าค่าทางซ้ายของ `?.` เป็น `undefined` หรือ `null` และจะคืนค่า `undefined` กลับมา
 
-The optional chaining `?.` stops the evaluation if the value before `?.` is `undefined` or `null` and returns `undefined`.
+**ในบทความนี้ เพื่อความกระชับ เราจะใช้คำว่า "มีอยู่" หมายถึงไม่เป็น `null` หรือ `undefined`**
 
-**Further in this article, for brevity, we'll be saying that something "exists" if it's not `null` and not `undefined`.**
+กล่าวคือ `value?.prop`:
+- จะทำงานเหมือน `value.prop` ถ้า `value` มีอยู่
+- ถ้า `value` เป็น `undefined/null` จะคืนค่า `undefined`
 
-In other words, `value?.prop`:
-- works as `value.prop`, if `value` exists,
-- otherwise (when `value` is `undefined/null`) it returns `undefined`.
-
-Here's the safe way to access `user.address.street` using `?.`:
+ตัวอย่างการใช้ `?.` เพื่อเข้าถึง `user.address.street`:
 
 ```js run
-let user = {}; // user has no address
+let user = {}; // ผู้ใช้ไม่มีที่อยู่
 
-alert( user?.address?.street ); // undefined (no error)
+alert( user?.address?.street ); // undefined (ไม่เกิด error)
 ```
 
-The code is short and clean, there's no duplication at all.
+โค้ดสั้นลง และไม่มีการเช็คซ้ำๆ
+
+<<<<<<< HEAD
+กับตัวอย่าง `document.querySelector`:
 
+```js run
+let html = document.querySelector('.elem')?.innerHTML; // จะเป็น undefined ถ้าไม่เจอ element
+```
+
+แม้แต่ในกรณีที่ไม่มีตัวแปร `user` เลย ก็ยังใช้ `?.` ได้อย่างปลอดภัย:
+=======
 Here's an example with `document.querySelector`:
 
 ```js run
@@ -107,6 +127,7 @@ let html = document.querySelector('.elem')?.innerHTML; // will be undefined, if
 ```
 
 Reading the address with `user?.address` works even if `user` object doesn't exist:
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
 ```js run
 let user = null;
@@ -115,66 +136,88 @@ alert( user?.address ); // undefined
 alert( user?.address.street ); // undefined
 ```
 
-Please note: the `?.` syntax makes optional the value before it, but not any further.
+โปรดสังเกตว่า `?.` ทำให้ส่วนทางซ้ายมันเป็น optional ได้ แต่ไม่ใช่ส่วนถัดไป
 
-E.g. in `user?.address.street.name` the `?.` allows `user` to safely be `null/undefined` (and returns `undefined` in that case), but that's only for `user`. Further properties are accessed in a regular way. If we want some of them to be optional, then we'll need to replace more `.` with `?.`.
+ใน `user?.address.street.name` ตัว `?.` อนุญาตให้ `user` เป็น `null/undefined` แต่ส่วนที่เหลือ (`address`, `street`, `name`) จะถูกเข้าถึงแบบปกติ ถ้าเราอยากให้ส่วนอื่นเป็น optional ด้วย ต้องแทน `.` ด้วย `?.` เพิ่มเติม
 
-```warn header="Don't overuse the optional chaining"
-We should use `?.` only where it's ok that something doesn't exist.
+```warn header="ใช้ ?. อย่างพอดี"
+เราควรใช้ `?.` เฉพาะในกรณีที่ยอมรับได้หากบางอย่างไม่มีอยู่
 
+<<<<<<< HEAD
+เช่น ถ้าตามตรรกะของโปรแกรมแล้ว `user` ต้องมีอยู่ แต่ `address` เป็น optional ได้ เราควรเขียน `user.address?.street` แต่ไม่ใช่ `user?.address?.street`
+
+มิฉะนั้น ถ้าใช้ `?.` มากเกินไป เวลามีข้อผิดพลาดขึ้นมาจริงๆ มันอาจถูกซ่อนเงียบไว้ ทำให้ยากต่อการดีบั๊กในภายหลัง
+=======
 For example, if according to our code logic `user` object must exist, but `address` is optional, then we should write `user.address?.street`, but not `user?.address?.street`.
 
 Then, if `user` happens to be undefined, we'll see a programming error about it and fix it. Otherwise, if we overuse `?.`, coding errors can be silenced where not appropriate, and become more difficult to debug.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 ```
 
-````warn header="The variable before `?.` must be declared"
-If there's no variable `user` at all, then `user?.anything` triggers an error:
+````warn header="ตัวแปรทางซ้ายของ ?. ต้องถูกประกาศก่อน"
+ถ้าไม่มีตัวแปรนั้นเลย เช่น `user?.anything` จะเกิด error:
 
 ```js run
 // ReferenceError: user is not defined
 user?.address;
 ```
-The variable must be declared (e.g. `let/const/var user` or as a function parameter). The optional chaining works only for declared variables.
+ตัวแปรจะต้องถูกประกาศก่อน จากนั้น optional chaining จึงจะใช้งานได้
 ````
 
-## Short-circuiting
+## Short-Circuiting
 
+<<<<<<< HEAD
+`?.` จะหยุดการทำงานทันทีถ้าส่วนซ้ายไม่มีอยู่ (เป็น `null/undefined`) ดังนั้นถ้ามีการเรียก function หรือคำสั่งอื่นๆ ทางขวาของ `?.` จะไม่ถูกรันเลย
+=======
 As it was said before, the `?.` immediately stops ("short-circuits") the evaluation if the left part doesn't exist.
 
 So, if there are any further function calls or operations to the right of `?.`, they won't be made.
 
 For instance:
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
 ```js run
 let user = null;
 let x = 0;
 
+<<<<<<< HEAD
+user?.sayHi(x++); // ไม่มี "user" จึงไม่ถึงการเรียก sayHi และ x++
+=======
 user?.sayHi(x++); // no "user", so the execution doesn't reach sayHi call and x++
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-alert(x); // 0, value not incremented
+alert(x); // 0, ค่า x ไม่ถูกเพิ่ม
 ```
 
-## Other variants: ?.(), ?.[]
-
-The optional chaining `?.` is not an operator, but a special syntax construct, that also works with functions and square brackets.
+## Optional Chaining กับ Function: `?.()`  
 
-For example, `?.()` is used to call a function that may not exist.
+`?.()` ใช้เพื่อเรียก function ที่อาจจะไม่มีอยู่
 
-In the code below, some of our users have `admin` method, and some don't:
+ตัวอย่างเช่นในโค้ดด้านล่าง ผู้ใช้บางคนมี method `admin` บางคนไม่มี:
 
 ```js run
 let userAdmin = {
   admin() {
-    alert("I am admin");
+    alert("ฉันคือ admin");
   }
 };
 
 let userGuest = {};
 
 *!*
-userAdmin.admin?.(); // I am admin
+userAdmin.admin?.(); // ฉันคือ admin
 */!*
 
+<<<<<<< HEAD
+*!*  
+userGuest.admin?.(); // ไม่มีอะไรเกิดขึ้น (ไม่มี method admin)
+*/!*
+```
+
+สังเกตว่าเราใช้ `.` เพื่อเข้าถึง `admin` ก่อน เพราะเรามั่นใจว่าตัวแปร `user` มีอยู่แน่ๆ จากนั้นจึงตามด้วย `?.()`
+
+## Optional Chaining กับ [] : `?.[]`
+=======
 *!*
 userGuest.admin?.(); // nothing happens (no such method)
 */!*
@@ -183,8 +226,9 @@ userGuest.admin?.(); // nothing happens (no such method)
 Here, in both lines we first use the dot (`userAdmin.admin`) to get `admin` property, because we assume that the `user` object exists, so it's safe read from it.
 
 Then `?.()` checks the left part: if the `admin` function exists, then it runs (that's so for `userAdmin`). Otherwise (for `userGuest`) the evaluation stops without errors.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-The `?.[]` syntax also works, if we'd like to use brackets `[]` to access properties instead of dot `.`. Similar to previous cases, it allows to safely read a property from an object that may not exist.
+ถ้าเราต้องการใช้ `[]` เพื่อเข้าถึง property แทนที่จะใช้ `.` ก็ใช้ `?.[]` ได้
 
 ```js run
 let key = "firstName";
@@ -199,35 +243,48 @@ alert( user1?.[key] ); // John
 alert( user2?.[key] ); // undefined
 ```
 
-Also we can use `?.` with `delete`:
+และสามารถใช้กับ `delete` ได้ด้วย:
 
 ```js run
-delete user?.name; // delete user.name if user exists
+delete user?.name; // ลบ user.name ถ้า user มีอยู่
 ```
 
+<<<<<<< HEAD
+````warn header="ใช้ ?. ได้แค่อ่านและลบ ไม่ใช่การเขียน"
+Optional chaining `?.` ไม่ใช้ในด้านซ้ายของการกำหนดค่า
+=======
 ````warn header="We can use `?.` for safe reading and deleting, but not writing"
 The optional chaining `?.` has no use on the left side of an assignment.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-For example:
 ```js run
 let user = null;
 
+<<<<<<< HEAD
+user?.name = "John"; // Error เพราะจะประเมินเป็น undefined = "John"
+```
+=======
 user?.name = "John"; // Error, doesn't work
 // because it evaluates to: undefined = "John"
 ```
 
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 ````
 
-## Summary
+## สรุป
 
-The optional chaining `?.` syntax has three forms:
+ไวยากรณ์ Optional chaining `?.` มี 3 รูปแบบ:
 
-1. `obj?.prop` -- returns `obj.prop` if `obj` exists, otherwise `undefined`.
-2. `obj?.[prop]` -- returns `obj[prop]` if `obj` exists, otherwise `undefined`.
-3. `obj.method?.()` -- calls `obj.method()` if `obj.method` exists, otherwise returns `undefined`.
+1. `obj?.prop` -- คืนค่า `obj.prop` ถ้า `obj` มีอยู่ ไม่งั้นคืน `undefined`
+2. `obj?.[prop]` -- คืนค่า `obj[prop]` ถ้า `obj` มีอยู่ ไม่งั้นคืน `undefined` 
+3. `obj.method?.()` -- เรียก `obj.method()` ถ้า `obj.method` มีอยู่ ไม่งั้นคืน `undefined`
 
-As we can see, all of them are straightforward and simple to use. The `?.` checks the left part for `null/undefined` and allows the evaluation to proceed if it's not so.
+`?.` จะเช็ค `null/undefined` ทางด้านซ้าย และอนุญาตให้เข้าถึงต่อไปได้ถ้าไม่ใช่
 
-A chain of `?.` allows to safely access nested properties.
+การเรียงต่อกันหลายตัวของ `?.` ทำให้เข้าถึง property ที่ซ้อนกันได้อย่างปลอดภัย
 
+<<<<<<< HEAD
+อย่างไรก็ตาม ควรใช้ `?.` อย่างระมัดระวัง เฉพาะในกรณีที่ยอมรับได้หากบางอย่างไม่มีอยู่จริง เพื่อไม่ให้ข้อผิดพลาดที่ควรเกิดถูกซ่อนเงียบไป
+=======
 Still, we should apply `?.` carefully, only where it's acceptable, according to our code logic, that the left part doesn't exist. So that it won't hide programming errors from us, if they occur.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
diff --git a/1-js/04-object-basics/08-symbol/article.md b/1-js/04-object-basics/08-symbol/article.md
index 10a98af0a..e499521f0 100644
--- a/1-js/04-object-basics/08-symbol/article.md
+++ b/1-js/04-object-basics/08-symbol/article.md
@@ -1,6 +1,13 @@
+# ชนิดข้อมูล Symbol
 
-# Symbol type
+ในภาษา JavaScript นั้น มีเพียงชนิดข้อมูลพื้นฐานสองประเภทเท่านั้นที่สามารถใช้เป็น key ของ property ในออบเจ็กต์ได้ นั่นคือ:
 
+<<<<<<< HEAD
+- string และ
+- symbol 
+
+สำหรับชนิดข้อมูลอื่นๆ เช่น number เมื่อใช้เป็น key มันจะถูกแปลงเป็น string โดยอัตโนมัติ ซึ่งหมายความว่า `obj[1]` จะเท่ากับ `obj["1"]` และ `obj[true]` จะเท่ากับ `obj["true"]`
+=======
 By specification, only two primitive types may serve as object property keys:
 
 - string type, or
@@ -11,27 +18,40 @@ Otherwise, if one uses another type, such as number, it's autoconverted to strin
 Until now we've been using only strings.
 
 Now let's explore symbols, see what they can do for us.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
+
+ที่ผ่านมา เราใช้แต่ string เป็น key มาโดยตลอด 
 
-## Symbols
+คราวนี้ลองมาทำความรู้จักกับ symbol และประโยชน์ของมันกันดูบ้าง
 
-A "symbol" represents a unique identifier.
+## Symbol คืออะไร
 
-A value of this type can be created using `Symbol()`:
+"Symbol" เป็นตัวแทนของ unique identifier หรือตัวระบุที่ไม่ซ้ำกัน
+
+เราสามารถสร้างค่า symbol ได้โดยใช้ฟังก์ชัน `Symbol()` ดังนี้:
 
 ```js
 let id = Symbol();
 ```
 
+<<<<<<< HEAD
+เวลาสร้าง symbol เรายังสามารถให้คำอธิบาย (description) หรือชื่อให้กับมันได้ด้วย ซึ่งส่วนใหญ่จะมีประโยชน์ในการดีบั๊ก:
+=======
 Upon creation, we can give symbols a description (also called a symbol name), mostly useful for debugging purposes:
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
 ```js
-// id is a symbol with the description "id"
+// id คือ symbol ที่มีคำอธิบายว่า "id"
 let id = Symbol("id");
 ```
 
+<<<<<<< HEAD
+Symbol รับประกันว่าจะมีค่าไม่ซ้ำกันเสมอ ถึงแม้จะสร้าง symbol หลายตัวด้วยคำอธิบายเดียวกัน ค่าของมันก็จะไม่เหมือนกัน เพราะคำอธิบายเป็นเพียงป้ายชื่อ (label) ที่ไม่ได้กำหนดค่าจริงของ symbol แต่อย่างใด 
+=======
 Symbols are guaranteed to be unique. Even if we create many symbols with exactly the same description, they are different values. The description is just a label that doesn't affect anything.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-For instance, here are two symbols with the same description -- they are not equal:
+ยกตัวอย่างเช่น symbol สองตัวด้านล่างนี้ แม้จะมีคำอธิบายเหมือนกัน แต่ค่าจะไม่เท่ากัน:
 
 ```js run
 let id1 = Symbol("id");
@@ -42,34 +62,50 @@ alert(id1 == id2); // false
 */!*
 ```
 
-If you are familiar with Ruby or another language that also has some sort of "symbols" -- please don't be misguided. JavaScript symbols are different.
+ถ้าคุณคุ้นเคยกับ symbol ในภาษา Ruby หรือภาษาอื่นที่มีแนวคิดคล้ายๆ กัน อย่าสับสน เพราะ symbol ใน JavaScript นั้นแตกต่างออกไป
 
+<<<<<<< HEAD
+โดยสรุปคือ symbol คือค่าพื้นฐานที่ unique ซึ่งอาจมี description กำกับไว้ก็ได้ มาดูกันว่าเราจะประยุกต์ใช้มันได้อย่างไรบ้าง
+=======
 So, to summarize, a symbol is a "primitive unique value" with an optional description. Let's see where we can use them.
 
 ````warn header="Symbols don't auto-convert to a string"
 Most values in JavaScript support implicit conversion to a string. For instance, we can `alert` almost any value, and it will work. Symbols are special. They don't auto-convert.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
+
+````warn header="Symbol ไม่ถูกแปลงเป็น string โดยอัตโนมัติ"
+ค่าส่วนใหญ่ใน JavaScript รองรับการถูกแปลงเป็น string โดยอัตโนมัติ เช่น เราสามารถ `alert(value)` ค่าอะไรก็ได้ออกมา และมันจะทำงาน
 
-For instance, this `alert` will show an error:
+แต่ symbol นั้นพิเศษกว่า มันจะไม่ยอมถูกแปลงเป็น string โดยอัตโนมัติ เช่นถ้าเรา alert symbol ตรงๆ แบบนี้:
 
 ```js run
 let id = Symbol("id");
 *!*
-alert(id); // TypeError: Cannot convert a Symbol value to a string
+alert(id); // TypeError: ไม่สามารถแปลง Symbol เป็น string ได้
 */!*
 ```
 
-That's a "language guard" against messing up, because strings and symbols are fundamentally different and should not accidentally convert one into another.
+จะเกิด error ขึ้น เพราะภาษาต้องการป้องกันไม่ให้เราแปลง string และ symbol ให้กันและกันโดยไม่ตั้งใจ เนื่องจากมันเป็นคนละประเภทกันโดยสิ้นเชิง
 
+ถ้าเราต้องการจะแสดง symbol จริงๆ เราต้องเรียกเมท็อด `.toString()` อย่างชัดเจน แบบนี้:
+
+<<<<<<< HEAD
+=======
 If we really want to show a symbol, we need to explicitly call `.toString()` on it, like here:
 
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 ```js run
 let id = Symbol("id");
 *!*
-alert(id.toString()); // Symbol(id), now it works
+alert(id.toString()); // Symbol(id) ตอนนี้โอเคแล้ว
 */!*
 ```
 
+<<<<<<< HEAD
+หรือถ้าเราอยากได้แค่ description ของ symbol ก็ใช้ `.description` ได้:
+=======
 Or get `symbol.description` property to show the description only:
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
 ```js run
 let id = Symbol("id");
@@ -77,20 +113,21 @@ let id = Symbol("id");
 alert(id.description); // id
 */!*
 ```
-
 ````
 
-## "Hidden" properties
+## Property ที่ "ซ่อนอยู่"
 
+<<<<<<< HEAD
+Symbol ช่วยให้เราสร้าง "hidden" property ใส่ในออบเจ็กต์ได้ โดยที่โค้ดส่วนอื่นๆ จะไม่สามารถเข้าถึงหรือเขียนทับโดยไม่ได้ตั้งใจ
+=======
 
 Symbols allow us to create "hidden" properties of an object, that no other part of code can accidentally access or overwrite.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-For instance, if we're working with `user` objects, that belong to a third-party code. We'd like to add identifiers to them.
-
-Let's use a symbol key for it:
+สมมติว่าเรากำลังทำงานกับออบเจ็กต์ `user` ซึ่งเป็นของโค้ดจากที่อื่นมา แล้วเราอยากเพิ่ม identifier ใส่ลงไป เพื่อให้ identifier นั้นไม่ไปซ้ำกับ property ที่มีอยู่แล้ว เราเลยใช้ symbol แทนการใช้ชื่อ string ปกติ:
 
 ```js run
-let user = { // belongs to another code
+let user = { // เป็นของโค้ดจากที่อื่น
   name: "John"
 };
 
@@ -98,45 +135,49 @@ let id = Symbol("id");
 
 user[id] = 1;
 
-alert( user[id] ); // we can access the data using the symbol as the key
+alert( user[id] ); // เราสามารถเข้าถึงข้อมูลโดยใช้ symbol เป็น key
 ```
 
-What's the benefit of using `Symbol("id")` over a string `"id"`?
+ข้อดีของการใช้ `Symbol("id")` แทนที่จะเป็น `"id"` string ธรรมดาคือ มันจะไม่ไปทับ property ที่มีอยู่ก่อน
+
+<<<<<<< HEAD
+เนื่องจากออบเจ็กต์ `user` เป็นของคนอื่น การไปเพิ่ม field ใหม่ลงไปในนั้นโดยตรงอาจไม่ปลอดภัย เพราะอาจไปขัดแย้งกับลอจิกที่เขาเขียนไว้ได้ แต่ symbol จะไม่มีทางถูกเข้าถึงจากโค้ดอื่นโดยบังเอิญ เพราะโค้ดอื่นจะไม่มี symbol ตัวนี้ ดังนั้นเราจึงสามารถใช้ symbol เพิ่มอะไรลงไปในออบเจ็กต์ `user` ได้อย่างปลอดภัย  
 
+จินตนาการว่า ถ้ามีอีกสคริปต์นึงอยากใช้ identifier ของมันเองกับ `user` เพื่อวัตถุประสงค์บางอย่าง สคริปต์นั้นก็แค่สร้าง `Symbol("id")` ของมันเอง ดังนี้:
+=======
 As `user` objects belong to another codebase, it's unsafe to add fields to them, since we might affect pre-defined behavior in that other codebase. However, symbols cannot be accessed accidentally. The third-party code won't be aware of newly defined symbols, so it's safe to add symbols to the `user` objects.
 
 Also, imagine that another script wants to have its own identifier inside `user`, for its own purposes.
 
 Then that script can create its own `Symbol("id")`, like this:
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
 ```js
 // ...
 let id = Symbol("id");
 
-user[id] = "Their id value";
+user[id] = "ไอดีของสคริปต์นั้น";
 ```
 
-There will be no conflict between our and their identifiers, because symbols are always different, even if they have the same name.
+ไม่มีการชนกันเกิดขึ้นระหว่าง identifier ของเรากับของอีกสคริปต์ เพราะ symbol จะไม่ซ้ำกันเสมอ แม้จะใช้ชื่อคำอธิบายเดียวกันก็ตาม
 
-...But if we used a string `"id"` instead of a symbol for the same purpose, then there *would* be a conflict:
+...แต่ถ้าเราใช้ string `"id"` ตรงๆ แทนที่จะเป็น symbol ในกรณีนี้ มันก็*จะ* เกิดการชนกันขึ้นแน่ๆ:
 
 ```js
 let user = { name: "John" };
 
-// Our script uses "id" property
-user.id = "Our id value";
+// สคริปต์ของเราใช้ property "id" 
+user.id = "ไอดีของเรา";
 
-// ...Another script also wants "id" for its purposes...
+// ...สคริปต์อื่นก็อยากใช้ "id" เหมือนกัน
 
-user.id = "Their id value"
-// Boom! overwritten by another script!
+user.id = "ไอดีของอีกสคริปต์"
+// บูม! โดนสคริปต์อื่นเขียนทับแล้ว!
 ```
 
-### Symbols in an object literal
+### ใช้ Symbol ใน Object Literal
 
-If we want to use a symbol in an object literal `{...}`, we need square brackets around it.
-
-Like this:
+ถ้าเราต้องการใช้ symbol ใน object literal `{...}` จะต้องครอบมันไว้ด้วยวงเล็บก้ามปู (square bracket) แบบนี้:
 
 ```js
 let id = Symbol("id");
@@ -144,17 +185,18 @@ let id = Symbol("id");
 let user = {
   name: "John",
 *!*
-  [id]: 123 // not "id": 123
+  [id]: 123 // ไม่ใช่ "id": 123
 */!*
 };
 ```
-That's because we need the value from the variable `id` as the key, not the string "id".
 
-### Symbols are skipped by for..in
+เพราะเราต้องการใช้ค่าที่เก็บอยู่ในตัวแปร `id` เป็น key ไม่ใช่ string "id"
+
+### Symbol จะถูกข้ามโดย for..in
 
-Symbolic properties do not participate in `for..in` loop.
+Property ที่เป็น symbol จะไม่เข้าร่วมในการ loop `for..in` 
 
-For instance:
+ลองดูตัวอย่าง:
 
 ```js run
 let id = Symbol("id");
@@ -165,16 +207,20 @@ let user = {
 };
 
 *!*
-for (let key in user) alert(key); // name, age (no symbols)
+for (let key in user) alert(key); // name, age (ไม่มี symbol)
 */!*
 
+<<<<<<< HEAD
+// ถ้าเข้าถึงโดยตรง symbol ก็ยังใช้งานได้
+=======
 // the direct access by the symbol works
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 alert( "Direct: " + user[id] ); // Direct: 123
 ```
 
-[Object.keys(user)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/keys) also ignores them. That's a part of the general "hiding symbolic properties" principle. If another script or a library loops over our object, it won't unexpectedly access a symbolic property.
+`Object.keys(user)` ก็จะละเว้น symbol เช่นกัน นี่คือส่วนหนึ่งของหลักการ "ซ่อน symbol property" ที่ว่า ถ้ามีไลบรารีอื่นมา for..in ออบเจ็กต์ของเรา มันจะไม่เจอ property ที่เป็น symbol โดยไม่ได้ตั้งใจ
 
-In contrast, [Object.assign](mdn:js/Object/assign) copies both string and symbol properties:
+ในทางตรงกันข้าม `Object.assign` นั้นจะคัดลอกทั้ง string และ symbol property:
 
 ```js run
 let id = Symbol("id");
@@ -187,103 +233,134 @@ let clone = Object.assign({}, user);
 alert( clone[id] ); // 123
 ```
 
-There's no paradox here. That's by design. The idea is that when we clone an object or merge objects, we usually want *all* properties to be copied (including symbols like `id`).
+ไม่มีอะไรแปลกตรงนี้ เพราะนั่นคือสิ่งที่มันถูกออกแบบมาให้ทำ แนวคิดคือ เวลาเรา clone หรือ merge ออบเจ็กต์ เราก็มักจะอยากให้มัน copy *ทุก* property (string และ symbol) นั่นเอง
 
-## Global symbols
+## Global Symbol
 
-As we've seen, usually all symbols are different, even if they have the same name. But sometimes we want same-named symbols to be same entities. For instance, different parts of our application want to access symbol `"id"` meaning exactly the same property.
+อย่างที่เห็น ปกติแล้ว symbol ทุกตัวจะไม่ซ้ำกันเลย แม้ว่าจะมีคำอธิบายเดียวกันก็ตาม 
 
-To achieve that, there exists a *global symbol registry*. We can create symbols in it and access them later, and it guarantees that repeated accesses by the same name return exactly the same symbol.
+แต่บางครั้ง เราอาจอยากให้ symbol ที่มีชื่อเหมือนกันเป็นตัวเดียวกันด้วย เช่นอยากให้ส่วนต่างๆ ของแอปพลิเคชันใช้ symbol ที่ชื่อ `"id"` โดยอ้างอิงถึง property อันเดียวกัน
 
-In order to read (create if absent) a symbol from the registry, use `Symbol.for(key)`.
+เพื่อทำแบบนั้น มีสิ่งที่เรียกว่า *global symbol registry* เราสามารถสร้าง symbol ไว้ในนั้น และเรียกใช้ซ้ำได้ในภายหลัง registry นี้จะรับประกันว่า การเข้าถึงด้วยชื่อเดิมซ้ำๆ จะคืน symbol ตัวเดียวกันเสมอ
 
-That call checks the global registry, and if there's a symbol described as `key`, then returns it, otherwise creates a new symbol `Symbol(key)` and stores it in the registry by the given `key`.
+ใช้ `Symbol.for(key)` ในการอ่าน (หรือสร้างใหม่ถ้ายังไม่มี) symbol จาก registry นี้
 
-For instance:
+การเรียกเมท็อดนี้จะไปค้นหาใน global registry ว่ามี symbol ที่มี `key` ตามที่ระบุไว้หรือไม่ ถ้ามีก็จะคืน symbol นั้น ถ้าไม่ก็จะสร้าง symbol ใหม่ด้วย `Symbol(key)` แล้วเก็บไว้ใน registry โดยใช้ `key` เป็นชื่อ
+
+ยกตัวอย่างเช่น:
 
 ```js run
-// read from the global registry
-let id = Symbol.for("id"); // if the symbol did not exist, it is created
+// อ่าน symbol จาก global registry
+let id = Symbol.for("id"); // ถ้ายังไม่มี symbol นี้อยู่ มันก็จะถูกสร้างขึ้นมาใหม่
 
-// read it again (maybe from another part of the code)
+// อ่าน symbol อีกรอบ (อาจจะจากส่วนอื่นของโค้ด)
 let idAgain = Symbol.for("id");
 
-// the same symbol
+// คือ symbol อันเดียวกัน
 alert( id === idAgain ); // true
 ```
 
-Symbols inside the registry are called *global symbols*. If we want an application-wide symbol, accessible everywhere in the code -- that's what they are for.
+Symbol ภายใน registry นี้ถูกเรียกว่า *global symbol* ถ้าเราต้องการ symbol ที่ใช้ทั่วทั้งแอปพลิเคชันและเข้าถึงได้จากทุกที่ในโค้ด เราก็ใช้อันนี้ได้เลย
 
-```smart header="That sounds like Ruby"
-In some programming languages, like Ruby, there's a single symbol per name.
+```smart header="เหมือนใน Ruby"
+ในบางภาษาเช่น Ruby จะมี symbol อยู่หนึ่งตัวสำหรับชื่อหนึ่งชื่อ
 
+<<<<<<< HEAD
+ใน JavaScript อย่างที่เราเห็น มันเป็นอย่างนั้นสำหรับ global symbol เท่านั้น
+=======
 In JavaScript, as we can see, that's true for global symbols.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 ```
 
 ### Symbol.keyFor
 
+<<<<<<< HEAD
+เราเห็นแล้วว่า `Symbol.for(key)` จะคืน symbol ที่มีชื่อตามที่ระบุ เราก็สามารถทำย้อนกลับได้ด้วยเช่นกัน โดยใช้เมท็อด `Symbol.keyFor(sym)` เพื่อคืนชื่อจาก global symbol
+=======
 We have seen that for global symbols, `Symbol.for(key)` returns a symbol by name. To do the opposite -- return a name by global symbol -- we can use: `Symbol.keyFor(sym)`:
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-For instance:
+ตัวอย่างเช่น:
 
 ```js run
-// get symbol by name
+// รับ symbol จากชื่อ
 let sym = Symbol.for("name");
 let sym2 = Symbol.for("id");
 
-// get name by symbol
+// รับชื่อจาก symbol
 alert( Symbol.keyFor(sym) ); // name
 alert( Symbol.keyFor(sym2) ); // id
 ```
 
-The `Symbol.keyFor` internally uses the global symbol registry to look up the key for the symbol. So it doesn't work for non-global symbols. If the symbol is not global, it won't be able to find it and returns `undefined`.
+`Symbol.keyFor` จะค้นหา key ของ symbol จาก global symbol registry ซึ่งหมายความว่ามันจะไม่ใช้กับ symbol ที่ไม่ใช่ global การใช้กับ symbol ที่ไม่ใช่ global จะคืน `undefined`
 
+<<<<<<< HEAD
+เทียบกับ `Symbol.for` แล้ว `Symbol.keyFor` นั้นเป็นตรงข้ามกัน: อันแรกคือรับชื่อแล้วคืน symbol ส่วนอันหลังคือรับ symbol แล้วคืนชื่อ
+=======
 That said, all symbols have the `description` property.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
+
+อย่างไรก็ตาม ไม่ใช่ทุก symbol ที่จะถูกเก็บไว้ใน global registry ซึ่ง `Symbol.for` ช่วยให้เรามี global symbol ที่มีชื่อเดียวกันได้ในขณะที่ symbol ทั่วไปจะเป็นคนละอันแม้ชื่อเหมือนกัน
 
-For instance:
+ลองดูโค้ดนี้:
 
 ```js run
 let globalSymbol = Symbol.for("name");
 let localSymbol = Symbol("name");
 
-alert( Symbol.keyFor(globalSymbol) ); // name, global symbol
-alert( Symbol.keyFor(localSymbol) ); // undefined, not global
+alert( Symbol.keyFor(globalSymbol) ); // name เพราะเป็น global symbol
+alert( Symbol.keyFor(localSymbol) ); // undefined เพราะไม่ใช่ global
 
 alert( localSymbol.description ); // name
 ```
 
-## System symbols
+## Symbol ของระบบ
 
-There exist many "system" symbols that JavaScript uses internally, and we can use them to fine-tune various aspects of our objects.
+มี "system symbol" ต่างๆ ที่ JavaScript ใช้ภายใน ซึ่งเราสามารถใช้มันปรับแต่งพฤติกรรมของออบเจ็กต์ได้บางส่วน
 
-They are listed in the specification in the [Well-known symbols](https://tc39.github.io/ecma262/#sec-well-known-symbols) table:
+พวกมันถูกแสดงอยู่ในตารางของ specification ชื่อ [Well-known symbols](https://tc39.github.io/ecma262/#sec-well-known-symbols) เช่น:
 
 - `Symbol.hasInstance`
 - `Symbol.isConcatSpreadable`
 - `Symbol.iterator`
 - `Symbol.toPrimitive`
-- ...and so on.
+- และอื่นๆ อีกมาก
 
-For instance, `Symbol.toPrimitive` allows us to describe object to primitive conversion. We'll see its use very soon.
+ยกตัวอย่างเช่น `Symbol.toPrimitive` ช่วยให้เราปรับแต่งวิธีการแปลงออบเจ็กต์เป็นค่าพื้นฐานได้ เราจะได้เห็นการใช้งานจริงของมันเร็วๆ นี้
 
-Other symbols will also become familiar when we study the corresponding language features.
+Symbol พวกนี้จะดูคุ้นตาเมื่อเราศึกษา feature ต่างๆ ของภาษาที่เกี่ยวข้องกับมัน
 
-## Summary
+## สรุป
 
-`Symbol` is a primitive type for unique identifiers.
+`Symbol` เป็นชนิดข้อมูลพื้นฐาน (primitive) สำหรับ unique identifier
 
-Symbols are created with `Symbol()` call with an optional description (name).
+Symbol สร้างได้ด้วย `Symbol()` โดยให้ description เป็นตัวเลือก
 
-Symbols are always different values, even if they have the same name. If we want same-named symbols to be equal, then we should use the global registry: `Symbol.for(key)` returns (creates if needed) a global symbol with `key` as the name. Multiple calls of `Symbol.for` with the same `key` return exactly the same symbol.
+Symbol จะมีค่าไม่ซ้ำกันเลย แม้จะมี description เหมือนกัน ถ้าเราต้องการให้ symbol ที่มีชื่อเดียวกันมีค่าเท่ากัน ให้ใช้ global registry: `Symbol.for(key)` จะคืน (หรือสร้างถ้ายังไม่มี) global symbol ที่มี `key` เป็นชื่อ การเรียก `Symbol.for` หลายครั้งด้วย key เดียวกันจะให้ symbol ตัวเดียวกันเสมอ
 
-Symbols have two main use cases:
+Symbol มีสองประโยชน์หลักๆ คือ:
 
+<<<<<<< HEAD
+1. "Hidden" property ของออบเจ็กต์
+=======
 1. "Hidden" object properties.
 
     If we want to add a property into an object that "belongs" to another script or a library, we can create a symbol and use it as a property key. A symbolic property does not appear in `for..in`, so it won't be accidentally processed together with other properties. Also it won't be accessed directly, because another script does not have our symbol. So the property will be protected from accidental use or overwrite.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
+
+    ถ้าเราอยากเพิ่ม property ลงในออบเจ็กต์ที่ "เป็นของ" script หรือ library อื่น เราสามารถสร้าง symbol แล้วใช้เป็น key ของมันได้ 
+
+    Property ที่เป็น symbol จะไม่ปรากฏใน `for..in` จึงไม่ถูกประมวลผลโดยไม่ได้ตั้งใจ และไม่สามารถเข้าถึงได้โดยตรงด้วย เพราะ script อื่นไม่มี symbol ของเรา ทำให้ property นั้นจะได้รับการปกป้องจากการถูกใช้หรือเขียนทับโดยไม่ตั้งใจ
+
+<<<<<<< HEAD
+    เราสามารถ "แอบยัด" อะไรบางอย่งเข้าไปในออบเจ็กต์ที่เราใช้อยู่ โดยที่ไม่ให้ใครอื่นรู้ได้ ผ่านการใช้ symbol property นี้
 
-    So we can "covertly" hide something into objects that we need, but others should not see, using symbolic properties.
+2. มี system symbol หลายตัวที่ JavaScript ใช้เองภายใน ซึ่งเราสามารถใช้ผ่าน `Symbol.*` ได้ เราสามารถใช้มันปรับแต่งพฤติกรรมบางอย่างในภาษาได้  
+    เช่นในบทต่อๆ ไป เราจะใช้ `Symbol.iterator` เพื่อทำ [iteration](info:iterable) `Symbol.toPrimitive` ในการ[แปลงออบเจ็กต์เป็นค่าพื้นฐาน](info:object-toprimitive) เป็นต้น
 
-2. There are many system symbols used by JavaScript which are accessible as `Symbol.*`. We can use them to alter some built-in behaviors. For instance, later in the tutorial we'll use `Symbol.iterator` for [iterables](info:iterable), `Symbol.toPrimitive` to setup [object-to-primitive conversion](info:object-toprimitive) and so on.
+ในแง่เทคนิคแล้ว symbol ไม่ได้ถูกซ่อนไว้ 100% มีบางเมท็อดในตัวอย่างเช่น [Object.getOwnPropertySymbols(obj)](mdn:js/Object/getOwnPropertySymbols) ที่ช่วยให้เราเข้าถึง symbol ทั้งหมดได้ และเมท็อด [Reflect.ownKeys(obj)](mdn:js/Reflect/ownKeys) ที่คืน *ทุก* key ของออบเจ็กต์ รวมถึง symbol ด้วย 
 
+แต่ส่วนใหญ่แล้ว ไลบรารีต่างๆ เมท็อดและ syntax structure ในตัวจะไม่ค่อยใช้เมท็อดเหล่านี้กัน ทำให้ symbol property ยังคงความเป็นส่วนตัวไว้ได้ในระดับหนึ่ง
+=======
 Technically, symbols are not 100% hidden. There is a built-in method [Object.getOwnPropertySymbols(obj)](mdn:js/Object/getOwnPropertySymbols) that allows us to get all symbols. Also there is a method named [Reflect.ownKeys(obj)](mdn:js/Reflect/ownKeys) that returns *all* keys of an object including symbolic ones. But most libraries, built-in functions and syntax constructs don't use these methods.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
diff --git a/1-js/04-object-basics/09-object-toprimitive/article.md b/1-js/04-object-basics/09-object-toprimitive/article.md
index fa68da583..7dc69c8b5 100644
--- a/1-js/04-object-basics/09-object-toprimitive/article.md
+++ b/1-js/04-object-basics/09-object-toprimitive/article.md
@@ -1,22 +1,39 @@
+# การแปลงออบเจ็กต์เป็นค่าปฐมภูมิ
 
-# Object to primitive conversion
+เกิดอะไรขึ้นเมื่อเรานำออบเจ็กต์ไปบวก (`obj1 + obj2`) ลบ (`obj1 - obj2`) หรือแสดงผลด้วย `alert(obj)`?
 
-What happens when objects are added `obj1 + obj2`, subtracted `obj1 - obj2` or printed using `alert(obj)`?
+ใน JavaScript เราไม่สามารถกำหนดพฤติกรรมของตัวดำเนินการเมื่อใช้กับออบเจ็กต์ได้เอง แตกต่างจากบางภาษาเช่น Ruby หรือ C++ ที่สามารถใช้เมท็อดพิเศษเพื่อควบคุมการทำงานของตัวดำเนินการได้ 
 
+<<<<<<< HEAD
+ในกรณีเหล่านี้ ออบเจ็กต์จะถูกแปลงเป็นค่าปฐมภูมิ (primitive value) โดยอัตโนมัติก่อน จากนั้นการดำเนินการจะเกิดขึ้นกับค่าปฐมภูมินั้น และส่งผลลัพธ์กลับมาเป็นค่าปฐมภูมิเช่นกัน
+=======
 JavaScript doesn't allow you to customize how operators work on objects. Unlike some other programming languages, such as Ruby or C++, we can't implement a special object method to handle addition (or other operators).
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-In case of such operations, objects are auto-converted to primitives, and then the operation is carried out over these primitives and results in a primitive value.
+นี่เป็นข้อจำกัดที่สำคัญ: ผลลัพธ์ของ `obj1 + obj2` (หรือการดำเนินการทางคณิตศาสตร์อื่นๆ) ไม่สามารถเป็นออบเจ็กต์ได้ 
 
+<<<<<<< HEAD
+ดังนั้น เราจึงไม่สามารถนิยามออบเจ็กต์ที่แทนเวกเตอร์หรือเมทริกซ์ แล้วคาดหวังให้การบวกออบเจ็กต์เหล่านั้นเข้าด้วยกัน ทำให้ได้เวกเตอร์หรือเมทริกซ์ใหม่ที่ "รวม" ค่าเข้าด้วยกัน ข้อจำกัดนี้ทำให้ไม่สามารถเขียนโค้ดในลักษณะนั้นได้เลย
+=======
 That's an important limitation: the result of `obj1 + obj2` (or another math operation) can't be another object!
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-E.g. we can't make objects representing vectors or matrices (or achievements or whatever), add them and expect a "summed" object as the result. Such architectural feats are automatically "off the board".
+ด้วยเหตุนี้ การทำงานทางคณิตศาสตร์โดยใช้ออบเจ็กต์จึงมีใช้น้อยมากในโปรเจ็กต์จริง และถ้าเกิดขึ้นมักจะเป็นเพราะข้อผิดพลาดในการเขียนโค้ดมากกว่า
 
+<<<<<<< HEAD
+ในบทความนี้ เราจะเรียนรู้กระบวนการแปลงออบเจ็กต์เป็นค่าปฐมภูมิ และวิธีควบคุมกระบวนการนั้นด้วยตัวเอง โดยมีจุดประสงค์ 2 ประการ:
+=======
 So, because we can't technically do much here, there's no maths with objects in real projects. When it happens, with rare exceptions, it's because of a coding mistake.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-In this chapter we'll cover how an object converts to primitive and how to customize it.
+1. เพื่อเข้าใจสิ่งที่เกิดขึ้นเมื่อมีข้อผิดพลาดในการเขียนโค้ด ที่ทำให้เกิดการแปลงโดยไม่ตั้งใจ
+2. เพื่อศึกษากรณียกเว้นที่การแปลงดังกล่าวมีประโยชน์และให้ผลลัพธ์ที่ถูกต้อง เช่น การลบหรือเปรียบเทียบวันที่ (Date)
 
-We have two purposes:
+## ขั้นตอนการแปลง
 
+<<<<<<< HEAD
+ใน JavaScript มี 3 ประเภทของการแปลงออบเจ็กต์เป็นค่าปฐมภูมิ ซึ่งเรียกว่า "hint" (คำใบ้) ขึ้นอยู่กับสถานการณ์ที่เกิดขึ้น ดังนี้:
+=======
 1. It will allow us to understand what's going on in case of coding mistakes, when such an operation happened accidentally.
 2. There are exceptions, where such operations are possible and look good. E.g. subtracting or comparing dates (`Date` objects). We'll come across them later.
 
@@ -37,42 +54,32 @@ Now let's get into technical details, because it's the only way to cover the top
 How does JavaScript decide which conversion to apply?
 
 There are three variants of type conversion, that happen in various situations. They're called "hints", as described in the [specification](https://tc39.github.io/ecma262/#sec-toprimitive):
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
 `"string"`
-: For an object-to-string conversion, when we're doing an operation on an object that expects a string, like `alert`:
-
-    ```js
-    // output
-    alert(obj);
-
-    // using object as a property key
-    anotherObj[obj] = 123;
-    ```
+: สำหรับการแปลงเป็น string เมื่อเราต้องการนำออบเจ็กต์ไปใช้ในบริบทที่คาดหวังค่า string เช่น `alert(obj)`
 
 `"number"`
-: For an object-to-number conversion, like when we're doing maths:
-
-    ```js
-    // explicit conversion
-    let num = Number(obj);
-
-    // maths (except binary plus)
-    let n = +obj; // unary plus
-    let delta = date1 - date2;
-
-    // less/greater comparison
-    let greater = user1 > user2;
-    ```
+: สำหรับการแปลงเป็นตัวเลข เช่น ในการคำนวณทางคณิตศาสตร์ `let num = Number(obj)`, `let n = +obj`, `let delta = date1 - date2`, `let greater = user1 > user2` เป็นต้น ฟังก์ชันคณิตศาสตร์ส่วนใหญ่ก็ใช้การแปลงแบบนี้ด้วย
 
     Most built-in mathematical functions also include such conversion.
 
 `"default"`
-: Occurs in rare cases when the operator is "not sure" what type to expect.
+: เกิดขึ้นน้อยครั้ง เมื่อตัวดำเนินการ "ไม่แน่ใจ" ว่าคาดหวังข้อมูลประเภทใด เช่น ตัวดำเนินการบวกเลขฐานสอง `+` ที่ยอมรับทั้ง string และตัวเลข ดังนั้นจึงใช้ hint นี้เมื่อได้รับออบเจ็กต์มา นอกจากนี้ตัวดำเนินการเปรียบเทียบ `==` กับ string, number หรือ symbol ก็ใช้ hint `"default"` เช่นกัน
 
+<<<<<<< HEAD
+ในทางปฏิบัติ สถานการณ์อาจง่ายกว่านี้เล็กน้อย ออบเจ็กต์ส่วนใหญ่ (ยกเว้น Date) จะใช้การแปลงแบบ `"default"` เหมือนกับ `"number"` และเราก็ควรทำเช่นนั้น แต่ก็ยังจำเป็นต้องรู้จักทั้ง 3 ประเภท เพื่อให้เข้าใจว่ามันมีประโยชน์อย่างไร
+=======
     For instance, binary plus `+` can work both with strings (concatenates them) and numbers (adds them). So if a binary plus gets an object as an argument, it uses the `"default"` hint to convert it.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-    Also, if an object is compared using `==` with a string, number or a symbol, it's also unclear which conversion should be done, so the `"default"` hint is used.
+**เมื่อต้องการแปลงออบเจ็กต์เป็นค่าปฐมภูมิ JavaScript จะพยายามค้นหาและเรียกใช้เมท็อดต่างๆ ตามลำดับดังนี้:**
 
+<<<<<<< HEAD
+1. เรียกใช้ `obj[Symbol.toPrimitive](hint)` หากมีการกำหนดเมท็อดนี้ไว้ โดย `Symbol.toPrimitive` เป็นสัญลักษณ์ในตัวของระบบ
+2. มิฉะนั้น ถ้า hint เป็น `"string"` จะลองเรียก `obj.toString()` และ `obj.valueOf()` อย่างใดอย่างหนึ่งที่มีอยู่
+3. มิฉะนั้น ถ้า hint เป็น `"number"` หรือ `"default"` จะลองเรียก `obj.valueOf()` และ `obj.toString()` อย่างใดอย่างหนึ่งที่มีอยู่
+=======
     ```js
     // binary plus uses the "default" hint
     let total = obj1 + obj2;
@@ -96,24 +103,25 @@ Still, it's important to know about all 3 hints, soon we'll see why.
     - try calling `obj.toString()` or `obj.valueOf()`, whatever exists.
 3. Otherwise if hint is `"number"` or `"default"`
     - try calling `obj.valueOf()` or `obj.toString()`, whatever exists.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
 ## Symbol.toPrimitive
 
-Let's start from the first method. There's a built-in symbol named `Symbol.toPrimitive` that should be used to name the conversion method, like this:
+วิธีแรกคือใช้ symbol ในตัว `Symbol.toPrimitive` เป็นชื่อเมท็อดสำหรับแปลงออบเจ็กต์ โดยใช้ดังนี้:
 
 ```js
 obj[Symbol.toPrimitive] = function(hint) {
-  // here goes the code to convert this object to a primitive
-  // it must return a primitive value
-  // hint = one of "string", "number", "default"
+  // โค้ดสำหรับแปลงออบเจ็กต์นี้เป็นค่าปฐมภูมิ
+  // ต้องคืนค่าเป็นค่าปฐมภูมิ
+  // hint จะเป็นหนึ่งใน "string", "number", "default"
 };
 ```
 
-If the method `Symbol.toPrimitive` exists, it's used for all hints, and no more methods are needed.
+ถ้ามีเมท็อด `Symbol.toPrimitive` มันจะถูกเรียกใช้สำหรับทุก hint และไม่จำเป็นต้องใช้เมท็อดอื่นอีก
 
-For instance, here `user` object implements it:
+ตัวอย่างเช่น ออบเจ็กต์ `user` ใช้เมท็อดนี้:
 
-```js run
+```js
 let user = {
   name: "John",
   money: 1000,
@@ -124,62 +132,70 @@ let user = {
   }
 };
 
-// conversions demo:
+// ตัวอย่างการแปลง:
 alert(user); // hint: string -> {name: "John"}
 alert(+user); // hint: number -> 1000
 alert(user + 500); // hint: default -> 1500
 ```
 
+<<<<<<< HEAD
+จะเห็นว่า `user` กลายเป็น string หรือตัวเลข ขึ้นอยู่กับรูปแบบการแปลง โดยใช้แค่เมท็อดเดียว `user[Symbol.toPrimitive]` ในการจัดการทุกกรณี
+=======
 As we can see from the code, `user` becomes a self-descriptive string or a money amount, depending on the conversion. The single method `user[Symbol.toPrimitive]` handles all conversion cases.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
 ## toString/valueOf
 
-If there's no `Symbol.toPrimitive` then JavaScript tries to find methods `toString` and `valueOf`:
+ถ้าไม่มี `Symbol.toPrimitive` JavaScript จะมองหาเมท็อด `toString` และ `valueOf` แทน:
 
+<<<<<<< HEAD
+- สำหรับ hint ชนิด `"string"` จะเรียก `toString` ก่อน หากไม่มีหรือคืนค่าเป็นออบเจ็กต์ จะไปเรียก `valueOf` แทน (ดังนั้น `toString` จึงมีความสำคัญมากกว่าในการแปลงเป็น string)
+- สำหรับ hint ชนิด `"number"` หรือ `"default"` จะเรียก `valueOf` ก่อน หากไม่มีหรือคืนค่าเป็นออบเจ็กต์ จะไปเรียก `toString` แทน (ดังนั้น `valueOf` จึงมีความสำคัญมากกว่าในการคำนวณ)
+=======
 - For the `"string"` hint: call `toString` method, and if it doesn't exist or if it returns an object instead of a primitive value, then call `valueOf` (so `toString` has the priority for string conversions).
 - For other hints: call `valueOf`, and if it doesn't exist or if it returns an object instead of a primitive value, then call `toString` (so `valueOf` has the priority for maths).
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-Methods `toString` and `valueOf` come from ancient times. They are not symbols (symbols did not exist that long ago), but rather "regular" string-named methods. They provide an alternative "old-style" way to implement the conversion.
+เมท็อด `toString` และ `valueOf` มาจากสมัยเก่า ก่อนที่จะมีแนวคิดเรื่อง symbol เป็นเมท็อดชื่อ string ธรรมดาที่ให้วิธีการแปลงแบบ "โบราณ"
 
-These methods must return a primitive value. If `toString` or `valueOf` returns an object, then it's ignored (same as if there were no method).
+โดยเมท็อดเหล่านี้ต้องคืนค่าปฐมภูมิ หาก `toString` หรือ `valueOf` คืนค่าเป็นออบเจ็กต์ ก็จะถูกละเลยเสมือนไม่มีการกำหนดเมท็อดนั้นไว้เลย
 
-By default, a plain object has following `toString` and `valueOf` methods:
+ออบเจ็กต์ทั่วไปมีเมท็อด `toString` และ `valueOf` ค่าเริ่มต้นดังนี้:
 
-- The `toString` method returns a string `"[object Object]"`.
-- The `valueOf` method returns the object itself.
+- `toString` คืนค่าเป็น string `"[object Object]"`
+- `valueOf` คืนออบเจ็กต์ตัวมันเอง
 
-Here's the demo:
+ตัวอย่างเช่น:
 
-```js run
+```js
 let user = {name: "John"};
 
 alert(user); // [object Object]
 alert(user.valueOf() === user); // true
 ```
 
-So if we try to use an object as a string, like in an `alert` or so, then by default we see `[object Object]`.
+ดังนั้น หากใช้ออบเจ็กต์แทนที่ที่คาดหวังค่า string เช่นใน `alert` โดยปกติแล้วจะแสดงผลเป็น `[object Object]`
 
-The default `valueOf` is mentioned here only for the sake of completeness, to avoid any confusion. As you can see, it returns the object itself, and so is ignored. Don't ask me why, that's for historical reasons. So we can assume it doesn't exist.
+ส่วน `valueOf` ที่คืนออบเจ็กต์ตัวมันเองนั้น ไม่มากมีประโยชน์ มีการกล่าวถึงไว้ที่นี่เพื่อความครบถ้วนเท่านั้น ซึ่งเป็นแบบนี้มาตั้งแต่สมัยแรกด้วยบางเหตุผล ส่วนใหญ่แล้วมักจะถือว่ามันไม่มีอยู่
 
-Let's implement these methods to customize the conversion.
+มาลองใช้เมท็อดเหล่านี้ในการกำหนดพฤติกรรมการแปลงเป็นแบบของเราเองกัน
 
-For instance, here `user` does the same as above using a combination of `toString` and `valueOf` instead of `Symbol.toPrimitive`:
+ตัวอย่างเช่น ที่นี่ `user` จะทำงานแบบเดียวกับตัวอย่างก่อนหน้า แต่ใช้ `toString` กับ `valueOf` แทน `Symbol.toPrimitive`:
 
-```js run
+```js
 let user = {
   name: "John",
   money: 1000,
 
-  // for hint="string"
+  // สำหรับ hint "string"
   toString() {
     return `{name: "${this.name}"}`;
   },
 
-  // for hint="number" or "default"
+  // สำหรับ hint "number" หรือ "default"
   valueOf() {
     return this.money;
   }
-
 };
 
 alert(user); // toString -> {name: "John"}
@@ -187,11 +203,9 @@ alert(+user); // valueOf -> 1000
 alert(user + 500); // valueOf -> 1500
 ```
 
-As we can see, the behavior is the same as the previous example with `Symbol.toPrimitive`.
+โดยทั่วไปแล้ว มักต้องการจุดรวมศูนย์เดียวในการจัดการการแปลงออบเจ็กต์ให้เป็นค่าปฐมภูมิทั้งหมด ในกรณีนี้เราจะใช้แค่ `toString` อย่างเดียว ทำให้มันเป็นตัวจัดการหลักในการแปลง ดังตัวอย่าง:
 
-Often we want a single "catch-all" place to handle all primitive conversions. In this case, we can implement `toString` only, like this:
-
-```js run
+```js
 let user = {
   name: "John",
 
@@ -204,71 +218,133 @@ alert(user); // toString -> John
 alert(user + 500); // toString -> John500
 ```
 
-In the absence of `Symbol.toPrimitive` and `valueOf`, `toString` will handle all primitive conversions.
+หากไม่มี `Symbol.toPrimitive` และ `valueOf` เมท็อด `toString` ก็จะรับผิดชอบการแปลงออบเจ็กต์เป็นค่าปฐมภูมิทั้งหมดเอง
 
-### A conversion can return any primitive type
+### การแปลงสามารถคืนค่าปฐมภูมิประเภทใดก็ได้
 
-The important thing to know about all primitive-conversion methods is that they do not necessarily return the "hinted" primitive.
+สิ่งสำคัญที่ต้องทราบเกี่ยวกับเมท็อดทั้งหมดที่ใช้ในการแปลงออบเจ็กต์ คือ พวกมันไม่จำเป็นต้องคืนค่าปฐมภูมิประเภทที่ตรงกับ hint เสมอไป
 
+<<<<<<< HEAD
+ไม่มีข้อบังคับว่า `toString` ต้องคืนค่าเป็น string เสมอ หรือ `Symbol.toPrimitive` ต้องคืนตัวเลขเมื่อ hint เป็น `"number"` 
+=======
 There is no control whether `toString` returns exactly a string, or whether `Symbol.toPrimitive` method returns a number for the hint `"number"`.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-The only mandatory thing: these methods must return a primitive, not an object.
+สิ่งเดียวที่จำเป็นคือ เมท็อดเหล่านั้นต้องคืนค่าปฐมภูมิ ไม่ใช่ออบเจ็กต์
 
-```smart header="Historical notes"
-For historical reasons, if `toString` or `valueOf` returns an object, there's no error, but such value is ignored (like if the method didn't exist). That's because in ancient times there was no good "error" concept in JavaScript.
+```smart header="หมายเหตุทางประวัติศาสตร์"
+สมัยก่อน ถ้า `toString` หรือ `valueOf` คืนออบเจ็กต์ ก็จะไม่เกิด error แต่ค่านั้นจะถูกละเลย (เสมือนไม่มีการกำหนดเมท็อดนั้นไว้) นั่นเป็นเพราะไม่มีแนวคิดเรื่อง "error" ที่ดีพอใน JavaScript สมัยนั้น
 
+<<<<<<< HEAD
+ในทางตรงข้าม `Symbol.toPrimitive` มีกฎเข้มงวดกว่า มันต้องคืนค่าปฐมภูมิเท่านั้น ไม่เช่นนั้นจะเกิด error
+=======
 In contrast, `Symbol.toPrimitive` is stricter, it *must* return a primitive, otherwise there will be an error.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 ```
 
-## Further conversions
+## การแปลงอื่นๆ
 
-As we know already, many operators and functions perform type conversions, e.g. multiplication `*` converts operands to numbers.
+อย่างที่เราได้เรียนรู้มา มีตัวดำเนินการและฟังก์ชันหลายตัวที่ดำเนินการแปลงชนิดข้อมูล เช่น การคูณ `*` จะแปลงตัวถูกดำเนินการให้เป็นตัวเลข
 
+<<<<<<< HEAD
+หากเราส่งออบเจ็กต์เป็นอาร์กิวเมนต์ การคำนวณจะประกอบด้วย 2 ขั้นตอน:
+1. ออบเจ็กต์จะถูกแปลงให้เป็นค่าปฐมภูมิ (ตามกฎที่อธิบายข้างต้น)
+2. หากจำเป็นสำหรับการดำเนินการต่อไป ค่าปฐมภูมินั้นจะถูกแปลงอีกครั้ง
+=======
 If we pass an object as an argument, then there are two stages of calculations:
 1. The object is converted to a primitive (using the rules described above).
 2. If necessary for further calculations, the resulting primitive is also converted.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-For instance:
+ตัวอย่างเช่น:
 
-```js run
+```js
 let obj = {
-  // toString handles all conversions in the absence of other methods
+  // toString จัดการการแปลงทั้งหมดเมื่อไม่มีเมท็อดอื่น
   toString() {
     return "2";
   }
 };
 
-alert(obj * 2); // 4, object converted to primitive "2", then multiplication made it a number
+alert(obj * 2); // 4 ออบเจ็กต์ถูกแปลงเป็น "2", จากนั้น "2" จึงถูกคูณด้วย 2
 ```
 
-1. The multiplication `obj * 2` first converts the object to primitive (that's a string `"2"`).
-2. Then `"2" * 2` becomes `2 * 2` (the string is converted to number).
+1. การคูณ `obj * 2` ขั้นแรกจะแปลง `obj` ให้เป็นค่าปฐมภูมิ ซึ่งจะเป็น string `"2"` (จาก `toString`)
+2. จากนั้น `"2" * 2` จะกลายเป็น `2 * 2` (string ถูกแปลงเป็นตัวเลข)
 
-Binary plus will concatenate strings in the same situation, as it gladly accepts a string:
+บวกด้วย `+` ก็มีกฎพิเศษเหมือนกัน:
 
-```js run
+```js
 let obj = {
   toString() {
     return "2";
   }
 };
 
+<<<<<<< HEAD
+alert(obj + 2); // 22 ("2" + 2), การแปลงเป็น string เกิดขึ้น
+=======
 alert(obj + 2); // "22" ("2" + 2), conversion to primitive returned a string => concatenation
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 ```
 
-## Summary
+การบวก `obj + 2` ในตอนแรกจะแปลง `obj` เป็นค่าปฐมภูมิ (ซึ่งเป็น string `"2"`) จากนั้นจึงเกิดการต่อ string `"2" + 2 = "22"`
 
-The object-to-primitive conversion is called automatically by many built-in functions and operators that expect a primitive as a value.
+ในทางตรงข้าม การลบ `-` และตัวดำเนินการเปรียบเทียบอื่นๆ เช่น `<` `>` จะแปลงทั้งสอง operand ให้เป็นตัวเลขเสมอ:
 
+<<<<<<< HEAD
+```js
+let obj = {
+  toString() {
+    return "2";
+  }
+};
+
+alert(obj - 2); // 0 ("2" - 2), การแปลงเป็นตัวเลขเกิดขึ้น
+```
+=======
 There are 3 types (hints) of it:
 - `"string"` (for `alert` and other operations that need a string)
 - `"number"` (for maths)
 - `"default"` (few operators, usually objects implement it the same way as `"number"`)
 
 The specification describes explicitly which operator uses which hint.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
+
+นี่คือตารางสรุประบุว่าตัวดำเนินการใช้การแปลงแบบใด:
+
+<<<<<<< HEAD
+| ตัวดำเนินการ | การแปลงตัวถูกดำเนินการ |
+|--------------|----------------------|
+| + | ทำการต่อ string ถ้าสามารถแปลงได้ เช่น `"1" + "2" = "12"`, `"1" + 2 = "12"` |
+| - | แปลงเป็นตัวเลข |
+| * / | แปลงเป็นตัวเลข |
+| == | แปลงเป็นตัวเลข แต่ `null` กับ `undefined` จะถูกเปรียบเทียบโดยไม่มีการแปลง |
+| < > >= <= | แปลงเป็นตัวเลข |
+| + (unary) | แปลงเป็นตัวเลข |
+
+
+## สรุป
+
+การแปลงออบเจ็กต์เป็นค่าปฐมภูมิจะถูกเรียกใช้โดยอัตโนมัติ โดยฟังก์ชันและตัวดำเนินการหลายตัวที่คาดหวังให้ข้อมูลเป็นค่าปฐมภูมิ
+
+มีการแปลง 3 แบบ:
+- `"string"` (สำหรับ `alert` และตัวดำเนินการที่ต้องการ string)  
+- `"number"` (สำหรับการคำนวณทางคณิตศาสตร์)
+- `"default"` (สำหรับตัวดำเนินการบางตัวเท่านั้น)
+
+ซึ่งมีระบุไว้ชัดเจนในสเปคว่าตัวดำเนินการแต่ละตัวใช้การแปลงแบบใด
+
+ลำดับขั้นตอนการแปลงคือ:
 
-The conversion algorithm is:
+1. เรียกใช้ `obj[Symbol.toPrimitive](hint)` หากมีการกำหนดไว้
+2. มิฉะนั้น ถ้า hint คือ `"string"`
+    - ลองเรียก `obj.toString()` และ `obj.valueOf()` ตามลำดับ เลือกอันแรกที่ใช้ได้ 
+3. มิฉะนั้น ถ้า hint คือ `"number"` หรือ `"default"`
+    - ลองเรียก `obj.valueOf()` และ `obj.toString()` ตามลำดับ เลือกอันแรกที่ใช้ได้
 
+ในทางปฏิบัติ การใช้เมท็อด `obj.toString()` เพียงอย่างเดียวเป็นตัวจัดการหลักในการแปลงออบเจ็กต์เป็น string มักจะพอเพียง และถูกใช้เพื่ออธิบายข้อมูลของออบเจ็กต์ในรูปแบบที่อ่านได้ง่าย โดยมักใช้ในการล็อก (log) และดีบั๊ก
+=======
 1. Call `obj[Symbol.toPrimitive](hint)` if the method exists,
 2. Otherwise if hint is `"string"`
     - try calling `obj.toString()` or `obj.valueOf()`, whatever exists.
@@ -278,3 +354,4 @@ The conversion algorithm is:
 All these methods must return a primitive to work (if defined).
 
 In practice, it's often enough to implement only `obj.toString()` as a "catch-all" method for string conversions that should return a "human-readable" representation of an object, for logging or debugging purposes.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
diff --git a/1-js/04-object-basics/index.md b/1-js/04-object-basics/index.md
index d2387aafa..4f3f65b32 100644
--- a/1-js/04-object-basics/index.md
+++ b/1-js/04-object-basics/index.md
@@ -1 +1 @@
-# Objects: the basics
+# อ็อบเจ็กต์เบื้องต้น
diff --git a/1-js/05-data-types/01-primitives-methods/article.md b/1-js/05-data-types/01-primitives-methods/article.md
index 69e7196e9..3e2f67b21 100644
--- a/1-js/05-data-types/01-primitives-methods/article.md
+++ b/1-js/05-data-types/01-primitives-methods/article.md
@@ -1,20 +1,18 @@
-# Methods of primitives
+# เมท็อดของข้อมูลปฐมภูมิ
 
-JavaScript allows us to work with primitives (strings, numbers, etc.) as if they were objects. They also provide methods to call as such. We will study those soon, but first we'll see how it works because, of course, primitives are not objects (and here we will make it even clearer).
+JavaScript อนุญาตให้เราทำงานกับข้อมูลปฐมภูมิ (เช่น string, number) ราวกับว่าพวกมันเป็นออบเจ็กต์ โดยมีเมท็อดให้เรียกใช้ได้ด้วย เราจะศึกษาวิธีการทำงานนี้กันในรายละเอียด
 
-Let's look at the key distinctions between primitives and objects.
+ก่อนอื่นมาทำความเข้าใจความแตกต่างสำคัญระหว่างข้อมูลปฐมภูมิกับออบเจ็กต์กันก่อน
 
-A primitive
+ข้อมูลปฐมภูมิ:
+- เป็นค่าปฐมภูมีประเภทต่างๆ 
+- มีทั้งหมด 7 ประเภท ได้แก่ `string`, `number`, `bigint`, `boolean`, `symbol`, `null` และ `undefined`
 
-- Is a value of a primitive type.
-- There are 7 primitive types: `string`, `number`, `bigint`, `boolean`, `symbol`, `null` and `undefined`.
+ออบเจ็กต์:
+- สามารถเก็บพร็อพเพอร์ตี้หลายค่า ในรูปแบบคีย์-ค่า
+- สามารถสร้างได้ด้วย `{}` เช่น `{name: "John", age: 30}` และในภาษา JavaScript ยังมีออบเจ็กต์ประเภทอื่นๆ อีก เช่น ฟังก์ชันเองก็ถือเป็นออบเจ็กต์
 
-An object
-
-- Is capable of storing multiple values as properties.
-- Can be created with `{}`, for instance: `{name: "John", age: 30}`. There are other kinds of objects in JavaScript: functions, for example, are objects.
-
-One of the best things about objects is that we can store a function as one of its properties.
+หนึ่งในจุดเด่นของออบเจ็กต์คือ เราสามารถเก็บฟังก์ชันเป็นพร็อพเพอร์ตี้ได้:
 
 ```js run
 let john = {
@@ -27,32 +25,37 @@ let john = {
 john.sayHi(); // Hi buddy!
 ```
 
-So here we've made an object `john` with the method `sayHi`.
+ที่นี่เราสร้างออบเจ็กต์ `john` ที่มีเมท็อด `sayHi` ไว้ด้วย
 
-Many built-in objects already exist, such as those that work with dates, errors, HTML elements, etc. They have different properties and methods.
+มีออบเจ็กต์ในตัวจำนวนมากที่มีอยู่แล้ว เช่น ออบเจ็กต์สำหรับวันที่ (Date), ข้อผิดพลาด (Error), องค์ประกอบ HTML เป็นต้น ซึ่งมีพร็อพเพอร์ตี้และเมท็อดเฉพาะตัวที่หลากหลาย
 
-But, these features come with a cost!
+แต่คุณสมบัติเหล่านี้ก็มีค่าใช้จ่าย!
 
-Objects are "heavier" than primitives. They require additional resources to support the internal machinery.
+ออบเจ็กต์จะ "หนัก" กว่าข้อมูลปฐมภูมิ เพราะต้องใช้ทรัพยากรเพิ่มเติมเพื่อสนับสนุนกลไกภายในต่างๆ
 
-## A primitive as an object
+## ข้อมูลปฐมภูมิในฐานะออบเจ็กต์ 
 
-Here's the paradox faced by the creator of JavaScript:
+นี่คือปัญหาที่ผู้สร้าง JavaScript ต้องเผชิญ:
 
+<<<<<<< HEAD
+- เรามักจะอยากทำอะไรหลายๆ อย่างกับข้อมูลปฐมภูมิ เช่น string หรือ number การเข้าถึงข้อมูลผ่านเมท็อดจะช่วยได้มาก  
+- แต่ข้อมูลปฐมภูมิควรจะเบาและรวดเร็วที่สุดเท่าที่จะเป็นไปได้
+=======
 - There are many things one would want to do with a primitive, like a string or a number. It would be great to access them using methods.
 - Primitives must be as fast and lightweight as possible.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-The solution looks a little bit awkward, but here it is:
+วิธีแก้ปัญหาอาจดูแปลกไปหน่อย แต่ทำได้ดังนี้:
 
-1. Primitives are still primitive. A single value, as desired.
-2. The language allows access to methods and properties of strings, numbers, booleans and symbols.
-3. In order for that to work, a special "object wrapper" that provides the extra functionality is created, and then is destroyed.
+1. ข้อมูลปฐมภูมิยังคงเป็นข้อมูลปฐมภูมิ ซึ่งเป็นค่าเดี่ยวตามต้องการ
+2. ภาษานี้อนุญาตให้เข้าถึงเมท็อดและพร็อพเพอร์ตี้ของ string, number, boolean และ symbol
+3. เพื่อให้ทำได้ มีการสร้าง "ออบเจ็กต์ห่อหุ้ม (wrapper)" พิเศษขึ้นมาเพื่อให้ฟังก์ชันการทำงานเพิ่มเติม ซึ่งจะถูกทำลายทิ้งหลังจากเสร็จงาน
 
-The "object wrappers" are different for each primitive type and are called: `String`, `Number`, `Boolean`, `Symbol` and `BigInt`. Thus, they provide different sets of methods.
+"ออบเจ็กต์ห่อหุ้ม (wrapper)" จะแตกต่างกันตามชนิดของข้อมูลปฐมภูมิ มี `String`, `Number`, `Boolean`, `Symbol` และ `BigInt` แต่ละตัวจะมีเมท็อดเฉพาะของตัวเอง
 
-For instance, there exists a string method [str.toUpperCase()](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase) that returns a capitalized `str`.
+ยกตัวอย่างเช่น มีเมท็อดสำหรับ string อย่าง [str.toUpperCase()](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase) ที่คืนค่า `str` เป็นตัวอักษรพิมพ์ใหญ่ทั้งหมด
 
-Here's how it works:
+ลองดูการทำงานได้ดังนี้:
 
 ```js run
 let str = "Hello";
@@ -60,17 +63,17 @@ let str = "Hello";
 alert( str.toUpperCase() ); // HELLO
 ```
 
-Simple, right? Here's what actually happens in `str.toUpperCase()`:
+ง่ายๆ เลย แต่แท้จริงแล้ว เบื้องหลัง `str.toUpperCase()` เกิดอะไรขึ้นมั่ง:
 
-1. The string `str` is a primitive. So in the moment of accessing its property, a special object is created that knows the value of the string, and has useful methods, like `toUpperCase()`.
-2. That method runs and returns a new string (shown by `alert`).
-3. The special object is destroyed, leaving the primitive `str` alone.
+1. string `str` เป็นข้อมูลปฐมภูมิ ดังนั้นเมื่อมีการเข้าถึงพร็อพเพอร์ตี้ จะมีการสร้างออบเจ็กต์พิเศษขึ้นมาซึ่งรู้ค่าของ string นั้น และมีเมท็อดที่มีประโยชน์ต่างๆ เช่น `toUpperCase()`
+2. เมท็อดนั้นรันและคืนค่า string ใหม่ (แสดงโดย `alert`)
+3. ออบเจ็กต์พิเศษจะถูกทำลายทิ้ง ปล่อย `str` ไว้เป็นข้อมูลปฐมภูมิตามเดิม
 
-So primitives can provide methods, but they still remain lightweight.
+ดังนั้น ข้อมูลปฐมภูมิสามารถจัดการเมท็อดได้ โดยยังคงความเป็นข้อมูลที่มีน้ำหนักเบาไว้เหมือนเดิม
 
-The JavaScript engine highly optimizes this process. It may even skip the creation of the extra object at all. But it must still adhere to the specification and behave as if it creates one.
+เอ็นจิน JavaScript ทำให้กระบวนการนี้ราบรื่นที่สุด บางครั้งอาจแม้กระทั่งข้ามการสร้างออบเจ็กต์พิเศษไปเลย แต่ยังคงปฏิบัติตามข้อกำหนดและให้ผลเสมือนมีการสร้างออบเจ็กต์นั้นขึ้นมาจริง
 
-A number has methods of its own, for instance, [toFixed(n)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toFixed) rounds the number to the given precision:
+ตัวเลขก็มีเมท็อดเป็นของตัวเองเช่นกัน เช่น [toFixed(n)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toFixed) ที่ปัดเศษทศนิยมตามจำนวนตำแหน่งที่ระบุ:
 
 ```js run
 let n = 1.23456;
@@ -78,15 +81,15 @@ let n = 1.23456;
 alert( n.toFixed(2) ); // 1.23
 ```
 
-We'll see more specific methods in chapters <info:number> and <info:string>.
+เราจะได้เรียนรู้เมท็อดเฉพาะของข้อมูลปฐมภูมิแต่ละตัวเพิ่มเติมในบท <info:number> และ <info:string>
 
 
-````warn header="Constructors `String/Number/Boolean` are for internal use only"
-Some languages like Java allow us to explicitly create "wrapper objects" for primitives using a syntax like `new Number(1)` or `new Boolean(false)`.
+````warn header="constructor ของ String/Number/Boolean ใช้สำหรับภายในเท่านั้น"
+บางภาษา เช่น Java อนุญาตให้เราสร้าง "ออบเจ็กต์ wrapper" สำหรับข้อมูลปฐมภูมิได้โดยใช้ syntax แบบ `new Number(1)` หรือ `new Boolean(false)`
 
-In JavaScript, that's also possible for historical reasons, but highly **unrecommended**. Things will go crazy in several places.
+JavaScript ก็อนุญาตให้ทำแบบนั้นได้เช่นกันเพราะเหตุผลบางอย่างในอดีต แต่ปัจจุบัน*ไม่แนะนำให้ใช้วิธีนี้เด็ดขาด* เนื่องจากอาจนำไปสู่ปัญหามากมาย
 
-For instance:
+ยกตัวอย่างเช่น:
 
 ```js run
 alert( typeof 0 ); // "number"
@@ -94,36 +97,42 @@ alert( typeof 0 ); // "number"
 alert( typeof new Number(0) ); // "object"!
 ```
 
-Objects are always truthy in `if`, so here the alert will show up:
+ออบเจ็กต์จะมีค่าเป็น truthy เสมอ ดังนั้น alert ด้านล่างจะแสดงอะไรออกมา:
 
 ```js run
 let zero = new Number(0);
 
-if (zero) { // zero is true, because it's an object
+if (zero) { // zero เป็น true เพราะเป็นออบเจ็กต์
   alert( "zero is truthy!?!" );
 }
 ```
 
+<<<<<<< HEAD
+ในทางกลับกัน การใช้ฟังก์ชัน `String/Number/Boolean` แบบไม่มี `new` นั้นโอเค และมีประโยชน์มาก เพราะจะแปลงค่าเป็น string/number/boolean ตามแต่ประเภทที่ต้องการ (ซึ่งยังคงเป็นค่าปฐมภูมิ)
+
+ยกตัวอย่างเช่น นี่เป็นวิธีที่ถูกต้อง:
+=======
 On the other hand, using the same functions `String/Number/Boolean` without `new` is totally fine and useful thing. They convert a value to the corresponding type: to a string, a number, or a boolean (primitive).
 
 For example, this is entirely valid:
 
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 ```js
-let num = Number("123"); // convert a string to number
+let num = Number("123"); // แปลง string เป็น number
 ```
 ````
 
+````warn header="null/undefined ไม่มีเมท็อด"
+ข้อมูลปฐมภูมิพิเศษ `null` กับ `undefined` ถือเป็นข้อยกเว้น ไม่มี "ออบเจ็กต์ wrapper" สำหรับค่าเหล่านี้ และก็ไม่มีเมท็อดอะไรด้วย แปลว่าพวกมันคือข้อมูลปฐมภูมิล้วนๆ ที่สุดเลยก็ว่าได้
 
-````warn header="null/undefined have no methods"
-The special primitives `null` and `undefined` are exceptions. They have no corresponding "wrapper objects" and provide no methods. In a sense, they are "the most primitive".
-
-An attempt to access a property of such value would give the error:
+การพยายามเข้าถึงพร็อพเพอร์ตี้ของค่าพวกนี้จะทำให้เกิด error:
 
 ```js run
 alert(null.test); // error
+```
 ````
 
-## Summary
+## สรุป
 
-- Primitives except `null` and `undefined` provide many helpful methods. We will study those in the upcoming chapters.
-- Formally, these methods work via temporary objects, but JavaScript engines are well tuned to optimize that internally, so they are not expensive to call.
+- ข้อมูลปฐมภูมิยกเว้น `null` และ `undefined` มีเมท็อดที่ใช้งานได้จำนวนมาก เราจะศึกษาเมท็อดเหล่านั้นในบทต่อๆ ไป
+- อย่างเป็นทางการแล้ว เมท็อดพวกนี้ทำงานผ่านออบเจ็กต์ชั่วคราว แต่เอ็นจิน JavaScript ได้รับการปรับแต่งอย่างดีเพื่อให้เกิดค่าใช้จ่ายในการเรียกใช้น้อยที่สุด
\ No newline at end of file
diff --git a/1-js/05-data-types/02-number/1-sum-interface/solution.md b/1-js/05-data-types/02-number/1-sum-interface/solution.md
index f2c81437d..4c0acbd5f 100644
--- a/1-js/05-data-types/02-number/1-sum-interface/solution.md
+++ b/1-js/05-data-types/02-number/1-sum-interface/solution.md
@@ -1,12 +1,12 @@
 
 
 ```js run demo
-let a = +prompt("The first number?", "");
-let b = +prompt("The second number?", "");
+let a = +prompt("ตัวเลขแรก?", "");
+let b = +prompt("ตัวเลขที่สอง?", "");
 
 alert( a + b );
 ```
 
-Note the unary plus `+` before `prompt`. It immediately converts the value to a number.
+สังเกตเครื่องหมายบวกเดี่ยว `+` หน้า `prompt` มันแปลงค่าเป็นตัวเลขทันที
 
-Otherwise, `a` and `b` would be string their sum would be their concatenation, that is: `"1" + "2" = "12"`.
\ No newline at end of file
+มิฉะนั้น `a` และ `b` จะเป็นสตริง และผลรวมของพวกมันจะเป็นการต่อสตริง เช่น: `"1" + "2" = "12"`
diff --git a/1-js/05-data-types/02-number/1-sum-interface/task.md b/1-js/05-data-types/02-number/1-sum-interface/task.md
index 780126640..ae16be5b6 100644
--- a/1-js/05-data-types/02-number/1-sum-interface/task.md
+++ b/1-js/05-data-types/02-number/1-sum-interface/task.md
@@ -2,10 +2,12 @@ importance: 5
 
 ---
 
-# Sum numbers from the visitor
+คุณต้องการให้ผมแปลโจทย์และคำอธิบายนี้เป็นภาษาไทยใช่ไหมครับ? ถ้าใช่ นี่คือคำแปล:
 
-Create a script that prompts the visitor to enter two numbers and then shows their sum.
+# รวมตัวเลขจากผู้เข้าชม
 
-[demo]
+สร้างสคริปต์ที่ขอให้ผู้เข้าชมป้อนตัวเลขสองตัว แล้วแสดงผลรวมของตัวเลขเหล่านั้น
 
-P.S. There is a gotcha with types.
+[สาธิต]
+
+ข้อควรระวัง: มีจุดที่ต้องระวังเกี่ยวกับประเภทข้อมูล
diff --git a/1-js/05-data-types/02-number/2-why-rounded-down/solution.md b/1-js/05-data-types/02-number/2-why-rounded-down/solution.md
index 4bcd74512..9e26f46d5 100644
--- a/1-js/05-data-types/02-number/2-why-rounded-down/solution.md
+++ b/1-js/05-data-types/02-number/2-why-rounded-down/solution.md
@@ -1,33 +1,36 @@
-Internally the decimal fraction `6.35` is an endless binary. As always in such cases, it is stored with a precision loss.
+ภายในระบบ เศษส่วนทศนิยม `6.35` เป็นเลขฐานสองที่ไม่มีที่สิ้นสุด เหมือนกับกรณีอื่นๆ ทั้งหมด มันถูกเก็บไว้โดยมีการสูญเสียความแม่นยำ
 
-Let's see:
+ลองดู:
 
 ```js run
 alert( 6.35.toFixed(20) ); // 6.34999999999999964473
 ```
 
-The precision loss can cause both increase and decrease of a number. In this particular case the number becomes a tiny bit less, that's why it rounded down.
+การสูญเสียความแม่นยำนี้สามารถทำให้ตัวเลขเพิ่มขึ้นหรือลดลงได้ ในกรณีนี้ตัวเลขกลายเป็นน้อยลงเล็กน้อย นั่นคือเหตุผลที่มันถูกปัดลง
 
-And what's for `1.35`?
+แล้ว `1.35` ล่ะ?
 
 ```js run
 alert( 1.35.toFixed(20) ); // 1.35000000000000008882
 ```
 
-Here the precision loss made the number a little bit greater, so it rounded up.
+ในกรณีนี้ การสูญเสียความแม่นยำทำให้ตัวเลขมากขึ้นเล็กน้อย ดังนั้นมันจึงถูกปัดขึ้น
 
-**How can we fix the problem with `6.35` if we want it to be rounded the right way?**
+**เราจะแก้ปัญหากับ `6.35` ได้อย่างไรถ้าเราต้องการให้มันถูกปัดเศษอย่างถูกต้อง?**
 
-We should bring it closer to an integer prior to rounding:
+เราควรทำให้มันใกล้กับจำนวนเต็มก่อนที่จะปัดเศษ:
 
 ```js run
 alert( (6.35 * 10).toFixed(20) ); // 63.50000000000000000000
 ```
 
-Note that `63.5` has no precision loss at all. That's because the decimal part `0.5` is actually `1/2`. Fractions divided by powers of `2` are exactly represented in the binary system, now we can round it:
-
+สังเกตว่า `63.5` ไม่มีการสูญเสียความแม่นยำเลย นั่นเป็นเพราะส่วนทศนิยม `0.5` จริงๆ แล้วคือ `1/2` เศษส่วนที่หารด้วยกำลังของ `2` จะถูกแสดงอย่างแม่นยำในระบบฐานสอง ตอนนี้เราสามารถปัดเศษมันได้:
 
 ```js run
+<<<<<<< HEAD
+alert( Math.round(6.35 * 10) / 10); // 6.35 -> 63.5 -> 64(ปัดเศษ) -> 6.4
+=======
 alert( Math.round(6.35 * 10) / 10 ); // 6.35 -> 63.5 -> 64(rounded) -> 6.4
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 ```
 
diff --git a/1-js/05-data-types/02-number/2-why-rounded-down/task.md b/1-js/05-data-types/02-number/2-why-rounded-down/task.md
index 568c26480..43a985eac 100644
--- a/1-js/05-data-types/02-number/2-why-rounded-down/task.md
+++ b/1-js/05-data-types/02-number/2-why-rounded-down/task.md
@@ -2,21 +2,20 @@ importance: 4
 
 ---
 
-# Why 6.35.toFixed(1) == 6.3?
+# ทำไม 6.35.toFixed(1) == 6.3?
 
-According to the documentation `Math.round` and `toFixed` both round to the nearest number: `0..4` lead down while `5..9` lead up.
+ตามเอกสารประกอบ ทั้ง `Math.round` และ `toFixed` ปัดเศษไปยังตัวเลขที่ใกล้ที่สุด: `0..4` ปัดลง ขณะที่ `5..9` ปัดขึ้น
 
-For instance:
+ตัวอย่างเช่น:
 
 ```js run
 alert( 1.35.toFixed(1) ); // 1.4
 ```
 
-In the similar example below, why is `6.35` rounded to `6.3`, not `6.4`?
+ในตัวอย่างที่คล้ายกันด้านล่าง ทำไม `6.35` ถูกปัดเศษเป็น `6.3` ไม่ใช่ `6.4`?
 
 ```js run
 alert( 6.35.toFixed(1) ); // 6.3
 ```
 
-How to round `6.35` the right way?
-
+จะปัดเศษ `6.35` ให้ถูกต้องได้อย่างไร?
\ No newline at end of file
diff --git a/1-js/05-data-types/02-number/3-repeat-until-number/solution.md b/1-js/05-data-types/02-number/3-repeat-until-number/solution.md
index 005116d17..21054ad29 100644
--- a/1-js/05-data-types/02-number/3-repeat-until-number/solution.md
+++ b/1-js/05-data-types/02-number/3-repeat-until-number/solution.md
@@ -1,10 +1,9 @@
-
 ```js run demo
 function readNumber() {
   let num;
 
   do {
-    num = prompt("Enter a number please?", 0);
+    num = prompt("กรุณาป้อนตัวเลข", 0);
   } while ( !isFinite(num) );
 
   if (num === null || num === '') return null;
@@ -12,12 +11,11 @@ function readNumber() {
   return +num;
 }
 
-alert(`Read: ${readNumber()}`);
+alert(`อ่านค่า: ${readNumber()}`);
 ```
 
-The solution is a little bit more intricate that it could be because we need to handle `null`/empty lines.
-
-So we actually accept the input until it is a "regular number". Both `null` (cancel) and empty line also fit that condition, because in numeric form they are `0`.
+วิธีแก้ปัญหานี้ค่อนข้างซับซ้อนกว่าที่ควรจะเป็นเล็กน้อย เพราะเราต้องจัดการกับ `null` และบรรทัดว่าง
 
-After we stopped, we need to treat `null` and empty line specially (return `null`), because converting them to a number would return `0`.
+ดังนั้นเราจึงยอมรับการป้อนข้อมูลจนกว่าจะเป็น "ตัวเลขปกติ" ทั้ง `null` (ยกเลิก) และบรรทัดว่างก็เข้าเงื่อนไขนี้ด้วย เพราะในรูปแบบตัวเลขพวกมันเป็น `0`
 
+หลังจากที่เราหยุด เราต้องจัดการกับ `null` และบรรทัดว่างเป็นพิเศษ (ส่งคืน `null`) เพราะการแปลงพวกมันเป็นตัวเลขจะส่งคืน `0`
diff --git a/1-js/05-data-types/02-number/3-repeat-until-number/task.md b/1-js/05-data-types/02-number/3-repeat-until-number/task.md
index 9b172fa8a..3b40b12f2 100644
--- a/1-js/05-data-types/02-number/3-repeat-until-number/task.md
+++ b/1-js/05-data-types/02-number/3-repeat-until-number/task.md
@@ -2,13 +2,12 @@ importance: 5
 
 ---
 
-# Repeat until the input is a number
+# ทำซ้ำจนกว่าจะได้รับข้อมูลเป็นตัวเลข
 
-Create a function `readNumber` which prompts for a number until the visitor enters a valid numeric value.
+สร้างฟังก์ชัน `readNumber` ที่ขอให้ป้อนตัวเลขจนกว่าผู้เข้าชมจะป้อนค่าตัวเลขที่ถูกต้อง
 
-The resulting value must be returned as a number.
+ค่าที่ได้ต้องถูกส่งคืนเป็นตัวเลข
 
-The visitor can also stop the process by entering an empty line or pressing "CANCEL". In that case, the function should return `null`.
-
-[demo]
+ผู้เข้าชมสามารถหยุดกระบวนการได้โดยการป้อนบรรทัดว่างหรือกด "CANCEL" ในกรณีนั้น ฟังก์ชันควรส่งคืน `null`
 
+[สาธิต]
\ No newline at end of file
diff --git a/1-js/05-data-types/02-number/4-endless-loop-error/solution.md b/1-js/05-data-types/02-number/4-endless-loop-error/solution.md
index 8bc55bd02..f77929e9f 100644
--- a/1-js/05-data-types/02-number/4-endless-loop-error/solution.md
+++ b/1-js/05-data-types/02-number/4-endless-loop-error/solution.md
@@ -1,6 +1,6 @@
-That's because `i` would never equal `10`.
+นั่นเป็นเพราะ `i` จะไม่มีวันเท่ากับ `10` พอดี
 
-Run it to see the *real* values of `i`:
+ลองรันโค้ดเพื่อดูค่าจริงๆ ของ `i`:
 
 ```js run
 let i = 0;
@@ -10,8 +10,13 @@ while (i < 11) {
 }
 ```
 
-None of them is exactly `10`.
+ไม่มีค่าใดที่เท่ากับ `10` พอดีเลย
 
-Such things happen because of the precision losses when adding fractions like `0.2`.
+สิ่งเหล่านี้เกิดขึ้นเนื่องจากการสูญเสียความแม่นยำเมื่อบวกเศษส่วนเช่น `0.2`
 
-Conclusion: evade equality checks when working with decimal fractions.
\ No newline at end of file
+คำอธิบายเพิ่มเติม:
+1. ในระบบคอมพิวเตอร์ เลขทศนิยมถูกเก็บในรูปแบบเลขฐานสอง ซึ่งไม่สามารถแสดงเศษส่วนบางตัว (เช่น 0.2) ได้อย่างแม่นยำ
+2. การบวก 0.2 ซ้ำๆ จะสะสมความคลาดเคลื่อนเล็กน้อยในแต่ละครั้ง
+3. เมื่อ `i` เข้าใกล้ 10 มันอาจจะมีค่าเช่น 9.999999999999998 หรือ 10.000000000000002 ซึ่งไม่เท่ากับ 10 พอดี
+
+บทสรุป: หลีกเลี่ยงการตรวจสอบความเท่ากันอย่างแม่นยำเมื่อทำงานกับเศษส่วนทศนิยม
\ No newline at end of file
diff --git a/1-js/05-data-types/02-number/4-endless-loop-error/task.md b/1-js/05-data-types/02-number/4-endless-loop-error/task.md
index 592ece31c..757b59359 100644
--- a/1-js/05-data-types/02-number/4-endless-loop-error/task.md
+++ b/1-js/05-data-types/02-number/4-endless-loop-error/task.md
@@ -2,9 +2,9 @@ importance: 4
 
 ---
 
-# An occasional infinite loop
+# ลูปอนันต์ที่ไม่คาดคิด
 
-This loop is infinite. It never ends. Why?
+ลูปนี้เป็นลูปอนันต์ มันไม่มีวันจบ ทำไม?
 
 ```js
 let i = 0;
diff --git a/1-js/05-data-types/02-number/8-random-min-max/solution.md b/1-js/05-data-types/02-number/8-random-min-max/solution.md
index 8736c3d56..a5da25540 100644
--- a/1-js/05-data-types/02-number/8-random-min-max/solution.md
+++ b/1-js/05-data-types/02-number/8-random-min-max/solution.md
@@ -1,11 +1,11 @@
-We need to "map" all values from the interval 0..1 into values from `min` to `max`.
+เราต้องการ "แมป" ค่าทั้งหมดจากช่วง 0..1 ไปเป็นค่าจาก `min` ถึง `max`
 
-That can be done in two stages:
+สามารถทำได้ใน 2 ขั้นตอน:
 
-1. If we multiply a random number from 0..1 by `max-min`, then the interval of possible values increases `0..1` to `0..max-min`.
-2. Now if we add `min`, the possible interval becomes from `min` to `max`.
+1. ถ้าเราคูณตัวเลขสุ่มจาก 0..1 ด้วย `max-min` ช่วงของค่าที่เป็นไปได้จะขยายจาก `0..1` เป็น `0..max-min`
+2. จากนั้นถ้าเราบวก `min` ช่วงที่เป็นไปได้จะกลายเป็นจาก `min` ถึง `max`
 
-The function:
+ฟังก์ชัน:
 
 ```js run
 function random(min, max) {
diff --git a/1-js/05-data-types/02-number/8-random-min-max/task.md b/1-js/05-data-types/02-number/8-random-min-max/task.md
index 7037cfcbb..dac208fdd 100644
--- a/1-js/05-data-types/02-number/8-random-min-max/task.md
+++ b/1-js/05-data-types/02-number/8-random-min-max/task.md
@@ -2,13 +2,13 @@ importance: 2
 
 ---
 
-# A random number from min to max
+# สุ่มตัวเลขจาก min ถึง max
 
-The built-in function `Math.random()` creates a random value from `0` to `1` (not including `1`).
+ฟังก์ชันในตัว `Math.random()` สร้างค่าสุ่มจาก `0` ถึง `1` (ไม่รวม `1`)
 
-Write the function `random(min, max)` to generate a random floating-point number from `min` to `max` (not including `max`).
+เขียนฟังก์ชัน `random(min, max)` เพื่อสร้างตัวเลขทศนิยมแบบสุ่มจาก `min` ถึง `max` (ไม่รวม `max`)
 
-Examples of its work:
+ตัวอย่างการทำงาน:
 
 ```js
 alert( random(1, 5) ); // 1.2345623452
diff --git a/1-js/05-data-types/02-number/9-random-int-min-max/solution.md b/1-js/05-data-types/02-number/9-random-int-min-max/solution.md
index 0950ff812..eba1eac5b 100644
--- a/1-js/05-data-types/02-number/9-random-int-min-max/solution.md
+++ b/1-js/05-data-types/02-number/9-random-int-min-max/solution.md
@@ -1,6 +1,6 @@
-# The simple but wrong solution
+# วิธีแก้ที่ง่ายแต่ไม่ถูกต้อง
 
-The simplest, but wrong solution would be to generate a value from `min` to `max` and round it:
+วิธีที่ง่ายที่สุดแต่ไม่ถูกต้องคือการสร้างค่าจาก `min` ถึง `max` แล้วปัดเศษ:
 
 ```js run
 function randomInteger(min, max) {
@@ -11,56 +11,52 @@ function randomInteger(min, max) {
 alert( randomInteger(1, 3) );
 ```
 
-The function works, but it is incorrect. The probability to get edge values `min` and `max` is two times less than any other.
+ฟังก์ชันนี้ทำงานได้ แต่ไม่ถูกต้อง โอกาสที่จะได้ค่าขอบ `min` และ `max` น้อยกว่าค่าอื่นๆ สองเท่า
 
-If you run the example above many times, you would easily see that `2` appears the most often.
+ถ้าคุณรันตัวอย่างข้างบนหลายๆ ครั้ง คุณจะเห็นว่า `2` ปรากฏบ่อยที่สุด
 
-That happens because `Math.round()` gets random numbers from the interval `1..3` and rounds them as follows:
+นี่เกิดขึ้นเพราะ `Math.round()` รับตัวเลขสุ่มจากช่วง `1..3` และปัดเศษดังนี้:
 
 ```js no-beautify
-values from 1    ... to 1.4999999999  become 1
-values from 1.5  ... to 2.4999999999  become 2
-values from 2.5  ... to 2.9999999999  become 3
+ค่าจาก 1    ... ถึง 1.4999999999  กลายเป็น 1
+ค่าจาก 1.5  ... ถึง 2.4999999999  กลายเป็น 2
+ค่าจาก 2.5  ... ถึง 2.9999999999  กลายเป็น 3
 ```
 
-Now we can clearly see that `1` gets twice less values than `2`. And the same with `3`.
+เราเห็นชัดว่า `1` ได้ค่าน้อยกว่า `2` สองเท่า และเช่นเดียวกันกับ `3`
 
-# The correct solution
+# วิธีแก้ที่ถูกต้อง
 
-There are many correct solutions to the task. One of them is to adjust interval borders. To ensure the same intervals, we can generate values from `0.5 to 3.5`, thus adding the required probabilities to the edges:
+มีหลายวิธีที่ถูกต้องสำหรับโจทย์นี้ หนึ่งในนั้นคือการปรับขอบเขตของช่วง เพื่อให้แน่ใจว่าช่วงเท่ากัน เราสามารถสร้างค่าจาก `0.5 ถึง 3.5` เพื่อเพิ่มโอกาสที่ต้องการให้กับขอบ:
 
 ```js run
-*!*
 function randomInteger(min, max) {
-  // now rand is from  (min-0.5) to (max+0.5)
+  // ตอนนี้ rand อยู่ระหว่าง (min-0.5) ถึง (max+0.5)
   let rand = min - 0.5 + Math.random() * (max - min + 1);
   return Math.round(rand);
 }
-*/!*
 
 alert( randomInteger(1, 3) );
 ```
 
-An alternative way could be to use `Math.floor` for a random number from `min` to `max+1`:
+อีกวิธีหนึ่งคือใช้ `Math.floor` สำหรับตัวเลขสุ่มจาก `min` ถึง `max+1`:
 
 ```js run
-*!*
 function randomInteger(min, max) {
-  // here rand is from min to (max+1)
+  // ตรงนี้ rand อยู่ระหว่าง min ถึง (max+1)
   let rand = min + Math.random() * (max + 1 - min);
   return Math.floor(rand);
 }
-*/!*
 
 alert( randomInteger(1, 3) );
 ```
 
-Now all intervals are mapped this way:
+ตอนนี้ทุกช่วงถูกแมปดังนี้:
 
 ```js no-beautify
-values from 1  ... to 1.9999999999  become 1
-values from 2  ... to 2.9999999999  become 2
-values from 3  ... to 3.9999999999  become 3
+ค่าจาก 1  ... ถึง 1.9999999999  กลายเป็น 1
+ค่าจาก 2  ... ถึง 2.9999999999  กลายเป็น 2
+ค่าจาก 3  ... ถึง 3.9999999999  กลายเป็น 3
 ```
 
-All intervals have the same length, making the final distribution uniform.
+ทุกช่วงมีความยาวเท่ากัน ทำให้การกระจายสุดท้ายสม่ำเสมอ
diff --git a/1-js/05-data-types/02-number/9-random-int-min-max/task.md b/1-js/05-data-types/02-number/9-random-int-min-max/task.md
index 4ac7b5fbb..7e0af57be 100644
--- a/1-js/05-data-types/02-number/9-random-int-min-max/task.md
+++ b/1-js/05-data-types/02-number/9-random-int-min-max/task.md
@@ -2,14 +2,13 @@ importance: 2
 
 ---
 
-# A random integer from min to max
+# สุ่มจำนวนเต็มจาก min ถึง max
 
-Create a function `randomInteger(min, max)` that generates a random *integer* number from `min` to `max` including both `min` and `max` as possible values.
+สร้างฟังก์ชัน `randomInteger(min, max)` ที่สร้างตัวเลขจำนวนเต็มสุ่มจาก `min` ถึง `max` โดยรวมทั้ง `min` และ `max` เป็นค่าที่เป็นไปได้ด้วย
 
-Any number from the interval `min..max` must appear with the same probability.
+ตัวเลขใดๆ จากช่วง `min..max` ต้องปรากฏด้วยความน่าจะเป็นเท่ากัน
 
-
-Examples of its work:
+ตัวอย่างการทำงาน:
 
 ```js
 alert( randomInteger(1, 5) ); // 1
@@ -17,4 +16,4 @@ alert( randomInteger(1, 5) ); // 3
 alert( randomInteger(1, 5) ); // 5
 ```
 
-You can use the solution of the [previous task](info:task/random-min-max) as the base.
+คุณสามารถใช้วิธีแก้ของ [โจทย์ก่อนหน้า](info:task/random-min-max) เป็นพื้นฐานได้
diff --git a/1-js/05-data-types/02-number/article.md b/1-js/05-data-types/02-number/article.md
index 8e41f673d..1c4c1908e 100644
--- a/1-js/05-data-types/02-number/article.md
+++ b/1-js/05-data-types/02-number/article.md
@@ -1,101 +1,122 @@
-# Numbers
+# ตัวเลข
 
-In modern JavaScript, there are two types of numbers:
+ในจาวาสคริปต์ยุคใหม่ มีตัวเลขอยู่สองประเภท:
 
+<<<<<<< HEAD
+1. ตัวเลขทั่วไปในจาวาสคริปต์ถูกเก็บในรูปแบบ 64 บิต [IEEE-754](https://en.wikipedia.org/wiki/IEEE_754-2008_revision) หรือที่เรียกว่า "จำนวนทศนิยมความแม่นยำสองเท่า" ตัวเลขเหล่านี้เป็นตัวเลขที่เราใช้บ่อยที่สุด และเราจะพูดถึงในบทนี้
+
+2. BigInt ใช้แทนจำนวนเต็มที่มีความยาวไม่จำกัด บางครั้งจำเป็นต้องใช้เพราะตัวเลขทั่วไปไม่สามารถเกิน <code>2<sup>53</sup></code> หรือน้อยกว่า <code>-2<sup>53</sup></code> ได้อย่างปลอดภัย เนื่องจาก BigInt ใช้ในบางกรณีพิเศษเท่านั้น เราจึงแยกไว้ในบทเฉพาะ <info:bigint>
+=======
 1. Regular numbers in JavaScript are stored in 64-bit format [IEEE-754](https://en.wikipedia.org/wiki/IEEE_754), also known as "double precision floating point numbers". These are numbers that we're using most of the time, and we'll talk about them in this chapter.
 
 2. BigInt numbers represent integers of arbitrary length. They are sometimes needed because a regular integer number can't safely exceed <code>(2<sup>53</sup>-1)</code> or be less than <code>-(2<sup>53</sup>-1)</code>, as we mentioned earlier in the chapter <info:types>. As bigints are used in a few special areas, we devote them to a special chapter <info:bigint>.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-So here we'll talk about regular numbers. Let's expand our knowledge of them.
+ในบทนี้เราจะพูดถึงตัวเลขทั่วไป มาดูรายละเอียดเพิ่มเติมกัน
 
-## More ways to write a number
+## วิธีเขียนตัวเลขแบบอื่นๆ
 
-Imagine we need to write 1 billion. The obvious way is:
+สมมติว่าเราต้องเขียนหนึ่งพันล้าน วิธีที่ชัดเจนคือ:
 
 ```js
 let billion = 1000000000;
 ```
 
-We also can use underscore `_` as the separator:
+แต่ในชีวิตจริง เราอาจสับสนกับจำนวนศูนย์ได้ง่าย ในภาษาไทย เรามักใช้คำว่า "ล้าน" "สิบล้าน" "ร้อยล้าน" เพื่อช่วยในการอ่าน ในจาวาสคริปต์ เราสามารถใช้เครื่องหมายขีดล่าง `_` เป็นตัวคั่นได้:
 
 ```js
 let billion = 1_000_000_000;
 ```
 
+<<<<<<< HEAD
+ในที่นี้ เครื่องหมายขีดล่าง `_` ทำหน้าที่เป็น "น้ำตาลทางไวยากรณ์" ช่วยให้ตัวเลขอ่านง่ายขึ้น เครื่องมือจาวาสคริปต์จะมองข้าม `_` ระหว่างตัวเลข ดังนั้นจึงเป็นตัวเลขหนึ่งพันล้านเหมือนกันกับข้างบน
+=======
 Here the underscore `_` plays the role of the "[syntactic sugar](https://en.wikipedia.org/wiki/Syntactic_sugar)", it makes the number more readable. The JavaScript engine simply ignores `_` between digits, so it's exactly the same one billion as above.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-In real life though, we try to avoid writing long sequences of zeroes. We're too lazy for that. We'll try to write something like `"1bn"` for a billion or `"7.3bn"` for 7 billion 300 million. The same is true for most large numbers.
+ในชีวิตจริง เรามักหลีกเลี่ยงการเขียนเลขศูนย์ต่อกันยาวๆ เพราะขี้เกียจ เรามักเขียนแบบย่อ เช่น `"1พันล้าน"` สำหรับหนึ่งพันล้าน หรือ `"7.3พันล้าน"` สำหรับเจ็ดพันสามร้อยล้าน เช่นเดียวกับตัวเลขใหญ่ส่วนมาก
 
-In JavaScript, we can shorten a number by appending the letter `"e"` to it and specifying the zeroes count:
+ในจาวาสคริปต์ เราสามารถย่อตัวเลขโดยเพิ่มตัวอักษร `"e"` ต่อท้ายและระบุจำนวนศูนย์:
 
 ```js run
-let billion = 1e9;  // 1 billion, literally: 1 and 9 zeroes
+let billion = 1e9;  // 1 พันล้าน คือ 1 ตามด้วยศูนย์ 9 ตัว
 
-alert( 7.3e9 );  // 7.3 billions (same as 7300000000 or 7_300_000_000)
+alert( 7.3e9 );  // 7.3 พันล้าน (เท่ากับ 7300000000 หรือ 7_300_000_000)
 ```
 
-In other words, `e` multiplies the number by `1` with the given zeroes count.
+กล่าวคือ `e` คูณตัวเลขด้วย 1 ตามด้วยจำนวนศูนย์ที่กำหนด
 
 ```js
-1e3 === 1 * 1000; // e3 means *1000
-1.23e6 === 1.23 * 1000000; // e6 means *1000000
+1e3 === 1 * 1000; // e3 หมายถึง *1000
+1.23e6 === 1.23 * 1000000; // e6 หมายถึง *1000000
 ```
 
+<<<<<<< HEAD
+ทีนี้มาเขียนตัวเลขที่เล็กมากๆ กัน สมมติว่า 1 ไมโครวินาที (หนึ่งในล้านของวินาที):
+=======
 Now let's write something very small. Say, 1 microsecond (one-millionth of a second):
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
 ```js
 let mсs = 0.000001;
 ```
 
+<<<<<<< HEAD
+เช่นเดียวกับก่อนหน้านี้ การใช้ `"e"` ช่วยได้ ถ้าเราไม่อยากเขียนศูนย์เยอะๆ เราก็เขียนแบบนี้ได้:
+
+```js
+let mcs = 1e-6; // ศูนย์หกตัวทางซ้ายของ 1
+=======
 Just like before, using `"e"` can help. If we'd like to avoid writing the zeroes explicitly, we could write the same as:
 
 ```js
 let mcs = 1e-6; // five zeroes to the left from 1
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 ```
 
-If we count the zeroes in `0.000001`, there are 6 of them. So naturally it's `1e-6`.
+ถ้านับจำนวนศูนย์ใน `0.000001` จะมี 6 ตัว ดังนั้นจึงเป็น `1e-6`
 
-In other words, a negative number after `"e"` means a division by 1 with the given number of zeroes:
+กล่าวอีกนัยหนึ่ง ตัวเลขลบหลัง `"e"` หมายถึงการหารด้วย 1 ตามด้วยจำนวนศูนย์ที่กำหนด:
 
 ```js
-// -3 divides by 1 with 3 zeroes
+// -3 หมายถึงหารด้วย 1000 (3 ศูนย์)
 1e-3 === 1 / 1000; // 0.001
 
-// -6 divides by 1 with 6 zeroes
+// -6 หมายถึงหารด้วย 1,000,000 (6 ศูนย์)
 1.23e-6 === 1.23 / 1000000; // 0.00000123
 
 // an example with a bigger number
 1234e-2 === 1234 / 100; // 12.34, decimal point moves 2 times
 ```
 
-### Hex, binary and octal numbers
+### เลขฐานสิบหก ฐานสอง และฐานแปด
 
-[Hexadecimal](https://en.wikipedia.org/wiki/Hexadecimal) numbers are widely used in JavaScript to represent colors, encode characters, and for many other things. So naturally, there exists a shorter way to write them: `0x` and then the number.
+[เลขฐานสิบหก](https://en.wikipedia.org/wiki/Hexadecimal) ใช้กันมากในจาวาสคริปต์ เพื่อแสดงสี เข้ารหัสตัวอักษร และอื่นๆ อีกมาก จึงมีวิธีเขียนแบบย่อ คือใช้ `0x` นำหน้าตัวเลข
 
-For instance:
+ตัวอย่าง:
 
 ```js run
 alert( 0xff ); // 255
-alert( 0xFF ); // 255 (the same, case doesn't matter)
+alert( 0xFF ); // 255 (ไม่ต่างกัน ตัวพิมพ์เล็กหรือใหญ่ไม่สำคัญ)
 ```
 
-Binary and octal numeral systems are rarely used, but also supported using the `0b` and `0o` prefixes:
+ระบบเลขฐานสองและฐานแปดใช้น้อย แต่ก็รองรับ โดยใช้คำนำหน้า `0b` และ `0o`:
 
 
 ```js run
-let a = 0b11111111; // binary form of 255
-let b = 0o377; // octal form of 255
+let a = 0b11111111; // รูปแบบเลขฐานสองของ 255
+let b = 0o377; // รูปแบบเลขฐานแปดของ 255
 
-alert( a == b ); // true, the same number 255 at both sides
+alert( a == b ); // จริง เป็นเลข 255 เหมือนกันทั้งสองฝั่ง
 ```
 
-There are only 3 numeral systems with such support. For other numeral systems, we should use the function `parseInt` (which we will see later in this chapter).
+มีแค่ 3 ระบบเลขที่รองรับแบบนี้ สำหรับระบบเลขอื่นๆ เราควรใช้ฟังก์ชัน `parseInt` (ซึ่งเราจะเห็นในภายหลังในบทนี้)
 
 ## toString(base)
 
-The method `num.toString(base)` returns a string representation of `num` in the numeral system with the given `base`.
+วิธี `num.toString(base)` คืนค่าสตริงที่แสดง `num` ในระบบเลขฐาน `base`
 
-For example:
+ตัวอย่าง:
 ```js run
 let num = 255;
 
@@ -103,46 +124,64 @@ alert( num.toString(16) );  // ff
 alert( num.toString(2) );   // 11111111
 ```
 
+<<<<<<< HEAD
+`base` อาจมีค่าตั้งแต่ `2` ถึง `36` โดยค่าเริ่มต้นคือ `10`
+=======
 The `base` can vary from `2` to `36`. By default, it's `10`.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-Common use cases for this are:
+กรณีใช้งานทั่วไปคือ:
 
+<<<<<<< HEAD
+- **base=16** ใช้สำหรับสีในรูปแบบเลขฐานสิบหก, เข้ารหัสตัวอักษร ฯลฯ ตัวเลขอาจเป็น `0..9` หรือ `A..F`
+- **base=2** ส่วนใหญ่ใช้สำหรับการแก้จุดบกพร่องของการดำเนินการระดับบิต ตัวเลขอาจเป็น `0` หรือ `1`
+- **base=36** เป็นค่าสูงสุด ตัวเลขอาจเป็น `0..9` หรือ `A..Z` ตัวอักษรละตินทั้งหมดถูกใช้แทนตัวเลข กรณีที่สนุกแต่มีประโยชน์สำหรับ `36` คือเมื่อเราต้องการย่อตัวระบุตัวเลขที่ยาวให้สั้นลง เช่น ทำ URL ย่อ เราสามารถแสดงมันในระบบเลขฐาน `36` ได้ง่ายๆ:
+=======
 - **base=16** is used for hex colors, character encodings etc, digits can be `0..9` or `A..F`.
 - **base=2** is mostly for debugging bitwise operations, digits can be `0` or `1`.
 - **base=36** is the maximum, digits can be `0..9` or `A..Z`. The whole Latin alphabet is used to represent a number. A funny, but useful case for `36` is when we need to turn a long numeric identifier into something shorter, for example, to make a short url. Can simply represent it in the numeral system with base `36`:
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
     ```js run
     alert( 123456..toString(36) ); // 2n9c
     ```
 
-```warn header="Two dots to call a method"
-Please note that two dots in `123456..toString(36)` is not a typo. If we want to call a method directly on a number, like `toString` in the example above, then we need to place two dots `..` after it.
+```warn header="จุดสองจุดเพื่อเรียกเมธอด"
+โปรดสังเกตว่าจุดสองจุดใน `123456..toString(36)` ไม่ใช่การพิมพ์ผิด ถ้าเราต้องการเรียกเมธอดโดยตรงกับตัวเลข เช่น `toString` ในตัวอย่างข้างต้น เราต้องใส่จุดสองจุด `..` หลังตัวเลข
 
+<<<<<<< HEAD
+ถ้าเราใส่จุดเดียว: `123456.toString(36)` จะเกิดข้อผิดพลาด เพราะไวยากรณ์จาวาสคริปต์เข้าใจว่าส่วนทศนิยมอยู่หลังจุดแรก และถ้าเราใส่จุดอีกจุด จาวาสคริปต์จะเข้าใจว่าส่วนทศนิยมว่างเปล่าและตามด้วยเมธอด
+=======
 If we placed a single dot: `123456.toString(36)`, then there would be an error, because JavaScript syntax implies the decimal part after the first dot. And if we place one more dot, then JavaScript knows that the decimal part is empty and now uses the method.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-Also could write `(123456).toString(36)`.
+เราสามารถเขียน `(123456).toString(36)` ได้เช่นกัน
 
 ```
 
-## Rounding
+## การปัดเศษ
 
-One of the most used operations when working with numbers is rounding.
+การดำเนินการที่ใช้บ่อยที่สุดเมื่อทำงานกับตัวเลขคือการปัดเศษ
 
-There are several built-in functions for rounding:
+มีฟังก์ชันในตัวหลายตัวสำหรับการปัดเศษ:
 
 `Math.floor`
-: Rounds down: `3.1` becomes `3`, and `-1.1` becomes `-2`.
+: ปัดลง: `3.1` เป็น `3`, `-1.1` เป็น `-2`
 
 `Math.ceil`
-: Rounds up: `3.1` becomes `4`, and `-1.1` becomes `-1`.
+: ปัดขึ้น: `3.1` เป็น `4`, `-1.1` เป็น `-1`
 
 `Math.round`
+<<<<<<< HEAD
+: ปัดเศษไปยังจำนวนเต็มที่ใกล้ที่สุด: `3.1` เป็น `3`, `3.6` เป็น `4`, กรณีกึ่งกลาง `3.5` ปัดขึ้นเป็น `4` เช่นกัน
+=======
 : Rounds to the nearest integer: `3.1` becomes `3`, `3.6` becomes `4`. In the middle cases `3.5` rounds up to `4`, and `-3.5` rounds up to `-3`.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-`Math.trunc` (not supported by Internet Explorer)
-: Removes anything after the decimal point without rounding: `3.1` becomes `3`, `-1.1` becomes `-1`.
+`Math.trunc` (ไม่รองรับใน Internet Explorer)
+: ตัดส่วนทศนิยมทิ้งโดยไม่ปัดเศษ: `3.1` เป็น `3`, `-1.1` เป็น `-1`
 
-Here's the table to summarize the differences between them:
+ตารางสรุปความแตกต่างระหว่างฟังก์ชันเหล่านี้:
 
 |   | `Math.floor` | `Math.ceil` | `Math.round` | `Math.trunc` |
 |---|---------|--------|---------|---------|
@@ -154,76 +193,106 @@ Here's the table to summarize the differences between them:
 |`-1.6`|  `-2`    |   `-1`  |    `-2`  |   `-1`   |
 
 
-These functions cover all of the possible ways to deal with the decimal part of a number. But what if we'd like to round the number to `n-th` digit after the decimal?
+ฟังก์ชันเหล่านี้ครอบคลุมวิธีการจัดการกับส่วนทศนิยมของตัวเลขทั้งหมด แต่ถ้าเราต้องการปัดเศษตัวเลขไปยังตำแหน่งทศนิยมที่ `n` ล่ะ?
+
+เช่น เรามี `1.2345` และต้องการปัดเศษให้เหลือ 2 ตำแหน่งทศนิยม เป็น `1.23`
 
-For instance, we have `1.2345` and want to round it to 2 digits, getting only `1.23`.
+มีสองวิธีในการทำเช่นนี้:
 
-There are two ways to do so:
+1. คูณและหาร
 
-1. Multiply-and-divide.
+    เช่น เพื่อปัดเศษตัวเลขไปยังตำแหน่งทศนิยมที่ 2 เราสามารถคูณตัวเลขด้วย `100` (หรือกำลังของ 10 ที่มากกว่า) เรียกใช้ฟังก์ชันปัดเศษ แล้วหารกลับ
 
+<<<<<<< HEAD
+=======
     For example, to round the number to the 2nd digit after the decimal, we can multiply the number by `100`, call the rounding function and then divide it back.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
     ```js run
     let num = 1.23456;
 
     alert( Math.round(num * 100) / 100 ); // 1.23456 -> 123.456 -> 123 -> 1.23
     ```
 
-2. The method [toFixed(n)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toFixed) rounds the number to `n` digits after the point and returns a string representation of the result.
+2. วิธี [toFixed(n)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toFixed) ปัดเศษตัวเลขไปยัง `n` ตำแหน่งหลังจุดทศนิยมและคืนค่าเป็นสตริง
 
     ```js run
     let num = 12.34;
     alert( num.toFixed(1) ); // "12.3"
     ```
 
-    This rounds up or down to the nearest value, similar to `Math.round`:
+    วิธีนี้ปัดขึ้นหรือลงไปยังค่าที่ใกล้ที่สุด คล้ายกับ `Math.round`:
 
     ```js run
     let num = 12.36;
     alert( num.toFixed(1) ); // "12.4"
     ```
 
+<<<<<<< HEAD
+    โปรดทราบว่าผลลัพธ์ของ `toFixed` เป็นสตริง หากส่วนทศนิยมสั้นกว่าที่ต้องการ จะเพิ่มศูนย์ต่อท้าย:
+=======
     Please note that the result of `toFixed` is a string. If the decimal part is shorter than required, zeroes are appended to the end:
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
     ```js run
     let num = 12.34;
-    alert( num.toFixed(5) ); // "12.34000", added zeroes to make exactly 5 digits
+    alert( num.toFixed(5) ); // "12.34000", เพิ่มศูนย์เพื่อให้ครบ 5 หลัก
     ```
 
+<<<<<<< HEAD
+    เราสามารถแปลงเป็นตัวเลขโดยใช้เครื่องหมายบวกเดี่ยวหรือเรียก `Number()`: `+num.toFixed(5)`
+=======
     We can convert it to a number using the unary plus or a `Number()` call, e.g. write `+num.toFixed(5)`.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-## Imprecise calculations
+## การคำนวณที่ไม่แม่นยำ
 
+<<<<<<< HEAD
+ภายใน ตัวเลขถูกเก็บในรูปแบบ 64 บิต [IEEE-754](https://en.wikipedia.org/wiki/IEEE_754-2008_revision) มีบิต 64 บิตเพื่อเก็บตัวเลข: 52 บิตใช้เก็บตัวเลข, 11 บิตเก็บตำแหน่งของจุดทศนิยม (เป็นศูนย์สำหรับจำนวนเต็ม) และ 1 บิตสำหรับเครื่องหมาย
+
+ถ้าตัวเลขใหญ่เกินไป อาจล้นพื้นที่เก็บข้อมูล 64 บิต ทำให้ได้ค่าอนันต์:
+=======
 Internally, a number is represented in 64-bit format [IEEE-754](https://en.wikipedia.org/wiki/IEEE_754), so there are exactly 64 bits to store a number: 52 of them are used to store the digits, 11 of them store the position of the decimal point, and 1 bit is for the sign.
 
 If a number is really huge, it may overflow the 64-bit storage and become a special numeric value `Infinity`:
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
 ```js run
 alert( 1e500 ); // Infinity
 ```
 
-What may be a little less obvious, but happens quite often, is the loss of precision.
+สิ่งที่อาจไม่ชัดเจนนัก แต่เกิดขึ้นบ่อย คือการสูญเสียความแม่นยำ
 
+<<<<<<< HEAD
+พิจารณาการทดสอบนี้ (ที่ให้ผลเป็นเท็จ):
+=======
 Consider this (falsy!) equality test:
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
 ```js run
-alert( 0.1 + 0.2 == 0.3 ); // *!*false*/!*
+alert( 0.1 + 0.2 == 0.3 ); // เท็จ
 ```
 
-That's right, if we check whether the sum of `0.1` and `0.2` is `0.3`, we get `false`.
+ถูกต้อง ถ้าเราตรวจสอบว่าผลรวมของ `0.1` และ `0.2` เท่ากับ `0.3` เราจะได้ `เท็จ`
 
-Strange! What is it then if not `0.3`?
+แปลก! แล้วมันคืออะไรถ้าไม่ใช่ `0.3`?
 
 ```js run
 alert( 0.1 + 0.2 ); // 0.30000000000000004
 ```
 
+<<<<<<< HEAD
+โอ้! มีผลกระทบมากกว่าการเปรียบเทียบที่ไม่ถูกต้อง ลองนึกภาพว่าคุณกำลังทำเว็บไซต์ขายของออนไลน์ และลูกค้าใส่สินค้ามูลค่า `฿10` และ `฿20` ลงในตะกร้า ยอดรวมจะเป็น `฿30.000000000000004` ซึ่งจะทำให้ทุกคนแปลกใจ
+=======
 Ouch! Imagine you're making an e-shopping site and the visitor puts `$0.10` and `$0.20` goods into their cart. The order total will be `$0.30000000000000004`. That would surprise anyone.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-But why does this happen?
+แต่ทำไมถึงเกิดเรื่องนี้ขึ้น?
 
-A number is stored in memory in its binary form, a sequence of bits - ones and zeroes. But fractions like `0.1`, `0.2` that look simple in the decimal numeric system are actually unending fractions in their binary form.
+ตัวเลขถูกเก็บในหน่วยความจำในรูปแบบไบนารี เป็นลำดับของบิต 0 และ 1 แต่เศษส่วนเช่น `0.1`, `0.2` ที่ดูง่ายในระบบเลขฐานสิบ จริงๆ แล้วเป็นเศษส่วนไม่รู้จบในระบบไบนารี
 
+<<<<<<< HEAD
+กล่าวคือ `0.1` คืออะไร? มันคือ 1 หาร 10 หรือ `1/10` ในระบบเลขฐานสิบ ตัวเลขแบบนี้แสดงได้ง่าย เปรียบเทียบกับ 1 หาร 3 หรือ `1/3` ซึ่งเป็นเศษส่วนไม่รู้จบ `0.33333(3)`
+=======
 ```js run
 alert(0.1.toString(2)); // 0.0001100110011001100110011001100110011001100110011001101
 alert(0.2.toString(2)); // 0.001100110011001100110011001100110011001100110011001101
@@ -231,117 +300,141 @@ alert((0.1 + 0.2).toString(2)); // 0.0100110011001100110011001100110011001100110
 ```
 
 What is `0.1`? It is one divided by ten `1/10`, one-tenth. In the decimal numeral system, such numbers are easily representable. Compare it to one-third: `1/3`. It becomes an endless fraction `0.33333(3)`.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-So, division by powers `10` is guaranteed to work well in the decimal system, but division by `3` is not. For the same reason, in the binary numeral system, the division by powers of `2` is guaranteed to work, but `1/10` becomes an endless binary fraction.
+ดังนั้น การหารด้วยกำลังของ 10 รับประกันว่าจะทำงานได้ดีในระบบฐานสิบ แต่การหารด้วย 3 ไม่ใช่ ด้วยเหตุผลเดียวกัน ในระบบไบนารี การหารด้วยกำลังของ 2 รับประกันว่าจะทำงานได้ แต่ `1/10` กลายเป็นเศษส่วนไบนารีไม่รู้จบ
 
-There's just no way to store *exactly 0.1* or *exactly 0.2* using the binary system, just like there is no way to store one-third as a decimal fraction.
+ไม่มีทางเก็บ *0.1 หรือ 0.2 อย่างแม่นยำ* โดยใช้ระบบไบนารี เช่นเดียวกับที่ไม่มีทางเก็บหนึ่งส่วนสามเป็นเศษส่วนทศนิยมได้อย่างแม่นยำ
 
-The numeric format IEEE-754 solves this by rounding to the nearest possible number. These rounding rules normally don't allow us to see that "tiny precision loss", but it exists.
+รูปแบบตัวเลข IEEE-754 แก้ปัญหานี้โดยปัดเศษไปยังตัวเลขที่ใกล้ที่สุดที่เป็นไปได้ กฎการปัดเศษเหล่านี้ปกติไม่ให้เราเห็น "การสูญเสียความแม่นยำเล็กน้อย" นั้น แต่มันมีอยู่
 
-We can see this in action:
+เราสามารถเห็นสิ่งนี้ในการทำงาน:
 ```js run
 alert( 0.1.toFixed(20) ); // 0.10000000000000000555
 ```
 
-And when we sum two numbers, their "precision losses" add up.
+และเมื่อเรารวมสองตัวเลข "การสูญเสียความแม่นยำ" ของพวกมันจะรวมกัน
 
-That's why `0.1 + 0.2` is not exactly `0.3`.
+นั่นคือเหตุผลที่ `0.1 + 0.2` ไม่เท่ากับ `0.3` อย่างแม่นยำ
 
-```smart header="Not only JavaScript"
-The same issue exists in many other programming languages.
+```smart header="ไม่ใช่แค่จาวาสคริปต์"
+ปัญหาเดียวกันนี้มีอยู่ในภาษาโปรแกรมอื่นๆ หลายภาษา
 
+<<<<<<< HEAD
+PHP, Java, C, Perl, Ruby ให้ผลลัพธ์เดียวกัน เพราะพวกมันใช้รูปแบบตัวเลขเดียวกัน
+=======
 PHP, Java, C, Perl, and Ruby give exactly the same result, because they are based on the same numeric format.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 ```
 
-Can we work around the problem? Sure, the most reliable method is to round the result with the help of a method [toFixed(n)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toFixed):
+เราสามารถแก้ไขปัญหานี้ได้ไหม? แน่นอน วิธีที่น่าเชื่อถือที่สุดคือปัดเศษผลลัพธ์โดยใช้วิธี [toFixed(n)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toFixed):
 
 ```js run
 let sum = 0.1 + 0.2;
 alert( sum.toFixed(2) ); // "0.30"
 ```
 
-Please note that `toFixed` always returns a string. It ensures that it has 2 digits after the decimal point. That's actually convenient if we have an e-shopping and need to show `$0.30`. For other cases, we can use the unary plus to coerce it into a number:
+โปรดทราบว่า `toFixed` คืนค่าเป็นสตริงเสมอ มันรับประกันว่าจะมี 2 ตำแหน่งหลังจุดทศนิยม ซึ่งสะดวกถ้าเรามีร้านค้าออนไลน์และต้องแสดง `฿0.30` สำหรับกรณีอื่นๆ เราสามารถใช้เครื่องหมายบวกเดี่ยวเพื่อแปลงเป็นตัวเลข:
 
 ```js run
 let sum = 0.1 + 0.2;
 alert( +sum.toFixed(2) ); // 0.3
 ```
 
-We also can temporarily multiply the numbers by 100 (or a bigger number) to turn them into integers, do the maths, and then divide back. Then, as we're doing maths with integers, the error somewhat decreases, but we still get it on division:
+เราสามารถคูณตัวเลขด้วย 100 (หรือตัวเลขที่ใหญ่กว่า) ชั่วคราวเพื่อเปลี่ยนให้เป็นจำนวนเต็ม ทำการคำนวณ แล้วหารกลับ เมื่อทำเช่นนี้ ข้อผิดพลาดจะลดลงบ้าง แต่ยังคงมีเมื่อหาร:
 
 ```js run
 alert( (0.1 * 10 + 0.2 * 10) / 10 ); // 0.3
 alert( (0.28 * 100 + 0.14 * 100) / 100); // 0.4200000000000001
 ```
 
+<<<<<<< HEAD
+ดังนั้น วิธีคูณ/หารช่วยลดข้อผิดพลาด แต่ไม่ได้กำจัดออกทั้งหมด
+=======
 So, the multiply/divide approach reduces the error, but doesn't remove it totally.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-Sometimes we could try to evade fractions at all. Like if we're dealing with a shop, then we can store prices in cents instead of dollars. But what if we apply a discount of 30%? In practice, totally evading fractions is rarely possible. Just round them to cut "tails" when needed.
+บางครั้งเราอาจพยายามหลีกเลี่ยงเศษส่วนทั้งหมด เช่น ถ้าเราทำเรื่องร้านค้า เราอาจเก็บราคาเป็นสตางค์แทนบาท แต่ถ้าเราลดราคา 30% ล่ะ? ในทางปฏิบัติ การหลีกเลี่ยงเศษส่วนทั้งหมดแทบจะเป็นไปไม่ได้ เพียงแค่ปัดเศษตัดทศนิยมเมื่อจำเป็น
 
-````smart header="The funny thing"
-Try running this:
+````smart header="เรื่องแปลก"
+ลองรันโค้ดนี้ดู:
 
 ```js run
-// Hello! I'm a self-increasing number!
-alert( 9999999999999999 ); // shows 10000000000000000
+// สวัสดี! ฉันเป็นตัวเลขที่เพิ่มขึ้นเอง!
+alert( 9999999999999999 ); // แสดง 10000000000000000
 ```
 
-This suffers from the same issue: a loss of precision. There are 64 bits for the number, 52 of them can be used to store digits, but that's not enough. So the least significant digits disappear.
+นี่เกิดจากปัญหาเดียวกัน: การสูญเสียความแม่นยำ มี 64 บิตสำหรับตัวเลข, 52 บิตใช้เก็บตัวเลข แต่ไม่พอ ดังนั้นตัวเลขที่มีนัยสำคัญน้อยที่สุดจึงหายไป
 
-JavaScript doesn't trigger an error in such events. It does its best to fit the number into the desired format, but unfortunately, this format is not big enough.
+จาวาสคริปต์ไม่แจ้งข้อผิดพลาดในกรณีเช่นนี้ มันพยายามทำให้ตัวเลขพอดีกับรูปแบบที่ต้องการ แต่น่าเสียดายที่รูปแบบนี้ไม่ใหญ่พอ
 ````
 
-```smart header="Two zeroes"
-Another funny consequence of the internal representation of numbers is the existence of two zeroes: `0` and `-0`.
+```smart header="สองศูนย์"
+ผลพลอยได้ที่แปลกอีกอย่างของการแสดงตัวเลขภายในคือการมีศูนย์สองแบบ: `0` และ `-0`
 
-That's because a sign is represented by a single bit, so it can be set or not set for any number including a zero.
+นั่นเพราะเครื่องหมายถูกแสดงด้วยบิตเดียว ดังนั้นจึงอาจตั้งค่าหรือไม่ตั้งค่าสำหรับตัวเลขใดๆ รวมถึงศูนย์
 
+<<<<<<< HEAD
+ในกรณีส่วนใหญ่ ความแตกต่างไม่สังเกตเห็น เพราะตัวดำเนินการปฏิบัติต่อพวกมันเหมือนกัน
+=======
 In most cases, the distinction is unnoticeable, because operators are suited to treat them as the same.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 ```
 
-## Tests: isFinite and isNaN
-
-Remember these two special numeric values?
+## การทดสอบ: isFinite และ isNaN
 
-- `Infinity` (and `-Infinity`) is a special numeric value that is greater (less) than anything.
-- `NaN` represents an error.
+จำค่าตัวเลขพิเศษสองค่านี้ได้ไหม?
 
-They belong to the type `number`, but are not "normal" numbers, so there are special functions to check for them:
+- `Infinity` (และ `-Infinity`) เป็นค่าตัวเลขพิเศษที่มากกว่า (น้อยกว่า) ทุกอย่าง
+- `NaN` แทนข้อผิดพลาด
 
+ค่าเหล่านี้เป็นประเภท `number` แต่ไม่ใช่ตัวเลข "ปกติ" จึงมีฟังก์ชันพิเศษสำหรับตรวจสอบ:
 
-- `isNaN(value)` converts its argument to a number and then tests it for being `NaN`:
+- `isNaN(value)` แปลงอาร์กิวเมนต์เป็นตัวเลขแล้วทดสอบว่าเป็น `NaN`:
 
     ```js run
-    alert( isNaN(NaN) ); // true
-    alert( isNaN("str") ); // true
+    alert( isNaN(NaN) ); // จริง
+    alert( isNaN("str") ); // จริง
     ```
 
+<<<<<<< HEAD
+    แต่เราจำเป็นต้องใช้ฟังก์ชันนี้ไหม? เราไม่สามารถใช้การเปรียบเทียบ `=== NaN` ได้หรือ? ขอโทษ แต่คำตอบคือไม่ได้ ค่า `NaN` เป็นค่าพิเศษที่ไม่เท่ากับอะไรเลย รวมถึงตัวมันเอง:
+=======
     But do we need this function? Can't we just use the comparison `=== NaN`? Unfortunately not. The value `NaN` is unique in that it does not equal anything, including itself:
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
     ```js run
-    alert( NaN === NaN ); // false
+    alert( NaN === NaN ); // เท็จ
     ```
 
-- `isFinite(value)` converts its argument to a number and returns `true` if it's a regular number, not `NaN/Infinity/-Infinity`:
+- `isFinite(value)` แปลงอาร์กิวเมนต์เป็นตัวเลขและคืนค่า `จริง` ถ้าเป็นตัวเลขปกติ ไม่ใช่ `NaN/Infinity/-Infinity`:
 
     ```js run
-    alert( isFinite("15") ); // true
-    alert( isFinite("str") ); // false, because a special value: NaN
-    alert( isFinite(Infinity) ); // false, because a special value: Infinity
+    alert( isFinite("15") ); // จริง
+    alert( isFinite("str") ); // เท็จ เพราะเป็นค่าพิเศษ: NaN
+    alert( isFinite(Infinity) ); // เท็จ เพราะเป็นค่าพิเศษ: Infinity
     ```
 
-Sometimes `isFinite` is used to validate whether a string value is a regular number:
+บางครั้ง `isFinite` ถูกใช้เพื่อตรวจสอบว่าค่าสตริงเป็นตัวเลขปกติหรือไม่:
 
 
 ```js run
-let num = +prompt("Enter a number", '');
+let num = +prompt("ป้อนตัวเลข", '');
 
-// will be true unless you enter Infinity, -Infinity or not a number
+// จะเป็นจริงยกเว้นคุณป้อน Infinity, -Infinity หรือไม่ใช่ตัวเลข
 alert( isFinite(num) );
 ```
 
-Please note that an empty or a space-only string is treated as `0` in all numeric functions including `isFinite`.
+โปรดทราบว่าสตริงว่างเปล่าหรือสตริงที่มีแต่ช่องว่างจะถูกปฏิบัติเป็น `0` ในทุกฟังก์ชันตัวเลขรวมถึง `isFinite`
+
+<<<<<<< HEAD
+```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` ทางเทคนิคแล้วถูกต้อง เพราะภายในตัวเลขมีบิตเครื่องหมายที่อาจต่างกันแม้บิตอื่นทั้งหมดเป็นศูนย์
+=======
 ````smart header="`Number.isNaN` and `Number.isFinite`"
 [Number.isNaN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isNaN) and [Number.isFinite](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isFinite) methods are the more "strict" versions of `isNaN` and `isFinite` functions. They do not autoconvert their argument into a number, but check if it belongs to the `number` type instead.
 
@@ -376,71 +469,85 @@ There is a special built-in method `Object.is` that compares values like `===`,
 
 1. It works with `NaN`: `Object.is(NaN, NaN) === true`, that's a good thing.
 2. Values `0` and `-0` are different: `Object.is(0, -0) === false`, technically that's correct because internally the number has a sign bit that may be different even if all other bits are zeroes.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-In all other cases, `Object.is(a, b)` is the same as `a === b`.
+ในกรณีอื่นๆ ทั้งหมด `Object.is(a, b)` เหมือนกับ `a === b`
 
+<<<<<<< HEAD
+วิธีเปรียบเทียบนี้มักใช้ในข้อกำหนดของจาวาสคริปต์ เมื่ออัลกอริทึมภายในต้องเปรียบเทียบสองค่าว่าเหมือนกันพอดี จะใช้ `Object.is` (เรียกภายในว่า [SameValue](https://tc39.github.io/ecma262/#sec-samevalue))
+=======
 We mention `Object.is` here, because it's often used in JavaScript specification. When an internal algorithm needs to compare two values for being exactly the same, it uses `Object.is` (internally called [SameValue](https://tc39.github.io/ecma262/#sec-samevalue)).
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 ```
 
 
-## parseInt and parseFloat
+## parseInt และ parseFloat
 
-Numeric conversion using a plus `+` or `Number()` is strict. If a value is not exactly a number, it fails:
+การแปลงเป็นตัวเลขโดยใช้เครื่องหมายบวก `+` หรือ `Number()` นั้นเข้มงวด ถ้าค่าไม่ใช่ตัวเลขพอดี จะล้มเหลว:
 
 ```js run
 alert( +"100px" ); // NaN
 ```
 
-The sole exception is spaces at the beginning or at the end of the string, as they are ignored.
+ข้อยกเว้นเดียวคือช่องว่างที่อยู่ต้นหรือท้ายสตริง ซึ่งจะถูกละเลย
 
+<<<<<<< HEAD
+แต่ในชีวิตจริง เรามักมีค่าในหน่วยต่างๆ เช่น `"100px"` หรือ `"12pt"` ใน CSS และในหลายประเทศสัญลักษณ์สกุลเงินอยู่หลังจำนวน เช่น `"19฿"` และเราอยากแยกค่าตัวเลขออกมา
+=======
 But in real life, we often have values in units, like `"100px"` or `"12pt"` in CSS. Also in many countries, the currency symbol goes after the amount, so we have `"19€"` and would like to extract a numeric value out of that.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-That's what `parseInt` and `parseFloat` are for.
+นั่นคือสิ่งที่ `parseInt` และ `parseFloat` มีไว้
 
-They "read" a number from a string until they can't. In case of an error, the gathered number is returned. The function `parseInt` returns an integer, whilst `parseFloat` will return a floating-point number:
+ฟังก์ชันเหล่านี้ "อ่าน" ตัวเลขจากสตริงจนกว่าจะอ่านไม่ได้ ถ้าเกิดข้อผิดพลาด จะคืนค่าตัวเลขที่อ่านได้ ฟังก์ชัน `parseInt` คืนค่าจำนวนเต็ม ส่วน `parseFloat` คืนค่าทศนิยม:
 
 ```js run
 alert( parseInt('100px') ); // 100
 alert( parseFloat('12.5em') ); // 12.5
 
-alert( parseInt('12.3') ); // 12, only the integer part is returned
-alert( parseFloat('12.3.4') ); // 12.3, the second point stops the reading
+alert( parseInt('12.3') ); // 12, คืนเฉพาะส่วนจำนวนเต็ม
+alert( parseFloat('12.3.4') ); // 12.3, หยุดอ่านที่จุดทศนิยมที่สอง
 ```
 
-There are situations when `parseInt/parseFloat` will return `NaN`. It happens when no digits could be read:
+มีบางสถานการณ์ที่ `parseInt/parseFloat` จะคืนค่า `NaN` เกิดขึ้นเมื่อไม่สามารถอ่านตัวเลขได้เลย:
 
 ```js run
-alert( parseInt('a123') ); // NaN, the first symbol stops the process
+alert( parseInt('a123') ); // NaN, หยุดอ่านที่ตัวอักษรแรก
 ```
 
-````smart header="The second argument of `parseInt(str, radix)`"
-The `parseInt()` function has an optional second parameter. It specifies the base of the numeral system, so `parseInt` can also parse strings of hex numbers, binary numbers and so on:
+````smart header="อาร์กิวเมนต์ที่สองของ parseInt(str, radix)"
+ฟังก์ชัน `parseInt()` มีอาร์กิวเมนต์ที่สองเป็นตัวเลือก กำหนดฐานของระบบตัวเลข ดังนั้น `parseInt` สามารถแยกวิเคราะห์สตริงของตัวเลขฐานสิบหก ฐานสอง และอื่นๆ ได้:
 
 ```js run
 alert( parseInt('0xff', 16) ); // 255
-alert( parseInt('ff', 16) ); // 255, without 0x also works
+alert( parseInt('ff', 16) ); // 255, ทำงานได้โดยไม่มี 0x ด้วย
 
 alert( parseInt('2n9c', 36) ); // 123456
 ```
 ````
 
-## Other math functions
+## ฟังก์ชันคณิตศาสตร์อื่นๆ
 
-JavaScript has a built-in [Math](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Math) object which contains a small library of mathematical functions and constants.
+จาวาสคริปต์มีวัตถุ [Math](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Math) ในตัว ซึ่งมีไลบรารีขนาดเล็กของฟังก์ชันคณิตศาสตร์และค่าคงที่
 
-A few examples:
+ตัวอย่างบางส่วน:
 
 `Math.random()`
-: Returns a random number from 0 to 1 (not including 1).
+: สร้างตัวเลขสุ่มตั้งแต่ 0 ถึง 1 (ไม่รวม 1)
 
     ```js run
     alert( Math.random() ); // 0.1234567894322
     alert( Math.random() ); // 0.5435252343232
-    alert( Math.random() ); // ... (any random numbers)
+    alert( Math.random() ); // ... (ตัวเลขสุ่มใดๆ)
     ```
 
+<<<<<<< HEAD
+`Math.max(a, b, c...)` / `Math.min(a, b, c...)`
+: คืนค่าสูงสุด/ต่ำสุดจากอาร์กิวเมนต์ที่ให้มา
+=======
 `Math.max(a, b, c...)` and `Math.min(a, b, c...)`
 : Returns the greatest and smallest from the arbitrary number of arguments.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
     ```js run
     alert( Math.max(3, 5, -10, 0, 1) ); // 5
@@ -448,27 +555,30 @@ A few examples:
     ```
 
 `Math.pow(n, power)`
-: Returns `n` raised to the given power.
+: คืนค่า `n` ยกกำลัง `power`
 
     ```js run
-    alert( Math.pow(2, 10) ); // 2 in power 10 = 1024
+    alert( Math.pow(2, 10) ); // 2 ยกกำลัง 10 = 1024
     ```
 
-There are more functions and constants in `Math` object, including trigonometry, which you can find in the [docs for the Math object](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Math).
+มีฟังก์ชันและค่าคงที่อื่นๆ อีกใน `Math` รวมถึงตรีโกณมิติ ซึ่งคุณสามารถดูได้ในเอกสารสำหรับวัตถุ [Math](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Math)
 
-## Summary
+## สรุป
 
-To write numbers with many zeroes:
+การเขียนตัวเลขที่มีศูนย์จำนวนมาก:
 
-- Append `"e"` with the zeroes count to the number. Like: `123e6` is the same as `123` with 6 zeroes `123000000`.
-- A negative number after `"e"` causes the number to be divided by 1 with given zeroes. E.g. `123e-6` means `0.000123` (`123` millionths).
+- เพิ่ม `"e"` ตามด้วยจำนวนศูนย์ต่อท้ายตัวเลข เช่น: `123e6` เท่ากับ `123` ตามด้วยศูนย์ 6 ตัว `123000000`
+- ตัวเลขลบหลัง `"e"` ทำให้ตัวเลขถูกหารด้วย 1 ตามด้วยจำนวนศูนย์ที่กำหนด เช่น `123e-6` หมายถึง `0.000123` (`123` หนึ่งในล้าน)
 
-For different numeral systems:
+สำหรับระบบตัวเลขต่างๆ:
 
-- Can write numbers directly in hex (`0x`), octal (`0o`) and binary (`0b`) systems.
-- `parseInt(str, base)` parses the string `str` into an integer in numeral system with given `base`, `2 ≤ base ≤ 36`.
-- `num.toString(base)` converts a number to a string in the numeral system with the given `base`.
+- เขียนตัวเลขโดยตรงในระบบฐานสิบหก (`0x`), ฐานแปด (`0o`) และฐานสอง (`0b`) ได้
+- `parseInt(str, base)` แยกวิเคราะห์สตริง `str` เป็นจำนวนเต็มในระบบตัวเลขฐาน `base`, `2 ≤ base ≤ 36`
+- `num.toString(base)` แปลงตัวเลขเป็นสตริงในระบบตัวเลขฐานที่กำหนด
 
+<<<<<<< HEAD
+สำหรับการแปลงค่าเช่น `12pt` และ `100px` เป็นตัวเลข:
+=======
 For regular number tests:
 
 - `isNaN(value)` converts its argument to a number and then tests it for being `NaN`
@@ -477,14 +587,19 @@ For regular number tests:
 - `Number.isFinite(value)` checks whether its argument belongs to the `number` type, and if so, tests it for not being `NaN/Infinity/-Infinity`
 
 For converting values like `12pt` and `100px` to a number:
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-- Use `parseInt/parseFloat` for the "soft" conversion, which reads a number from a string and then returns the value they could read before the error.
+- ใช้ `parseInt/parseFloat` สำหรับการแปลง "แบบยืดหยุ่น" ซึ่งอ่านตัวเลขจากสตริงแล้วคืนค่าที่อ่านได้ก่อนเกิดข้อผิดพลาด
 
-For fractions:
+สำหรับเศษส่วน:
 
-- Round using `Math.floor`, `Math.ceil`, `Math.trunc`, `Math.round` or `num.toFixed(precision)`.
-- Make sure to remember there's a loss of precision when working with fractions.
+- ปัดเศษโดยใช้ `Math.floor`, `Math.ceil`, `Math.trunc`, `Math.round` หรือ `num.toFixed(precision)`
+- พึงระวังการสูญเสียความแม่นยำเมื่อทำงานกับเศษส่วน
 
-More mathematical functions:
+ฟังก์ชันคณิตศาสตร์เพิ่มเติม:
 
+<<<<<<< HEAD
+- ดู [Math](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Math) เมื่อต้องการใช้ ไลบรารีนี้มีขนาดเล็ก แต่ครอบคลุมความต้องการพื้นฐานทางคณิตศาสตร์ได้
+=======
 - See the [Math](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Math) object when you need them. The library is very small but can cover basic needs.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
diff --git a/1-js/05-data-types/03-string/article.md b/1-js/05-data-types/03-string/article.md
index 60ce2b6f0..175b422ad 100644
--- a/1-js/05-data-types/03-string/article.md
+++ b/1-js/05-data-types/03-string/article.md
@@ -1,14 +1,19 @@
-# Strings
+# สตริง (Strings)
 
-In JavaScript, the textual data is stored as strings. There is no separate type for a single character.
+ในภาษา JavaScript ข้อมูลที่เป็นตัวอักษรจะถูกเก็บในรูปแบบของสตริง โดยไม่มีประเภทข้อมูลแยกต่างหากสำหรับอักขระเดี่ยว ซึ่งต่างจากบางภาษาโปรแกรมมิ่งอื่นๆ ที่มีประเภทข้อมูลเฉพาะสำหรับตัวอักษรเดี่ยว
 
-The internal format for strings is always [UTF-16](https://en.wikipedia.org/wiki/UTF-16), it is not tied to the page encoding.
+รูปแบบภายในของสตริงใน JavaScript จะเป็น UTF-16 เสมอ โดยไม่ขึ้นอยู่กับการเข้ารหัสของหน้าเว็บ นี่หมายความว่าสตริงใน JavaScript สามารถรองรับอักขระยูนิโค้ดได้อย่างกว้างขวาง ทำให้สามารถทำงานกับข้อความในหลายภาษาได้อย่างมีประสิทธิภาพ
 
-## Quotes
+## เครื่องหมายคำพูด
 
-Let's recall the kinds of quotes.
+มาทบทวนประเภทของเครื่องหมายคำพูดที่ใช้ในการสร้างสตริงใน JavaScript กัน
+สตริงสามารถอยู่ภายในเครื่องหมายคำพูดได้ 3 แบบ:
 
-Strings can be enclosed within either single quotes, double quotes or backticks:
+เครื่องหมายคำพูดเดี่ยว (Single quotes)
+เครื่องหมายคำพูดคู่ (Double quotes)
+เครื่องหมาย backticks
+
+ตัวอย่างการใช้งาน:
 
 ```js
 let single = 'single-quoted';
@@ -17,7 +22,9 @@ let double = "double-quoted";
 let backticks = `backticks`;
 ```
 
-Single and double quotes are essentially the same. Backticks, however, allow us to embed any expression into the string, by wrapping it in `${…}`:
+เครื่องหมายคำพูดเดี่ยวและคู่มีลักษณะการทำงานเหมือนกัน แต่เครื่องหมาย backticks มีความสามารถพิเศษ ช่วยให้เราสามารถแทรกนิพจน์ (expression) ใดๆ ลงในสตริงได้ โดยครอบด้วย `${…}` ซึ่งเรียกว่า template literals หรือ template strings
+
+ตัวอย่างการใช้ template literals:
 
 ```js run
 function sum(a, b) {
@@ -27,7 +34,7 @@ function sum(a, b) {
 alert(`1 + 2 = ${sum(1, 2)}.`); // 1 + 2 = 3.
 ```
 
-Another advantage of using backticks is that they allow a string to span multiple lines:
+ข้อดีอีกอย่างของการใช้ backticks คือสามารถทำให้สตริงมีหลายบรรทัดได้:
 
 ```js run
 let guestList = `Guests:
@@ -39,41 +46,79 @@ let guestList = `Guests:
 alert(guestList); // a list of guests, multiple lines
 ```
 
-Looks natural, right? But single or double quotes do not work this way.
+สังเกตว่าการใช้ backticks ทำให้เราสามารถเขียนข้อความหลายบรรทัดได้อย่างเป็นธรรมชาติ โดยไม่ต้องใช้อักขระพิเศษเช่น `\n` เพื่อขึ้นบรรทัดใหม่
 
-If we use them and try to use multiple lines, there'll be an error:
+ในทางกลับกัน ถ้าเราใช้เครื่องหมายคำพูดเดี่ยวหรือคู่และพยายามใช้หลายบรรทัด จะเกิดข้อผิดพลาด:
 
 ```js run
 let guestList = "Guests: // Error: Unexpected token ILLEGAL
   * John";
 ```
 
+<<<<<<< HEAD
+เครื่องหมายคำพูดเดี่ยวและคู่มีมาตั้งแต่ยุคแรกๆ ของการสร้างภาษา JavaScript ซึ่งตอนนั้นยังไม่ได้คำนึงถึงความต้องการในการใช้สตริงหลายบรรทัด ส่วน backticks เพิ่งมาในภายหลังใน ECMAScript 6 (ES6) จึงมีความสามารถที่หลากหลายกว่า
+
+นอกจากนี้ backticks ยังช่วยให้เราสามารถระบุ "ฟังก์ชันเทมเพลต" (template function) ก่อน backtick แรกได้ด้วย ไวยากรณ์คือ: <code>func&#96;string&#96;</code> ฟังก์ชัน `func` จะถูกเรียกโดยอัตโนมัติ รับสตริงและนิพจน์ที่แทรกเข้ามาและสามารถประมวลผลได้ คุณลักษณะนี้เรียกว่า "tagged templates" ซึ่งมีประโยชน์มากในการสร้างสตริงที่ซับซ้อนหรือต้องการการประมวลผลพิเศษ แม้ว่าจะพบเห็นได้ไม่บ่อยนักในโค้ดทั่วไป แต่มีประโยชน์มากในไลบรารีหรือเฟรมเวิร์กบางตัว คุณสามารถอ่านเพิ่มเติมได้ที่เอกสารอ้างอิงของ MDN: [Template literals](mdn:/JavaScript/Reference/Template_literals#Tagged_templates)
+=======
 Single and double quotes come from ancient times of language creation, when the need for multiline strings was not taken into account. Backticks appeared much later and thus are more versatile.
 
 Backticks also allow us to specify a "template function" before the first backtick. The syntax is: <code>func&#96;string&#96;</code>. The function `func` is called automatically, receives the string and embedded expressions and can process them. This feature is called "tagged templates", it's rarely seen, but you can read about it in the MDN: [Template literals](mdn:/JavaScript/Reference/Template_literals#Tagged_templates).
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-## Special characters
+## อักขระพิเศษ
 
-It is still possible to create multiline strings with single and double quotes by using a so-called "newline character", written as `\n`, which denotes a line break:
+แม้ว่า backticks จะช่วยให้เราสร้างสตริงหลายบรรทัดได้ง่าย แต่เราก็ยังสามารถสร้างสตริงหลายบรรทัดด้วยเครื่องหมายคำพูดเดี่ยวและคู่ได้ โดยใช้ "อักขระขึ้นบรรทัดใหม่" (newline character) ซึ่งเขียนเป็น `\n`:
 
 ```js run
 let guestList = "Guests:\n * John\n * Pete\n * Mary";
 
+<<<<<<< HEAD
+alert(guestList); // แสดงรายชื่อแขกหลายบรรทัด เหมือนกับตัวอย่างก่อนหน้า
+```
+
+ตัวอย่างที่ง่ายกว่านี้ สองบรรทัดต่อไปนี้ให้ผลลัพธ์เหมือนกัน แค่เขียนต่างกัน:
+=======
 alert(guestList); // a multiline list of guests, same as above
 ```
 
 As a simpler example, these two lines are equal, just written differently:
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
 ```js run
-let str1 = "Hello\nWorld"; // two lines using a "newline symbol"
+let str1 = "Hello\nWorld"; // สองบรรทัดโดยใช้ "สัญลักษณ์ขึ้นบรรทัดใหม่"
 
-// two lines using a normal newline and backticks
+// สองบรรทัดโดยใช้การขึ้นบรรทัดปกติและ backticks
 let str2 = `Hello
 World`;
 
-alert(str1 == str2); // true
+alert(str1 == str2); // true แสดงว่าทั้งสองสตริงเหมือนกัน
+```
+
+<<<<<<< HEAD
+มีอักขระพิเศษอื่นๆ ที่พบได้น้อยกว่า:
+
+| อักขระ | คำอธิบาย |
+|-----------|-------------|
+|`\n`|ขึ้นบรรทัดใหม่|
+|`\r`|Carriage return (ใช้ในระบบ Windows)|
+|`\t`|แท็บ (Tab)|
+|`\'`|เครื่องหมายคำพูดเดี่ยว|
+|`\"`|เครื่องหมายคำพูดคู่|
+|<code>\\`</code>|Backtick|
+|`\\`|แบ็คสแลช|
+
+สำหรับระบบปฏิบัติการ Windows การรวมกันของอักขระสองตัว `\r\n` แสดงถึงการขึ้นบรรทัดใหม่ ในขณะที่ระบบปฏิบัติการอื่นๆ เช่น macOS หรือ Linux จะใช้แค่ `\n` นี่เป็นเพราะเหตุผลทางประวัติศาสตร์ของการพัฒนาระบบปฏิบัติการ อย่างไรก็ตาม ซอฟต์แวร์ Windows ส่วนใหญ่ในปัจจุบันก็เข้าใจ `\n` เช่นกัน
+
+ดังที่คุณเห็น อักขระพิเศษทั้งหมดเริ่มต้นด้วยเครื่องหมายแบ็คสแลช `\` ซึ่งเรียกว่า "อักขระหลบ" (escape character) เนื่องจากมันมีความพิเศษ ถ้าเราต้องการแสดงแบ็คสแลชจริงๆ `\` ในสตริง เราต้องเขียนมันสองครั้ง:
+
+```js run
+alert( `The backslash: \\` ); // แสดงผล: แบ็คสแลช: \
 ```
 
+เครื่องหมายคำพูดที่ "หลบ" (escaped) `\'`, `\"`, <code>\\`</code> ใช้เพื่อแทรกเครื่องหมายคำพูดลงในสตริงที่ใช้เครื่องหมายคำพูดแบบเดียวกัน
+
+ตัวอย่างเช่น:
+=======
 There are other, less common special characters:
 
 | Character | Description |
@@ -96,58 +141,116 @@ alert( `The backslash: \\` ); // The backslash: \
 So-called "escaped" quotes `\'`, `\"`, <code>\\`</code> are used to insert a quote into the same-quoted string.
 
 For instance:
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
 ```js run
 alert( 'I*!*\'*/!*m the Walrus!' ); // *!*I'm*/!* the Walrus!
 ```
 
-As you can see, we have to prepend the inner quote by the backslash `\'`, because otherwise it would indicate the string end.
+ในตัวอย่างนี้ เราใช้ `\'` เพื่อแทรกเครื่องหมายคำพูดเดี่ยวลงในสตริงที่ล้อมรอบด้วยเครื่องหมายคำพูดเดี่ยวเช่นกัน ถ้าไม่ใช้ `\` JavaScript จะเข้าใจผิดว่าเครื่องหมายคำพูดนั้นเป็นจุดสิ้นสุดของสตริง
+
+อย่างไรก็ตาม วิธีที่สะดวกและอ่านง่ายกว่าคือการใช้เครื่องหมายคำพูดที่ต่างกัน:
 
-Of course, only the quotes that are the same as the enclosing ones need to be escaped. So, as a more elegant solution, we could switch to double quotes or backticks instead:
 
 ```js run
 alert( "I'm the Walrus!" ); // I'm the Walrus!
 ```
 
+<<<<<<< HEAD
+ในกรณีนี้ เราใช้เครื่องหมายคำพูดคู่ภายนอกและเครื่องหมายคำพูดเดี่ยวภายใน ทำให้ไม่ต้องใช้อักขระหลบและอ่านง่ายขึ้น 
+
+## ความยาวของสตริง
+
+คุณสมบัติ `length` ใช้เพื่อหาความยาวของสตริง:
+=======
 Besides these special characters, there's also a special notation for Unicode codes `\u…`, it's rarely used and is covered in the optional chapter about [Unicode](info:unicode).
 
 ## String length
 
 The `length` property has the string length:
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
 ```js run
 alert( `My\n`.length ); // 3
 ```
 
-Note that `\n` is a single "special" character, so the length is indeed `3`.
+สังเกตว่า `\n` เป็น "อักขระพิเศษ" เดียว ดังนั้นความยาวของสตริงนี้จึงเป็น `3`
 
-```warn header="`length` is a property"
-People with a background in some other languages sometimes mistype by calling `str.length()` instead of just `str.length`. That doesn't work.
+```warn header="`length` เป็นคุณสมบัติ"
+ผู้ที่มีพื้นฐานจากภาษาอื่นบางครั้งอาจเผลอเรียกใช้ `str.length()` แทนที่จะใช้แค่ `str.length` ซึ่งไม่ถูกต้องและจะทำให้โปรแกรมทำงานผิดพลาด
 
+<<<<<<< HEAD
+โปรดจำไว้ว่า `str.length` เป็นคุณสมบัติเชิงตัวเลข ไม่ใช่ฟังก์ชัน ไม่จำเป็นต้องเพิ่มวงเล็บหลังมัน เราใช้แค่ `.length` ไม่ใช่ `.length()`
+=======
 Please note that `str.length` is a numeric property, not a function. There is no need to add parenthesis after it. Not `.length()`, but `.length`.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 ```
 
-## Accessing characters
+## การเข้าถึงอักขระ
+
+<<<<<<< HEAD
+ในภาษา JavaScript เรามีวิธีการเข้าถึงอักขระในสตริงสองวิธีหลัก:
 
+1. การใช้วงเล็บเหลี่ยม `[]`
+2. การใช้เมธอด `at()`
+
+### การใช้วงเล็บเหลี่ยม
+
+เพื่อเข้าถึงอักขระที่ตำแหน่ง `pos` เราสามารถใช้วงเล็บเหลี่ยม `[pos]` โดยการนับเริ่มจาก 0:
+=======
 To get a character at position `pos`, use square brackets `[pos]` or call the method [str.at(pos)](mdn:js/String/at). The first character starts from the zero position:
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
 ```js run
 let str = `Hello`;
 
-// the first character
+// อักขระแรก
 alert( str[0] ); // H
+<<<<<<< HEAD
+=======
 alert( str.at(0) ); // H
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-// the last character
+// อักขระสุดท้าย
 alert( str[str.length - 1] ); // o
 alert( str.at(-1) );
 ```
 
+<<<<<<< HEAD
+### การใช้เมธอด at()
+
+อีกวิธีหนึ่งคือการใช้เมธอด [str.at(pos)](mdn:js/String/at) ซึ่งมีข้อดีคือสามารถใช้ค่าลบเพื่อนับจากท้ายสตริงได้:
+=======
 As you can see, the `.at(pos)` method has a benefit of allowing negative position. If `pos` is negative, then it's counted from the end of the string.
 
 So `.at(-1)` means the last character, and `.at(-2)` is the one before it, etc.
 
 The square brackets always return `undefined` for negative indexes, for instance:
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
+
+```js run
+let str = `Hello`;
+
+<<<<<<< HEAD
+// อักขระแรก
+alert( str.at(0) ); // H
+
+// อักขระสุดท้าย
+alert( str.at(-1) ); // o
+
+// อักขระก่อนสุดท้าย
+=======
+alert( str[-2] ); // undefined
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
+alert( str.at(-2) ); // l
+```
+
+ข้อแตกต่างที่สำคัญระหว่างสองวิธีนี้คือ:
+
+1. วงเล็บเหลี่ยม `[]` จะคืนค่า `undefined` เสมอสำหรับดัชนีที่เป็นลบ
+2. เมธอด `at()` สามารถใช้ค่าลบเพื่อนับจากท้ายสตริงได้
+
+ตัวอย่างเช่น:
 
 ```js run
 let str = `Hello`;
@@ -156,7 +259,7 @@ alert( str[-2] ); // undefined
 alert( str.at(-2) ); // l
 ```
 
-We can also iterate over characters using `for..of`:
+เราสามารถวนลูปผ่านอักขระของสตริงโดยใช้ `for..of` ได้ด้วย:
 
 ```js run
 for (let char of "Hello") {
@@ -164,72 +267,68 @@ for (let char of "Hello") {
 }
 ```
 
-## Strings are immutable
+## สตริงไม่สามารถเปลี่ยนแปลงได้
 
-Strings can't be changed in JavaScript. It is impossible to change a character.
+สตริงใน JavaScript เป็นประเภทข้อมูลที่ไม่สามารถเปลี่ยนแปลงได้ (immutable) นั่นหมายความว่าเราไม่สามารถแก้ไขอักขระในสตริงที่มีอยู่แล้วได้
 
-Let's try it to show that it doesn't work:
+ลองดูตัวอย่างนี้เพื่อแสดงให้เห็นว่าการพยายามเปลี่ยนแปลงสตริงโดยตรงไม่ทำงาน:
 
 ```js run
 let str = 'Hi';
 
-str[0] = 'h'; // error
-alert( str[0] ); // doesn't work
+str[0] = 'h'; // เกิดข้อผิดพลาด
+alert( str[0] ); // ไม่ทำงาน
 ```
 
-The usual workaround is to create a whole new string and assign it to `str` instead of the old one.
+วิธีแก้ปัญหาทั่วไปเมื่อต้องการเปลี่ยนแปลงสตริงคือการสร้างสตริงใหม่ทั้งหมดและกำหนดให้กับตัวแปรเดิม:
 
-For instance:
+ตัวอย่างเช่น:
 
 ```js run
 let str = 'Hi';
 
-str = 'h' + str[1]; // replace the string
+str = 'h' + str[1]; // แทนที่ 'H' ด้วย 'h'
 
 alert( str ); // hi
 ```
 
-In the following sections we'll see more examples of this.
+ในตัวอย่างนี้ เราสร้างสตริงใหม่โดยใช้อักขระ 'h' แทนที่อักขระแรกของสตริงเดิม และคงอักขระที่เหลือไว้เหมือนเดิม
 
-## Changing the case
+## การเปลี่ยนตัวพิมพ์
 
-Methods [toLowerCase()](mdn:js/String/toLowerCase) and [toUpperCase()](mdn:js/String/toUpperCase) change the case:
+การเปลี่ยนตัวพิมพ์ของสตริงเป็นสิ่งที่ทำได้ง่ายใน JavaScript โดยใช้เมธอด `toLowerCase()` และ `toUpperCase()`:
 
 ```js run
 alert( 'Interface'.toUpperCase() ); // INTERFACE
 alert( 'Interface'.toLowerCase() ); // interface
 ```
 
-Or, if we want a single character lowercased:
+ถ้าเราต้องการเปลี่ยนตัวพิมพ์ของอักขระเดี่ยว เราสามารถทำได้โดยการเข้าถึงอักขระนั้นก่อนแล้วใช้เมธอดเปลี่ยนตัวพิมพ์:
 
 ```js run
 alert( 'Interface'[0].toLowerCase() ); // 'i'
 ```
 
-## Searching for a substring
+## การค้นหาสตริงย่อย
 
-There are multiple ways to look for a substring within a string.
+JavaScript มีหลายวิธีในการค้นหาสตริงย่อยภายในสตริง แต่ละวิธีมีจุดเด่นและการใช้งานที่แตกต่างกัน
 
 ### str.indexOf
 
-The first method is [str.indexOf(substr, pos)](mdn:js/String/indexOf).
-
-It looks for the `substr` in `str`, starting from the given position `pos`, and returns the position where the match was found or `-1` if nothing can be found.
+เมธอด [str.indexOf(substr, pos)](mdn:js/String/indexOf) เป็นวิธีพื้นฐานในการค้นหาสตริงย่อย:
 
-For instance:
+ตัวอย่างเช่น:
 
 ```js run
 let str = 'Widget with id';
 
-alert( str.indexOf('Widget') ); // 0, because 'Widget' is found at the beginning
-alert( str.indexOf('widget') ); // -1, not found, the search is case-sensitive
+alert( str.indexOf('Widget') ); // 0, เพราะ 'Widget' พบที่จุดเริ่มต้น
+alert( str.indexOf('widget') ); // // -1, ไม่พบ การค้นหานี้คำนึงถึงตัวพิมพ์ใหญ่-เล็ก
 
-alert( str.indexOf("id") ); // 1, "id" is found at the position 1 (..idget with id)
+alert( str.indexOf("id") ); // 1, "ไอดี" พบที่ตำแหน่ง 1
 ```
 
-The optional second parameter allows us to start searching from a given position.
-
-For instance, the first occurrence of `"id"` is at position `1`. To look for the next occurrence, let's start the search from position `2`:
+พารามิเตอร์ที่สองเป็นตัวเลือก ช่วยให้เราเริ่มค้นหาจากตำแหน่งที่กำหนดได้:
 
 ```js run
 let str = 'Widget with id';
@@ -237,12 +336,12 @@ let str = 'Widget with id';
 alert( str.indexOf('id', 2) ) // 12
 ```
 
-If we're interested in all occurrences, we can run `indexOf` in a loop. Every new call is made with the position after the previous match:
+ถ้าเราต้องการหาทุกตำแหน่งที่สตริงย่อยปรากฏ เราสามารถใช้ `indexOf` ในลูปได้:
 
 ```js run
 let str = 'As sly as a fox, as strong as an ox';
 
-let target = 'as'; // let's look for it
+let target = 'as'; // หา "as" ในสตริง
 
 let pos = 0;
 while (true) {
@@ -250,11 +349,11 @@ while (true) {
   if (foundPos == -1) break;
 
   alert( `Found at ${foundPos}` );
-  pos = foundPos + 1; // continue the search from the next position
+  pos = foundPos + 1; // ตำแหน่งถัดไปจากการค้นหาล่าสุด
 }
 ```
 
-The same algorithm can be layed out shorter:
+อัลกอริทึมเดียวกันนี้สามารถเขียนให้กระชับขึ้นได้:
 
 ```js run
 let str = "As sly as a fox, as strong as an ox";
@@ -269,24 +368,24 @@ while ((pos = str.indexOf(target, pos + 1)) != -1) {
 ```
 
 ```smart header="`str.lastIndexOf(substr, position)`"
-There is also a similar method [str.lastIndexOf(substr, position)](mdn:js/String/lastIndexOf) that searches from the end of a string to its beginning.
+มีเมธอดที่คล้ายกันคือ [str.lastIndexOf(substr, position)](mdn:js/String/lastIndexOf) ที่ค้นหาจากท้ายสตริงไปยังจุดเริ่มต้น
 
-It would list the occurrences in the reverse order.
+มันจะแสดงรายการการปรากฏในลำดับย้อนกลับ ซึ่งมีประโยชน์เมื่อต้องการหาการปรากฏล่าสุดของสตริงย่อย
 ```
 
-There is a slight inconvenience with `indexOf` in the `if` test. We can't put it in the `if` like this:
+มีข้อควรระวังเล็กน้อยเมื่อใช้ `indexOf` ในการทดสอบเงื่อนไข เราไม่สามารถใช้มันใน `if` แบบนี้ได้โดยตรง:
 
 ```js run
 let str = "Widget with id";
 
 if (str.indexOf("Widget")) {
-    alert("We found it"); // doesn't work!
+    alert("We found it"); // ไม่ทำงานอย่างที่คาด!
 }
 ```
 
-The `alert` in the example above doesn't show because `str.indexOf("Widget")` returns `0` (meaning that it found the match at the starting position). Right, but `if` considers `0` to be `false`.
+`alert` ในตัวอย่างด้านบนไม่แสดงผลเพราะ `str.indexOf("Widget")` คืนค่า `0` (หมายความว่าพบการจับคู่ที่ตำแหน่งเริ่มต้น) แต่ `if` ถือว่า `0` เป็น `false`
 
-So, we should actually check for `-1`, like this:
+ดังนั้น วิธีที่ถูกต้องคือการตรวจสอบว่าผลลัพธ์ไม่เท่ากับ `-1`:
 
 ```js run
 let str = "Widget with id";
@@ -294,15 +393,14 @@ let str = "Widget with id";
 *!*
 if (str.indexOf("Widget") != -1) {
 */!*
-    alert("We found it"); // works now!
+    alert("We found it"); // ตอนนี้ทำงานแล้ว!
 }
 ```
 
 ### includes, startsWith, endsWith
 
-The more modern method [str.includes(substr, pos)](mdn:js/String/includes) returns `true/false` depending on whether `str` contains `substr` within.
+เมธอดที่ทันสมัยและใช้งานง่ายกว่าสำหรับการตรวจสอบการมีอยู่ของสตริงย่อยคือ [str.includes(substr, pos)](mdn:js/String/includes) ซึ่งส่งคืน `true` หรือ `false` ขึ้นอยู่กับว่า `str` มี `substr` อยู่หรือไม่:
 
-It's the right choice if we need to test for the match, but don't need its position:
 
 ```js run
 alert( "Widget with id".includes("Widget") ); // true
@@ -310,128 +408,171 @@ alert( "Widget with id".includes("Widget") ); // true
 alert( "Hello".includes("Bye") ); // false
 ```
 
-The optional second argument of `str.includes` is the position to start searching from:
+อาร์กิวเมนต์ที่สองของ `str.includes` เป็นตัวเลือก เป็นตำแหน่งที่จะเริ่มค้นหา:
 
 ```js run
 alert( "Widget".includes("id") ); // true
-alert( "Widget".includes("id", 3) ); // false, from position 3 there is no "id"
+alert( "Widget".includes("id", 3) ); // false, ตั้งแต่ตำแหน่งที่ 3 ไม่มี "id"
 ```
 
-The methods [str.startsWith](mdn:js/String/startsWith) and [str.endsWith](mdn:js/String/endsWith) do exactly what they say:
+เมธอด [str.startsWith](mdn:js/String/startsWith) และ [str.endsWith](mdn:js/String/endsWith) ทำหน้าที่ตามชื่อของมันเลย คือตรวจสอบว่าสตริงขึ้นต้นหรือลงท้ายด้วยสตริงย่อยที่กำหนดหรือไม่:
 
 ```js run
+<<<<<<< HEAD
+alert( "*!*Wid*/!*get".startsWith("Wid") ); // true ขึ้นต้นด้วย "Wid"
+alert( "Wid*!*get*/!*".endsWith("get") ); // true ลงท้ายด้วย "get"
+=======
 alert( "*!*Wid*/!*get".startsWith("Wid") ); // true, "Widget" starts with "Wid"
 alert( "Wid*!*get*/!*".endsWith("get") ); // true, "Widget" ends with "get"
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 ```
 
-## Getting a substring
+## การดึงสตริงย่อย
 
-There are 3 methods in JavaScript to get a substring: `substring`, `substr` and `slice`.
+มี 3 เมธอดหลักใน JavaScript สำหรับการดึงสตริงย่อย: `substring`, `substr` และ `slice` แต่ละวิธีมีลักษณะการทำงานที่แตกต่างกันเล็กน้อย ดังนี้:
 
 `str.slice(start [, end])`
-: Returns the part of the string from `start` to (but not including) `end`.
+: ส่งคืนส่วนของสตริงจาก `start` ถึง (แต่ไม่รวม) `end`
 
-    For instance:
+    ตัวอย่างการใช้งาน:
 
     ```js run
     let str = "stringify";
-    alert( str.slice(0, 5) ); // 'strin', the substring from 0 to 5 (not including 5)
-    alert( str.slice(0, 1) ); // 's', from 0 to 1, but not including 1, so only character at 0
+    alert( str.slice(0, 5) ); // 'strin', สตริงย่อยจาก 0 ถึง 5 (ไม่รวม 5)
+    alert( str.slice(0, 1) ); // 's', จาก 0 ถึง 1 แต่ไม่รวม 1 ดังนั้นเป็นเพียงอักขระที่ 0
     ```
 
-    If there is no second argument, then `slice` goes till the end of the string:
+    ถ้าไม่ระบุอาร์กิวเมนต์ที่สอง `slice` จะดึงสตริงย่อยจนถึงท้ายสตริง:
 
     ```js run
     let str = "st*!*ringify*/!*";
-    alert( str.slice(2) ); // 'ringify', from the 2nd position till the end
+    alert( str.slice(2) ); // 'ringify', จากตำแหน่งที่ 2 จนถึงท้าย
     ```
 
-    Negative values for `start/end` are also possible. They mean the position is counted from the string end:
+    `slice` ยังรองรับค่าลบสำหรับ `start` และ `end` ซึ่งหมายถึงตำแหน่งจะถูกนับจากท้ายสตริง:
 
     ```js run
     let str = "strin*!*gif*/!*y";
 
-    // start at the 4th position from the right, end at the 1st from the right
+    // เริ่มที่ตำแหน่งที่ 4 จากขวา จบที่ตำแหน่งที่ 1 จากขวา
     alert( str.slice(-4, -1) ); // 'gif'
     ```
 
 `str.substring(start [, end])`
+<<<<<<< HEAD
+: ส่งคืนส่วนของสตริง*ระหว่าง* `start` และ `end` (ไม่รวม `end`)
+
+    การทำงานคล้ายกับ `slice` แต่มีความแตกต่างสำคัญคือ `substring` อนุญาตให้ `start` มีค่ามากกว่า `end` ได้ ในกรณีนี้มันจะสลับค่า `start` และ `end` โดยอัตโนมัติ
+=======
 : Returns the part of the string *between* `start` and `end` (not including `end`).
 
     This is almost the same as `slice`, but it allows `start` to be greater than `end` (in this case it simply swaps `start` and `end` values).
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-    For instance:
+    ตัวอย่างการใช้งาน:
 
     ```js run
     let str = "st*!*ring*/!*ify";
 
-    // these are same for substring
+    // ทั้งสองคำสั่งนี้ให้ผลลัพธ์เหมือนกันสำหรับ substring
     alert( str.substring(2, 6) ); // "ring"
     alert( str.substring(6, 2) ); // "ring"
 
-    // ...but not for slice:
-    alert( str.slice(2, 6) ); // "ring" (the same)
-    alert( str.slice(6, 2) ); // "" (an empty string)
+    // แต่ให้ผลต่างกันสำหรับ slice:
+    alert( str.slice(2, 6) ); // "ring" (เหมือนกัน)
+    alert( str.slice(6, 2) ); // "" (สตริงว่าง)
 
     ```
 
-    Negative arguments are (unlike slice) not supported, they are treated as `0`.
+    `substring` จะปฏิบัติกับอาร์กิวเมนต์ที่เป็นลบเสมือนเป็น `0` ซึ่งต่างจาก `slice`
 
 `str.substr(start [, length])`
-: Returns the part of the string from `start`, with the given `length`.
+: ส่งคืนส่วนของสตริงจาก `start` โดยมีความยาวที่กำหนด
 
-    In contrast with the previous methods, this one allows us to specify the `length` instead of the ending position:
+    วิธีนี้แตกต่างจากสองวิธีแรกตรงที่เราระบุ `length` แทนตำแหน่งสิ้นสุด:
 
     ```js run
     let str = "st*!*ring*/!*ify";
-    alert( str.substr(2, 4) ); // 'ring', from the 2nd position get 4 characters
+    alert( str.substr(2, 4) ); // 'ring', จากตำแหน่งที่ 2 ดึง 4 อักขระ
     ```
 
-    The first argument may be negative, to count from the end:
+    อาร์กิวเมนต์แรกสามารถเป็นค่าลบได้ เพื่อนับจากท้ายสตริง:
 
     ```js run
     let str = "strin*!*gi*/!*fy";
-    alert( str.substr(-4, 2) ); // 'gi', from the 4th position get 2 characters
+    alert( str.substr(-4, 2) ); // 'gi', จากตำแหน่งที่ 4 จากท้าย ดึง 2 อักขระ
     ```
 
+<<<<<<< HEAD
+    อย่างไรก็ตาม ควรระมัดระวังในการใช้ `substr` เนื่องจากมีอยู่ใน [Annex B](https://tc39.es/ecma262/#sec-string.prototype.substr) ของข้อกำหนดภาษา JavaScript ซึ่งหมายความว่าอาจไม่ได้รับการสนับสนุนในสภาพแวดล้อมที่ไม่ใช่เบราว์เซอร์ แม้ว่าในทางปฏิบัติจะได้รับการสนับสนุนในเกือบทุกที่ แต่ก็ไม่แนะนำให้ใช้ในโค้ดใหม่
+=======
     This method resides in the [Annex B](https://tc39.es/ecma262/#sec-string.prototype.substr) of the language specification. It means that only browser-hosted Javascript engines should support it, and it's not recommended to use it. In practice, it's supported everywhere.
 
 Let's recap these methods to avoid any confusion:
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-| method | selects... | negatives |
+สรุปเมธอดเหล่านี้เพื่อให้เข้าใจง่ายขึ้น:
+
+| เมธอด | เลือก... | ค่าลบ |
 |--------|-----------|-----------|
+<<<<<<< HEAD
+| `slice(start, end)` | จาก `start` ถึง `end` (ไม่รวม `end`) | อนุญาตค่าลบ |
+| `substring(start, end)` | ระหว่าง `start` และ `end` (ไม่รวม `end`) | ค่าลบหมายถึง `0` |
+| `substr(start, length)` | จาก `start` ดึง `length` อักขระ | อนุญาต `start` เป็นลบ |
+=======
 | `slice(start, end)` | from `start` to `end` (not including `end`) | allows negatives |
 | `substring(start, end)` | between `start` and `end` (not including `end`)| negative values mean `0` |
 | `substr(start, length)` | from `start` get `length` characters | allows negative `start` |
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
+
+```smart header="ควรเลือกใช้เมธอดไหนดี?"
+ทั้งสามเมธอดสามารถทำงานได้ แต่แต่ละวิธีมีข้อดีและข้อจำกัดต่างกัน:
 
-```smart header="Which one to choose?"
-All of them can do the job. Formally, `substr` has a minor drawback: it is described not in the core JavaScript specification, but in Annex B, which covers browser-only features that exist mainly for historical reasons. So, non-browser environments may fail to support it. But in practice it works everywhere.
+<<<<<<< HEAD
+- `substr` มีข้อเสียคือไม่ได้อยู่ในข้อกำหนดหลักของ JavaScript แต่อยู่ใน Annex B ซึ่งครอบคลุมคุณลักษณะที่มีไว้เพื่อความเข้ากันได้กับโค้ดเก่าเป็นหลัก อาจมีปัญหาในสภาพแวดล้อมที่ไม่ใช่เบราว์เซอร์
+- `substring` มีพฤติกรรมแปลกๆ กับค่าลบ ซึ่งอาจทำให้สับสนได้
+- `slice` มีความยืดหยุ่นมากที่สุด รองรับค่าลบได้ และมีไวยากรณ์ที่เข้าใจง่าย
 
+ดังนั้น สำหรับการใช้งานทั่วไป การจดจำและใช้แค่ `slice` ก็เพียงพอและปลอดภัยที่สุด
+=======
 Of the other two variants, `slice` is a little bit more flexible, it allows negative arguments and shorter to write.
 
 So, for practical use it's enough to remember only `slice`.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 ```
 
-## Comparing strings
+## การเปรียบเทียบสตริง
 
-As we know from the chapter <info:comparison>, strings are compared character-by-character in alphabetical order.
+การเปรียบเทียบสตริงใน JavaScript ใช้การเปรียบเทียบทีละอักขระตามลำดับตัวอักษร (lexicographical order) ซึ่งอาจให้ผลลัพธ์ที่แตกต่างจากที่คาดไว้ในบางกรณี:
 
-Although, there are some oddities.
-
-1. A lowercase letter is always greater than the uppercase:
+1. ตัวพิมพ์เล็กจะมากกว่าตัวพิมพ์ใหญ่เสมอ:
 
     ```js run
     alert( 'a' > 'Z' ); // true
     ```
 
-2. Letters with diacritical marks are "out of order":
+2. ตัวอักษรที่มีเครื่องหมายกำกับอาจไม่เรียงตามที่คาดหวัง:
 
     ```js run
     alert( 'Österreich' > 'Zealand' ); // true
     ```
 
-    This may lead to strange results if we sort these country names. Usually people would expect `Zealand` to come after `Österreich` in the list.
+    ผลลัพธ์นี้อาจดูแปลกประหลาดถ้าเราเรียงลำดับชื่อประเทศ โดยปกติแล้วคนจะคาดหวังว่า `Zealand` ควรมาหลัง `Österreich` ในรายการที่เรียงตามตัวอักษร
+
+<<<<<<< HEAD
+เพื่อเข้าใจว่าทำไมจึงเป็นเช่นนี้ เราต้องรู้ว่าสตริงใน JavaScript ถูกเข้ารหัสโดยใช้ [UTF-16](https://en.wikipedia.org/wiki/UTF-16) ซึ่งหมายความว่าแต่ละอักขระมีรหัสตัวเลขที่สอดคล้องกัน
+
+JavaScript มีเมธอดพิเศษที่ช่วยให้เราได้รหัสของอักขระและสร้างอักขระจากรหัส:
+
+`str.codePointAt(pos)`
+: ส่งคืนรหัส Unicode ของอักขระที่ตำแหน่ง `pos`:
 
+    ```js run
+    // ตัวอักษรที่มีตัวพิมพ์ต่างกันจะมีรหัสต่างกัน
+    alert( "Z".codePointAt(0) ); // 90
+    alert( "z".codePointAt(0) ); // 122
+    alert( "z".codePointAt(0).toString(16) ); // 7a (ถ้าเราต้องการค่าฐานสิบหก)
+=======
 To understand what happens, we should be aware that strings in Javascript are encoded using [UTF-16](https://en.wikipedia.org/wiki/UTF-16). That is: each character has a corresponding numeric code.
 
 There are special methods that allow to get the character for the code and back:
@@ -444,17 +585,25 @@ There are special methods that allow to get the character for the code and back:
     alert( "Z".codePointAt(0) ); // 90
     alert( "z".codePointAt(0) ); // 122
     alert( "z".codePointAt(0).toString(16) ); // 7a (if we need a hexadecimal value)
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
     ```
 
 `String.fromCodePoint(code)`
-: Creates a character by its numeric `code`
+: สร้างอักขระจากรหัส Unicode ที่กำหนด:
 
     ```js run
     alert( String.fromCodePoint(90) ); // Z
+<<<<<<< HEAD
+    alert( String.fromCodePoint(0x5a) ); // Z (เราสามารถใช้ค่าฐานสิบหกเป็นอาร์กิวเมนต์ได้ด้วย)
+    ```
+
+เราสามารถทดลองดูอักขระที่มีรหัสระหว่าง 65 ถึง 220 (ซึ่งครอบคลุมตัวอักษรละตินและสัญลักษณ์พิเศษบางตัว) ได้ดังนี้:
+=======
     alert( String.fromCodePoint(0x5a) ); // Z (we can also use a hex value as an argument)
     ```
 
 Now let's see the characters with codes `65..220` (the latin alphabet and a little bit extra) by making a string of them:
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
 ```js run
 let str = '';
@@ -463,26 +612,35 @@ for (let i = 65; i <= 220; i++) {
   str += String.fromCodePoint(i);
 }
 alert( str );
+<<<<<<< HEAD
+// ผลลัพธ์:
+// ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
+=======
 // Output:
 // ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 // ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜ
 ```
 
-See? Capital characters go first, then a few special ones, then lowercase characters, and `Ö` near the end of the output.
+จากผลลัพธ์นี้ เราจะเห็นว่าตัวอักษรตัวพิมพ์ใหญ่มาก่อน ตามด้วยสัญลักษณ์พิเศษบางตัว แล้วจึงเป็นตัวอักษรตัวพิมพ์เล็ก และตัวอักษรที่มีเครื่องหมายกำกับ (เช่น Ö) อยู่ท้ายสุด
 
-Now it becomes obvious why `a > Z`.
+ตอนนี้เราเข้าใจแล้วว่าทำไม `'a' > 'Z'`:
 
-The characters are compared by their numeric code. The greater code means that the character is greater. The code for `a` (97) is greater than the code for `Z` (90).
+1. อักขระถูกเปรียบเทียบโดยใช้รหัสตัวเลขของพวกมัน
+2. รหัสที่มากกว่าหมายถึงอักขระนั้น "มากกว่า" ในการเปรียบเทียบ
+3. รหัสสำหรับ `a` (97) มากกว่ารหัสสำหรับ `Z` (90)
 
-- All lowercase letters go after uppercase letters because their codes are greater.
-- Some letters like `Ö` stand apart from the main alphabet. Here, its code is greater than anything from `a` to `z`.
+### การเปรียบเทียบที่ถูกต้องตามภาษา
 
-### Correct comparisons [#correct-comparisons]
+อัลกอริทึมการเปรียบเทียบสตริง "ที่ถูกต้อง" ตามหลักภาษาศาสตร์นั้นซับซ้อนกว่าที่คิด เพราะภาษาต่างๆ มีกฎการเรียงลำดับตัวอักษรที่แตกต่างกัน
 
-The "right" algorithm to do string comparisons is more complex than it may seem, because alphabets are different for different languages.
+โชคดีที่เบราว์เซอร์สมัยใหม่ (และ Node.js) สนับสนุนมาตรฐานการทำให้เป็นสากล [ECMA-402](https://www.ecma-international.org/publications-and-standards/standards/ecma-402/) ซึ่งให้วิธีการเปรียบเทียบสตริงที่คำนึงถึงกฎของแต่ละภาษา
 
-So, the browser needs to know the language to compare.
+เราสามารถใช้เมธอด [str.localeCompare(str2)](mdn:js/String/localeCompare) เพื่อเปรียบเทียบสตริงตามกฎภาษา:
 
+<<<<<<< HEAD
+ตัวอย่างเช่น:
+=======
 Luckily, modern browsers support the internationalization standard [ECMA-402](https://www.ecma-international.org/publications-and-standards/standards/ecma-402/).
 
 It provides a special method to compare strings in different languages, following their rules.
@@ -494,13 +652,69 @@ The call [str.localeCompare(str2)](mdn:js/String/localeCompare) returns an integ
 - Returns `0` if they are equivalent.
 
 For instance:
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
 ```js run
 alert( 'Österreich'.localeCompare('Zealand') ); // -1
 ```
+เข้าใจครับ ผมจะขยายความเฉพาะส่วนที่เกี่ยวกับ `localeCompare` และสรุปตามที่ระบุไว้ในต้นฉบับ โดยไม่เพิ่มเติมเนื้อหาใหม่
+
+เมธอด `localeCompare` มีอาร์กิวเมนต์เพิ่มเติมที่ช่วยให้เราสามารถปรับแต่งการเปรียบเทียบได้ดังนี้:
+
+<<<<<<< HEAD
+```js
+str.localeCompare(str2, [locales, [options]])
+```
+
+- `locales`: ช่วยระบุภาษาที่ใช้ในการเปรียบเทียบ โดยค่าเริ่มต้นจะใช้ภาษาตามสภาพแวดล้อมของระบบ
+- `options`: เป็นวัตถุที่ใช้กำหนดกฎเพิ่มเติมในการเปรียบเทียบ เช่น การคำนึงถึงตัวพิมพ์ใหญ่-เล็ก หรือการปฏิบัติต่ออักขระที่มีเครื่องหมายกำกับ
+
+การใช้อาร์กิวเมนต์เหล่านี้ช่วยให้เราสามารถปรับแต่งการเปรียบเทียบให้เหมาะกับความต้องการเฉพาะได้ เช่น การเปรียบเทียบโดยไม่คำนึงถึงตัวพิมพ์ใหญ่-เล็ก หรือการปฏิบัติต่อตัวอักษรที่มีเครื่องหมายกำกับ (เช่น "a" และ "á") ให้เหมือนกัน
+
+## สรุป
+
+เรามาสรุปสาระสำคัญเกี่ยวกับการจัดการสตริงใน JavaScript กัน:
+
+1. **การสร้างสตริง**: สามารถใช้เครื่องหมายคำพูดเดี่ยว (''), คู่ ("") หรือ backticks (``). Backticks มีความสามารถพิเศษในการแทรกนิพจน์และสร้างสตริงหลายบรรทัด
+
+2. **การเข้าถึงอักขระ**: ใช้วงเล็บเหลี่ยม `[]` หรือเมธอด `at()` โดย `at()` สามารถใช้ดัชนีเชิงลบได้
+
+3. **การเปลี่ยนตัวพิมพ์**: ใช้ `toLowerCase()` และ `toUpperCase()`
+
+4. **การค้นหาสตริงย่อย**: 
+   - `indexOf()`: หาตำแหน่งแรกที่พบ
+   - `includes()`: ตรวจสอบการมีอยู่
+   - `startsWith()` และ `endsWith()`: ตรวจสอบการขึ้นต้นและลงท้าย
+
+5. **การดึงสตริงย่อย**: 
+   - `slice(start, end)`: ดึงจาก start ถึง (ไม่รวม) end, รองรับดัชนีลบ
+   - `substring(start, end)`: คล้าย slice แต่ไม่รองรับดัชนีลบ
+   - `substr(start, length)`: ดึงตามความยาวที่กำหนด (ไม่แนะนำให้ใช้ในโค้ดใหม่)
+
+6. **การเปรียบเทียบสตริง**: 
+   - ใช้เครื่องหมาย `<`, `>`, `==`, `===` สำหรับการเปรียบเทียบทั่วไป
+   - ใช้ `localeCompare()` สำหรับการเปรียบเทียบที่คำนึงถึงภาษา
+
+7. **อักขระพิเศษ**: เช่น `\n` สำหรับขึ้นบรรทัดใหม่, `\t` สำหรับแท็บ, `\'` และ `\"` สำหรับเครื่องหมายคำพูด
+
+8. **ความยาวของสตริง**: ใช้คุณสมบัติ `length`
+
+9. **สตริงเป็นข้อมูลที่ไม่สามารถเปลี่ยนแปลงได้ (immutable)**: การแก้ไขสตริงต้องสร้างสตริงใหม่เสมอ
+
+10. **การทำงานกับ Unicode**: ใช้ `codePointAt()` และ `String.fromCodePoint()` สำหรับการจัดการรหัส Unicode
+
+เมื่อทำงานกับสตริง สิ่งสำคัญคือต้องเลือกใช้เมธอดที่เหมาะสมกับงาน และระมัดระวังเรื่องประสิทธิภาพเมื่อต้องทำงานกับสตริงขนาดใหญ่หรือการดำเนินการซ้ำๆ
+
+นอกจากนี้ JavaScript ยังมีเมธอดอื่นๆ สำหรับการจัดการสตริงที่มีประโยชน์ เช่น:
+
+- `trim()`: ลบช่องว่างจากจุดเริ่มต้นและจุดสิ้นสุดของสตริง
+- `repeat(n)`: ทำซ้ำสตริง `n` ครั้ง
+- `padStart()` และ `padEnd()`: เติมสตริงให้ได้ความยาวที่กำหนด
 
-This method actually has two additional arguments specified in [the documentation](mdn:js/String/localeCompare), which allows it to specify the language (by default taken from the environment, letter order depends on the language) and setup additional rules like case sensitivity or should `"a"` and `"á"` be treated as the same etc.
+สำหรับการค้นหาและแทนที่ที่ซับซ้อนมากขึ้น JavaScript รองรับการใช้นิพจน์ทั่วไป (Regular Expressions) ซึ่งเป็นเครื่องมือที่ทรงพลังสำหรับการจัดการกับรูปแบบของสตริง
 
+สุดท้าย เมื่อทำงานกับสตริงที่มีอักขระพิเศษหรือต้องการความถูกต้องในการจัดการกับ Unicode ควรศึกษาเพิ่มเติมเกี่ยวกับการทำงานของ Unicode ใน JavaScript เพื่อหลีกเลี่ยงปัญหาที่อาจเกิดขึ้นกับอักขระบางตัว ดูเพิ่มเติมได้ที่บทเรียนนี้ info:unicode
+=======
 ## Summary
 
 - There are 3 types of quotes. Backticks allow a string to span multiple lines and embed expressions `${…}`.
@@ -520,3 +734,4 @@ There are several other helpful methods in strings:
 Strings also have methods for doing search/replace with regular expressions. But that's big topic, so it's explained in a separate tutorial section <info:regular-expressions>.
 
 Also, as of now it's important to know that strings are based on Unicode encoding, and hence there're issues with comparisons. There's more about Unicode in the chapter <info:unicode>.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
diff --git a/1-js/05-data-types/09-destructuring-assignment/article.md b/1-js/05-data-types/09-destructuring-assignment/article.md
new file mode 100644
index 000000000..e69de29bb
diff --git a/1-js/05-data-types/09-destructuring-assignment/destructuring-complex.svg b/1-js/05-data-types/09-destructuring-assignment/destructuring-complex.svg
new file mode 100644
index 000000000..c3e25b569
--- /dev/null
+++ b/1-js/05-data-types/09-destructuring-assignment/destructuring-complex.svg
@@ -0,0 +1,59 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg width="488px" height="150px" viewBox="0 0 488 150" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
+    <!-- Generator: sketchtool 55.2 (78181) - https://sketchapp.com -->
+    <title>destructuring-complex.svg</title>
+    <desc>Created with sketchtool.</desc>
+    <g id="combined" stroke="none" stroke-width="1" fill="none" fill-rule="evenodd">
+        <g id="destructuring-complex.svg" fill-rule="nonzero">
+            <g id="let-options-=-{" transform="translate(275.175781, 11.101562)">
+                <path d="M2.25585938,1.21679688 L0.225585938,1.21679688 L0.225585938,0.239257812 L3.45898438,0.239257812 L3.45898438,8.90722656 L5.50292969,8.90722656 L5.50292969,9.8984375 L0,9.8984375 L0,8.90722656 L2.25585938,8.90722656 L2.25585938,1.21679688 Z M13.4121094,6.10449219 C13.4121094,6.27311282 13.4098308,6.41438745 13.4052734,6.52832031 C13.4007161,6.64225317 13.3938803,6.74934846 13.3847656,6.84960938 L8.56542969,6.84960938 C8.56542969,7.5514358 8.76139127,8.09033015 9.15332031,8.46630859 C9.54524936,8.84228704 10.1103479,9.03027344 10.8486328,9.03027344 C11.0491546,9.03027344 11.2496735,9.02229826 11.4501953,9.00634766 C11.6507171,8.99039706 11.8444001,8.96875014 12.03125,8.94140625 C12.2180999,8.91406236 12.3969718,8.88330095 12.5678711,8.84912109 C12.7387704,8.81494124 12.8971347,8.77734396 13.0429688,8.73632812 L13.0429688,9.71386719 C12.7193994,9.80501348 12.3536804,9.87906873 11.9458008,9.93603516 C11.5379211,9.99300159 11.1152366,10.0214844 10.6777344,10.0214844 C10.0898408,10.0214844 9.58398649,9.94173257 9.16015625,9.78222656 C8.73632601,9.62272056 8.38883599,9.39144032 8.11767578,9.08837891 C7.84651557,8.7853175 7.64599674,8.41390194 7.51611328,7.97412109 C7.38622982,7.53434025 7.32128906,7.03646111 7.32128906,6.48046875 C7.32128906,5.99739342 7.39078707,5.5405295 7.52978516,5.10986328 C7.66878325,4.67919707 7.8715807,4.30094564 8.13818359,3.97509766 C8.40478649,3.64924967 8.7317689,3.39062596 9.11914062,3.19921875 C9.50651235,3.00781154 9.9462866,2.91210938 10.4384766,2.91210938 C10.9169946,2.91210938 11.3408185,2.98730394 11.7099609,3.13769531 C12.0791034,3.28808669 12.3901355,3.50113794 12.6430664,3.77685547 C12.8959974,4.05257299 13.0874017,4.38753058 13.2172852,4.78173828 C13.3471686,5.17594598 13.4121094,5.61685954 13.4121094,6.10449219 Z M12.1748047,5.93359375 C12.1884766,5.62825368 12.1588545,5.34912236 12.0859375,5.09619141 C12.0130205,4.84326045 11.9002286,4.62565195 11.7475586,4.44335938 C11.5948886,4.2610668 11.4046235,4.11865286 11.1767578,4.01611328 C10.9488921,3.91357371 10.6845718,3.86230469 10.3837891,3.86230469 C10.1240221,3.86230469 9.88704534,3.91243439 9.67285156,4.01269531 C9.45865778,4.11295623 9.27408932,4.25423086 9.11914062,4.43652344 C8.96419193,4.61881602 8.83886767,4.83756383 8.74316406,5.09277344 C8.64746046,5.34798305 8.58821626,5.62825368 8.56542969,5.93359375 L12.1748047,5.93359375 Z M20.8427734,9.80273438 C20.5738919,9.87109409 20.2958999,9.92008449 20.0087891,9.94970703 C19.7216783,9.97932958 19.4300145,9.99414062 19.1337891,9.99414062 C18.2724566,9.99414062 17.6298849,9.79931835 17.2060547,9.40966797 C16.7822244,9.02001758 16.5703125,8.42187903 16.5703125,7.61523437 L16.5703125,4.03320312 L14.6494141,4.03320312 L14.6494141,3.03515625 L16.5703125,3.03515625 L16.5703125,1.1484375 L17.7597656,0.840820312 L17.7597656,3.03515625 L20.8427734,3.03515625 L20.8427734,4.03320312 L17.7597656,4.03320312 L17.7597656,7.51953125 C17.7597656,8.01172121 17.8907865,8.37971883 18.152832,8.62353516 C18.4148776,8.86735148 18.8011042,8.98925781 19.3115234,8.98925781 C19.5302745,8.98925781 19.76953,8.97216814 20.0292969,8.93798828 C20.2890638,8.90380842 20.5602199,8.85026078 20.8427734,8.77734375 L20.8427734,9.80273438 Z" id="let" fill="#0077AA"></path>
+                <path d="M36.6816406,6.41210938 C36.6816406,6.94531517 36.6064461,7.43407981 36.4560547,7.87841797 C36.3056633,8.32275613 36.0891941,8.70328618 35.8066406,9.02001953 C35.5240871,9.33675289 35.180015,9.58284417 34.7744141,9.75830078 C34.3688131,9.93375739 33.9085312,10.0214844 33.3935547,10.0214844 C32.9013647,10.0214844 32.4604512,9.9451505 32.0708008,9.79248047 C31.6811504,9.63981043 31.3507501,9.41536606 31.0795898,9.11914062 C30.8084296,8.82291519 30.6010749,8.45605688 30.4575195,8.01855469 C30.3139641,7.5810525 30.2421875,7.07747681 30.2421875,6.5078125 C30.2421875,5.97460671 30.3173821,5.48812069 30.4677734,5.04833984 C30.6181648,4.608559 30.834634,4.23030757 31.1171875,3.91357422 C31.399741,3.59684086 31.7438131,3.35074958 32.1494141,3.17529297 C32.555015,2.99983636 33.0152969,2.91210938 33.5302734,2.91210938 C34.0224634,2.91210938 34.463377,2.98844325 34.8530273,3.14111328 C35.2426777,3.29378332 35.5730781,3.51708837 35.8442383,3.81103516 C36.1153985,4.10498194 36.3227532,4.47070094 36.4663086,4.90820312 C36.609864,5.34570531 36.6816406,5.84700238 36.6816406,6.41210938 Z M35.4648438,6.46679688 C35.4648438,6.04296663 35.418132,5.67269039 35.324707,5.35595703 C35.2312821,5.03922368 35.0979826,4.7749034 34.9248047,4.56298828 C34.7516267,4.35107316 34.5408541,4.19156955 34.2924805,4.08447266 C34.0441068,3.97737577 33.7672541,3.92382812 33.4619141,3.92382812 C33.1064435,3.92382812 32.8022474,3.99332613 32.5493164,4.13232422 C32.2963855,4.27132231 32.0890308,4.45703009 31.9272461,4.68945312 C31.7654614,4.92187616 31.646973,5.19189299 31.5717773,5.49951172 C31.4965817,5.80713044 31.4589844,6.12955561 31.4589844,6.46679688 C31.4589844,6.89062712 31.5056961,7.26204268 31.5991211,7.58105469 C31.692546,7.9000667 31.8258455,8.16552628 31.9990234,8.37744141 C32.1722014,8.58935653 32.3818347,8.74886014 32.6279297,8.85595703 C32.8740247,8.96305392 33.1520167,9.01660156 33.4619141,9.01660156 C33.8173846,9.01660156 34.1215808,8.94710356 34.3745117,8.80810547 C34.6274427,8.66910738 34.8347974,8.4833996 34.996582,8.25097656 C35.1583667,8.01855353 35.2768551,7.74853669 35.3520508,7.44091797 C35.4272465,7.13329924 35.4648438,6.80859546 35.4648438,6.46679688 Z M44.2695312,6.34375 C44.2695312,6.95443014 44.1840829,7.48762793 44.0131836,7.94335938 C43.8422843,8.39909082 43.6064468,8.77734225 43.3056641,9.078125 C43.0048813,9.37890775 42.6494161,9.60449144 42.2392578,9.75488281 C41.8290995,9.90527419 41.384768,9.98046875 40.90625,9.98046875 C40.6874989,9.98046875 40.4698904,9.96907563 40.253418,9.94628906 C40.0369455,9.92350249 39.8170584,9.8847659 39.59375,9.83007812 L39.59375,12.7011719 L38.4042969,12.7011719 L38.4042969,3.03515625 L39.4638672,3.03515625 L39.5390625,4.18359375 C39.8808611,3.71419036 40.2454408,3.38492933 40.6328125,3.19580078 C41.0201842,3.00667223 41.4394509,2.91210938 41.890625,2.91210938 C42.282554,2.91210938 42.6266261,2.9941398 42.9228516,3.15820312 C43.219077,3.32226645 43.4674469,3.55354668 43.6679688,3.85205078 C43.8684906,4.15055488 44.0188797,4.51057732 44.1191406,4.93212891 C44.2194015,5.35368049 44.2695312,5.82421615 44.2695312,6.34375 Z M43.0527344,6.3984375 C43.0527344,6.03840966 43.0265302,5.70800932 42.9741211,5.40722656 C42.921712,5.10644381 42.8385422,4.8489594 42.7246094,4.63476562 C42.6106765,4.42057185 42.4648446,4.25309305 42.2871094,4.13232422 C42.1093741,4.01155539 41.8974622,3.95117188 41.6513672,3.95117188 C41.5009758,3.95117188 41.3483081,3.97509742 41.1933594,4.02294922 C41.0384107,4.07080102 40.8777678,4.15055283 40.7114258,4.26220703 C40.5450838,4.37386124 40.3696298,4.52197173 40.1850586,4.70654297 C40.0004874,4.8911142 39.8033865,5.12011582 39.59375,5.39355469 L39.59375,8.72265625 C39.8125011,8.81380254 40.042642,8.88557917 40.2841797,8.93798828 C40.5257174,8.9903974 40.7626942,9.01660156 40.9951172,9.01660156 C41.6376985,9.01660156 42.1412742,8.79899306 42.5058594,8.36376953 C42.8704445,7.928546 43.0527344,7.27344188 43.0527344,6.3984375 Z M51.6318359,9.80273438 C51.3629544,9.87109409 51.0849624,9.92008449 50.7978516,9.94970703 C50.5107408,9.97932958 50.219077,9.99414062 49.9228516,9.99414062 C49.0615191,9.99414062 48.4189474,9.79931835 47.9951172,9.40966797 C47.5712869,9.02001758 47.359375,8.42187903 47.359375,7.61523437 L47.359375,4.03320312 L45.4384766,4.03320312 L45.4384766,3.03515625 L47.359375,3.03515625 L47.359375,1.1484375 L48.5488281,0.840820312 L48.5488281,3.03515625 L51.6318359,3.03515625 L51.6318359,4.03320312 L48.5488281,4.03320312 L48.5488281,7.51953125 C48.5488281,8.01172121 48.679849,8.37971883 48.9418945,8.62353516 C49.2039401,8.86735148 49.5901667,8.98925781 50.1005859,8.98925781 C50.319337,8.98925781 50.5585925,8.97216814 50.8183594,8.93798828 C51.0781263,8.90380842 51.3492824,8.85026078 51.6318359,8.77734375 L51.6318359,9.80273438 Z M56.1367188,4.01953125 L54.1064453,4.01953125 L54.1064453,3.03515625 L57.3398438,3.03515625 L57.3398438,8.90722656 L59.3837891,8.90722656 L59.3837891,9.8984375 L53.8808594,9.8984375 L53.8808594,8.90722656 L56.1367188,8.90722656 L56.1367188,4.01953125 Z M56.5537109,0.157226562 C56.6858731,0.157226562 56.8089187,0.181152104 56.9228516,0.229003906 C57.0367844,0.276855708 57.1359045,0.344075088 57.2202148,0.430664062 C57.3045252,0.517253037 57.3706052,0.61637314 57.418457,0.728027344 C57.4663088,0.839681548 57.4902344,0.961587881 57.4902344,1.09375 C57.4902344,1.2213548 57.4663088,1.34212183 57.418457,1.45605469 C57.3706052,1.56998755 57.3045252,1.67024696 57.2202148,1.75683594 C57.1359045,1.84342491 57.0367844,1.91064429 56.9228516,1.95849609 C56.8089187,2.0063479 56.6858731,2.03027344 56.5537109,2.03027344 C56.4215488,2.03027344 56.2985032,2.0063479 56.1845703,1.95849609 C56.0706375,1.91064429 55.9715173,1.84342491 55.887207,1.75683594 C55.8028967,1.67024696 55.7368166,1.56998755 55.6889648,1.45605469 C55.641113,1.34212183 55.6171875,1.2213548 55.6171875,1.09375 C55.6171875,0.961587881 55.641113,0.839681548 55.6889648,0.728027344 C55.7368166,0.61637314 55.8028967,0.517253037 55.887207,0.430664062 C55.9715173,0.344075088 56.0706375,0.276855708 56.1845703,0.229003906 C56.2985032,0.181152104 56.4215488,0.157226562 56.5537109,0.157226562 Z M67.4707031,6.41210938 C67.4707031,6.94531517 67.3955086,7.43407981 67.2451172,7.87841797 C67.0947258,8.32275613 66.8782566,8.70328618 66.5957031,9.02001953 C66.3131496,9.33675289 65.9690775,9.58284417 65.5634766,9.75830078 C65.1578756,9.93375739 64.6975937,10.0214844 64.1826172,10.0214844 C63.6904272,10.0214844 63.2495137,9.9451505 62.8598633,9.79248047 C62.4702129,9.63981043 62.1398126,9.41536606 61.8686523,9.11914062 C61.5974921,8.82291519 61.3901374,8.45605688 61.246582,8.01855469 C61.1030266,7.5810525 61.03125,7.07747681 61.03125,6.5078125 C61.03125,5.97460671 61.1064446,5.48812069 61.2568359,5.04833984 C61.4072273,4.608559 61.6236965,4.23030757 61.90625,3.91357422 C62.1888035,3.59684086 62.5328756,3.35074958 62.9384766,3.17529297 C63.3440775,2.99983636 63.8043594,2.91210938 64.3193359,2.91210938 C64.8115259,2.91210938 65.2524395,2.98844325 65.6420898,3.14111328 C66.0317402,3.29378332 66.3621406,3.51708837 66.6333008,3.81103516 C66.904461,4.10498194 67.1118157,4.47070094 67.2553711,4.90820312 C67.3989265,5.34570531 67.4707031,5.84700238 67.4707031,6.41210938 Z M66.2539062,6.46679688 C66.2539062,6.04296663 66.2071945,5.67269039 66.1137695,5.35595703 C66.0203446,5.03922368 65.8870451,4.7749034 65.7138672,4.56298828 C65.5406892,4.35107316 65.3299166,4.19156955 65.081543,4.08447266 C64.8331693,3.97737577 64.5563166,3.92382812 64.2509766,3.92382812 C63.895506,3.92382812 63.5913099,3.99332613 63.3383789,4.13232422 C63.085448,4.27132231 62.8780933,4.45703009 62.7163086,4.68945312 C62.5545239,4.92187616 62.4360355,5.19189299 62.3608398,5.49951172 C62.2856442,5.80713044 62.2480469,6.12955561 62.2480469,6.46679688 C62.2480469,6.89062712 62.2947586,7.26204268 62.3881836,7.58105469 C62.4816085,7.9000667 62.614908,8.16552628 62.7880859,8.37744141 C62.9612639,8.58935653 63.1708972,8.74886014 63.4169922,8.85595703 C63.6630872,8.96305392 63.9410792,9.01660156 64.2509766,9.01660156 C64.6064471,9.01660156 64.9106433,8.94710356 65.1635742,8.80810547 C65.4165052,8.66910738 65.6238599,8.4833996 65.7856445,8.25097656 C65.9474292,8.01855353 66.0659176,7.74853669 66.1411133,7.44091797 C66.216309,7.13329924 66.2539062,6.80859546 66.2539062,6.46679688 Z M69.1933594,3.03515625 L70.2529297,3.03515625 L70.3007812,4.14257812 C70.5013031,3.90559777 70.694986,3.70849688 70.8818359,3.55126953 C71.0686858,3.39404218 71.252115,3.2675786 71.4321289,3.171875 C71.6121428,3.0761714 71.795572,3.00895202 71.9824219,2.97021484 C72.1692718,2.93147767 72.3629547,2.91210938 72.5634766,2.91210938 C73.2698603,2.91210938 73.8041974,3.12060338 74.1665039,3.53759766 C74.5288104,3.95459193 74.7099609,4.58235258 74.7099609,5.42089844 L74.7099609,9.8984375 L73.5205078,9.8984375 L73.5205078,5.51660156 C73.5205078,4.97883846 73.4202484,4.58121874 73.2197266,4.32373047 C73.0192047,4.0662422 72.7207051,3.9375 72.3242188,3.9375 C72.1783847,3.9375 72.0359707,3.95914692 71.8969727,4.00244141 C71.7579746,4.04573589 71.613282,4.12093045 71.4628906,4.22802734 C71.3124992,4.33512423 71.1495777,4.4798168 70.9741211,4.66210938 C70.7986645,4.84440195 70.6015636,5.07226426 70.3828125,5.34570312 L70.3828125,9.8984375 L69.1933594,9.8984375 L69.1933594,3.03515625 Z M82.3251953,8.02539062 C82.3251953,8.26692829 82.2841801,8.48339748 82.2021484,8.67480469 C82.1201168,8.86621189 82.0084642,9.03596931 81.8671875,9.18408203 C81.7259108,9.33219475 81.5618499,9.45865833 81.375,9.56347656 C81.1881501,9.66829479 80.9887706,9.75488247 80.7768555,9.82324219 C80.5649403,9.8916019 80.3473318,9.94173161 80.1240234,9.97363281 C79.900715,10.005534 79.6819672,10.0214844 79.4677734,10.0214844 C79.0029274,10.0214844 78.5756855,10.0009768 78.1860352,9.95996094 C77.7963848,9.91894511 77.4147154,9.85286504 77.0410156,9.76171875 L77.0410156,8.66796875 C77.4420593,8.78190161 77.8408183,8.86848929 78.2373047,8.92773438 C78.633791,8.98697946 79.0279928,9.01660156 79.4199219,9.01660156 C79.9895862,9.01660156 80.4111314,8.93912838 80.6845703,8.78417969 C80.9580092,8.629231 81.0947266,8.40820456 81.0947266,8.12109375 C81.0947266,7.99804626 81.0730796,7.88753304 81.0297852,7.78955078 C80.9864907,7.69156852 80.9078782,7.59814498 80.7939453,7.50927734 C80.6800125,7.42040971 80.5034192,7.32812548 80.2641602,7.23242188 C80.0249011,7.13671827 79.6979187,7.02734437 79.2832031,6.90429688 C78.9733057,6.81315059 78.6873385,6.70947324 78.425293,6.59326172 C78.1632474,6.4770502 77.9365244,6.33919351 77.7451172,6.1796875 C77.55371,6.02018149 77.4033209,5.8333344 77.2939453,5.61914062 C77.1845698,5.40494685 77.1298828,5.15201969 77.1298828,4.86035156 C77.1298828,4.66894436 77.174316,4.45931104 77.2631836,4.23144531 C77.3520512,4.00357959 77.5035797,3.79166765 77.7177734,3.59570312 C77.9319672,3.3997386 78.2213523,3.23681706 78.5859375,3.10693359 C78.9505227,2.97705013 79.4062473,2.91210938 79.953125,2.91210938 C80.2220066,2.91210938 80.5205062,2.92692042 80.8486328,2.95654297 C81.1767595,2.98616551 81.5185529,3.03743453 81.8740234,3.11035156 L81.8740234,4.16992188 C81.5003237,4.07877559 81.1459978,4.01155621 80.8110352,3.96826172 C80.4760725,3.92496723 80.1855481,3.90332031 79.9394531,3.90332031 C79.6432277,3.90332031 79.3937185,3.92610654 79.190918,3.97167969 C78.9881175,4.01725283 78.8240566,4.07991497 78.6987305,4.15966797 C78.5734043,4.23942097 78.4833987,4.33284452 78.4287109,4.43994141 C78.3740232,4.5470383 78.3466797,4.66210876 78.3466797,4.78515625 C78.3466797,4.90820374 78.3706052,5.01985627 78.418457,5.12011719 C78.4663088,5.22037811 78.5551751,5.31721958 78.6850586,5.41064453 C78.8149421,5.50406948 78.9960926,5.59749302 79.2285156,5.69091797 C79.4609387,5.78434292 79.7639955,5.88574164 80.1376953,5.99511719 C80.5432963,6.11360736 80.8850898,6.23779232 81.1630859,6.36767578 C81.4410821,6.49755924 81.6666658,6.64225181 81.8398438,6.80175781 C82.0130217,6.96126382 82.1372067,7.14127504 82.2124023,7.34179688 C82.287598,7.54231871 82.3251953,7.77018102 82.3251953,8.02539062 Z" id="options" fill="#000000"></path>
+                <path d="M97.9794922,5.48242188 L92.1005859,5.48242188 L92.1005859,4.47753906 L97.9794922,4.47753906 L97.9794922,5.48242188 Z M97.9794922,7.86132812 L92.1005859,7.86132812 L92.1005859,6.85644531 L97.9794922,6.85644531 L97.9794922,7.86132812 Z" id="=" fill="#A67F59"></path>
+                <path d="M112.717773,12.7011719 L112.211914,12.7011719 C111.332352,12.7011719 110.678388,12.4949565 110.25,12.0825195 C109.821612,11.6700826 109.607422,11.0446005 109.607422,10.2060547 L109.607422,7.85449219 C109.607422,7.63118378 109.582357,7.43180426 109.532227,7.25634766 C109.482096,7.08089105 109.394369,6.93278055 109.269043,6.81201172 C109.143717,6.69124289 108.977377,6.59895865 108.77002,6.53515625 C108.562662,6.47135385 108.301759,6.43945313 107.987305,6.43945313 L107.693359,6.43945313 L107.693359,5.48925781 L107.987305,5.48925781 C108.319989,5.48925781 108.591145,5.46191434 108.800781,5.40722656 C109.010418,5.35253879 109.174479,5.26936905 109.292969,5.15771484 C109.411459,5.04606064 109.493489,4.9036467 109.539062,4.73046875 C109.584636,4.5572908 109.607422,4.35221473 109.607422,4.11523438 L109.607422,2.49511719 C109.607422,2.11230277 109.652994,1.76709138 109.744141,1.45947266 C109.835287,1.15185393 109.984537,0.88981228 110.191895,0.673339844 C110.399252,0.456867407 110.66813,0.290527925 110.998535,0.174316406 C111.32894,0.0581048877 111.733396,0 112.211914,0 L112.717773,0 L112.717773,0.95703125 L112.314453,0.95703125 C111.257156,0.95703125 110.728516,1.46972144 110.728516,2.49511719 L110.728516,4.08789062 C110.728516,5.19987535 110.247726,5.82649669 109.286133,5.96777344 C110.256841,6.06347704 110.742188,6.68781976 110.742188,7.84082031 L110.742188,10.1787109 C110.742188,11.2223359 111.266271,11.7441406 112.314453,11.7441406 L112.717773,11.7441406 L112.717773,12.7011719 Z" id="{" fill="#999999"></path>
+                <path d="M20.7470703,25.0253906 C20.7470703,25.2669283 20.7060551,25.4833975 20.6240234,25.6748047 C20.5419918,25.8662119 20.4303392,26.0359693 20.2890625,26.184082 C20.1477858,26.3321948 19.9837249,26.4586583 19.796875,26.5634766 C19.6100251,26.6682948 19.4106456,26.7548825 19.1987305,26.8232422 C18.9868153,26.8916019 18.7692068,26.9417316 18.5458984,26.9736328 C18.32259,27.005534 18.1038422,27.0214844 17.8896484,27.0214844 C17.4248024,27.0214844 16.9975605,27.0009768 16.6079102,26.9599609 C16.2182598,26.9189451 15.8365904,26.852865 15.4628906,26.7617188 L15.4628906,25.6679688 C15.8639343,25.7819016 16.2626933,25.8684893 16.6591797,25.9277344 C17.055666,25.9869795 17.4498678,26.0166016 17.8417969,26.0166016 C18.4114612,26.0166016 18.8330064,25.9391284 19.1064453,25.7841797 C19.3798842,25.629231 19.5166016,25.4082046 19.5166016,25.1210938 C19.5166016,24.9980463 19.4949546,24.887533 19.4516602,24.7895508 C19.4083657,24.6915685 19.3297532,24.598145 19.2158203,24.5092773 C19.1018875,24.4204097 18.9252942,24.3281255 18.6860352,24.2324219 C18.4467761,24.1367183 18.1197937,24.0273444 17.7050781,23.9042969 C17.3951807,23.8131506 17.1092135,23.7094732 16.847168,23.5932617 C16.5851224,23.4770502 16.3583994,23.3391935 16.1669922,23.1796875 C15.975585,23.0201815 15.8251959,22.8333344 15.7158203,22.6191406 C15.6064448,22.4049468 15.5517578,22.1520197 15.5517578,21.8603516 C15.5517578,21.6689444 15.596191,21.459311 15.6850586,21.2314453 C15.7739262,21.0035796 15.9254547,20.7916676 16.1396484,20.5957031 C16.3538422,20.3997386 16.6432273,20.2368171 17.0078125,20.1069336 C17.3723977,19.9770501 17.8281223,19.9121094 18.375,19.9121094 C18.6438816,19.9121094 18.9423812,19.9269204 19.2705078,19.956543 C19.5986345,19.9861655 19.9404279,20.0374345 20.2958984,20.1103516 L20.2958984,21.1699219 C19.9221987,21.0787756 19.5678728,21.0115562 19.2329102,20.9682617 C18.8979475,20.9249672 18.6074231,20.9033203 18.3613281,20.9033203 C18.0651027,20.9033203 17.8155935,20.9261065 17.612793,20.9716797 C17.4099925,21.0172528 17.2459316,21.079915 17.1206055,21.159668 C16.9952793,21.239421 16.9052737,21.3328445 16.8505859,21.4399414 C16.7958982,21.5470383 16.7685547,21.6621088 16.7685547,21.7851562 C16.7685547,21.9082037 16.7924802,22.0198563 16.840332,22.1201172 C16.8881838,22.2203781 16.9770501,22.3172196 17.1069336,22.4106445 C17.2368171,22.5040695 17.4179676,22.597493 17.6503906,22.690918 C17.8828137,22.7843429 18.1858705,22.8857416 18.5595703,22.9951172 C18.9651713,23.1136074 19.3069648,23.2377923 19.5849609,23.3676758 C19.8629571,23.4975592 20.0885408,23.6422518 20.2617188,23.8017578 C20.4348967,23.9612638 20.5590817,24.141275 20.6342773,24.3417969 C20.709473,24.5423187 20.7470703,24.770181 20.7470703,25.0253906 Z M25.3476562,21.0195312 L23.3173828,21.0195312 L23.3173828,20.0351562 L26.5507812,20.0351562 L26.5507812,25.9072266 L28.5947266,25.9072266 L28.5947266,26.8984375 L23.0917969,26.8984375 L23.0917969,25.9072266 L25.3476562,25.9072266 L25.3476562,21.0195312 Z M25.7646484,17.1572266 C25.8968106,17.1572266 26.0198562,17.1811521 26.1337891,17.2290039 C26.2477219,17.2768557 26.346842,17.3440751 26.4311523,17.4306641 C26.5154627,17.517253 26.5815427,17.6163731 26.6293945,17.7280273 C26.6772463,17.8396815 26.7011719,17.9615879 26.7011719,18.09375 C26.7011719,18.2213548 26.6772463,18.3421218 26.6293945,18.4560547 C26.5815427,18.5699875 26.5154627,18.670247 26.4311523,18.7568359 C26.346842,18.8434249 26.2477219,18.9106443 26.1337891,18.9584961 C26.0198562,19.0063479 25.8968106,19.0302734 25.7646484,19.0302734 C25.6324863,19.0302734 25.5094407,19.0063479 25.3955078,18.9584961 C25.281575,18.9106443 25.1824548,18.8434249 25.0981445,18.7568359 C25.0138342,18.670247 24.9477541,18.5699875 24.8999023,18.4560547 C24.8520505,18.3421218 24.828125,18.2213548 24.828125,18.09375 C24.828125,17.9615879 24.8520505,17.8396815 24.8999023,17.7280273 C24.9477541,17.6163731 25.0138342,17.517253 25.0981445,17.4306641 C25.1824548,17.3440751 25.281575,17.2768557 25.3955078,17.2290039 C25.5094407,17.1811521 25.6324863,17.1572266 25.7646484,17.1572266 Z M36.2646484,26.8984375 L30.734375,26.8984375 L30.734375,26.0439453 L34.6103516,21.0332031 L30.8300781,21.0332031 L30.8300781,20.0351562 L36.0390625,20.0351562 L36.0390625,20.9648438 L32.2314453,25.8935547 L36.2646484,25.8935547 L36.2646484,26.8984375 Z M44.2011719,23.1044922 C44.2011719,23.2731128 44.1988933,23.4143875 44.1943359,23.5283203 C44.1897786,23.6422532 44.1829428,23.7493485 44.1738281,23.8496094 L39.3544922,23.8496094 C39.3544922,24.5514358 39.5504538,25.0903302 39.9423828,25.4663086 C40.3343119,25.842287 40.8994104,26.0302734 41.6376953,26.0302734 C41.8382171,26.0302734 42.038736,26.0222983 42.2392578,26.0063477 C42.4397796,25.9903971 42.6334626,25.9687501 42.8203125,25.9414062 C43.0071624,25.9140624 43.1860343,25.883301 43.3569336,25.8491211 C43.5278329,25.8149412 43.6861972,25.777344 43.8320312,25.7363281 L43.8320312,26.7138672 C43.5084619,26.8050135 43.1427429,26.8790687 42.7348633,26.9360352 C42.3269836,26.9930016 41.9042991,27.0214844 41.4667969,27.0214844 C40.8789033,27.0214844 40.373049,26.9417326 39.9492188,26.7822266 C39.5253885,26.6227206 39.1778985,26.3914403 38.9067383,26.0883789 C38.6355781,25.7853175 38.4350592,25.4139019 38.3051758,24.9741211 C38.1752923,24.5343402 38.1103516,24.0364611 38.1103516,23.4804688 C38.1103516,22.9973934 38.1798496,22.5405295 38.3188477,22.1098633 C38.4578457,21.6791971 38.6606432,21.3009456 38.9272461,20.9750977 C39.193849,20.6492497 39.5208314,20.390626 39.9082031,20.1992188 C40.2955749,20.0078115 40.7353491,19.9121094 41.2275391,19.9121094 C41.7060571,19.9121094 42.129881,19.9873039 42.4990234,20.1376953 C42.8681659,20.2880867 43.179198,20.5011379 43.4321289,20.7768555 C43.6850599,21.052573 43.8764642,21.3875306 44.0063477,21.7817383 C44.1362311,22.175946 44.2011719,22.6168595 44.2011719,23.1044922 Z M42.9638672,22.9335938 C42.9775391,22.6282537 42.947917,22.3491224 42.875,22.0961914 C42.802083,21.8432605 42.6892911,21.625652 42.5366211,21.4433594 C42.3839511,21.2610668 42.193686,21.1186529 41.9658203,21.0161133 C41.7379546,20.9135737 41.4736343,20.8623047 41.1728516,20.8623047 C40.9130846,20.8623047 40.6761078,20.9124344 40.4619141,21.0126953 C40.2477203,21.1129562 40.0631518,21.2542309 39.9082031,21.4365234 C39.7532544,21.618816 39.6279302,21.8375638 39.5322266,22.0927734 C39.436523,22.347983 39.3772788,22.6282537 39.3544922,22.9335938 L42.9638672,22.9335938 Z" id="size" fill="#000000"></path>
+                <path d="M48.8564453,19.9121094 C48.9977221,19.9121094 49.1321608,19.9405922 49.2597656,19.9975586 C49.3873704,20.054525 49.499023,20.1308589 49.5947266,20.2265625 C49.6904302,20.3222661 49.766764,20.4339186 49.8237305,20.5615234 C49.8806969,20.6891282 49.9091797,20.823567 49.9091797,20.9648438 C49.9091797,21.1106778 49.8806969,21.2462559 49.8237305,21.371582 C49.766764,21.4969082 49.6904302,21.6074214 49.5947266,21.703125 C49.499023,21.7988286 49.3873704,21.8740232 49.2597656,21.9287109 C49.1321608,21.9833987 48.9977221,22.0107422 48.8564453,22.0107422 C48.7106112,22.0107422 48.5750332,21.9833987 48.449707,21.9287109 C48.3243809,21.8740232 48.2138677,21.7988286 48.1181641,21.703125 C48.0224605,21.6074214 47.9472659,21.4969082 47.8925781,21.371582 C47.8378904,21.2462559 47.8105469,21.1106778 47.8105469,20.9648438 C47.8105469,20.823567 47.8378904,20.6891282 47.8925781,20.5615234 C47.9472659,20.4339186 48.0224605,20.3222661 48.1181641,20.2265625 C48.2138677,20.1308589 48.3243809,20.054525 48.449707,19.9975586 C48.5750332,19.9405922 48.7106112,19.9121094 48.8564453,19.9121094 Z M48.8564453,24.9228516 C48.9977221,24.9228516 49.1321608,24.9513344 49.2597656,25.0083008 C49.3873704,25.0652672 49.499023,25.1416011 49.5947266,25.2373047 C49.6904302,25.3330083 49.766764,25.4446608 49.8237305,25.5722656 C49.8806969,25.6998704 49.9091797,25.8343092 49.9091797,25.9755859 C49.9091797,26.12142 49.8806969,26.2569981 49.8237305,26.3823242 C49.766764,26.5076504 49.6904302,26.6181636 49.5947266,26.7138672 C49.499023,26.8095708 49.3873704,26.8847654 49.2597656,26.9394531 C49.1321608,26.9941409 48.9977221,27.0214844 48.8564453,27.0214844 C48.7106112,27.0214844 48.5750332,26.9941409 48.449707,26.9394531 C48.3243809,26.8847654 48.2138677,26.8095708 48.1181641,26.7138672 C48.0224605,26.6181636 47.9472659,26.5076504 47.8925781,26.3823242 C47.8378904,26.2569981 47.8105469,26.12142 47.8105469,25.9755859 C47.8105469,25.8343092 47.8378904,25.6998704 47.8925781,25.5722656 C47.9472659,25.4446608 48.0224605,25.3330083 48.1181641,25.2373047 C48.2138677,25.1416011 48.3243809,25.0652672 48.449707,25.0083008 C48.5750332,24.9513344 48.7106112,24.9228516 48.8564453,24.9228516 Z M66.5341797,29.7011719 L66.0283203,29.7011719 C65.1487586,29.7011719 64.4947938,29.4949565 64.0664062,29.0825195 C63.6380187,28.6700826 63.4238281,28.0446005 63.4238281,27.2060547 L63.4238281,24.8544922 C63.4238281,24.6311838 63.3987633,24.4318043 63.3486328,24.2563477 C63.2985024,24.080891 63.2107754,23.9327806 63.0854492,23.8120117 C62.9601231,23.6912429 62.7937836,23.5989587 62.5864258,23.5351562 C62.379068,23.4713538 62.1181656,23.4394531 61.8037109,23.4394531 L61.5097656,23.4394531 L61.5097656,22.4892578 L61.8037109,22.4892578 C62.1363949,22.4892578 62.407551,22.4619143 62.6171875,22.4072266 C62.826824,22.3525388 62.9908848,22.269369 63.109375,22.1577148 C63.2278652,22.0460606 63.3098956,21.9036467 63.3554688,21.7304688 C63.4010419,21.5572908 63.4238281,21.3522147 63.4238281,21.1152344 L63.4238281,19.4951172 C63.4238281,19.1123028 63.4694006,18.7670914 63.5605469,18.4594727 C63.6516932,18.1518539 63.800943,17.8898123 64.0083008,17.6733398 C64.2156586,17.4568674 64.4845361,17.2905279 64.8149414,17.1743164 C65.1453467,17.0581049 65.5498023,17 66.0283203,17 L66.5341797,17 L66.5341797,17.9570312 L66.1308594,17.9570312 C65.0735624,17.9570312 64.5449219,18.4697214 64.5449219,19.4951172 L64.5449219,21.0878906 C64.5449219,22.1998754 64.0641324,22.8264967 63.1025391,22.9677734 C64.073247,23.063477 64.5585938,23.6878198 64.5585938,24.8408203 L64.5585938,27.1787109 C64.5585938,28.2223359 65.0826771,28.7441406 66.1308594,28.7441406 L66.5341797,28.7441406 L66.5341797,29.7011719 Z" id=":{" fill="#999999"></path>
+                <path d="M37.0644531,37.0351562 L36.0664062,43.8984375 L34.6240234,43.8984375 L33.6328125,41.0273438 L33.4345703,40.3300781 L33.2089844,41.0683594 L32.2587891,43.8984375 L30.8574219,43.8984375 L29.8662109,37.0351562 L31.0283203,37.0351562 L31.6025391,41.6972656 L31.7255859,42.7363281 L32.0195312,41.8271484 L33.0175781,38.7441406 L33.8720703,38.7441406 L34.9453125,41.7861328 L35.2529297,42.6953125 L35.3554688,41.7314453 L35.8886719,37.0351562 L37.0644531,37.0351562 Z M40.7421875,38.0195312 L38.7119141,38.0195312 L38.7119141,37.0351562 L41.9453125,37.0351562 L41.9453125,42.9072266 L43.9892578,42.9072266 L43.9892578,43.8984375 L38.4863281,43.8984375 L38.4863281,42.9072266 L40.7421875,42.9072266 L40.7421875,38.0195312 Z M41.1591797,34.1572266 C41.2913418,34.1572266 41.4143875,34.1811521 41.5283203,34.2290039 C41.6422532,34.2768557 41.7413733,34.3440751 41.8256836,34.4306641 C41.9099939,34.517253 41.976074,34.6163731 42.0239258,34.7280273 C42.0717776,34.8396815 42.0957031,34.9615879 42.0957031,35.09375 C42.0957031,35.2213548 42.0717776,35.3421218 42.0239258,35.4560547 C41.976074,35.5699875 41.9099939,35.670247 41.8256836,35.7568359 C41.7413733,35.8434249 41.6422532,35.9106443 41.5283203,35.9584961 C41.4143875,36.0063479 41.2913418,36.0302734 41.1591797,36.0302734 C41.0270176,36.0302734 40.9039719,36.0063479 40.7900391,35.9584961 C40.6761062,35.9106443 40.5769861,35.8434249 40.4926758,35.7568359 C40.4083655,35.670247 40.3422854,35.5699875 40.2944336,35.4560547 C40.2465818,35.3421218 40.2226562,35.2213548 40.2226562,35.09375 C40.2226562,34.9615879 40.2465818,34.8396815 40.2944336,34.7280273 C40.3422854,34.6163731 40.4083655,34.517253 40.4926758,34.4306641 C40.5769861,34.3440751 40.6761062,34.2768557 40.7900391,34.2290039 C40.9039719,34.1811521 41.0270176,34.1572266 41.1591797,34.1572266 Z M45.7529297,40.6103516 C45.7529297,40.0270153 45.8326815,39.5086286 45.9921875,39.0551758 C46.1516935,38.601723 46.3784165,38.2189143 46.6723633,37.9067383 C46.9663101,37.5945622 47.3194966,37.3575854 47.7319336,37.1958008 C48.1443706,37.0340161 48.6035131,36.953125 49.109375,36.953125 C49.3281261,36.953125 49.543456,36.9667967 49.7553711,36.9941406 C49.9672862,37.0214845 50.1757802,37.0647783 50.3808594,37.1240234 L50.3808594,34.2392578 L51.5771484,34.2392578 L51.5771484,43.8984375 L50.5107422,43.8984375 L50.4697266,42.5996094 C50.1370426,43.0826847 49.7770202,43.4404285 49.3896484,43.6728516 C49.0022767,43.9052746 48.5830101,44.0214844 48.1318359,44.0214844 C47.7399069,44.0214844 47.3946955,43.9394539 47.0961914,43.7753906 C46.7976873,43.6113273 46.5493174,43.3800471 46.3510742,43.081543 C46.152831,42.7830389 46.0035812,42.4241557 45.9033203,42.0048828 C45.8030594,41.5856099 45.7529297,41.1207708 45.7529297,40.6103516 Z M46.9697266,40.5351562 C46.9697266,41.3645875 47.0916329,41.9832336 47.3354492,42.3911133 C47.5792655,42.7989929 47.9244769,43.0029297 48.3710938,43.0029297 C48.6718765,43.0029297 48.9897444,42.8684909 49.324707,42.5996094 C49.6596696,42.3307278 50.0117169,41.9319688 50.3808594,41.4033203 L50.3808594,38.2177734 C50.1848949,38.1266271 49.9684257,38.0571291 49.7314453,38.0092773 C49.494465,37.9614255 49.2597668,37.9375 49.0273438,37.9375 C48.3802051,37.9375 47.8754901,38.1471333 47.5131836,38.5664062 C47.1508771,38.9856792 46.9697266,39.6419226 46.9697266,40.5351562 Z M59.3291016,43.8027344 C59.06022,43.8710941 58.782228,43.9200845 58.4951172,43.949707 C58.2080064,43.9793296 57.9163426,43.9941406 57.6201172,43.9941406 C56.7587848,43.9941406 56.1162131,43.7993184 55.6923828,43.409668 C55.2685526,43.0200176 55.0566406,42.421879 55.0566406,41.6152344 L55.0566406,38.0332031 L53.1357422,38.0332031 L53.1357422,37.0351562 L55.0566406,37.0351562 L55.0566406,35.1484375 L56.2460938,34.8408203 L56.2460938,37.0351562 L59.3291016,37.0351562 L59.3291016,38.0332031 L56.2460938,38.0332031 L56.2460938,41.5195312 C56.2460938,42.0117212 56.3771146,42.3797188 56.6391602,42.6235352 C56.9012057,42.8673515 57.2874323,42.9892578 57.7978516,42.9892578 C58.0166027,42.9892578 58.2558581,42.9721681 58.515625,42.9379883 C58.7753919,42.9038084 59.0465481,42.8502608 59.3291016,42.7773438 L59.3291016,43.8027344 Z M67.0126953,43.8984375 L65.8232422,43.8984375 L65.8232422,39.5166016 C65.8232422,38.9879531 65.7241221,38.592612 65.5258789,38.3305664 C65.3276357,38.0685208 65.0439472,37.9375 64.6748047,37.9375 C64.5152987,37.9375 64.3660489,37.9591469 64.2270508,38.0024414 C64.0880527,38.0457359 63.9433601,38.1209305 63.7929688,38.2280273 C63.6425774,38.3351242 63.4785165,38.4798168 63.3007812,38.6621094 C63.123046,38.844402 62.9179699,39.0722643 62.6855469,39.3457031 L62.6855469,43.8984375 L61.4960938,43.8984375 L61.4960938,34.2392578 L62.6855469,34.2392578 L62.6855469,37.0351562 L62.6445312,38.1152344 C62.8313811,37.891926 63.0148103,37.7039396 63.1948242,37.5512695 C63.3748381,37.3985995 63.5548494,37.2744145 63.7348633,37.1787109 C63.9148772,37.0830073 64.0983064,37.0146486 64.2851562,36.9736328 C64.4720061,36.932617 64.6656891,36.9121094 64.8662109,36.9121094 C65.5498081,36.9121094 66.0784487,37.1206034 66.4521484,37.5375977 C66.8258482,37.9545919 67.0126953,38.5823526 67.0126953,39.4208984 L67.0126953,43.8984375 Z" id="width" fill="#000000"></path>
+                <path d="M71.9482422,36.9121094 C72.0895189,36.9121094 72.2239577,36.9405922 72.3515625,36.9975586 C72.4791673,37.054525 72.5908198,37.1308589 72.6865234,37.2265625 C72.782227,37.3222661 72.8585609,37.4339186 72.9155273,37.5615234 C72.9724938,37.6891282 73.0009766,37.823567 73.0009766,37.9648438 C73.0009766,38.1106778 72.9724938,38.2462559 72.9155273,38.371582 C72.8585609,38.4969082 72.782227,38.6074214 72.6865234,38.703125 C72.5908198,38.7988286 72.4791673,38.8740232 72.3515625,38.9287109 C72.2239577,38.9833987 72.0895189,39.0107422 71.9482422,39.0107422 C71.8024081,39.0107422 71.6668301,38.9833987 71.5415039,38.9287109 C71.4161778,38.8740232 71.3056645,38.7988286 71.2099609,38.703125 C71.1142573,38.6074214 71.0390628,38.4969082 70.984375,38.371582 C70.9296872,38.2462559 70.9023438,38.1106778 70.9023438,37.9648438 C70.9023438,37.823567 70.9296872,37.6891282 70.984375,37.5615234 C71.0390628,37.4339186 71.1142573,37.3222661 71.2099609,37.2265625 C71.3056645,37.1308589 71.4161778,37.054525 71.5415039,36.9975586 C71.6668301,36.9405922 71.8024081,36.9121094 71.9482422,36.9121094 Z M71.9482422,41.9228516 C72.0895189,41.9228516 72.2239577,41.9513344 72.3515625,42.0083008 C72.4791673,42.0652672 72.5908198,42.1416011 72.6865234,42.2373047 C72.782227,42.3330083 72.8585609,42.4446608 72.9155273,42.5722656 C72.9724938,42.6998704 73.0009766,42.8343092 73.0009766,42.9755859 C73.0009766,43.12142 72.9724938,43.2569981 72.9155273,43.3823242 C72.8585609,43.5076504 72.782227,43.6181636 72.6865234,43.7138672 C72.5908198,43.8095708 72.4791673,43.8847654 72.3515625,43.9394531 C72.2239577,43.9941409 72.0895189,44.0214844 71.9482422,44.0214844 C71.8024081,44.0214844 71.6668301,43.9941409 71.5415039,43.9394531 C71.4161778,43.8847654 71.3056645,43.8095708 71.2099609,43.7138672 C71.1142573,43.6181636 71.0390628,43.5076504 70.984375,43.3823242 C70.9296872,43.2569981 70.9023438,43.12142 70.9023438,42.9755859 C70.9023438,42.8343092 70.9296872,42.6998704 70.984375,42.5722656 C71.0390628,42.4446608 71.1142573,42.3330083 71.2099609,42.2373047 C71.3056645,42.1416011 71.4161778,42.0652672 71.5415039,42.0083008 C71.6668301,41.9513344 71.8024081,41.9228516 71.9482422,41.9228516 Z" id=":" fill="#999999"></path>
+                <path d="M90.3095703,43.8984375 L84.6972656,43.8984375 L84.6972656,42.7910156 L86.9941406,42.7910156 L86.9941406,36.2695312 L84.8544922,37.4316406 L84.4169922,36.4199219 L87.2607422,34.9228516 L88.3134766,34.9228516 L88.3134766,42.7910156 L90.3095703,42.7910156 L90.3095703,43.8984375 Z M98.2871094,39.4345703 C98.2871094,40.1181675 98.2187507,40.7413709 98.0820312,41.3041992 C97.9453118,41.8670276 97.7379571,42.3500956 97.4599609,42.753418 C97.1819648,43.1567403 96.8367534,43.4689117 96.4243164,43.6899414 C96.0118794,43.9109712 95.5276721,44.0214844 94.9716797,44.0214844 C94.4931617,44.0214844 94.0579447,43.9314788 93.6660156,43.7514648 C93.2740866,43.5714509 92.939129,43.2945982 92.6611328,42.9208984 C92.3831366,42.5471987 92.1689461,42.0709664 92.0185547,41.4921875 C91.8681633,40.9134086 91.7929688,40.227543 91.7929688,39.4345703 C91.7929688,38.7509731 91.8624668,38.1266304 92.0014648,37.5615234 C92.1404629,36.9964164 92.3478176,36.512209 92.6235352,36.1088867 C92.8992527,35.7055644 93.2444641,35.393393 93.6591797,35.1723633 C94.0738953,34.9513335 94.5569634,34.8408203 95.1083984,34.8408203 C95.5869165,34.8408203 96.0221335,34.9308259 96.4140625,35.1108398 C96.8059915,35.2908538 97.1409491,35.5688458 97.4189453,35.9448242 C97.6969415,36.3208027 97.9111321,36.7981742 98.0615234,37.3769531 C98.2119148,37.9557321 98.2871094,38.6415976 98.2871094,39.4345703 Z M97.0839844,39.4755859 C97.0839844,39.3206372 97.0782878,39.1668302 97.0668945,39.0141602 C97.0555012,38.8614901 97.0429688,38.7122403 97.0292969,38.5664062 L93.2490234,41.3759766 C93.3173832,41.6129569 93.4039708,41.8317047 93.5087891,42.0322266 C93.6136073,42.2327484 93.7400709,42.4047844 93.8881836,42.5483398 C94.0362963,42.6918952 94.2049144,42.8035478 94.394043,42.8833008 C94.5831715,42.9630538 94.7985014,43.0029297 95.0400391,43.0029297 C95.3499364,43.0029297 95.6313464,42.9277351 95.8842773,42.7773438 C96.1372083,42.6269524 96.3525382,42.4036473 96.5302734,42.1074219 C96.7080087,41.8111964 96.8447261,41.4431988 96.9404297,41.003418 C97.0361333,40.5636371 97.0839844,40.0543649 97.0839844,39.4755859 Z M92.9960938,39.3935547 C92.9960938,39.5348314 92.9972331,39.6761061 92.9995117,39.8173828 C93.0017904,39.9586596 93.0097656,40.0953769 93.0234375,40.2275391 L96.8037109,37.4316406 C96.7353512,37.1992176 96.6487635,36.9873056 96.5439453,36.7958984 C96.4391271,36.6044912 96.3138028,36.4392911 96.1679688,36.300293 C96.0221347,36.1612949 95.8557952,36.0530603 95.6689453,35.9755859 C95.4820954,35.8981116 95.2724621,35.859375 95.0400391,35.859375 C94.7301417,35.859375 94.4487317,35.9345696 94.1958008,36.0849609 C93.9428698,36.2353523 93.72754,36.4597967 93.5498047,36.7583008 C93.3720694,37.0568049 93.235352,37.4259418 93.1396484,37.8657227 C93.0439448,38.3055035 92.9960938,38.8147758 92.9960938,39.3935547 Z M105.984375,39.4345703 C105.984375,40.1181675 105.916016,40.7413709 105.779297,41.3041992 C105.642577,41.8670276 105.435223,42.3500956 105.157227,42.753418 C104.87923,43.1567403 104.534019,43.4689117 104.121582,43.6899414 C103.709145,43.9109712 103.224938,44.0214844 102.668945,44.0214844 C102.190427,44.0214844 101.75521,43.9314788 101.363281,43.7514648 C100.971352,43.5714509 100.636395,43.2945982 100.358398,42.9208984 C100.080402,42.5471987 99.8662117,42.0709664 99.7158203,41.4921875 C99.5654289,40.9134086 99.4902344,40.227543 99.4902344,39.4345703 C99.4902344,38.7509731 99.5597324,38.1266304 99.6987305,37.5615234 C99.8377286,36.9964164 100.045083,36.512209 100.320801,36.1088867 C100.596518,35.7055644 100.94173,35.393393 101.356445,35.1723633 C101.771161,34.9513335 102.254229,34.8408203 102.805664,34.8408203 C103.284182,34.8408203 103.719399,34.9308259 104.111328,35.1108398 C104.503257,35.2908538 104.838215,35.5688458 105.116211,35.9448242 C105.394207,36.3208027 105.608398,36.7981742 105.758789,37.3769531 C105.90918,37.9557321 105.984375,38.6415976 105.984375,39.4345703 Z M104.78125,39.4755859 C104.78125,39.3206372 104.775553,39.1668302 104.76416,39.0141602 C104.752767,38.8614901 104.740234,38.7122403 104.726562,38.5664062 L100.946289,41.3759766 C101.014649,41.6129569 101.101236,41.8317047 101.206055,42.0322266 C101.310873,42.2327484 101.437336,42.4047844 101.585449,42.5483398 C101.733562,42.6918952 101.90218,42.8035478 102.091309,42.8833008 C102.280437,42.9630538 102.495767,43.0029297 102.737305,43.0029297 C103.047202,43.0029297 103.328612,42.9277351 103.581543,42.7773438 C103.834474,42.6269524 104.049804,42.4036473 104.227539,42.1074219 C104.405274,41.8111964 104.541992,41.4431988 104.637695,41.003418 C104.733399,40.5636371 104.78125,40.0543649 104.78125,39.4755859 Z M100.693359,39.3935547 C100.693359,39.5348314 100.694499,39.6761061 100.696777,39.8173828 C100.699056,39.9586596 100.707031,40.0953769 100.720703,40.2275391 L104.500977,37.4316406 C104.432617,37.1992176 104.346029,36.9873056 104.241211,36.7958984 C104.136393,36.6044912 104.011068,36.4392911 103.865234,36.300293 C103.7194,36.1612949 103.553061,36.0530603 103.366211,35.9755859 C103.179361,35.8981116 102.969728,35.859375 102.737305,35.859375 C102.427407,35.859375 102.145997,35.9345696 101.893066,36.0849609 C101.640135,36.2353523 101.424806,36.4597967 101.24707,36.7583008 C101.069335,37.0568049 100.932618,37.4259418 100.836914,37.8657227 C100.74121,38.3055035 100.693359,38.8147758 100.693359,39.3935547 Z" id="100" fill="#990055"></path>
+                <path d="M108.212891,45.2998047 C108.445314,45.3089193 108.670897,45.2884117 108.889648,45.2382812 C109.1084,45.1881508 109.300943,45.1140955 109.467285,45.0161133 C109.633627,44.918131 109.766927,44.7962247 109.867188,44.6503906 C109.967448,44.5045566 110.017578,44.3382171 110.017578,44.1513672 C110.017578,43.95996 109.984538,43.8050136 109.918457,43.6865234 C109.852376,43.5680333 109.778321,43.4586594 109.696289,43.3583984 C109.614257,43.2581375 109.540202,43.1510422 109.474121,43.0371094 C109.40804,42.9231765 109.375,42.7705088 109.375,42.5791016 C109.375,42.483398 109.393229,42.3831385 109.429688,42.2783203 C109.466146,42.1735021 109.521972,42.0777999 109.597168,41.9912109 C109.672364,41.904622 109.768066,41.8339846 109.884277,41.7792969 C110.000489,41.7246091 110.138346,41.6972656 110.297852,41.6972656 C110.457358,41.6972656 110.611165,41.7303057 110.759277,41.7963867 C110.90739,41.8624678 111.037272,41.9638665 111.148926,42.1005859 C111.26058,42.2373054 111.349446,42.4082021 111.415527,42.6132812 C111.481608,42.8183604 111.514648,43.0598944 111.514648,43.3378906 C111.514648,43.7161477 111.44515,44.0795881 111.306152,44.4282227 C111.167154,44.7768572 110.9598,45.0856106 110.684082,45.3544922 C110.408365,45.6233737 110.064292,45.8375643 109.651855,45.9970703 C109.239419,46.1565763 108.759768,46.2363281 108.212891,46.2363281 L108.212891,45.2998047 Z" id="," fill="#999999"></path>
+                <path d="M36.2236328,60.8984375 L35.0341797,60.8984375 L35.0341797,56.5166016 C35.0341797,55.9879531 34.9350596,55.592612 34.7368164,55.3305664 C34.5385732,55.0685208 34.2548847,54.9375 33.8857422,54.9375 C33.7262362,54.9375 33.5769864,54.9591469 33.4379883,55.0024414 C33.2989902,55.0457359 33.1542976,55.1209305 33.0039062,55.2280273 C32.8535149,55.3351242 32.689454,55.4798168 32.5117188,55.6621094 C32.3339835,55.844402 32.1289074,56.0722643 31.8964844,56.3457031 L31.8964844,60.8984375 L30.7070312,60.8984375 L30.7070312,51.2392578 L31.8964844,51.2392578 L31.8964844,54.0351562 L31.8554688,55.1152344 C32.0423186,54.891926 32.2257478,54.7039396 32.4057617,54.5512695 C32.5857756,54.3985995 32.7657869,54.2744145 32.9458008,54.1787109 C33.1258147,54.0830073 33.3092439,54.0146486 33.4960938,53.9736328 C33.6829436,53.932617 33.8766266,53.9121094 34.0771484,53.9121094 C34.7607456,53.9121094 35.2893862,54.1206034 35.6630859,54.5375977 C36.0367857,54.9545919 36.2236328,55.5823526 36.2236328,56.4208984 L36.2236328,60.8984375 Z M44.2011719,57.1044922 C44.2011719,57.2731128 44.1988933,57.4143875 44.1943359,57.5283203 C44.1897786,57.6422532 44.1829428,57.7493485 44.1738281,57.8496094 L39.3544922,57.8496094 C39.3544922,58.5514358 39.5504538,59.0903302 39.9423828,59.4663086 C40.3343119,59.842287 40.8994104,60.0302734 41.6376953,60.0302734 C41.8382171,60.0302734 42.038736,60.0222983 42.2392578,60.0063477 C42.4397796,59.9903971 42.6334626,59.9687501 42.8203125,59.9414062 C43.0071624,59.9140624 43.1860343,59.883301 43.3569336,59.8491211 C43.5278329,59.8149412 43.6861972,59.777344 43.8320312,59.7363281 L43.8320312,60.7138672 C43.5084619,60.8050135 43.1427429,60.8790687 42.7348633,60.9360352 C42.3269836,60.9930016 41.9042991,61.0214844 41.4667969,61.0214844 C40.8789033,61.0214844 40.373049,60.9417326 39.9492188,60.7822266 C39.5253885,60.6227206 39.1778985,60.3914403 38.9067383,60.0883789 C38.6355781,59.7853175 38.4350592,59.4139019 38.3051758,58.9741211 C38.1752923,58.5343402 38.1103516,58.0364611 38.1103516,57.4804688 C38.1103516,56.9973934 38.1798496,56.5405295 38.3188477,56.1098633 C38.4578457,55.6791971 38.6606432,55.3009456 38.9272461,54.9750977 C39.193849,54.6492497 39.5208314,54.390626 39.9082031,54.1992188 C40.2955749,54.0078115 40.7353491,53.9121094 41.2275391,53.9121094 C41.7060571,53.9121094 42.129881,53.9873039 42.4990234,54.1376953 C42.8681659,54.2880867 43.179198,54.5011379 43.4321289,54.7768555 C43.6850599,55.052573 43.8764642,55.3875306 44.0063477,55.7817383 C44.1362311,56.175946 44.2011719,56.6168595 44.2011719,57.1044922 Z M42.9638672,56.9335938 C42.9775391,56.6282537 42.947917,56.3491224 42.875,56.0961914 C42.802083,55.8432605 42.6892911,55.625652 42.5366211,55.4433594 C42.3839511,55.2610668 42.193686,55.1186529 41.9658203,55.0161133 C41.7379546,54.9135737 41.4736343,54.8623047 41.1728516,54.8623047 C40.9130846,54.8623047 40.6761078,54.9124344 40.4619141,55.0126953 C40.2477203,55.1129562 40.0631518,55.2542309 39.9082031,55.4365234 C39.7532544,55.618816 39.6279302,55.8375638 39.5322266,56.0927734 C39.436523,56.347983 39.3772788,56.6282537 39.3544922,56.9335938 L42.9638672,56.9335938 Z M48.4394531,55.0195312 L46.4091797,55.0195312 L46.4091797,54.0351562 L49.6425781,54.0351562 L49.6425781,59.9072266 L51.6865234,59.9072266 L51.6865234,60.8984375 L46.1835938,60.8984375 L46.1835938,59.9072266 L48.4394531,59.9072266 L48.4394531,55.0195312 Z M48.8564453,51.1572266 C48.9886074,51.1572266 49.1116531,51.1811521 49.2255859,51.2290039 C49.3395188,51.2768557 49.4386389,51.3440751 49.5229492,51.4306641 C49.6072595,51.517253 49.6733396,51.6163731 49.7211914,51.7280273 C49.7690432,51.8396815 49.7929688,51.9615879 49.7929688,52.09375 C49.7929688,52.2213548 49.7690432,52.3421218 49.7211914,52.4560547 C49.6733396,52.5699875 49.6072595,52.670247 49.5229492,52.7568359 C49.4386389,52.8434249 49.3395188,52.9106443 49.2255859,52.9584961 C49.1116531,53.0063479 48.9886074,53.0302734 48.8564453,53.0302734 C48.7242832,53.0302734 48.6012375,53.0063479 48.4873047,52.9584961 C48.3733718,52.9106443 48.2742517,52.8434249 48.1899414,52.7568359 C48.1056311,52.670247 48.039551,52.5699875 47.9916992,52.4560547 C47.9438474,52.3421218 47.9199219,52.2213548 47.9199219,52.09375 C47.9199219,51.9615879 47.9438474,51.8396815 47.9916992,51.7280273 C48.039551,51.6163731 48.1056311,51.517253 48.1899414,51.4306641 C48.2742517,51.3440751 48.3733718,51.2768557 48.4873047,51.2290039 C48.6012375,51.1811521 48.7242832,51.1572266 48.8564453,51.1572266 Z M58.7412109,55.0058594 C58.8688157,55.1653654 58.9679358,55.3510732 59.0385742,55.5629883 C59.1092126,55.7749034 59.1445312,56.003905 59.1445312,56.25 C59.1445312,56.6054705 59.0795905,56.9301743 58.949707,57.2241211 C58.8198236,57.5180679 58.6363944,57.7698557 58.3994141,57.9794922 C58.1624337,58.1891287 57.8787451,58.3520502 57.5483398,58.4682617 C57.2179345,58.5844732 56.8544942,58.6425781 56.4580078,58.6425781 C56.170897,58.6425781 55.9020195,58.6118167 55.6513672,58.550293 C55.4007149,58.4887692 55.2024747,58.4124354 55.0566406,58.3212891 C54.9700517,58.4488939 54.8971357,58.5696609 54.8378906,58.6835938 C54.7786455,58.7975266 54.7490234,58.9251295 54.7490234,59.0664062 C54.7490234,59.2395842 54.8321932,59.3831375 54.9985352,59.4970703 C55.1648771,59.6110032 55.3847643,59.672526 55.6582031,59.6816406 L57.4628906,59.75 C57.8046892,59.7591146 58.1202785,59.8024085 58.409668,59.8798828 C58.6990574,59.9573572 58.9474273,60.0690097 59.1547852,60.2148438 C59.362143,60.3606778 59.5239252,60.540689 59.6401367,60.7548828 C59.7563482,60.9690766 59.8144531,61.2174465 59.8144531,61.5 C59.8144531,61.8053401 59.7483731,62.0947252 59.6162109,62.3681641 C59.4840488,62.6416029 59.2801121,62.8819977 59.0043945,63.0893555 C58.728677,63.2967133 58.3789084,63.4619134 57.9550781,63.5849609 C57.5312479,63.7080084 57.0276722,63.7695312 56.4443359,63.7695312 C55.8883436,63.7695312 55.4155293,63.7250981 55.0258789,63.6362305 C54.6362285,63.5473628 54.316082,63.4243172 54.0654297,63.2670898 C53.8147774,63.1098625 53.6324875,62.9230154 53.5185547,62.706543 C53.4046218,62.4900705 53.3476562,62.2519544 53.3476562,61.9921875 C53.3476562,61.6595035 53.4251294,61.3678398 53.5800781,61.1171875 C53.7350268,60.8665352 53.9742822,60.6250012 54.2978516,60.3925781 C54.1793614,60.3378904 54.0768233,60.2695317 53.9902344,60.1875 C53.9036454,60.1054683 53.8330081,60.0154627 53.7783203,59.9174805 C53.7236325,59.8194982 53.6826173,59.7158209 53.6552734,59.6064453 C53.6279296,59.4970698 53.6142578,59.3899745 53.6142578,59.2851562 C53.6142578,58.9889308 53.6837558,58.7177747 53.8227539,58.4716797 C53.961752,58.2255847 54.1269522,57.9931652 54.3183594,57.7744141 C54.2317704,57.6695958 54.1554365,57.5670578 54.0893555,57.4667969 C54.0232744,57.366536 53.9663088,57.2583014 53.918457,57.1420898 C53.8706052,57.0258783 53.8341473,56.9005541 53.809082,56.7661133 C53.7840168,56.6316725 53.7714844,56.4778654 53.7714844,56.3046875 C53.7714844,55.949217 53.8364251,55.6245132 53.9663086,55.3305664 C54.0961921,55.0366196 54.2784819,54.7848318 54.5131836,54.5751953 C54.7478853,54.3655588 55.0304345,54.2026373 55.3608398,54.0864258 C55.6912451,53.9702143 56.0569641,53.9121094 56.4580078,53.9121094 C56.6266284,53.9121094 56.7884107,53.9235025 56.9433594,53.9462891 C57.0983081,53.9690756 57.2350254,53.9986977 57.3535156,54.0351562 L59.8417969,54.0351562 L59.8417969,55.0058594 L58.7412109,55.0058594 Z M54.6123047,61.8896484 C54.6123047,62.2132178 54.7809228,62.4490552 55.1181641,62.597168 C55.4554053,62.7452807 55.9248017,62.8193359 56.5263672,62.8193359 C56.9046243,62.8193359 57.2224922,62.7851566 57.4799805,62.7167969 C57.7374687,62.6484372 57.9448234,62.5584315 58.1020508,62.4467773 C58.2592781,62.3351231 58.37207,62.2075202 58.4404297,62.0639648 C58.5087894,61.9204094 58.5429688,61.7734383 58.5429688,61.6230469 C58.5429688,61.3450507 58.4290376,61.1399746 58.2011719,61.0078125 C57.9733062,60.8756504 57.6246768,60.7981772 57.1552734,60.7753906 L55.3642578,60.7138672 C55.2138664,60.8141281 55.0896815,60.9121089 54.9916992,61.0078125 C54.893717,61.1035161 54.8173831,61.2003576 54.7626953,61.2983398 C54.7080075,61.3963221 54.6692709,61.4943029 54.6464844,61.5922852 C54.6236978,61.6902674 54.6123047,61.7893875 54.6123047,61.8896484 Z M54.9746094,56.2773438 C54.9746094,56.4960948 55.0110673,56.6966137 55.0839844,56.8789062 C55.1569014,57.0611988 55.2594394,57.2161452 55.3916016,57.34375 C55.5237637,57.4713548 55.6798494,57.5704749 55.8598633,57.6411133 C56.0398772,57.7117517 56.2392567,57.7470703 56.4580078,57.7470703 C56.6949882,57.7470703 56.9057608,57.7071944 57.090332,57.6274414 C57.2749033,57.5476884 57.4298496,57.4394538 57.5551758,57.3027344 C57.6805019,57.1660149 57.7762041,57.00879 57.8422852,56.8310547 C57.9083662,56.6533194 57.9414062,56.468751 57.9414062,56.2773438 C57.9414062,56.0585927 57.9049483,55.8580738 57.8320312,55.6757812 C57.7591142,55.4934887 57.6565762,55.3385423 57.5244141,55.2109375 C57.3922519,55.0833327 57.2361663,54.9842126 57.0561523,54.9135742 C56.8761384,54.8429358 56.6767589,54.8076172 56.4580078,54.8076172 C56.2210275,54.8076172 56.0102548,54.8486324 55.8256836,54.9306641 C55.6411124,55.0126957 55.486166,55.1209303 55.3608398,55.2553711 C55.2355137,55.3898119 55.1398115,55.5458975 55.0737305,55.7236328 C55.0076494,55.9013681 54.9746094,56.0859365 54.9746094,56.2773438 Z M67.0126953,60.8984375 L65.8232422,60.8984375 L65.8232422,56.5166016 C65.8232422,55.9879531 65.7241221,55.592612 65.5258789,55.3305664 C65.3276357,55.0685208 65.0439472,54.9375 64.6748047,54.9375 C64.5152987,54.9375 64.3660489,54.9591469 64.2270508,55.0024414 C64.0880527,55.0457359 63.9433601,55.1209305 63.7929688,55.2280273 C63.6425774,55.3351242 63.4785165,55.4798168 63.3007812,55.6621094 C63.123046,55.844402 62.9179699,56.0722643 62.6855469,56.3457031 L62.6855469,60.8984375 L61.4960938,60.8984375 L61.4960938,51.2392578 L62.6855469,51.2392578 L62.6855469,54.0351562 L62.6445312,55.1152344 C62.8313811,54.891926 63.0148103,54.7039396 63.1948242,54.5512695 C63.3748381,54.3985995 63.5548494,54.2744145 63.7348633,54.1787109 C63.9148772,54.0830073 64.0983064,54.0146486 64.2851562,53.9736328 C64.4720061,53.932617 64.6656891,53.9121094 64.8662109,53.9121094 C65.5498081,53.9121094 66.0784487,54.1206034 66.4521484,54.5375977 C66.8258482,54.9545919 67.0126953,55.5823526 67.0126953,56.4208984 L67.0126953,60.8984375 Z M74.7236328,60.8027344 C74.4547513,60.8710941 74.1767592,60.9200845 73.8896484,60.949707 C73.6025376,60.9793296 73.3108739,60.9941406 73.0146484,60.9941406 C72.153316,60.9941406 71.5107443,60.7993184 71.0869141,60.409668 C70.6630838,60.0200176 70.4511719,59.421879 70.4511719,58.6152344 L70.4511719,55.0332031 L68.5302734,55.0332031 L68.5302734,54.0351562 L70.4511719,54.0351562 L70.4511719,52.1484375 L71.640625,51.8408203 L71.640625,54.0351562 L74.7236328,54.0351562 L74.7236328,55.0332031 L71.640625,55.0332031 L71.640625,58.5195312 C71.640625,59.0117212 71.7716458,59.3797188 72.0336914,59.6235352 C72.295737,59.8673515 72.6819636,59.9892578 73.1923828,59.9892578 C73.4111339,59.9892578 73.6503893,59.9721681 73.9101562,59.9379883 C74.1699232,59.9038084 74.4410793,59.8502608 74.7236328,59.7773438 L74.7236328,60.8027344 Z" id="height" fill="#000000"></path>
+                <path d="M79.6455078,53.9121094 C79.7867846,53.9121094 79.9212233,53.9405922 80.0488281,53.9975586 C80.1764329,54.054525 80.2880855,54.1308589 80.3837891,54.2265625 C80.4794927,54.3222661 80.5558265,54.4339186 80.612793,54.5615234 C80.6697594,54.6891282 80.6982422,54.823567 80.6982422,54.9648438 C80.6982422,55.1106778 80.6697594,55.2462559 80.612793,55.371582 C80.5558265,55.4969082 80.4794927,55.6074214 80.3837891,55.703125 C80.2880855,55.7988286 80.1764329,55.8740232 80.0488281,55.9287109 C79.9212233,55.9833987 79.7867846,56.0107422 79.6455078,56.0107422 C79.4996737,56.0107422 79.3640957,55.9833987 79.2387695,55.9287109 C79.1134434,55.8740232 79.0029302,55.7988286 78.9072266,55.703125 C78.811523,55.6074214 78.7363284,55.4969082 78.6816406,55.371582 C78.6269529,55.2462559 78.5996094,55.1106778 78.5996094,54.9648438 C78.5996094,54.823567 78.6269529,54.6891282 78.6816406,54.5615234 C78.7363284,54.4339186 78.811523,54.3222661 78.9072266,54.2265625 C79.0029302,54.1308589 79.1134434,54.054525 79.2387695,53.9975586 C79.3640957,53.9405922 79.4996737,53.9121094 79.6455078,53.9121094 Z M79.6455078,58.9228516 C79.7867846,58.9228516 79.9212233,58.9513344 80.0488281,59.0083008 C80.1764329,59.0652672 80.2880855,59.1416011 80.3837891,59.2373047 C80.4794927,59.3330083 80.5558265,59.4446608 80.612793,59.5722656 C80.6697594,59.6998704 80.6982422,59.8343092 80.6982422,59.9755859 C80.6982422,60.12142 80.6697594,60.2569981 80.612793,60.3823242 C80.5558265,60.5076504 80.4794927,60.6181636 80.3837891,60.7138672 C80.2880855,60.8095708 80.1764329,60.8847654 80.0488281,60.9394531 C79.9212233,60.9941409 79.7867846,61.0214844 79.6455078,61.0214844 C79.4996737,61.0214844 79.3640957,60.9941409 79.2387695,60.9394531 C79.1134434,60.8847654 79.0029302,60.8095708 78.9072266,60.7138672 C78.811523,60.6181636 78.7363284,60.5076504 78.6816406,60.3823242 C78.6269529,60.2569981 78.5996094,60.12142 78.5996094,59.9755859 C78.5996094,59.8343092 78.6269529,59.6998704 78.6816406,59.5722656 C78.7363284,59.4446608 78.811523,59.3330083 78.9072266,59.2373047 C79.0029302,59.1416011 79.1134434,59.0652672 79.2387695,59.0083008 C79.3640957,58.9513344 79.4996737,58.9228516 79.6455078,58.9228516 Z" id=":" fill="#999999"></path>
+                <path d="M98.0820312,60.8984375 L92.1962891,60.8984375 L92.1962891,59.8320312 L94.5068359,57.5351562 C94.885093,57.1614565 95.1927071,56.837892 95.4296875,56.5644531 C95.6666679,56.2910143 95.8512363,56.041505 95.9833984,55.815918 C96.1155606,55.5903309 96.2044269,55.3772796 96.25,55.1767578 C96.2955731,54.976236 96.3183594,54.7597668 96.3183594,54.5273438 C96.3183594,54.3085927 96.2887373,54.1000986 96.2294922,53.9018555 C96.1702471,53.7036123 96.0791022,53.5292976 95.9560547,53.3789062 C95.8330072,53.2285149 95.6735036,53.1100265 95.4775391,53.0234375 C95.2815745,52.9368485 95.0468764,52.8935547 94.7734375,52.8935547 C94.3951804,52.8935547 94.0511083,52.9778637 93.7412109,53.1464844 C93.4313136,53.315105 93.1464857,53.5338528 92.8867188,53.8027344 L92.2304688,53.0166016 C92.56771,52.661131 92.9562152,52.3763032 93.3959961,52.1621094 C93.8357769,51.9479156 94.3473278,51.8408203 94.9306641,51.8408203 C95.3271504,51.8408203 95.6883122,51.9000645 96.0141602,52.0185547 C96.3400081,52.1370449 96.6214181,52.3079416 96.8583984,52.53125 C97.0953788,52.7545584 97.2788079,53.0279932 97.4086914,53.3515625 C97.5385749,53.6751318 97.6035156,54.0397115 97.6035156,54.4453125 C97.6035156,54.7871111 97.5579432,55.1038397 97.4667969,55.3955078 C97.3756506,55.6871759 97.2377939,55.9777004 97.0532227,56.2670898 C96.8686514,56.5564793 96.6362319,56.8561182 96.355957,57.1660156 C96.0756822,57.475913 95.7441425,57.8154278 95.3613281,58.1845703 L93.7412109,59.7636719 L98.0820312,59.7636719 L98.0820312,60.8984375 Z M105.984375,56.4345703 C105.984375,57.1181675 105.916016,57.7413709 105.779297,58.3041992 C105.642577,58.8670276 105.435223,59.3500956 105.157227,59.753418 C104.87923,60.1567403 104.534019,60.4689117 104.121582,60.6899414 C103.709145,60.9109712 103.224938,61.0214844 102.668945,61.0214844 C102.190427,61.0214844 101.75521,60.9314788 101.363281,60.7514648 C100.971352,60.5714509 100.636395,60.2945982 100.358398,59.9208984 C100.080402,59.5471987 99.8662117,59.0709664 99.7158203,58.4921875 C99.5654289,57.9134086 99.4902344,57.227543 99.4902344,56.4345703 C99.4902344,55.7509731 99.5597324,55.1266304 99.6987305,54.5615234 C99.8377286,53.9964164 100.045083,53.512209 100.320801,53.1088867 C100.596518,52.7055644 100.94173,52.393393 101.356445,52.1723633 C101.771161,51.9513335 102.254229,51.8408203 102.805664,51.8408203 C103.284182,51.8408203 103.719399,51.9308259 104.111328,52.1108398 C104.503257,52.2908538 104.838215,52.5688458 105.116211,52.9448242 C105.394207,53.3208027 105.608398,53.7981742 105.758789,54.3769531 C105.90918,54.9557321 105.984375,55.6415976 105.984375,56.4345703 Z M104.78125,56.4755859 C104.78125,56.3206372 104.775553,56.1668302 104.76416,56.0141602 C104.752767,55.8614901 104.740234,55.7122403 104.726562,55.5664062 L100.946289,58.3759766 C101.014649,58.6129569 101.101236,58.8317047 101.206055,59.0322266 C101.310873,59.2327484 101.437336,59.4047844 101.585449,59.5483398 C101.733562,59.6918952 101.90218,59.8035478 102.091309,59.8833008 C102.280437,59.9630538 102.495767,60.0029297 102.737305,60.0029297 C103.047202,60.0029297 103.328612,59.9277351 103.581543,59.7773438 C103.834474,59.6269524 104.049804,59.4036473 104.227539,59.1074219 C104.405274,58.8111964 104.541992,58.4431988 104.637695,58.003418 C104.733399,57.5636371 104.78125,57.0543649 104.78125,56.4755859 Z M100.693359,56.3935547 C100.693359,56.5348314 100.694499,56.6761061 100.696777,56.8173828 C100.699056,56.9586596 100.707031,57.0953769 100.720703,57.2275391 L104.500977,54.4316406 C104.432617,54.1992176 104.346029,53.9873056 104.241211,53.7958984 C104.136393,53.6044912 104.011068,53.4392911 103.865234,53.300293 C103.7194,53.1612949 103.553061,53.0530603 103.366211,52.9755859 C103.179361,52.8981116 102.969728,52.859375 102.737305,52.859375 C102.427407,52.859375 102.145997,52.9345696 101.893066,53.0849609 C101.640135,53.2353523 101.424806,53.4597967 101.24707,53.7583008 C101.069335,54.0568049 100.932618,54.4259418 100.836914,54.8657227 C100.74121,55.3055035 100.693359,55.8147758 100.693359,56.3935547 Z M113.681641,56.4345703 C113.681641,57.1181675 113.613282,57.7413709 113.476562,58.3041992 C113.339843,58.8670276 113.132488,59.3500956 112.854492,59.753418 C112.576496,60.1567403 112.231285,60.4689117 111.818848,60.6899414 C111.406411,60.9109712 110.922203,61.0214844 110.366211,61.0214844 C109.887693,61.0214844 109.452476,60.9314788 109.060547,60.7514648 C108.668618,60.5714509 108.33366,60.2945982 108.055664,59.9208984 C107.777668,59.5471987 107.563477,59.0709664 107.413086,58.4921875 C107.262695,57.9134086 107.1875,57.227543 107.1875,56.4345703 C107.1875,55.7509731 107.256998,55.1266304 107.395996,54.5615234 C107.534994,53.9964164 107.742349,53.512209 108.018066,53.1088867 C108.293784,52.7055644 108.638995,52.393393 109.053711,52.1723633 C109.468427,51.9513335 109.951495,51.8408203 110.50293,51.8408203 C110.981448,51.8408203 111.416665,51.9308259 111.808594,52.1108398 C112.200523,52.2908538 112.53548,52.5688458 112.813477,52.9448242 C113.091473,53.3208027 113.305663,53.7981742 113.456055,54.3769531 C113.606446,54.9557321 113.681641,55.6415976 113.681641,56.4345703 Z M112.478516,56.4755859 C112.478516,56.3206372 112.472819,56.1668302 112.461426,56.0141602 C112.450032,55.8614901 112.4375,55.7122403 112.423828,55.5664062 L108.643555,58.3759766 C108.711914,58.6129569 108.798502,58.8317047 108.90332,59.0322266 C109.008139,59.2327484 109.134602,59.4047844 109.282715,59.5483398 C109.430828,59.6918952 109.599446,59.8035478 109.788574,59.8833008 C109.977703,59.9630538 110.193033,60.0029297 110.43457,60.0029297 C110.744468,60.0029297 111.025878,59.9277351 111.278809,59.7773438 C111.53174,59.6269524 111.747069,59.4036473 111.924805,59.1074219 C112.10254,58.8111964 112.239257,58.4431988 112.334961,58.003418 C112.430665,57.5636371 112.478516,57.0543649 112.478516,56.4755859 Z M108.390625,56.3935547 C108.390625,56.5348314 108.391764,56.6761061 108.394043,56.8173828 C108.396322,56.9586596 108.404297,57.0953769 108.417969,57.2275391 L112.198242,54.4316406 C112.129882,54.1992176 112.043295,53.9873056 111.938477,53.7958984 C111.833658,53.6044912 111.708334,53.4392911 111.5625,53.300293 C111.416666,53.1612949 111.250326,53.0530603 111.063477,52.9755859 C110.876627,52.8981116 110.666993,52.859375 110.43457,52.859375 C110.124673,52.859375 109.843263,52.9345696 109.590332,53.0849609 C109.337401,53.2353523 109.122071,53.4597967 108.944336,53.7583008 C108.766601,54.0568049 108.629883,54.4259418 108.53418,54.8657227 C108.438476,55.3055035 108.390625,55.8147758 108.390625,56.3935547 Z" id="200" fill="#990055"></path>
+                <path d="M15.7841797,68 L16.2900391,68 C17.1696008,68 17.8235656,68.2062154 18.2519531,68.6186523 C18.6803407,69.0310893 18.8945312,69.6565713 18.8945312,70.4951172 L18.8945312,72.0742188 C18.8945312,72.2975272 18.9195961,72.4969067 18.9697266,72.6723633 C19.019857,72.8478199 19.107584,72.9959304 19.2329102,73.1166992 C19.3582363,73.2374681 19.5257151,73.3297523 19.7353516,73.3935547 C19.944988,73.4573571 20.2070297,73.4892578 20.5214844,73.4892578 L20.8154297,73.4892578 L20.8154297,74.4394531 L20.5214844,74.4394531 C20.1888004,74.4394531 19.916505,74.4667966 19.7045898,74.5214844 C19.4926747,74.5761721 19.3274746,74.6593419 19.2089844,74.7709961 C19.0904942,74.8826503 19.0084638,75.0250642 18.9628906,75.1982422 C18.9173175,75.3714201 18.8945312,75.5764962 18.8945312,75.8134766 L18.8945312,78.2060547 C18.8945312,78.5888691 18.8489588,78.9340805 18.7578125,79.2416992 C18.6666662,79.5493179 18.5185557,79.8113596 18.3134766,80.027832 C18.1083974,80.2443045 17.8395199,80.410644 17.5068359,80.5268555 C17.174152,80.643067 16.7685571,80.7011719 16.2900391,80.7011719 L15.7841797,80.7011719 L15.7841797,79.7441406 L16.1943359,79.7441406 C17.2470756,79.7441406 17.7734375,79.2314504 17.7734375,78.2060547 L17.7734375,75.8408203 C17.7734375,74.7288356 18.254227,74.1044929 19.2158203,73.9677734 C18.2451123,73.8629552 17.7597656,73.2363339 17.7597656,72.0878906 L17.7597656,70.5224609 C17.7597656,69.4788359 17.2379609,68.9570312 16.1943359,68.9570312 L15.7841797,68.9570312 L15.7841797,68 Z M23.5429688,79.2998047 C23.7753918,79.3089193 24.0009755,79.2884117 24.2197266,79.2382812 C24.4384777,79.1881508 24.6310213,79.1140955 24.7973633,79.0161133 C24.9637053,78.918131 25.0970047,78.7962247 25.1972656,78.6503906 C25.2975265,78.5045566 25.3476562,78.3382171 25.3476562,78.1513672 C25.3476562,77.95996 25.3146162,77.8050136 25.2485352,77.6865234 C25.1824541,77.5680333 25.1083988,77.4586594 25.0263672,77.3583984 C24.9443355,77.2581375 24.8702803,77.1510422 24.8041992,77.0371094 C24.7381182,76.9231765 24.7050781,76.7705088 24.7050781,76.5791016 C24.7050781,76.483398 24.7233071,76.3831385 24.7597656,76.2783203 C24.7962241,76.1735021 24.8520504,76.0777999 24.9272461,75.9912109 C25.0024418,75.904622 25.098144,75.8339846 25.2143555,75.7792969 C25.330567,75.7246091 25.4684237,75.6972656 25.6279297,75.6972656 C25.7874357,75.6972656 25.9412427,75.7303057 26.0893555,75.7963867 C26.2374682,75.8624678 26.3673497,75.9638665 26.4790039,76.1005859 C26.5906581,76.2373054 26.6795244,76.4082021 26.7456055,76.6132812 C26.8116865,76.8183604 26.8447266,77.0598944 26.8447266,77.3378906 C26.8447266,77.7161477 26.7752286,78.0795881 26.6362305,78.4282227 C26.4972324,78.7768572 26.2898777,79.0856106 26.0141602,79.3544922 C25.7384426,79.6233737 25.3943706,79.8375643 24.9819336,79.9970703 C24.5694966,80.1565763 24.0898465,80.2363281 23.5429688,80.2363281 L23.5429688,79.2998047 Z" id="}," fill="#999999"></path>
+                <path d="M17.6503906,89.0195312 L15.6201172,89.0195312 L15.6201172,88.0351562 L18.8535156,88.0351562 L18.8535156,93.9072266 L20.8974609,93.9072266 L20.8974609,94.8984375 L15.3945312,94.8984375 L15.3945312,93.9072266 L17.6503906,93.9072266 L17.6503906,89.0195312 Z M18.0673828,85.1572266 C18.1995449,85.1572266 18.3225906,85.1811521 18.4365234,85.2290039 C18.5504563,85.2768557 18.6495764,85.3440751 18.7338867,85.4306641 C18.818197,85.517253 18.8842771,85.6163731 18.9321289,85.7280273 C18.9799807,85.8396815 19.0039062,85.9615879 19.0039062,86.09375 C19.0039062,86.2213548 18.9799807,86.3421218 18.9321289,86.4560547 C18.8842771,86.5699875 18.818197,86.670247 18.7338867,86.7568359 C18.6495764,86.8434249 18.5504563,86.9106443 18.4365234,86.9584961 C18.3225906,87.0063479 18.1995449,87.0302734 18.0673828,87.0302734 C17.9352207,87.0302734 17.812175,87.0063479 17.6982422,86.9584961 C17.5843093,86.9106443 17.4851892,86.8434249 17.4008789,86.7568359 C17.3165686,86.670247 17.2504885,86.5699875 17.2026367,86.4560547 C17.1547849,86.3421218 17.1308594,86.2213548 17.1308594,86.09375 C17.1308594,85.9615879 17.1547849,85.8396815 17.2026367,85.7280273 C17.2504885,85.6163731 17.3165686,85.517253 17.4008789,85.4306641 C17.4851892,85.3440751 17.5843093,85.2768557 17.6982422,85.2290039 C17.812175,85.1811521 17.9352207,85.1572266 18.0673828,85.1572266 Z M28.5400391,94.8027344 C28.2711575,94.8710941 27.9931655,94.9200845 27.7060547,94.949707 C27.4189439,94.9793296 27.1272801,94.9941406 26.8310547,94.9941406 C25.9697223,94.9941406 25.3271506,94.7993184 24.9033203,94.409668 C24.4794901,94.0200176 24.2675781,93.421879 24.2675781,92.6152344 L24.2675781,89.0332031 L22.3466797,89.0332031 L22.3466797,88.0351562 L24.2675781,88.0351562 L24.2675781,86.1484375 L25.4570312,85.8408203 L25.4570312,88.0351562 L28.5400391,88.0351562 L28.5400391,89.0332031 L25.4570312,89.0332031 L25.4570312,92.5195312 C25.4570312,93.0117212 25.5880521,93.3797188 25.8500977,93.6235352 C26.1121432,93.8673515 26.4983698,93.9892578 27.0087891,93.9892578 C27.2275402,93.9892578 27.4667956,93.9721681 27.7265625,93.9379883 C27.9863294,93.9038084 28.2574856,93.8502608 28.5400391,93.7773438 L28.5400391,94.8027344 Z M36.5039062,91.1044922 C36.5039062,91.2731128 36.5016276,91.4143875 36.4970703,91.5283203 C36.492513,91.6422532 36.4856771,91.7493485 36.4765625,91.8496094 L31.6572266,91.8496094 C31.6572266,92.5514358 31.8531881,93.0903302 32.2451172,93.4663086 C32.6370462,93.842287 33.2021447,94.0302734 33.9404297,94.0302734 C34.1409515,94.0302734 34.3414704,94.0222983 34.5419922,94.0063477 C34.742514,93.9903971 34.936197,93.9687501 35.1230469,93.9414062 C35.3098968,93.9140624 35.4887687,93.883301 35.659668,93.8491211 C35.8305673,93.8149412 35.9889316,93.777344 36.1347656,93.7363281 L36.1347656,94.7138672 C35.8111963,94.8050135 35.4454773,94.8790687 35.0375977,94.9360352 C34.629718,94.9930016 34.2070334,95.0214844 33.7695312,95.0214844 C33.1816377,95.0214844 32.6757834,94.9417326 32.2519531,94.7822266 C31.8281229,94.6227206 31.4806329,94.3914403 31.2094727,94.0883789 C30.9383124,93.7853175 30.7377936,93.4139019 30.6079102,92.9741211 C30.4780267,92.5343402 30.4130859,92.0364611 30.4130859,91.4804688 C30.4130859,90.9973934 30.4825839,90.5405295 30.621582,90.1098633 C30.7605801,89.6791971 30.9633776,89.3009456 31.2299805,88.9750977 C31.4965834,88.6492497 31.8235658,88.390626 32.2109375,88.1992188 C32.5983092,88.0078115 33.0380835,87.9121094 33.5302734,87.9121094 C34.0087915,87.9121094 34.4326153,87.9873039 34.8017578,88.1376953 C35.1709003,88.2880867 35.4819323,88.5011379 35.7348633,88.7768555 C35.9877942,89.052573 36.1791986,89.3875306 36.309082,89.7817383 C36.4389655,90.175946 36.5039062,90.6168595 36.5039062,91.1044922 Z M35.2666016,90.9335938 C35.2802735,90.6282537 35.2506514,90.3491224 35.1777344,90.0961914 C35.1048173,89.8432605 34.9920255,89.625652 34.8393555,89.4433594 C34.6866854,89.2610668 34.4964204,89.1186529 34.2685547,89.0161133 C34.040689,88.9135737 33.7763687,88.8623047 33.4755859,88.8623047 C33.215819,88.8623047 32.9788422,88.9124344 32.7646484,89.0126953 C32.5504547,89.1129562 32.3658862,89.2542309 32.2109375,89.4365234 C32.0559888,89.618816 31.9306645,89.8375638 31.8349609,90.0927734 C31.7392573,90.347983 31.6800131,90.6282537 31.6572266,90.9335938 L35.2666016,90.9335938 Z M43.2988281,94.8984375 L43.2988281,89.9697266 C43.2988281,89.7555328 43.2908529,89.5800788 43.2749023,89.4433594 C43.2589517,89.3066399 43.2338869,89.1984053 43.199707,89.1186523 C43.1655272,89.0388993 43.1222333,88.9830731 43.0698242,88.9511719 C43.0174151,88.9192707 42.9524743,88.9033203 42.875,88.9033203 C42.7838537,88.9033203 42.6995447,88.9306638 42.6220703,88.9853516 C42.544596,89.0400393 42.4614262,89.1289056 42.3725586,89.2519531 C42.283691,89.3750006 42.1857102,89.5379222 42.0786133,89.7407227 C41.9715164,89.9435231 41.8450528,90.1930324 41.6992188,90.4892578 L41.6992188,94.8984375 L40.6123047,94.8984375 L40.6123047,90.0996094 C40.6123047,89.8489571 40.6043295,89.6461596 40.5883789,89.4912109 C40.5724283,89.3362622 40.5473635,89.2154952 40.5131836,89.1289062 C40.4790037,89.0423173 40.4345706,88.9830731 40.3798828,88.9511719 C40.325195,88.9192707 40.259115,88.9033203 40.1816406,88.9033203 C40.099609,88.9033203 40.0221358,88.9261065 39.9492188,88.9716797 C39.8763017,89.0172528 39.7954106,89.0992833 39.706543,89.2177734 C39.6176753,89.3362636 39.5185552,89.4980458 39.4091797,89.703125 C39.2998041,89.9082042 39.1699226,90.1702458 39.0195312,90.4892578 L39.0195312,94.8984375 L37.9257812,94.8984375 L37.9257812,88.0351562 L38.8349609,88.0351562 L38.8896484,89.3408203 C39.0081386,89.0810534 39.1232091,88.860027 39.2348633,88.6777344 C39.3465175,88.4954418 39.4615879,88.3484706 39.5800781,88.2368164 C39.6985683,88.1251622 39.8250319,88.0431318 39.9594727,87.9907227 C40.0939134,87.9383135 40.2431632,87.9121094 40.4072266,87.9121094 C40.776369,87.9121094 41.0566397,88.0328764 41.2480469,88.2744141 C41.4394541,88.5159517 41.5351562,88.8896459 41.5351562,89.3955078 C41.6445318,89.1585275 41.7516271,88.9477548 41.8564453,88.7631836 C41.9612635,88.5786124 42.0740554,88.423666 42.1948242,88.2983398 C42.3155931,88.1730137 42.4488925,88.0773115 42.5947266,88.0112305 C42.7405606,87.9451494 42.9091787,87.9121094 43.1005859,87.9121094 C43.9619184,87.9121094 44.3925781,88.5751887 44.3925781,89.9013672 L44.3925781,94.8984375 L43.2988281,94.8984375 Z M51.5361328,93.0253906 C51.5361328,93.2669283 51.4951176,93.4833975 51.4130859,93.6748047 C51.3310543,93.8662119 51.2194017,94.0359693 51.078125,94.184082 C50.9368483,94.3321948 50.7727874,94.4586583 50.5859375,94.5634766 C50.3990876,94.6682948 50.1997081,94.7548825 49.987793,94.8232422 C49.7758778,94.8916019 49.5582693,94.9417316 49.3349609,94.9736328 C49.1116525,95.005534 48.8929047,95.0214844 48.6787109,95.0214844 C48.2138649,95.0214844 47.786623,95.0009768 47.3969727,94.9599609 C47.0073223,94.9189451 46.6256529,94.852865 46.2519531,94.7617188 L46.2519531,93.6679688 C46.6529968,93.7819016 47.0517558,93.8684893 47.4482422,93.9277344 C47.8447285,93.9869795 48.2389303,94.0166016 48.6308594,94.0166016 C49.2005237,94.0166016 49.6220689,93.9391284 49.8955078,93.7841797 C50.1689467,93.629231 50.3056641,93.4082046 50.3056641,93.1210938 C50.3056641,92.9980463 50.2840171,92.887533 50.2407227,92.7895508 C50.1974282,92.6915685 50.1188157,92.598145 50.0048828,92.5092773 C49.89095,92.4204097 49.7143567,92.3281255 49.4750977,92.2324219 C49.2358386,92.1367183 48.9088562,92.0273444 48.4941406,91.9042969 C48.1842432,91.8131506 47.898276,91.7094732 47.6362305,91.5932617 C47.3741849,91.4770502 47.1474619,91.3391935 46.9560547,91.1796875 C46.7646475,91.0201815 46.6142584,90.8333344 46.5048828,90.6191406 C46.3955073,90.4049468 46.3408203,90.1520197 46.3408203,89.8603516 C46.3408203,89.6689444 46.3852535,89.459311 46.4741211,89.2314453 C46.5629887,89.0035796 46.7145172,88.7916676 46.9287109,88.5957031 C47.1429047,88.3997386 47.4322898,88.2368171 47.796875,88.1069336 C48.1614602,87.9770501 48.6171848,87.9121094 49.1640625,87.9121094 C49.4329441,87.9121094 49.7314437,87.9269204 50.0595703,87.956543 C50.387697,87.9861655 50.7294904,88.0374345 51.0849609,88.1103516 L51.0849609,89.1699219 C50.7112612,89.0787756 50.3569353,89.0115562 50.0219727,88.9682617 C49.68701,88.9249672 49.3964856,88.9033203 49.1503906,88.9033203 C48.8541652,88.9033203 48.604656,88.9261065 48.4018555,88.9716797 C48.199055,89.0172528 48.0349941,89.079915 47.909668,89.159668 C47.7843418,89.239421 47.6943362,89.3328445 47.6396484,89.4399414 C47.5849607,89.5470383 47.5576172,89.6621088 47.5576172,89.7851562 C47.5576172,89.9082037 47.5815427,90.0198563 47.6293945,90.1201172 C47.6772463,90.2203781 47.7661126,90.3172196 47.8959961,90.4106445 C48.0258796,90.5040695 48.2070301,90.597493 48.4394531,90.690918 C48.6718762,90.7843429 48.974933,90.8857416 49.3486328,90.9951172 C49.7542338,91.1136074 50.0960273,91.2377923 50.3740234,91.3676758 C50.6520196,91.4975592 50.8776033,91.6422518 51.0507812,91.8017578 C51.2239592,91.9612638 51.3481442,92.141275 51.4233398,92.3417969 C51.4985355,92.5423187 51.5361328,92.770181 51.5361328,93.0253906 Z" id="items" fill="#000000"></path>
+                <path d="M56.5537109,87.9121094 C56.6949877,87.9121094 56.8294264,87.9405922 56.9570312,87.9975586 C57.0846361,88.054525 57.1962886,88.1308589 57.2919922,88.2265625 C57.3876958,88.3222661 57.4640297,88.4339186 57.5209961,88.5615234 C57.5779625,88.6891282 57.6064453,88.823567 57.6064453,88.9648438 C57.6064453,89.1106778 57.5779625,89.2462559 57.5209961,89.371582 C57.4640297,89.4969082 57.3876958,89.6074214 57.2919922,89.703125 C57.1962886,89.7988286 57.0846361,89.8740232 56.9570312,89.9287109 C56.8294264,89.9833987 56.6949877,90.0107422 56.5537109,90.0107422 C56.4078769,90.0107422 56.2722988,89.9833987 56.1469727,89.9287109 C56.0216465,89.8740232 55.9111333,89.7988286 55.8154297,89.703125 C55.7197261,89.6074214 55.6445315,89.4969082 55.5898438,89.371582 C55.535156,89.2462559 55.5078125,89.1106778 55.5078125,88.9648438 C55.5078125,88.823567 55.535156,88.6891282 55.5898438,88.5615234 C55.6445315,88.4339186 55.7197261,88.3222661 55.8154297,88.2265625 C55.9111333,88.1308589 56.0216465,88.054525 56.1469727,87.9975586 C56.2722988,87.9405922 56.4078769,87.9121094 56.5537109,87.9121094 Z M56.5537109,92.9228516 C56.6949877,92.9228516 56.8294264,92.9513344 56.9570312,93.0083008 C57.0846361,93.0652672 57.1962886,93.1416011 57.2919922,93.2373047 C57.3876958,93.3330083 57.4640297,93.4446608 57.5209961,93.5722656 C57.5779625,93.6998704 57.6064453,93.8343092 57.6064453,93.9755859 C57.6064453,94.12142 57.5779625,94.2569981 57.5209961,94.3823242 C57.4640297,94.5076504 57.3876958,94.6181636 57.2919922,94.7138672 C57.1962886,94.8095708 57.0846361,94.8847654 56.9570312,94.9394531 C56.8294264,94.9941409 56.6949877,95.0214844 56.5537109,95.0214844 C56.4078769,95.0214844 56.2722988,94.9941409 56.1469727,94.9394531 C56.0216465,94.8847654 55.9111333,94.8095708 55.8154297,94.7138672 C55.7197261,94.6181636 55.6445315,94.5076504 55.5898438,94.3823242 C55.535156,94.2569981 55.5078125,94.12142 55.5078125,93.9755859 C55.5078125,93.8343092 55.535156,93.6998704 55.5898438,93.5722656 C55.6445315,93.4446608 55.7197261,93.3330083 55.8154297,93.2373047 C55.9111333,93.1416011 56.0216465,93.0652672 56.1469727,93.0083008 C56.2722988,92.9513344 56.4078769,92.9228516 56.5537109,92.9228516 Z M73.828125,97.7011719 L70.4580078,97.7011719 L70.4580078,85 L73.828125,85 L73.828125,85.9570312 L71.5927734,85.9570312 L71.5927734,96.7441406 L73.828125,96.7441406 L73.828125,97.7011719 Z" id=":[" fill="#999999"></path>
+                <path d="M79.0712891,85.2392578 L78.8798828,88.4453125 L77.7587891,88.4453125 L77.5605469,85.2392578 L79.0712891,85.2392578 Z M81.7304688,85.2392578 L81.5390625,88.4453125 L80.4179688,88.4453125 L80.2197266,85.2392578 L81.7304688,85.2392578 Z M90.2958984,94.5634766 C89.5804001,94.859702 88.8307331,95.0078125 88.046875,95.0078125 C86.7844989,95.0078125 85.8149448,94.6307004 85.1381836,93.8764648 C84.4614224,93.1222293 84.1230469,92.0068433 84.1230469,90.5302734 C84.1230469,89.8147751 84.2164704,89.1676461 84.4033203,88.5888672 C84.5901702,88.0100883 84.8567691,87.519045 85.203125,87.1157227 C85.5494809,86.7124003 85.9687475,86.4013683 86.4609375,86.1826172 C86.9531275,85.9638661 87.5045542,85.8544922 88.1152344,85.8544922 C88.52995,85.8544922 88.9150373,85.8898108 89.2705078,85.9604492 C89.6259783,86.0310876 89.9677718,86.1393222 90.2958984,86.2851562 L90.2958984,87.4814453 C89.9723291,87.30371 89.6373715,87.168132 89.2910156,87.074707 C88.9446597,86.9812821 88.5664083,86.9345703 88.15625,86.9345703 C87.7369771,86.9345703 87.3575863,87.0131828 87.0180664,87.1704102 C86.6785465,87.3276375 86.3903007,87.5554998 86.1533203,87.8540039 C85.91634,88.152508 85.7340501,88.5170877 85.6064453,88.9477539 C85.4788405,89.3784201 85.4150391,89.8694634 85.4150391,90.4208984 C85.4150391,91.5784563 85.6497372,92.4511689 86.1191406,93.0390625 C86.588544,93.6269561 87.2766882,93.9208984 88.1835938,93.9208984 C88.5664082,93.9208984 88.9332665,93.8764653 89.2841797,93.7875977 C89.6350929,93.69873 89.9723291,93.5745451 90.2958984,93.4150391 L90.2958984,94.5634766 Z M96.6943359,94.8984375 L96.6669922,93.9755859 C96.2932924,94.3447284 95.9139017,94.6113273 95.5288086,94.7753906 C95.1437155,94.9394539 94.7392599,95.0214844 94.3154297,95.0214844 C93.9235006,95.0214844 93.5885431,94.9713547 93.3105469,94.8710938 C93.0325507,94.7708328 92.8035491,94.6329761 92.6235352,94.4575195 C92.4435212,94.2820629 92.3113611,94.0758475 92.2270508,93.8388672 C92.1427405,93.6018868 92.1005859,93.3444024 92.1005859,93.0664062 C92.1005859,92.3782518 92.356931,91.8393574 92.8696289,91.449707 C93.3823268,91.0600566 94.1399689,90.8652344 95.1425781,90.8652344 L96.5644531,90.8652344 L96.5644531,90.2636719 C96.5644531,89.8580709 96.4345716,89.5333671 96.1748047,89.2895508 C95.9150378,89.0457345 95.5185574,88.9238281 94.9853516,88.9238281 C94.5979798,88.9238281 94.2163105,88.967122 93.840332,89.0537109 C93.4643536,89.1402999 93.0758484,89.2633456 92.6748047,89.4228516 L92.6748047,88.3496094 C92.8251961,88.2949216 92.9926749,88.241374 93.1772461,88.1889648 C93.3618173,88.1365557 93.5566396,88.089844 93.7617188,88.0488281 C93.9667979,88.0078123 94.1809885,87.9747723 94.4042969,87.949707 C94.6276053,87.9246418 94.853189,87.9121094 95.0810547,87.9121094 C95.4957703,87.9121094 95.8694645,87.9576818 96.2021484,88.0488281 C96.5348324,88.1399744 96.8162423,88.2789704 97.0463867,88.4658203 C97.2765311,88.6526702 97.4531244,88.8873684 97.5761719,89.1699219 C97.6992194,89.4524754 97.7607422,89.7851543 97.7607422,90.1679688 L97.7607422,94.8984375 L96.6943359,94.8984375 Z M96.5644531,91.7744141 L95.0537109,91.7744141 C94.7574855,91.7744141 94.5022797,91.8040362 94.2880859,91.8632812 C94.0738922,91.9225263 93.8984382,92.0068354 93.7617188,92.1162109 C93.6249993,92.2255865 93.5236006,92.3566073 93.4575195,92.5092773 C93.3914385,92.6619474 93.3583984,92.8339834 93.3583984,93.0253906 C93.3583984,93.1575527 93.378906,93.2840163 93.4199219,93.4047852 C93.4609377,93.525554 93.5270178,93.6326493 93.6181641,93.7260742 C93.7093104,93.8194992 93.8277987,93.8935544 93.9736328,93.9482422 C94.1194669,94.00293 94.2971995,94.0302734 94.5068359,94.0302734 C94.7802748,94.0302734 95.0935855,93.9471037 95.4467773,93.7807617 C95.7999692,93.6144197 96.1725241,93.3512388 96.5644531,92.9912109 L96.5644531,91.7744141 Z M106.155273,94.8984375 L104.521484,94.8984375 L101.322266,91.2207031 L101.322266,94.8984375 L100.132812,94.8984375 L100.132812,85.2392578 L101.322266,85.2392578 L101.322266,91.1728516 L104.405273,88.0351562 L105.977539,88.0351562 L102.757812,91.2001953 L106.155273,94.8984375 Z M113.476562,91.1044922 C113.476562,91.2731128 113.474284,91.4143875 113.469727,91.5283203 C113.465169,91.6422532 113.458333,91.7493485 113.449219,91.8496094 L108.629883,91.8496094 C108.629883,92.5514358 108.825844,93.0903302 109.217773,93.4663086 C109.609702,93.842287 110.174801,94.0302734 110.913086,94.0302734 C111.113608,94.0302734 111.314127,94.0222983 111.514648,94.0063477 C111.71517,93.9903971 111.908853,93.9687501 112.095703,93.9414062 C112.282553,93.9140624 112.461425,93.883301 112.632324,93.8491211 C112.803224,93.8149412 112.961588,93.777344 113.107422,93.7363281 L113.107422,94.7138672 C112.783853,94.8050135 112.418134,94.8790687 112.010254,94.9360352 C111.602374,94.9930016 111.17969,95.0214844 110.742188,95.0214844 C110.154294,95.0214844 109.64844,94.9417326 109.224609,94.7822266 C108.800779,94.6227206 108.453289,94.3914403 108.182129,94.0883789 C107.910969,93.7853175 107.71045,93.4139019 107.580566,92.9741211 C107.450683,92.5343402 107.385742,92.0364611 107.385742,91.4804688 C107.385742,90.9973934 107.45524,90.5405295 107.594238,90.1098633 C107.733236,89.6791971 107.936034,89.3009456 108.202637,88.9750977 C108.46924,88.6492497 108.796222,88.390626 109.183594,88.1992188 C109.570965,88.0078115 110.01074,87.9121094 110.50293,87.9121094 C110.981448,87.9121094 111.405272,87.9873039 111.774414,88.1376953 C112.143557,88.2880867 112.454589,88.5011379 112.70752,88.7768555 C112.96045,89.052573 113.151855,89.3875306 113.281738,89.7817383 C113.411622,90.175946 113.476562,90.6168595 113.476562,91.1044922 Z M112.239258,90.9335938 C112.25293,90.6282537 112.223308,90.3491224 112.150391,90.0961914 C112.077474,89.8432605 111.964682,89.625652 111.812012,89.4433594 C111.659342,89.2610668 111.469077,89.1186529 111.241211,89.0161133 C111.013345,88.9135737 110.749025,88.8623047 110.448242,88.8623047 C110.188475,88.8623047 109.951498,88.9124344 109.737305,89.0126953 C109.523111,89.1129562 109.338542,89.2542309 109.183594,89.4365234 C109.028645,89.618816 108.903321,89.8375638 108.807617,90.0927734 C108.711914,90.347983 108.652669,90.6282537 108.629883,90.9335938 L112.239258,90.9335938 Z M117.557617,85.2392578 L117.366211,88.4453125 L116.245117,88.4453125 L116.046875,85.2392578 L117.557617,85.2392578 Z M120.216797,85.2392578 L120.025391,88.4453125 L118.904297,88.4453125 L118.706055,85.2392578 L120.216797,85.2392578 Z" id="&quot;Cake&quot;" fill="#669900"></path>
+                <path d="M123.607422,96.2998047 C123.839845,96.3089193 124.065429,96.2884117 124.28418,96.2382812 C124.502931,96.1881508 124.695474,96.1140955 124.861816,96.0161133 C125.028158,95.918131 125.161458,95.7962247 125.261719,95.6503906 C125.36198,95.5045566 125.412109,95.3382171 125.412109,95.1513672 C125.412109,94.95996 125.379069,94.8050136 125.312988,94.6865234 C125.246907,94.5680333 125.172852,94.4586594 125.09082,94.3583984 C125.008789,94.2581375 124.934733,94.1510422 124.868652,94.0371094 C124.802571,93.9231765 124.769531,93.7705088 124.769531,93.5791016 C124.769531,93.483398 124.78776,93.3831385 124.824219,93.2783203 C124.860677,93.1735021 124.916504,93.0777999 124.991699,92.9912109 C125.066895,92.904622 125.162597,92.8339846 125.278809,92.7792969 C125.39502,92.7246091 125.532877,92.6972656 125.692383,92.6972656 C125.851889,92.6972656 126.005696,92.7303057 126.153809,92.7963867 C126.301921,92.8624678 126.431803,92.9638665 126.543457,93.1005859 C126.655111,93.2373054 126.743978,93.4082021 126.810059,93.6132812 C126.87614,93.8183604 126.90918,94.0598944 126.90918,94.3378906 C126.90918,94.7161477 126.839682,95.0795881 126.700684,95.4282227 C126.561686,95.7768572 126.354331,96.0856106 126.078613,96.3544922 C125.802896,96.6233737 125.458824,96.8375643 125.046387,96.9970703 C124.63395,97.1565763 124.1543,97.2363281 123.607422,97.2363281 L123.607422,96.2998047 Z" id="," fill="#999999"></path>
+                <path d="M140.649414,85.2392578 L140.458008,88.4453125 L139.336914,88.4453125 L139.138672,85.2392578 L140.649414,85.2392578 Z M143.308594,85.2392578 L143.117188,88.4453125 L141.996094,88.4453125 L141.797852,85.2392578 L143.308594,85.2392578 Z M152.270508,90.3320312 C152.270508,90.7604188 152.237468,91.170571 152.171387,91.5625 C152.105306,91.954429 151.99935,92.3190087 151.853516,92.65625 C151.707682,92.9934913 151.518556,93.2999661 151.286133,93.5756836 C151.05371,93.8514011 150.768882,94.0872386 150.431641,94.2832031 C150.094399,94.4791676 149.702476,94.6306961 149.255859,94.737793 C148.809243,94.8448899 148.30111,94.8984375 147.731445,94.8984375 L145.817383,94.8984375 L145.817383,85.9638672 L148.121094,85.9638672 C149.515632,85.9638672 150.555823,86.3227503 151.241699,87.0405273 C151.927575,87.7583044 152.270508,88.8554614 152.270508,90.3320312 Z M150.992188,90.4208984 C150.992188,89.7874317 150.932943,89.2519553 150.814453,88.8144531 C150.695963,88.3769509 150.515952,88.0237644 150.274414,87.7548828 C150.032876,87.4860013 149.72982,87.291179 149.365234,87.1704102 C149.000649,87.0496413 148.572268,86.9892578 148.080078,86.9892578 L147.03418,86.9892578 L147.03418,93.8457031 L147.943359,93.8457031 C149.975922,93.8457031 150.992188,92.704113 150.992188,90.4208984 Z M159.837891,91.4121094 C159.837891,91.9453152 159.762696,92.4340798 159.612305,92.878418 C159.461913,93.3227561 159.245444,93.7032862 158.962891,94.0200195 C158.680337,94.3367529 158.336265,94.5828442 157.930664,94.7583008 C157.525063,94.9337574 157.064781,95.0214844 156.549805,95.0214844 C156.057615,95.0214844 155.616701,94.9451505 155.227051,94.7924805 C154.8374,94.6398104 154.507,94.4153661 154.23584,94.1191406 C153.96468,93.8229152 153.757325,93.4560569 153.61377,93.0185547 C153.470214,92.5810525 153.398438,92.0774768 153.398438,91.5078125 C153.398438,90.9746067 153.473632,90.4881207 153.624023,90.0483398 C153.774415,89.608559 153.990884,89.2303076 154.273438,88.9135742 C154.555991,88.5968409 154.900063,88.3507496 155.305664,88.175293 C155.711265,87.9998364 156.171547,87.9121094 156.686523,87.9121094 C157.178713,87.9121094 157.619627,87.9884432 158.009277,88.1411133 C158.398928,88.2937833 158.729328,88.5170884 159.000488,88.8110352 C159.271648,89.1049819 159.479003,89.4707009 159.622559,89.9082031 C159.766114,90.3457053 159.837891,90.8470024 159.837891,91.4121094 Z M158.621094,91.4667969 C158.621094,91.0429666 158.574382,90.6726904 158.480957,90.355957 C158.387532,90.0392237 158.254233,89.7749034 158.081055,89.5629883 C157.907877,89.3510732 157.697104,89.1915695 157.44873,89.0844727 C157.200357,88.9773758 156.923504,88.9238281 156.618164,88.9238281 C156.262694,88.9238281 155.958497,88.9933261 155.705566,89.1323242 C155.452635,89.2713223 155.245281,89.4570301 155.083496,89.6894531 C154.921711,89.9218762 154.803223,90.191893 154.728027,90.4995117 C154.652832,90.8071304 154.615234,91.1295556 154.615234,91.4667969 C154.615234,91.8906271 154.661946,92.2620427 154.755371,92.5810547 C154.848796,92.9000667 154.982095,93.1655263 155.155273,93.3774414 C155.328451,93.5893565 155.538085,93.7488601 155.78418,93.855957 C156.030275,93.9630539 156.308267,94.0166016 156.618164,94.0166016 C156.973635,94.0166016 157.277831,93.9471036 157.530762,93.8081055 C157.783693,93.6691074 157.991047,93.4833996 158.152832,93.2509766 C158.314617,93.0185535 158.433105,92.7485367 158.508301,92.440918 C158.583496,92.1332992 158.621094,91.8085955 158.621094,91.4667969 Z M161.560547,88.0351562 L162.620117,88.0351562 L162.667969,89.1425781 C162.868491,88.9055978 163.062174,88.7084969 163.249023,88.5512695 C163.435873,88.3940422 163.619302,88.2675786 163.799316,88.171875 C163.97933,88.0761714 164.162759,88.008952 164.349609,87.9702148 C164.536459,87.9314777 164.730142,87.9121094 164.930664,87.9121094 C165.637048,87.9121094 166.171385,88.1206034 166.533691,88.5375977 C166.895998,88.9545919 167.077148,89.5823526 167.077148,90.4208984 L167.077148,94.8984375 L165.887695,94.8984375 L165.887695,90.5166016 C165.887695,89.9788385 165.787436,89.5812187 165.586914,89.3237305 C165.386392,89.0662422 165.087893,88.9375 164.691406,88.9375 C164.545572,88.9375 164.403158,88.9591469 164.26416,89.0024414 C164.125162,89.0457359 163.98047,89.1209305 163.830078,89.2280273 C163.679687,89.3351242 163.516765,89.4798168 163.341309,89.6621094 C163.165852,89.844402 162.968751,90.0722643 162.75,90.3457031 L162.75,94.8984375 L161.560547,94.8984375 L161.560547,88.0351562 Z M174.774414,94.8984375 L173.708008,94.8984375 L173.666992,93.7910156 C173.461913,94.027996 173.267091,94.2250969 173.08252,94.3823242 C172.897948,94.5395516 172.714519,94.6660151 172.532227,94.7617188 C172.349934,94.8574224 172.166505,94.9246417 171.981934,94.9633789 C171.797362,95.0021161 171.60254,95.0214844 171.397461,95.0214844 C170.691077,95.0214844 170.157879,94.8141297 169.797852,94.3994141 C169.437824,93.9846984 169.257812,93.3580771 169.257812,92.5195312 L169.257812,88.0351562 L170.447266,88.0351562 L170.447266,92.4238281 C170.447266,93.4765678 170.843746,94.0029297 171.636719,94.0029297 C171.782553,94.0029297 171.924967,93.9812828 172.063965,93.9379883 C172.202963,93.8946938 172.348795,93.8194992 172.501465,93.7124023 C172.654135,93.6053055 172.818196,93.4606129 172.993652,93.2783203 C173.169109,93.0960277 173.36621,92.8658868 173.584961,92.5878906 L173.584961,88.0351562 L174.774414,88.0351562 L174.774414,94.8984375 Z M182.485352,94.8027344 C182.21647,94.8710941 181.938478,94.9200845 181.651367,94.949707 C181.364256,94.9793296 181.072593,94.9941406 180.776367,94.9941406 C179.915035,94.9941406 179.272463,94.7993184 178.848633,94.409668 C178.424803,94.0200176 178.212891,93.421879 178.212891,92.6152344 L178.212891,89.0332031 L176.291992,89.0332031 L176.291992,88.0351562 L178.212891,88.0351562 L178.212891,86.1484375 L179.402344,85.8408203 L179.402344,88.0351562 L182.485352,88.0351562 L182.485352,89.0332031 L179.402344,89.0332031 L179.402344,92.5195312 C179.402344,93.0117212 179.533365,93.3797188 179.79541,93.6235352 C180.057456,93.8673515 180.443682,93.9892578 180.954102,93.9892578 C181.172853,93.9892578 181.412108,93.9721681 181.671875,93.9379883 C181.931642,93.9038084 182.202798,93.8502608 182.485352,93.7773438 L182.485352,94.8027344 Z M186.833008,85.2392578 L186.641602,88.4453125 L185.520508,88.4453125 L185.322266,85.2392578 L186.833008,85.2392578 Z M189.492188,85.2392578 L189.300781,88.4453125 L188.179688,88.4453125 L187.981445,85.2392578 L189.492188,85.2392578 Z" id="&quot;Donut&quot;" fill="#669900"></path>
+                <path d="M196.594727,97.7011719 L193.224609,97.7011719 L193.224609,96.7441406 L195.446289,96.7441406 L195.446289,85.9570312 L193.224609,85.9570312 L193.224609,85 L196.594727,85 L196.594727,97.7011719 Z M200.580078,96.2998047 C200.812501,96.3089193 201.038085,96.2884117 201.256836,96.2382812 C201.475587,96.1881508 201.668131,96.1140955 201.834473,96.0161133 C202.000815,95.918131 202.134114,95.7962247 202.234375,95.6503906 C202.334636,95.5045566 202.384766,95.3382171 202.384766,95.1513672 C202.384766,94.95996 202.351726,94.8050136 202.285645,94.6865234 C202.219563,94.5680333 202.145508,94.4586594 202.063477,94.3583984 C201.981445,94.2581375 201.90739,94.1510422 201.841309,94.0371094 C201.775228,93.9231765 201.742188,93.7705088 201.742188,93.5791016 C201.742188,93.483398 201.760416,93.3831385 201.796875,93.2783203 C201.833334,93.1735021 201.88916,93.0777999 201.964355,92.9912109 C202.039551,92.904622 202.135253,92.8339846 202.251465,92.7792969 C202.367676,92.7246091 202.505533,92.6972656 202.665039,92.6972656 C202.824545,92.6972656 202.978352,92.7303057 203.126465,92.7963867 C203.274578,92.8624678 203.404459,92.9638665 203.516113,93.1005859 C203.627767,93.2373054 203.716634,93.4082021 203.782715,93.6132812 C203.848796,93.8183604 203.881836,94.0598944 203.881836,94.3378906 C203.881836,94.7161477 203.812338,95.0795881 203.67334,95.4282227 C203.534342,95.7768572 203.326987,96.0856106 203.05127,96.3544922 C202.775552,96.6233737 202.43148,96.8375643 202.019043,96.9970703 C201.606606,97.1565763 201.126956,97.2363281 200.580078,97.2363281 L200.580078,96.2998047 Z" id="]," fill="#999999"></path>
+                <path d="M21.109375,108.104492 C21.109375,108.273113 21.1070964,108.414387 21.1025391,108.52832 C21.0979817,108.642253 21.0911459,108.749348 21.0820312,108.849609 L16.2626953,108.849609 C16.2626953,109.551436 16.4586569,110.09033 16.8505859,110.466309 C17.242515,110.842287 17.8076135,111.030273 18.5458984,111.030273 C18.7464203,111.030273 18.9469391,111.022298 19.1474609,111.006348 C19.3479828,110.990397 19.5416657,110.96875 19.7285156,110.941406 C19.9153655,110.914062 20.0942374,110.883301 20.2651367,110.849121 C20.436036,110.814941 20.5944003,110.777344 20.7402344,110.736328 L20.7402344,111.713867 C20.416665,111.805013 20.050946,111.879069 19.6430664,111.936035 C19.2351868,111.993002 18.8125022,112.021484 18.375,112.021484 C17.7871064,112.021484 17.2812521,111.941733 16.8574219,111.782227 C16.4335916,111.622721 16.0861016,111.39144 15.8149414,111.088379 C15.5437812,110.785317 15.3432624,110.413902 15.2133789,109.974121 C15.0834954,109.53434 15.0185547,109.036461 15.0185547,108.480469 C15.0185547,107.997393 15.0880527,107.540529 15.2270508,107.109863 C15.3660489,106.679197 15.5688463,106.300946 15.8354492,105.975098 C16.1020521,105.64925 16.4290345,105.390626 16.8164062,105.199219 C17.203778,105.007812 17.6435522,104.912109 18.1357422,104.912109 C18.6142602,104.912109 19.0380841,104.987304 19.4072266,105.137695 C19.776369,105.288087 20.0874011,105.501138 20.340332,105.776855 C20.593263,106.052573 20.7846673,106.387531 20.9145508,106.781738 C21.0444342,107.175946 21.109375,107.61686 21.109375,108.104492 Z M19.8720703,107.933594 C19.8857423,107.628254 19.8561202,107.349122 19.7832031,107.096191 C19.7102861,106.84326 19.5974943,106.625652 19.4448242,106.443359 C19.2921542,106.261067 19.1018892,106.118653 18.8740234,106.016113 C18.6461577,105.913574 18.3818374,105.862305 18.0810547,105.862305 C17.8212878,105.862305 17.584311,105.912434 17.3701172,106.012695 C17.1559234,106.112956 16.9713549,106.254231 16.8164062,106.436523 C16.6614576,106.618816 16.5361333,106.837564 16.4404297,107.092773 C16.3447261,107.347983 16.2854819,107.628254 16.2626953,107.933594 L19.8720703,107.933594 Z M29.1962891,111.898438 L27.6171875,111.898438 L25.7646484,109.280273 L23.9326172,111.898438 L22.3945312,111.898438 L25.0537109,108.453125 L22.5175781,105.035156 L24.0419922,105.035156 L25.8466797,107.673828 L27.6171875,105.035156 L29.0869141,105.035156 L26.5097656,108.480469 L29.1962891,111.898438 Z M36.2373047,111.802734 C35.9684231,111.871094 35.6904311,111.920084 35.4033203,111.949707 C35.1162095,111.97933 34.8245458,111.994141 34.5283203,111.994141 C33.6669879,111.994141 33.0244162,111.799318 32.6005859,111.409668 C32.1767557,111.020018 31.9648438,110.421879 31.9648438,109.615234 L31.9648438,106.033203 L30.0439453,106.033203 L30.0439453,105.035156 L31.9648438,105.035156 L31.9648438,103.148438 L33.1542969,102.84082 L33.1542969,105.035156 L36.2373047,105.035156 L36.2373047,106.033203 L33.1542969,106.033203 L33.1542969,109.519531 C33.1542969,110.011721 33.2853177,110.379719 33.5473633,110.623535 C33.8094089,110.867351 34.1956355,110.989258 34.7060547,110.989258 C34.9248058,110.989258 35.1640612,110.972168 35.4238281,110.937988 C35.683595,110.903808 35.9547512,110.850261 36.2373047,110.777344 L36.2373047,111.802734 Z M38.6845703,105.035156 L39.7714844,105.035156 L39.8056641,106.299805 C40.211265,105.812172 40.6111634,105.458985 41.0053711,105.240234 C41.3995788,105.021483 41.7971985,104.912109 42.1982422,104.912109 C42.9091832,104.912109 43.4480776,105.14225 43.8149414,105.602539 C44.1818052,106.062828 44.3515626,106.746415 44.3242188,107.65332 L43.1210938,107.65332 C43.1347657,107.051755 43.0470387,106.615398 42.8579102,106.344238 C42.6687816,106.073078 42.3919289,105.9375 42.0273438,105.9375 C41.8678377,105.9375 41.7071948,105.965983 41.5454102,106.022949 C41.3836255,106.079916 41.217286,106.171061 41.0463867,106.296387 C40.8754874,106.421713 40.6943369,106.582356 40.5029297,106.77832 C40.3115225,106.974285 40.1064464,107.211262 39.8876953,107.489258 L39.8876953,111.898438 L38.6845703,111.898438 L38.6845703,105.035156 Z M50.5107422,111.898438 L50.4833984,110.975586 C50.1096987,111.344728 49.7303079,111.611327 49.3452148,111.775391 C48.9601218,111.939454 48.5556662,112.021484 48.1318359,112.021484 C47.7399069,112.021484 47.4049493,111.971355 47.1269531,111.871094 C46.8489569,111.770833 46.6199553,111.632976 46.4399414,111.45752 C46.2599275,111.282063 46.1277673,111.075848 46.043457,110.838867 C45.9591467,110.601887 45.9169922,110.344402 45.9169922,110.066406 C45.9169922,109.378252 46.1733373,108.839357 46.6860352,108.449707 C47.198733,108.060057 47.9563752,107.865234 48.9589844,107.865234 L50.3808594,107.865234 L50.3808594,107.263672 C50.3808594,106.858071 50.2509779,106.533367 49.9912109,106.289551 C49.731444,106.045734 49.3349636,105.923828 48.8017578,105.923828 C48.4143861,105.923828 48.0327167,105.967122 47.6567383,106.053711 C47.2807598,106.1403 46.8922546,106.263346 46.4912109,106.422852 L46.4912109,105.349609 C46.6416023,105.294922 46.8090811,105.241374 46.9936523,105.188965 C47.1782236,105.136556 47.3730458,105.089844 47.578125,105.048828 C47.7832042,105.007812 47.9973947,104.974772 48.2207031,104.949707 C48.4440115,104.924642 48.6695952,104.912109 48.8974609,104.912109 C49.3121766,104.912109 49.6858707,104.957682 50.0185547,105.048828 C50.3512386,105.139974 50.6326486,105.27897 50.862793,105.46582 C51.0929373,105.65267 51.2695306,105.887368 51.3925781,106.169922 C51.5156256,106.452475 51.5771484,106.785154 51.5771484,107.167969 L51.5771484,111.898438 L50.5107422,111.898438 Z M50.3808594,108.774414 L48.8701172,108.774414 C48.5738917,108.774414 48.318686,108.804036 48.1044922,108.863281 C47.8902984,108.922526 47.7148444,109.006835 47.578125,109.116211 C47.4414056,109.225586 47.3400068,109.356607 47.2739258,109.509277 C47.2078447,109.661947 47.1748047,109.833983 47.1748047,110.025391 C47.1748047,110.157553 47.1953123,110.284016 47.2363281,110.404785 C47.277344,110.525554 47.343424,110.632649 47.4345703,110.726074 C47.5257166,110.819499 47.644205,110.893554 47.7900391,110.948242 C47.9358731,111.00293 48.1136057,111.030273 48.3232422,111.030273 C48.5966811,111.030273 48.9099917,110.947104 49.2631836,110.780762 C49.6163755,110.61442 49.9889303,110.351239 50.3808594,109.991211 L50.3808594,108.774414 Z" id="extra" fill="#000000"></path>
+                <path d="M56.5537109,104.912109 C56.6949877,104.912109 56.8294264,104.940592 56.9570312,104.997559 C57.0846361,105.054525 57.1962886,105.130859 57.2919922,105.226562 C57.3876958,105.322266 57.4640297,105.433919 57.5209961,105.561523 C57.5779625,105.689128 57.6064453,105.823567 57.6064453,105.964844 C57.6064453,106.110678 57.5779625,106.246256 57.5209961,106.371582 C57.4640297,106.496908 57.3876958,106.607421 57.2919922,106.703125 C57.1962886,106.798829 57.0846361,106.874023 56.9570312,106.928711 C56.8294264,106.983399 56.6949877,107.010742 56.5537109,107.010742 C56.4078769,107.010742 56.2722988,106.983399 56.1469727,106.928711 C56.0216465,106.874023 55.9111333,106.798829 55.8154297,106.703125 C55.7197261,106.607421 55.6445315,106.496908 55.5898438,106.371582 C55.535156,106.246256 55.5078125,106.110678 55.5078125,105.964844 C55.5078125,105.823567 55.535156,105.689128 55.5898438,105.561523 C55.6445315,105.433919 55.7197261,105.322266 55.8154297,105.226562 C55.9111333,105.130859 56.0216465,105.054525 56.1469727,104.997559 C56.2722988,104.940592 56.4078769,104.912109 56.5537109,104.912109 Z M56.5537109,109.922852 C56.6949877,109.922852 56.8294264,109.951334 56.9570312,110.008301 C57.0846361,110.065267 57.1962886,110.141601 57.2919922,110.237305 C57.3876958,110.333008 57.4640297,110.444661 57.5209961,110.572266 C57.5779625,110.69987 57.6064453,110.834309 57.6064453,110.975586 C57.6064453,111.12142 57.5779625,111.256998 57.5209961,111.382324 C57.4640297,111.50765 57.3876958,111.618164 57.2919922,111.713867 C57.1962886,111.809571 57.0846361,111.884765 56.9570312,111.939453 C56.8294264,111.994141 56.6949877,112.021484 56.5537109,112.021484 C56.4078769,112.021484 56.2722988,111.994141 56.1469727,111.939453 C56.0216465,111.884765 55.9111333,111.809571 55.8154297,111.713867 C55.7197261,111.618164 55.6445315,111.50765 55.5898438,111.382324 C55.535156,111.256998 55.5078125,111.12142 55.5078125,110.975586 C55.5078125,110.834309 55.535156,110.69987 55.5898438,110.572266 C55.6445315,110.444661 55.7197261,110.333008 55.8154297,110.237305 C55.9111333,110.141601 56.0216465,110.065267 56.1469727,110.008301 C56.2722988,109.951334 56.4078769,109.922852 56.5537109,109.922852 Z" id=":" fill="#999999"></path>
+                <path d="M74.7236328,111.802734 C74.4547513,111.871094 74.1767592,111.920084 73.8896484,111.949707 C73.6025376,111.97933 73.3108739,111.994141 73.0146484,111.994141 C72.153316,111.994141 71.5107443,111.799318 71.0869141,111.409668 C70.6630838,111.020018 70.4511719,110.421879 70.4511719,109.615234 L70.4511719,106.033203 L68.5302734,106.033203 L68.5302734,105.035156 L70.4511719,105.035156 L70.4511719,103.148438 L71.640625,102.84082 L71.640625,105.035156 L74.7236328,105.035156 L74.7236328,106.033203 L71.640625,106.033203 L71.640625,109.519531 C71.640625,110.011721 71.7716458,110.379719 72.0336914,110.623535 C72.295737,110.867351 72.6819636,110.989258 73.1923828,110.989258 C73.4111339,110.989258 73.6503893,110.972168 73.9101562,110.937988 C74.1699232,110.903808 74.4410793,110.850261 74.7236328,110.777344 L74.7236328,111.802734 Z M77.1708984,105.035156 L78.2578125,105.035156 L78.2919922,106.299805 C78.6975932,105.812172 79.0974915,105.458985 79.4916992,105.240234 C79.8859069,105.021483 80.2835266,104.912109 80.6845703,104.912109 C81.3955114,104.912109 81.9344057,105.14225 82.3012695,105.602539 C82.6681333,106.062828 82.8378908,106.746415 82.8105469,107.65332 L81.6074219,107.65332 C81.6210938,107.051755 81.5333668,106.615398 81.3442383,106.344238 C81.1551097,106.073078 80.878257,105.9375 80.5136719,105.9375 C80.3541659,105.9375 80.1935229,105.965983 80.0317383,106.022949 C79.8699536,106.079916 79.7036141,106.171061 79.5327148,106.296387 C79.3618156,106.421713 79.180665,106.582356 78.9892578,106.77832 C78.7978506,106.974285 78.5927745,107.211262 78.3740234,107.489258 L78.3740234,111.898438 L77.1708984,111.898438 L77.1708984,105.035156 Z M90.1044922,111.898438 L89.0380859,111.898438 L88.9970703,110.791016 C88.7919912,111.027996 88.5971689,111.225097 88.4125977,111.382324 C88.2280264,111.539552 88.0445973,111.666015 87.8623047,111.761719 C87.6800121,111.857422 87.496583,111.924642 87.3120117,111.963379 C87.1274405,112.002116 86.9326182,112.021484 86.7275391,112.021484 C86.0211553,112.021484 85.4879575,111.81413 85.1279297,111.399414 C84.7679018,110.984698 84.5878906,110.358077 84.5878906,109.519531 L84.5878906,105.035156 L85.7773438,105.035156 L85.7773438,109.423828 C85.7773438,110.476568 86.1738242,111.00293 86.9667969,111.00293 C87.1126309,111.00293 87.2550449,110.981283 87.394043,110.937988 C87.5330411,110.894694 87.6788729,110.819499 87.831543,110.712402 C87.984213,110.605305 88.1482739,110.460613 88.3237305,110.27832 C88.4991871,110.096028 88.696288,109.865887 88.9150391,109.587891 L88.9150391,105.035156 L90.1044922,105.035156 L90.1044922,111.898438 Z M98.0820312,108.104492 C98.0820312,108.273113 98.0797526,108.414387 98.0751953,108.52832 C98.070638,108.642253 98.0638021,108.749348 98.0546875,108.849609 L93.2353516,108.849609 C93.2353516,109.551436 93.4313131,110.09033 93.8232422,110.466309 C94.2151712,110.842287 94.7802697,111.030273 95.5185547,111.030273 C95.7190765,111.030273 95.9195954,111.022298 96.1201172,111.006348 C96.320639,110.990397 96.514322,110.96875 96.7011719,110.941406 C96.8880218,110.914062 97.0668937,110.883301 97.237793,110.849121 C97.4086923,110.814941 97.5670566,110.777344 97.7128906,110.736328 L97.7128906,111.713867 C97.3893213,111.805013 97.0236023,111.879069 96.6157227,111.936035 C96.207843,111.993002 95.7851584,112.021484 95.3476562,112.021484 C94.7597627,112.021484 94.2539084,111.941733 93.8300781,111.782227 C93.4062479,111.622721 93.0587579,111.39144 92.7875977,111.088379 C92.5164374,110.785317 92.3159186,110.413902 92.1860352,109.974121 C92.0561517,109.53434 91.9912109,109.036461 91.9912109,108.480469 C91.9912109,107.997393 92.0607089,107.540529 92.199707,107.109863 C92.3387051,106.679197 92.5415026,106.300946 92.8081055,105.975098 C93.0747084,105.64925 93.4016908,105.390626 93.7890625,105.199219 C94.1764342,105.007812 94.6162085,104.912109 95.1083984,104.912109 C95.5869165,104.912109 96.0107403,104.987304 96.3798828,105.137695 C96.7490253,105.288087 97.0600573,105.501138 97.3129883,105.776855 C97.5659192,106.052573 97.7573236,106.387531 97.887207,106.781738 C98.0170905,107.175946 98.0820312,107.61686 98.0820312,108.104492 Z M96.8447266,107.933594 C96.8583985,107.628254 96.8287764,107.349122 96.7558594,107.096191 C96.6829423,106.84326 96.5701505,106.625652 96.4174805,106.443359 C96.2648104,106.261067 96.0745454,106.118653 95.8466797,106.016113 C95.618814,105.913574 95.3544937,105.862305 95.0537109,105.862305 C94.793944,105.862305 94.5569672,105.912434 94.3427734,106.012695 C94.1285797,106.112956 93.9440112,106.254231 93.7890625,106.436523 C93.6341138,106.618816 93.5087895,106.837564 93.4130859,107.092773 C93.3173823,107.347983 93.2581381,107.628254 93.2353516,107.933594 L96.8447266,107.933594 Z" id="true" fill="#990055"></path>
+                <path d="M0.389648438,119 L0.895507812,119 C1.7750695,119 2.42903432,119.206215 2.85742188,119.618652 C3.28580943,120.031089 3.5,120.656571 3.5,121.495117 L3.5,123.074219 C3.5,123.297527 3.52506485,123.496907 3.57519531,123.672363 C3.62532577,123.84782 3.71305276,123.99593 3.83837891,124.116699 C3.96370505,124.237468 4.13118385,124.329752 4.34082031,124.393555 C4.55045678,124.457357 4.81249843,124.489258 5.12695312,124.489258 L5.42089844,124.489258 L5.42089844,125.439453 L5.12695312,125.439453 C4.79426917,125.439453 4.52197372,125.466797 4.31005859,125.521484 C4.09814347,125.576172 3.9329433,125.659342 3.81445313,125.770996 C3.69596295,125.88265 3.61393252,126.025064 3.56835937,126.198242 C3.52278623,126.37142 3.5,126.576496 3.5,126.813477 L3.5,129.206055 C3.5,129.588869 3.45442754,129.93408 3.36328125,130.241699 C3.27213496,130.549318 3.12402446,130.81136 2.91894531,131.027832 C2.71386616,131.244304 2.44498864,131.410644 2.11230469,131.526855 C1.77962073,131.643067 1.37402583,131.701172 0.895507812,131.701172 L0.389648438,131.701172 L0.389648438,130.744141 L0.799804688,130.744141 C1.85254433,130.744141 2.37890625,130.23145 2.37890625,129.206055 L2.37890625,126.84082 C2.37890625,125.728836 2.85969571,125.104493 3.82128906,124.967773 C2.85058108,124.862955 2.36523438,124.236334 2.36523438,123.087891 L2.36523438,121.522461 C2.36523438,120.478836 1.8434297,119.957031 0.799804688,119.957031 L0.389648438,119.957031 L0.389648438,119 Z" id="}" fill="#999999"></path>
+            </g>
+            <g id="let-{-size:-{-width," transform="translate(12.175781, 11.101562)">
+                <path d="M2.25585938,1.21679688 L0.225585938,1.21679688 L0.225585938,0.239257812 L3.45898438,0.239257812 L3.45898438,8.90722656 L5.50292969,8.90722656 L5.50292969,9.8984375 L0,9.8984375 L0,8.90722656 L2.25585938,8.90722656 L2.25585938,1.21679688 Z M13.4121094,6.10449219 C13.4121094,6.27311282 13.4098308,6.41438745 13.4052734,6.52832031 C13.4007161,6.64225317 13.3938803,6.74934846 13.3847656,6.84960938 L8.56542969,6.84960938 C8.56542969,7.5514358 8.76139127,8.09033015 9.15332031,8.46630859 C9.54524936,8.84228704 10.1103479,9.03027344 10.8486328,9.03027344 C11.0491546,9.03027344 11.2496735,9.02229826 11.4501953,9.00634766 C11.6507171,8.99039706 11.8444001,8.96875014 12.03125,8.94140625 C12.2180999,8.91406236 12.3969718,8.88330095 12.5678711,8.84912109 C12.7387704,8.81494124 12.8971347,8.77734396 13.0429688,8.73632812 L13.0429688,9.71386719 C12.7193994,9.80501348 12.3536804,9.87906873 11.9458008,9.93603516 C11.5379211,9.99300159 11.1152366,10.0214844 10.6777344,10.0214844 C10.0898408,10.0214844 9.58398649,9.94173257 9.16015625,9.78222656 C8.73632601,9.62272056 8.38883599,9.39144032 8.11767578,9.08837891 C7.84651557,8.7853175 7.64599674,8.41390194 7.51611328,7.97412109 C7.38622982,7.53434025 7.32128906,7.03646111 7.32128906,6.48046875 C7.32128906,5.99739342 7.39078707,5.5405295 7.52978516,5.10986328 C7.66878325,4.67919707 7.8715807,4.30094564 8.13818359,3.97509766 C8.40478649,3.64924967 8.7317689,3.39062596 9.11914062,3.19921875 C9.50651235,3.00781154 9.9462866,2.91210938 10.4384766,2.91210938 C10.9169946,2.91210938 11.3408185,2.98730394 11.7099609,3.13769531 C12.0791034,3.28808669 12.3901355,3.50113794 12.6430664,3.77685547 C12.8959974,4.05257299 13.0874017,4.38753058 13.2172852,4.78173828 C13.3471686,5.17594598 13.4121094,5.61685954 13.4121094,6.10449219 Z M12.1748047,5.93359375 C12.1884766,5.62825368 12.1588545,5.34912236 12.0859375,5.09619141 C12.0130205,4.84326045 11.9002286,4.62565195 11.7475586,4.44335938 C11.5948886,4.2610668 11.4046235,4.11865286 11.1767578,4.01611328 C10.9488921,3.91357371 10.6845718,3.86230469 10.3837891,3.86230469 C10.1240221,3.86230469 9.88704534,3.91243439 9.67285156,4.01269531 C9.45865778,4.11295623 9.27408932,4.25423086 9.11914062,4.43652344 C8.96419193,4.61881602 8.83886767,4.83756383 8.74316406,5.09277344 C8.64746046,5.34798305 8.58821626,5.62825368 8.56542969,5.93359375 L12.1748047,5.93359375 Z M20.8427734,9.80273438 C20.5738919,9.87109409 20.2958999,9.92008449 20.0087891,9.94970703 C19.7216783,9.97932958 19.4300145,9.99414062 19.1337891,9.99414062 C18.2724566,9.99414062 17.6298849,9.79931835 17.2060547,9.40966797 C16.7822244,9.02001758 16.5703125,8.42187903 16.5703125,7.61523437 L16.5703125,4.03320312 L14.6494141,4.03320312 L14.6494141,3.03515625 L16.5703125,3.03515625 L16.5703125,1.1484375 L17.7597656,0.840820312 L17.7597656,3.03515625 L20.8427734,3.03515625 L20.8427734,4.03320312 L17.7597656,4.03320312 L17.7597656,7.51953125 C17.7597656,8.01172121 17.8907865,8.37971883 18.152832,8.62353516 C18.4148776,8.86735148 18.8011042,8.98925781 19.3115234,8.98925781 C19.5302745,8.98925781 19.76953,8.97216814 20.0292969,8.93798828 C20.2890638,8.90380842 20.5602199,8.85026078 20.8427734,8.77734375 L20.8427734,9.80273438 Z" id="let" fill="#0C6399"></path>
+                <path d="M35.7451172,12.7011719 L35.2392578,12.7011719 C34.3596961,12.7011719 33.7057313,12.4949565 33.2773438,12.0825195 C32.8489562,11.6700826 32.6347656,11.0446005 32.6347656,10.2060547 L32.6347656,7.85449219 C32.6347656,7.63118378 32.6097008,7.43180426 32.5595703,7.25634766 C32.5094399,7.08089105 32.4217129,6.93278055 32.2963867,6.81201172 C32.1710606,6.69124289 32.0047211,6.59895865 31.7973633,6.53515625 C31.5900055,6.47135385 31.3291031,6.43945313 31.0146484,6.43945313 L30.7207031,6.43945313 L30.7207031,5.48925781 L31.0146484,5.48925781 C31.3473324,5.48925781 31.6184885,5.46191434 31.828125,5.40722656 C32.0377615,5.35253879 32.2018223,5.26936905 32.3203125,5.15771484 C32.4388027,5.04606064 32.5208331,4.9036467 32.5664062,4.73046875 C32.6119794,4.5572908 32.6347656,4.35221473 32.6347656,4.11523438 L32.6347656,2.49511719 C32.6347656,2.11230277 32.6803381,1.76709138 32.7714844,1.45947266 C32.8626307,1.15185393 33.0118805,0.88981228 33.2192383,0.673339844 C33.4265961,0.456867407 33.6954736,0.290527925 34.0258789,0.174316406 C34.3562842,0.0581048877 34.7607398,0 35.2392578,0 L35.7451172,0 L35.7451172,0.95703125 L35.3417969,0.95703125 C34.2844999,0.95703125 33.7558594,1.46972144 33.7558594,2.49511719 L33.7558594,4.08789062 C33.7558594,5.19987535 33.2750699,5.82649669 32.3134766,5.96777344 C33.2841845,6.06347704 33.7695312,6.68781976 33.7695312,7.84082031 L33.7695312,10.1787109 C33.7695312,11.2223359 34.2936146,11.7441406 35.3417969,11.7441406 L35.7451172,11.7441406 L35.7451172,12.7011719 Z" id="{" fill="#878787"></path>
+                <path d="M20.7470703,25.0253906 C20.7470703,25.2669283 20.7060551,25.4833975 20.6240234,25.6748047 C20.5419918,25.8662119 20.4303392,26.0359693 20.2890625,26.184082 C20.1477858,26.3321948 19.9837249,26.4586583 19.796875,26.5634766 C19.6100251,26.6682948 19.4106456,26.7548825 19.1987305,26.8232422 C18.9868153,26.8916019 18.7692068,26.9417316 18.5458984,26.9736328 C18.32259,27.005534 18.1038422,27.0214844 17.8896484,27.0214844 C17.4248024,27.0214844 16.9975605,27.0009768 16.6079102,26.9599609 C16.2182598,26.9189451 15.8365904,26.852865 15.4628906,26.7617188 L15.4628906,25.6679688 C15.8639343,25.7819016 16.2626933,25.8684893 16.6591797,25.9277344 C17.055666,25.9869795 17.4498678,26.0166016 17.8417969,26.0166016 C18.4114612,26.0166016 18.8330064,25.9391284 19.1064453,25.7841797 C19.3798842,25.629231 19.5166016,25.4082046 19.5166016,25.1210938 C19.5166016,24.9980463 19.4949546,24.887533 19.4516602,24.7895508 C19.4083657,24.6915685 19.3297532,24.598145 19.2158203,24.5092773 C19.1018875,24.4204097 18.9252942,24.3281255 18.6860352,24.2324219 C18.4467761,24.1367183 18.1197937,24.0273444 17.7050781,23.9042969 C17.3951807,23.8131506 17.1092135,23.7094732 16.847168,23.5932617 C16.5851224,23.4770502 16.3583994,23.3391935 16.1669922,23.1796875 C15.975585,23.0201815 15.8251959,22.8333344 15.7158203,22.6191406 C15.6064448,22.4049468 15.5517578,22.1520197 15.5517578,21.8603516 C15.5517578,21.6689444 15.596191,21.459311 15.6850586,21.2314453 C15.7739262,21.0035796 15.9254547,20.7916676 16.1396484,20.5957031 C16.3538422,20.3997386 16.6432273,20.2368171 17.0078125,20.1069336 C17.3723977,19.9770501 17.8281223,19.9121094 18.375,19.9121094 C18.6438816,19.9121094 18.9423812,19.9269204 19.2705078,19.956543 C19.5986345,19.9861655 19.9404279,20.0374345 20.2958984,20.1103516 L20.2958984,21.1699219 C19.9221987,21.0787756 19.5678728,21.0115562 19.2329102,20.9682617 C18.8979475,20.9249672 18.6074231,20.9033203 18.3613281,20.9033203 C18.0651027,20.9033203 17.8155935,20.9261065 17.612793,20.9716797 C17.4099925,21.0172528 17.2459316,21.079915 17.1206055,21.159668 C16.9952793,21.239421 16.9052737,21.3328445 16.8505859,21.4399414 C16.7958982,21.5470383 16.7685547,21.6621088 16.7685547,21.7851562 C16.7685547,21.9082037 16.7924802,22.0198563 16.840332,22.1201172 C16.8881838,22.2203781 16.9770501,22.3172196 17.1069336,22.4106445 C17.2368171,22.5040695 17.4179676,22.597493 17.6503906,22.690918 C17.8828137,22.7843429 18.1858705,22.8857416 18.5595703,22.9951172 C18.9651713,23.1136074 19.3069648,23.2377923 19.5849609,23.3676758 C19.8629571,23.4975592 20.0885408,23.6422518 20.2617188,23.8017578 C20.4348967,23.9612638 20.5590817,24.141275 20.6342773,24.3417969 C20.709473,24.5423187 20.7470703,24.770181 20.7470703,25.0253906 Z M25.3476562,21.0195312 L23.3173828,21.0195312 L23.3173828,20.0351562 L26.5507812,20.0351562 L26.5507812,25.9072266 L28.5947266,25.9072266 L28.5947266,26.8984375 L23.0917969,26.8984375 L23.0917969,25.9072266 L25.3476562,25.9072266 L25.3476562,21.0195312 Z M25.7646484,17.1572266 C25.8968106,17.1572266 26.0198562,17.1811521 26.1337891,17.2290039 C26.2477219,17.2768557 26.346842,17.3440751 26.4311523,17.4306641 C26.5154627,17.517253 26.5815427,17.6163731 26.6293945,17.7280273 C26.6772463,17.8396815 26.7011719,17.9615879 26.7011719,18.09375 C26.7011719,18.2213548 26.6772463,18.3421218 26.6293945,18.4560547 C26.5815427,18.5699875 26.5154627,18.670247 26.4311523,18.7568359 C26.346842,18.8434249 26.2477219,18.9106443 26.1337891,18.9584961 C26.0198562,19.0063479 25.8968106,19.0302734 25.7646484,19.0302734 C25.6324863,19.0302734 25.5094407,19.0063479 25.3955078,18.9584961 C25.281575,18.9106443 25.1824548,18.8434249 25.0981445,18.7568359 C25.0138342,18.670247 24.9477541,18.5699875 24.8999023,18.4560547 C24.8520505,18.3421218 24.828125,18.2213548 24.828125,18.09375 C24.828125,17.9615879 24.8520505,17.8396815 24.8999023,17.7280273 C24.9477541,17.6163731 25.0138342,17.517253 25.0981445,17.4306641 C25.1824548,17.3440751 25.281575,17.2768557 25.3955078,17.2290039 C25.5094407,17.1811521 25.6324863,17.1572266 25.7646484,17.1572266 Z M36.2646484,26.8984375 L30.734375,26.8984375 L30.734375,26.0439453 L34.6103516,21.0332031 L30.8300781,21.0332031 L30.8300781,20.0351562 L36.0390625,20.0351562 L36.0390625,20.9648438 L32.2314453,25.8935547 L36.2646484,25.8935547 L36.2646484,26.8984375 Z M44.2011719,23.1044922 C44.2011719,23.2731128 44.1988933,23.4143875 44.1943359,23.5283203 C44.1897786,23.6422532 44.1829428,23.7493485 44.1738281,23.8496094 L39.3544922,23.8496094 C39.3544922,24.5514358 39.5504538,25.0903302 39.9423828,25.4663086 C40.3343119,25.842287 40.8994104,26.0302734 41.6376953,26.0302734 C41.8382171,26.0302734 42.038736,26.0222983 42.2392578,26.0063477 C42.4397796,25.9903971 42.6334626,25.9687501 42.8203125,25.9414062 C43.0071624,25.9140624 43.1860343,25.883301 43.3569336,25.8491211 C43.5278329,25.8149412 43.6861972,25.777344 43.8320312,25.7363281 L43.8320312,26.7138672 C43.5084619,26.8050135 43.1427429,26.8790687 42.7348633,26.9360352 C42.3269836,26.9930016 41.9042991,27.0214844 41.4667969,27.0214844 C40.8789033,27.0214844 40.373049,26.9417326 39.9492188,26.7822266 C39.5253885,26.6227206 39.1778985,26.3914403 38.9067383,26.0883789 C38.6355781,25.7853175 38.4350592,25.4139019 38.3051758,24.9741211 C38.1752923,24.5343402 38.1103516,24.0364611 38.1103516,23.4804688 C38.1103516,22.9973934 38.1798496,22.5405295 38.3188477,22.1098633 C38.4578457,21.6791971 38.6606432,21.3009456 38.9272461,20.9750977 C39.193849,20.6492497 39.5208314,20.390626 39.9082031,20.1992188 C40.2955749,20.0078115 40.7353491,19.9121094 41.2275391,19.9121094 C41.7060571,19.9121094 42.129881,19.9873039 42.4990234,20.1376953 C42.8681659,20.2880867 43.179198,20.5011379 43.4321289,20.7768555 C43.6850599,21.052573 43.8764642,21.3875306 44.0063477,21.7817383 C44.1362311,22.175946 44.2011719,22.6168595 44.2011719,23.1044922 Z M42.9638672,22.9335938 C42.9775391,22.6282537 42.947917,22.3491224 42.875,22.0961914 C42.802083,21.8432605 42.6892911,21.625652 42.5366211,21.4433594 C42.3839511,21.2610668 42.193686,21.1186529 41.9658203,21.0161133 C41.7379546,20.9135737 41.4736343,20.8623047 41.1728516,20.8623047 C40.9130846,20.8623047 40.6761078,20.9124344 40.4619141,21.0126953 C40.2477203,21.1129562 40.0631518,21.2542309 39.9082031,21.4365234 C39.7532544,21.618816 39.6279302,21.8375638 39.5322266,22.0927734 C39.436523,22.347983 39.3772788,22.6282537 39.3544922,22.9335938 L42.9638672,22.9335938 Z" id="size" fill="#000000"></path>
+                <path d="M48.8564453,19.9121094 C48.9977221,19.9121094 49.1321608,19.9405922 49.2597656,19.9975586 C49.3873704,20.054525 49.499023,20.1308589 49.5947266,20.2265625 C49.6904302,20.3222661 49.766764,20.4339186 49.8237305,20.5615234 C49.8806969,20.6891282 49.9091797,20.823567 49.9091797,20.9648438 C49.9091797,21.1106778 49.8806969,21.2462559 49.8237305,21.371582 C49.766764,21.4969082 49.6904302,21.6074214 49.5947266,21.703125 C49.499023,21.7988286 49.3873704,21.8740232 49.2597656,21.9287109 C49.1321608,21.9833987 48.9977221,22.0107422 48.8564453,22.0107422 C48.7106112,22.0107422 48.5750332,21.9833987 48.449707,21.9287109 C48.3243809,21.8740232 48.2138677,21.7988286 48.1181641,21.703125 C48.0224605,21.6074214 47.9472659,21.4969082 47.8925781,21.371582 C47.8378904,21.2462559 47.8105469,21.1106778 47.8105469,20.9648438 C47.8105469,20.823567 47.8378904,20.6891282 47.8925781,20.5615234 C47.9472659,20.4339186 48.0224605,20.3222661 48.1181641,20.2265625 C48.2138677,20.1308589 48.3243809,20.054525 48.449707,19.9975586 C48.5750332,19.9405922 48.7106112,19.9121094 48.8564453,19.9121094 Z M48.8564453,24.9228516 C48.9977221,24.9228516 49.1321608,24.9513344 49.2597656,25.0083008 C49.3873704,25.0652672 49.499023,25.1416011 49.5947266,25.2373047 C49.6904302,25.3330083 49.766764,25.4446608 49.8237305,25.5722656 C49.8806969,25.6998704 49.9091797,25.8343092 49.9091797,25.9755859 C49.9091797,26.12142 49.8806969,26.2569981 49.8237305,26.3823242 C49.766764,26.5076504 49.6904302,26.6181636 49.5947266,26.7138672 C49.499023,26.8095708 49.3873704,26.8847654 49.2597656,26.9394531 C49.1321608,26.9941409 48.9977221,27.0214844 48.8564453,27.0214844 C48.7106112,27.0214844 48.5750332,26.9941409 48.449707,26.9394531 C48.3243809,26.8847654 48.2138677,26.8095708 48.1181641,26.7138672 C48.0224605,26.6181636 47.9472659,26.5076504 47.8925781,26.3823242 C47.8378904,26.2569981 47.8105469,26.12142 47.8105469,25.9755859 C47.8105469,25.8343092 47.8378904,25.6998704 47.8925781,25.5722656 C47.9472659,25.4446608 48.0224605,25.3330083 48.1181641,25.2373047 C48.2138677,25.1416011 48.3243809,25.0652672 48.449707,25.0083008 C48.5750332,24.9513344 48.7106112,24.9228516 48.8564453,24.9228516 Z M66.5341797,29.7011719 L66.0283203,29.7011719 C65.1487586,29.7011719 64.4947938,29.4949565 64.0664062,29.0825195 C63.6380187,28.6700826 63.4238281,28.0446005 63.4238281,27.2060547 L63.4238281,24.8544922 C63.4238281,24.6311838 63.3987633,24.4318043 63.3486328,24.2563477 C63.2985024,24.080891 63.2107754,23.9327806 63.0854492,23.8120117 C62.9601231,23.6912429 62.7937836,23.5989587 62.5864258,23.5351562 C62.379068,23.4713538 62.1181656,23.4394531 61.8037109,23.4394531 L61.5097656,23.4394531 L61.5097656,22.4892578 L61.8037109,22.4892578 C62.1363949,22.4892578 62.407551,22.4619143 62.6171875,22.4072266 C62.826824,22.3525388 62.9908848,22.269369 63.109375,22.1577148 C63.2278652,22.0460606 63.3098956,21.9036467 63.3554688,21.7304688 C63.4010419,21.5572908 63.4238281,21.3522147 63.4238281,21.1152344 L63.4238281,19.4951172 C63.4238281,19.1123028 63.4694006,18.7670914 63.5605469,18.4594727 C63.6516932,18.1518539 63.800943,17.8898123 64.0083008,17.6733398 C64.2156586,17.4568674 64.4845361,17.2905279 64.8149414,17.1743164 C65.1453467,17.0581049 65.5498023,17 66.0283203,17 L66.5341797,17 L66.5341797,17.9570312 L66.1308594,17.9570312 C65.0735624,17.9570312 64.5449219,18.4697214 64.5449219,19.4951172 L64.5449219,21.0878906 C64.5449219,22.1998754 64.0641324,22.8264967 63.1025391,22.9677734 C64.073247,23.063477 64.5585938,23.6878198 64.5585938,24.8408203 L64.5585938,27.1787109 C64.5585938,28.2223359 65.0826771,28.7441406 66.1308594,28.7441406 L66.5341797,28.7441406 L66.5341797,29.7011719 Z" id=":{" fill="#878787"></path>
+                <path d="M37.0644531,37.0351562 L36.0664062,43.8984375 L34.6240234,43.8984375 L33.6328125,41.0273438 L33.4345703,40.3300781 L33.2089844,41.0683594 L32.2587891,43.8984375 L30.8574219,43.8984375 L29.8662109,37.0351562 L31.0283203,37.0351562 L31.6025391,41.6972656 L31.7255859,42.7363281 L32.0195312,41.8271484 L33.0175781,38.7441406 L33.8720703,38.7441406 L34.9453125,41.7861328 L35.2529297,42.6953125 L35.3554688,41.7314453 L35.8886719,37.0351562 L37.0644531,37.0351562 Z M40.7421875,38.0195312 L38.7119141,38.0195312 L38.7119141,37.0351562 L41.9453125,37.0351562 L41.9453125,42.9072266 L43.9892578,42.9072266 L43.9892578,43.8984375 L38.4863281,43.8984375 L38.4863281,42.9072266 L40.7421875,42.9072266 L40.7421875,38.0195312 Z M41.1591797,34.1572266 C41.2913418,34.1572266 41.4143875,34.1811521 41.5283203,34.2290039 C41.6422532,34.2768557 41.7413733,34.3440751 41.8256836,34.4306641 C41.9099939,34.517253 41.976074,34.6163731 42.0239258,34.7280273 C42.0717776,34.8396815 42.0957031,34.9615879 42.0957031,35.09375 C42.0957031,35.2213548 42.0717776,35.3421218 42.0239258,35.4560547 C41.976074,35.5699875 41.9099939,35.670247 41.8256836,35.7568359 C41.7413733,35.8434249 41.6422532,35.9106443 41.5283203,35.9584961 C41.4143875,36.0063479 41.2913418,36.0302734 41.1591797,36.0302734 C41.0270176,36.0302734 40.9039719,36.0063479 40.7900391,35.9584961 C40.6761062,35.9106443 40.5769861,35.8434249 40.4926758,35.7568359 C40.4083655,35.670247 40.3422854,35.5699875 40.2944336,35.4560547 C40.2465818,35.3421218 40.2226562,35.2213548 40.2226562,35.09375 C40.2226562,34.9615879 40.2465818,34.8396815 40.2944336,34.7280273 C40.3422854,34.6163731 40.4083655,34.517253 40.4926758,34.4306641 C40.5769861,34.3440751 40.6761062,34.2768557 40.7900391,34.2290039 C40.9039719,34.1811521 41.0270176,34.1572266 41.1591797,34.1572266 Z M45.7529297,40.6103516 C45.7529297,40.0270153 45.8326815,39.5086286 45.9921875,39.0551758 C46.1516935,38.601723 46.3784165,38.2189143 46.6723633,37.9067383 C46.9663101,37.5945622 47.3194966,37.3575854 47.7319336,37.1958008 C48.1443706,37.0340161 48.6035131,36.953125 49.109375,36.953125 C49.3281261,36.953125 49.543456,36.9667967 49.7553711,36.9941406 C49.9672862,37.0214845 50.1757802,37.0647783 50.3808594,37.1240234 L50.3808594,34.2392578 L51.5771484,34.2392578 L51.5771484,43.8984375 L50.5107422,43.8984375 L50.4697266,42.5996094 C50.1370426,43.0826847 49.7770202,43.4404285 49.3896484,43.6728516 C49.0022767,43.9052746 48.5830101,44.0214844 48.1318359,44.0214844 C47.7399069,44.0214844 47.3946955,43.9394539 47.0961914,43.7753906 C46.7976873,43.6113273 46.5493174,43.3800471 46.3510742,43.081543 C46.152831,42.7830389 46.0035812,42.4241557 45.9033203,42.0048828 C45.8030594,41.5856099 45.7529297,41.1207708 45.7529297,40.6103516 Z M46.9697266,40.5351562 C46.9697266,41.3645875 47.0916329,41.9832336 47.3354492,42.3911133 C47.5792655,42.7989929 47.9244769,43.0029297 48.3710938,43.0029297 C48.6718765,43.0029297 48.9897444,42.8684909 49.324707,42.5996094 C49.6596696,42.3307278 50.0117169,41.9319688 50.3808594,41.4033203 L50.3808594,38.2177734 C50.1848949,38.1266271 49.9684257,38.0571291 49.7314453,38.0092773 C49.494465,37.9614255 49.2597668,37.9375 49.0273438,37.9375 C48.3802051,37.9375 47.8754901,38.1471333 47.5131836,38.5664062 C47.1508771,38.9856792 46.9697266,39.6419226 46.9697266,40.5351562 Z M59.3291016,43.8027344 C59.06022,43.8710941 58.782228,43.9200845 58.4951172,43.949707 C58.2080064,43.9793296 57.9163426,43.9941406 57.6201172,43.9941406 C56.7587848,43.9941406 56.1162131,43.7993184 55.6923828,43.409668 C55.2685526,43.0200176 55.0566406,42.421879 55.0566406,41.6152344 L55.0566406,38.0332031 L53.1357422,38.0332031 L53.1357422,37.0351562 L55.0566406,37.0351562 L55.0566406,35.1484375 L56.2460938,34.8408203 L56.2460938,37.0351562 L59.3291016,37.0351562 L59.3291016,38.0332031 L56.2460938,38.0332031 L56.2460938,41.5195312 C56.2460938,42.0117212 56.3771146,42.3797188 56.6391602,42.6235352 C56.9012057,42.8673515 57.2874323,42.9892578 57.7978516,42.9892578 C58.0166027,42.9892578 58.2558581,42.9721681 58.515625,42.9379883 C58.7753919,42.9038084 59.0465481,42.8502608 59.3291016,42.7773438 L59.3291016,43.8027344 Z M67.0126953,43.8984375 L65.8232422,43.8984375 L65.8232422,39.5166016 C65.8232422,38.9879531 65.7241221,38.592612 65.5258789,38.3305664 C65.3276357,38.0685208 65.0439472,37.9375 64.6748047,37.9375 C64.5152987,37.9375 64.3660489,37.9591469 64.2270508,38.0024414 C64.0880527,38.0457359 63.9433601,38.1209305 63.7929688,38.2280273 C63.6425774,38.3351242 63.4785165,38.4798168 63.3007812,38.6621094 C63.123046,38.844402 62.9179699,39.0722643 62.6855469,39.3457031 L62.6855469,43.8984375 L61.4960938,43.8984375 L61.4960938,34.2392578 L62.6855469,34.2392578 L62.6855469,37.0351562 L62.6445312,38.1152344 C62.8313811,37.891926 63.0148103,37.7039396 63.1948242,37.5512695 C63.3748381,37.3985995 63.5548494,37.2744145 63.7348633,37.1787109 C63.9148772,37.0830073 64.0983064,37.0146486 64.2851562,36.9736328 C64.4720061,36.932617 64.6656891,36.9121094 64.8662109,36.9121094 C65.5498081,36.9121094 66.0784487,37.1206034 66.4521484,37.5375977 C66.8258482,37.9545919 67.0126953,38.5823526 67.0126953,39.4208984 L67.0126953,43.8984375 Z" id="width" fill="#000000"></path>
+                <path d="M69.7265625,45.2998047 C69.9589855,45.3089193 70.1845692,45.2884117 70.4033203,45.2382812 C70.6220714,45.1881508 70.8146151,45.1140955 70.980957,45.0161133 C71.147299,44.918131 71.2805985,44.7962247 71.3808594,44.6503906 C71.4811203,44.5045566 71.53125,44.3382171 71.53125,44.1513672 C71.53125,43.95996 71.49821,43.8050136 71.4321289,43.6865234 C71.3660478,43.5680333 71.2919926,43.4586594 71.2099609,43.3583984 C71.1279293,43.2581375 71.053874,43.1510422 70.987793,43.0371094 C70.9217119,42.9231765 70.8886719,42.7705088 70.8886719,42.5791016 C70.8886719,42.483398 70.9069009,42.3831385 70.9433594,42.2783203 C70.9798179,42.1735021 71.0356442,42.0777999 71.1108398,41.9912109 C71.1860355,41.904622 71.2817377,41.8339846 71.3979492,41.7792969 C71.5141607,41.7246091 71.6520174,41.6972656 71.8115234,41.6972656 C71.9710294,41.6972656 72.1248365,41.7303057 72.2729492,41.7963867 C72.4210619,41.8624678 72.5509435,41.9638665 72.6625977,42.1005859 C72.7742519,42.2373054 72.8631182,42.4082021 72.9291992,42.6132812 C72.9952803,42.8183604 73.0283203,43.0598944 73.0283203,43.3378906 C73.0283203,43.7161477 72.9588223,44.0795881 72.8198242,44.4282227 C72.6808261,44.7768572 72.4734714,45.0856106 72.1977539,45.3544922 C71.9220364,45.6233737 71.5779643,45.8375643 71.1655273,45.9970703 C70.7530904,46.1565763 70.2734402,46.2363281 69.7265625,46.2363281 L69.7265625,45.2998047 Z" id="," fill="#878787"></path>
+                <path d="M36.2236328,60.8984375 L35.0341797,60.8984375 L35.0341797,56.5166016 C35.0341797,55.9879531 34.9350596,55.592612 34.7368164,55.3305664 C34.5385732,55.0685208 34.2548847,54.9375 33.8857422,54.9375 C33.7262362,54.9375 33.5769864,54.9591469 33.4379883,55.0024414 C33.2989902,55.0457359 33.1542976,55.1209305 33.0039062,55.2280273 C32.8535149,55.3351242 32.689454,55.4798168 32.5117188,55.6621094 C32.3339835,55.844402 32.1289074,56.0722643 31.8964844,56.3457031 L31.8964844,60.8984375 L30.7070312,60.8984375 L30.7070312,51.2392578 L31.8964844,51.2392578 L31.8964844,54.0351562 L31.8554688,55.1152344 C32.0423186,54.891926 32.2257478,54.7039396 32.4057617,54.5512695 C32.5857756,54.3985995 32.7657869,54.2744145 32.9458008,54.1787109 C33.1258147,54.0830073 33.3092439,54.0146486 33.4960938,53.9736328 C33.6829436,53.932617 33.8766266,53.9121094 34.0771484,53.9121094 C34.7607456,53.9121094 35.2893862,54.1206034 35.6630859,54.5375977 C36.0367857,54.9545919 36.2236328,55.5823526 36.2236328,56.4208984 L36.2236328,60.8984375 Z M44.2011719,57.1044922 C44.2011719,57.2731128 44.1988933,57.4143875 44.1943359,57.5283203 C44.1897786,57.6422532 44.1829428,57.7493485 44.1738281,57.8496094 L39.3544922,57.8496094 C39.3544922,58.5514358 39.5504538,59.0903302 39.9423828,59.4663086 C40.3343119,59.842287 40.8994104,60.0302734 41.6376953,60.0302734 C41.8382171,60.0302734 42.038736,60.0222983 42.2392578,60.0063477 C42.4397796,59.9903971 42.6334626,59.9687501 42.8203125,59.9414062 C43.0071624,59.9140624 43.1860343,59.883301 43.3569336,59.8491211 C43.5278329,59.8149412 43.6861972,59.777344 43.8320312,59.7363281 L43.8320312,60.7138672 C43.5084619,60.8050135 43.1427429,60.8790687 42.7348633,60.9360352 C42.3269836,60.9930016 41.9042991,61.0214844 41.4667969,61.0214844 C40.8789033,61.0214844 40.373049,60.9417326 39.9492188,60.7822266 C39.5253885,60.6227206 39.1778985,60.3914403 38.9067383,60.0883789 C38.6355781,59.7853175 38.4350592,59.4139019 38.3051758,58.9741211 C38.1752923,58.5343402 38.1103516,58.0364611 38.1103516,57.4804688 C38.1103516,56.9973934 38.1798496,56.5405295 38.3188477,56.1098633 C38.4578457,55.6791971 38.6606432,55.3009456 38.9272461,54.9750977 C39.193849,54.6492497 39.5208314,54.390626 39.9082031,54.1992188 C40.2955749,54.0078115 40.7353491,53.9121094 41.2275391,53.9121094 C41.7060571,53.9121094 42.129881,53.9873039 42.4990234,54.1376953 C42.8681659,54.2880867 43.179198,54.5011379 43.4321289,54.7768555 C43.6850599,55.052573 43.8764642,55.3875306 44.0063477,55.7817383 C44.1362311,56.175946 44.2011719,56.6168595 44.2011719,57.1044922 Z M42.9638672,56.9335938 C42.9775391,56.6282537 42.947917,56.3491224 42.875,56.0961914 C42.802083,55.8432605 42.6892911,55.625652 42.5366211,55.4433594 C42.3839511,55.2610668 42.193686,55.1186529 41.9658203,55.0161133 C41.7379546,54.9135737 41.4736343,54.8623047 41.1728516,54.8623047 C40.9130846,54.8623047 40.6761078,54.9124344 40.4619141,55.0126953 C40.2477203,55.1129562 40.0631518,55.2542309 39.9082031,55.4365234 C39.7532544,55.618816 39.6279302,55.8375638 39.5322266,56.0927734 C39.436523,56.347983 39.3772788,56.6282537 39.3544922,56.9335938 L42.9638672,56.9335938 Z M48.4394531,55.0195312 L46.4091797,55.0195312 L46.4091797,54.0351562 L49.6425781,54.0351562 L49.6425781,59.9072266 L51.6865234,59.9072266 L51.6865234,60.8984375 L46.1835938,60.8984375 L46.1835938,59.9072266 L48.4394531,59.9072266 L48.4394531,55.0195312 Z M48.8564453,51.1572266 C48.9886074,51.1572266 49.1116531,51.1811521 49.2255859,51.2290039 C49.3395188,51.2768557 49.4386389,51.3440751 49.5229492,51.4306641 C49.6072595,51.517253 49.6733396,51.6163731 49.7211914,51.7280273 C49.7690432,51.8396815 49.7929688,51.9615879 49.7929688,52.09375 C49.7929688,52.2213548 49.7690432,52.3421218 49.7211914,52.4560547 C49.6733396,52.5699875 49.6072595,52.670247 49.5229492,52.7568359 C49.4386389,52.8434249 49.3395188,52.9106443 49.2255859,52.9584961 C49.1116531,53.0063479 48.9886074,53.0302734 48.8564453,53.0302734 C48.7242832,53.0302734 48.6012375,53.0063479 48.4873047,52.9584961 C48.3733718,52.9106443 48.2742517,52.8434249 48.1899414,52.7568359 C48.1056311,52.670247 48.039551,52.5699875 47.9916992,52.4560547 C47.9438474,52.3421218 47.9199219,52.2213548 47.9199219,52.09375 C47.9199219,51.9615879 47.9438474,51.8396815 47.9916992,51.7280273 C48.039551,51.6163731 48.1056311,51.517253 48.1899414,51.4306641 C48.2742517,51.3440751 48.3733718,51.2768557 48.4873047,51.2290039 C48.6012375,51.1811521 48.7242832,51.1572266 48.8564453,51.1572266 Z M58.7412109,55.0058594 C58.8688157,55.1653654 58.9679358,55.3510732 59.0385742,55.5629883 C59.1092126,55.7749034 59.1445312,56.003905 59.1445312,56.25 C59.1445312,56.6054705 59.0795905,56.9301743 58.949707,57.2241211 C58.8198236,57.5180679 58.6363944,57.7698557 58.3994141,57.9794922 C58.1624337,58.1891287 57.8787451,58.3520502 57.5483398,58.4682617 C57.2179345,58.5844732 56.8544942,58.6425781 56.4580078,58.6425781 C56.170897,58.6425781 55.9020195,58.6118167 55.6513672,58.550293 C55.4007149,58.4887692 55.2024747,58.4124354 55.0566406,58.3212891 C54.9700517,58.4488939 54.8971357,58.5696609 54.8378906,58.6835938 C54.7786455,58.7975266 54.7490234,58.9251295 54.7490234,59.0664062 C54.7490234,59.2395842 54.8321932,59.3831375 54.9985352,59.4970703 C55.1648771,59.6110032 55.3847643,59.672526 55.6582031,59.6816406 L57.4628906,59.75 C57.8046892,59.7591146 58.1202785,59.8024085 58.409668,59.8798828 C58.6990574,59.9573572 58.9474273,60.0690097 59.1547852,60.2148438 C59.362143,60.3606778 59.5239252,60.540689 59.6401367,60.7548828 C59.7563482,60.9690766 59.8144531,61.2174465 59.8144531,61.5 C59.8144531,61.8053401 59.7483731,62.0947252 59.6162109,62.3681641 C59.4840488,62.6416029 59.2801121,62.8819977 59.0043945,63.0893555 C58.728677,63.2967133 58.3789084,63.4619134 57.9550781,63.5849609 C57.5312479,63.7080084 57.0276722,63.7695312 56.4443359,63.7695312 C55.8883436,63.7695312 55.4155293,63.7250981 55.0258789,63.6362305 C54.6362285,63.5473628 54.316082,63.4243172 54.0654297,63.2670898 C53.8147774,63.1098625 53.6324875,62.9230154 53.5185547,62.706543 C53.4046218,62.4900705 53.3476562,62.2519544 53.3476562,61.9921875 C53.3476562,61.6595035 53.4251294,61.3678398 53.5800781,61.1171875 C53.7350268,60.8665352 53.9742822,60.6250012 54.2978516,60.3925781 C54.1793614,60.3378904 54.0768233,60.2695317 53.9902344,60.1875 C53.9036454,60.1054683 53.8330081,60.0154627 53.7783203,59.9174805 C53.7236325,59.8194982 53.6826173,59.7158209 53.6552734,59.6064453 C53.6279296,59.4970698 53.6142578,59.3899745 53.6142578,59.2851562 C53.6142578,58.9889308 53.6837558,58.7177747 53.8227539,58.4716797 C53.961752,58.2255847 54.1269522,57.9931652 54.3183594,57.7744141 C54.2317704,57.6695958 54.1554365,57.5670578 54.0893555,57.4667969 C54.0232744,57.366536 53.9663088,57.2583014 53.918457,57.1420898 C53.8706052,57.0258783 53.8341473,56.9005541 53.809082,56.7661133 C53.7840168,56.6316725 53.7714844,56.4778654 53.7714844,56.3046875 C53.7714844,55.949217 53.8364251,55.6245132 53.9663086,55.3305664 C54.0961921,55.0366196 54.2784819,54.7848318 54.5131836,54.5751953 C54.7478853,54.3655588 55.0304345,54.2026373 55.3608398,54.0864258 C55.6912451,53.9702143 56.0569641,53.9121094 56.4580078,53.9121094 C56.6266284,53.9121094 56.7884107,53.9235025 56.9433594,53.9462891 C57.0983081,53.9690756 57.2350254,53.9986977 57.3535156,54.0351562 L59.8417969,54.0351562 L59.8417969,55.0058594 L58.7412109,55.0058594 Z M54.6123047,61.8896484 C54.6123047,62.2132178 54.7809228,62.4490552 55.1181641,62.597168 C55.4554053,62.7452807 55.9248017,62.8193359 56.5263672,62.8193359 C56.9046243,62.8193359 57.2224922,62.7851566 57.4799805,62.7167969 C57.7374687,62.6484372 57.9448234,62.5584315 58.1020508,62.4467773 C58.2592781,62.3351231 58.37207,62.2075202 58.4404297,62.0639648 C58.5087894,61.9204094 58.5429688,61.7734383 58.5429688,61.6230469 C58.5429688,61.3450507 58.4290376,61.1399746 58.2011719,61.0078125 C57.9733062,60.8756504 57.6246768,60.7981772 57.1552734,60.7753906 L55.3642578,60.7138672 C55.2138664,60.8141281 55.0896815,60.9121089 54.9916992,61.0078125 C54.893717,61.1035161 54.8173831,61.2003576 54.7626953,61.2983398 C54.7080075,61.3963221 54.6692709,61.4943029 54.6464844,61.5922852 C54.6236978,61.6902674 54.6123047,61.7893875 54.6123047,61.8896484 Z M54.9746094,56.2773438 C54.9746094,56.4960948 55.0110673,56.6966137 55.0839844,56.8789062 C55.1569014,57.0611988 55.2594394,57.2161452 55.3916016,57.34375 C55.5237637,57.4713548 55.6798494,57.5704749 55.8598633,57.6411133 C56.0398772,57.7117517 56.2392567,57.7470703 56.4580078,57.7470703 C56.6949882,57.7470703 56.9057608,57.7071944 57.090332,57.6274414 C57.2749033,57.5476884 57.4298496,57.4394538 57.5551758,57.3027344 C57.6805019,57.1660149 57.7762041,57.00879 57.8422852,56.8310547 C57.9083662,56.6533194 57.9414062,56.468751 57.9414062,56.2773438 C57.9414062,56.0585927 57.9049483,55.8580738 57.8320312,55.6757812 C57.7591142,55.4934887 57.6565762,55.3385423 57.5244141,55.2109375 C57.3922519,55.0833327 57.2361663,54.9842126 57.0561523,54.9135742 C56.8761384,54.8429358 56.6767589,54.8076172 56.4580078,54.8076172 C56.2210275,54.8076172 56.0102548,54.8486324 55.8256836,54.9306641 C55.6411124,55.0126957 55.486166,55.1209303 55.3608398,55.2553711 C55.2355137,55.3898119 55.1398115,55.5458975 55.0737305,55.7236328 C55.0076494,55.9013681 54.9746094,56.0859365 54.9746094,56.2773438 Z M67.0126953,60.8984375 L65.8232422,60.8984375 L65.8232422,56.5166016 C65.8232422,55.9879531 65.7241221,55.592612 65.5258789,55.3305664 C65.3276357,55.0685208 65.0439472,54.9375 64.6748047,54.9375 C64.5152987,54.9375 64.3660489,54.9591469 64.2270508,55.0024414 C64.0880527,55.0457359 63.9433601,55.1209305 63.7929688,55.2280273 C63.6425774,55.3351242 63.4785165,55.4798168 63.3007812,55.6621094 C63.123046,55.844402 62.9179699,56.0722643 62.6855469,56.3457031 L62.6855469,60.8984375 L61.4960938,60.8984375 L61.4960938,51.2392578 L62.6855469,51.2392578 L62.6855469,54.0351562 L62.6445312,55.1152344 C62.8313811,54.891926 63.0148103,54.7039396 63.1948242,54.5512695 C63.3748381,54.3985995 63.5548494,54.2744145 63.7348633,54.1787109 C63.9148772,54.0830073 64.0983064,54.0146486 64.2851562,53.9736328 C64.4720061,53.932617 64.6656891,53.9121094 64.8662109,53.9121094 C65.5498081,53.9121094 66.0784487,54.1206034 66.4521484,54.5375977 C66.8258482,54.9545919 67.0126953,55.5823526 67.0126953,56.4208984 L67.0126953,60.8984375 Z M74.7236328,60.8027344 C74.4547513,60.8710941 74.1767592,60.9200845 73.8896484,60.949707 C73.6025376,60.9793296 73.3108739,60.9941406 73.0146484,60.9941406 C72.153316,60.9941406 71.5107443,60.7993184 71.0869141,60.409668 C70.6630838,60.0200176 70.4511719,59.421879 70.4511719,58.6152344 L70.4511719,55.0332031 L68.5302734,55.0332031 L68.5302734,54.0351562 L70.4511719,54.0351562 L70.4511719,52.1484375 L71.640625,51.8408203 L71.640625,54.0351562 L74.7236328,54.0351562 L74.7236328,55.0332031 L71.640625,55.0332031 L71.640625,58.5195312 C71.640625,59.0117212 71.7716458,59.3797188 72.0336914,59.6235352 C72.295737,59.8673515 72.6819636,59.9892578 73.1923828,59.9892578 C73.4111339,59.9892578 73.6503893,59.9721681 73.9101562,59.9379883 C74.1699232,59.9038084 74.4410793,59.8502608 74.7236328,59.7773438 L74.7236328,60.8027344 Z" id="height" fill="#000000"></path>
+                <path d="M15.7841797,68 L16.2900391,68 C17.1696008,68 17.8235656,68.2062154 18.2519531,68.6186523 C18.6803407,69.0310893 18.8945312,69.6565713 18.8945312,70.4951172 L18.8945312,72.0742188 C18.8945312,72.2975272 18.9195961,72.4969067 18.9697266,72.6723633 C19.019857,72.8478199 19.107584,72.9959304 19.2329102,73.1166992 C19.3582363,73.2374681 19.5257151,73.3297523 19.7353516,73.3935547 C19.944988,73.4573571 20.2070297,73.4892578 20.5214844,73.4892578 L20.8154297,73.4892578 L20.8154297,74.4394531 L20.5214844,74.4394531 C20.1888004,74.4394531 19.916505,74.4667966 19.7045898,74.5214844 C19.4926747,74.5761721 19.3274746,74.6593419 19.2089844,74.7709961 C19.0904942,74.8826503 19.0084638,75.0250642 18.9628906,75.1982422 C18.9173175,75.3714201 18.8945312,75.5764962 18.8945312,75.8134766 L18.8945312,78.2060547 C18.8945312,78.5888691 18.8489588,78.9340805 18.7578125,79.2416992 C18.6666662,79.5493179 18.5185557,79.8113596 18.3134766,80.027832 C18.1083974,80.2443045 17.8395199,80.410644 17.5068359,80.5268555 C17.174152,80.643067 16.7685571,80.7011719 16.2900391,80.7011719 L15.7841797,80.7011719 L15.7841797,79.7441406 L16.1943359,79.7441406 C17.2470756,79.7441406 17.7734375,79.2314504 17.7734375,78.2060547 L17.7734375,75.8408203 C17.7734375,74.7288356 18.254227,74.1044929 19.2158203,73.9677734 C18.2451123,73.8629552 17.7597656,73.2363339 17.7597656,72.0878906 L17.7597656,70.5224609 C17.7597656,69.4788359 17.2379609,68.9570312 16.1943359,68.9570312 L15.7841797,68.9570312 L15.7841797,68 Z M23.5429688,79.2998047 C23.7753918,79.3089193 24.0009755,79.2884117 24.2197266,79.2382812 C24.4384777,79.1881508 24.6310213,79.1140955 24.7973633,79.0161133 C24.9637053,78.918131 25.0970047,78.7962247 25.1972656,78.6503906 C25.2975265,78.5045566 25.3476562,78.3382171 25.3476562,78.1513672 C25.3476562,77.95996 25.3146162,77.8050136 25.2485352,77.6865234 C25.1824541,77.5680333 25.1083988,77.4586594 25.0263672,77.3583984 C24.9443355,77.2581375 24.8702803,77.1510422 24.8041992,77.0371094 C24.7381182,76.9231765 24.7050781,76.7705088 24.7050781,76.5791016 C24.7050781,76.483398 24.7233071,76.3831385 24.7597656,76.2783203 C24.7962241,76.1735021 24.8520504,76.0777999 24.9272461,75.9912109 C25.0024418,75.904622 25.098144,75.8339846 25.2143555,75.7792969 C25.330567,75.7246091 25.4684237,75.6972656 25.6279297,75.6972656 C25.7874357,75.6972656 25.9412427,75.7303057 26.0893555,75.7963867 C26.2374682,75.8624678 26.3673497,75.9638665 26.4790039,76.1005859 C26.5906581,76.2373054 26.6795244,76.4082021 26.7456055,76.6132812 C26.8116865,76.8183604 26.8447266,77.0598944 26.8447266,77.3378906 C26.8447266,77.7161477 26.7752286,78.0795881 26.6362305,78.4282227 C26.4972324,78.7768572 26.2898777,79.0856106 26.0141602,79.3544922 C25.7384426,79.6233737 25.3943706,79.8375643 24.9819336,79.9970703 C24.5694966,80.1565763 24.0898465,80.2363281 23.5429688,80.2363281 L23.5429688,79.2998047 Z" id="}," fill="#878787"></path>
+                <path d="M17.6503906,89.0195312 L15.6201172,89.0195312 L15.6201172,88.0351562 L18.8535156,88.0351562 L18.8535156,93.9072266 L20.8974609,93.9072266 L20.8974609,94.8984375 L15.3945312,94.8984375 L15.3945312,93.9072266 L17.6503906,93.9072266 L17.6503906,89.0195312 Z M18.0673828,85.1572266 C18.1995449,85.1572266 18.3225906,85.1811521 18.4365234,85.2290039 C18.5504563,85.2768557 18.6495764,85.3440751 18.7338867,85.4306641 C18.818197,85.517253 18.8842771,85.6163731 18.9321289,85.7280273 C18.9799807,85.8396815 19.0039062,85.9615879 19.0039062,86.09375 C19.0039062,86.2213548 18.9799807,86.3421218 18.9321289,86.4560547 C18.8842771,86.5699875 18.818197,86.670247 18.7338867,86.7568359 C18.6495764,86.8434249 18.5504563,86.9106443 18.4365234,86.9584961 C18.3225906,87.0063479 18.1995449,87.0302734 18.0673828,87.0302734 C17.9352207,87.0302734 17.812175,87.0063479 17.6982422,86.9584961 C17.5843093,86.9106443 17.4851892,86.8434249 17.4008789,86.7568359 C17.3165686,86.670247 17.2504885,86.5699875 17.2026367,86.4560547 C17.1547849,86.3421218 17.1308594,86.2213548 17.1308594,86.09375 C17.1308594,85.9615879 17.1547849,85.8396815 17.2026367,85.7280273 C17.2504885,85.6163731 17.3165686,85.517253 17.4008789,85.4306641 C17.4851892,85.3440751 17.5843093,85.2768557 17.6982422,85.2290039 C17.812175,85.1811521 17.9352207,85.1572266 18.0673828,85.1572266 Z M28.5400391,94.8027344 C28.2711575,94.8710941 27.9931655,94.9200845 27.7060547,94.949707 C27.4189439,94.9793296 27.1272801,94.9941406 26.8310547,94.9941406 C25.9697223,94.9941406 25.3271506,94.7993184 24.9033203,94.409668 C24.4794901,94.0200176 24.2675781,93.421879 24.2675781,92.6152344 L24.2675781,89.0332031 L22.3466797,89.0332031 L22.3466797,88.0351562 L24.2675781,88.0351562 L24.2675781,86.1484375 L25.4570312,85.8408203 L25.4570312,88.0351562 L28.5400391,88.0351562 L28.5400391,89.0332031 L25.4570312,89.0332031 L25.4570312,92.5195312 C25.4570312,93.0117212 25.5880521,93.3797188 25.8500977,93.6235352 C26.1121432,93.8673515 26.4983698,93.9892578 27.0087891,93.9892578 C27.2275402,93.9892578 27.4667956,93.9721681 27.7265625,93.9379883 C27.9863294,93.9038084 28.2574856,93.8502608 28.5400391,93.7773438 L28.5400391,94.8027344 Z M36.5039062,91.1044922 C36.5039062,91.2731128 36.5016276,91.4143875 36.4970703,91.5283203 C36.492513,91.6422532 36.4856771,91.7493485 36.4765625,91.8496094 L31.6572266,91.8496094 C31.6572266,92.5514358 31.8531881,93.0903302 32.2451172,93.4663086 C32.6370462,93.842287 33.2021447,94.0302734 33.9404297,94.0302734 C34.1409515,94.0302734 34.3414704,94.0222983 34.5419922,94.0063477 C34.742514,93.9903971 34.936197,93.9687501 35.1230469,93.9414062 C35.3098968,93.9140624 35.4887687,93.883301 35.659668,93.8491211 C35.8305673,93.8149412 35.9889316,93.777344 36.1347656,93.7363281 L36.1347656,94.7138672 C35.8111963,94.8050135 35.4454773,94.8790687 35.0375977,94.9360352 C34.629718,94.9930016 34.2070334,95.0214844 33.7695312,95.0214844 C33.1816377,95.0214844 32.6757834,94.9417326 32.2519531,94.7822266 C31.8281229,94.6227206 31.4806329,94.3914403 31.2094727,94.0883789 C30.9383124,93.7853175 30.7377936,93.4139019 30.6079102,92.9741211 C30.4780267,92.5343402 30.4130859,92.0364611 30.4130859,91.4804688 C30.4130859,90.9973934 30.4825839,90.5405295 30.621582,90.1098633 C30.7605801,89.6791971 30.9633776,89.3009456 31.2299805,88.9750977 C31.4965834,88.6492497 31.8235658,88.390626 32.2109375,88.1992188 C32.5983092,88.0078115 33.0380835,87.9121094 33.5302734,87.9121094 C34.0087915,87.9121094 34.4326153,87.9873039 34.8017578,88.1376953 C35.1709003,88.2880867 35.4819323,88.5011379 35.7348633,88.7768555 C35.9877942,89.052573 36.1791986,89.3875306 36.309082,89.7817383 C36.4389655,90.175946 36.5039062,90.6168595 36.5039062,91.1044922 Z M35.2666016,90.9335938 C35.2802735,90.6282537 35.2506514,90.3491224 35.1777344,90.0961914 C35.1048173,89.8432605 34.9920255,89.625652 34.8393555,89.4433594 C34.6866854,89.2610668 34.4964204,89.1186529 34.2685547,89.0161133 C34.040689,88.9135737 33.7763687,88.8623047 33.4755859,88.8623047 C33.215819,88.8623047 32.9788422,88.9124344 32.7646484,89.0126953 C32.5504547,89.1129562 32.3658862,89.2542309 32.2109375,89.4365234 C32.0559888,89.618816 31.9306645,89.8375638 31.8349609,90.0927734 C31.7392573,90.347983 31.6800131,90.6282537 31.6572266,90.9335938 L35.2666016,90.9335938 Z M43.2988281,94.8984375 L43.2988281,89.9697266 C43.2988281,89.7555328 43.2908529,89.5800788 43.2749023,89.4433594 C43.2589517,89.3066399 43.2338869,89.1984053 43.199707,89.1186523 C43.1655272,89.0388993 43.1222333,88.9830731 43.0698242,88.9511719 C43.0174151,88.9192707 42.9524743,88.9033203 42.875,88.9033203 C42.7838537,88.9033203 42.6995447,88.9306638 42.6220703,88.9853516 C42.544596,89.0400393 42.4614262,89.1289056 42.3725586,89.2519531 C42.283691,89.3750006 42.1857102,89.5379222 42.0786133,89.7407227 C41.9715164,89.9435231 41.8450528,90.1930324 41.6992188,90.4892578 L41.6992188,94.8984375 L40.6123047,94.8984375 L40.6123047,90.0996094 C40.6123047,89.8489571 40.6043295,89.6461596 40.5883789,89.4912109 C40.5724283,89.3362622 40.5473635,89.2154952 40.5131836,89.1289062 C40.4790037,89.0423173 40.4345706,88.9830731 40.3798828,88.9511719 C40.325195,88.9192707 40.259115,88.9033203 40.1816406,88.9033203 C40.099609,88.9033203 40.0221358,88.9261065 39.9492188,88.9716797 C39.8763017,89.0172528 39.7954106,89.0992833 39.706543,89.2177734 C39.6176753,89.3362636 39.5185552,89.4980458 39.4091797,89.703125 C39.2998041,89.9082042 39.1699226,90.1702458 39.0195312,90.4892578 L39.0195312,94.8984375 L37.9257812,94.8984375 L37.9257812,88.0351562 L38.8349609,88.0351562 L38.8896484,89.3408203 C39.0081386,89.0810534 39.1232091,88.860027 39.2348633,88.6777344 C39.3465175,88.4954418 39.4615879,88.3484706 39.5800781,88.2368164 C39.6985683,88.1251622 39.8250319,88.0431318 39.9594727,87.9907227 C40.0939134,87.9383135 40.2431632,87.9121094 40.4072266,87.9121094 C40.776369,87.9121094 41.0566397,88.0328764 41.2480469,88.2744141 C41.4394541,88.5159517 41.5351562,88.8896459 41.5351562,89.3955078 C41.6445318,89.1585275 41.7516271,88.9477548 41.8564453,88.7631836 C41.9612635,88.5786124 42.0740554,88.423666 42.1948242,88.2983398 C42.3155931,88.1730137 42.4488925,88.0773115 42.5947266,88.0112305 C42.7405606,87.9451494 42.9091787,87.9121094 43.1005859,87.9121094 C43.9619184,87.9121094 44.3925781,88.5751887 44.3925781,89.9013672 L44.3925781,94.8984375 L43.2988281,94.8984375 Z M51.5361328,93.0253906 C51.5361328,93.2669283 51.4951176,93.4833975 51.4130859,93.6748047 C51.3310543,93.8662119 51.2194017,94.0359693 51.078125,94.184082 C50.9368483,94.3321948 50.7727874,94.4586583 50.5859375,94.5634766 C50.3990876,94.6682948 50.1997081,94.7548825 49.987793,94.8232422 C49.7758778,94.8916019 49.5582693,94.9417316 49.3349609,94.9736328 C49.1116525,95.005534 48.8929047,95.0214844 48.6787109,95.0214844 C48.2138649,95.0214844 47.786623,95.0009768 47.3969727,94.9599609 C47.0073223,94.9189451 46.6256529,94.852865 46.2519531,94.7617188 L46.2519531,93.6679688 C46.6529968,93.7819016 47.0517558,93.8684893 47.4482422,93.9277344 C47.8447285,93.9869795 48.2389303,94.0166016 48.6308594,94.0166016 C49.2005237,94.0166016 49.6220689,93.9391284 49.8955078,93.7841797 C50.1689467,93.629231 50.3056641,93.4082046 50.3056641,93.1210938 C50.3056641,92.9980463 50.2840171,92.887533 50.2407227,92.7895508 C50.1974282,92.6915685 50.1188157,92.598145 50.0048828,92.5092773 C49.89095,92.4204097 49.7143567,92.3281255 49.4750977,92.2324219 C49.2358386,92.1367183 48.9088562,92.0273444 48.4941406,91.9042969 C48.1842432,91.8131506 47.898276,91.7094732 47.6362305,91.5932617 C47.3741849,91.4770502 47.1474619,91.3391935 46.9560547,91.1796875 C46.7646475,91.0201815 46.6142584,90.8333344 46.5048828,90.6191406 C46.3955073,90.4049468 46.3408203,90.1520197 46.3408203,89.8603516 C46.3408203,89.6689444 46.3852535,89.459311 46.4741211,89.2314453 C46.5629887,89.0035796 46.7145172,88.7916676 46.9287109,88.5957031 C47.1429047,88.3997386 47.4322898,88.2368171 47.796875,88.1069336 C48.1614602,87.9770501 48.6171848,87.9121094 49.1640625,87.9121094 C49.4329441,87.9121094 49.7314437,87.9269204 50.0595703,87.956543 C50.387697,87.9861655 50.7294904,88.0374345 51.0849609,88.1103516 L51.0849609,89.1699219 C50.7112612,89.0787756 50.3569353,89.0115562 50.0219727,88.9682617 C49.68701,88.9249672 49.3964856,88.9033203 49.1503906,88.9033203 C48.8541652,88.9033203 48.604656,88.9261065 48.4018555,88.9716797 C48.199055,89.0172528 48.0349941,89.079915 47.909668,89.159668 C47.7843418,89.239421 47.6943362,89.3328445 47.6396484,89.4399414 C47.5849607,89.5470383 47.5576172,89.6621088 47.5576172,89.7851562 C47.5576172,89.9082037 47.5815427,90.0198563 47.6293945,90.1201172 C47.6772463,90.2203781 47.7661126,90.3172196 47.8959961,90.4106445 C48.0258796,90.5040695 48.2070301,90.597493 48.4394531,90.690918 C48.6718762,90.7843429 48.974933,90.8857416 49.3486328,90.9951172 C49.7542338,91.1136074 50.0960273,91.2377923 50.3740234,91.3676758 C50.6520196,91.4975592 50.8776033,91.6422518 51.0507812,91.8017578 C51.2239592,91.9612638 51.3481442,92.141275 51.4233398,92.3417969 C51.4985355,92.5423187 51.5361328,92.770181 51.5361328,93.0253906 Z" id="items" fill="#000000"></path>
+                <path d="M56.5537109,87.9121094 C56.6949877,87.9121094 56.8294264,87.9405922 56.9570312,87.9975586 C57.0846361,88.054525 57.1962886,88.1308589 57.2919922,88.2265625 C57.3876958,88.3222661 57.4640297,88.4339186 57.5209961,88.5615234 C57.5779625,88.6891282 57.6064453,88.823567 57.6064453,88.9648438 C57.6064453,89.1106778 57.5779625,89.2462559 57.5209961,89.371582 C57.4640297,89.4969082 57.3876958,89.6074214 57.2919922,89.703125 C57.1962886,89.7988286 57.0846361,89.8740232 56.9570312,89.9287109 C56.8294264,89.9833987 56.6949877,90.0107422 56.5537109,90.0107422 C56.4078769,90.0107422 56.2722988,89.9833987 56.1469727,89.9287109 C56.0216465,89.8740232 55.9111333,89.7988286 55.8154297,89.703125 C55.7197261,89.6074214 55.6445315,89.4969082 55.5898438,89.371582 C55.535156,89.2462559 55.5078125,89.1106778 55.5078125,88.9648438 C55.5078125,88.823567 55.535156,88.6891282 55.5898438,88.5615234 C55.6445315,88.4339186 55.7197261,88.3222661 55.8154297,88.2265625 C55.9111333,88.1308589 56.0216465,88.054525 56.1469727,87.9975586 C56.2722988,87.9405922 56.4078769,87.9121094 56.5537109,87.9121094 Z M56.5537109,92.9228516 C56.6949877,92.9228516 56.8294264,92.9513344 56.9570312,93.0083008 C57.0846361,93.0652672 57.1962886,93.1416011 57.2919922,93.2373047 C57.3876958,93.3330083 57.4640297,93.4446608 57.5209961,93.5722656 C57.5779625,93.6998704 57.6064453,93.8343092 57.6064453,93.9755859 C57.6064453,94.12142 57.5779625,94.2569981 57.5209961,94.3823242 C57.4640297,94.5076504 57.3876958,94.6181636 57.2919922,94.7138672 C57.1962886,94.8095708 57.0846361,94.8847654 56.9570312,94.9394531 C56.8294264,94.9941409 56.6949877,95.0214844 56.5537109,95.0214844 C56.4078769,95.0214844 56.2722988,94.9941409 56.1469727,94.9394531 C56.0216465,94.8847654 55.9111333,94.8095708 55.8154297,94.7138672 C55.7197261,94.6181636 55.6445315,94.5076504 55.5898438,94.3823242 C55.535156,94.2569981 55.5078125,94.12142 55.5078125,93.9755859 C55.5078125,93.8343092 55.535156,93.6998704 55.5898438,93.5722656 C55.6445315,93.4446608 55.7197261,93.3330083 55.8154297,93.2373047 C55.9111333,93.1416011 56.0216465,93.0652672 56.1469727,93.0083008 C56.2722988,92.9513344 56.4078769,92.9228516 56.5537109,92.9228516 Z M73.828125,97.7011719 L70.4580078,97.7011719 L70.4580078,85 L73.828125,85 L73.828125,85.9570312 L71.5927734,85.9570312 L71.5927734,96.7441406 L73.828125,96.7441406 L73.828125,97.7011719 Z" id=":[" fill="#878787"></path>
+                <path d="M79.2285156,89.0195312 L77.1982422,89.0195312 L77.1982422,88.0351562 L80.4316406,88.0351562 L80.4316406,93.9072266 L82.4755859,93.9072266 L82.4755859,94.8984375 L76.9726562,94.8984375 L76.9726562,93.9072266 L79.2285156,93.9072266 L79.2285156,89.0195312 Z M79.6455078,85.1572266 C79.7776699,85.1572266 79.9007156,85.1811521 80.0146484,85.2290039 C80.1285813,85.2768557 80.2277014,85.3440751 80.3120117,85.4306641 C80.396322,85.517253 80.4624021,85.6163731 80.5102539,85.7280273 C80.5581057,85.8396815 80.5820312,85.9615879 80.5820312,86.09375 C80.5820312,86.2213548 80.5581057,86.3421218 80.5102539,86.4560547 C80.4624021,86.5699875 80.396322,86.670247 80.3120117,86.7568359 C80.2277014,86.8434249 80.1285813,86.9106443 80.0146484,86.9584961 C79.9007156,87.0063479 79.7776699,87.0302734 79.6455078,87.0302734 C79.5133457,87.0302734 79.3903,87.0063479 79.2763672,86.9584961 C79.1624343,86.9106443 79.0633142,86.8434249 78.9790039,86.7568359 C78.8946936,86.670247 78.8286135,86.5699875 78.7807617,86.4560547 C78.7329099,86.3421218 78.7089844,86.2213548 78.7089844,86.09375 C78.7089844,85.9615879 78.7329099,85.8396815 78.7807617,85.7280273 C78.8286135,85.6163731 78.8946936,85.517253 78.9790039,85.4306641 C79.0633142,85.3440751 79.1624343,85.2768557 79.2763672,85.2290039 C79.3903,85.1811521 79.5133457,85.1572266 79.6455078,85.1572266 Z M90.1181641,94.8027344 C89.8492825,94.8710941 89.5712905,94.9200845 89.2841797,94.949707 C88.9970689,94.9793296 88.7054051,94.9941406 88.4091797,94.9941406 C87.5478473,94.9941406 86.9052756,94.7993184 86.4814453,94.409668 C86.0576151,94.0200176 85.8457031,93.421879 85.8457031,92.6152344 L85.8457031,89.0332031 L83.9248047,89.0332031 L83.9248047,88.0351562 L85.8457031,88.0351562 L85.8457031,86.1484375 L87.0351562,85.8408203 L87.0351562,88.0351562 L90.1181641,88.0351562 L90.1181641,89.0332031 L87.0351562,89.0332031 L87.0351562,92.5195312 C87.0351562,93.0117212 87.1661771,93.3797188 87.4282227,93.6235352 C87.6902682,93.8673515 88.0764948,93.9892578 88.5869141,93.9892578 C88.8056652,93.9892578 89.0449206,93.9721681 89.3046875,93.9379883 C89.5644544,93.9038084 89.8356106,93.8502608 90.1181641,93.7773438 L90.1181641,94.8027344 Z M98.0820312,91.1044922 C98.0820312,91.2731128 98.0797526,91.4143875 98.0751953,91.5283203 C98.070638,91.6422532 98.0638021,91.7493485 98.0546875,91.8496094 L93.2353516,91.8496094 C93.2353516,92.5514358 93.4313131,93.0903302 93.8232422,93.4663086 C94.2151712,93.842287 94.7802697,94.0302734 95.5185547,94.0302734 C95.7190765,94.0302734 95.9195954,94.0222983 96.1201172,94.0063477 C96.320639,93.9903971 96.514322,93.9687501 96.7011719,93.9414062 C96.8880218,93.9140624 97.0668937,93.883301 97.237793,93.8491211 C97.4086923,93.8149412 97.5670566,93.777344 97.7128906,93.7363281 L97.7128906,94.7138672 C97.3893213,94.8050135 97.0236023,94.8790687 96.6157227,94.9360352 C96.207843,94.9930016 95.7851584,95.0214844 95.3476562,95.0214844 C94.7597627,95.0214844 94.2539084,94.9417326 93.8300781,94.7822266 C93.4062479,94.6227206 93.0587579,94.3914403 92.7875977,94.0883789 C92.5164374,93.7853175 92.3159186,93.4139019 92.1860352,92.9741211 C92.0561517,92.5343402 91.9912109,92.0364611 91.9912109,91.4804688 C91.9912109,90.9973934 92.0607089,90.5405295 92.199707,90.1098633 C92.3387051,89.6791971 92.5415026,89.3009456 92.8081055,88.9750977 C93.0747084,88.6492497 93.4016908,88.390626 93.7890625,88.1992188 C94.1764342,88.0078115 94.6162085,87.9121094 95.1083984,87.9121094 C95.5869165,87.9121094 96.0107403,87.9873039 96.3798828,88.1376953 C96.7490253,88.2880867 97.0600573,88.5011379 97.3129883,88.7768555 C97.5659192,89.052573 97.7573236,89.3875306 97.887207,89.7817383 C98.0170905,90.175946 98.0820312,90.6168595 98.0820312,91.1044922 Z M96.8447266,90.9335938 C96.8583985,90.6282537 96.8287764,90.3491224 96.7558594,90.0961914 C96.6829423,89.8432605 96.5701505,89.625652 96.4174805,89.4433594 C96.2648104,89.2610668 96.0745454,89.1186529 95.8466797,89.0161133 C95.618814,88.9135737 95.3544937,88.8623047 95.0537109,88.8623047 C94.793944,88.8623047 94.5569672,88.9124344 94.3427734,89.0126953 C94.1285797,89.1129562 93.9440112,89.2542309 93.7890625,89.4365234 C93.6341138,89.618816 93.5087895,89.8375638 93.4130859,90.0927734 C93.3173823,90.347983 93.2581381,90.6282537 93.2353516,90.9335938 L96.8447266,90.9335938 Z M104.876953,94.8984375 L104.876953,89.9697266 C104.876953,89.7555328 104.868978,89.5800788 104.853027,89.4433594 C104.837077,89.3066399 104.812012,89.1984053 104.777832,89.1186523 C104.743652,89.0388993 104.700358,88.9830731 104.647949,88.9511719 C104.59554,88.9192707 104.530599,88.9033203 104.453125,88.9033203 C104.361979,88.9033203 104.27767,88.9306638 104.200195,88.9853516 C104.122721,89.0400393 104.039551,89.1289056 103.950684,89.2519531 C103.861816,89.3750006 103.763835,89.5379222 103.656738,89.7407227 C103.549641,89.9435231 103.423178,90.1930324 103.277344,90.4892578 L103.277344,94.8984375 L102.19043,94.8984375 L102.19043,90.0996094 C102.19043,89.8489571 102.182455,89.6461596 102.166504,89.4912109 C102.150553,89.3362622 102.125488,89.2154952 102.091309,89.1289062 C102.057129,89.0423173 102.012696,88.9830731 101.958008,88.9511719 C101.90332,88.9192707 101.83724,88.9033203 101.759766,88.9033203 C101.677734,88.9033203 101.600261,88.9261065 101.527344,88.9716797 C101.454427,89.0172528 101.373536,89.0992833 101.284668,89.2177734 C101.1958,89.3362636 101.09668,89.4980458 100.987305,89.703125 C100.877929,89.9082042 100.748048,90.1702458 100.597656,90.4892578 L100.597656,94.8984375 L99.5039062,94.8984375 L99.5039062,88.0351562 L100.413086,88.0351562 L100.467773,89.3408203 C100.586264,89.0810534 100.701334,88.860027 100.812988,88.6777344 C100.924642,88.4954418 101.039713,88.3484706 101.158203,88.2368164 C101.276693,88.1251622 101.403157,88.0431318 101.537598,87.9907227 C101.672038,87.9383135 101.821288,87.9121094 101.985352,87.9121094 C102.354494,87.9121094 102.634765,88.0328764 102.826172,88.2744141 C103.017579,88.5159517 103.113281,88.8896459 103.113281,89.3955078 C103.222657,89.1585275 103.329752,88.9477548 103.43457,88.7631836 C103.539389,88.5786124 103.65218,88.423666 103.772949,88.2983398 C103.893718,88.1730137 104.027017,88.0773115 104.172852,88.0112305 C104.318686,87.9451494 104.487304,87.9121094 104.678711,87.9121094 C105.540043,87.9121094 105.970703,88.5751887 105.970703,89.9013672 L105.970703,94.8984375 L104.876953,94.8984375 Z M113.401367,94.8984375 L107.789062,94.8984375 L107.789062,93.7910156 L110.085938,93.7910156 L110.085938,87.2695312 L107.946289,88.4316406 L107.508789,87.4199219 L110.352539,85.9228516 L111.405273,85.9228516 L111.405273,93.7910156 L113.401367,93.7910156 L113.401367,94.8984375 Z" id="item1" fill="#000000"></path>
+                <path d="M115.910156,96.2998047 C116.142579,96.3089193 116.368163,96.2884117 116.586914,96.2382812 C116.805665,96.1881508 116.998209,96.1140955 117.164551,96.0161133 C117.330893,95.918131 117.464192,95.7962247 117.564453,95.6503906 C117.664714,95.5045566 117.714844,95.3382171 117.714844,95.1513672 C117.714844,94.95996 117.681804,94.8050136 117.615723,94.6865234 C117.549642,94.5680333 117.475586,94.4586594 117.393555,94.3583984 C117.311523,94.2581375 117.237468,94.1510422 117.171387,94.0371094 C117.105306,93.9231765 117.072266,93.7705088 117.072266,93.5791016 C117.072266,93.483398 117.090495,93.3831385 117.126953,93.2783203 C117.163412,93.1735021 117.219238,93.0777999 117.294434,92.9912109 C117.369629,92.904622 117.465331,92.8339846 117.581543,92.7792969 C117.697754,92.7246091 117.835611,92.6972656 117.995117,92.6972656 C118.154623,92.6972656 118.30843,92.7303057 118.456543,92.7963867 C118.604656,92.8624678 118.734537,92.9638665 118.846191,93.1005859 C118.957846,93.2373054 119.046712,93.4082021 119.112793,93.6132812 C119.178874,93.8183604 119.211914,94.0598944 119.211914,94.3378906 C119.211914,94.7161477 119.142416,95.0795881 119.003418,95.4282227 C118.86442,95.7768572 118.657065,96.0856106 118.381348,96.3544922 C118.10563,96.6233737 117.761558,96.8375643 117.349121,96.9970703 C116.936684,97.1565763 116.457034,97.2363281 115.910156,97.2363281 L115.910156,96.2998047 Z" id="," fill="#878787"></path>
+                <path d="M133.109375,89.0195312 L131.079102,89.0195312 L131.079102,88.0351562 L134.3125,88.0351562 L134.3125,93.9072266 L136.356445,93.9072266 L136.356445,94.8984375 L130.853516,94.8984375 L130.853516,93.9072266 L133.109375,93.9072266 L133.109375,89.0195312 Z M133.526367,85.1572266 C133.658529,85.1572266 133.781575,85.1811521 133.895508,85.2290039 C134.009441,85.2768557 134.108561,85.3440751 134.192871,85.4306641 C134.277181,85.517253 134.343261,85.6163731 134.391113,85.7280273 C134.438965,85.8396815 134.462891,85.9615879 134.462891,86.09375 C134.462891,86.2213548 134.438965,86.3421218 134.391113,86.4560547 C134.343261,86.5699875 134.277181,86.670247 134.192871,86.7568359 C134.108561,86.8434249 134.009441,86.9106443 133.895508,86.9584961 C133.781575,87.0063479 133.658529,87.0302734 133.526367,87.0302734 C133.394205,87.0302734 133.271159,87.0063479 133.157227,86.9584961 C133.043294,86.9106443 132.944174,86.8434249 132.859863,86.7568359 C132.775553,86.670247 132.709473,86.5699875 132.661621,86.4560547 C132.613769,86.3421218 132.589844,86.2213548 132.589844,86.09375 C132.589844,85.9615879 132.613769,85.8396815 132.661621,85.7280273 C132.709473,85.6163731 132.775553,85.517253 132.859863,85.4306641 C132.944174,85.3440751 133.043294,85.2768557 133.157227,85.2290039 C133.271159,85.1811521 133.394205,85.1572266 133.526367,85.1572266 Z M143.999023,94.8027344 C143.730142,94.8710941 143.45215,94.9200845 143.165039,94.949707 C142.877928,94.9793296 142.586265,94.9941406 142.290039,94.9941406 C141.428707,94.9941406 140.786135,94.7993184 140.362305,94.409668 C139.938474,94.0200176 139.726562,93.421879 139.726562,92.6152344 L139.726562,89.0332031 L137.805664,89.0332031 L137.805664,88.0351562 L139.726562,88.0351562 L139.726562,86.1484375 L140.916016,85.8408203 L140.916016,88.0351562 L143.999023,88.0351562 L143.999023,89.0332031 L140.916016,89.0332031 L140.916016,92.5195312 C140.916016,93.0117212 141.047036,93.3797188 141.309082,93.6235352 C141.571128,93.8673515 141.957354,93.9892578 142.467773,93.9892578 C142.686525,93.9892578 142.92578,93.9721681 143.185547,93.9379883 C143.445314,93.9038084 143.71647,93.8502608 143.999023,93.7773438 L143.999023,94.8027344 Z M151.962891,91.1044922 C151.962891,91.2731128 151.960612,91.4143875 151.956055,91.5283203 C151.951497,91.6422532 151.944662,91.7493485 151.935547,91.8496094 L147.116211,91.8496094 C147.116211,92.5514358 147.312173,93.0903302 147.704102,93.4663086 C148.096031,93.842287 148.661129,94.0302734 149.399414,94.0302734 C149.599936,94.0302734 149.800455,94.0222983 150.000977,94.0063477 C150.201498,93.9903971 150.395181,93.9687501 150.582031,93.9414062 C150.768881,93.9140624 150.947753,93.883301 151.118652,93.8491211 C151.289552,93.8149412 151.447916,93.777344 151.59375,93.7363281 L151.59375,94.7138672 C151.270181,94.8050135 150.904462,94.8790687 150.496582,94.9360352 C150.088702,94.9930016 149.666018,95.0214844 149.228516,95.0214844 C148.640622,95.0214844 148.134768,94.9417326 147.710938,94.7822266 C147.287107,94.6227206 146.939617,94.3914403 146.668457,94.0883789 C146.397297,93.7853175 146.196778,93.4139019 146.066895,92.9741211 C145.937011,92.5343402 145.87207,92.0364611 145.87207,91.4804688 C145.87207,90.9973934 145.941568,90.5405295 146.080566,90.1098633 C146.219564,89.6791971 146.422362,89.3009456 146.688965,88.9750977 C146.955568,88.6492497 147.28255,88.390626 147.669922,88.1992188 C148.057294,88.0078115 148.497068,87.9121094 148.989258,87.9121094 C149.467776,87.9121094 149.8916,87.9873039 150.260742,88.1376953 C150.629885,88.2880867 150.940917,88.5011379 151.193848,88.7768555 C151.446779,89.052573 151.638183,89.3875306 151.768066,89.7817383 C151.89795,90.175946 151.962891,90.6168595 151.962891,91.1044922 Z M150.725586,90.9335938 C150.739258,90.6282537 150.709636,90.3491224 150.636719,90.0961914 C150.563802,89.8432605 150.45101,89.625652 150.29834,89.4433594 C150.14567,89.2610668 149.955405,89.1186529 149.727539,89.0161133 C149.499673,88.9135737 149.235353,88.8623047 148.93457,88.8623047 C148.674803,88.8623047 148.437827,88.9124344 148.223633,89.0126953 C148.009439,89.1129562 147.824871,89.2542309 147.669922,89.4365234 C147.514973,89.618816 147.389649,89.8375638 147.293945,90.0927734 C147.198242,90.347983 147.138998,90.6282537 147.116211,90.9335938 L150.725586,90.9335938 Z M158.757812,94.8984375 L158.757812,89.9697266 C158.757812,89.7555328 158.749837,89.5800788 158.733887,89.4433594 C158.717936,89.3066399 158.692871,89.1984053 158.658691,89.1186523 C158.624512,89.0388993 158.581218,88.9830731 158.528809,88.9511719 C158.476399,88.9192707 158.411459,88.9033203 158.333984,88.9033203 C158.242838,88.9033203 158.158529,88.9306638 158.081055,88.9853516 C158.00358,89.0400393 157.920411,89.1289056 157.831543,89.2519531 C157.742675,89.3750006 157.644695,89.5379222 157.537598,89.7407227 C157.430501,89.9435231 157.304037,90.1930324 157.158203,90.4892578 L157.158203,94.8984375 L156.071289,94.8984375 L156.071289,90.0996094 C156.071289,89.8489571 156.063314,89.6461596 156.047363,89.4912109 C156.031413,89.3362622 156.006348,89.2154952 155.972168,89.1289062 C155.937988,89.0423173 155.893555,88.9830731 155.838867,88.9511719 C155.784179,88.9192707 155.718099,88.9033203 155.640625,88.9033203 C155.558593,88.9033203 155.48112,88.9261065 155.408203,88.9716797 C155.335286,89.0172528 155.254395,89.0992833 155.165527,89.2177734 C155.07666,89.3362636 154.97754,89.4980458 154.868164,89.703125 C154.758789,89.9082042 154.628907,90.1702458 154.478516,90.4892578 L154.478516,94.8984375 L153.384766,94.8984375 L153.384766,88.0351562 L154.293945,88.0351562 L154.348633,89.3408203 C154.467123,89.0810534 154.582193,88.860027 154.693848,88.6777344 C154.805502,88.4954418 154.920572,88.3484706 155.039062,88.2368164 C155.157553,88.1251622 155.284016,88.0431318 155.418457,87.9907227 C155.552898,87.9383135 155.702148,87.9121094 155.866211,87.9121094 C156.235353,87.9121094 156.515624,88.0328764 156.707031,88.2744141 C156.898438,88.5159517 156.994141,88.8896459 156.994141,89.3955078 C157.103516,89.1585275 157.210611,88.9477548 157.31543,88.7631836 C157.420248,88.5786124 157.53304,88.423666 157.653809,88.2983398 C157.774577,88.1730137 157.907877,88.0773115 158.053711,88.0112305 C158.199545,87.9451494 158.368163,87.9121094 158.55957,87.9121094 C159.420903,87.9121094 159.851562,88.5751887 159.851562,89.9013672 L159.851562,94.8984375 L158.757812,94.8984375 Z M167.357422,94.8984375 L161.47168,94.8984375 L161.47168,93.8320312 L163.782227,91.5351562 C164.160484,91.1614565 164.468098,90.837892 164.705078,90.5644531 C164.942058,90.2910143 165.126627,90.041505 165.258789,89.815918 C165.390951,89.5903309 165.479817,89.3772796 165.525391,89.1767578 C165.570964,88.976236 165.59375,88.7597668 165.59375,88.5273438 C165.59375,88.3085927 165.564128,88.1000986 165.504883,87.9018555 C165.445638,87.7036123 165.354493,87.5292976 165.231445,87.3789062 C165.108398,87.2285149 164.948894,87.1100265 164.75293,87.0234375 C164.556965,86.9368485 164.322267,86.8935547 164.048828,86.8935547 C163.670571,86.8935547 163.326499,86.9778637 163.016602,87.1464844 C162.706704,87.315105 162.421876,87.5338528 162.162109,87.8027344 L161.505859,87.0166016 C161.843101,86.661131 162.231606,86.3763032 162.671387,86.1621094 C163.111168,85.9479156 163.622718,85.8408203 164.206055,85.8408203 C164.602541,85.8408203 164.963703,85.9000645 165.289551,86.0185547 C165.615399,86.1370449 165.896809,86.3079416 166.133789,86.53125 C166.370769,86.7545584 166.554199,87.0279932 166.684082,87.3515625 C166.813965,87.6751318 166.878906,88.0397115 166.878906,88.4453125 C166.878906,88.7871111 166.833334,89.1038397 166.742188,89.3955078 C166.651041,89.6871759 166.513185,89.9777004 166.328613,90.2670898 C166.144042,90.5564793 165.911622,90.8561182 165.631348,91.1660156 C165.351073,91.475913 165.019533,91.8154278 164.636719,92.1845703 L163.016602,93.7636719 L167.357422,93.7636719 L167.357422,94.8984375 Z" id="item2" fill="#000000"></path>
+                <path d="M173.50293,97.7011719 L170.132812,97.7011719 L170.132812,96.7441406 L172.354492,96.7441406 L172.354492,85.9570312 L170.132812,85.9570312 L170.132812,85 L173.50293,85 L173.50293,97.7011719 Z M177.488281,96.2998047 C177.720704,96.3089193 177.946288,96.2884117 178.165039,96.2382812 C178.38379,96.1881508 178.576334,96.1140955 178.742676,96.0161133 C178.909018,95.918131 179.042317,95.7962247 179.142578,95.6503906 C179.242839,95.5045566 179.292969,95.3382171 179.292969,95.1513672 C179.292969,94.95996 179.259929,94.8050136 179.193848,94.6865234 C179.127767,94.5680333 179.053711,94.4586594 178.97168,94.3583984 C178.889648,94.2581375 178.815593,94.1510422 178.749512,94.0371094 C178.683431,93.9231765 178.650391,93.7705088 178.650391,93.5791016 C178.650391,93.483398 178.66862,93.3831385 178.705078,93.2783203 C178.741537,93.1735021 178.797363,93.0777999 178.872559,92.9912109 C178.947754,92.904622 179.043456,92.8339846 179.159668,92.7792969 C179.275879,92.7246091 179.413736,92.6972656 179.573242,92.6972656 C179.732748,92.6972656 179.886555,92.7303057 180.034668,92.7963867 C180.182781,92.8624678 180.312662,92.9638665 180.424316,93.1005859 C180.535971,93.2373054 180.624837,93.4082021 180.690918,93.6132812 C180.756999,93.8183604 180.790039,94.0598944 180.790039,94.3378906 C180.790039,94.7161477 180.720541,95.0795881 180.581543,95.4282227 C180.442545,95.7768572 180.23519,96.0856106 179.959473,96.3544922 C179.683755,96.6233737 179.339683,96.8375643 178.927246,96.9970703 C178.514809,97.1565763 178.035159,97.2363281 177.488281,97.2363281 L177.488281,96.2998047 Z" id="]," fill="#878787"></path>
+                <path d="M20.8427734,111.802734 C20.5738919,111.871094 20.2958999,111.920084 20.0087891,111.949707 C19.7216783,111.97933 19.4300145,111.994141 19.1337891,111.994141 C18.2724566,111.994141 17.6298849,111.799318 17.2060547,111.409668 C16.7822244,111.020018 16.5703125,110.421879 16.5703125,109.615234 L16.5703125,106.033203 L14.6494141,106.033203 L14.6494141,105.035156 L16.5703125,105.035156 L16.5703125,103.148438 L17.7597656,102.84082 L17.7597656,105.035156 L20.8427734,105.035156 L20.8427734,106.033203 L17.7597656,106.033203 L17.7597656,109.519531 C17.7597656,110.011721 17.8907865,110.379719 18.152832,110.623535 C18.4148776,110.867351 18.8011042,110.989258 19.3115234,110.989258 C19.5302745,110.989258 19.76953,110.972168 20.0292969,110.937988 C20.2890638,110.903808 20.5602199,110.850261 20.8427734,110.777344 L20.8427734,111.802734 Z M25.3476562,106.019531 L23.3173828,106.019531 L23.3173828,105.035156 L26.5507812,105.035156 L26.5507812,110.907227 L28.5947266,110.907227 L28.5947266,111.898438 L23.0917969,111.898438 L23.0917969,110.907227 L25.3476562,110.907227 L25.3476562,106.019531 Z M25.7646484,102.157227 C25.8968106,102.157227 26.0198562,102.181152 26.1337891,102.229004 C26.2477219,102.276856 26.346842,102.344075 26.4311523,102.430664 C26.5154627,102.517253 26.5815427,102.616373 26.6293945,102.728027 C26.6772463,102.839682 26.7011719,102.961588 26.7011719,103.09375 C26.7011719,103.221355 26.6772463,103.342122 26.6293945,103.456055 C26.5815427,103.569988 26.5154627,103.670247 26.4311523,103.756836 C26.346842,103.843425 26.2477219,103.910644 26.1337891,103.958496 C26.0198562,104.006348 25.8968106,104.030273 25.7646484,104.030273 C25.6324863,104.030273 25.5094407,104.006348 25.3955078,103.958496 C25.281575,103.910644 25.1824548,103.843425 25.0981445,103.756836 C25.0138342,103.670247 24.9477541,103.569988 24.8999023,103.456055 C24.8520505,103.342122 24.828125,103.221355 24.828125,103.09375 C24.828125,102.961588 24.8520505,102.839682 24.8999023,102.728027 C24.9477541,102.616373 25.0138342,102.517253 25.0981445,102.430664 C25.1824548,102.344075 25.281575,102.276856 25.3955078,102.229004 C25.5094407,102.181152 25.6324863,102.157227 25.7646484,102.157227 Z M36.2373047,111.802734 C35.9684231,111.871094 35.6904311,111.920084 35.4033203,111.949707 C35.1162095,111.97933 34.8245458,111.994141 34.5283203,111.994141 C33.6669879,111.994141 33.0244162,111.799318 32.6005859,111.409668 C32.1767557,111.020018 31.9648438,110.421879 31.9648438,109.615234 L31.9648438,106.033203 L30.0439453,106.033203 L30.0439453,105.035156 L31.9648438,105.035156 L31.9648438,103.148438 L33.1542969,102.84082 L33.1542969,105.035156 L36.2373047,105.035156 L36.2373047,106.033203 L33.1542969,106.033203 L33.1542969,109.519531 C33.1542969,110.011721 33.2853177,110.379719 33.5473633,110.623535 C33.8094089,110.867351 34.1956355,110.989258 34.7060547,110.989258 C34.9248058,110.989258 35.1640612,110.972168 35.4238281,110.937988 C35.683595,110.903808 35.9547512,110.850261 36.2373047,110.777344 L36.2373047,111.802734 Z M40.7421875,103.216797 L38.7119141,103.216797 L38.7119141,102.239258 L41.9453125,102.239258 L41.9453125,110.907227 L43.9892578,110.907227 L43.9892578,111.898438 L38.4863281,111.898438 L38.4863281,110.907227 L40.7421875,110.907227 L40.7421875,103.216797 Z M51.8984375,108.104492 C51.8984375,108.273113 51.8961589,108.414387 51.8916016,108.52832 C51.8870442,108.642253 51.8802084,108.749348 51.8710938,108.849609 L47.0517578,108.849609 C47.0517578,109.551436 47.2477194,110.09033 47.6396484,110.466309 C48.0315775,110.842287 48.596676,111.030273 49.3349609,111.030273 C49.5354828,111.030273 49.7360016,111.022298 49.9365234,111.006348 C50.1370453,110.990397 50.3307282,110.96875 50.5175781,110.941406 C50.704428,110.914062 50.8832999,110.883301 51.0541992,110.849121 C51.2250985,110.814941 51.3834628,110.777344 51.5292969,110.736328 L51.5292969,111.713867 C51.2057275,111.805013 50.8400085,111.879069 50.4321289,111.936035 C50.0242493,111.993002 49.6015647,112.021484 49.1640625,112.021484 C48.5761689,112.021484 48.0703146,111.941733 47.6464844,111.782227 C47.2226541,111.622721 46.8751641,111.39144 46.6040039,111.088379 C46.3328437,110.785317 46.1323249,110.413902 46.0024414,109.974121 C45.8725579,109.53434 45.8076172,109.036461 45.8076172,108.480469 C45.8076172,107.997393 45.8771152,107.540529 46.0161133,107.109863 C46.1551114,106.679197 46.3579088,106.300946 46.6245117,105.975098 C46.8911146,105.64925 47.218097,105.390626 47.6054688,105.199219 C47.9928405,105.007812 48.4326147,104.912109 48.9248047,104.912109 C49.4033227,104.912109 49.8271466,104.987304 50.1962891,105.137695 C50.5654315,105.288087 50.8764636,105.501138 51.1293945,105.776855 C51.3823255,106.052573 51.5737298,106.387531 51.7036133,106.781738 C51.8334967,107.175946 51.8984375,107.61686 51.8984375,108.104492 Z M50.6611328,107.933594 C50.6748048,107.628254 50.6451827,107.349122 50.5722656,107.096191 C50.4993486,106.84326 50.3865568,106.625652 50.2338867,106.443359 C50.0812167,106.261067 49.8909517,106.118653 49.6630859,106.016113 C49.4352202,105.913574 49.1708999,105.862305 48.8701172,105.862305 C48.6103503,105.862305 48.3733735,105.912434 48.1591797,106.012695 C47.9449859,106.112956 47.7604174,106.254231 47.6054688,106.436523 C47.4505201,106.618816 47.3251958,106.837564 47.2294922,107.092773 C47.1337886,107.347983 47.0745444,107.628254 47.0517578,107.933594 L50.6611328,107.933594 Z" id="title" fill="#000000"></path>
+                <path d="M67.1904297,107.482422 L61.3115234,107.482422 L61.3115234,106.477539 L67.1904297,106.477539 L67.1904297,107.482422 Z M67.1904297,109.861328 L61.3115234,109.861328 L61.3115234,108.856445 L67.1904297,108.856445 L67.1904297,109.861328 Z" id="=" fill="#946C47"></path>
+                <path d="M79.0712891,102.239258 L78.8798828,105.445312 L77.7587891,105.445312 L77.5605469,102.239258 L79.0712891,102.239258 Z M81.7304688,102.239258 L81.5390625,105.445312 L80.4179688,105.445312 L80.2197266,102.239258 L81.7304688,102.239258 Z M90.8564453,111.898438 L89.6669922,111.898438 L89.4892578,106.327148 L89.4140625,104.1875 L88.9970703,105.431641 L87.6777344,108.986328 L86.8369141,108.986328 L85.5791016,105.568359 L85.1621094,104.1875 L85.1347656,106.422852 L84.9775391,111.898438 L83.8291016,111.898438 L84.2666016,102.963867 L85.7089844,102.963867 L86.9121094,106.327148 L87.3017578,107.461914 L87.6777344,106.327148 L88.9423828,102.963867 L90.4257812,102.963867 L90.8564453,111.898438 Z M98.0820312,108.104492 C98.0820312,108.273113 98.0797526,108.414387 98.0751953,108.52832 C98.070638,108.642253 98.0638021,108.749348 98.0546875,108.849609 L93.2353516,108.849609 C93.2353516,109.551436 93.4313131,110.09033 93.8232422,110.466309 C94.2151712,110.842287 94.7802697,111.030273 95.5185547,111.030273 C95.7190765,111.030273 95.9195954,111.022298 96.1201172,111.006348 C96.320639,110.990397 96.514322,110.96875 96.7011719,110.941406 C96.8880218,110.914062 97.0668937,110.883301 97.237793,110.849121 C97.4086923,110.814941 97.5670566,110.777344 97.7128906,110.736328 L97.7128906,111.713867 C97.3893213,111.805013 97.0236023,111.879069 96.6157227,111.936035 C96.207843,111.993002 95.7851584,112.021484 95.3476562,112.021484 C94.7597627,112.021484 94.2539084,111.941733 93.8300781,111.782227 C93.4062479,111.622721 93.0587579,111.39144 92.7875977,111.088379 C92.5164374,110.785317 92.3159186,110.413902 92.1860352,109.974121 C92.0561517,109.53434 91.9912109,109.036461 91.9912109,108.480469 C91.9912109,107.997393 92.0607089,107.540529 92.199707,107.109863 C92.3387051,106.679197 92.5415026,106.300946 92.8081055,105.975098 C93.0747084,105.64925 93.4016908,105.390626 93.7890625,105.199219 C94.1764342,105.007812 94.6162085,104.912109 95.1083984,104.912109 C95.5869165,104.912109 96.0107403,104.987304 96.3798828,105.137695 C96.7490253,105.288087 97.0600573,105.501138 97.3129883,105.776855 C97.5659192,106.052573 97.7573236,106.387531 97.887207,106.781738 C98.0170905,107.175946 98.0820312,107.61686 98.0820312,108.104492 Z M96.8447266,107.933594 C96.8583985,107.628254 96.8287764,107.349122 96.7558594,107.096191 C96.6829423,106.84326 96.5701505,106.625652 96.4174805,106.443359 C96.2648104,106.261067 96.0745454,106.118653 95.8466797,106.016113 C95.618814,105.913574 95.3544937,105.862305 95.0537109,105.862305 C94.793944,105.862305 94.5569672,105.912434 94.3427734,106.012695 C94.1285797,106.112956 93.9440112,106.254231 93.7890625,106.436523 C93.6341138,106.618816 93.5087895,106.837564 93.4130859,107.092773 C93.3173823,107.347983 93.2581381,107.628254 93.2353516,107.933594 L96.8447266,107.933594 Z M99.9824219,105.035156 L101.041992,105.035156 L101.089844,106.142578 C101.290366,105.905598 101.484049,105.708497 101.670898,105.55127 C101.857748,105.394042 102.041177,105.267579 102.221191,105.171875 C102.401205,105.076171 102.584634,105.008952 102.771484,104.970215 C102.958334,104.931478 103.152017,104.912109 103.352539,104.912109 C104.058923,104.912109 104.59326,105.120603 104.955566,105.537598 C105.317873,105.954592 105.499023,106.582353 105.499023,107.420898 L105.499023,111.898438 L104.30957,111.898438 L104.30957,107.516602 C104.30957,106.978838 104.209311,106.581219 104.008789,106.32373 C103.808267,106.066242 103.509768,105.9375 103.113281,105.9375 C102.967447,105.9375 102.825033,105.959147 102.686035,106.002441 C102.547037,106.045736 102.402345,106.12093 102.251953,106.228027 C102.101562,106.335124 101.93864,106.479817 101.763184,106.662109 C101.587727,106.844402 101.390626,107.072264 101.171875,107.345703 L101.171875,111.898438 L99.9824219,111.898438 L99.9824219,105.035156 Z M113.196289,111.898438 L112.129883,111.898438 L112.088867,110.791016 C111.883788,111.027996 111.688966,111.225097 111.504395,111.382324 C111.319823,111.539552 111.136394,111.666015 110.954102,111.761719 C110.771809,111.857422 110.58838,111.924642 110.403809,111.963379 C110.219237,112.002116 110.024415,112.021484 109.819336,112.021484 C109.112952,112.021484 108.579754,111.81413 108.219727,111.399414 C107.859699,110.984698 107.679688,110.358077 107.679688,109.519531 L107.679688,105.035156 L108.869141,105.035156 L108.869141,109.423828 C108.869141,110.476568 109.265621,111.00293 110.058594,111.00293 C110.204428,111.00293 110.346842,110.981283 110.48584,110.937988 C110.624838,110.894694 110.77067,110.819499 110.92334,110.712402 C111.07601,110.605305 111.240071,110.460613 111.415527,110.27832 C111.590984,110.096028 111.788085,109.865887 112.006836,109.587891 L112.006836,105.035156 L113.196289,105.035156 L113.196289,111.898438 Z M117.557617,102.239258 L117.366211,105.445312 L116.245117,105.445312 L116.046875,102.239258 L117.557617,102.239258 Z M120.216797,102.239258 L120.025391,105.445312 L118.904297,105.445312 L118.706055,102.239258 L120.216797,102.239258 Z" id="&quot;Menu&quot;" fill="#558A03"></path>
+                <path d="M0.389648438,119 L0.895507812,119 C1.7750695,119 2.42903432,119.206215 2.85742188,119.618652 C3.28580943,120.031089 3.5,120.656571 3.5,121.495117 L3.5,123.074219 C3.5,123.297527 3.52506485,123.496907 3.57519531,123.672363 C3.62532577,123.84782 3.71305276,123.99593 3.83837891,124.116699 C3.96370505,124.237468 4.13118385,124.329752 4.34082031,124.393555 C4.55045678,124.457357 4.81249843,124.489258 5.12695312,124.489258 L5.42089844,124.489258 L5.42089844,125.439453 L5.12695312,125.439453 C4.79426917,125.439453 4.52197372,125.466797 4.31005859,125.521484 C4.09814347,125.576172 3.9329433,125.659342 3.81445313,125.770996 C3.69596295,125.88265 3.61393252,126.025064 3.56835937,126.198242 C3.52278623,126.37142 3.5,126.576496 3.5,126.813477 L3.5,129.206055 C3.5,129.588869 3.45442754,129.93408 3.36328125,130.241699 C3.27213496,130.549318 3.12402446,130.81136 2.91894531,131.027832 C2.71386616,131.244304 2.44498864,131.410644 2.11230469,131.526855 C1.77962073,131.643067 1.37402583,131.701172 0.895507812,131.701172 L0.389648438,131.701172 L0.389648438,130.744141 L0.799804688,130.744141 C1.85254433,130.744141 2.37890625,130.23145 2.37890625,129.206055 L2.37890625,126.84082 C2.37890625,125.728836 2.85969571,125.104493 3.82128906,124.967773 C2.85058108,124.862955 2.36523438,124.236334 2.36523438,123.087891 L2.36523438,121.522461 C2.36523438,120.478836 1.8434297,119.957031 0.799804688,119.957031 L0.389648438,119.957031 L0.389648438,119 Z" id="}" fill="#878787"></path>
+            </g>
+            <path id="Line-Copy" d="M253.5,52.5 L213.5,52.5 L213.5,50.5 L253.5,50.5 L253.5,44.5 L267.5,51.5 L253.5,58.5 L253.5,52.5 Z" fill="#EE6B47"></path>
+            <path id="Line-Copy-2" d="M253.5,67.5 L213.5,67.5 L213.5,65.5 L253.5,65.5 L253.5,59.5 L267.5,66.5 L253.5,73.5 L253.5,67.5 Z" fill="#EE6B47"></path>
+            <path id="Line-Copy-3" d="M253.5,102.5 L213.5,102.5 L213.5,100.5 L253.5,100.5 L253.5,94.5 L267.5,101.5 L253.5,108.5 L253.5,102.5 Z" fill="#EE6B47"></path>
+        </g>
+    </g>
+</svg>
\ No newline at end of file
diff --git a/1-js/05-data-types/11-json/json-meetup.svg b/1-js/05-data-types/11-json/json-meetup.svg
new file mode 100644
index 000000000..5e1929343
--- /dev/null
+++ b/1-js/05-data-types/11-json/json-meetup.svg
@@ -0,0 +1,35 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg width="188px" height="192px" viewBox="0 0 188 192" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
+    <!-- Generator: sketchtool 55.2 (78181) - https://sketchapp.com -->
+    <title>json-meetup.svg</title>
+    <desc>Created with sketchtool.</desc>
+    <g id="combined" stroke="none" stroke-width="1" fill="none" fill-rule="evenodd">
+        <g id="json-meetup.svg">
+            <rect id="Rectangle-2" stroke="#BCA68E" stroke-width="2" fill="#FFF9EB" x="59" y="1" width="89" height="26"></rect>
+            <text id="number:-23" font-family="Consolas" font-size="12" font-weight="normal" fill="#8A704D">
+                <tspan x="72" y="17">number: 23</tspan>
+            </text>
+            <rect id="Rectangle-3" stroke="#BCA68E" stroke-width="2" fill="#FFF9EB" x="25" y="80" width="152" height="26"></rect>
+            <text id="title:-&quot;Conference&quot;" font-family="Consolas" font-size="12" font-weight="normal" fill="#8A704D">
+                <tspan x="38" y="96">title: "Conference"</tspan>
+            </text>
+            <rect id="Rectangle-3-Copy" stroke="#BCA68E" stroke-width="2" fill="#FFF9EB" x="57" y="157" width="89" height="26"></rect>
+            <text id="..." font-family="Consolas" font-size="12" font-weight="normal" fill="#8A704D">
+                <tspan x="91" y="173">...</tspan>
+            </text>
+            <text id="place" font-family="Consolas" font-size="14" font-weight="normal" fill="#8A704D">
+                <tspan x="127" y="56">place</tspan>
+            </text>
+            <path id="Line" d="M93.5,52.5 L93.5,34.5 L95.5,34.5 L95.5,52.5 L101.5,52.5 L94.5,66.5 L87.5,52.5 L93.5,52.5 Z" fill="#EE6B47" fill-rule="nonzero"></path>
+            <path id="Line-Copy" d="M108.5,49.5 L108.5,67.5 L106.5,67.5 L106.5,49.5 L100.5,49.5 L107.5,35.5 L114.5,49.5 L108.5,49.5 Z" fill="#EE6B47" fill-rule="nonzero"></path>
+            <text id="occupiedBy" font-family="Consolas" font-size="14" font-weight="normal" fill="#8A704D">
+                <tspan x="5" y="56">occupiedBy</tspan>
+            </text>
+            <path id="Line-Copy-2" d="M100.5,131.5 L100.5,113.5 L102.5,113.5 L102.5,131.5 L108.5,131.5 L101.5,145.5 L94.5,131.5 L100.5,131.5 Z" fill="#EE6B47" fill-rule="nonzero"></path>
+            <text id="participants" font-family="Consolas" font-size="14" font-weight="normal" fill="#8A704D">
+                <tspan x="0" y="135">participants</tspan>
+            </text>
+            <ellipse id="Oval-32" stroke="#F5A623" cx="101" cy="52.5" rx="37" ry="33.5"></ellipse>
+        </g>
+    </g>
+</svg>
\ No newline at end of file
diff --git a/1-js/06-advanced-functions/02-rest-parameters-spread/article.md b/1-js/06-advanced-functions/02-rest-parameters-spread/article.md
index dbdfbd6c0..d25ea327e 100644
--- a/1-js/06-advanced-functions/02-rest-parameters-spread/article.md
+++ b/1-js/06-advanced-functions/02-rest-parameters-spread/article.md
@@ -1,20 +1,20 @@
-# Rest parameters and spread syntax
+# ทำความรู้จัก Rest parameters และ spread syntax 
 
-Many JavaScript built-in functions support an arbitrary number of arguments.
+ในภาษา JavaScript จะมี built-in ฟังก์ชั่นที่ช่วยทำงานให้เราต่าง ๆ มากมาย
 
-For instance:
+ยกตัวอย่าง:
 
-- `Math.max(arg1, arg2, ..., argN)` -- returns the greatest of the arguments.
-- `Object.assign(dest, src1, ..., srcN)` -- copies properties from `src1..N` into `dest`.
-- ...and so on.
+- `Math.max(arg1, arg2, ..., argN)` -- หาจำนวนที่มีค่ามากที่สุดในกลุ่ม.
+- `Object.assign(dest, src1, ..., srcN)` -- ก๊อบปี้ค่าของ `src1..N` ไปที่ `dest`.
+- และอื่น ๆ อีกมากมาย
 
-In this chapter we'll learn how to do the same. And also, how to pass arrays to such functions as parameters.
+ในบทนี้ เราจะมาเรียนรู้ built-in ฟังก์ชั่นอีกรูปแบบนึง ได้แก่ Rest parameters และ spread syntax
 
 ## Rest parameters `...`
 
-A function can be called with any number of arguments, no matter how it is defined.
+ฟังก์ชั่นที่สามารถรับ arguments กี่ตัวก็ได้ ไม่ว่าจะตั้งค่าแบบไหน
 
-Like here:
+ตัวอย่าง:
 ```js run
 function sum(a, b) {
   return a + b;
@@ -23,14 +23,18 @@ function sum(a, b) {
 alert( sum(1, 2, 3, 4, 5) );
 ```
 
+<<<<<<< HEAD
+ในโค้ดตัวอย่างนี้ จะไม่เกิด error จากการที่มีตัวแปรที่มากไป แต่ ฟังก์ชั่น sum จะถูกคำนวนจาก arguments แค่ 2 ตัวแรกเท่านั้น
+=======
 There will be no error because of "excessive" arguments. But of course in the result only the first two will be counted, so the result in the code above is `3`.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-The rest of the parameters can be included in the function definition by using three dots `...` followed by the name of the array that will contain them. The dots literally mean "gather the remaining parameters into an array".
+parameters ที่เหลือสามารถเขียนเพิ่มในฟังก์ชั่นได้ผ่านการใช้จุดสามจุด `...` แล้วตามด้วยชื่อของ array นั้น โดยจุดหมายถึง การรวม parameters ที่เหลือใน array ด้วย
 
-For instance, to gather all arguments into array `args`:
+ยกตัวอย่าง การรวม arguments ทั้งหมดใน array `args`:
 
 ```js run
-function sumAll(...args) { // args is the name for the array
+function sumAll(...args) { // args คือชื่อของ array
   let sum = 0;
 
   for (let arg of args) sum += arg;
@@ -43,16 +47,16 @@ alert( sumAll(1, 2) ); // 3
 alert( sumAll(1, 2, 3) ); // 6
 ```
 
-We can choose to get the first parameters as variables, and gather only the rest.
+เราสามารถใช้ parameters ตัวแรก ๆ เป็นตัวแปร และรวม parameter ที่เหลือใน Rest parameters ได้
 
-Here the first two arguments go into variables and the rest go into `titles` array:
+ตัวอย่างการให้ 2 parameter แรกเป็นตัวแปร และรวม parameter ที่เหลือใน array ที่ชื่อว่า `titles`
 
 ```js run
 function showName(firstName, lastName, ...titles) {
   alert( firstName + ' ' + lastName ); // Julius Caesar
 
-  // the rest go into titles array
-  // i.e. titles = ["Consul", "Imperator"]
+  // parameter ที่เหลือจะถูกรวมใน titles array
+  // ตัวอย่าง titles = ["Consul", "Imperator"]
   alert( titles[0] ); // Consul
   alert( titles[1] ); // Imperator
   alert( titles.length ); // 2
@@ -61,23 +65,23 @@ function showName(firstName, lastName, ...titles) {
 showName("Julius", "Caesar", "Consul", "Imperator");
 ```
 
-````warn header="The rest parameters must be at the end"
-The rest parameters gather all remaining arguments, so the following does not make sense and causes an error:
+````warn header="The rest parameters ต้องอยู่ท้ายสุด"
+เพราะ Rest parameters จะรวม arguments ที่เหลืออยู่ทั้งหมด ดังนั้นการเขียนแบบในตัวอย่างด้านล่างจะไม่สมเหตุสมผลและ ก่อให้เกิด error:
 
 ```js
-function f(arg1, ...rest, arg2) { // arg2 after ...rest ?!
+function f(arg1, ...rest, arg2) { // arg2 หลังจาก ...rest ?!
   // error
 }
 ```
 
-The `...rest` must always be last.
+ฉะนั้น `...rest` ต้องอยู่ท้ายสุด
 ````
 
-## The "arguments" variable
+## ตัวแปร "arguments"
 
-There is also a special array-like object named `arguments` that contains all arguments by their index.
+มี object นึงที่ทำหน้าที่เหมือน array เรียกว่า `arguments` ที่ภายในจะมี argument เรียงตาม index
 
-For instance:
+ยกตัวอย่าง
 
 ```js run
 function showName() {
@@ -85,29 +89,29 @@ function showName() {
   alert( arguments[0] );
   alert( arguments[1] );
 
-  // it's iterable
+  // เราสามารถวนซ้ำกับมันได้
   // for(let arg of arguments) alert(arg);
 }
 
-// shows: 2, Julius, Caesar
+// แสดงผลเป็น: 2, Julius, Caesar
 showName("Julius", "Caesar");
 
-// shows: 1, Ilya, undefined (no second argument)
+// แสดงผลเป็น: 1, Ilya, undefined (no second argument)
 showName("Ilya");
 ```
 
-In old times, rest parameters did not exist in the language, and using `arguments` was the only way to get all arguments of the function. And it still works, we can find it in the old code.
+ในสมัยก่อนที่จะมี rest parameters การใช้ `arguments` เป็นวิธีที่จะรวมทุก ๆ arguments ของฟังก์ชั่นนั้น ๆ ซึ่งคุณอาจจะเห็นได้จากในโค้ดเก่า ๆ
 
-But the downside is that although `arguments` is both array-like and iterable, it's not an array. It does not support array methods, so we can't call `arguments.map(...)` for example.
+แต่ข้อเสียของ `arguments` คือมันมีความเป็น array และยังสามารถวนซ้ำกับมันเพื่ออ่านค่า argument แต่ละตัวได้ แต่มันก็ไม่ใช่ array เพราะมันไม่สามารถเรียกใช้ array methods ได้ เช่นเราไม่สามารถใช้ `arguments.map(...)` ได้
 
-Also, it always contains all arguments. We can't capture them partially, like we did with rest parameters.
+แม้มันจะมีทุก ๆ arguments แต่เราไม่สามารถเรียกใช้บางส่วนแบบที่ rest parameters ทำได้
 
-So when we need these features, then rest parameters are preferred.
+ดังนั้นเมื่อเราจะใช้ฟีเจอร์นี้ rest parameters จึงเหมาะสมกว่า
 
-````smart header="Arrow functions do not have `\"arguments\"`"
-If we access the `arguments` object from an arrow function, it takes them from the outer "normal" function.
+````smart header="Arrow functions จะไม่มี `\"arguments\"`"
+ถ้าเราจะเรียกใช้ object `arguments` จาก arrow function มันจะได้ผลลัพธ์เหมือนฟังก์ชั่นปกติทั่วไป
 
-Here's an example:
+ตัวอย่าง:
 
 ```js run
 function f() {
@@ -118,25 +122,25 @@ function f() {
 f(1); // 1
 ```
 
-As we remember, arrow functions don't have their own `this`. Now we know they don't have the special `arguments` object either.
+ถ้าเราจำได้ arrow functions จะไม่มี `this` เป็นของตัวเอง และตอนนี้เราก็รู้แล้วว่า arrow functions ก็ไม่มี object `arguments` เหมือนกัน
 ````
 
 
 ## Spread syntax [#spread-syntax]
 
-We've just seen how to get an array from the list of parameters.
+จากที่เราได้เห็นการดึง array จากกลุ่มของ parameters แล้ว
 
-But sometimes we need to do exactly the reverse.
+แต่ในบางครั้งเราต้องการทำสิ่งตรงกันข้าม
 
-For instance, there's a built-in function [Math.max](mdn:js/Math/max) that returns the greatest number from a list:
+อย่างเช่น built-in ฟังก์ชั่น [Math.max](mdn:js/Math/max) ที่จะหาจำนวนที่มีค่ามากที่สุดในกลุ่ม:
 
 ```js run
 alert( Math.max(3, 5, 1) ); // 5
 ```
 
-Now let's say we have an array `[3, 5, 1]`. How do we call `Math.max` with it?
+เรามี array ที่มีค่าดังนี้ `[3, 5, 1]`. เราจะเรียกใช้ `Math.max` กับมันได้อย่างไร ?
 
-Passing it "as is" won't work, because `Math.max` expects a list of numeric arguments, not a single array:
+การเรียกใช้แบบ "as is" คงจะไม่เวิร์ค เพราะ `Math.max` จะรับค่าเฉพาะ arguments ที่เป็นตัวเลข ไม่ใช่ array:
 
 ```js run
 let arr = [3, 5, 1];
@@ -146,21 +150,21 @@ alert( Math.max(arr) ); // NaN
 */!*
 ```
 
-And surely we can't manually list items in the code `Math.max(arr[0], arr[1], arr[2])`, because we may be unsure how many there are. As our script executes, there could be a lot, or there could be none. And that would get ugly.
+และเราก็ไม่สามารถเรียกใช้ตัวแปรแต่ละตัวจาก array แบบนี้ได้ในโค้ด `Math.max(arr[0], arr[1], arr[2])`, เพราะเราไม่มีทางรู้ได้เลยว่าใน array จะมีตัวแปรกี่ตัว ในการทำงานจริงคงจะไม่ได้มีแค่ตัวสองตัว หรือบางทีอาจจะไม่มีเลย นั่นแหละคือปัญหา
 
-*Spread syntax* to the rescue! It looks similar to rest parameters, also using `...`, but does quite the opposite.
+*Spread syntax* จะเข้ามาช่วยเหลือ โดยหน้าตามันจะเหมือนกับ rest parameters แถมยังใช้ `...` เหมือนกันอีก แต่การทำงานค่อนข้างแตกต่างกัน
 
-When `...arr` is used in the function call, it "expands" an iterable object `arr` into the list of arguments.
+เมื่อ `...arr` ถูกใช้ในการเรียกฟังก์ชั่นมันจะกระจาย object `arr` ออกมาเป็นกลุ่มของ arguments.
 
-For `Math.max`:
+ตัวอย่างเช่น `Math.max`:
 
 ```js run
 let arr = [3, 5, 1];
 
-alert( Math.max(...arr) ); // 5 (spread turns array into a list of arguments)
+alert( Math.max(...arr) ); // 5 (กระจาย array ออกเป็นกลุ่มของ arguments)
 ```
 
-We also can pass multiple iterables this way:
+นอกจากนี้เรายังสามารถใช้ Spread syntax ได้มากกว่าหนึ่งตัว:
 
 ```js run
 let arr1 = [1, -2, 3, 4];
@@ -169,7 +173,7 @@ let arr2 = [8, 3, -8, 1];
 alert( Math.max(...arr1, ...arr2) ); // 8
 ```
 
-We can even combine the spread syntax with normal values:
+หรือเราจะผสม Spread syntax กับตัวแปรธรรมดาก็ย่อมได้:
 
 
 ```js run
@@ -179,7 +183,7 @@ let arr2 = [8, 3, -8, 1];
 alert( Math.max(1, ...arr1, 2, ...arr2, 25) ); // 25
 ```
 
-Also, the spread syntax can be used to merge arrays:
+และ Spread syntax ยังสามารถใช้เพื่อรวม array 2 อันเข้าด้วยกัน:
 
 ```js run
 let arr = [3, 5, 1];
@@ -189,12 +193,12 @@ let arr2 = [8, 9, 15];
 let merged = [0, ...arr, 2, ...arr2];
 */!*
 
-alert(merged); // 0,3,5,1,2,8,9,15 (0, then arr, then 2, then arr2)
+alert(merged); // 0,3,5,1,2,8,9,15 (0, ต่อด้วย arr, ต่อด้วย 2, ต่อด้วย arr2)
 ```
 
-In the examples above we used an array to demonstrate the spread syntax, but any iterable will do.
+ในตัวอย่างข้างต้น เราใช้ array เพื่อสาธิตการใช้ spread syntax แต่อะไรก็ตามที่เราสามารถวนซ้ำกับมันได้ก็สามารถทำแบบนี้ได้เช่นกัน
 
-For instance, here we use the spread syntax to turn the string into array of characters:
+ยกตัวอย่าง เราสามารถใช้ spread syntax เพื่อที่จะแปลง string เป็น array of characters:
 
 ```js run
 let str = "Hello";
@@ -202,94 +206,94 @@ let str = "Hello";
 alert( [...str] ); // H,e,l,l,o
 ```
 
-The spread syntax internally uses iterators to gather elements, the same way as `for..of` does.
+หลักการทำงานของ Spread syntax คือการใช้การวนซ้ำรวม elements แบบที่ `for..of` ทำ
 
-So, for a string, `for..of` returns characters and `...str` becomes `"H","e","l","l","o"`. The list of characters is passed to array initializer `[...str]`.
+ดังนั้นสำหรับ string, `for..of` จะคืนค่ามาเป็น characters และ `...str` จะคืนค่ามาเป็น `"H","e","l","l","o"`. ในรูปแบบของ array of string `[...str]`.
 
-For this particular task we could also use `Array.from`, because it converts an iterable (like a string) into an array:
+สำหรับงานบางประเภท เราสามารถใช้ `Array.from`, เพราะมันสามารถแปลงข้อมูลใด ๆ ที่เราสามารถวนซ้ำกับมันได้ (เช่น string) ให้เป็น array ได้:
 
 ```js run
 let str = "Hello";
 
-// Array.from converts an iterable into an array
+// Array.from แปลงข้อมูลใด ๆ ที่เราสามารถวนซ้ำกับมันได้ให้เป็น array
 alert( Array.from(str) ); // H,e,l,l,o
 ```
 
-The result is the same as `[...str]`.
+ผลลัพธ์ที่ได้จะเหมือนกับ `[...str]`.
 
-But there's a subtle difference between `Array.from(obj)` and `[...obj]`:
+แต่ทั้งนี้ทั้ง ก็ยังมีความแตกต่างระหว่าง `Array.from(obj)` และ `[...obj]`:
 
-- `Array.from` operates on both array-likes and iterables.
-- The spread syntax works only with iterables.
+- `Array.from` สามารถทำงานกับข้อมูลที่เป็น array-likes และข้อมูลที่เราสามารถวนซ้ำกับมันได้
+- Spread syntax ทำงานได้กับแค่ข้อมูลที่เราสามารถวนซ้ำกับมันได้
 
-So, for the task of turning something into an array, `Array.from` tends to be more universal.
+ดังนั้น สำหรับการเปลี่ยนบางสิ่งให้กลายเป็น array, `Array.from` ดูจะเหมาะสมมากกว่า
 
 
-## Copy an array/object
+## การก๊อบปี้ array/object
 
-Remember when we talked about `Object.assign()` [in the past](info:object-copy#cloning-and-merging-object-assign)?
+จำได้มั้ยว่าเราเคยพูดถึง `Object.assign()` [in the past](info:object-copy#cloning-and-merging-object-assign)?
 
-It is possible to do the same thing with the spread syntax.
+เราสามารถทำแบบ `Object.assign()` ได้ ผ่านการใช้ spread syntax.
 
 ```js run
 let arr = [1, 2, 3];
 
 *!*
-let arrCopy = [...arr]; // spread the array into a list of parameters
-                        // then put the result into a new array
+let arrCopy = [...arr]; // กระจาย array ออกมาเป็นกลุ่มของ parameters
+                        // จากนั้นนำผลลัพธ์ไปสร้าง array ตัวใหม่
 */!*
 
-// do the arrays have the same contents?
+// แล้ว array ตัวใหม่ กับ array ตัวเดิมมีค่าเหมือนกันมั้ย ?
 alert(JSON.stringify(arr) === JSON.stringify(arrCopy)); // true
 
-// are the arrays equal?
-alert(arr === arrCopy); // false (not same reference)
+// แล้ว array 2 ตัวนั้นถูกอ้างอิงจากที่เดียวกันหรือป่าว ?
+alert(arr === arrCopy); // false (ไม่ได้ถูกอ้างอิงจากที่เดียวกัน)
 
-// modifying our initial array does not modify the copy:
+// การเปลี่ยน array ต้นแบบ จะไม่เปลี่ยนค่า array ตัวใหม่:
 arr.push(4);
 alert(arr); // 1, 2, 3, 4
 alert(arrCopy); // 1, 2, 3
 ```
 
-Note that it is possible to do the same thing to make a copy of an object:
+จำไว้ว่า มันเป็นไปได้ที่จะทำเหมือนกัน ตอนที่เราจะก๊อปปี้ object:
 
 ```js run
 let obj = { a: 1, b: 2, c: 3 };
 
 *!*
-let objCopy = { ...obj }; // spread the object into a list of parameters
-                          // then return the result in a new object
+let objCopy = { ...obj }; // กระจาย object ออกมาเป็นกลุ่มของ parameters
+                          // จากนั้นนำผลลัพธ์ไปสร้าง object ตัวใหม่
 */!*
 
-// do the objects have the same contents?
+// แล้ว object ตัวใหม่ กับ object ตัวเดิมมีค่าเหมือนกันมั้ย ?
 alert(JSON.stringify(obj) === JSON.stringify(objCopy)); // true
 
-// are the objects equal?
-alert(obj === objCopy); // false (not same reference)
+// แล้ว object 2 ตัวนั้นถูกอ้างอิงจากที่เดียวกันหรือป่าว ?
+alert(obj === objCopy); // false (ไม่ได้ถูกอ้างอิงจากที่เดียวกัน)
 
-// modifying our initial object does not modify the copy:
+// การเปลี่ยน object ต้นแบบ จะไม่เปลี่ยนค่า object ตัวใหม่:
 obj.d = 4;
 alert(JSON.stringify(obj)); // {"a":1,"b":2,"c":3,"d":4}
 alert(JSON.stringify(objCopy)); // {"a":1,"b":2,"c":3}
 ```
 
-This way of copying an object is much shorter than `let objCopy = Object.assign({}, obj)` or for an array `let arrCopy = Object.assign([], arr)` so we prefer to use it whenever we can.
+ด้วยวิธีการนี้จะทำให้การเขียนก๊อปปี้ object เขียนได้สั้นกว่า `let objCopy = Object.assign({}, obj)` หรือสำหรับ array คือ `let arrCopy = Object.assign([], arr)` ดังนั้นเราจึงใช้พยายามใช้มันบ่อย ๆ เท่าที่จะทำได้
 
 
-## Summary
+## สรุป
 
-When we see `"..."` in the code, it is either rest parameters or the spread syntax.
+เมื่อเราเห็น `"..."` ในโค้ด, มันอาจจะเป็น rest parameters หรือ spread syntax ก็ได้
 
-There's an easy way to distinguish between them:
+แต่มันก็มีวิธีง่าย ๆ ในการแยกแยะความแตกต่างระหว่างสองสิ่งนี้
 
-- When `...` is at the end of function parameters, it's "rest parameters" and gathers the rest of the list of arguments into an array.
-- When `...` occurs in a function call or alike, it's called a "spread syntax" and expands an array into a list.
+- เมื่อ `...` ปรากฏอยู่ที่ด้านท้ายของ parameters ในฟังก์ชั่น, มันคือ "rest parameters" ซึ่งจะรวม argument ที่เหลือใน array
+- เมื่อ `...` ปรากฏอยู่ ตอนที่เรียกใช้ฟังก์ชั่น, มันคือ "spread syntax" ซึ่งจะกระจาย array ออกมาเป็นกลุ่มของ parameter
 
-Use patterns:
+Patterns การใช้งาน:
 
-- Rest parameters are used to create functions that accept any number of arguments.
-- The spread syntax is used to pass an array to functions that normally require a list of many arguments.
+- Rest parameters มักใช้กับฟังก์ชั่นที่สามารถรับ arguments กี่ตัวก็ได้
+- Spread syntax จะใช้กับการเรียกใช้ array ในฟังก์ชั่น ที่ในฟังก์ชั่นนั้นอาจจะมีหลาย arguments
 
-Together they help to travel between a list and an array of parameters with ease.
+ทั้งสองอย่างนี้ช่วยให้เราทำงานกับ array ของ parameters ได้ง่ายยิ่งขึ้น
 
-All arguments of a function call are also available in "old-style" `arguments`: array-like iterable object.
+ตัว arguments ในฟังก์ชั่นยังคงสามารถเรียกใช้ผ่าน "old-style" `arguments`: array-like iterable object ได้เหมือนเดิม
diff --git a/1-js/index.md b/1-js/index.md
index c313cb85c..50dc5a5a3 100644
--- a/1-js/index.md
+++ b/1-js/index.md
@@ -1,6 +1,3 @@
-# The JavaScript language
-
-Here we learn JavaScript, starting from scratch and go on to advanced concepts like OOP.
-
-We concentrate on the language itself here, with the minimum of environment-specific notes.
+# ภาษาจาวาสคริป
 
+บทเรียนนี้เรียนเกี่ยวกับจาวาคริป โดยเริ่มจากศูนย์ จนถึงคอนเช็ปต์ยากๆอย่าง OOP
diff --git a/README.md b/README.md
index 371793d6d..1e59d7f2f 100755
--- a/README.md
+++ b/README.md
@@ -1,39 +1,174 @@
-# The Modern JavaScript Tutorial
+# โมเดิร์นจาวาสคริปฉบับภาษาไทย
 
+<<<<<<< HEAD
+ยินดีต้อนรับสู่คู่มือภาษาโปรแกรม JavaScript สำหรับผู้เริ่มต้นชาวไทย! ในคู่มือนี้ เราจะแนะนำแนวคิดพื้นฐานของ JavaScript และการประยุกต์ใช้ในการพัฒนาเว็บไซต์
+=======
 This repository hosts the English content of the Modern JavaScript Tutorial, published at [https://javascript.info](https://javascript.info).
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
 
-## Translations
+JavaScript เป็นภาษาโปรแกรมที่ใช้กันอย่างแพร่หลายในการสร้างเว็บไซต์แบบไดนามิกและอินเทอร์แอคทีฟ มันทำงานร่วมกับ HTML และ CSS เพื่อเพิ่มความสามารถและปรับแต่งหน้าเว็บให้ตอบสนองต่อการกระทำของผู้ใช้ ด้วย JavaScript คุณสามารถสร้างเว็บไซต์ที่มีคุณสมบัติน่าสนใจ เช่น แบบฟอร์มที่ตรวจสอบข้อมูลอัตโนมัติ เมนูที่เลื่อนลงเมื่อคลิก หรือการโหลดเนื้อหาใหม่โดยไม่ต้องรีเฟรชหน้า
 
-We'd like to make the tutorial available in many languages. Please help us to translate.
+นอกจากการใช้งานในเว็บเบราว์เซอร์แล้ว JavaScript ยังสามารถใช้ในการพัฒนาแอปพลิเคชันฝั่งเซิร์ฟเวอร์ด้วยแพลตฟอร์มอย่าง Node.js ทำให้สามารถสร้างแอปพลิเคชันเว็บแบบครบวงจรด้วยภาษาเดียว
 
-See <https://javascript.info/translate> for the details.
+ตัวอย่างการใช้งาน JavaScript ในชีวิตประจำวันของคนไทย เช่น:
+- ระบบซื้อขายออนไลน์ เช่น Lazada หรือ Shopee ที่ใช้ JavaScript ในการจัดการตะกร้าสินค้า คำนวณราคา และตรวจสอบข้อมูลที่กรอกในแบบฟอร์ม
+- เว็บไซต์ข่าวหรือบันเทิง เช่น Sanook หรือ Kapook ที่ใช้ JavaScript ในการโหลดข่าวเพิ่มเติมเมื่อเลื่อนจอ หรือแสดงวิดีโอโดยไม่ต้องเปลี่ยนหน้า
+- ระบบจองตั๋วออนไลน์ เช่น Nok Air หรือ Thai Ticketmaster ที่ใช้ JavaScript เพื่อตรวจสอบที่นั่งว่าง และอัปเดตราคาตั๋วแบบเรียลไทม์
 
-## Contributions
+ในคู่มือนี้ เราจะเริ่มต้นจากพื้นฐาน เช่น ไวยากรณ์ของ JavaScript, ชนิดข้อมูล, ตัวแปร, ฟังก์ชัน, และโครงสร้างควบคุม จากนั้นจะค่อย ๆ ไปสู่หัวข้อที่ซับซ้อนขึ้น เช่น การทำงานกับ HTML และ CSS, การจัดการเหตุการณ์ และการโต้ตอบกับ API
 
-We'd also like to collaborate on the tutorial with other people.
+เราหวังว่าคู่มือนี้จะช่วยให้คุณสามารถเรียนรู้และใช้งาน JavaScript ได้อย่างมั่นใจ มาร่วมกันสำรวจโลกของการพัฒนาเว็บด้วย JavaScript กันเลย!
 
+<<<<<<< HEAD
+**อยากมีส่วนร่วมทำได้อย่างไร**
+- สามารถดูความคืบหน้าการแปลได้ที่หน้า [Thai Translate Progress](https://github.com/javascript-tutorial/th.javascript.info/issues/1)
+- เลือกบทความที่ยังไม่ถูกติ๊กและแปล
+- คอมเม้นชื่อหัวข้อที่ต้องการแปล ลงใน [Thai Translate Progress](https://github.com/javascript-tutorial/th.javascript.info/issues/1) issue. ตัวอย่าง `An Introduction to JavaScript`.
+    - บอทจะทำการติ๊ก issue ดังกล่าว ทุกคนจะรับทราบว่ามีคนกำลังแปลหัวข้อนี้อยู่
+    - คอมเม้นควรมีแค่ชื่อหัวข้อที่จะแปลเท่านั้น
+- ทำการ fork เรโปฯนี้, แปลและส่ง PR มาเมื่อการแปลเสร็จสิ้น
+    - จั่วหัว PR ควรใช้ชื่อเดียวกับหัวข้อบทความ ทีนี้บอทจะมอบหมายเลขให้ issue นั้นๆ
+
+คลิก <https://javascript.info/translate> เพื่อดูรายละเอียดในภาษาอื่นๆ
+=======
 Something's wrong? A topic is missing? Explain it to people, add it as PR 👏
 
 **You can edit the text in any editor.** The tutorial uses an enhanced "markdown" format, easy to grasp. And if you want to see how it looks on-site, there's a server to run the tutorial locally at <https://github.com/javascript-tutorial/server>.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
+
+Maintainers จะรีวิวและแก้ไขการแปลไปตามความเหมาะสม
 
-The list of contributors is available at <https://javascript.info/about#contributors>.
+หาก maintainers ไม่ตอบ หรือ ต้องการเป็น maintainers กรุณาเขียนคำร้องที่ [เรโปฯหลัก](https://github.com/javascript-tutorial/en.javascript.info/issues/new).
 
-## Structure
+<<<<<<< HEAD
+**มาช่วยร่วมกันแปลคู่มือจาวาสคริปต์ฉบับภาษาไทย**
 
+ชื่อของผู้มีส่วนร่วมและจำนวน contribution จะแสดงอยู่ในหน้า "About project" เมื่อการแปลถูกเผยแพร่เป็นที่เรียบร้อย
+=======
 Every chapter, article, or task has its folder.
 
 The folder is named like `N-url`, where `N` is a number for the sorting purposes and `URL` is the URL part with the title of the material.
+>>>>>>> 5e893cffce8e2346d4e50926d5148c70af172533
+
+## โครงสร้าง
+
+ในแต่ละบทจะในโฟลเดอร์เป็นของตัวเอง
+
+โดยโฟลเดอร์จะใช้ชื่อ `N-url` N แทนตัวเลขเพื่อให้ง่านต่อการจัดเรียง ส่วน url แทน URL-slug บนเว็บไซต์
+
+ฉะนั้นในหนึ่งโฟลเดอร์จะประกอบด้วย
+
+- `index.md` หมายถึงบทเรียน
+- `article.md` หมายถึงบทความ
+- `task.md` หมายถึงการบ้าน
+
+ในแต่ละไฟล์จะเริ่มต้นด้วย `# หัวเรื่อง` เนื้อหาทั้งหมดจะเป็นภาษามาร์กดาวน์ สามารถแก้ไขได้ด้วย text editor หรือ IDE ได้ตามความชอบ
+
+
+## ทริปการแปล
+
+รบกวนคงตัวแบ่งบรรทัดและย่อหน้าไว้อย่างเดิม ไม่ควรเพิ่มบรรทัดใหม่ และไม่ควรลบบรรทัดหรือย่อหน้าที่มีอยู่แล้ว เพื่อให้ง่ายต่อการ merge กับต้นฉบับภาษาอังกฤษ
+
+ถ้าเห็นว่าสำนวนในภาษาอังกฤษหรือภาษาไทยควรปรับปรุงเพิ่มเติม สามารถส่ง PR มาได้เลย
+
+### ข้อกำหนดเพิ่มเติม
+
+- สำหรับคำศัพท์เฉพาะทางโปรแกรมมิ่ง ไม่ควรแปลหรือทับศัพท์ใดๆลงไป ควรละคำดังกล่าวเอาไว้ เช่น "Function Declaration" 
+- คำที่เป็น keyword ของภาษาอย่าง `resolved promise`, `slash`, `regexp` และอื่นๆ - ควรตรวจดูอภิธานศัพท์เพิ่มเติมจาก [MDN](https://developer.mozilla.org/th/) หากไม่พบกรุณาละไว้เช่นเดิม
+
+### ข้อความใน Code Blocks
+
+- แปลเฉพาะคอมเม้นต์
+- แปลเฉพาะ user-messages และ สตริงตัวอย่าง
+- ไม่ควรแปลชื่อตัวแปร, ชื่อคลาส, ชื่อ identifiers
+- เมื่อแปลเสร็จอย่าลืมตรวจสอบว่าโค้ดทำงานได้อย่างเดิม
+
+ตัวอย่าง:
+
+```js
+// Example
+const text = "Hello, world";
+document.querySelector('.hello').innerHTML = text;
+```
+
+✅ ทำได้ (แปลคอมเม้น)
+
+```js
+// ตัวอย่าง
+const text = 'Hello, world';
+document.querySelector('.hello').innerHTML = text;
+```
+
+❌ ไม่ควรทำ (แปลคลาส):
+
+```js
+// ตัวอย่าง
+const text = 'Hello, world';
+// ".hello" เป็นชื่อคลาสใน HTML
+// ไม่ควรแปล
+document.querySelector('.สวัสดี').innerHTML = text;
+```
 
-The type of the material is defined by the file inside the folder:
+### ลิงค์ภายนอก
 
-  - `index.md` stands for a chapter
-  - `article.md` stands for an article
-  - `task.md` stands for a task (solution must be provided in `solution.md` file as well)
+ในกรณีลิงค์ภายนอกเช่นวิกีพีเดีย อย่าง `https://en.wikipedia.org/wiki/JavaScript` หรือมีบทความภาษาไทยอื่นๆที่มีคุณภาพและน่าเชื่อถือ สามารถแนบลิงค์ไปที่บทความนั้นๆแทน
 
-Each of these files starts from the `# Main header`.
+ตัวอย่าง:
 
-It's very easy to add something new.
+```md
+[JavaScript](https://en.wikipedia.org/wiki/JavaScript) is a programming language.
+```
+
+✅ ทำได้ (en -> th):
+
+```md
+[JavaScript](https://th.wikipedia.org/wiki/JavaScript) คือภาษาโปรแกรมมิ่ง
+```
+
+จะใช้ลิงค์ไปหาบทความที่ได้รับการแปลแค่บางส่วนใน MDN ก็ได้
+
+ไม่ควรแนบลิงค์บทความที่ไม่ใช่ภาษาไทย
+
+### Metadata
+
+มีบางไฟล์, tasks จะมี YAML metadata อยู่ข้างบน สังเกตได้จาก `---`:
+
+```md
+importance: 5
+---
+...
+```
+
+ไม่ควรแปล "importance" และ metadata อื่นๆ
+
+### Anchors
+
+ในบางหัวข้อจะมี `[#anchor]` ปิดท้าย ตัวอย่าง
+
+```md
+## Spread operator [#spread-operator]
+```
+
+ไม่ควรแปลหรือลบส่วนที่เป็น `[#...]` เพราะมีไว้สำหรับ URL anchors.
+
+## รันในเครื่องส่วนตัว
+
+คุณสามารถแก้ไขข้อความผ่าน editor ใดก็ได้ คู่มือนี้จะใช้ฟอร์แมตของ `markdown` เพราะเข้าใจง่าย และหากต้องการเห็นหน้าตาเวลาออนไลน์ ทางเรามีเซิฟเวอร์ที่สามารถรันคู่มือนี้ในเครื่องตัวเองได้ผ่านลิงค์ <https://github.com/javascript-tutorial/server>
+
+วิธีการรันสามารถทำตามได้ที่ <https://github.com/javascript-tutorial/server>. 
+
+สำหรับผู้ที่ใช้ VS Code และ IDE ตระกูล JetBrains สามารถดาวน์โหลดปลั๊กอินเพื่ออำนวยความสะดวกในการเขียนมาร์กดาวน์ได้ดังต่อไปนี้
+
+**VS Code**
+
+- [Markdown All in One](https://marketplace.visualstudio.com/items?itemName=yzhang.markdown-all-in-one)
+- [Markdown Preview Github Styling](https://marketplace.visualstudio.com/items?itemName=bierner.markdown-preview-github-styles)
+
+**Jetbrains**
+
+- [Markdown Navigator](https://plugins.jetbrains.com/plugin/7896-markdown-navigator/)
 
----  
 ♥  
-Ilya Kantor @iliakan
+Prasit Tongpradit @EpicHigh - Maintainer
+
+Prasit Tongpradit @EpicHigh