From e5316898f4ba6c93c634f2b36a08999872c46ece Mon Sep 17 00:00:00 2001
From: Prasit Tongpradit <prasit_tongpradit@windowslive.com>
Date: Sun, 8 Mar 2026 09:14:52 +0700
Subject: [PATCH] docs: translate advanced-functions section (11 articles)

---
 .../01-recursion/01-sum-to/solution.md        |  12 +-
 .../01-recursion/01-sum-to/task.md            |  22 +-
 .../01-recursion/02-factorial/solution.md     |   6 +-
 .../01-recursion/02-factorial/task.md         |  12 +-
 .../03-fibonacci-numbers/solution.md          |  60 ++--
 .../01-recursion/03-fibonacci-numbers/task.md |  16 +-
 .../04-output-single-linked-list/solution.md  |  26 +-
 .../04-output-single-linked-list/task.md      |  10 +-
 .../solution.md                               |  16 +-
 .../task.md                                   |   6 +-
 .../01-recursion/article.md                   | 294 +++++++++---------
 .../02-rest-parameters-spread/article.md      | 158 +++++-----
 .../1-closure-latest-changes/solution.md      |   6 +-
 .../1-closure-latest-changes/task.md          |  10 +-
 .../10-make-army/_js.view/solution.js         |   4 +-
 .../10-make-army/_js.view/source.js           |  10 +-
 .../03-closure/10-make-army/solution.md       | 110 +++----
 .../03-closure/10-make-army/task.md           |  26 +-
 .../2-closure-variable-access/solution.md     |   8 +-
 .../2-closure-variable-access/task.md         |  14 +-
 .../3-counter-independent/solution.md         |   6 +-
 .../03-closure/3-counter-independent/task.md  |   6 +-
 .../4-counter-object-independent/solution.md  |   6 +-
 .../4-counter-object-independent/task.md      |   6 +-
 .../03-closure/5-function-in-if/solution.md   |   4 +-
 .../03-closure/5-function-in-if/task.md       |   4 +-
 .../03-closure/6-closure-sum/solution.md      |   6 +-
 .../03-closure/6-closure-sum/task.md          |   8 +-
 .../03-closure/7-let-scope/solution.md        |  20 +-
 .../03-closure/7-let-scope/task.md            |   6 +-
 .../_js.view/source.js                        |   4 +-
 .../8-filter-through-function/task.md         |  20 +-
 .../9-sort-by-field/_js.view/source.js        |   2 +-
 .../03-closure/9-sort-by-field/task.md        |  16 +-
 .../03-closure/article.md                     | 260 ++++++++--------
 1-js/06-advanced-functions/04-var/article.md  | 138 ++++----
 .../05-global-object/article.md               |  63 ++--
 .../2-counter-inc-dec/_js.view/source.js      |   8 +-
 .../2-counter-inc-dec/solution.md             |   2 +-
 .../2-counter-inc-dec/task.md                 |  14 +-
 .../5-sum-many-brackets/_js.view/source.js    |   2 +-
 .../5-sum-many-brackets/solution.md           |  24 +-
 .../5-sum-many-brackets/task.md               |   6 +-
 .../06-function-object/article.md             | 170 +++++-----
 .../07-new-function/article.md                |  71 ++---
 .../1-output-numbers-100ms/solution.md        |  12 +-
 .../1-output-numbers-100ms/task.md            |  10 +-
 .../4-settimeout-result/solution.md           |   8 +-
 .../4-settimeout-result/task.md               |  18 +-
 .../08-settimeout-setinterval/article.md      | 194 ++++++------
 .../01-spy-decorator/_js.view/solution.js     |   2 +-
 .../01-spy-decorator/_js.view/source.js       |   2 +-
 .../01-spy-decorator/solution.md              |   2 +-
 .../01-spy-decorator/task.md                  |  10 +-
 .../02-delay/solution.md                      |  14 +-
 .../09-call-apply-decorators/02-delay/task.md |  14 +-
 .../03-debounce/debounce.view/index.html      |  10 +-
 .../03-debounce/solution.md                   |   2 +-
 .../03-debounce/task.md                       |  32 +-
 .../04-throttle/_js.view/solution.js          |  10 +-
 .../04-throttle/solution.md                   |  10 +-
 .../04-throttle/task.md                       |  50 +--
 .../09-call-apply-decorators/article.md       | 246 +++++++--------
 .../2-write-to-object-after-bind/solution.md  |   6 +-
 .../2-write-to-object-after-bind/task.md      |   4 +-
 .../10-bind/3-second-bind/solution.md         |   6 +-
 .../10-bind/3-second-bind/task.md             |   6 +-
 .../solution.md                               |   5 +-
 .../4-function-property-after-bind/task.md    |   6 +-
 .../10-bind/5-question-use-bind/solution.md   |  14 +-
 .../10-bind/5-question-use-bind/task.md       |   8 +-
 .../10-bind/6-ask-partial/solution.md         |  14 +-
 .../10-bind/6-ask-partial/task.md             |  10 +-
 1-js/06-advanced-functions/10-bind/article.md | 154 +++++----
 .../12-arrow-functions/article.md             |  74 ++---
 1-js/06-advanced-functions/index.md           |   2 +-
 76 files changed, 1326 insertions(+), 1327 deletions(-)

diff --git a/1-js/06-advanced-functions/01-recursion/01-sum-to/solution.md b/1-js/06-advanced-functions/01-recursion/01-sum-to/solution.md
index 11667f940..ff819662c 100644
--- a/1-js/06-advanced-functions/01-recursion/01-sum-to/solution.md
+++ b/1-js/06-advanced-functions/01-recursion/01-sum-to/solution.md
@@ -1,4 +1,4 @@
-The solution using a loop:
+วิธีใช้ลูป:
 
 ```js run
 function sumTo(n) {
@@ -12,7 +12,7 @@ function sumTo(n) {
 alert( sumTo(100) );
 ```
 
-The solution using recursion:
+วิธีใช้การเรียกซ้ำ:
 
 ```js run
 function sumTo(n) {
@@ -23,7 +23,7 @@ function sumTo(n) {
 alert( sumTo(100) );
 ```
 
-The solution using the formula: `sumTo(n) = n*(n+1)/2`:
+วิธีใช้สูตร: `sumTo(n) = n*(n+1)/2`:
 
 ```js run
 function sumTo(n) {
@@ -33,8 +33,8 @@ function sumTo(n) {
 alert( sumTo(100) );
 ```
 
-P.S. Naturally, the formula is the fastest solution. It uses only 3 operations for any number `n`. The math helps!
+P.S. แน่นอนว่าสูตรคณิตศาสตร์เร็วที่สุด ใช้แค่ 3 การดำเนินการไม่ว่า `n` จะเป็นเท่าไหร่ คณิตศาสตร์ช่วยได้!
 
-The loop variant is the second in terms of speed. In both the recursive and the loop variant we sum the same numbers. But the recursion involves nested calls and execution stack management. That also takes resources, so it's slower.
+วิธีลูปเร็วเป็นอันดับสอง ทั้งแบบเรียกซ้ำและแบบลูปบวกตัวเลขชุดเดียวกัน แต่การเรียกซ้ำมีการเรียกฟังก์ชันซ้อนและจัดการ execution stack ซึ่งกินทรัพยากรเพิ่ม จึงช้ากว่า
 
-P.P.S. Some engines support the "tail call" optimization: if a recursive call is the very last one in the function, with no other calculations performed, then the outer function will not need to resume the execution, so the engine doesn't need to remember its execution context. That removes the burden on memory. But if the JavaScript engine does not support tail call optimization (most of them don't), there will be an error: maximum stack size exceeded, because there's usually a limitation on the total stack size.
+P.P.S. บาง engine รองรับการปรับแต่ง "tail call" คือถ้าการเรียกซ้ำเป็นคำสั่งสุดท้ายของฟังก์ชัน โดยไม่มีการคำนวณอื่นอีก ฟังก์ชันภายนอกก็ไม่ต้องกลับมาทำงานต่อ ดังนั้น engine ไม่ต้องจำ execution context ช่วยลดภาระหน่วยความจำได้ แต่ถ้า JavaScript engine ไม่รองรับ tail call optimization (ส่วนใหญ่ไม่รองรับ) ก็จะเกิด error: maximum stack size exceeded เพราะปกติจะมีการจำกัดขนาดสแต็กรวมไว้
diff --git a/1-js/06-advanced-functions/01-recursion/01-sum-to/task.md b/1-js/06-advanced-functions/01-recursion/01-sum-to/task.md
index cabc13290..08289aa83 100644
--- a/1-js/06-advanced-functions/01-recursion/01-sum-to/task.md
+++ b/1-js/06-advanced-functions/01-recursion/01-sum-to/task.md
@@ -2,11 +2,11 @@ importance: 5
 
 ---
 
-# Sum all numbers till the given one
+# หาผลรวมของตัวเลขทั้งหมดจนถึงจำนวนที่กำหนด
 
-Write a function `sumTo(n)` that calculates the sum of numbers `1 + 2 + ... + n`.
+เขียนฟังก์ชัน `sumTo(n)` ที่คำนวณผลรวมของตัวเลข `1 + 2 + ... + n`
 
-For instance:
+ตัวอย่าง:
 
 ```js no-beautify
 sumTo(1) = 1
@@ -17,20 +17,20 @@ sumTo(4) = 4 + 3 + 2 + 1 = 10
 sumTo(100) = 100 + 99 + ... + 2 + 1 = 5050
 ```
 
-Make 3 solution variants:
+เขียนคำตอบ 3 แบบ:
 
-1. Using a for loop.
-2. Using a recursion, cause `sumTo(n) = n + sumTo(n-1)` for `n > 1`.
-3. Using the [arithmetic progression](https://en.wikipedia.org/wiki/Arithmetic_progression) formula.
+1. ใช้ for loop
+2. ใช้การเรียกซ้ำ เพราะ `sumTo(n) = n + sumTo(n-1)` เมื่อ `n > 1`
+3. ใช้สูตร[อนุกรมเลขคณิต](https://en.wikipedia.org/wiki/Arithmetic_progression)
 
-An example of the result:
+ตัวอย่างผลลัพธ์:
 
 ```js
-function sumTo(n) { /*... your code ... */ }
+function sumTo(n) { /*... โค้ดของคุณ ... */ }
 
 alert( sumTo(100) ); // 5050
 ```
 
-P.S. Which solution variant is the fastest? The slowest? Why?
+P.S. วิธีไหนเร็วที่สุด? ช้าที่สุด? ทำไม?
 
-P.P.S. Can we use recursion to count `sumTo(100000)`? 
+P.P.S. เราใช้การเรียกซ้ำคำนวณ `sumTo(100000)` ได้ไหม?
diff --git a/1-js/06-advanced-functions/01-recursion/02-factorial/solution.md b/1-js/06-advanced-functions/01-recursion/02-factorial/solution.md
index 09e511db5..5b9f882a6 100644
--- a/1-js/06-advanced-functions/01-recursion/02-factorial/solution.md
+++ b/1-js/06-advanced-functions/01-recursion/02-factorial/solution.md
@@ -1,6 +1,6 @@
-By definition, a factorial `n!` can be written as `n * (n-1)!`.
+จากนิยาม แฟกทอเรียล `n!` เขียนได้เป็น `n * (n-1)!`
 
-In other words, the result of `factorial(n)` can be calculated as `n` multiplied by the result of `factorial(n-1)`. And the call for `n-1` can recursively descend lower, and lower, till `1`.
+พูดอีกอย่างก็คือ ผลลัพธ์ของ `factorial(n)` คือ `n` คูณกับผลลัพธ์ของ `factorial(n-1)` แล้วการเรียกที่ `n-1` ก็เรียกซ้ำลดลงไปเรื่อยๆ จนถึง `1`
 
 ```js run
 function factorial(n) {
@@ -10,7 +10,7 @@ function factorial(n) {
 alert( factorial(5) ); // 120
 ```
 
-The basis of recursion is the value `1`. We can also make `0` the basis here, doesn't matter much, but gives one more recursive step:
+ฐานของการเรียกซ้ำคือค่า `1` เราจะใช้ `0` เป็นฐานแทนก็ได้ ไม่ต่างกันมาก แค่เพิ่มขั้นตอนการเรียกซ้ำอีกหนึ่งครั้ง:
 
 ```js run
 function factorial(n) {
diff --git a/1-js/06-advanced-functions/01-recursion/02-factorial/task.md b/1-js/06-advanced-functions/01-recursion/02-factorial/task.md
index d2aef2d90..2157bcdee 100644
--- a/1-js/06-advanced-functions/01-recursion/02-factorial/task.md
+++ b/1-js/06-advanced-functions/01-recursion/02-factorial/task.md
@@ -2,17 +2,17 @@ importance: 4
 
 ---
 
-# Calculate factorial
+# คำนวณแฟกทอเรียล
 
-The [factorial](https://en.wikipedia.org/wiki/Factorial) of a natural number is a number multiplied by `"number minus one"`, then by `"number minus two"`, and so on till `1`. The factorial of `n` is denoted as `n!`
+[แฟกทอเรียล](https://en.wikipedia.org/wiki/Factorial)ของจำนวนธรรมชาติ คือการนำจำนวนนั้นคูณกับ "จำนวนนั้นลบหนึ่ง" แล้วคูณกับ "จำนวนนั้นลบสอง" ไปเรื่อยๆ จนถึง `1` แฟกทอเรียลของ `n` เขียนแทนด้วย `n!`
 
-We can write a definition of factorial like this:
+เขียนเป็นนิยามได้แบบนี้:
 
 ```js
 n! = n * (n - 1) * (n - 2) * ...*1
 ```
 
-Values of factorials for different `n`:
+ค่าแฟกทอเรียลของ `n` ค่าต่างๆ:
 
 ```js
 1! = 1
@@ -22,10 +22,10 @@ Values of factorials for different `n`:
 5! = 5 * 4 * 3 * 2 * 1 = 120
 ```
 
-The task is to write a function `factorial(n)` that calculates `n!` using recursive calls.
+โจทย์คือเขียนฟังก์ชัน `factorial(n)` ที่คำนวณ `n!` โดยใช้การเรียกซ้ำ
 
 ```js
 alert( factorial(5) ); // 120
 ```
 
-P.S. Hint: `n!` can be written as `n * (n-1)!` For instance: `3! = 3*2! = 3*2*1! = 6`
+P.S. คำใบ้: `n!` เขียนในรูป `n * (n-1)!` ได้ เช่น `3! = 3*2! = 3*2*1! = 6`
diff --git a/1-js/06-advanced-functions/01-recursion/03-fibonacci-numbers/solution.md b/1-js/06-advanced-functions/01-recursion/03-fibonacci-numbers/solution.md
index 36524a45a..32c59b496 100644
--- a/1-js/06-advanced-functions/01-recursion/03-fibonacci-numbers/solution.md
+++ b/1-js/06-advanced-functions/01-recursion/03-fibonacci-numbers/solution.md
@@ -1,6 +1,6 @@
-The first solution we could try here is the recursive one.
+วิธีแรกที่ลองได้คือแบบเรียกซ้ำ
 
-Fibonacci numbers are recursive by definition:
+ตัวเลขฟีโบนักชีถูกนิยามแบบเรียกซ้ำอยู่แล้ว:
 
 ```js run
 function fib(n) {
@@ -9,14 +9,14 @@ function fib(n) {
 
 alert( fib(3) ); // 2
 alert( fib(7) ); // 13
-// fib(77); // will be extremely slow!
+// fib(77); // จะช้ามาก!
 ```
 
-...But for big values of `n` it's very slow. For instance, `fib(77)` may hang up the engine for some time eating all CPU resources.
+...แต่ถ้า `n` มีค่ามาก จะช้ามากๆ เช่น `fib(77)` อาจทำให้ engine ค้างเลย เพราะกิน CPU ไปหมด
 
-That's because the function makes too many subcalls. The same values are re-evaluated again and again.
+ที่เป็นแบบนี้เพราะฟังก์ชันเรียกซ้อนมากเกินไป ค่าเดิมๆ ถูกคำนวณซ้ำแล้วซ้ำอีก
 
-For instance, let's see a piece of calculations for `fib(5)`:
+ลองดูส่วนหนึ่งของการคำนวณ `fib(5)`:
 
 ```js no-beautify
 ...
@@ -25,68 +25,68 @@ fib(4) = fib(3) + fib(2)
 ...
 ```
 
-Here we can see that the value of `fib(3)` is needed for both `fib(5)` and `fib(4)`. So `fib(3)` will be called and evaluated two times completely independently.
+จะเห็นว่าค่า `fib(3)` ถูกใช้ทั้งใน `fib(5)` และ `fib(4)` ดังนั้น `fib(3)` จะถูกเรียกและคำนวณซ้ำสองครั้งโดยอิสระต่อกัน
 
-Here's the full recursion tree:
+นี่คือต้นไม้การเรียกซ้ำทั้งหมด:
 
 ![fibonacci recursion tree](fibonacci-recursion-tree.svg)
 
-We can clearly notice that `fib(3)` is evaluated two times and `fib(2)` is evaluated three times. The total amount of computations grows much faster than `n`, making it enormous even for `n=77`.
+เห็นชัดเลยว่า `fib(3)` ถูกคำนวณสองครั้ง และ `fib(2)` ถูกคำนวณสามครั้ง จำนวนการคำนวณทั้งหมดเพิ่มขึ้นเร็วกว่า `n` มาก จนมหาศาลแม้แค่ `n=77`
 
-We can optimize that by remembering already-evaluated values: if a value of say `fib(3)` is calculated once, then we can just reuse it in future computations.
+เราแก้ปัญหาได้โดยจำค่าที่คำนวณไปแล้ว: ถ้า `fib(3)` คำนวณแล้วครั้งหนึ่ง ก็นำค่ากลับมาใช้ได้เลยในการคำนวณครั้งถัดไป
 
-Another variant would be to give up recursion and use a totally different loop-based algorithm.
+อีกทางเลือกหนึ่งคือเลิกใช้การเรียกซ้ำ แล้วใช้อัลกอริทึมแบบลูปแทนเลย
 
-Instead of going from `n` down to lower values, we can make a loop that starts from `1` and `2`, then gets `fib(3)` as their sum, then `fib(4)` as the sum of two previous values, then `fib(5)` and goes up and up, till it gets to the needed value. On each step we only need to remember two previous values.
+แทนที่จะเริ่มจาก `n` แล้วลดลง เราเริ่มจาก `1` กับ `2` แล้วหา `fib(3)` จากผลรวมของสองตัว จากนั้นหา `fib(4)` จากผลรวมของสองค่าก่อนหน้า แล้วก็ `fib(5)` ไล่ขึ้นไปเรื่อยๆ จนถึงค่าที่ต้องการ ในแต่ละรอบต้องจำแค่สองค่าก่อนหน้า
 
-Here are the steps of the new algorithm in details.
+รายละเอียดขั้นตอนของอัลกอริทึมใหม่:
 
-The start:
+จุดเริ่มต้น:
 
 ```js
-// a = fib(1), b = fib(2), these values are by definition 1
+// a = fib(1), b = fib(2) ค่าเหล่านี้เท่ากับ 1 ตามนิยาม
 let a = 1, b = 1;
 
-// get c = fib(3) as their sum
+// หา c = fib(3) จากผลรวม
 let c = a + b;
 
-/* we now have fib(1), fib(2), fib(3)
+/* ตอนนี้เรามี fib(1), fib(2), fib(3)
 a  b  c
 1, 1, 2
 */
 ```
 
-Now we want to get `fib(4) = fib(2) + fib(3)`.
+ต่อไปเราต้องการ `fib(4) = fib(2) + fib(3)`
 
-Let's shift the variables: `a,b` will get `fib(2),fib(3)`, and `c` will get their sum:
+เลื่อนตัวแปร: `a,b` จะรับค่า `fib(2),fib(3)` แล้ว `c` จะเป็นผลรวม:
 
 ```js no-beautify
-a = b; // now a = fib(2)
-b = c; // now b = fib(3)
+a = b; // ตอนนี้ a = fib(2)
+b = c; // ตอนนี้ b = fib(3)
 c = a + b; // c = fib(4)
 
-/* now we have the sequence:
+/* ตอนนี้ลำดับเป็น:
    a  b  c
 1, 1, 2, 3
 */
 ```
 
-The next step gives another sequence number:
+ขั้นตอนถัดไปก็ได้ตัวเลขในลำดับอีกตัว:
 
 ```js no-beautify
-a = b; // now a = fib(3)
-b = c; // now b = fib(4)
+a = b; // ตอนนี้ a = fib(3)
+b = c; // ตอนนี้ b = fib(4)
 c = a + b; // c = fib(5)
 
-/* now the sequence is (one more number):
+/* ตอนนี้ลำดับเป็น (เพิ่มอีกหนึ่งตัว):
       a  b  c
 1, 1, 2, 3, 5
 */
 ```
 
-...And so on until we get the needed value. That's much faster than recursion and involves no duplicate computations.
+...ทำไปเรื่อยๆ จนได้ค่าที่ต้องการ วิธีนี้เร็วกว่าการเรียกซ้ำมาก และไม่มีการคำนวณซ้ำ
 
-The full code:
+โค้ดเต็ม:
 
 ```js run
 function fib(n) {
@@ -105,6 +105,6 @@ alert( fib(7) ); // 13
 alert( fib(77) ); // 5527939700884757
 ```
 
-The loop starts with `i=3`, because the first and the second sequence values are hard-coded into variables `a=1`, `b=1`.
+ลูปเริ่มที่ `i=3` เพราะค่าแรกและค่าที่สองของลำดับถูกกำหนดไว้แล้วในตัวแปร `a=1`, `b=1`
 
-The approach is called [dynamic programming bottom-up](https://en.wikipedia.org/wiki/Dynamic_programming).
+วิธีนี้เรียกว่า [dynamic programming แบบ bottom-up](https://en.wikipedia.org/wiki/Dynamic_programming)
diff --git a/1-js/06-advanced-functions/01-recursion/03-fibonacci-numbers/task.md b/1-js/06-advanced-functions/01-recursion/03-fibonacci-numbers/task.md
index 3cdadd219..9fefe1ed5 100644
--- a/1-js/06-advanced-functions/01-recursion/03-fibonacci-numbers/task.md
+++ b/1-js/06-advanced-functions/01-recursion/03-fibonacci-numbers/task.md
@@ -2,24 +2,24 @@ importance: 5
 
 ---
 
-# Fibonacci numbers
+# ตัวเลขฟีโบนักชี
 
-The sequence of [Fibonacci numbers](https://en.wikipedia.org/wiki/Fibonacci_number) has the formula <code>F<sub>n</sub> = F<sub>n-1</sub> + F<sub>n-2</sub></code>. In other words, the next number is a sum of the two preceding ones.
+ลำดับ[ตัวเลขฟีโบนักชี](https://en.wikipedia.org/wiki/Fibonacci_number)มีสูตรว่า <code>F<sub>n</sub> = F<sub>n-1</sub> + F<sub>n-2</sub></code> พูดง่ายๆ ก็คือ ตัวเลขถัดไปเป็นผลรวมของสองตัวก่อนหน้า
 
-First two numbers are `1`, then `2(1+1)`, then `3(1+2)`, `5(2+3)` and so on: `1, 1, 2, 3, 5, 8, 13, 21...`.
+สองตัวแรกคือ `1` จากนั้นก็เป็น `2(1+1)` แล้วก็ `3(1+2)`, `5(2+3)` ไปเรื่อยๆ: `1, 1, 2, 3, 5, 8, 13, 21...`
 
-Fibonacci numbers are related to the [Golden ratio](https://en.wikipedia.org/wiki/Golden_ratio) and many natural phenomena around us.
+ตัวเลขฟีโบนักชีมีความเกี่ยวข้องกับ[อัตราส่วนทอง](https://en.wikipedia.org/wiki/Golden_ratio)และปรากฏการณ์ทางธรรมชาติมากมายรอบตัวเรา
 
-Write a function `fib(n)` that returns the `n-th` Fibonacci number.
+เขียนฟังก์ชัน `fib(n)` ที่คืนค่าตัวเลขฟีโบนักชีลำดับที่ `n`
 
-An example of work:
+ตัวอย่างการทำงาน:
 
 ```js
-function fib(n) { /* your code */ }
+function fib(n) { /* โค้ดของคุณ */ }
 
 alert(fib(3)); // 2
 alert(fib(7)); // 13
 alert(fib(77)); // 5527939700884757
 ```
 
-P.S. The function should be fast. The call to `fib(77)` should take no more than a fraction of a second.
+P.S. ฟังก์ชันต้องทำงานเร็ว การเรียก `fib(77)` ควรใช้เวลาไม่ถึงวินาที
diff --git a/1-js/06-advanced-functions/01-recursion/04-output-single-linked-list/solution.md b/1-js/06-advanced-functions/01-recursion/04-output-single-linked-list/solution.md
index cfcbffea5..63ad28241 100644
--- a/1-js/06-advanced-functions/01-recursion/04-output-single-linked-list/solution.md
+++ b/1-js/06-advanced-functions/01-recursion/04-output-single-linked-list/solution.md
@@ -1,6 +1,6 @@
-# Loop-based solution
+# วิธีใช้ลูป
 
-The loop-based variant of the solution:
+คำตอบแบบใช้ลูป:
 
 ```js run
 let list = {
@@ -30,7 +30,7 @@ function printList(list) {
 printList(list);
 ```
 
-Please note that we use a temporary variable `tmp` to walk over the list. Technically, we could use a function parameter `list` instead:
+สังเกตว่าเราใช้ตัวแปรชั่วคราว `tmp` ในการท่องผ่าน list ในทางเทคนิค เราใช้พารามิเตอร์ `list` โดยตรงก็ได้:
 
 ```js
 function printList(list) {
@@ -43,15 +43,15 @@ function printList(list) {
 }
 ```
 
-...But that would be unwise. In the future we may need to extend a function, do something else with the list. If we change `list`, then we lose such ability.
+...แต่นั่นไม่ใช่ความคิดที่ดี เพราะในอนาคตเราอาจต้องขยายฟังก์ชัน หรือทำอะไรอย่างอื่นกับ list ถ้าเปลี่ยนค่า `list` ไปแล้ว จะทำไม่ได้
 
-Talking about good variable names, `list` here is the list itself. The first element of it. And it should remain like that. That's clear and reliable.
+ในแง่ชื่อตัวแปรที่ดี `list` ตรงนี้คือตัว list เอง คือสมาชิกตัวแรก ควรคงค่าไว้แบบนั้น เพื่อความชัดเจนและเชื่อถือได้
 
-From the other side, the role of `tmp` is exclusively a list traversal, like `i` in the `for` loop.
+ส่วน `tmp` มีหน้าที่แค่ท่องผ่าน list เท่านั้น เหมือน `i` ในลูป `for`
 
-# Recursive solution
+# วิธีใช้การเรียกซ้ำ
 
-The recursive variant of `printList(list)` follows a simple logic: to output a list we should output the current element `list`, then do the same for `list.next`:
+คำตอบแบบเรียกซ้ำของ `printList(list)` ใช้หลักคิดง่ายๆ คือ แสดงสมาชิกปัจจุบัน `list` แล้วทำแบบเดียวกันกับ `list.next`:
 
 ```js run
 let list = {
@@ -70,10 +70,10 @@ let list = {
 
 function printList(list) {
 
-  alert(list.value); // output the current item
+  alert(list.value); // แสดงสมาชิกปัจจุบัน
 
   if (list.next) {
-    printList(list.next); // do the same for the rest of the list
+    printList(list.next); // ทำแบบเดียวกันกับสมาชิกที่เหลือ
   }
 
 }
@@ -81,8 +81,8 @@ function printList(list) {
 printList(list);
 ```
 
-Now what's better?
+แล้วแบบไหนดีกว่ากัน?
 
-Technically, the loop is more effective. These two variants do the same, but the loop does not spend resources for nested function calls.
+ในทางเทคนิค ลูปมีประสิทธิภาพดีกว่า ทั้งสองวิธีทำงานเหมือนกัน แต่ลูปไม่เปลืองทรัพยากรในการเรียกฟังก์ชันซ้อน
 
-From the other side, the recursive variant is shorter and sometimes easier to understand.
+อีกด้านหนึ่ง แบบเรียกซ้ำเขียนสั้นกว่า และบางครั้งก็เข้าใจง่ายกว่า
diff --git a/1-js/06-advanced-functions/01-recursion/04-output-single-linked-list/task.md b/1-js/06-advanced-functions/01-recursion/04-output-single-linked-list/task.md
index 1076b952a..0d3c44bca 100644
--- a/1-js/06-advanced-functions/01-recursion/04-output-single-linked-list/task.md
+++ b/1-js/06-advanced-functions/01-recursion/04-output-single-linked-list/task.md
@@ -2,9 +2,9 @@ importance: 5
 
 ---
 
-# Output a single-linked list
+# แสดงผล linked list
 
-Let's say we have a single-linked list (as described in the chapter <info:recursion>):
+สมมติเรามี linked list (ตามที่อธิบายในบท <info:recursion>):
 
 ```js
 let list = {
@@ -22,8 +22,8 @@ let list = {
 };
 ```
 
-Write a function `printList(list)` that outputs list items one-by-one.
+เขียนฟังก์ชัน `printList(list)` ที่แสดงสมาชิกใน list ทีละตัว
 
-Make two variants of the solution: using a loop and using recursion.
+เขียนคำตอบ 2 แบบ: ใช้ลูป และใช้การเรียกซ้ำ
 
-What's better: with recursion or without it?
+แบบไหนดีกว่ากัน? แบบเรียกซ้ำ หรือไม่เรียกซ้ำ?
diff --git a/1-js/06-advanced-functions/01-recursion/05-output-single-linked-list-reverse/solution.md b/1-js/06-advanced-functions/01-recursion/05-output-single-linked-list-reverse/solution.md
index 0eb76ea1c..11a71dbcc 100644
--- a/1-js/06-advanced-functions/01-recursion/05-output-single-linked-list-reverse/solution.md
+++ b/1-js/06-advanced-functions/01-recursion/05-output-single-linked-list-reverse/solution.md
@@ -1,8 +1,8 @@
-# Using a recursion
+# วิธีใช้การเรียกซ้ำ
 
-The recursive logic is a little bit tricky here.
+หลักคิดแบบเรียกซ้ำตรงนี้ต้องคิดสักนิด
 
-We need to first output the rest of the list and *then* output the current one:
+เราต้องแสดงผลสมาชิกที่เหลือของ list ก่อน *แล้วค่อย* แสดงสมาชิกปัจจุบัน:
 
 ```js run
 let list = {
@@ -31,13 +31,13 @@ function printReverseList(list) {
 printReverseList(list);
 ```
 
-# Using a loop
+# วิธีใช้ลูป
 
-The loop variant is also a little bit more complicated than the direct output.
+วิธีลูปก็ซับซ้อนกว่าการแสดงผลตามลำดับปกติเล็กน้อย
 
-There is no way to get the last value in our `list`. We also can't "go back".
+ไม่มีทางดึงค่าตัวสุดท้ายของ `list` ได้โดยตรง และไม่สามารถ "ย้อนกลับ" ได้
 
-So what we can do is to first go through the items in the direct order and remember them in an array, and then output what we remembered in the reverse order:
+ดังนั้น สิ่งที่ทำได้คือท่องผ่านสมาชิกตามลำดับปกติก่อน แล้วเก็บไว้ในอาร์เรย์ จากนั้นค่อยแสดงผลจากท้ายมาหน้า:
 
 ```js run
 let list = {
@@ -71,4 +71,4 @@ function printReverseList(list) {
 printReverseList(list);
 ```
 
-Please note that the recursive solution actually does exactly the same: it follows the list, remembers the items in the chain of nested calls (in the execution context stack), and then outputs them. 
+สังเกตว่าวิธีเรียกซ้ำทำงานเหมือนกันทุกประการ — ท่องผ่าน list แล้วจำสมาชิกไว้ในสายการเรียกซ้อน (ใน execution context stack) จากนั้นค่อยแสดงผลออกมา
diff --git a/1-js/06-advanced-functions/01-recursion/05-output-single-linked-list-reverse/task.md b/1-js/06-advanced-functions/01-recursion/05-output-single-linked-list-reverse/task.md
index 81b1f3e33..24abcd217 100644
--- a/1-js/06-advanced-functions/01-recursion/05-output-single-linked-list-reverse/task.md
+++ b/1-js/06-advanced-functions/01-recursion/05-output-single-linked-list-reverse/task.md
@@ -2,8 +2,8 @@ importance: 5
 
 ---
 
-# Output a single-linked list in the reverse order
+# แสดงผล linked list แบบย้อนกลับ
 
-Output a single-linked list from the previous task <info:task/output-single-linked-list> in the reverse order.
+แสดงผล linked list จากโจทย์ก่อนหน้า <info:task/output-single-linked-list> แบบย้อนกลับ
 
-Make two solutions: using a loop and using a recursion.
+เขียนคำตอบ 2 แบบ: ใช้ลูป และใช้การเรียกซ้ำ
diff --git a/1-js/06-advanced-functions/01-recursion/article.md b/1-js/06-advanced-functions/01-recursion/article.md
index 5ae894474..243375608 100644
--- a/1-js/06-advanced-functions/01-recursion/article.md
+++ b/1-js/06-advanced-functions/01-recursion/article.md
@@ -1,18 +1,18 @@
-# Recursion and stack
+# การเรียกซ้ำ (Recursion) และสแต็ก
 
-Let's return to functions and study them more in-depth.
+กลับมาศึกษาเรื่องฟังก์ชันกันต่อ คราวนี้เราจะเจาะลึกมากขึ้น
 
-Our first topic will be *recursion*.
+หัวข้อแรกที่เราจะพูดถึงคือ *การเรียกซ้ำ (recursion)*
 
-If you are not new to programming, then it is probably familiar and you could skip this chapter.
+ถ้าเขียนโปรแกรมมาบ้างแล้ว อาจจะคุ้นเคยกับเรื่องนี้อยู่ ข้ามบทนี้ไปได้เลย
 
-Recursion is a programming pattern that is useful in situations when a task can be naturally split into several tasks of the same kind, but simpler. Or when a task can be simplified into an easy action plus a simpler variant of the same task. Or, as we'll see soon, to deal with certain data structures.
+การเรียกซ้ำเป็นรูปแบบการเขียนโปรแกรมที่มีประโยชน์เวลาที่โจทย์สามารถแตกออกเป็นโจทย์ย่อยที่เหมือนกันแต่ง่ายกว่า หรือเวลาที่โจทย์หนึ่งสามารถลดรูปเป็น "การกระทำง่ายๆ + โจทย์เดิมที่เล็กลง" หรืออย่างที่เราจะได้เห็นในบทนี้ ใช้จัดการโครงสร้างข้อมูลบางประเภทได้ดี
 
-When a function solves a task, in the process it can call many other functions. A partial case of this is when a function calls *itself*. That's called *recursion*.
+ในขั้นตอนการทำงานของฟังก์ชัน อาจมีการเรียกฟังก์ชันอื่นๆ อีกหลายตัว กรณีพิเศษอย่างหนึ่งก็คือเมื่อฟังก์ชัน *เรียกตัวเอง* นั่นแหละที่เราเรียกว่า *การเรียกซ้ำ (recursion)*
 
-## Two ways of thinking
+## สองวิธีคิด
 
-For something simple to start with -- let's write a function `pow(x, n)` that raises `x` to a natural power of `n`. In other words, multiplies `x` by itself `n` times.
+เริ่มจากเรื่องง่ายๆ กันก่อน -- มาเขียนฟังก์ชัน `pow(x, n)` ที่ยกกำลัง `x` ด้วยจำนวนเต็มบวก `n` พูดง่ายๆ ก็คือ คูณ `x` ด้วยตัวเอง `n` ครั้ง
 
 ```js
 pow(2, 2) = 4
@@ -20,15 +20,15 @@ pow(2, 3) = 8
 pow(2, 4) = 16
 ```
 
-There are two ways to implement it.
+มีสองวิธีในการเขียน
 
-1. Iterative thinking: the `for` loop:
+1. คิดแบบวนลูป: ใช้ `for` loop
 
     ```js run
     function pow(x, n) {
       let result = 1;
 
-      // multiply result by x n times in the loop
+      // คูณ result ด้วย x จำนวน n ครั้งในลูป
       for (let i = 0; i < n; i++) {
         result *= x;
       }
@@ -39,7 +39,7 @@ There are two ways to implement it.
     alert( pow(2, 3) ); // 8
     ```
 
-2. Recursive thinking: simplify the task and call self:
+2. คิดแบบเรียกซ้ำ: ลดรูปโจทย์แล้วเรียกตัวเอง
 
     ```js run
     function pow(x, n) {
@@ -53,9 +53,9 @@ There are two ways to implement it.
     alert( pow(2, 3) ); // 8
     ```
 
-Please note how the recursive variant is fundamentally different.
+สังเกตว่าวิธีเรียกซ้ำนั้นแตกต่างจากวิธีแรกโดยสิ้นเชิง
 
-When `pow(x, n)` is called, the execution splits into two branches:
+เมื่อเรียก `pow(x, n)` การทำงานจะแยกออกเป็นสองทาง:
 
 ```js
               if n==1  = x
@@ -65,27 +65,27 @@ pow(x, n) =
               else     = x * pow(x, n - 1)
 ```
 
-1. If `n == 1`, then everything is trivial. It is called *the base* of recursion, because it immediately produces the obvious result: `pow(x, 1)` equals `x`.
-2. Otherwise, we can represent `pow(x, n)` as `x * pow(x, n - 1)`. In maths, one would write <code>x<sup>n</sup> = x * x<sup>n-1</sup></code>. This is called *a recursive step*: we transform the task into a simpler action (multiplication by `x`) and a simpler call of the same task (`pow` with lower `n`). Next steps simplify it further and further until `n` reaches `1`.
+1. ถ้า `n == 1` ก็ง่ายเลย เราเรียกกรณีนี้ว่า *ฐานของการเรียกซ้ำ (base of recursion)* เพราะให้ผลลัพธ์ทันที: `pow(x, 1)` เท่ากับ `x`
+2. กรณีอื่น เราสามารถเขียน `pow(x, n)` ในรูป `x * pow(x, n - 1)` ได้ ในทางคณิตศาสตร์คือ <code>x<sup>n</sup> = x * x<sup>n-1</sup></code> ตรงนี้เรียกว่า *ขั้นตอนการเรียกซ้ำ (recursive step)* — เราแปลงโจทย์ให้ง่ายลงโดยเหลือแค่การคูณด้วย `x` บวกกับการเรียก `pow` ที่ `n` ลดลง แล้วก็ลดลงเรื่อยๆ จนกว่า `n` จะถึง `1`
 
-We can also say that `pow` *recursively calls itself* till `n == 1`.
+พูดอีกอย่างก็คือ `pow` *เรียกตัวเองซ้ำไปเรื่อยๆ* จนกว่า `n == 1`
 
 ![recursive diagram of pow](recursion-pow.svg)
 
 
-For example, to calculate `pow(2, 4)` the recursive variant does these steps:
+ยกตัวอย่าง การคำนวณ `pow(2, 4)` ด้วยวิธีเรียกซ้ำจะมีขั้นตอนดังนี้:
 
 1. `pow(2, 4) = 2 * pow(2, 3)`
 2. `pow(2, 3) = 2 * pow(2, 2)`
 3. `pow(2, 2) = 2 * pow(2, 1)`
 4. `pow(2, 1) = 2`
 
-So, the recursion reduces a function call to a simpler one, and then -- to even more simpler, and so on, until the result becomes obvious.
+การเรียกซ้ำจะลดรูปการเรียกฟังก์ชันให้ง่ายลงเรื่อยๆ จนกระทั่งผลลัพธ์ชัดเจน
 
-````smart header="Recursion is usually shorter"
-A recursive solution is usually shorter than an iterative one.
+````smart header="การเรียกซ้ำมักเขียนได้สั้นกว่า"
+โค้ดแบบเรียกซ้ำมักสั้นกว่าแบบใช้ลูป
 
-Here we can rewrite the same using the conditional operator `?` instead of `if` to make `pow(x, n)` more terse and still very readable:
+ตรงนี้เราเขียนใหม่ได้โดยใช้ตัวดำเนินการเงื่อนไข `?` แทน `if` ทำให้ `pow(x, n)` กระชับขึ้นแต่ยังอ่านง่าย:
 
 ```js run
 function pow(x, n) {
@@ -94,36 +94,36 @@ function pow(x, n) {
 ```
 ````
 
-The maximal number of nested calls (including the first one) is called *recursion depth*. In our case, it will be exactly `n`.
+จำนวนการเรียกซ้อนสูงสุด (รวมการเรียกครั้งแรกด้วย) เรียกว่า *ความลึกของการเรียกซ้ำ (recursion depth)* ในกรณีของเรา จะเท่ากับ `n` พอดี
 
-The maximal recursion depth is limited by JavaScript engine. We can rely on it being 10000, some engines allow more, but 100000 is probably out of limit for the majority of them. There are automatic optimizations that help alleviate this ("tail calls optimizations"), but they are not yet supported everywhere and work only in simple cases.
+JavaScript engine จำกัดความลึกของการเรียกซ้ำไว้ โดยทั่วไปเชื่อถือได้ที่ 10000 ชั้น บาง engine รองรับมากกว่านั้น แต่ 100000 ชั้นน่าจะเกินขีดจำกัดของ engine ส่วนใหญ่ มีการปรับแต่งประสิทธิภาพอัตโนมัติที่ช่วยได้ (เรียกว่า "tail calls optimizations") แต่ยังไม่รองรับทุกที่ และใช้ได้เฉพาะกรณีง่ายๆ เท่านั้น
 
-That limits the application of recursion, but it still remains very wide. There are many tasks where recursive way of thinking gives simpler code, easier to maintain.
+ข้อจำกัดนี้ทำให้ใช้การเรียกซ้ำได้ไม่ทุกกรณี แต่ก็ยังมีประโยชน์อยู่มาก หลายโจทย์ที่ใช้วิธีคิดแบบเรียกซ้ำจะได้โค้ดที่เรียบง่ายและดูแลรักษาง่ายกว่า
 
-## The execution context and stack
+## Execution context และสแต็ก
 
-Now let's examine how recursive calls work. For that we'll look under the hood of functions.
+ทีนี้มาดูกันว่าการเรียกซ้ำทำงานอย่างไร เราจะเจาะลึกเข้าไปดูเบื้องหลังของฟังก์ชัน
 
-The information about the process of execution of a running function is stored in its *execution context*.
+ข้อมูลเกี่ยวกับการทำงานของฟังก์ชันที่กำลังรันอยู่จะถูกเก็บไว้ใน *execution context*
 
-The [execution context](https://tc39.github.io/ecma262/#sec-execution-contexts) is an internal data structure that contains details about the execution of a function: where the control flow is now, the current variables, the value of `this` (we don't use it here) and few other internal details.
+[Execution context](https://tc39.github.io/ecma262/#sec-execution-contexts) เป็นโครงสร้างข้อมูลภายในที่เก็บรายละเอียดการทำงานของฟังก์ชัน เช่น ตอนนี้ทำงานถึงบรรทัดไหนแล้ว ตัวแปรมีค่าอะไรบ้าง `this` ชี้ไปที่ไหน (ในตัวอย่างนี้ยังไม่ใช้) และรายละเอียดภายในอื่นๆ
 
-One function call has exactly one execution context associated with it.
+การเรียกฟังก์ชันหนึ่งครั้ง จะมี execution context หนึ่งตัวผูกอยู่เสมอ
 
-When a function makes a nested call, the following happens:
+เมื่อฟังก์ชันเรียกฟังก์ชันซ้อน จะเกิดขั้นตอนดังนี้:
 
-- The current function is paused.
-- The execution context associated with it is remembered in a special data structure called *execution context stack*.
-- The nested call executes.
-- After it ends, the old execution context is retrieved from the stack, and the outer function is resumed from where it stopped.
+- ฟังก์ชันปัจจุบันถูกพักไว้ก่อน
+- Execution context ของฟังก์ชันนั้นจะถูกเก็บไว้ในโครงสร้างข้อมูลพิเศษที่เรียกว่า *execution context stack*
+- ฟังก์ชันซ้อนเริ่มทำงาน
+- เมื่อทำงานเสร็จ execution context เดิมจะถูกดึงกลับมาจากสแต็ก แล้วฟังก์ชันเดิมก็ทำงานต่อจากจุดที่ค้างไว้
 
-Let's see what happens during the `pow(2, 3)` call.
+มาดูกันว่าเกิดอะไรขึ้นระหว่างการเรียก `pow(2, 3)`
 
 ### pow(2, 3)
 
-In the beginning of the call `pow(2, 3)` the execution context will store variables: `x = 2, n = 3`, the execution flow is at line `1` of the function.
+ตอนเริ่มเรียก `pow(2, 3)` execution context จะเก็บตัวแปร `x = 2, n = 3` และการทำงานอยู่ที่บรรทัด `1` ของฟังก์ชัน
 
-We can sketch it as:
+วาดออกมาเป็นแผนภาพได้แบบนี้:
 
 <ul class="function-execution-context-list">
   <li>
@@ -132,7 +132,7 @@ We can sketch it as:
   </li>
 </ul>
 
-That's when the function starts to execute. The condition `n == 1` is falsy, so the flow continues into the second branch of `if`:
+นี่คือจุดที่ฟังก์ชันเริ่มทำงาน เงื่อนไข `n == 1` เป็นเท็จ จึงเข้าสู่สาขาที่สองของ `if`:
 
 ```js run
 function pow(x, n) {
@@ -149,7 +149,7 @@ alert( pow(2, 3) );
 ```
 
 
-The variables are same, but the line changes, so the context is now:
+ตัวแปรยังเหมือนเดิม แต่บรรทัดเปลี่ยนไป ตอนนี้ context เป็นแบบนี้:
 
 <ul class="function-execution-context-list">
   <li>
@@ -158,19 +158,19 @@ The variables are same, but the line changes, so the context is now:
   </li>
 </ul>
 
-To calculate `x * pow(x, n - 1)`, we need to make a subcall of `pow` with new arguments `pow(2, 2)`.
+ในการคำนวณ `x * pow(x, n - 1)` เราต้องเรียก `pow` ซ้อนด้วยอาร์กิวเมนต์ใหม่ `pow(2, 2)`
 
 ### pow(2, 2)
 
-To do a nested call, JavaScript remembers the current execution context in the *execution context stack*.
+ก่อนเรียกฟังก์ชันซ้อน JavaScript จะจำ execution context ปัจจุบันไว้ใน *execution context stack*
 
-Here we call the same function `pow`, but it absolutely doesn't matter. The process is the same for all functions:
+ตรงนี้เราเรียกฟังก์ชัน `pow` ตัวเดิม แต่ไม่ต่างจากการเรียกฟังก์ชันอื่นเลย ขั้นตอนเหมือนกันหมดสำหรับทุกฟังก์ชัน:
 
-1. The current context is "remembered" on top of the stack.
-2. The new context is created for the subcall.
-3. When the subcall is finished -- the previous context is popped from the stack, and its execution continues.
+1. Context ปัจจุบันถูก "จดจำ" ไว้บนสุดของสแต็ก
+2. สร้าง context ใหม่สำหรับการเรียกซ้อน
+3. เมื่อการเรียกซ้อนเสร็จ -- context เดิมจะถูกดึงออกจากสแต็ก แล้วทำงานต่อ
 
-Here's the context stack when we entered the subcall `pow(2, 2)`:
+นี่คือ context stack เมื่อเข้าสู่การเรียก `pow(2, 2)`:
 
 <ul class="function-execution-context-list">
   <li>
@@ -183,21 +183,21 @@ Here's the context stack when we entered the subcall `pow(2, 2)`:
   </li>
 </ul>
 
-The new current execution context is on top (and bold), and previous remembered contexts are below.
+Execution context ปัจจุบัน (ตัวใหม่) อยู่บนสุด (ตัวหนา) ส่วน context ที่เก็บไว้ก่อนหน้าอยู่ข้างล่าง
 
-When we finish the subcall -- it is easy to resume the previous context, because it keeps both variables and the exact place of the code where it stopped.
+เมื่อการเรียกซ้อนเสร็จ เราสามารถกลับไปทำงานต่อใน context เดิมได้ง่ายๆ เพราะ context เก็บทั้งตัวแปรและตำแหน่งที่ค้างไว้
 
 ```smart
-Here in the picture we use the word "line", as in our example there's only one subcall in line, but generally a single line of code may contain multiple subcalls, like `pow(…) + pow(…) + somethingElse(…)`.
+ในภาพเราใช้คำว่า "บรรทัด" (line) เพราะตัวอย่างของเรามีการเรียกซ้อนแค่ครั้งเดียวต่อบรรทัด แต่โดยทั่วไปบรรทัดเดียวอาจมีการเรียกซ้อนหลายครั้ง เช่น `pow(…) + pow(…) + somethingElse(…)`
 
-So it would be more precise to say that the execution resumes "immediately after the subcall".
+พูดให้ถูกต้องกว่าก็คือ การทำงานจะกลับมาทำต่อ "ทันทีหลังจากการเรียกซ้อนเสร็จ"
 ```
 
 ### pow(2, 1)
 
-The process repeats: a new subcall is made at line `5`, now with arguments `x=2`, `n=1`.
+กระบวนการเดิมซ้ำอีกครั้ง: เรียกซ้อนที่บรรทัด `5` ด้วยอาร์กิวเมนต์ `x=2`, `n=1`
 
-A new execution context is created, the previous one is pushed on top of the stack:
+สร้าง execution context ใหม่ ส่วนตัวก่อนหน้าถูกดันไปไว้บนสแต็ก:
 
 <ul class="function-execution-context-list">
   <li>
@@ -214,11 +214,11 @@ A new execution context is created, the previous one is pushed on top of the sta
   </li>
 </ul>
 
-There are 2 old contexts now and 1 currently running for `pow(2, 1)`.
+ตอนนี้มี context เก่าอยู่ 2 ตัว และอีก 1 ตัวที่กำลังทำงานอยู่คือ `pow(2, 1)`
 
-### The exit
+### ขาออก (The exit)
 
-During the execution of `pow(2, 1)`, unlike before, the condition `n == 1` is truthy, so the first branch of `if` works:
+ระหว่างที่ `pow(2, 1)` ทำงาน คราวนี้ต่างจากก่อนหน้า เงื่อนไข `n == 1` เป็นจริง จึงเข้าสู่สาขาแรกของ `if`:
 
 ```js
 function pow(x, n) {
@@ -232,9 +232,9 @@ function pow(x, n) {
 }
 ```
 
-There are no more nested calls, so the function finishes, returning `2`.
+ไม่มีการเรียกซ้อนอีกแล้ว ฟังก์ชันจึงทำงานเสร็จและคืนค่า `2`
 
-As the function finishes, its execution context is not needed anymore, so it's removed from the memory. The previous one is restored off the top of the stack:
+เมื่อฟังก์ชันทำงานเสร็จ execution context ของมันก็ไม่จำเป็นอีกต่อไป จึงถูกลบออกจากหน่วยความจำ แล้ว context ก่อนหน้าจะถูกดึงกลับมาจากสแต็ก:
 
 
 <ul class="function-execution-context-list">
@@ -248,9 +248,9 @@ As the function finishes, its execution context is not needed anymore, so it's r
   </li>
 </ul>
 
-The execution of `pow(2, 2)` is resumed. It has the result of the subcall `pow(2, 1)`, so it also can finish the evaluation of `x * pow(x, n - 1)`, returning `4`.
+`pow(2, 2)` กลับมาทำงานต่อ ตอนนี้ได้ผลลัพธ์จากการเรียก `pow(2, 1)` แล้ว จึงคำนวณ `x * pow(x, n - 1)` ได้ ซึ่งคืนค่า `4`
 
-Then the previous context is restored:
+จากนั้น context ก่อนหน้าถูกดึงกลับมา:
 
 <ul class="function-execution-context-list">
   <li>
@@ -259,15 +259,15 @@ Then the previous context is restored:
   </li>
 </ul>
 
-When it finishes, we have a result of `pow(2, 3) = 8`.
+เมื่อทำงานเสร็จ เราได้ผลลัพธ์ `pow(2, 3) = 8`
 
-The recursion depth in this case was: **3**.
+ความลึกของการเรียกซ้ำในกรณีนี้คือ **3**
 
-As we can see from the illustrations above, recursion depth equals the maximal number of context in the stack.
+จากภาพประกอบข้างต้นจะเห็นว่า ความลึกของการเรียกซ้ำเท่ากับจำนวน context สูงสุดในสแต็ก
 
-Note the memory requirements. Contexts take memory. In our case, raising to the power of `n` actually requires the memory for `n` contexts, for all lower values of `n`.
+สังเกตเรื่องการใช้หน่วยความจำด้วย แต่ละ context ต้องใช้หน่วยความจำ ในกรณีของเรา การยกกำลัง `n` ต้องใช้หน่วยความจำสำหรับ `n` context ครบทุกค่าของ `n` ที่ลดลงมา
 
-A loop-based algorithm is more memory-saving:
+อัลกอริทึมแบบใช้ลูปประหยัดหน่วยความจำกว่า:
 
 ```js
 function pow(x, n) {
@@ -281,19 +281,19 @@ function pow(x, n) {
 }
 ```
 
-The iterative `pow` uses a single context changing `i` and `result` in the process. Its memory requirements are small, fixed and do not depend on `n`.
+`pow` แบบใช้ลูปใช้ context เดียว โดยเปลี่ยนค่า `i` กับ `result` ไปเรื่อยๆ ใช้หน่วยความจำน้อย คงที่ และไม่ขึ้นกับค่า `n`
 
-**Any recursion can be rewritten as a loop. The loop variant usually can be made more effective.**
+**การเรียกซ้ำทุกแบบสามารถเขียนใหม่เป็นลูปได้ และแบบลูปมักจะมีประสิทธิภาพดีกว่า**
 
-...But sometimes the rewrite is non-trivial, especially when a function uses different recursive subcalls depending on conditions and merges their results or when the branching is more intricate. And the optimization may be unneeded and totally not worth the efforts.
+...แต่บางทีการเขียนใหม่เป็นลูปก็ไม่ง่าย โดยเฉพาะเมื่อฟังก์ชันเรียกซ้ำหลายทางตามเงื่อนไขต่างๆ แล้วรวมผลลัพธ์กัน หรือเมื่อการแตกกิ่งซับซ้อน อีกทั้งการปรับแต่งประสิทธิภาพอาจไม่จำเป็นและไม่คุ้มค่ากับความพยายาม
 
-Recursion can give a shorter code, easier to understand and support. Optimizations are not required in every place, mostly we need a good code, that's why it's used.
+การเรียกซ้ำให้โค้ดที่สั้นกว่า เข้าใจง่ายกว่า และดูแลง่ายกว่า ไม่จำเป็นต้องปรับแต่งประสิทธิภาพทุกจุด สิ่งที่ต้องการจริงๆ คือโค้ดที่ดี นั่นจึงเป็นเหตุผลที่เรานิยมใช้การเรียกซ้ำ
 
-## Recursive traversals
+## การท่องข้อมูลแบบเรียกซ้ำ (Recursive traversals)
 
-Another great application of the recursion is a recursive traversal.
+การเรียกซ้ำมีประโยชน์อีกอย่างหนึ่งคือการท่องข้อมูลแบบเรียกซ้ำ
 
-Imagine, we have a company. The staff structure can be presented as an object:
+สมมติว่าเรามีบริษัทแห่งหนึ่ง โครงสร้างพนักงานสามารถแสดงเป็นออบเจ็กต์ได้แบบนี้:
 
 ```js
 let company = {
@@ -322,34 +322,34 @@ let company = {
 };
 ```
 
-In other words, a company has departments.
+พูดง่ายๆ ก็คือ บริษัทมีหลายแผนก
 
-- A department may have an array of staff. For instance, `sales` department has 2 employees: John and Alice.
-- Or a department may split into subdepartments, like `development` has two branches: `sites` and `internals`. Each of them has their own staff.
-- It is also possible that when a subdepartment grows, it divides into subsubdepartments (or teams).
+- แผนกหนึ่งอาจมีอาร์เรย์ของพนักงาน เช่น แผนก `sales` มีพนักงาน 2 คน คือ John กับ Alice
+- หรือแผนกหนึ่งอาจแบ่งออกเป็นแผนกย่อย เช่น `development` มี 2 สาขาคือ `sites` กับ `internals` แต่ละสาขาก็มีพนักงานของตัวเอง
+- นอกจากนี้ เมื่อแผนกย่อยเติบโตขึ้น ก็อาจแบ่งออกเป็นแผนกย่อยลงไปอีก (หรือเป็นทีม)
 
-    For instance, the `sites` department in the future may be split into teams for `siteA` and `siteB`. And they, potentially, can split even more. That's not on the picture, just something to have in mind.
+    ยกตัวอย่าง แผนก `sites` ในอนาคตอาจแยกเป็นทีม `siteA` กับ `siteB` แล้วก็อาจแยกออกไปอีก ตรงนี้ยังไม่ได้อยู่ในภาพ แค่ให้จินตนาการไว้
 
-Now let's say we want a function to get the sum of all salaries. How can we do that?
+ทีนี้ สมมติเราต้องการฟังก์ชันที่รวมเงินเดือนทั้งหมด จะทำยังไงดี?
 
-An iterative approach is not easy, because the structure is not simple. The first idea may be to make a `for` loop over `company` with nested subloop over 1st level departments. But then we need more nested subloops to iterate over the staff in 2nd level departments like `sites`... And then another subloop inside those for 3rd level departments that might appear in the future? If we put 3-4 nested subloops in the code to traverse a single object, it becomes rather ugly.
+ถ้าใช้วิธีวนลูปจะไม่ง่ายเลย เพราะโครงสร้างซับซ้อน ความคิดแรกอาจเป็นการใช้ `for` ลูปวนผ่าน `company` แล้วซ้อนลูปย่อยสำหรับแผนกระดับที่ 1 แต่แล้วก็ต้องซ้อนลูปอีกเพื่อวนพนักงานในแผนกระดับที่ 2 อย่าง `sites`... แล้วก็ต้องซ้อนอีกสำหรับแผนกระดับที่ 3 ที่อาจเกิดขึ้นในอนาคต? ถ้าซ้อนลูป 3-4 ชั้นเพื่อท่องข้อมูลในออบเจ็กต์เดียว โค้ดจะดูรกมาก
 
-Let's try recursion.
+ลองใช้การเรียกซ้ำดีกว่า
 
-As we can see, when our function gets a department to sum, there are two possible cases:
+จะเห็นว่าเมื่อฟังก์ชันรับแผนกมาเพื่อรวมเงินเดือน จะมีสองกรณี:
 
-1. Either it's a "simple" department with an *array* of people -- then we can sum the salaries in a simple loop.
-2. Or it's *an object* with `N` subdepartments -- then we can make `N` recursive calls to get the sum for each of the subdeps and combine the results.
+1. เป็นแผนก "ธรรมดา" ที่มี *อาร์เรย์* ของพนักงาน -- ก็รวมเงินเดือนด้วยลูปง่ายๆ ได้เลย
+2. เป็น *ออบเจ็กต์* ที่มีแผนกย่อย `N` แผนก -- ก็เรียกซ้ำ `N` ครั้งเพื่อรวมเงินเดือนของแต่ละแผนกย่อย แล้วนำผลลัพธ์มารวมกัน
 
-The 1st case is the base of recursion, the trivial case, when we get an array.
+กรณีที่ 1 คือฐานของการเรียกซ้ำ เป็นกรณีง่ายๆ เมื่อได้รับอาร์เรย์
 
-The 2nd case when we get an object is the recursive step. A complex task is split into subtasks for smaller departments. They may in turn split again, but sooner or later the split will finish at (1).
+กรณีที่ 2 ที่ได้รับออบเจ็กต์คือขั้นตอนการเรียกซ้ำ โจทย์ที่ซับซ้อนจะถูกแตกออกเป็นโจทย์ย่อยตามแผนกต่างๆ ซึ่งอาจแตกย่อยออกไปอีก แต่สุดท้ายก็จะจบที่กรณีที่ (1)
 
-The algorithm is probably even easier to read from the code:
+อัลกอริทึมนี้อ่านจากโค้ดน่าจะเข้าใจง่ายกว่า:
 
 
 ```js run
-let company = { // the same object, compressed for brevity
+let company = { // ออบเจ็กต์เดิม ย่อให้กระชับ
   sales: [{name: 'John', salary: 1000}, {name: 'Alice', salary: 1600 }],
   development: {
     sites: [{name: 'Peter', salary: 2000}, {name: 'Alex', salary: 1800 }],
@@ -357,15 +357,15 @@ let company = { // the same object, compressed for brevity
   }
 };
 
-// The function to do the job
+// ฟังก์ชันทำงาน
 *!*
 function sumSalaries(department) {
-  if (Array.isArray(department)) { // case (1)
-    return department.reduce((prev, current) => prev + current.salary, 0); // sum the array
-  } else { // case (2)
+  if (Array.isArray(department)) { // กรณีที่ (1)
+    return department.reduce((prev, current) => prev + current.salary, 0); // รวมค่าในอาร์เรย์
+  } else { // กรณีที่ (2)
     let sum = 0;
     for (let subdep of Object.values(department)) {
-      sum += sumSalaries(subdep); // recursively call for subdepartments, sum the results
+      sum += sumSalaries(subdep); // เรียกซ้ำสำหรับแผนกย่อย แล้วรวมผลลัพธ์
     }
     return sum;
   }
@@ -375,62 +375,62 @@ function sumSalaries(department) {
 alert(sumSalaries(company)); // 7700
 ```
 
-The code is short and easy to understand (hopefully?). That's the power of recursion. It also works for any level of subdepartment nesting.
+โค้ดสั้นและเข้าใจง่ายใช่ไหม? นี่แหละพลังของการเรียกซ้ำ โค้ดนี้ใช้ได้กับแผนกย่อยกี่ระดับก็ได้
 
-Here's the diagram of calls:
+นี่คือแผนภาพการเรียก:
 
 ![recursive salaries](recursive-salaries.svg)
 
-We can easily see the principle: for an object `{...}` subcalls are made, while arrays `[...]` are the "leaves" of the recursion tree, they give immediate result.
+หลักการเห็นได้ชัดเลย: เมื่อเจอออบเจ็กต์ `{...}` ก็เรียกซ้ำต่อ ส่วนอาร์เรย์ `[...]` คือ "ใบ" ของต้นไม้การเรียกซ้ำ ซึ่งให้ผลลัพธ์ทันที
 
-Note that the code uses smart features that we've covered before:
+สังเกตว่าโค้ดนี้ใช้ฟีเจอร์ที่เราเรียนมาแล้ว:
 
-- Method `arr.reduce` explained in the chapter <info:array-methods> to get the sum of the array.
-- Loop `for(val of Object.values(obj))` to iterate over object values: `Object.values` returns an array of them.
+- เมธอด `arr.reduce` ที่อธิบายไว้ในบท <info:array-methods> สำหรับรวมค่าในอาร์เรย์
+- ลูป `for(val of Object.values(obj))` สำหรับวนผ่านค่าของออบเจ็กต์ โดย `Object.values` คืนค่าเป็นอาร์เรย์
 
 
-## Recursive structures
+## โครงสร้างข้อมูลแบบเรียกซ้ำ (Recursive structures)
 
-A recursive (recursively-defined) data structure is a structure that replicates itself in parts.
+โครงสร้างข้อมูลแบบเรียกซ้ำ คือโครงสร้างที่นิยามตัวเองซ้ำในส่วนย่อย
 
-We've just seen it in the example of a company structure above.
+เราเพิ่งเห็นตัวอย่างจากโครงสร้างบริษัทข้างต้น
 
-A company *department* is:
-- Either an array of people.
-- Or an object with *departments*.
+*แผนก* ของบริษัทอาจเป็น:
+- อาร์เรย์ของพนักงาน
+- หรือออบเจ็กต์ที่มี *แผนกย่อย* อยู่ภายใน
 
-For web-developers there are much better-known examples: HTML and XML documents.
+สำหรับเว็บเดเวลอปเปอร์ มีตัวอย่างที่คุ้นเคยกว่านี้อีก นั่นคือเอกสาร HTML และ XML
 
-In the HTML document, an *HTML-tag* may contain a list of:
-- Text pieces.
-- HTML-comments.
-- Other *HTML-tags* (that in turn may contain text pieces/comments or other tags etc).
+ในเอกสาร HTML *แท็ก HTML* หนึ่งตัวอาจมี:
+- ข้อความ
+- คอมเมนต์ HTML
+- *แท็ก HTML* ตัวอื่นๆ (ซึ่งก็อาจมีข้อความ/คอมเมนต์/แท็กอื่นซ้อนลงไปอีก)
 
-That's once again a recursive definition.
+นี่ก็เป็นนิยามแบบเรียกซ้ำเช่นกัน
 
-For better understanding, we'll cover one more recursive structure named "Linked list" that might be a better alternative for arrays in some cases.
+เพื่อให้เข้าใจมากขึ้น เราจะมาดูโครงสร้างแบบเรียกซ้ำอีกตัวหนึ่งชื่อว่า "Linked list" ซึ่งบางกรณีอาจเป็นทางเลือกที่ดีกว่าอาร์เรย์
 
 ### Linked list
 
-Imagine, we want to store an ordered list of objects.
+สมมติเราต้องการเก็บรายการออบเจ็กต์ที่มีลำดับ
 
-The natural choice would be an array:
+ทางเลือกที่นึกถึงก่อนก็คืออาร์เรย์:
 
 ```js
 let arr = [obj1, obj2, obj3];
 ```
 
-...But there's a problem with arrays. The "delete element" and "insert element" operations are expensive. For instance, `arr.unshift(obj)` operation has to renumber all elements to make room for a new `obj`, and if the array is big, it takes time. Same with `arr.shift()`.
+...แต่อาร์เรย์มีปัญหาอยู่อย่างหนึ่ง การ "ลบสมาชิก" และ "แทรกสมาชิก" นั้นค่อนข้างช้า เช่น `arr.unshift(obj)` ต้องขยับหมายเลขของสมาชิกทุกตัวเพื่อเปิดที่ว่างให้ `obj` ใหม่ ถ้าอาร์เรย์ใหญ่ก็กินเวลามาก `arr.shift()` ก็เช่นกัน
 
-The only structural modifications that do not require mass-renumbering are those that operate with the end of array: `arr.push/pop`. So an array can be quite slow for big queues, when we have to work with the beginning.
+การเปลี่ยนแปลงโครงสร้างที่ไม่ต้องขยับหมายเลขทั้งหมดมีแค่ตัวที่ทำงานกับท้ายอาร์เรย์ คือ `arr.push/pop` ดังนั้น อาร์เรย์อาจช้ามากสำหรับคิวขนาดใหญ่ที่ต้องทำงานกับด้านหน้าบ่อยๆ
 
-Alternatively, if we really need fast insertion/deletion, we can choose another data structure called a [linked list](https://en.wikipedia.org/wiki/Linked_list).
+ถ้าต้องการแทรก/ลบที่รวดเร็วจริงๆ เราเลือกใช้โครงสร้างข้อมูลอีกแบบที่เรียกว่า [linked list](https://en.wikipedia.org/wiki/Linked_list)
 
-The *linked list element* is recursively defined as an object with:
-- `value`.
-- `next` property referencing the next *linked list element* or `null` if that's the end.
+*สมาชิกของ linked list* ถูกนิยามแบบเรียกซ้ำเป็นออบเจ็กต์ที่มี:
+- `value` — ค่าที่เก็บไว้
+- พร็อพเพอร์ตี้ `next` ที่ชี้ไปยัง *สมาชิกตัวถัดไป* ใน linked list หรือ `null` ถ้าเป็นตัวสุดท้าย
 
-For instance:
+ตัวอย่าง:
 
 ```js
 let list = {
@@ -448,11 +448,11 @@ let list = {
 };
 ```
 
-Graphical representation of the list:
+แสดงเป็นภาพได้แบบนี้:
 
 ![linked list](linked-list.svg)
 
-An alternative code for creation:
+อีกวิธีหนึ่งในการสร้าง:
 
 ```js no-beautify
 let list = { value: 1 };
@@ -462,9 +462,9 @@ list.next.next.next = { value: 4 };
 list.next.next.next.next = null;
 ```
 
-Here we can even more clearly see that there are multiple objects, each one has the `value` and `next` pointing to the neighbour. The `list` variable is the first object in the chain, so following `next` pointers from it we can reach any element.
+แบบนี้เห็นชัดเจนขึ้นว่ามีออบเจ็กต์หลายตัว แต่ละตัวมี `value` และ `next` ชี้ไปหาตัวถัดไป ตัวแปร `list` คือออบเจ็กต์แรกในสาย เราสามารถตาม `next` ไปเรื่อยๆ จนถึงสมาชิกตัวไหนก็ได้
 
-The list can be easily split into multiple parts and later joined back:
+Linked list แบ่งออกเป็นหลายส่วนได้ง่าย แล้วเชื่อมกลับทีหลังก็ได้:
 
 ```js
 let secondList = list.next.next;
@@ -473,15 +473,15 @@ list.next.next = null;
 
 ![linked list split](linked-list-split.svg)
 
-To join:
+เชื่อมกลับ:
 
 ```js
 list.next.next = secondList;
 ```
 
-And surely we can insert or remove items in any place.
+แน่นอนว่าเราแทรกหรือลบสมาชิกตรงไหนก็ได้
 
-For instance, to prepend a new value, we need to update the head of the list:
+เช่น ถ้าจะเพิ่มค่าใหม่ไว้ข้างหน้า ก็แค่อัปเดตหัวของ list:
 
 ```js
 let list = { value: 1 };
@@ -490,14 +490,14 @@ list.next.next = { value: 3 };
 list.next.next.next = { value: 4 };
 
 *!*
-// prepend the new value to the list
+// เพิ่มค่าใหม่ไว้ข้างหน้า list
 list = { value: "new item", next: list };
 */!*
 ```
 
 ![linked list](linked-list-0.svg)
 
-To remove a value from the middle, change `next` of the previous one:
+ถ้าจะลบค่าตรงกลาง ก็เปลี่ยน `next` ของตัวก่อนหน้า:
 
 ```js
 list.next = list.next.next;
@@ -505,38 +505,38 @@ list.next = list.next.next;
 
 ![linked list](linked-list-remove-1.svg)
 
-We made `list.next` jump over `1` to value `2`. The value `1` is now excluded from the chain. If it's not stored anywhere else, it will be automatically removed from the memory.
+เราทำให้ `list.next` ข้ามจากค่า `1` ไปที่ค่า `2` ค่า `1` ถูกตัดออกจากสายแล้ว ถ้าไม่มีที่ไหนอ้างอิงถึงอีก ก็จะถูกลบออกจากหน่วยความจำโดยอัตโนมัติ
 
-Unlike arrays, there's no mass-renumbering, we can easily rearrange elements.
+ต่างจากอาร์เรย์ตรงที่ไม่ต้องขยับหมายเลขทั้งหมด เราจัดเรียงสมาชิกใหม่ได้ง่ายๆ
 
-Naturally, lists are not always better than arrays. Otherwise everyone would use only lists.
+แน่นอนว่า linked list ไม่ได้ดีกว่าอาร์เรย์เสมอไป ไม่อย่างนั้นทุกคนคงใช้แต่ list กันแล้ว
 
-The main drawback is that we can't easily access an element by its number. In an array that's easy: `arr[n]` is a direct reference. But in the list we need to start from the first item and go `next` `N` times to get the Nth element.
+ข้อเสียหลักคือเราเข้าถึงสมาชิกตามหมายเลขลำดับไม่ได้ง่ายๆ ถ้าเป็นอาร์เรย์ก็แค่ `arr[n]` ได้เลย แต่ใน linked list ต้องเริ่มจากตัวแรกแล้วตาม `next` ไป `N` ครั้งถึงจะได้สมาชิกตัวที่ N
 
-...But we don't always need such operations. For instance, when we need a queue or even a [deque](https://en.wikipedia.org/wiki/Double-ended_queue) -- the ordered structure that must allow very fast adding/removing elements from both ends, but access to its middle is not needed.
+...แต่ไม่ใช่ว่าเราต้องการแบบนั้นเสมอไป เช่น เมื่อต้องการคิว (queue) หรือ [deque](https://en.wikipedia.org/wiki/Double-ended_queue) ซึ่งเป็นโครงสร้างที่ต้องเพิ่ม/ลบสมาชิกจากทั้งสองด้านได้เร็วมาก แต่ไม่ต้องเข้าถึงตรงกลาง
 
-Lists can be enhanced:
-- We can add property `prev` in addition to `next` to reference the previous element, to move back easily.
-- We can also add a variable named `tail` referencing the last element of the list (and update it when adding/removing elements from the end).
-- ...The data structure may vary according to our needs.
+Linked list ยังปรับปรุงเพิ่มเติมได้อีก:
+- เพิ่มพร็อพเพอร์ตี้ `prev` ควบคู่กับ `next` เพื่อชี้ไปยังสมาชิกก่อนหน้า ให้ย้อนกลับได้ง่าย
+- เพิ่มตัวแปรชื่อ `tail` ที่ชี้ไปยังสมาชิกตัวสุดท้ายของ list (และอัปเดตเมื่อเพิ่ม/ลบสมาชิกจากท้าย list)
+- ...โครงสร้างข้อมูลปรับเปลี่ยนได้ตามความต้องการ
 
-## Summary
+## สรุป
 
-Terms:
-- *Recursion*  is a programming term that means calling a function from itself. Recursive functions can be used to solve tasks in elegant ways.
+คำศัพท์:
+- *การเรียกซ้ำ (Recursion)* คือศัพท์ทางโปรแกรมมิ่งที่หมายถึงฟังก์ชันเรียกตัวเอง ฟังก์ชันแบบเรียกซ้ำใช้แก้โจทย์ได้อย่างกระชับ
 
-    When a function calls itself, that's called a *recursion step*. The *basis* of recursion is function arguments that make the task so simple that the function does not make further calls.
+    เมื่อฟังก์ชันเรียกตัวเอง เรียกว่า *ขั้นตอนการเรียกซ้ำ (recursion step)* ส่วน *ฐานของการเรียกซ้ำ (basis)* คือกรณีที่อาร์กิวเมนต์ทำให้โจทย์ง่ายพอจนฟังก์ชันไม่ต้องเรียกต่อ
 
-- A [recursively-defined](https://en.wikipedia.org/wiki/Recursive_data_type) data structure is a data structure that can be defined using itself.
+- [โครงสร้างข้อมูลแบบเรียกซ้ำ](https://en.wikipedia.org/wiki/Recursive_data_type) คือโครงสร้างข้อมูลที่นิยามตัวเองได้
 
-    For instance, the linked list can be defined as a data structure consisting of an object referencing a list (or null).
+    ยกตัวอย่าง linked list สามารถนิยามเป็นโครงสร้างข้อมูลที่ประกอบด้วยออบเจ็กต์ที่อ้างอิงไปยัง list อีกตัว (หรือ null)
 
     ```js
     list = { value, next -> list }
     ```
 
-    Trees like HTML elements tree or the department tree from this chapter are also naturally recursive: they have branches and every branch can have other branches.
+    ต้นไม้ (tree) เช่น ต้นไม้ของ HTML elements หรือต้นไม้แผนกในบทนี้ ก็เป็นโครงสร้างแบบเรียกซ้ำโดยธรรมชาติ — แต่ละกิ่งสามารถมีกิ่งย่อยซ้อนลงไปได้อีก
 
-    Recursive functions can be used to walk them as we've seen in the `sumSalary` example.
+    ฟังก์ชันแบบเรียกซ้ำใช้ท่องข้อมูลเหล่านี้ได้ ดังที่เห็นในตัวอย่าง `sumSalary`
 
-Any recursive function can be rewritten into an iterative one. And that's sometimes required to optimize stuff. But for many tasks a recursive solution is fast enough and easier to write and support.
+ฟังก์ชันแบบเรียกซ้ำทุกตัวสามารถเขียนใหม่เป็นแบบวนลูปได้ และบางครั้งก็จำเป็นเพื่อปรับแต่งประสิทธิภาพ แต่ในหลายๆ โจทย์ วิธีเรียกซ้ำเร็วพอ เขียนง่ายกว่า และดูแลง่ายกว่า
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 527ada062..375c68d4d 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 และ spread syntax 
+# Rest parameters และ spread syntax
 
-ในภาษา JavaScript จะมี built-in ฟังก์ชั่นที่ช่วยทำงานให้เราต่าง ๆ มากมาย
+ฟังก์ชัน built-in หลายตัวของ JavaScript รองรับอาร์กิวเมนต์จำนวนไม่จำกัด
 
-ยกตัวอย่าง:
+ยกตัวอย่างเช่น:
 
-- `Math.max(arg1, arg2, ..., argN)` -- หาจำนวนที่มีค่ามากที่สุดในกลุ่ม.
-- `Object.assign(dest, src1, ..., srcN)` -- ก๊อบปี้ค่าของ `src1..N` ไปที่ `dest`.
-- และอื่น ๆ อีกมากมาย
+- `Math.max(arg1, arg2, ..., argN)` -- คืนค่าจำนวนที่มากที่สุดจากอาร์กิวเมนต์ทั้งหมด
+- `Object.assign(dest, src1, ..., srcN)` -- คัดลอกพร็อพเพอร์ตี้จาก `src1..N` ไปยัง `dest`
+- ...และอื่น ๆ อีกมากมาย
 
-ในบทนี้ เราจะมาเรียนรู้ built-in ฟังก์ชั่นอีกรูปแบบนึง ได้แก่ Rest parameters และ spread syntax
+ในบทนี้ เราจะมาเรียนรู้วิธีการแบบเดียวกัน รวมถึงวิธีส่งอาร์เรย์เข้าไปเป็นพารามิเตอร์ของฟังก์ชัน
 
 ## Rest parameters `...`
 
-ฟังก์ชั่นที่สามารถรับ arguments กี่ตัวก็ได้ ไม่ว่าจะตั้งค่าแบบไหน
+เราเรียกฟังก์ชันโดยส่งอาร์กิวเมนต์กี่ตัวก็ได้ ไม่ว่าฟังก์ชันนั้นจะประกาศพารามิเตอร์ไว้กี่ตัวก็ตาม
 
-ตัวอย่าง:
+ลองดูตัวอย่าง:
 ```js run
 function sum(a, b) {
   return a + b;
@@ -23,11 +23,11 @@ function sum(a, b) {
 alert( sum(1, 2, 3, 4, 5) );
 ```
 
-ในโค้ดตัวอย่างนี้ จะไม่เกิด error จากการที่มีตัวแปรที่มากไป แต่ ฟังก์ชั่น sum จะถูกคำนวนจาก arguments แค่ 2 ตัวแรกเท่านั้น
+โค้ดนี้จะไม่เกิด error แม้จะส่งอาร์กิวเมนต์มากเกินไป แต่ผลลัพธ์จะคำนวณจากอาร์กิวเมนต์ 2 ตัวแรกเท่านั้น
 
-parameters ที่เหลือสามารถเขียนเพิ่มในฟังก์ชั่นได้ผ่านการใช้จุดสามจุด `...` แล้วตามด้วยชื่อของ array นั้น โดยจุดหมายถึง การรวม parameters ที่เหลือใน array ด้วย
+เราสามารถรวมพารามิเตอร์ที่เหลือเข้าด้วยกันได้ โดยใช้จุดสามจุด `...` ตามด้วยชื่อของอาร์เรย์ที่จะรองรับค่าเหล่านั้น จุดสามจุดนี้หมายความว่า "รวมพารามิเตอร์ที่เหลือทั้งหมดเข้าไปในอาร์เรย์"
 
-ยกตัวอย่าง การรวม arguments ทั้งหมดใน array `args`:
+ยกตัวอย่าง การรวมอาร์กิวเมนต์ทั้งหมดเข้าในอาร์เรย์ `args`:
 
 ```js run
 function sumAll(...args) { // args คือชื่อของ array
@@ -43,16 +43,16 @@ alert( sumAll(1, 2) ); // 3
 alert( sumAll(1, 2, 3) ); // 6
 ```
 
-เราสามารถใช้ parameters ตัวแรก ๆ เป็นตัวแปร และรวม parameter ที่เหลือใน Rest parameters ได้
+เราเลือกให้พารามิเตอร์ตัวแรก ๆ เป็นตัวแปรแยก แล้วรวมเฉพาะส่วนที่เหลือไว้ใน rest parameters ก็ได้
 
-ตัวอย่างการให้ 2 parameter แรกเป็นตัวแปร และรวม parameter ที่เหลือใน array ที่ชื่อว่า `titles`
+ตัวอย่างนี้ให้ 2 ตัวแรกเป็นตัวแปร แล้วที่เหลือรวมไว้ในอาร์เรย์ `titles`
 
 ```js run
 function showName(firstName, lastName, ...titles) {
   alert( firstName + ' ' + lastName ); // Julius Caesar
 
-  // parameter ที่เหลือจะถูกรวมใน titles array
-  // ตัวอย่าง titles = ["Consul", "Imperator"]
+  // พารามิเตอร์ที่เหลือจะรวมอยู่ในอาร์เรย์ titles
+  // เช่น titles = ["Consul", "Imperator"]
   alert( titles[0] ); // Consul
   alert( titles[1] ); // Imperator
   alert( titles.length ); // 2
@@ -61,8 +61,8 @@ function showName(firstName, lastName, ...titles) {
 showName("Julius", "Caesar", "Consul", "Imperator");
 ```
 
-````warn header="The rest parameters ต้องอยู่ท้ายสุด"
-เพราะ Rest parameters จะรวม arguments ที่เหลืออยู่ทั้งหมด ดังนั้นการเขียนแบบในตัวอย่างด้านล่างจะไม่สมเหตุสมผลและ ก่อให้เกิด error:
+````warn header="Rest parameters ต้องอยู่ท้ายสุดเสมอ"
+เนื่องจาก rest parameters จะรวมอาร์กิวเมนต์ที่เหลือทั้งหมด การเขียนแบบนี้จึงไม่สมเหตุสมผลและทำให้เกิด error:
 
 ```js
 function f(arg1, ...rest, arg2) { // arg2 หลังจาก ...rest ?!
@@ -75,9 +75,9 @@ function f(arg1, ...rest, arg2) { // arg2 หลังจาก ...rest ?!
 
 ## ตัวแปร "arguments"
 
-มี object นึงที่ทำหน้าที่เหมือน array เรียกว่า `arguments` ที่ภายในจะมี argument เรียงตาม index
+นอกจากนี้ยังมีออบเจ็กต์พิเศษที่มีลักษณะคล้ายอาร์เรย์ ชื่อว่า `arguments` ซึ่งเก็บอาร์กิวเมนต์ทั้งหมดเรียงตาม index
 
-ยกตัวอย่าง
+ลองดูตัวอย่าง
 
 ```js run
 function showName() {
@@ -85,27 +85,27 @@ function showName() {
   alert( arguments[0] );
   alert( arguments[1] );
 
-  // เราสามารถวนซ้ำกับมันได้
+  // วนลูปได้เช่นกัน
   // for(let arg of arguments) alert(arg);
 }
 
 // แสดงผลเป็น: 2, Julius, Caesar
 showName("Julius", "Caesar");
 
-// แสดงผลเป็น: 1, Ilya, undefined (no second argument)
+// แสดงผลเป็น: 1, Ilya, undefined (ไม่มีอาร์กิวเมนต์ตัวที่สอง)
 showName("Ilya");
 ```
 
-ในสมัยก่อนที่จะมี rest parameters การใช้ `arguments` เป็นวิธีที่จะรวมทุก ๆ arguments ของฟังก์ชั่นนั้น ๆ ซึ่งคุณอาจจะเห็นได้จากในโค้ดเก่า ๆ
+สมัยก่อนที่จะมี rest parameters การใช้ `arguments` เป็นวิธีเดียวที่จะเข้าถึงอาร์กิวเมนต์ทั้งหมดของฟังก์ชัน ซึ่งยังใช้งานได้อยู่ และอาจเจอได้ในโค้ดเก่า ๆ
 
-แต่ข้อเสียของ `arguments` คือมันมีความเป็น array และยังสามารถวนซ้ำกับมันเพื่ออ่านค่า argument แต่ละตัวได้ แต่มันก็ไม่ใช่ array เพราะมันไม่สามารถเรียกใช้ array methods ได้ เช่นเราไม่สามารถใช้ `arguments.map(...)` ได้
+แต่ข้อเสียของ `arguments` คือ ถึงจะมีลักษณะคล้ายอาร์เรย์และวนลูปได้ แต่จริง ๆ แล้วไม่ใช่อาร์เรย์ จึงใช้เมธอดของอาร์เรย์ไม่ได้ เช่น `arguments.map(...)` จะใช้ไม่ได้
 
-แม้มันจะมีทุก ๆ arguments แต่เราไม่สามารถเรียกใช้บางส่วนแบบที่ rest parameters ทำได้
+นอกจากนี้ `arguments` จะเก็บอาร์กิวเมนต์ทั้งหมดเสมอ เราไม่สามารถเลือกรับเฉพาะบางส่วนได้แบบที่ rest parameters ทำได้
 
-ดังนั้นเมื่อเราจะใช้ฟีเจอร์นี้ rest parameters จึงเหมาะสมกว่า
+ดังนั้นถ้าต้องการความยืดหยุ่น rest parameters จึงเหมาะกว่า
 
-````smart header="Arrow functions จะไม่มี `\"arguments\"`"
-ถ้าเราจะเรียกใช้ object `arguments` จาก arrow function มันจะได้ผลลัพธ์เหมือนฟังก์ชั่นปกติทั่วไป
+````smart header="Arrow function ไม่มี `\"arguments\"`"
+ถ้าเราเข้าถึงออบเจ็กต์ `arguments` จากภายใน arrow function จะได้ค่า `arguments` ของฟังก์ชันภายนอกที่ครอบอยู่แทน
 
 ตัวอย่าง:
 
@@ -118,25 +118,25 @@ function f() {
 f(1); // 1
 ```
 
-ถ้าเราจำได้ arrow functions จะไม่มี `this` เป็นของตัวเอง และตอนนี้เราก็รู้แล้วว่า arrow functions ก็ไม่มี object `arguments` เหมือนกัน
+ดังที่เราเคยเรียนมาแล้ว arrow function ไม่มี `this` เป็นของตัวเอง และตอนนี้เราก็รู้แล้วว่าไม่มีออบเจ็กต์ `arguments` เป็นของตัวเองเช่นกัน
 ````
 
 
 ## Spread syntax [#spread-syntax]
 
-จากที่เราได้เห็นการดึง array จากกลุ่มของ parameters แล้ว
+เราเพิ่งเห็นวิธีรวมกลุ่มพารามิเตอร์เข้าเป็นอาร์เรย์ไปแล้ว
 
-แต่ในบางครั้งเราต้องการทำสิ่งตรงกันข้าม
+แต่บางครั้งเราต้องการทำสิ่งตรงกันข้าม
 
-อย่างเช่น built-in ฟังก์ชั่น [Math.max](mdn:js/Math/max) ที่จะหาจำนวนที่มีค่ามากที่สุดในกลุ่ม:
+ยกตัวอย่าง ฟังก์ชัน built-in อย่าง [Math.max](mdn:js/Math/max) จะคืนค่าจำนวนที่มากที่สุดจากรายการที่ส่งเข้าไป:
 
 ```js run
 alert( Math.max(3, 5, 1) ); // 5
 ```
 
-เรามี array ที่มีค่าดังนี้ `[3, 5, 1]`. เราจะเรียกใช้ `Math.max` กับมันได้อย่างไร ?
+สมมติเรามีอาร์เรย์ `[3, 5, 1]` แล้วจะส่งเข้า `Math.max` ได้อย่างไร?
 
-การเรียกใช้แบบ "as is" คงจะไม่เวิร์ค เพราะ `Math.max` จะรับค่าเฉพาะ arguments ที่เป็นตัวเลข ไม่ใช่ array:
+ส่งเข้าไปตรง ๆ ไม่ได้ เพราะ `Math.max` รับอาร์กิวเมนต์เป็นตัวเลขแยกทีละตัว ไม่ใช่อาร์เรย์:
 
 ```js run
 let arr = [3, 5, 1];
@@ -146,21 +146,21 @@ alert( Math.max(arr) ); // NaN
 */!*
 ```
 
-และเราก็ไม่สามารถเรียกใช้ตัวแปรแต่ละตัวจาก array แบบนี้ได้ในโค้ด `Math.max(arr[0], arr[1], arr[2])`, เพราะเราไม่มีทางรู้ได้เลยว่าใน array จะมีตัวแปรกี่ตัว ในการทำงานจริงคงจะไม่ได้มีแค่ตัวสองตัว หรือบางทีอาจจะไม่มีเลย นั่นแหละคือปัญหา
+แน่นอนว่าเราเขียน `Math.max(arr[0], arr[1], arr[2])` แบบระบุทีละตัวไม่ได้ เพราะไม่รู้ว่าอาร์เรย์จะมีสมาชิกกี่ตัว อาจมีเยอะมากหรืออาจไม่มีเลยก็ได้
 
-*Spread syntax* จะเข้ามาช่วยเหลือ โดยหน้าตามันจะเหมือนกับ rest parameters แถมยังใช้ `...` เหมือนกันอีก แต่การทำงานค่อนข้างแตกต่างกัน
+*Spread syntax* จะเข้ามาช่วยตรงนี้ หน้าตาเหมือน rest parameters เพราะใช้ `...` เหมือนกัน แต่ทำงานตรงกันข้าม
 
-เมื่อ `...arr` ถูกใช้ในการเรียกฟังก์ชั่นมันจะกระจาย object `arr` ออกมาเป็นกลุ่มของ arguments.
+เมื่อใช้ `...arr` ตอนเรียกฟังก์ชัน จะ "กระจาย" iterable ออบเจ็กต์ `arr` ออกเป็นอาร์กิวเมนต์แยกทีละตัว
 
-ตัวอย่างเช่น `Math.max`:
+ลองดูตัวอย่างกับ `Math.max`:
 
 ```js run
 let arr = [3, 5, 1];
 
-alert( Math.max(...arr) ); // 5 (กระจาย array ออกเป็นกลุ่มของ arguments)
+alert( Math.max(...arr) ); // 5 (spread กระจายอาร์เรย์ออกเป็นอาร์กิวเมนต์แยกทีละตัว)
 ```
 
-นอกจากนี้เรายังสามารถใช้ Spread syntax ได้มากกว่าหนึ่งตัว:
+นอกจากนี้ยังส่ง iterable หลายตัวพร้อมกันได้:
 
 ```js run
 let arr1 = [1, -2, 3, 4];
@@ -169,7 +169,7 @@ let arr2 = [8, 3, -8, 1];
 alert( Math.max(...arr1, ...arr2) ); // 8
 ```
 
-หรือเราจะผสม Spread syntax กับตัวแปรธรรมดาก็ย่อมได้:
+หรือจะผสม spread syntax กับค่าตัวเลขธรรมดาก็ได้:
 
 
 ```js run
@@ -179,7 +179,7 @@ let arr2 = [8, 3, -8, 1];
 alert( Math.max(1, ...arr1, 2, ...arr2, 25) ); // 25
 ```
 
-และ Spread syntax ยังสามารถใช้เพื่อรวม array 2 อันเข้าด้วยกัน:
+Spread syntax ยังใช้รวมอาร์เรย์เข้าด้วยกันได้อีกด้วย:
 
 ```js run
 let arr = [3, 5, 1];
@@ -192,9 +192,9 @@ let merged = [0, ...arr, 2, ...arr2];
 alert(merged); // 0,3,5,1,2,8,9,15 (0, ต่อด้วย arr, ต่อด้วย 2, ต่อด้วย arr2)
 ```
 
-ในตัวอย่างข้างต้น เราใช้ array เพื่อสาธิตการใช้ spread syntax แต่อะไรก็ตามที่เราสามารถวนซ้ำกับมันได้ก็สามารถทำแบบนี้ได้เช่นกัน
+ตัวอย่างข้างต้นใช้อาร์เรย์ แต่จริง ๆ แล้ว spread syntax ใช้ได้กับ iterable ทุกชนิด
 
-ยกตัวอย่าง เราสามารถใช้ spread syntax เพื่อที่จะแปลง string เป็น array of characters:
+ยกตัวอย่างเช่น ใช้ spread syntax แปลงสตริงเป็นอาร์เรย์ของตัวอักษร:
 
 ```js run
 let str = "Hello";
@@ -202,94 +202,94 @@ let str = "Hello";
 alert( [...str] ); // H,e,l,l,o
 ```
 
-หลักการทำงานของ Spread syntax คือการใช้การวนซ้ำรวม elements แบบที่ `for..of` ทำ
+Spread syntax ทำงานเบื้องหลังโดยใช้ iterator เหมือนกับ `for..of`
 
-ดังนั้นสำหรับ string, `for..of` จะคืนค่ามาเป็น characters และ `...str` จะคืนค่ามาเป็น `"H","e","l","l","o"`. ในรูปแบบของ array of string `[...str]`.
+สำหรับสตริง `for..of` จะคืนค่าเป็นตัวอักษรทีละตัว ดังนั้น `...str` จึงได้ `"H","e","l","l","o"` แล้วพอส่งเข้า `[...str]` ก็จะได้อาร์เรย์ของตัวอักษรออกมา
 
-สำหรับงานบางประเภท เราสามารถใช้ `Array.from`, เพราะมันสามารถแปลงข้อมูลใด ๆ ที่เราสามารถวนซ้ำกับมันได้ (เช่น string) ให้เป็น array ได้:
+งานแบบนี้เราใช้ `Array.from` ก็ได้เช่นกัน เพราะมันแปลง iterable (เช่น สตริง) ให้เป็นอาร์เรย์ได้:
 
 ```js run
 let str = "Hello";
 
-// Array.from แปลงข้อมูลใด ๆ ที่เราสามารถวนซ้ำกับมันได้ให้เป็น array
+// Array.from แปลง iterable ให้เป็นอาร์เรย์
 alert( Array.from(str) ); // H,e,l,l,o
 ```
 
-ผลลัพธ์ที่ได้จะเหมือนกับ `[...str]`.
+ผลลัพธ์ที่ได้เหมือนกับ `[...str]`
 
-แต่ทั้งนี้ทั้ง ก็ยังมีความแตกต่างระหว่าง `Array.from(obj)` และ `[...obj]`:
+แต่ `Array.from(obj)` กับ `[...obj]` มีความต่างเล็กน้อย:
 
-- `Array.from` สามารถทำงานกับข้อมูลที่เป็น array-likes และข้อมูลที่เราสามารถวนซ้ำกับมันได้
-- Spread syntax ทำงานได้กับแค่ข้อมูลที่เราสามารถวนซ้ำกับมันได้
+- `Array.from` ใช้ได้ทั้งกับ array-like และ iterable
+- Spread syntax ใช้ได้กับ iterable เท่านั้น
 
-ดังนั้น สำหรับการเปลี่ยนบางสิ่งให้กลายเป็น array, `Array.from` ดูจะเหมาะสมมากกว่า
+ดังนั้นถ้าต้องการแปลงอะไรสักอย่างให้เป็นอาร์เรย์ `Array.from` จึงครอบคลุมกว่า
 
 
-## การก๊อบปี้ array/object
+## การคัดลอก array/object
 
-จำได้มั้ยว่าเราเคยพูดถึง `Object.assign()` [in the past](info:object-copy#cloning-and-merging-object-assign)?
+จำได้ไหมว่าเราเคยพูดถึง `Object.assign()` [ไปก่อนหน้านี้](info:object-copy#cloning-and-merging-object-assign)?
 
-เราสามารถทำแบบ `Object.assign()` ได้ ผ่านการใช้ spread syntax.
+เราใช้ spread syntax ทำแบบเดียวกันได้เลย
 
 ```js run
 let arr = [1, 2, 3];
 
 *!*
-let arrCopy = [...arr]; // กระจาย array ออกมาเป็นกลุ่มของ parameters
-                        // จากนั้นนำผลลัพธ์ไปสร้าง array ตัวใหม่
+let arrCopy = [...arr]; // กระจายอาร์เรย์ออกเป็นรายการค่า
+                        // แล้วนำไปสร้างอาร์เรย์ตัวใหม่
 */!*
 
-// แล้ว array ตัวใหม่ กับ array ตัวเดิมมีค่าเหมือนกันมั้ย ?
+// อาร์เรย์ทั้งสองมีค่าเหมือนกันไหม?
 alert(JSON.stringify(arr) === JSON.stringify(arrCopy)); // true
 
-// แล้ว array 2 ตัวนั้นถูกอ้างอิงจากที่เดียวกันหรือป่าว ?
-alert(arr === arrCopy); // false (ไม่ได้ถูกอ้างอิงจากที่เดียวกัน)
+// แต่อ้างอิงตัวเดียวกันไหม?
+alert(arr === arrCopy); // false (คนละตัวกัน)
 
-// การเปลี่ยน array ต้นแบบ จะไม่เปลี่ยนค่า array ตัวใหม่:
+// แก้ไขต้นฉบับจะไม่กระทบสำเนา:
 arr.push(4);
 alert(arr); // 1, 2, 3, 4
 alert(arrCopy); // 1, 2, 3
 ```
 
-จำไว้ว่า มันเป็นไปได้ที่จะทำเหมือนกัน ตอนที่เราจะก๊อปปี้ object:
+ใช้วิธีเดียวกันนี้คัดลอกออบเจ็กต์ก็ได้เช่นกัน:
 
 ```js run
 let obj = { a: 1, b: 2, c: 3 };
 
 *!*
-let objCopy = { ...obj }; // กระจาย object ออกมาเป็นกลุ่มของ parameters
-                          // จากนั้นนำผลลัพธ์ไปสร้าง object ตัวใหม่
+let objCopy = { ...obj }; // กระจายออบเจ็กต์ออกเป็นพร็อพเพอร์ตี้แยกทีละตัว
+                          // แล้วนำไปสร้างออบเจ็กต์ตัวใหม่
 */!*
 
-// แล้ว object ตัวใหม่ กับ object ตัวเดิมมีค่าเหมือนกันมั้ย ?
+// ออบเจ็กต์ทั้งสองมีค่าเหมือนกันไหม?
 alert(JSON.stringify(obj) === JSON.stringify(objCopy)); // true
 
-// แล้ว object 2 ตัวนั้นถูกอ้างอิงจากที่เดียวกันหรือป่าว ?
-alert(obj === objCopy); // false (ไม่ได้ถูกอ้างอิงจากที่เดียวกัน)
+// แต่อ้างอิงตัวเดียวกันไหม?
+alert(obj === objCopy); // false (คนละตัวกัน)
 
-// การเปลี่ยน 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}
 ```
 
-ด้วยวิธีการนี้จะทำให้การเขียนก๊อปปี้ object เขียนได้สั้นกว่า `let objCopy = Object.assign({}, obj)` หรือสำหรับ array คือ `let arrCopy = Object.assign([], arr)` ดังนั้นเราจึงใช้พยายามใช้มันบ่อย ๆ เท่าที่จะทำได้
+วิธีนี้เขียนสั้นกว่า `let objCopy = Object.assign({}, obj)` หรือ `let arrCopy = Object.assign([], arr)` มาก จึงนิยมใช้กันมากกว่า
 
 
 ## สรุป
 
-เมื่อเราเห็น `"..."` ในโค้ด, มันอาจจะเป็น rest parameters หรือ spread syntax ก็ได้
+พอเห็น `"..."` ในโค้ด อาจเป็นได้ทั้ง rest parameters หรือ spread syntax
 
-แต่มันก็มีวิธีง่าย ๆ ในการแยกแยะความแตกต่างระหว่างสองสิ่งนี้
+แยกได้ง่าย ๆ ดังนี้:
 
-- เมื่อ `...` ปรากฏอยู่ที่ด้านท้ายของ parameters ในฟังก์ชั่น, มันคือ "rest parameters" ซึ่งจะรวม argument ที่เหลือใน array
-- เมื่อ `...` ปรากฏอยู่ ตอนที่เรียกใช้ฟังก์ชั่น, มันคือ "spread syntax" ซึ่งจะกระจาย array ออกมาเป็นกลุ่มของ parameter
+- ถ้า `...` อยู่ท้ายพารามิเตอร์ของฟังก์ชัน นั่นคือ "rest parameters" ซึ่งจะรวมอาร์กิวเมนต์ที่เหลือเข้าเป็นอาร์เรย์
+- ถ้า `...` อยู่ตอนเรียกฟังก์ชัน นั่นคือ "spread syntax" ซึ่งจะกระจายอาร์เรย์ออกเป็นอาร์กิวเมนต์แยกทีละตัว
 
-Patterns การใช้งาน:
+รูปแบบการใช้งาน:
 
-- Rest parameters มักใช้กับฟังก์ชั่นที่สามารถรับ arguments กี่ตัวก็ได้
-- Spread syntax จะใช้กับการเรียกใช้ array ในฟังก์ชั่น ที่ในฟังก์ชั่นนั้นอาจจะมีหลาย arguments
+- Rest parameters ใช้สร้างฟังก์ชันที่รับอาร์กิวเมนต์ได้ไม่จำกัดจำนวน
+- Spread syntax ใช้ส่งอาร์เรย์เข้าไปในฟังก์ชันที่ต้องการอาร์กิวเมนต์แยกทีละตัว
 
-ทั้งสองอย่างนี้ช่วยให้เราทำงานกับ array ของ parameters ได้ง่ายยิ่งขึ้น
+ทั้งสองอย่างนี้ช่วยให้เราสลับไปมาระหว่างรายการค่ากับอาร์เรย์ได้สะดวก
 
-ตัว arguments ในฟังก์ชั่นยังคงสามารถเรียกใช้ผ่าน "old-style" `arguments`: array-like iterable object ได้เหมือนเดิม
+นอกจากนี้ ยังสามารถเข้าถึงอาร์กิวเมนต์ทั้งหมดของฟังก์ชันได้ผ่าน `arguments` แบบเดิม ซึ่งเป็น array-like iterable ออบเจ็กต์
diff --git a/1-js/06-advanced-functions/03-closure/1-closure-latest-changes/solution.md b/1-js/06-advanced-functions/03-closure/1-closure-latest-changes/solution.md
index 7cbd85ab7..597e35a5e 100644
--- a/1-js/06-advanced-functions/03-closure/1-closure-latest-changes/solution.md
+++ b/1-js/06-advanced-functions/03-closure/1-closure-latest-changes/solution.md
@@ -1,5 +1,5 @@
-The answer is: **Pete**.
+คำตอบคือ: **Pete**
 
-A function gets outer variables as they are now, it uses the most recent values.
+ฟังก์ชันจะดึงค่าตัวแปรภายนอก ณ ตอนที่เรียกใช้ โดยใช้ค่าล่าสุดเสมอ
 
-Old variable values are not saved anywhere. When a function wants a variable, it takes the current value from its own Lexical Environment or the outer one.
+ค่าเก่าจะไม่ถูกเก็บไว้ที่ไหน เมื่อฟังก์ชันต้องการตัวแปร จะดึงค่าปัจจุบันจาก Lexical Environment ของตัวเองหรือชั้นนอก
diff --git a/1-js/06-advanced-functions/03-closure/1-closure-latest-changes/task.md b/1-js/06-advanced-functions/03-closure/1-closure-latest-changes/task.md
index 819189773..defb1a3e1 100644
--- a/1-js/06-advanced-functions/03-closure/1-closure-latest-changes/task.md
+++ b/1-js/06-advanced-functions/03-closure/1-closure-latest-changes/task.md
@@ -2,9 +2,9 @@ importance: 5
 
 ---
 
-# Does a function pickup latest changes?
+# ฟังก์ชันจะเห็นค่าล่าสุดไหม?
 
-The function sayHi uses an external variable name. When the function runs, which value is it going to use?
+ฟังก์ชัน sayHi ใช้ตัวแปรภายนอก name เมื่อฟังก์ชันทำงาน จะใช้ค่าไหน?
 
 ```js
 let name = "John";
@@ -15,9 +15,9 @@ function sayHi() {
 
 name = "Pete";
 
-sayHi(); // what will it show: "John" or "Pete"?
+sayHi(); // จะแสดงอะไร: "John" หรือ "Pete"?
 ```
 
-Such situations are common both in browser and server-side development. A function may be scheduled to execute later than it is created, for instance after a user action or a network request.
+สถานการณ์แบบนี้พบได้บ่อยทั้งในฝั่ง browser และ server ฟังก์ชันอาจถูกตั้งเวลาให้ทำงานทีหลัง เช่น หลังจากผู้ใช้กดปุ่มหรือหลังจากรับข้อมูลจากเครือข่าย
 
-So, the question is: does it pick up the latest changes?
+คำถามคือ: ฟังก์ชันจะใช้ค่าล่าสุดไหม?
diff --git a/1-js/06-advanced-functions/03-closure/10-make-army/_js.view/solution.js b/1-js/06-advanced-functions/03-closure/10-make-army/_js.view/solution.js
index a26578ae1..dd01c66f9 100644
--- a/1-js/06-advanced-functions/03-closure/10-make-army/_js.view/solution.js
+++ b/1-js/06-advanced-functions/03-closure/10-make-army/_js.view/solution.js
@@ -3,8 +3,8 @@ function makeArmy() {
   let shooters = [];
 
   for(let i = 0; i < 10; i++) {
-    let shooter = function() { // shooter function
-      alert( i ); // should show its number
+    let shooter = function() { // ฟังก์ชัน shooter
+      alert( i ); // ควรแสดงหมายเลขของมัน
     };
     shooters.push(shooter);
   }
diff --git a/1-js/06-advanced-functions/03-closure/10-make-army/_js.view/source.js b/1-js/06-advanced-functions/03-closure/10-make-army/_js.view/source.js
index 7c7aaa1e3..2cb3826b7 100644
--- a/1-js/06-advanced-functions/03-closure/10-make-army/_js.view/source.js
+++ b/1-js/06-advanced-functions/03-closure/10-make-army/_js.view/source.js
@@ -3,8 +3,8 @@ function makeArmy() {
 
   let i = 0;
   while (i < 10) {
-    let shooter = function() { // shooter function
-      alert( i ); // should show its number
+    let shooter = function() { // ฟังก์ชัน shooter
+      alert( i ); // ควรแสดงหมายเลขของมัน
     };
     shooters.push(shooter);
     i++;
@@ -16,7 +16,7 @@ function makeArmy() {
 /*
 let army = makeArmy();
 
-army[0](); // the shooter number 0 shows 10
-army[5](); // and number 5 also outputs 10...
-// ... all shooters show 10 instead of their 0, 1, 2, 3...
+army[0](); // shooter หมายเลข 0 แสดง 10
+army[5](); // หมายเลข 5 ก็แสดง 10 เช่นกัน...
+// ... shooters ทุกตัวแสดง 10 แทนที่จะเป็น 0, 1, 2, 3...
 */
diff --git a/1-js/06-advanced-functions/03-closure/10-make-army/solution.md b/1-js/06-advanced-functions/03-closure/10-make-army/solution.md
index 9d99aa717..e455b5a2d 100644
--- a/1-js/06-advanced-functions/03-closure/10-make-army/solution.md
+++ b/1-js/06-advanced-functions/03-closure/10-make-army/solution.md
@@ -1,14 +1,14 @@
 
-Let's examine what exactly happens inside `makeArmy`, and the solution will become obvious.
+มาดูกันว่าเกิดอะไรขึ้นภายใน `makeArmy` แล้วจะเข้าใจคำตอบเอง
 
-1. It creates an empty array `shooters`:
+1. สร้างอาร์เรย์เปล่า `shooters`:
 
     ```js
     let shooters = [];
     ```
-2. Fills it with functions via `shooters.push(function)` in the loop.
+2. เติมฟังก์ชันเข้าไปด้วย `shooters.push(function)` ในลูป
 
-    Every element is a function, so the resulting array looks like this:
+    สมาชิกทุกตัวเป็นฟังก์ชัน อาร์เรย์ที่ได้จึงหน้าตาแบบนี้:
 
     ```js no-beautify
     shooters = [
@@ -25,105 +25,105 @@ Let's examine what exactly happens inside `makeArmy`, and the solution will beco
     ];
     ```
 
-3. The array is returned from the function.
-    
-    Then, later, the call to any member, e.g. `army[5]()` will get the element `army[5]` from the array (which is a function) and calls it.
-    
-    Now why do all such functions show the same value, `10`?
-    
-    That's because there's no local variable `i` inside `shooter` functions. When such a function is called, it takes `i` from its outer lexical environment.
-    
-    Then, what will be the value of `i`?
-    
-    If we look at the source:
-    
+3. อาร์เรย์ถูก return ออกจากฟังก์ชัน
+
+    จากนั้น เมื่อเรียกสมาชิกตัวใดก็ตาม เช่น `army[5]()` จะดึงเอลิเมนต์ `army[5]` จากอาร์เรย์ (ซึ่งเป็นฟังก์ชัน) แล้วเรียกใช้
+
+    ทำไมฟังก์ชันทุกตัวถึงแสดงค่าเดียวกันคือ `10`?
+
+    เพราะไม่มีตัวแปร `i` ภายในฟังก์ชัน `shooter` เมื่อเรียกฟังก์ชัน จึงดึงค่า `i` จาก Lexical Environment ชั้นนอก
+
+    แล้วค่าของ `i` จะเป็นเท่าไหร่?
+
+    ลองดูจากซอร์สโค้ด:
+
     ```js
     function makeArmy() {
       ...
       let i = 0;
       while (i < 10) {
-        let shooter = function() { // shooter function
-          alert( i ); // should show its number
+        let shooter = function() { // ฟังก์ชัน shooter
+          alert( i ); // ควรแสดงหมายเลขของมัน
         };
-        shooters.push(shooter); // add function to the array
+        shooters.push(shooter); // เพิ่มฟังก์ชันเข้าอาร์เรย์
         i++;
       }
       ...
     }
     ```
-    
-    We can see that all `shooter` functions are created in the lexical environment of `makeArmy()` function. But when `army[5]()` is called, `makeArmy` has already finished its job, and the final value of `i` is `10` (`while` stops at `i=10`).
-    
-    As the result, all `shooter` functions get the same value from the outer lexical environment and that is, the last value, `i=10`.
-    
+
+    จะเห็นว่าฟังก์ชัน `shooter` ทุกตัวถูกสร้างใน Lexical Environment ของฟังก์ชัน `makeArmy()` แต่เมื่อเรียก `army[5]()` ตอนนั้น `makeArmy` ทำงานเสร็จแล้ว และค่าสุดท้ายของ `i` คือ `10` (`while` หยุดที่ `i=10`)
+
+    ผลก็คือ ฟังก์ชัน `shooter` ทุกตัวดึงค่าเดียวกันจาก Lexical Environment ชั้นนอก นั่นคือค่าสุดท้าย `i=10`
+
     ![](lexenv-makearmy-empty.svg)
-    
-    As you can see above, on each iteration of a `while {...}` block, a new lexical environment is created. So, to fix this, we can copy the value of `i` into a variable within the `while {...}` block, like this:
-    
+
+    จากรูปด้านบนจะเห็นว่า ในแต่ละรอบของลูป `while {...}` จะสร้าง Lexical Environment ใหม่ ดังนั้นวิธีแก้คือ คัดลอกค่า `i` ไว้ในตัวแปรภายในบล็อก `while {...}` แบบนี้:
+
     ```js run
     function makeArmy() {
       let shooters = [];
-    
+
       let i = 0;
       while (i < 10) {
         *!*
           let j = i;
         */!*
-          let shooter = function() { // shooter function
-            alert( *!*j*/!* ); // should show its number
+          let shooter = function() { // ฟังก์ชัน shooter
+            alert( *!*j*/!* ); // ควรแสดงหมายเลขของมัน
           };
         shooters.push(shooter);
         i++;
       }
-    
+
       return shooters;
     }
-    
+
     let army = makeArmy();
-    
-    // Now the code works correctly
+
+    // ตอนนี้โค้ดทำงานถูกต้องแล้ว
     army[0](); // 0
     army[5](); // 5
     ```
-    
-    Here `let j = i` declares an "iteration-local" variable `j` and copies `i` into it. Primitives are copied "by value", so we actually get an independent copy of `i`, belonging to the current loop iteration.
-    
-    The shooters work correctly, because the value of `i` now lives a little bit closer. Not in `makeArmy()` Lexical Environment, but in the Lexical Environment that corresponds to the current loop iteration:
-    
+
+    ตรงนี้ `let j = i` ประกาศตัวแปร `j` ที่เป็นของแต่ละรอบลูป แล้วคัดลอกค่า `i` ไป ค่า primitive ถูกคัดลอก "ตามค่า" ดังนั้นจึงได้สำเนาอิสระของ `i` ที่เป็นของรอบลูปปัจจุบัน
+
+    shooters ทำงานถูกต้อง เพราะค่าของ `i` ตอนนี้อยู่ใกล้ขึ้น ไม่ได้อยู่ใน Lexical Environment ของ `makeArmy()` แต่อยู่ใน Lexical Environment ของรอบลูปปัจจุบัน:
+
     ![](lexenv-makearmy-while-fixed.svg)
-    
-    Such a problem could also be avoided if we used `for` in the beginning, like this:
-    
+
+    ปัญหานี้จะหายไปเลยถ้าใช้ `for` ตั้งแต่แรก แบบนี้:
+
     ```js run demo
     function makeArmy() {
-    
+
       let shooters = [];
-    
+
     *!*
       for(let i = 0; i < 10; i++) {
     */!*
-        let shooter = function() { // shooter function
-          alert( i ); // should show its number
+        let shooter = function() { // ฟังก์ชัน shooter
+          alert( i ); // ควรแสดงหมายเลขของมัน
         };
         shooters.push(shooter);
       }
-    
+
       return shooters;
     }
-    
+
     let army = makeArmy();
-    
+
     army[0](); // 0
     army[5](); // 5
     ```
-    
-    That's essentially the same, because `for` on each iteration generates a new lexical environment, with its own variable `i`. So `shooter` generated in every iteration references its own `i`, from that very iteration.
-    
+
+    หลักการเดียวกัน เพราะ `for` จะสร้าง Lexical Environment ใหม่ในแต่ละรอบ พร้อมตัวแปร `i` ของตัวเอง ดังนั้น `shooter` ที่สร้างในแต่ละรอบจะอ้างอิง `i` ของรอบนั้นโดยเฉพาะ
+
     ![](lexenv-makearmy-for-fixed.svg)
 
-Now, as you've put so much effort into reading this, and the final recipe is so simple - just use `for`, you may wonder -- was it worth that?
+ตอนนี้ที่อ่านมาตั้งมาก แล้วสรุปก็แค่ใช้ `for` อาจรู้สึกว่าคุ้มไหมที่อ่าน?
 
-Well, if you could easily answer the question, you wouldn't read the solution. So, hopefully this task must have helped you to understand things a bit better. 
+ถ้าตอบได้ทันทีก็คงไม่ต้องอ่านคำเฉลย หวังว่าโจทย์ข้อนี้จะช่วยให้เข้าใจเรื่องนี้ได้ดีขึ้น
 
-Besides, there are indeed cases when one prefers `while` to `for`, and other scenarios, where such problems are real.
+นอกจากนี้ ในการทำงานจริงก็มีกรณีที่ต้องใช้ `while` แทน `for` และปัญหาแบบนี้ก็เกิดขึ้นจริง
 
diff --git a/1-js/06-advanced-functions/03-closure/10-make-army/task.md b/1-js/06-advanced-functions/03-closure/10-make-army/task.md
index f50c7dc20..364203ea0 100644
--- a/1-js/06-advanced-functions/03-closure/10-make-army/task.md
+++ b/1-js/06-advanced-functions/03-closure/10-make-army/task.md
@@ -2,11 +2,11 @@ importance: 5
 
 ---
 
-# Army of functions
+# กองทัพของฟังก์ชัน
 
-The following code creates an array of `shooters`.
+โค้ดด้านล่างสร้างอาร์เรย์ของ `shooters`
 
-Every function is meant to output its number. But something is wrong...
+ฟังก์ชันแต่ละตัวควรจะแสดงหมายเลขของมัน แต่มีบางอย่างผิดพลาด...
 
 ```js run
 function makeArmy() {
@@ -14,28 +14,28 @@ function makeArmy() {
 
   let i = 0;
   while (i < 10) {
-    let shooter = function() { // create a shooter function,
-      alert( i ); // that should show its number
+    let shooter = function() { // สร้างฟังก์ชัน shooter
+      alert( i ); // ที่ควรแสดงหมายเลขของมัน
     };
-    shooters.push(shooter); // and add it to the array
+    shooters.push(shooter); // แล้วเพิ่มเข้าไปในอาร์เรย์
     i++;
   }
 
-  // ...and return the array of shooters
+  // ...แล้วคืนค่าอาร์เรย์ของ shooters
   return shooters;
 }
 
 let army = makeArmy();
 
 *!*
-// all shooters show 10 instead of their numbers 0, 1, 2, 3...
-army[0](); // 10 from the shooter number 0
-army[1](); // 10 from the shooter number 1
-army[2](); // 10 ...and so on.
+// shooters ทุกตัวแสดง 10 แทนที่จะเป็นหมายเลข 0, 1, 2, 3...
+army[0](); // 10 จาก shooter หมายเลข 0
+army[1](); // 10 จาก shooter หมายเลข 1
+army[2](); // 10 ...เป็นแบบนี้ไปเรื่อยๆ
 */!*
 ```
 
-Why do all of the shooters show the same value? 
+ทำไม shooters ทุกตัวถึงแสดงค่าเดียวกัน?
 
-Fix the code so that they work as intended.
+จงแก้โค้ดให้ทำงานตามที่ต้องการ
 
diff --git a/1-js/06-advanced-functions/03-closure/2-closure-variable-access/solution.md b/1-js/06-advanced-functions/03-closure/2-closure-variable-access/solution.md
index 0a522132f..798ed1ab4 100644
--- a/1-js/06-advanced-functions/03-closure/2-closure-variable-access/solution.md
+++ b/1-js/06-advanced-functions/03-closure/2-closure-variable-access/solution.md
@@ -1,9 +1,9 @@
-The answer is: **Pete**.
+คำตอบคือ: **Pete**
 
-The `work()` function in the code below gets `name` from the place of its origin through the outer lexical environment reference:
+ฟังก์ชัน `work()` ในโค้ดด้านล่างได้ค่า `name` จากตำแหน่งที่มันถูกสร้าง ผ่านการอ้างอิง Lexical Environment ชั้นนอก:
 
 ![](lexenv-nested-work.svg)
 
-So, the result is `"Pete"` here.
+ดังนั้นผลลัพธ์คือ `"Pete"`
 
-But if there were no `let name` in `makeWorker()`, then the search would go outside and take the global variable as we can see from the chain above. In that case the result would be `"John"`.
+แต่ถ้าไม่มี `let name` ใน `makeWorker()` การค้นหาจะไล่ออกไปข้างนอกและใช้ตัวแปร global ตามที่เห็นในห่วงโซ่ด้านบน ในกรณีนั้นผลลัพธ์จะเป็น `"John"`
diff --git a/1-js/06-advanced-functions/03-closure/2-closure-variable-access/task.md b/1-js/06-advanced-functions/03-closure/2-closure-variable-access/task.md
index d12a385c8..d63147b31 100644
--- a/1-js/06-advanced-functions/03-closure/2-closure-variable-access/task.md
+++ b/1-js/06-advanced-functions/03-closure/2-closure-variable-access/task.md
@@ -2,11 +2,11 @@ importance: 5
 
 ---
 
-# Which variables are available?
+# ตัวแปรไหนเข้าถึงได้บ้าง?
 
-The function `makeWorker` below makes another function and returns it. That new function can be called from somewhere else.
+ฟังก์ชัน `makeWorker` ด้านล่างสร้างฟังก์ชันอีกตัวหนึ่งแล้ว return ออกมา ฟังก์ชันใหม่นี้สามารถเรียกจากที่อื่นได้
 
-Will it have access to the outer variables from its creation place, or the invocation place, or both?
+คำถามคือ มันจะเข้าถึงตัวแปรภายนอกจากตอนที่สร้าง หรือจากตอนที่เรียกใช้ หรือทั้งคู่?
 
 ```js
 function makeWorker() {
@@ -19,11 +19,11 @@ function makeWorker() {
 
 let name = "John";
 
-// create a function
+// สร้างฟังก์ชัน
 let work = makeWorker();
 
-// call it
-work(); // what will it show?
+// เรียกใช้
+work(); // จะแสดงอะไร?
 ```
 
-Which value it will show? "Pete" or "John"?
+จะแสดง "Pete" หรือ "John"?
diff --git a/1-js/06-advanced-functions/03-closure/3-counter-independent/solution.md b/1-js/06-advanced-functions/03-closure/3-counter-independent/solution.md
index 25ecbea4c..544e225f4 100644
--- a/1-js/06-advanced-functions/03-closure/3-counter-independent/solution.md
+++ b/1-js/06-advanced-functions/03-closure/3-counter-independent/solution.md
@@ -1,5 +1,5 @@
-The answer: **0,1.**
+คำตอบคือ: **0,1**
 
-Functions `counter` and `counter2` are created by different invocations of `makeCounter`.
+ฟังก์ชัน `counter` กับ `counter2` ถูกสร้างจากการเรียก `makeCounter` คนละครั้ง
 
-So they have independent outer Lexical Environments, each one has its own `count`.
+ดังนั้นจึงมี Lexical Environment ชั้นนอกเป็นของตัวเอง แต่ละตัวมี `count` ของตัวเอง
diff --git a/1-js/06-advanced-functions/03-closure/3-counter-independent/task.md b/1-js/06-advanced-functions/03-closure/3-counter-independent/task.md
index e8c17dd31..e4caf578e 100644
--- a/1-js/06-advanced-functions/03-closure/3-counter-independent/task.md
+++ b/1-js/06-advanced-functions/03-closure/3-counter-independent/task.md
@@ -2,11 +2,11 @@ importance: 5
 
 ---
 
-# Are counters independent?
+# ตัวนับแต่ละตัวเป็นอิสระจากกันไหม?
 
-Here we make two counters: `counter` and `counter2` using the same `makeCounter` function.
+เราสร้างตัวนับ 2 ตัว คือ `counter` กับ `counter2` จากฟังก์ชัน `makeCounter` ตัวเดียวกัน
 
-Are they independent? What is the second counter going to show? `0,1` or `2,3` or something else?
+แต่ละตัวเป็นอิสระจากกันไหม? ตัวนับตัวที่สองจะแสดงค่าอะไร? `0,1` หรือ `2,3` หรืออย่างอื่น?
 
 ```js
 function makeCounter() {
diff --git a/1-js/06-advanced-functions/03-closure/4-counter-object-independent/solution.md b/1-js/06-advanced-functions/03-closure/4-counter-object-independent/solution.md
index cd4e641e4..da3e466ad 100644
--- a/1-js/06-advanced-functions/03-closure/4-counter-object-independent/solution.md
+++ b/1-js/06-advanced-functions/03-closure/4-counter-object-independent/solution.md
@@ -1,7 +1,7 @@
 
-Surely it will work just fine.
+ทำงานได้ปกติ
 
-Both nested functions are created within the same outer Lexical Environment, so they share access to the same `count` variable:
+ฟังก์ชันซ้อนทั้งสองตัวถูกสร้างภายใน Lexical Environment ชั้นนอกเดียวกัน จึงเข้าถึงตัวแปร `count` ตัวเดียวกันได้:
 
 ```js run
 function Counter() {
@@ -10,7 +10,7 @@ function Counter() {
   this.up = function() {
     return ++count;
   };
-  
+
   this.down = function() {
     return --count;
   };
diff --git a/1-js/06-advanced-functions/03-closure/4-counter-object-independent/task.md b/1-js/06-advanced-functions/03-closure/4-counter-object-independent/task.md
index d770b0ffc..d2ebe51f5 100644
--- a/1-js/06-advanced-functions/03-closure/4-counter-object-independent/task.md
+++ b/1-js/06-advanced-functions/03-closure/4-counter-object-independent/task.md
@@ -2,11 +2,11 @@ importance: 5
 
 ---
 
-# Counter object
+# ออบเจ็กต์ตัวนับ
 
-Here a counter object is made with the help of the constructor function.
+ตัวนับด้านล่างสร้างจากคอนสตรักเตอร์ฟังก์ชัน
 
-Will it work? What will it show?
+มันจะทำงานได้ไหม? จะแสดงอะไร?
 
 ```js
 function Counter() {
diff --git a/1-js/06-advanced-functions/03-closure/5-function-in-if/solution.md b/1-js/06-advanced-functions/03-closure/5-function-in-if/solution.md
index e2e7a91b3..0e4ce33c3 100644
--- a/1-js/06-advanced-functions/03-closure/5-function-in-if/solution.md
+++ b/1-js/06-advanced-functions/03-closure/5-function-in-if/solution.md
@@ -1,3 +1,3 @@
-The result is **an error**.
+ผลลัพธ์คือ **error**
 
-The function `sayHi` is declared inside the `if`, so it only lives inside it. There is no `sayHi` outside.
\ No newline at end of file
+ฟังก์ชัน `sayHi` ถูกประกาศภายในบล็อก `if` จึงมีอยู่แค่ภายในบล็อกนั้น ข้างนอกไม่มี `sayHi`
\ No newline at end of file
diff --git a/1-js/06-advanced-functions/03-closure/5-function-in-if/task.md b/1-js/06-advanced-functions/03-closure/5-function-in-if/task.md
index 4e386eec5..ac1c4a7d8 100644
--- a/1-js/06-advanced-functions/03-closure/5-function-in-if/task.md
+++ b/1-js/06-advanced-functions/03-closure/5-function-in-if/task.md
@@ -1,9 +1,9 @@
 importance: 5
 
 ---
-# Function in if
+# ฟังก์ชันใน if
 
-Look at the code. What will be the result of the call at the last line?
+ดูโค้ดนี้ ผลลัพธ์ของการเรียกบรรทัดสุดท้ายจะเป็นอะไร?
 
 ```js run
 let phrase = "Hello";
diff --git a/1-js/06-advanced-functions/03-closure/6-closure-sum/solution.md b/1-js/06-advanced-functions/03-closure/6-closure-sum/solution.md
index a6679cd20..cd5bcbc24 100644
--- a/1-js/06-advanced-functions/03-closure/6-closure-sum/solution.md
+++ b/1-js/06-advanced-functions/03-closure/6-closure-sum/solution.md
@@ -1,12 +1,12 @@
-For the second parentheses to work, the first ones must return a function.
+วงเล็บชั้นที่สองจะทำงานได้ วงเล็บชั้นแรกต้องคืนค่าเป็นฟังก์ชัน
 
-Like this:
+แบบนี้:
 
 ```js run
 function sum(a) {
 
   return function(b) {
-    return a + b; // takes "a" from the outer lexical environment
+    return a + b; // ดึงค่า "a" จาก Lexical Environment ชั้นนอก
   };
 
 }
diff --git a/1-js/06-advanced-functions/03-closure/6-closure-sum/task.md b/1-js/06-advanced-functions/03-closure/6-closure-sum/task.md
index b45758562..31b702549 100644
--- a/1-js/06-advanced-functions/03-closure/6-closure-sum/task.md
+++ b/1-js/06-advanced-functions/03-closure/6-closure-sum/task.md
@@ -2,13 +2,13 @@ importance: 4
 
 ---
 
-# Sum with closures
+# บวกเลขด้วยคลอเชอร์
 
-Write function `sum` that works like this: `sum(a)(b) = a+b`.
+เขียนฟังก์ชัน `sum` ที่ทำงานแบบนี้: `sum(a)(b) = a+b`
 
-Yes, exactly this way, using double parentheses (not a mistype).
+ใช่แล้ว เรียกด้วยวงเล็บสองชั้นแบบนี้เลย (ไม่ได้พิมพ์ผิด)
 
-For instance:
+ยกตัวอย่าง:
 
 ```js
 sum(1)(2) = 3
diff --git a/1-js/06-advanced-functions/03-closure/7-let-scope/solution.md b/1-js/06-advanced-functions/03-closure/7-let-scope/solution.md
index b16b35290..89c253f22 100644
--- a/1-js/06-advanced-functions/03-closure/7-let-scope/solution.md
+++ b/1-js/06-advanced-functions/03-closure/7-let-scope/solution.md
@@ -1,6 +1,6 @@
-The result is: **error**.
+ผลลัพธ์คือ: **error**
 
-Try running it:
+ลองรันดู:
 
 ```js run
 let x = 1;
@@ -15,20 +15,20 @@ function func() {
 func();
 ```
 
-In this example we can observe the peculiar difference between a "non-existing" and "uninitialized" variable.
+ตัวอย่างนี้แสดงให้เห็นความแตกต่างระหว่างตัวแปรที่ "ไม่มีอยู่" กับ "ยังไม่ได้ initialize"
 
-As you may have read in the article [](info:closure), a variable starts in the "uninitialized" state from the moment when the execution enters a code block (or a function). And it stays uninitalized until the corresponding `let` statement.
+อย่างที่อาจอ่านมาแล้วในบทความ [](info:closure) ตัวแปรจะเริ่มต้นในสถานะ "uninitialized" ตั้งแต่เมื่อการทำงานเข้าสู่บล็อกโค้ด (หรือฟังก์ชัน) และจะอยู่ในสถานะนี้จนกว่าจะถึงคำสั่ง `let` ที่ประกาศมัน
 
-In other words, a variable technically exists, but can't be used before `let`.
+พูดง่ายๆ ก็คือ ตัวแปรมีอยู่ในทางเทคนิค แต่ยังใช้ไม่ได้จนกว่าจะถึงบรรทัด `let`
 
-The code above demonstrates it.
+โค้ดด้านบนแสดงให้เห็นจุดนี้
 
 ```js
 function func() {
 *!*
-  // the local variable x is known to the engine from the beginning of the function,
-  // but "uninitialized" (unusable) until let ("dead zone")
-  // hence the error
+  // engine รู้ว่ามีตัวแปร x ตั้งแต่เริ่มฟังก์ชัน
+  // แต่อยู่ในสถานะ "uninitialized" (ใช้ไม่ได้) จนกว่าจะถึง let ("dead zone")
+  // จึงเกิด error
 */!*
 
   console.log(x); // ReferenceError: Cannot access 'x' before initialization
@@ -37,4 +37,4 @@ function func() {
 }
 ```
 
-This zone of temporary unusability of a variable (from the beginning of the code block till `let`) is sometimes called the "dead zone".
+โซนที่ตัวแปรใช้ไม่ได้ชั่วคราวนี้ (ตั้งแต่ต้นบล็อกจนถึง `let`) บางทีเรียกว่า "dead zone"
diff --git a/1-js/06-advanced-functions/03-closure/7-let-scope/task.md b/1-js/06-advanced-functions/03-closure/7-let-scope/task.md
index fb7445e66..351f8d306 100644
--- a/1-js/06-advanced-functions/03-closure/7-let-scope/task.md
+++ b/1-js/06-advanced-functions/03-closure/7-let-scope/task.md
@@ -2,9 +2,9 @@ importance: 4
 
 ---
 
-# Is variable visible?
+# ตัวแปรมองเห็นไหม?
 
-What will be the result of this code?
+โค้ดนี้จะให้ผลลัพธ์อะไร?
 
 ```js
 let x = 1;
@@ -18,4 +18,4 @@ function func() {
 func();
 ```
 
-P.S. There's a pitfall in this task. The solution is not obvious.
+ป.ล. โจทย์ข้อนี้มีกับดัก คำตอบอาจไม่ตรงตามที่คิดไว้
diff --git a/1-js/06-advanced-functions/03-closure/8-filter-through-function/_js.view/source.js b/1-js/06-advanced-functions/03-closure/8-filter-through-function/_js.view/source.js
index 74989df28..bba19d1db 100644
--- a/1-js/06-advanced-functions/03-closure/8-filter-through-function/_js.view/source.js
+++ b/1-js/06-advanced-functions/03-closure/8-filter-through-function/_js.view/source.js
@@ -2,9 +2,9 @@
 let arr = [1, 2, 3, 4, 5, 6, 7];
 
 function inBetween(a, b) {
-  // ...your code...
+  // ...โค้ดของคุณ...
 }
 
 function inArray(arr) {
-  // ...your code...
+  // ...โค้ดของคุณ...
 }
diff --git a/1-js/06-advanced-functions/03-closure/8-filter-through-function/task.md b/1-js/06-advanced-functions/03-closure/8-filter-through-function/task.md
index d1c39f949..09ec5df79 100644
--- a/1-js/06-advanced-functions/03-closure/8-filter-through-function/task.md
+++ b/1-js/06-advanced-functions/03-closure/8-filter-through-function/task.md
@@ -2,24 +2,24 @@ importance: 5
 
 ---
 
-# Filter through function
+# กรองข้อมูลผ่านฟังก์ชัน
 
-We have a built-in method `arr.filter(f)` for arrays. It filters all elements through the function `f`. If it returns `true`, then that element is returned in the resulting array.
+เรามีเมธอด `arr.filter(f)` สำหรับอาร์เรย์ ซึ่งกรองสมาชิกทั้งหมดผ่านฟังก์ชัน `f` ถ้าคืนค่า `true` สมาชิกนั้นจะถูกรวมไว้ในอาร์เรย์ผลลัพธ์
 
-Make a set of "ready to use" filters:
+จงสร้างชุดฟังก์ชันกรอง "สำเร็จรูป" ดังนี้:
 
-- `inBetween(a, b)` -- between `a` and `b` or equal to them (inclusively).
-- `inArray([...])` -- in the given array.
+- `inBetween(a, b)` -- กรองค่าที่อยู่ระหว่าง `a` ถึง `b` รวมค่าขอบด้วย
+- `inArray([...])` -- กรองค่าที่อยู่ในอาร์เรย์ที่กำหนด
 
-The usage must be like this:
+ใช้งานแบบนี้:
 
-- `arr.filter(inBetween(3,6))` -- selects only values between 3 and 6.
-- `arr.filter(inArray([1,2,3]))` -- selects only elements matching with one of the members of `[1,2,3]`.
+- `arr.filter(inBetween(3,6))` -- เลือกเฉพาะค่าที่อยู่ระหว่าง 3 ถึง 6
+- `arr.filter(inArray([1,2,3]))` -- เลือกเฉพาะสมาชิกที่ตรงกับค่าใน `[1,2,3]`
 
-For instance:
+ยกตัวอย่าง:
 
 ```js
-/* .. your code for inBetween and inArray */
+/* .. โค้ดของ inBetween และ inArray */
 let arr = [1, 2, 3, 4, 5, 6, 7];
 
 alert( arr.filter(inBetween(3, 6)) ); // 3,4,5,6
diff --git a/1-js/06-advanced-functions/03-closure/9-sort-by-field/_js.view/source.js b/1-js/06-advanced-functions/03-closure/9-sort-by-field/_js.view/source.js
index 23b433834..68c182f82 100644
--- a/1-js/06-advanced-functions/03-closure/9-sort-by-field/_js.view/source.js
+++ b/1-js/06-advanced-functions/03-closure/9-sort-by-field/_js.view/source.js
@@ -1,5 +1,5 @@
 function byField(fieldName){
 
-  // Your code goes here.
+  // เขียนโค้ดตรงนี้
 
 }
diff --git a/1-js/06-advanced-functions/03-closure/9-sort-by-field/task.md b/1-js/06-advanced-functions/03-closure/9-sort-by-field/task.md
index 08fb5cc34..752a9a1da 100644
--- a/1-js/06-advanced-functions/03-closure/9-sort-by-field/task.md
+++ b/1-js/06-advanced-functions/03-closure/9-sort-by-field/task.md
@@ -2,9 +2,9 @@ importance: 5
 
 ---
 
-# Sort by field
+# เรียงลำดับตามฟิลด์
 
-We've got an array of objects to sort:
+เรามีอาร์เรย์ของออบเจ็กต์ที่ต้องการเรียงลำดับ:
 
 ```js
 let users = [
@@ -14,23 +14,23 @@ let users = [
 ];
 ```
 
-The usual way to do that would be:
+วิธีปกติที่ทำกันคือ:
 
 ```js
-// by name (Ann, John, Pete)
+// เรียงตามชื่อ (Ann, John, Pete)
 users.sort((a, b) => a.name > b.name ? 1 : -1);
 
-// by age (Pete, Ann, John)
+// เรียงตามอายุ (Pete, Ann, John)
 users.sort((a, b) => a.age > b.age ? 1 : -1);
 ```
 
-Can we make it even less verbose, like this?
+จะทำให้กระชับกว่านี้ได้ไหม แบบนี้?
 
 ```js
 users.sort(byField('name'));
 users.sort(byField('age'));
 ```
 
-So, instead of writing a function, just put `byField(fieldName)`.
+คือแทนที่จะเขียนฟังก์ชันเอง แค่ใส่ `byField(fieldName)` ไปเลย
 
-Write the function `byField` that can be used for that.
+จงเขียนฟังก์ชัน `byField` ที่ใช้แบบนี้ได้
diff --git a/1-js/06-advanced-functions/03-closure/article.md b/1-js/06-advanced-functions/03-closure/article.md
index cb43a7968..dc9a5a69f 100644
--- a/1-js/06-advanced-functions/03-closure/article.md
+++ b/1-js/06-advanced-functions/03-closure/article.md
@@ -1,35 +1,35 @@
 
-# Variable scope, closure
+# สโคปของตัวแปรและคลอเชอร์ (Closure)
 
-JavaScript is a very function-oriented language. It gives us a lot of freedom. A function can be created at any moment, passed as an argument to another function, and then called from a totally different place of code later.
+JavaScript เป็นภาษาที่เน้นการใช้งานฟังก์ชันเป็นหลัก เราสร้างฟังก์ชันได้ทุกเมื่อ ส่งผ่านเป็นอาร์กิวเมนต์ให้ฟังก์ชันอื่น แล้วค่อยเรียกใช้ทีหลังจากที่อื่นในโค้ดก็ได้
 
-We already know that a function can access variables outside of it ("outer" variables).
+จากที่เราเรียนมาแล้ว ฟังก์ชันสามารถเข้าถึงตัวแปรภายนอก ("outer" variables) ได้
 
-But what happens if outer variables change since a function is created? Will the function get newer values or the old ones?
+แต่ถ้าตัวแปรภายนอกเปลี่ยนค่าไปหลังจากสร้างฟังก์ชันแล้วล่ะ? ฟังก์ชันจะได้ค่าใหม่หรือค่าเก่า?
 
-And what if a function is passed along as an argument and called from another place of code, will it get access to outer variables at the new place?
+แล้วถ้าส่งฟังก์ชันไปเป็นอาร์กิวเมนต์ แล้วเรียกใช้จากที่อื่นในโค้ด จะยังเข้าถึงตัวแปรภายนอกจากที่ใหม่ได้ไหม?
 
-Let's expand our knowledge to understand these scenarios and more complex ones.
+มาขยายความรู้เพื่อทำความเข้าใจสถานการณ์เหล่านี้ รวมถึงกรณีที่ซับซ้อนกว่ากัน
 
-```smart header="We'll talk about `let/const` variables here"
-In JavaScript, there are 3 ways to declare a variable: `let`, `const` (the modern ones), and `var` (the remnant of the past).
+```smart header="บทความนี้จะพูดถึงตัวแปร `let/const`"
+ใน JavaScript มีวิธีประกาศตัวแปรอยู่ 3 แบบ คือ `let`, `const` (แบบใหม่) และ `var` (ตกค้างจากยุคเก่า)
 
-- In this article we'll use `let` variables in examples.
-- Variables, declared with `const`, behave the same, so this article is about `const` too.
-- The old `var` has some notable differences, they will be covered in the article <info:var>.
+- ในบทความนี้เราจะใช้ `let` ในตัวอย่างเป็นหลัก
+- ตัวแปรที่ประกาศด้วย `const` ก็ทำงานเหมือนกัน ดังนั้นบทความนี้ครอบคลุม `const` ด้วยเช่นกัน
+- `var` แบบเก่ามีความแตกต่างที่สำคัญบางประการ จะอธิบายเพิ่มในบทความ <info:var>
 ```
 
-## Code blocks
+## บล็อกของโค้ด (Code blocks)
 
-If a variable is declared inside a code block `{...}`, it's only visible inside that block.
+ถ้าประกาศตัวแปรภายในบล็อกโค้ด `{...}` ตัวแปรนั้นจะมองเห็นได้แค่ภายในบล็อกนั้นเท่านั้น
 
-For example:
+ยกตัวอย่าง:
 
 ```js run
 {
-  // do some job with local variables that should not be seen outside
+  // ทำงานบางอย่างกับตัวแปรภายในที่ไม่ควรเห็นจากข้างนอก
 
-  let message = "Hello"; // only visible in this block
+  let message = "Hello"; // มองเห็นได้แค่ในบล็อกนี้
 
   alert(message); // Hello
 }
@@ -37,31 +37,31 @@ For example:
 alert(message); // Error: message is not defined
 ```
 
-We can use this to isolate a piece of code that does its own task, with variables that only belong to it:
+เราใช้วิธีนี้เพื่อแยกส่วนของโค้ดที่ทำงานเฉพาะของมันออกมา โดยมีตัวแปรที่ใช้เฉพาะภายในบล็อกนั้น:
 
 ```js run
 {
-  // show message
+  // แสดงข้อความ
   let message = "Hello";
   alert(message);
 }
 
 {
-  // show another message
+  // แสดงข้อความอีกอัน
   let message = "Goodbye";
   alert(message);
 }
 ```
 
-````smart header="There'd be an error without blocks"
-Please note, without separate blocks there would be an error, if we use `let` with the existing variable name:
+````smart header="ถ้าไม่มีบล็อกจะเกิด error"
+โปรดสังเกตว่า ถ้าไม่แยกเป็นบล็อก จะเกิด error เมื่อใช้ `let` กับชื่อตัวแปรที่มีอยู่แล้ว:
 
 ```js run
-// show message
+// แสดงข้อความ
 let message = "Hello";
 alert(message);
 
-// show another message
+// แสดงข้อความอีกอัน
 *!*
 let message = "Goodbye"; // Error: variable already declared
 */!*
@@ -69,7 +69,7 @@ alert(message);
 ```
 ````
 
-For `if`, `for`, `while` and so on, variables declared in `{...}` are also only visible inside:
+สำหรับ `if`, `for`, `while` และอื่นๆ ตัวแปรที่ประกาศใน `{...}` ก็มองเห็นได้แค่ข้างในเช่นกัน:
 
 ```js run
 if (true) {
@@ -81,35 +81,35 @@ if (true) {
 alert(phrase); // Error, no such variable!
 ```
 
-Here, after `if` finishes, the `alert` below won't see the `phrase`, hence the error.
+ในที่นี้ หลังจาก `if` ทำงานเสร็จ `alert` ด้านล่างจะมองไม่เห็น `phrase` จึงเกิด error
 
-That's great, as it allows us to create block-local variables, specific to an `if` branch.
+นี่เป็นสิ่งที่ดี เพราะช่วยให้เราสร้างตัวแปรที่ใช้เฉพาะภายในบล็อก เช่น ตัวแปรที่ใช้เฉพาะในสาขาของ `if`
 
-The similar thing holds true for `for` and `while` loops:
+หลักการเดียวกันนี้ใช้ได้กับลูป `for` และ `while` ด้วย:
 
 ```js run
 for (let i = 0; i < 3; i++) {
-  // the variable i is only visible inside this for
-  alert(i); // 0, then 1, then 2
+  // ตัวแปร i มองเห็นได้แค่ภายใน for นี้
+  alert(i); // 0, จากนั้น 1, จากนั้น 2
 }
 
 alert(i); // Error, no such variable
 ```
 
-Visually, `let i` is outside of `{...}`. But the `for` construct is special here: the variable, declared inside it, is considered a part of the block.
+ถึงแม้ `let i` จะดูเหมือนอยู่นอก `{...}` แต่โครงสร้าง `for` เป็นกรณีพิเศษ ตัวแปรที่ประกาศข้างในถือว่าเป็นส่วนหนึ่งของบล็อก
 
-## Nested functions
+## ฟังก์ชันซ้อน (Nested functions)
 
-A function is called "nested" when it is created inside another function.
+ฟังก์ชันที่สร้างขึ้นภายในฟังก์ชันอื่น เราเรียกว่า "ฟังก์ชันซ้อน" (nested function)
 
-It is easily possible to do this with JavaScript.
+ใน JavaScript ทำแบบนี้ได้ง่ายมาก
 
-We can use it to organize our code, like this:
+เราใช้เพื่อจัดระเบียบโค้ดได้ เช่นแบบนี้:
 
 ```js
 function sayHiBye(firstName, lastName) {
 
-  // helper nested function to use below
+  // ฟังก์ชันซ้อนที่เป็นตัวช่วย
   function getFullName() {
     return firstName + " " + lastName;
   }
@@ -120,11 +120,11 @@ function sayHiBye(firstName, lastName) {
 }
 ```
 
-Here the *nested* function `getFullName()` is made for convenience. It can access the outer variables and so can return the full name. Nested functions are quite common in JavaScript.
+ตรงนี้ฟังก์ชันซ้อน `getFullName()` ถูกสร้างขึ้นเพื่อความสะดวก มันเข้าถึงตัวแปรภายนอกได้ จึงคืนค่าชื่อเต็มได้ ฟังก์ชันซ้อนเป็นสิ่งที่พบได้บ่อยมากใน JavaScript
 
-What's much more interesting, a nested function can be returned: either as a property of a new object or as a result by itself. It can then be used somewhere else. No matter where, it still has access to the same outer variables.
+สิ่งที่น่าสนใจกว่านั้นคือ ฟังก์ชันซ้อนสามารถถูก return ออกมาได้ ไม่ว่าจะเป็นพร็อพเพอร์ตี้ของออบเจ็กต์ใหม่ หรือเป็นผลลัพธ์โดยตรง จากนั้นจะนำไปใช้ที่อื่นก็ได้ ไม่ว่าจะเรียกจากที่ไหน มันยังเข้าถึงตัวแปรภายนอกเดิมได้เสมอ
 
-Below, `makeCounter` creates the "counter" function that returns the next number on each invocation:
+ตัวอย่างด้านล่าง `makeCounter` สร้างฟังก์ชัน "ตัวนับ" ที่คืนค่าตัวเลขถัดไปทุกครั้งที่เรียก:
 
 ```js run
 function makeCounter() {
@@ -142,87 +142,87 @@ alert( counter() ); // 1
 alert( counter() ); // 2
 ```
 
-Despite being simple, slightly modified variants of that code have practical uses, for instance, as a [random number generator](https://en.wikipedia.org/wiki/Pseudorandom_number_generator) to generate random values for automated tests.
+แม้จะเป็นโค้ดง่ายๆ แต่ถ้าดัดแปลงนิดหน่อยก็นำไปใช้งานจริงได้ เช่น เป็น[ตัวสร้างเลขสุ่ม](https://en.wikipedia.org/wiki/Pseudorandom_number_generator)สำหรับสร้างค่าสุ่มในการทดสอบอัตโนมัติ
 
-How does this work? If we create multiple counters, will they be independent? What's going on with the variables here?
+โค้ดนี้ทำงานยังไง? ถ้าสร้างตัวนับหลายตัว แต่ละตัวจะเป็นอิสระจากกันไหม? เกิดอะไรขึ้นกับตัวแปรในนี้?
 
-Understanding such things is great for the overall knowledge of JavaScript and beneficial for more complex scenarios. So let's go a bit in-depth.
+การเข้าใจเรื่องพวกนี้เป็นพื้นฐานสำคัญของ JavaScript และจะมีประโยชน์มากเมื่อเจอสถานการณ์ที่ซับซ้อนขึ้น ดังนั้นมาเจาะลึกกันเลย
 
 ## Lexical Environment
 
-```warn header="Here be dragons!"
-The in-depth technical explanation lies ahead.
+```warn header="เนื้อหาเชิงลึกอยู่ข้างหน้า!"
+เราจะอธิบายรายละเอียดเชิงเทคนิคกันต่อไป
 
-As far as I'd like to avoid low-level language details, any understanding without them would be lacking and incomplete, so get ready.
+แม้จะอยากหลีกเลี่ยงรายละเอียดภาษาระดับต่ำ แต่ถ้าไม่เข้าใจตรงนี้ ความรู้จะไม่ครบถ้วน ดังนั้นเตรียมตัวให้พร้อม
 ```
 
-For clarity, the explanation is split into multiple steps.
+เพื่อให้อธิบายได้ชัดเจน จะแบ่งเป็นหลายขั้นตอน
 
-### Step 1. Variables
+### ขั้นตอนที่ 1: ตัวแปร
 
-In JavaScript, every running function, code block `{...}`, and the script as a whole have an internal (hidden) associated object known as the *Lexical Environment*.
+ใน JavaScript ทุกฟังก์ชันที่กำลังทำงาน ทุกบล็อกโค้ด `{...}` และทั้งสคริปต์ จะมีออบเจ็กต์ภายใน (ซ่อนอยู่) ที่เรียกว่า *Lexical Environment*
 
-The Lexical Environment object consists of two parts:
+ออบเจ็กต์ Lexical Environment ประกอบด้วย 2 ส่วน:
 
-1. *Environment Record* -- an object that stores all local variables as its properties (and some other information like the value of `this`).
-2. A reference to the *outer lexical environment*, the one associated with the outer code.
+1. *Environment Record* -- ออบเจ็กต์ที่เก็บตัวแปรภายในทั้งหมดเป็นพร็อพเพอร์ตี้ (รวมถึงข้อมูลอื่นๆ เช่น ค่าของ `this`)
+2. การอ้างอิงไปยัง *Lexical Environment ภายนอก* ที่เชื่อมกับโค้ดชั้นนอก
 
-**A "variable" is just a property of the special internal object, `Environment Record`. "To get or change a variable" means "to get or change a property of that object".**
+**"ตัวแปร" ก็คือพร็อพเพอร์ตี้หนึ่งของออบเจ็กต์ภายในพิเศษที่ชื่อ `Environment Record` นั่นเอง "การอ่านหรือเปลี่ยนค่าตัวแปร" ก็คือ "การอ่านหรือเปลี่ยนพร็อพเพอร์ตี้ของออบเจ็กต์ตัวนั้น"**
 
-In this simple code without functions, there is only one Lexical Environment:
+ในโค้ดง่ายๆ ที่ไม่มีฟังก์ชัน จะมี Lexical Environment แค่ตัวเดียว:
 
 ![lexical environment](lexical-environment-global.svg)
 
-This is the so-called *global* Lexical Environment, associated with the whole script.
+นี่คือ Lexical Environment แบบ *global* ที่เชื่อมกับทั้งสคริปต์
 
-On the picture above, the rectangle means Environment Record (variable store) and the arrow means the outer reference. The global Lexical Environment has no outer reference, that's why the arrow points to `null`.
+ในรูปด้านบน สี่เหลี่ยมคือ Environment Record (ที่เก็บตัวแปร) และลูกศรคือการอ้างอิงไปยังภายนอก Lexical Environment แบบ global ไม่มีการอ้างอิงภายนอก ลูกศรจึงชี้ไปที่ `null`
 
-As the code starts executing and goes on, the Lexical Environment changes.
+เมื่อโค้ดเริ่มทำงานและดำเนินต่อไป Lexical Environment จะเปลี่ยนแปลงไปเรื่อยๆ
 
-Here's a little bit longer code:
+ลองดูโค้ดที่ยาวขึ้นหน่อย:
 
 ![lexical environment](closure-variable-phrase.svg)
 
-Rectangles on the right-hand side demonstrate how the global Lexical Environment changes during the execution:
+สี่เหลี่ยมด้านขวาแสดงให้เห็นว่า Lexical Environment แบบ global เปลี่ยนแปลงอย่างไรระหว่างการทำงาน:
 
-1. When the script starts, the Lexical Environment is pre-populated with all declared variables.
-    - Initially, they are in the "Uninitialized" state. That's a special internal state, it means that the engine knows about the variable, but it cannot be referenced until it has been declared with `let`. It's almost the same as if the variable didn't exist.
-2. Then `let phrase` definition appears. There's no assignment yet, so its value is `undefined`. We can use the variable from this point forward.
-3. `phrase` is assigned a value.
-4. `phrase` changes the value.
+1. เมื่อสคริปต์เริ่มทำงาน Lexical Environment จะถูกเติมด้วยตัวแปรที่ประกาศไว้ทั้งหมด
+    - ตอนแรกตัวแปรจะอยู่ในสถานะ "Uninitialized" ซึ่งเป็นสถานะภายในพิเศษ หมายความว่า engine รู้ว่ามีตัวแปรนี้อยู่ แต่ยังอ้างอิงไม่ได้จนกว่าจะประกาศด้วย `let` เหมือนกับว่าตัวแปรยังไม่มีอยู่
+2. จากนั้น `let phrase` ปรากฏขึ้น ยังไม่มีการกำหนดค่า จึงเป็น `undefined` ตั้งแต่จุดนี้เป็นต้นไปเราใช้ตัวแปรนี้ได้
+3. `phrase` ถูกกำหนดค่า
+4. `phrase` เปลี่ยนค่า
 
-Everything looks simple for now, right?
+ดูง่ายใช่ไหม?
 
-- A variable is a property of a special internal object, associated with the currently executing block/function/script.
-- Working with variables is actually working with the properties of that object.
+- ตัวแปรคือพร็อพเพอร์ตี้ของออบเจ็กต์ภายในพิเศษ ที่เชื่อมกับบล็อก/ฟังก์ชัน/สคริปต์ที่กำลังทำงานอยู่
+- การทำงานกับตัวแปรก็คือการทำงานกับพร็อพเพอร์ตี้ของออบเจ็กต์ตัวนั้น
 
-```smart header="Lexical Environment is a specification object"
-"Lexical Environment" is a specification object: it only exists "theoretically" in the [language specification](https://tc39.es/ecma262/#sec-lexical-environments) to describe how things work. We can't get this object in our code and manipulate it directly.
+```smart header="Lexical Environment เป็นออบเจ็กต์ตามสเปก"
+"Lexical Environment" เป็นออบเจ็กต์ตามสเปกของภาษา (specification object) มีอยู่แค่ "ในทางทฤษฎี" ตาม[สเปกของภาษา](https://tc39.es/ecma262/#sec-lexical-environments)เพื่ออธิบายว่าสิ่งต่างๆ ทำงานอย่างไร เราไม่สามารถเข้าถึงออบเจ็กต์นี้ในโค้ดและจัดการโดยตรงได้
 
-JavaScript engines also may optimize it, discard variables that are unused to save memory and perform other internal tricks, as long as the visible behavior remains as described.
+JavaScript engine อาจปรับแต่งการทำงาน เช่น ตัดตัวแปรที่ไม่ได้ใช้ออกเพื่อประหยัดหน่วยความจำ หรือทำเทคนิคอื่นๆ ภายใน ตราบใดที่พฤติกรรมที่มองเห็นยังคงเป็นไปตามที่อธิบายไว้
 ```
 
-### Step 2. Function Declarations
+### ขั้นตอนที่ 2: Function Declaration
 
-A function is also a value, like a variable.
+ฟังก์ชันก็เป็นค่าตัวหนึ่ง เหมือนกับตัวแปร
 
-**The difference is that a Function Declaration is instantly fully initialized.**
+**ข้อแตกต่างคือ Function Declaration จะถูกเตรียมพร้อมใช้งานทันที**
 
-When a Lexical Environment is created, a Function Declaration immediately becomes a ready-to-use function (unlike `let`, that is unusable till the declaration).
+เมื่อสร้าง Lexical Environment ขึ้นมา Function Declaration จะกลายเป็นฟังก์ชันที่พร้อมใช้ทันที (ต่างจาก `let` ที่ใช้ไม่ได้จนกว่าจะถึงบรรทัดที่ประกาศ)
 
-That's why we can use a function, declared as Function Declaration, even before the declaration itself.
+นั่นเป็นเหตุผลว่าทำไมเราถึงเรียกใช้ฟังก์ชันที่ประกาศแบบ Function Declaration ได้ก่อนที่จะถึงบรรทัดประกาศ
 
-For example, here's the initial state of the global Lexical Environment when we add a function:
+ตัวอย่างเช่น สถานะเริ่มต้นของ Lexical Environment แบบ global เมื่อเราเพิ่มฟังก์ชันเข้ามา:
 
 ![](closure-function-declaration.svg)
 
-Naturally, this behavior only applies to Function Declarations, not Function Expressions where we assign a function to a variable, such as `let say = function(name)...`.
+แน่นอนว่าพฤติกรรมนี้ใช้ได้กับ Function Declaration เท่านั้น ไม่ใช่ Function Expression ที่เราใส่ฟังก์ชันให้กับตัวแปร เช่น `let say = function(name)...`
 
-### Step 3. Inner and outer Lexical Environment
+### ขั้นตอนที่ 3: Lexical Environment ชั้นในและชั้นนอก
 
-When a function runs, at the beginning of the call, a new Lexical Environment is created automatically to store local variables and parameters of the call.
+เมื่อฟังก์ชันทำงาน ณ ตอนเริ่มต้นการเรียก จะมี Lexical Environment ใหม่ถูกสร้างขึ้นโดยอัตโนมัติเพื่อเก็บตัวแปรภายในฟังก์ชันและพารามิเตอร์
 
-For instance, for `say("John")`, it looks like this (the execution is at the line, labelled with an arrow):
+ยกตัวอย่าง เมื่อเรียก `say("John")` จะเป็นแบบนี้ (การทำงานอยู่ที่บรรทัดที่มีลูกศรกำกับ):
 
 <!--
     ```js
@@ -237,28 +237,28 @@ For instance, for `say("John")`, it looks like this (the execution is at the lin
 
 ![](lexical-environment-simple.svg)
 
-During the function call we have two Lexical Environments: the inner one (for the function call) and the outer one (global):
+ระหว่างที่ฟังก์ชันทำงาน จะมี Lexical Environment 2 ตัว คือ ตัวชั้นใน (ของฟังก์ชัน) กับตัวชั้นนอก (global):
 
-- The inner Lexical Environment corresponds to the current execution of `say`. It has a single property: `name`, the function argument. We called `say("John")`, so the value of the `name` is `"John"`.
-- The outer Lexical Environment is the global Lexical Environment. It has the `phrase` variable and the function itself.
+- Lexical Environment ชั้นในตรงกับการทำงานปัจจุบันของ `say` มีพร็อพเพอร์ตี้ตัวเดียวคือ `name` ซึ่งเป็นอาร์กิวเมนต์ของฟังก์ชัน เราเรียก `say("John")` ดังนั้นค่าของ `name` จึงเป็น `"John"`
+- Lexical Environment ชั้นนอกคือ Lexical Environment แบบ global ที่มีตัวแปร `phrase` และตัวฟังก์ชันเอง
 
-The inner Lexical Environment has a reference to the `outer` one.
+Lexical Environment ชั้นในมีการอ้างอิงไปยัง `outer` (ชั้นนอก)
 
-**When the code wants to access a variable -- the inner Lexical Environment is searched first, then the outer one, then the more outer one and so on until the global one.**
+**เมื่อโค้ดต้องการเข้าถึงตัวแปร จะค้นหาจาก Lexical Environment ชั้นในก่อน จากนั้นชั้นนอก แล้วก็ชั้นนอกถัดไปเรื่อยๆ จนถึงระดับ global**
 
-If a variable is not found anywhere, that's an error in strict mode (without `use strict`, an assignment to a non-existing variable creates a new global variable, for compatibility with old code).
+ถ้าหาตัวแปรไม่เจอเลย ในโหมด strict จะเกิด error (ถ้าไม่ได้ใช้ `use strict` การกำหนดค่าให้ตัวแปรที่ไม่มีอยู่จะสร้างตัวแปร global ขึ้นมาใหม่ เพื่อรองรับโค้ดเก่า)
 
-In this example the search proceeds as follows:
+ในตัวอย่างนี้ การค้นหาเป็นดังนี้:
 
-- For the `name` variable, the `alert` inside `say` finds it immediately in the inner Lexical Environment.
-- When it wants to access `phrase`, then there is no `phrase` locally, so it follows the reference to the outer Lexical Environment and finds it there.
+- ตัวแปร `name` -- `alert` ภายใน `say` พบได้ทันทีใน Lexical Environment ชั้นใน
+- ตัวแปร `phrase` -- ไม่มีอยู่ในชั้นใน จึงไล่ตามการอ้างอิงไปยัง Lexical Environment ชั้นนอก และพบที่นั่น
 
 ![lexical environment lookup](lexical-environment-simple-lookup.svg)
 
 
-### Step 4. Returning a function
+### ขั้นตอนที่ 4: การ return ฟังก์ชัน
 
-Let's return to the `makeCounter` example.
+กลับมาที่ตัวอย่าง `makeCounter` กัน
 
 ```js
 function makeCounter() {
@@ -272,53 +272,53 @@ function makeCounter() {
 let counter = makeCounter();
 ```
 
-At the beginning of each `makeCounter()` call, a new Lexical Environment object is created, to store variables for this `makeCounter` run.
+ทุกครั้งที่เรียก `makeCounter()` จะสร้าง Lexical Environment ใหม่ขึ้นมาเพื่อเก็บตัวแปรของการเรียกครั้งนั้น
 
-So we have two nested Lexical Environments, just like in the example above:
+เราจึงมี Lexical Environment ซ้อนกัน 2 ชั้น เหมือนตัวอย่างก่อนหน้า:
 
 ![](closure-makecounter.svg)
 
-What's different is that, during the execution of `makeCounter()`, a tiny nested function is created of only one line: `return count++`. We don't run it yet, only create.
+สิ่งที่ต่างออกไปคือ ระหว่างที่ `makeCounter()` ทำงาน จะสร้างฟังก์ชันเล็กๆ แค่บรรทัดเดียว `return count++` ขึ้นมา แต่ยังไม่ได้รัน แค่สร้างเฉยๆ
 
-All functions remember the Lexical Environment in which they were made. Technically, there's no magic here: all functions have the hidden property named `[[Environment]]`, that keeps the reference to the Lexical Environment where the function was created:
+ฟังก์ชันทุกตัวจะจดจำ Lexical Environment ที่มันถูกสร้างขึ้น ไม่มีอะไรมหัศจรรย์ ฟังก์ชันทุกตัวมีพร็อพเพอร์ตี้ซ่อน `[[Environment]]` ที่เก็บการอ้างอิงไปยัง Lexical Environment ที่ฟังก์ชันถูกสร้าง:
 
 ![](closure-makecounter-environment.svg)
 
-So, `counter.[[Environment]]` has the reference to `{count: 0}` Lexical Environment. That's how the function remembers where it was created, no matter where it's called. The `[[Environment]]` reference is set once and forever at function creation time.
+ดังนั้น `counter.[[Environment]]` จึงอ้างอิงไปยัง Lexical Environment `{count: 0}` นี่คือวิธีที่ฟังก์ชันจดจำว่ามันถูกสร้างที่ไหน ไม่ว่าจะเรียกจากที่ใดก็ตาม การอ้างอิง `[[Environment]]` ถูกตั้งค่าครั้งเดียวตอนสร้างฟังก์ชันแล้วไม่เปลี่ยนอีก
 
-Later, when `counter()` is called, a new Lexical Environment is created for the call, and its outer Lexical Environment reference is taken from `counter.[[Environment]]`:
+ต่อมาเมื่อเรียก `counter()` จะสร้าง Lexical Environment ใหม่สำหรับการเรียกครั้งนั้น และการอ้างอิง Lexical Environment ชั้นนอกจะมาจาก `counter.[[Environment]]`:
 
 ![](closure-makecounter-nested-call.svg)
 
-Now when the code inside `counter()` looks for `count` variable, it first searches its own Lexical Environment (empty, as there are no local variables there), then the Lexical Environment of the outer `makeCounter()` call, where it finds and changes it.
+เมื่อโค้ดภายใน `counter()` หาตัวแปร `count` จะค้นหาจาก Lexical Environment ของตัวเองก่อน (ว่างเปล่า เพราะไม่มีตัวแปรภายใน) จากนั้นจึงค้นหาจาก Lexical Environment ของ `makeCounter()` ชั้นนอก ซึ่งพบและแก้ไขค่าที่นั่น
 
-**A variable is updated in the Lexical Environment where it lives.**
+**ตัวแปรจะถูกอัปเดตใน Lexical Environment ที่มันอาศัยอยู่**
 
-Here's the state after the execution:
+นี่คือสถานะหลังทำงานเสร็จ:
 
 ![](closure-makecounter-nested-call-2.svg)
 
-If we call `counter()` multiple times, the `count` variable will be increased to `2`, `3` and so on, at the same place.
+ถ้าเรียก `counter()` หลายครั้ง ตัวแปร `count` จะเพิ่มเป็น `2`, `3` ไปเรื่อยๆ ที่ตำแหน่งเดิม
 
-```smart header="Closure"
-There is a general programming term "closure", that developers generally should know.
+```smart header="คลอเชอร์ (Closure)"
+มีศัพท์ทั่วไปในการเขียนโปรแกรมคำหนึ่งคือ "คลอเชอร์" (closure) ที่นักพัฒนาควรรู้จัก
 
-A [closure](https://en.wikipedia.org/wiki/Closure_(computer_programming)) is a function that remembers its outer variables and can access them. In some languages, that's not possible, or a function should be written in a special way to make it happen. But as explained above, in JavaScript, all functions are naturally closures (there is only one exception, to be covered in <info:new-function>).
+[คลอเชอร์](https://en.wikipedia.org/wiki/Closure_(computer_programming)) คือฟังก์ชันที่จดจำตัวแปรภายนอกและเข้าถึงได้ ในบางภาษาทำแบบนี้ไม่ได้ หรือต้องเขียนฟังก์ชันแบบพิเศษถึงจะทำได้ แต่ใน JavaScript ฟังก์ชันทุกตัวเป็นคลอเชอร์โดยธรรมชาติ (มีข้อยกเว้นเดียวที่จะอธิบายใน <info:new-function>)
 
-That is: they automatically remember where they were created using a hidden `[[Environment]]` property, and then their code can access outer variables.
+กล่าวคือ ฟังก์ชันจดจำว่าถูกสร้างที่ไหนโดยอัตโนมัติผ่านพร็อพเพอร์ตี้ซ่อน `[[Environment]]` แล้วโค้ดของมันก็เข้าถึงตัวแปรภายนอกได้
 
-When on an interview, a frontend developer gets a question about "what's a closure?", a valid answer would be a definition of the closure and an explanation that all functions in JavaScript are closures, and maybe a few more words about technical details: the `[[Environment]]` property and how Lexical Environments work.
+เวลาสัมภาษณ์งาน ถ้าถูกถามว่า "คลอเชอร์คืออะไร?" คำตอบที่ดีคือ อธิบายนิยามของคลอเชอร์ พร้อมกับบอกว่าฟังก์ชันทุกตัวใน JavaScript เป็นคลอเชอร์ แล้วอาจเสริมรายละเอียดทางเทคนิคเกี่ยวกับพร็อพเพอร์ตี้ `[[Environment]]` และการทำงานของ Lexical Environment อีกเล็กน้อย
 ```
 
-## Garbage collection
+## การเก็บขยะ (Garbage collection)
 
-Usually, a Lexical Environment is removed from memory with all the variables after the function call finishes. That's because there are no references to it. As any JavaScript object, it's only kept in memory while it's reachable.
+โดยปกติ Lexical Environment จะถูกลบออกจากหน่วยความจำพร้อมกับตัวแปรทั้งหมด หลังจากฟังก์ชันทำงานเสร็จ เพราะไม่มีการอ้างอิงถึงอีกแล้ว เหมือนกับออบเจ็กต์ JavaScript ทั่วไปที่จะอยู่ในหน่วยความจำก็ต่อเมื่อยังมีการอ้างอิงถึง
 
-However, if there's a nested function that is still reachable after the end of a function, then it has `[[Environment]]` property that references the lexical environment.
+อย่างไรก็ตาม ถ้ามีฟังก์ชันซ้อนที่ยังเข้าถึงได้หลังจากฟังก์ชันหลักทำงานเสร็จ มันจะมีพร็อพเพอร์ตี้ `[[Environment]]` ที่อ้างอิงไปยัง Lexical Environment
 
-In that case the Lexical Environment is still reachable even after the completion of the function, so it stays alive.
+ในกรณีนั้น Lexical Environment ยังคงเข้าถึงได้แม้ฟังก์ชันจะทำงานเสร็จแล้ว จึงยังคงอยู่ในหน่วยความจำ
 
-For example:
+ยกตัวอย่าง:
 
 ```js
 function f() {
@@ -329,11 +329,11 @@ function f() {
   }
 }
 
-let g = f(); // g.[[Environment]] stores a reference to the Lexical Environment
-// of the corresponding f() call
+let g = f(); // g.[[Environment]] เก็บการอ้างอิงไปยัง Lexical Environment
+// ของการเรียก f() ครั้งนั้น
 ```
 
-Please note that if `f()` is called many times, and resulting functions are saved, then all corresponding Lexical Environment objects will also be retained in memory. In the code below, all 3 of them:
+สังเกตว่าถ้าเรียก `f()` หลายครั้ง แล้วเก็บฟังก์ชันที่ได้ไว้ Lexical Environment ของแต่ละครั้งก็จะยังคงอยู่ในหน่วยความจำด้วย ในโค้ดด้านล่างมีทั้งหมด 3 ตัว:
 
 ```js
 function f() {
@@ -342,14 +342,14 @@ function f() {
   return function() { alert(value); };
 }
 
-// 3 functions in array, every one of them links to Lexical Environment
-// from the corresponding f() run
+// ฟังก์ชัน 3 ตัวในอาร์เรย์ แต่ละตัวเชื่อมไปยัง Lexical Environment
+// ของการเรียก f() แต่ละครั้ง
 let arr = [f(), f(), f()];
 ```
 
-A Lexical Environment object dies when it becomes unreachable (just like any other object). In other words, it exists only while there's at least one nested function referencing it.
+ออบเจ็กต์ Lexical Environment จะถูกลบเมื่อไม่มีอะไรอ้างอิงถึงอีกแล้ว (เหมือนออบเจ็กต์ทั่วไป) พูดง่ายๆ ก็คือ มันจะมีอยู่ตราบใดที่ยังมีฟังก์ชันซ้อนอย่างน้อยหนึ่งตัวที่อ้างอิงถึง
 
-In the code below, after the nested function is removed, its enclosing Lexical Environment (and hence the `value`) is cleaned from memory:
+ในโค้ดด้านล่าง หลังจากลบฟังก์ชันซ้อนออก Lexical Environment ที่ห่อหุ้มอยู่ (รวมถึง `value`) ก็จะถูกล้างออกจากหน่วยความจำ:
 
 ```js
 function f() {
@@ -360,29 +360,29 @@ function f() {
   }
 }
 
-let g = f(); // while g function exists, the value stays in memory
+let g = f(); // ตราบใดที่ฟังก์ชัน g ยังอยู่ value ก็จะอยู่ในหน่วยความจำ
 
-g = null; // ...and now the memory is cleaned up
+g = null; // ...พอไม่มีการอ้างอิงแล้ว หน่วยความจำก็ถูกล้าง
 ```
 
-### Real-life optimizations
+### การปรับแต่งในการใช้งานจริง
 
-As we've seen, in theory while a function is alive, all outer variables are also retained.
+อย่างที่เราเห็น ในทางทฤษฎี ตราบใดที่ฟังก์ชันยังอยู่ ตัวแปรภายนอกทั้งหมดก็จะถูกเก็บไว้ด้วย
 
-But in practice, JavaScript engines try to optimize that. They analyze variable usage and if it's obvious from the code that an outer variable is not used -- it is removed.
+แต่ในทางปฏิบัติ JavaScript engine พยายามปรับแต่งตรงนี้ โดยวิเคราะห์การใช้งานตัวแปร ถ้าเห็นชัดว่าตัวแปรภายนอกไม่ได้ถูกใช้ ก็จะลบออก
 
-**An important side effect in V8 (Chrome, Edge, Opera) is that such variable will become unavailable in debugging.**
+**ผลข้างเคียงที่สำคัญใน V8 (Chrome, Edge, Opera) คือ ตัวแปรที่ถูกลบจะใช้ไม่ได้ขณะ debug**
 
-Try running the example below in Chrome with the Developer Tools open.
+ลองรันตัวอย่างด้านล่างใน Chrome โดยเปิด Developer Tools
 
-When it pauses, in the console type `alert(value)`.
+เมื่อหยุดที่ debugger ให้ลองพิมพ์ `alert(value)` ในคอนโซล
 
 ```js run
 function f() {
   let value = Math.random();
 
   function g() {
-    debugger; // in console: type alert(value); No such variable!
+    debugger; // ในคอนโซล: พิมพ์ alert(value); จะบอกว่าไม่มีตัวแปรนี้!
   }
 
   return g;
@@ -392,9 +392,9 @@ let g = f();
 g();
 ```
 
-As you could see -- there is no such variable! In theory, it should be accessible, but the engine optimized it out.
+อย่างที่เห็น ตัวแปรหายไป! ในทางทฤษฎีควรเข้าถึงได้ แต่ engine ปรับแต่งออกไปแล้ว
 
-That may lead to funny (if not such time-consuming) debugging issues. One of them -- we can see a same-named outer variable instead of the expected one:
+ปัญหานี้อาจนำไปสู่เรื่องน่าเวียนหัว (ที่อาจเสียเวลา debug) ตอน debug ตัวอย่างเช่น เราอาจเห็นตัวแปรภายนอกที่ชื่อเดียวกันแต่คนละตัวกับที่คาดไว้:
 
 ```js run global
 let value = "Surprise!";
@@ -403,7 +403,7 @@ function f() {
   let value = "the closest value";
 
   function g() {
-    debugger; // in console: type alert(value); Surprise!
+    debugger; // ในคอนโซล: พิมพ์ alert(value); จะได้ Surprise!
   }
 
   return g;
@@ -413,6 +413,6 @@ let g = f();
 g();
 ```
 
-This feature of V8 is good to know. If you are debugging with Chrome/Edge/Opera, sooner or later you will meet it.
+ฟีเจอร์นี้ของ V8 เป็นสิ่งที่ควรรู้ไว้ ถ้า debug ด้วย Chrome/Edge/Opera ไม่ช้าก็เร็วจะเจอ
 
-That is not a bug in the debugger, but rather a special feature of V8. Perhaps it will be changed sometime. You can always check for it by running the examples on this page.
+นี่ไม่ใช่บั๊กของ debugger แต่เป็นฟีเจอร์ของ V8 บางทีในอนาคตอาจมีการเปลี่ยนแปลง สามารถทดสอบได้เสมอโดยรันตัวอย่างในหน้านี้
diff --git a/1-js/06-advanced-functions/04-var/article.md b/1-js/06-advanced-functions/04-var/article.md
index 28d7a76ec..1f90356c4 100644
--- a/1-js/06-advanced-functions/04-var/article.md
+++ b/1-js/06-advanced-functions/04-var/article.md
@@ -1,54 +1,54 @@
 
-# The old "var"
+# "var" แบบเก่า
 
-```smart header="This article is for understanding old scripts"
-The information in this article is useful for understanding old scripts.
+```smart header="บทความนี้มีไว้สำหรับทำความเข้าใจโค้ดเก่า"
+ข้อมูลในบทความนี้จะช่วยให้เข้าใจสคริปต์เก่าๆ ได้
 
-That's not how we write new code.
+แต่ไม่ใช่วิธีที่เราจะเขียนโค้ดใหม่แล้วนะ
 ```
 
-In the very first chapter about [variables](info:variables), we mentioned three ways of variable declaration:
+ในบทแรกๆ เรื่อง[ตัวแปร](info:variables) เราเคยพูดถึงวิธีประกาศตัวแปร 3 แบบด้วยกัน คือ
 
 1. `let`
 2. `const`
 3. `var`
 
-The `var` declaration is similar to `let`. Most of the time we can replace `let` by `var` or vice-versa and expect things to work:
+การประกาศด้วย `var` คล้ายกับ `let` ส่วนใหญ่แล้วเราสามารถสลับใช้ `let` กับ `var` แทนกันได้ และทำงานได้เหมือนกัน:
 
 ```js run
 var message = "Hi";
 alert(message); // Hi
 ```
 
-But internally `var` is a very different beast, that originates from very old times. It's generally not used in modern scripts, but still lurks in the old ones.
+แต่เบื้องหลังแล้ว `var` แตกต่างจาก `let` อย่างมาก เพราะเป็นสิ่งที่หลงเหลือมาจากยุคเก่าของ JavaScript ปัจจุบันไม่ค่อยมีใครใช้ในโค้ดใหม่แล้ว แต่ยังพบได้ในโค้ดเก่าๆ อยู่
 
-If you don't plan on meeting such scripts you may even skip this chapter or postpone it.
+ถ้าไม่ได้วางแผนจะทำงานกับโค้ดเก่าๆ ก็ข้ามบทนี้ไปก่อนได้เลย หรือจะเก็บไว้อ่านทีหลังก็ได้
 
-On the other hand, it's important to understand differences when migrating old scripts from `var` to `let`, to avoid odd errors.
+แต่ถ้าต้องแก้ไขสคริปต์เก่าที่ใช้ `var` ให้เปลี่ยนมาเป็น `let` สิ่งสำคัญคือต้องเข้าใจความแตกต่าง ไม่งั้นอาจเจอ error แปลกๆ ได้
 
-## "var" has no block scope
+## "var" ไม่มีบล็อกสโคป
 
-Variables, declared with `var`, are either function-scoped or global-scoped. They are visible through blocks.
+ตัวแปรที่ประกาศด้วย `var` จะมีสโคปอยู่ระดับฟังก์ชัน หรือไม่ก็เป็นตัวแปร global ทั้งนี้ `var` จะมองทะลุบล็อกไปเลย
 
-For instance:
+ลองดูตัวอย่างนี้:
 
 ```js run
 if (true) {
-  var test = true; // use "var" instead of "let"
+  var test = true; // ใช้ "var" แทน "let"
 }
 
 *!*
-alert(test); // true, the variable lives after if
+alert(test); // true, ตัวแปรยังอยู่หลังจบ if
 */!*
 ```
 
-As `var` ignores code blocks, we've got a global variable `test`.
+เนื่องจาก `var` ไม่สนใจบล็อกโค้ด ตัวแปร `test` จึงกลายเป็นตัวแปร global ไป
 
-If we used `let test` instead of `var test`, then the variable would only be visible inside `if`:
+ถ้าเราใช้ `let test` แทน `var test` ตัวแปรจะมองเห็นได้แค่ภายใน `if` เท่านั้น:
 
 ```js run
 if (true) {
-  let test = true; // use "let"
+  let test = true; // ใช้ "let"
 }
 
 *!*
@@ -56,7 +56,7 @@ alert(test); // ReferenceError: test is not defined
 */!*
 ```
 
-The same thing for loops: `var` cannot be block- or loop-local:
+เช่นเดียวกันกับลูป `var` ไม่สามารถเป็นตัวแปรภายในบล็อกหรือภายในลูปได้:
 
 ```js run
 for (var i = 0; i < 10; i++) {
@@ -65,12 +65,12 @@ for (var i = 0; i < 10; i++) {
 }
 
 *!*
-alert(i);   // 10, "i" is visible after loop, it's a global variable
-alert(one); // 1, "one" is visible after loop, it's a global variable
+alert(i);   // 10, "i" ยังเห็นอยู่หลังจบลูป เพราะเป็นตัวแปร global
+alert(one); // 1, "one" ก็ยังเห็นอยู่หลังจบลูปเช่นกัน
 */!*
 ```
 
-If a code block is inside a function, then `var` becomes a function-level variable:
+แต่ถ้าบล็อกโค้ดอยู่ภายในฟังก์ชัน `var` จะกลายเป็นตัวแปรระดับฟังก์ชัน:
 
 ```js run
 function sayHi() {
@@ -78,42 +78,42 @@ function sayHi() {
     var phrase = "Hello";
   }
 
-  alert(phrase); // works
+  alert(phrase); // ใช้งานได้
 }
 
 sayHi();
 alert(phrase); // ReferenceError: phrase is not defined
 ```
 
-As we can see, `var` pierces through `if`, `for` or other code blocks. That's because a long time ago in JavaScript, blocks had no Lexical Environments, and `var` is a remnant of that.
+จะเห็นว่า `var` ทะลุผ่าน `if`, `for` และบล็อกโค้ดอื่นๆ ได้หมด ที่เป็นแบบนี้เพราะในอดีต JavaScript ไม่มี Lexical Environment ในระดับบล็อก และ `var` ก็เป็นสิ่งที่หลงเหลือจากยุคนั้น
 
-## "var" tolerates redeclarations
+## "var" ประกาศซ้ำได้
 
-If we declare the same variable with `let` twice in the same scope, that's an error:
+ถ้าเราประกาศตัวแปรด้วย `let` สองครั้งในสโคปเดียวกัน จะเกิด error ทันที:
 
 ```js run
 let user;
 let user; // SyntaxError: 'user' has already been declared
 ```
 
-With `var`, we can redeclare a variable any number of times. If we use `var` with an already-declared variable, it's just ignored:
+แต่ `var` ประกาศซ้ำกี่ครั้งก็ได้ ถ้าใช้ `var` กับตัวแปรที่ประกาศไว้แล้ว มันจะข้ามไปเฉยๆ:
 
 ```js run
 var user = "Pete";
 
-var user = "John"; // this "var" does nothing (already declared)
-// ...it doesn't trigger an error
+var user = "John"; // "var" นี้ไม่ทำอะไร (ประกาศไว้แล้ว)
+// ...ไม่เกิด error
 
 alert(user); // John
 ```
 
-## "var" variables can be declared below their use
+## ประกาศตัวแปร "var" ทีหลังก็ได้
 
-`var` declarations are processed when the function starts (or script starts for globals).
+การประกาศ `var` จะถูกประมวลผลตอนเริ่มต้นฟังก์ชัน (หรือตอนเริ่มต้นสคริปต์ สำหรับตัวแปร global)
 
-In other words, `var` variables are defined from the beginning of the function, no matter where the definition is (assuming that the definition is not in the nested function).
+พูดง่ายๆ ก็คือ ตัวแปร `var` จะถูกกำหนดตั้งแต่ต้นฟังก์ชัน ไม่ว่าจะเขียนการประกาศไว้ตรงไหนก็ตาม (ยกเว้นอยู่ในฟังก์ชันซ้อน)
 
-So this code:
+ลองดูโค้ดนี้:
 
 ```js run
 function sayHi() {
@@ -128,7 +128,7 @@ function sayHi() {
 sayHi();
 ```
 
-...Is technically the same as this (moved `var phrase` above):
+...จริงๆ แล้วทำงานเหมือนกับโค้ดนี้ (ย้าย `var phrase` ขึ้นไปข้างบน):
 
 ```js run
 function sayHi() {
@@ -143,7 +143,7 @@ function sayHi() {
 sayHi();
 ```
 
-...Or even as this (remember, code blocks are ignored):
+...หรือแม้แต่โค้ดนี้ (อย่าลืมว่า `var` มองทะลุบล็อก):
 
 ```js run
 function sayHi() {
@@ -160,13 +160,13 @@ function sayHi() {
 sayHi();
 ```
 
-People also call such behavior "hoisting" (raising), because all `var` are "hoisted" (raised) to the top of the function.
+พฤติกรรมแบบนี้เรียกว่า "hoisting" (การยกขึ้น) เพราะ `var` ทุกตัวจะถูก "ยก" ขึ้นไปอยู่ด้านบนสุดของฟังก์ชัน
 
-So in the example above, `if (false)` branch never executes, but that doesn't matter. The `var` inside it is processed in the beginning of the function, so at the moment of `(*)` the variable exists.
+ในตัวอย่างข้างบน `if (false)` ไม่มีทางถูกรันเลย แต่ไม่เป็นไร เพราะ `var` ที่อยู่ข้างในจะถูกประมวลผลตั้งแต่เริ่มต้นฟังก์ชัน ดังนั้นตอนที่ถึงบรรทัด `(*)` ตัวแปรก็มีอยู่แล้ว
 
-**Declarations are hoisted, but assignments are not.**
+**การประกาศถูก hoist แต่การกำหนดค่าไม่ได้ถูก hoist**
 
-That's best demonstrated with an example:
+มาดูตัวอย่างให้ชัดเจนกัน:
 
 ```js run
 function sayHi() {
@@ -180,40 +180,40 @@ function sayHi() {
 sayHi();
 ```
 
-The line `var phrase = "Hello"` has two actions in it:
+บรรทัด `var phrase = "Hello"` ทำ 2 อย่างด้วยกัน:
 
-1. Variable declaration `var`
-2. Variable assignment `=`.
+1. ประกาศตัวแปร `var`
+2. กำหนดค่าให้ตัวแปร `=`
 
-The declaration is processed at the start of function execution ("hoisted"), but the assignment always works at the place where it appears. So the code works essentially like this:
+ส่วนของการประกาศจะถูกประมวลผลตั้งแต่เริ่มต้นฟังก์ชัน ("hoist" ขึ้นไป) แต่การกำหนดค่าจะทำงานตรงจุดที่เขียนไว้เสมอ โค้ดจึงทำงานเหมือนกับเขียนแบบนี้:
 
 ```js run
 function sayHi() {
 *!*
-  var phrase; // declaration works at the start...
+  var phrase; // การประกาศถูกประมวลผลตั้งแต่ต้น...
 */!*
 
   alert(phrase); // undefined
 
 *!*
-  phrase = "Hello"; // ...assignment - when the execution reaches it.
+  phrase = "Hello"; // ...การกำหนดค่าทำงานตอนที่รันถึงบรรทัดนี้
 */!*
 }
 
 sayHi();
 ```
 
-Because all `var` declarations are processed at the function start, we can reference them at any place. But variables are undefined until the assignments.
+เนื่องจากการประกาศ `var` ทุกตัวถูกประมวลผลตั้งแต่เริ่มต้นฟังก์ชัน เราจึงอ้างถึงตัวแปรได้ทุกที่ แต่ค่าของตัวแปรจะเป็น undefined จนกว่าจะถึงบรรทัดที่กำหนดค่า
 
-In both examples above, `alert` runs without an error, because the variable `phrase` exists. But its value is not yet assigned, so it shows `undefined`.
+ในทั้งสองตัวอย่างข้างต้น `alert` ทำงานได้โดยไม่เกิด error เพราะตัวแปร `phrase` มีอยู่แล้ว แต่ยังไม่ได้กำหนดค่า จึงแสดง `undefined`
 
 ## IIFE
 
-In the past, as there was only `var`, and it has no block-level visibility, programmers invented a way to emulate it. What they did was called "immediately-invoked function expressions" (abbreviated as IIFE).
+ในอดีตมีแค่ `var` เท่านั้น และ `var` ไม่มีสโคประดับบล็อก โปรแกรมเมอร์จึงคิดวิธีจำลองบล็อกสโคปขึ้นมา เรียกว่า "immediately-invoked function expressions" หรือเรียกสั้นๆ ว่า IIFE
 
-That's not something we should use nowadays, but you can find them in old scripts.
+ปัจจุบันไม่มีความจำเป็นต้องใช้แล้ว แต่ยังเจอได้ในโค้ดเก่าๆ
 
-An IIFE looks like this:
+IIFE มีหน้าตาแบบนี้:
 
 ```js run
 (function() {
@@ -225,12 +225,12 @@ An IIFE looks like this:
 })();
 ```
 
-Here, a Function Expression is created and immediately called. So the code executes right away and has its own private variables.
+ตรงนี้เราสร้าง Function Expression แล้วเรียกใช้ทันที โค้ดจึงทำงานเลยและมีตัวแปรส่วนตัวของตัวเอง
 
-The Function Expression is wrapped with parenthesis `(function {...})`, because when JavaScript engine encounters `"function"` in the main code, it understands it as the start of a Function Declaration. But a Function Declaration must have a name, so this kind of code will give an error:
+Function Expression ถูกครอบด้วยวงเล็บ `(function {...})` เพราะเมื่อ JavaScript engine เจอคำว่า `"function"` ในโค้ดหลัก มันจะตีความว่าเป็นจุดเริ่มต้นของ Function Declaration แต่ Function Declaration ต้องมีชื่อ ดังนั้นโค้ดแบบนี้จะเกิด error:
 
 ```js run
-// Tries to declare and immediately call a function
+// พยายามประกาศฟังก์ชันแล้วเรียกใช้ทันที
 function() { // <-- SyntaxError: Function statements require a function name
 
   var message = "Hello";
@@ -240,48 +240,48 @@ function() { // <-- SyntaxError: Function statements require a function name
 }();
 ```
 
-Even if we say: "okay, let's add a name", that won't work, as JavaScript does not allow Function Declarations to be called immediately:
+แม้จะลองใส่ชื่อเข้าไป ก็ยังไม่ได้ เพราะ JavaScript ไม่อนุญาตให้เรียก Function Declaration ทันทีแบบนี้:
 
 ```js run
-// syntax error because of parentheses below
+// syntax error เพราะวงเล็บด้านล่าง
 function go() {
 
-}(); // <-- can't call Function Declaration immediately
+}(); // <-- เรียก Function Declaration ทันทีไม่ได้
 ```
 
-So, the parentheses around the function is a trick to show JavaScript that the function is created in the context of another expression, and hence it's a Function Expression: it needs no name and can be called immediately.
+วงเล็บที่ครอบฟังก์ชันจึงเป็นเทคนิคบอก JavaScript ว่าฟังก์ชันนี้ถูกสร้างขึ้นในบริบทของนิพจน์ (expression) ดังนั้นจึงเป็น Function Expression ไม่จำเป็นต้องมีชื่อ และเรียกใช้ทันทีได้เลย
 
-There exist other ways besides parentheses to tell JavaScript that we mean a Function Expression:
+นอกจากวงเล็บแล้ว ยังมีวิธีอื่นๆ ที่บอก JavaScript ว่านี่คือ Function Expression:
 
 ```js run
-// Ways to create IIFE
+// วิธีสร้าง IIFE
 
 *!*(*/!*function() {
-  alert("Parentheses around the function");
+  alert("ครอบวงเล็บรอบฟังก์ชัน");
 }*!*)*/!*();
 
 *!*(*/!*function() {
-  alert("Parentheses around the whole thing");
+  alert("ครอบวงเล็บรอบทั้งหมด");
 }()*!*)*/!*;
 
 *!*!*/!*function() {
-  alert("Bitwise NOT operator starts the expression");
+  alert("เริ่มนิพจน์ด้วย Bitwise NOT operator");
 }();
 
 *!*+*/!*function() {
-  alert("Unary plus starts the expression");
+  alert("เริ่มนิพจน์ด้วย Unary plus");
 }();
 ```
 
-In all the above cases we declare a Function Expression and run it immediately. Let's note again: nowadays there's no reason to write such code.
+ทุกวิธีข้างต้นล้วนประกาศ Function Expression แล้วเรียกใช้ทันที ย้ำอีกครั้งว่า ปัจจุบันไม่มีเหตุผลที่ต้องเขียนโค้ดแบบนี้แล้ว
 
-## Summary
+## สรุป
 
-There are two main differences of `var` compared to `let/const`:
+`var` แตกต่างจาก `let/const` อยู่ 2 ประเด็นหลัก:
 
-1. `var` variables have no block scope, their visibility is scoped to current function, or global, if declared outside function.
-2. `var` declarations are processed at function start (script start for globals).
+1. ตัวแปร `var` ไม่มีบล็อกสโคป สโคปของมันจะอยู่ระดับฟังก์ชัน หรือถ้าประกาศนอกฟังก์ชันก็จะเป็น global
+2. การประกาศ `var` จะถูกประมวลผลตั้งแต่เริ่มต้นฟังก์ชัน (หรือเริ่มต้นสคริปต์ สำหรับตัวแปร global)
 
-There's one more very minor difference related to the global object, that we'll cover in the next chapter.
+ยังมีความแตกต่างเล็กน้อยอีกเรื่องหนึ่งเกี่ยวกับ global object ซึ่งเราจะพูดถึงในบทถัดไป
 
-These differences make `var` worse than `let` most of the time. Block-level variables is such a great thing. That's why `let` was introduced in the standard long ago, and is now a major way (along with `const`) to declare a variable.
+ความแตกต่างเหล่านี้ทำให้ `var` ด้อยกว่า `let` ในเกือบทุกกรณี การมีสโคประดับบล็อกเป็นสิ่งที่ดีมาก นั่นจึงเป็นเหตุผลว่าทำไม `let` ถึงถูกเพิ่มเข้ามาในมาตรฐานตั้งนานแล้ว และปัจจุบันเป็นวิธีหลัก (คู่กับ `const`) ในการประกาศตัวแปร
diff --git a/1-js/06-advanced-functions/05-global-object/article.md b/1-js/06-advanced-functions/05-global-object/article.md
index cf4839d94..ad442f241 100644
--- a/1-js/06-advanced-functions/05-global-object/article.md
+++ b/1-js/06-advanced-functions/05-global-object/article.md
@@ -1,89 +1,90 @@
 
+
 # Global object
 
-The global object provides variables and functions that are available anywhere. By default, those that are built into the language or the environment.
+Global object เป็นออบเจ็กต์ที่เก็บตัวแปรและฟังก์ชันซึ่งเข้าถึงได้จากทุกที่ในโปรแกรม โดยปกติจะมีทั้งฟังก์ชันที่มากับตัวภาษาเองและฟังก์ชันที่มากับสภาพแวดล้อมการทำงาน
 
-In a browser it is named `window`, for Node.js it is `global`, for other environments it may have another name.
+ในเบราว์เซอร์จะใช้ชื่อ `window` ส่วน Node.js ใช้ `global` และสภาพแวดล้อมอื่นๆ อาจใช้ชื่อต่างออกไป
 
-Recently, `globalThis` was added to the language, as a standardized name for a global object, that should be supported across all environments. It's supported in all major browsers.
+เมื่อไม่นานมานี้ `globalThis` ถูกเพิ่มเข้ามาในภาษา เพื่อเป็นชื่อมาตรฐานของ global object ที่ใช้ได้ในทุกสภาพแวดล้อม ซึ่งเบราว์เซอร์หลักๆ ก็รองรับกันหมดแล้ว
 
-We'll use `window` here, assuming that our environment is a browser. If your script may run in other environments, it's better to use `globalThis` instead.
+ในบทความนี้เราจะใช้ `window` โดยสมมติว่าทำงานอยู่บนเบราว์เซอร์ แต่ถ้าสคริปต์ของเราอาจรันในสภาพแวดล้อมอื่นด้วย ควรใช้ `globalThis` แทนจะดีกว่า
 
-All properties of the global object can be accessed directly:
+พร็อพเพอร์ตี้ทั้งหมดของ global object สามารถเข้าถึงได้โดยตรง:
 
 ```js run
 alert("Hello");
-// is the same as
+// เหมือนกับ
 window.alert("Hello");
 ```
 
-In a browser, global functions and variables declared with `var` (not `let/const`!) become the property of the global object:
+ในเบราว์เซอร์ ฟังก์ชันและตัวแปรระดับ global ที่ประกาศด้วย `var` (ไม่ใช่ `let/const` นะ!) จะกลายเป็นพร็อพเพอร์ตี้ของ global object ด้วย:
 
 ```js run untrusted refresh
 var gVar = 5;
 
-alert(window.gVar); // 5 (became a property of the global object)
+alert(window.gVar); // 5 (กลายเป็นพร็อพเพอร์ตี้ของ global object)
 ```
 
-Function declarations have the same effect (statements with `function` keyword in the main code flow, not function expressions).
+Function Declaration ก็มีพฤติกรรมแบบเดียวกัน (หมายถึงคำสั่ง `function` ที่อยู่ในโฟลว์หลักของโค้ด ไม่ใช่ function expression)
 
-Please don't rely on that! This behavior exists for compatibility reasons. Modern scripts use [JavaScript modules](info:modules) where such a thing doesn't happen.
+อย่าพึ่งพาพฤติกรรมนี้นะ! มันมีอยู่เพื่อความเข้ากันได้กับโค้ดเก่าเท่านั้น สคริปต์สมัยใหม่ที่ใช้ [JavaScript modules](info:modules) จะไม่เกิดเรื่องแบบนี้
 
-If we used `let` instead, such thing wouldn't happen:
+ถ้าเราใช้ `let` แทน จะไม่เกิดพฤติกรรมดังกล่าว:
 
 ```js run untrusted refresh
 let gLet = 5;
 
-alert(window.gLet); // undefined (doesn't become a property of the global object)
+alert(window.gLet); // undefined (ไม่ได้กลายเป็นพร็อพเพอร์ตี้ของ global object)
 ```
 
-If a value is so important that you'd like to make it available globally, write it directly as a property:
+ถ้าต้องการให้ค่าใดค่าหนึ่งเข้าถึงได้จากทุกที่ในโปรแกรม ให้เขียนเป็นพร็อพเพอร์ตี้ของ global object โดยตรง:
 
 ```js run
 *!*
-// make current user information global, to let all scripts access it
+// กำหนดข้อมูลผู้ใช้ปัจจุบันเป็น global เพื่อให้ทุกสคริปต์เข้าถึงได้
 window.currentUser = {
   name: "John"
 };
 */!*
 
-// somewhere else in code
+// ที่อื่นในโค้ด
 alert(currentUser.name);  // John
 
-// or, if we have a local variable with the name "currentUser"
-// get it from window explicitly (safe!)
+// หรือถ้ามีตัวแปรภายในฟังก์ชันชื่อ "currentUser" อยู่แล้ว
+// ก็ดึงจาก window ตรงๆ ได้ (ปลอดภัย!)
 alert(window.currentUser.name); // John
 ```
 
-That said, using global variables is generally discouraged. There should be as few global variables as possible. The code design where a function gets "input" variables and produces certain "outcome" is clearer, less prone to errors and easier to test than if it uses outer or global variables.
+อย่างไรก็ตาม โดยทั่วไปไม่แนะนำให้ใช้ตัวแปร global ควรมีให้น้อยที่สุด การออกแบบโค้ดที่ฟังก์ชันรับ "ข้อมูลเข้า" แล้วส่ง "ผลลัพธ์" ออกมา จะชัดเจนกว่า เกิดข้อผิดพลาดน้อยกว่า และทดสอบง่ายกว่าการใช้ตัวแปรภายนอกหรือตัวแปร global
 
-## Using for polyfills
+## ใช้สำหรับ polyfill
 
-We use the global object to test for support of modern language features.
+เราใช้ global object ในการตรวจสอบว่าเบราว์เซอร์รองรับฟีเจอร์สมัยใหม่หรือไม่
 
-For instance, test if a built-in `Promise` object exists (it doesn't in really old browsers):
+ยกตัวอย่าง ลองเช็คว่ามีออบเจ็กต์ `Promise` ในตัวหรือเปล่า (เบราว์เซอร์เก่ามากๆ จะไม่มี):
 ```js run
 if (!window.Promise) {
   alert("Your browser is really old!");
 }
 ```
 
-If there's none (say, we're in an old browser), we can create "polyfills": add functions that are not supported by the environment, but exist in the modern standard.
+ถ้ายังไม่มี (เช่น เป็นเบราว์เซอร์เก่า) เราสามารถสร้าง "polyfill" ขึ้นมาได้ นั่นคือการเพิ่มฟังก์ชันที่สภาพแวดล้อมไม่รองรับ แต่มีอยู่ในมาตรฐานสมัยใหม่:
 
 ```js run
 if (!window.Promise) {
-  window.Promise = ... // custom implementation of the modern language feature
+  window.Promise = ... // โค้ดที่เราเขียนขึ้นมาเองเพื่อทดแทนฟีเจอร์ที่ขาดไป
 }
 ```
 
-## Summary
+## สรุป
 
-- The global object holds variables that should be available everywhere.
+- Global object เก็บตัวแปรที่ควรเข้าถึงได้จากทุกที่
 
-    That includes JavaScript built-ins, such as `Array` and environment-specific values, such as `window.innerHeight` -- the window height in the browser.
-- The global object has a universal name `globalThis`.
+    ซึ่งรวมถึงสิ่งที่มากับ JavaScript เช่น `Array` และค่าเฉพาะของสภาพแวดล้อม เช่น `window.innerHeight` ซึ่งคือความสูงของหน้าต่างเบราว์เซอร์
+- Global object มีชื่อมาตรฐานคือ `globalThis`
 
-    ...But more often is referred by "old-school" environment-specific names, such as `window` (browser) and `global` (Node.js).
-- We should store values in the global object only if they're truly global for our project. And keep their number at minimum.
-- In-browser, unless we're using [modules](info:modules), global functions and variables declared with `var` become a property of the global object.
-- To make our code future-proof and easier to understand, we should access properties of the global object directly, as `window.x`.
+    ...แต่ที่พบบ่อยกว่าคือชื่อเฉพาะของแต่ละสภาพแวดล้อม เช่น `window` (เบราว์เซอร์) และ `global` (Node.js)
+- ควรเก็บค่าไว้ใน global object เฉพาะเมื่อจำเป็นจริงๆ สำหรับทั้งโปรเจกต์เท่านั้น และให้มีจำนวนน้อยที่สุด
+- ในเบราว์เซอร์ หากไม่ได้ใช้ [modules](info:modules) ฟังก์ชันและตัวแปร global ที่ประกาศด้วย `var` จะกลายเป็นพร็อพเพอร์ตี้ของ global object
+- เพื่อให้โค้ดรองรับอนาคตและอ่านเข้าใจง่าย ควรเข้าถึงพร็อพเพอร์ตี้ของ global object โดยตรง เช่น `window.x`
diff --git a/1-js/06-advanced-functions/06-function-object/2-counter-inc-dec/_js.view/source.js b/1-js/06-advanced-functions/06-function-object/2-counter-inc-dec/_js.view/source.js
index 5bf29aa2d..dcc0fb75e 100644
--- a/1-js/06-advanced-functions/06-function-object/2-counter-inc-dec/_js.view/source.js
+++ b/1-js/06-advanced-functions/06-function-object/2-counter-inc-dec/_js.view/source.js
@@ -1,7 +1,7 @@
 function makeCounter() {
   let count = 0;
 
-  // ... your code ...
+  // ... โค้ดของคุณ ...
 }
 
 let counter = makeCounter();
@@ -9,10 +9,10 @@ let counter = makeCounter();
 alert( counter() ); // 0
 alert( counter() ); // 1
 
-counter.set(10); // set the new count
+counter.set(10); // ตั้งค่าตัวนับใหม่
 
 alert( counter() ); // 10
 
-counter.decrease(); // decrease the count by 1
+counter.decrease(); // ลดค่าตัวนับลง 1
 
-alert( counter() ); // 10 (instead of 11)
+alert( counter() ); // 10 (แทนที่จะเป็น 11)
diff --git a/1-js/06-advanced-functions/06-function-object/2-counter-inc-dec/solution.md b/1-js/06-advanced-functions/06-function-object/2-counter-inc-dec/solution.md
index e829d96ee..b2883c251 100644
--- a/1-js/06-advanced-functions/06-function-object/2-counter-inc-dec/solution.md
+++ b/1-js/06-advanced-functions/06-function-object/2-counter-inc-dec/solution.md
@@ -1,2 +1,2 @@
 
-The solution uses `count` in the local variable, but addition methods are written right into the `counter`. They share the same outer lexical environment and also can access the current `count`.
+วิธีนี้ใช้ `count` เป็นตัวแปรภายใน ส่วนเมธอดเพิ่มเติมถูกเขียนไว้ใน `counter` โดยตรง ทั้งหมดแชร์ Lexical Environment ภายนอกเดียวกัน จึงเข้าถึง `count` ปัจจุบันได้
diff --git a/1-js/06-advanced-functions/06-function-object/2-counter-inc-dec/task.md b/1-js/06-advanced-functions/06-function-object/2-counter-inc-dec/task.md
index a11821d67..7ec43f0b0 100644
--- a/1-js/06-advanced-functions/06-function-object/2-counter-inc-dec/task.md
+++ b/1-js/06-advanced-functions/06-function-object/2-counter-inc-dec/task.md
@@ -2,14 +2,14 @@ importance: 5
 
 ---
 
-# Set and decrease for counter
+# ตั้งค่าและลดค่าตัวนับ
 
-Modify the code of `makeCounter()` so that the counter can also decrease and set the number:
+แก้ไขโค้ดของ `makeCounter()` ให้ตัวนับสามารถลดค่าและตั้งค่าได้ด้วย:
 
-- `counter()` should return the next number (as before).
-- `counter.set(value)` should set the counter to `value`.
-- `counter.decrease()` should decrease the counter by 1.
+- `counter()` ควรคืนค่าตัวเลขถัดไป (เหมือนเดิม)
+- `counter.set(value)` ควรตั้งค่าตัวนับเป็น `value`
+- `counter.decrease()` ควรลดค่าตัวนับลง 1
 
-See the sandbox code for the complete usage example.
+ดูตัวอย่างการใช้งานแบบเต็มได้ในโค้ด sandbox
 
-P.S. You can use either a closure or the function property to keep the current count. Or write both variants.
+P.S. จะใช้คลอเชอร์หรือพร็อพเพอร์ตี้ของฟังก์ชันในการเก็บค่าปัจจุบันก็ได้ หรือจะเขียนทั้งสองแบบเลยก็ได้
diff --git a/1-js/06-advanced-functions/06-function-object/5-sum-many-brackets/_js.view/source.js b/1-js/06-advanced-functions/06-function-object/5-sum-many-brackets/_js.view/source.js
index f10dca5dc..bf217badb 100644
--- a/1-js/06-advanced-functions/06-function-object/5-sum-many-brackets/_js.view/source.js
+++ b/1-js/06-advanced-functions/06-function-object/5-sum-many-brackets/_js.view/source.js
@@ -1,5 +1,5 @@
 function sum(a){
-  // Your code goes here.
+  // เขียนโค้ดของคุณตรงนี้
 
 }
 
diff --git a/1-js/06-advanced-functions/06-function-object/5-sum-many-brackets/solution.md b/1-js/06-advanced-functions/06-function-object/5-sum-many-brackets/solution.md
index e97039f72..831079d9e 100644
--- a/1-js/06-advanced-functions/06-function-object/5-sum-many-brackets/solution.md
+++ b/1-js/06-advanced-functions/06-function-object/5-sum-many-brackets/solution.md
@@ -1,9 +1,9 @@
 
-1. For the whole thing to work *anyhow*, the result of `sum` must be function.
-2. That function must keep in memory the current value between calls.
-3. According to the task, the function must become the number when used in `==`. Functions are objects, so the conversion happens as described in the chapter <info:object-toprimitive>, and we can provide our own method that returns the number.
+1. ผลลัพธ์ของ `sum` ต้องเป็นฟังก์ชัน ไม่งั้นทั้งหมดนี้จะทำงานไม่ได้เลย
+2. ฟังก์ชันนั้นต้องจำค่าปัจจุบันไว้ระหว่างการเรียกแต่ละครั้ง
+3. ตามโจทย์ ฟังก์ชันต้องกลายเป็นตัวเลขเมื่อใช้กับ `==` เนื่องจากฟังก์ชันเป็นออบเจ็กต์ การแปลงจึงเกิดขึ้นตามที่อธิบายในบท <info:object-toprimitive> โดยเรากำหนดเมธอดของเราเองที่คืนค่าตัวเลขได้
 
-Now the code:
+โค้ดเป็นแบบนี้:
 
 ```js demo run
 function sum(a) {
@@ -28,28 +28,28 @@ alert( sum(6)(-1)(-2)(-3) ); // 0
 alert( sum(0)(1)(2)(3)(4)(5) ); // 15
 ```
 
-Please note that the `sum` function actually works only once. It returns function `f`.
+สังเกตว่าฟังก์ชัน `sum` ทำงานจริงแค่ครั้งเดียว คือคืนค่าฟังก์ชัน `f` ออกมา
 
-Then, on each subsequent call, `f` adds its parameter to the sum `currentSum`, and returns itself.
+จากนั้นในการเรียกครั้งถัดๆ ไป `f` จะบวกพารามิเตอร์เข้าไปใน `currentSum` แล้วคืนค่าตัวเองออกมา
 
-**There is no recursion in the last line of `f`.**
+**บรรทัดสุดท้ายของ `f` ไม่ใช่ recursion**
 
-Here is what recursion looks like:
+ถ้าเป็น recursion จะหน้าตาแบบนี้:
 
 ```js
 function f(b) {
   currentSum += b;
-  return f(); // <-- recursive call
+  return f(); // <-- เรียกตัวเองซ้ำ
 }
 ```
 
-And in our case, we just return the function, without calling it:
+แต่ในกรณีของเรา แค่คืนค่าฟังก์ชันออกมาโดยไม่ได้เรียก:
 
 ```js
 function f(b) {
   currentSum += b;
-  return f; // <-- does not call itself, returns itself
+  return f; // <-- ไม่ได้เรียกตัวเอง แค่คืนค่าตัวเองออกมา
 }
 ```
 
-This `f` will be used in the next call, again return itself, as many times as needed. Then, when used as a number or a string -- the `toString` returns the `currentSum`. We could also use `Symbol.toPrimitive` or `valueOf` here for the conversion.
+ฟังก์ชัน `f` นี้จะถูกใช้ในการเรียกครั้งถัดไป แล้วก็คืนค่าตัวเองออกมาอีก ต่อไปเรื่อยๆ กี่ครั้งก็ได้ จากนั้นเมื่อถูกใช้เป็นตัวเลขหรือสตริง `toString` จะคืนค่า `currentSum` ออกมา เราสามารถใช้ `Symbol.toPrimitive` หรือ `valueOf` แทนก็ได้เช่นกัน
diff --git a/1-js/06-advanced-functions/06-function-object/5-sum-many-brackets/task.md b/1-js/06-advanced-functions/06-function-object/5-sum-many-brackets/task.md
index dc13f260b..f0836b40c 100644
--- a/1-js/06-advanced-functions/06-function-object/5-sum-many-brackets/task.md
+++ b/1-js/06-advanced-functions/06-function-object/5-sum-many-brackets/task.md
@@ -2,9 +2,9 @@ importance: 2
 
 ---
 
-# Sum with an arbitrary amount of brackets
+# ผลรวมที่เรียกต่อกันกี่วงเล็บก็ได้
 
-Write function `sum` that would work like this:
+เขียนฟังก์ชัน `sum` ที่ทำงานได้แบบนี้:
 
 ```js
 sum(1)(2) == 3; // 1 + 2
@@ -14,4 +14,4 @@ sum(6)(-1)(-2)(-3) == 0
 sum(0)(1)(2)(3)(4)(5) == 15
 ```
 
-P.S. Hint: you may need to setup custom object to primitive conversion for your function.
\ No newline at end of file
+P.S. คำใบ้: อาจต้องกำหนดการแปลงออบเจ็กต์เป็นค่า primitive ให้ฟังก์ชันของคุณ
\ No newline at end of file
diff --git a/1-js/06-advanced-functions/06-function-object/article.md b/1-js/06-advanced-functions/06-function-object/article.md
index 8419ae763..ba3d4d8e4 100644
--- a/1-js/06-advanced-functions/06-function-object/article.md
+++ b/1-js/06-advanced-functions/06-function-object/article.md
@@ -1,20 +1,20 @@
 
-# Function object, NFE
+# ออบเจ็กต์ฟังก์ชัน, NFE
 
-As we already know, a function in JavaScript is a value.
+อย่างที่เราทราบกันแล้ว ฟังก์ชันใน JavaScript ก็คือค่า (value) ค่าหนึ่ง
 
-Every value in JavaScript has a type. What type is a function?
+แล้วค่าทุกตัวใน JavaScript ก็มีชนิดข้อมูล (type) คำถามคือ ฟังก์ชันเป็นชนิดอะไร?
 
-In JavaScript, functions are objects.
+ใน JavaScript ฟังก์ชันคือออบเจ็กต์
 
-A good way to imagine functions is as callable "action objects". We can not only call them, but also treat them as objects: add/remove properties, pass by reference etc.
+ลองนึกภาพว่าฟังก์ชันก็คือ "ออบเจ็กต์ที่เรียกใช้ได้" นั่นเอง เราไม่ได้แค่เรียกฟังก์ชันได้อย่างเดียว แต่ยังใช้มันเหมือนออบเจ็กต์ทั่วไปได้ด้วย เช่น เพิ่ม/ลบพร็อพเพอร์ตี้ ส่งต่อเป็น reference ฯลฯ
 
 
-## The "name" property
+## พร็อพเพอร์ตี้ "name"
 
-Function objects contain some useable properties.
+ออบเจ็กต์ฟังก์ชันมีพร็อพเพอร์ตี้ที่ใช้งานได้หลายตัว
 
-For instance, a function's name is accessible as the "name" property:
+ตัวอย่างเช่น ชื่อของฟังก์ชันสามารถเข้าถึงได้ผ่านพร็อพเพอร์ตี้ "name":
 
 ```js run
 function sayHi() {
@@ -24,29 +24,29 @@ function sayHi() {
 alert(sayHi.name); // sayHi
 ```
 
-What's kind of funny, the name-assigning logic is smart. It also assigns the correct name to a function even if it's created without one, and then immediately assigned:
+สิ่งที่น่าสนใจคือ ระบบตั้งชื่อฉลาดมาก แม้ฟังก์ชันจะถูกสร้างโดยไม่มีชื่อ แล้วนำไปกำหนดค่าให้ตัวแปรทันที JavaScript ก็ยังตั้งชื่อให้ถูกต้อง:
 
 ```js run
 let sayHi = function() {
   alert("Hi");
 };
 
-alert(sayHi.name); // sayHi (there's a name!)
+alert(sayHi.name); // sayHi (มีชื่อนะ!)
 ```
 
-It also works if the assignment is done via a default value:
+กลไกนี้ใช้ได้แม้กำหนดค่าผ่าน default value:
 
 ```js run
 function f(sayHi = function() {}) {
-  alert(sayHi.name); // sayHi (works!)
+  alert(sayHi.name); // sayHi (ใช้ได้!)
 }
 
 f();
 ```
 
-In the specification, this feature is called a "contextual name". If the function does not provide one, then in an assignment it is figured out from the context.
+ใน specification เรียกฟีเจอร์นี้ว่า "contextual name" หมายความว่าถ้าฟังก์ชันไม่ได้กำหนดชื่อเอง ก็จะดึงชื่อจากบริบทมาใช้แทน
 
-Object methods have names too:
+เมธอดของออบเจ็กต์ก็มีชื่อเช่นกัน:
 
 ```js run
 let user = {
@@ -65,21 +65,21 @@ alert(user.sayHi.name); // sayHi
 alert(user.sayBye.name); // sayBye
 ```
 
-There's no magic though. There are cases when there's no way to figure out the right name. In that case, the name property is empty, like here:
+แต่ก็ไม่ได้วิเศษทุกกรณี บางครั้ง JavaScript ก็หาชื่อที่ถูกต้องไม่ได้ พร็อพเพอร์ตี้ name จะเป็นสตริงว่างแบบนี้:
 
 ```js run
-// function created inside array
+// ฟังก์ชันที่สร้างภายในอาร์เรย์
 let arr = [function() {}];
 
-alert( arr[0].name ); // <empty string>
-// the engine has no way to set up the right name, so there is none
+alert( arr[0].name ); // <สตริงว่าง>
+// engine ไม่มีทางรู้ว่าควรตั้งชื่ออะไร จึงเป็นค่าว่าง
 ```
 
-In practice, however, most functions do have a name.
+แต่ในทางปฏิบัติ ฟังก์ชันส่วนใหญ่มักจะมีชื่ออยู่แล้ว
 
-## The "length" property
+## พร็อพเพอร์ตี้ "length"
 
-There is another built-in property "length" that returns the number of function parameters, for instance:
+มีพร็อพเพอร์ตี้ built-in อีกตัวหนึ่งคือ "length" ที่คืนค่าจำนวนพารามิเตอร์ของฟังก์ชัน เช่น:
 
 ```js run
 function f1(a) {}
@@ -91,20 +91,20 @@ alert(f2.length); // 2
 alert(many.length); // 2
 ```
 
-Here we can see that rest parameters are not counted.
+จะเห็นว่า rest parameter ไม่ถูกนับรวมด้วย
 
-The `length` property is sometimes used for [introspection](https://en.wikipedia.org/wiki/Type_introspection) in functions that operate on other functions.
+พร็อพเพอร์ตี้ `length` บางครั้งถูกนำมาใช้ในการทำ [introspection](https://en.wikipedia.org/wiki/Type_introspection) กับฟังก์ชันที่ต้องทำงานกับฟังก์ชันอื่นๆ
 
-For instance, in the code below the `ask` function accepts a `question` to ask and an arbitrary number of `handler` functions to call.
+ยกตัวอย่าง ในโค้ดด้านล่าง ฟังก์ชัน `ask` รับ `question` ที่จะถาม และฟังก์ชัน `handler` จำนวนกี่ตัวก็ได้
 
-Once a user provides their answer, the function calls the handlers. We can pass two kinds of handlers:
+เมื่อผู้ใช้ตอบ ฟังก์ชันจะเรียก handler ทั้งหมด โดยเราส่ง handler ได้ 2 แบบ:
 
-- A zero-argument function, which is only called when the user gives a positive answer.
-- A function with arguments, which is called in either case and returns an answer.
+- ฟังก์ชันที่ไม่รับอาร์กิวเมนต์ จะถูกเรียกเฉพาะเมื่อผู้ใช้ตอบ "ใช่" เท่านั้น
+- ฟังก์ชันที่รับอาร์กิวเมนต์ จะถูกเรียกทุกกรณีและคืนค่าคำตอบ
 
-To call `handler` the right way, we examine the `handler.length` property.
+เราใช้ `handler.length` เพื่อเลือกวิธีเรียก handler ให้ถูกต้อง
 
-The idea is that we have a simple, no-arguments handler syntax for positive cases (most frequent variant), but are able to support universal handlers as well:
+แนวคิดก็คือ สำหรับกรณีที่ผู้ใช้ตอบ "ใช่" (ซึ่งเกิดบ่อยที่สุด) เราจะมี handler แบบง่ายที่ไม่รับอาร์กิวเมนต์ แต่ก็ยังรองรับ handler แบบครอบจักรวาลที่ใช้ได้ทุกกรณีด้วย:
 
 ```js run
 function ask(question, ...handlers) {
@@ -120,47 +120,47 @@ function ask(question, ...handlers) {
 
 }
 
-// for positive answer, both handlers are called
-// for negative answer, only the second one
-ask("Question?", () => alert('You said yes'), result => alert(result));
+// ถ้าตอบ "ใช่" จะเรียก handler ทั้งสองตัว
+// ถ้าตอบ "ไม่ใช่" จะเรียกแค่ตัวที่สอง
+ask("คำถาม?", () => alert('คุณตอบใช่'), result => alert(result));
 ```
 
-This is a particular case of so-called [polymorphism](https://en.wikipedia.org/wiki/Polymorphism_(computer_science)) -- treating arguments differently depending on their type or, in our case depending on the `length`. The idea does have a use in JavaScript libraries.
+นี่คือตัวอย่างของ [polymorphism](https://en.wikipedia.org/wiki/Polymorphism_(computer_science)) -- ซึ่งก็คือการจัดการอาร์กิวเมนต์ต่างกันตามชนิดหรือในกรณีนี้คือตาม `length` แนวคิดนี้ถูกนำไปใช้จริงในไลบรารี JavaScript หลายตัว
 
-## Custom properties
+## พร็อพเพอร์ตี้ที่กำหนดเอง
 
-We can also add properties of our own.
+เราสามารถเพิ่มพร็อพเพอร์ตี้ของเราเองให้ฟังก์ชันได้ด้วย
 
-Here we add the `counter` property to track the total calls count:
+ตัวอย่างนี้เราเพิ่มพร็อพเพอร์ตี้ `counter` เพื่อนับจำนวนครั้งที่ฟังก์ชันถูกเรียก:
 
 ```js run
 function sayHi() {
   alert("Hi");
 
   *!*
-  // let's count how many times we run
+  // นับว่าเรียกฟังก์ชันนี้ไปกี่ครั้งแล้ว
   sayHi.counter++;
   */!*
 }
-sayHi.counter = 0; // initial value
+sayHi.counter = 0; // ค่าเริ่มต้น
 
 sayHi(); // Hi
 sayHi(); // Hi
 
-alert( `Called ${sayHi.counter} times` ); // Called 2 times
+alert( `เรียกไปทั้งหมด ${sayHi.counter} ครั้ง` ); // เรียกไปทั้งหมด 2 ครั้ง
 ```
 
-```warn header="A property is not a variable"
-A property assigned to a function like `sayHi.counter = 0` does *not* define a local variable `counter` inside it. In other words, a property `counter` and a variable `let counter` are two unrelated things.
+```warn header="พร็อพเพอร์ตี้ ≠ ตัวแปร"
+พร็อพเพอร์ตี้ที่กำหนดให้ฟังก์ชัน เช่น `sayHi.counter = 0` *ไม่ได้* สร้างตัวแปรภายในฟังก์ชัน `counter` ขึ้นมา พูดง่ายๆ คือ พร็อพเพอร์ตี้ `counter` กับตัวแปร `let counter` เป็นคนละตัวกันโดยสิ้นเชิง
 
-We can treat a function as an object, store properties in it, but that has no effect on its execution. Variables are not function properties and vice versa. These are just parallel worlds.
+เราสามารถใช้ฟังก์ชันเหมือนออบเจ็กต์ เก็บพร็อพเพอร์ตี้ไว้ในนั้นได้ แต่จะไม่มีผลต่อการทำงานของฟังก์ชันเลย ตัวแปรไม่ใช่พร็อพเพอร์ตี้ของฟังก์ชัน และพร็อพเพอร์ตี้ก็ไม่ใช่ตัวแปร ทั้งสองอย่างแยกจากกันอย่างสิ้นเชิง
 ```
 
-Function properties can replace closures sometimes. For instance, we can rewrite the counter function example from the chapter <info:closure> to use a function property:
+พร็อพเพอร์ตี้ของฟังก์ชันสามารถนำมาใช้แทนคลอเชอร์ได้ในบางกรณี ตัวอย่างเช่น เราสามารถเขียนตัวอย่างฟังก์ชันนับจากบท <info:closure> ใหม่โดยใช้พร็อพเพอร์ตี้ของฟังก์ชันแทน:
 
 ```js run
 function makeCounter() {
-  // instead of:
+  // แทนที่จะใช้:
   // let count = 0
 
   function counter() {
@@ -177,11 +177,11 @@ alert( counter() ); // 0
 alert( counter() ); // 1
 ```
 
-The `count` is now stored in the function directly, not in its outer Lexical Environment.
+ตอนนี้ `count` ถูกเก็บไว้ในตัวฟังก์ชันโดยตรง ไม่ได้อยู่ใน Lexical Environment ภายนอก
 
-Is it better or worse than using a closure?
+แล้วแบบไหนดีกว่ากัน ระหว่างใช้คลอเชอร์กับใช้พร็อพเพอร์ตี้?
 
-The main difference is that if the value of `count` lives in an outer variable, then external code is unable to access it. Only nested functions may modify it. And if it's bound to a function, then such a thing is possible:
+ข้อแตกต่างหลักคือ ถ้าค่า `count` อยู่ในตัวแปรภายนอก โค้ดข้างนอกจะเข้าถึงไม่ได้ มีเฉพาะฟังก์ชันซ้อนเท่านั้นที่แก้ไขค่าได้ แต่ถ้าผูกไว้เป็นพร็อพเพอร์ตี้ของฟังก์ชัน โค้ดข้างนอกก็เข้ามาแก้ไขได้:
 
 ```js run
 function makeCounter() {
@@ -203,13 +203,13 @@ alert( counter() ); // 10
 */!*
 ```
 
-So the choice of implementation depends on our aims.
+การเลือกใช้แบบไหนจึงขึ้นอยู่กับว่าต้องการอะไร
 
 ## Named Function Expression
 
-Named Function Expression, or NFE, is a term for Function Expressions that have a name.
+Named Function Expression หรือ NFE คือ Function Expression ที่มีชื่อกำกับ
 
-For instance, let's take an ordinary Function Expression:
+ลองดู Function Expression ธรรมดาก่อน:
 
 ```js
 let sayHi = function(who) {
@@ -217,7 +217,7 @@ let sayHi = function(who) {
 };
 ```
 
-And add a name to it:
+แล้วเพิ่มชื่อเข้าไป:
 
 ```js
 let sayHi = function *!*func*/!*(who) {
@@ -225,13 +225,13 @@ let sayHi = function *!*func*/!*(who) {
 };
 ```
 
-Did we achieve anything here? What's the purpose of that additional `"func"` name?
+การเพิ่มชื่อ `"func"` นี้ทำอะไรได้บ้าง?
 
-First let's note, that we still have a Function Expression. Adding the name `"func"` after `function` did not make it a Function Declaration, because it is still created as a part of an assignment expression.
+ก่อนอื่นต้องบอกว่า มันยังคงเป็น Function Expression เหมือนเดิม การเพิ่มชื่อ `"func"` หลังคำว่า `function` ไม่ได้ทำให้กลายเป็น Function Declaration เพราะมันยังถูกสร้างเป็นส่วนหนึ่งของ assignment expression อยู่
 
-Adding such a name also did not break anything.
+และการเพิ่มชื่อก็ไม่ได้ทำให้อะไรพัง
 
-The function is still available as `sayHi()`:
+ฟังก์ชันยังคงเรียกใช้ผ่าน `sayHi()` ได้ปกติ:
 
 ```js run
 let sayHi = function *!*func*/!*(who) {
@@ -241,12 +241,12 @@ let sayHi = function *!*func*/!*(who) {
 sayHi("John"); // Hello, John
 ```
 
-There are two special things about the name `func`, that are the reasons for it:
+ชื่อ `func` มีความพิเศษอยู่ 2 อย่าง:
 
-1. It allows the function to reference itself internally.
-2. It is not visible outside of the function.
+1. ทำให้ฟังก์ชันสามารถอ้างอิงถึงตัวเองจากภายในได้
+2. ชื่อนี้มองไม่เห็นจากภายนอกฟังก์ชัน
 
-For instance, the function `sayHi` below calls itself again with `"Guest"` if no `who` is provided:
+ตัวอย่างเช่น ฟังก์ชัน `sayHi` ด้านล่างจะเรียกตัวเองซ้ำด้วยค่า `"Guest"` ถ้าไม่มีการส่ง `who` เข้ามา:
 
 ```js run
 let sayHi = function *!*func*/!*(who) {
@@ -254,21 +254,21 @@ let sayHi = function *!*func*/!*(who) {
     alert(`Hello, ${who}`);
   } else {
 *!*
-    func("Guest"); // use func to re-call itself
+    func("Guest"); // ใช้ func เพื่อเรียกตัวเองซ้ำ
 */!*
   }
 };
 
 sayHi(); // Hello, Guest
 
-// But this won't work:
-func(); // Error, func is not defined (not visible outside of the function)
+// แต่แบบนี้ใช้ไม่ได้:
+func(); // Error, func is not defined (มองไม่เห็นจากภายนอก)
 ```
 
-Why do we use `func`? Maybe just use `sayHi` for the nested call?
+ทำไมต้องใช้ `func`? ใช้ `sayHi` เรียกตัวเองไม่ได้เหรอ?
 
 
-Actually, in most cases we can:
+จริงๆ ในกรณีส่วนใหญ่ก็ทำได้:
 
 ```js
 let sayHi = function(who) {
@@ -282,7 +282,7 @@ let sayHi = function(who) {
 };
 ```
 
-The problem with that code is that `sayHi` may change in the outer code. If the function gets assigned to another variable instead, the code will start to give errors:
+แต่ปัญหาคือ `sayHi` อาจถูกเปลี่ยนจากโค้ดภายนอก ถ้าฟังก์ชันถูกกำหนดให้ตัวแปรอื่นแล้ว โค้ดจะเริ่มมี error:
 
 ```js run
 let sayHi = function(who) {
@@ -298,14 +298,14 @@ let sayHi = function(who) {
 let welcome = sayHi;
 sayHi = null;
 
-welcome(); // Error, the nested sayHi call doesn't work any more!
+welcome(); // Error, การเรียก sayHi ซ้อนข้างในใช้ไม่ได้อีกแล้ว!
 ```
 
-That happens because the function takes `sayHi` from its outer lexical environment. There's no local `sayHi`, so the outer variable is used. And at the moment of the call that outer `sayHi` is `null`.
+เหตุที่เป็นแบบนี้เพราะฟังก์ชันดึง `sayHi` มาจาก Lexical Environment ภายนอก ไม่มี `sayHi` ภายใน จึงใช้ตัวแปรภายนอก แต่ตอนที่เรียกใช้ `sayHi` ภายนอกกลายเป็น `null` ไปแล้ว
 
-The optional name which we can put into the Function Expression is meant to solve exactly these kinds of problems.
+ชื่อที่เราใส่ให้ Function Expression มีไว้แก้ปัญหานี้โดยเฉพาะ
 
-Let's use it to fix our code:
+ลองมาแก้โค้ดกัน:
 
 ```js run
 let sayHi = function *!*func*/!*(who) {
@@ -313,7 +313,7 @@ let sayHi = function *!*func*/!*(who) {
     alert(`Hello, ${who}`);
   } else {
 *!*
-    func("Guest"); // Now all fine
+    func("Guest"); // ทำงานได้ปกติ
 */!*
   }
 };
@@ -321,33 +321,33 @@ let sayHi = function *!*func*/!*(who) {
 let welcome = sayHi;
 sayHi = null;
 
-welcome(); // Hello, Guest (nested call works)
+welcome(); // Hello, Guest (การเรียกซ้อนทำงานได้)
 ```
 
-Now it works, because the name `"func"` is function-local. It is not taken from outside (and not visible there). The specification guarantees that it will always reference the current function.
+ตอนนี้ใช้ได้แล้ว เพราะชื่อ `"func"` เป็นชื่อที่อยู่ภายในฟังก์ชันเท่านั้น ไม่ได้ดึงมาจากภายนอก (และมองไม่เห็นจากภายนอกด้วย) specification รับประกันว่าชื่อนี้จะอ้างอิงถึงฟังก์ชันปัจจุบันเสมอ
 
-The outer code still has its variable `sayHi` or `welcome`. And `func` is an "internal function name", the way for the function to call itself reliably.
+ส่วนโค้ดภายนอกก็ยังมีตัวแปร `sayHi` หรือ `welcome` ตามปกติ และ `func` เป็น "ชื่อภายในฟังก์ชัน" ที่ทำให้ฟังก์ชันเรียกตัวเองได้อย่างมั่นใจ
 
-```smart header="There's no such thing for Function Declaration"
-The "internal name" feature described here is only available for Function Expressions, not for Function Declarations. For Function Declarations, there is no syntax for adding an "internal" name.
+```smart header="Function Declaration ไม่มีฟีเจอร์นี้"
+ฟีเจอร์ "ชื่อภายใน" ที่อธิบายไปนี้ ใช้ได้เฉพาะกับ Function Expression เท่านั้น ไม่มีให้ใน Function Declaration เพราะ Function Declaration ไม่มี syntax สำหรับเพิ่มชื่อภายใน
 
-Sometimes, when we need a reliable internal name, it's the reason to rewrite a Function Declaration to Named Function Expression form.
+บางครั้งที่ต้องการชื่อภายในที่เชื่อถือได้ ก็เป็นเหตุผลหนึ่งที่เราเขียน Function Declaration เป็น Named Function Expression แทน
 ```
 
-## Summary
+## สรุป
 
-Functions are objects.
+ฟังก์ชันคือออบเจ็กต์
 
-Here we covered their properties:
+พร็อพเพอร์ตี้ที่มีมาให้ ได้แก่:
 
-- `name` -- the function name. Usually taken from the function definition, but if there's none, JavaScript tries to guess it from the context (e.g. an assignment).
-- `length` -- the number of arguments in the function definition. Rest parameters are not counted.
+- `name` -- ชื่อของฟังก์ชัน ปกติจะดึงมาจากตอนที่ประกาศ แต่ถ้าไม่มีชื่อ JavaScript จะพยายามเดาจากบริบท (เช่น จากการกำหนดค่า)
+- `length` -- จำนวนพารามิเตอร์ในตอนประกาศฟังก์ชัน โดย rest parameter ไม่ถูกนับรวม
 
-If the function is declared as a Function Expression (not in the main code flow), and it carries the name, then it is called a Named Function Expression. The name can be used inside to reference itself, for recursive calls or such.
+ถ้าฟังก์ชันถูกประกาศเป็น Function Expression (ไม่ได้อยู่ในโฟลว์หลักของโค้ด) และมีชื่อกำกับ จะเรียกว่า Named Function Expression ชื่อนี้ใช้ภายในฟังก์ชันเพื่ออ้างอิงตัวเอง เช่น สำหรับการเรียกซ้ำ (recursive call) เป็นต้น
 
-Also, functions may carry additional properties. Many well-known JavaScript libraries make great use of this feature.
+นอกจากนี้ ฟังก์ชันยังสามารถเก็บพร็อพเพอร์ตี้เพิ่มเติมได้ ไลบรารี JavaScript ที่มีชื่อเสียงหลายตัวใช้ประโยชน์จากฟีเจอร์นี้
 
-They create a "main" function and attach many other "helper" functions to it. For instance, the [jQuery](https://jquery.com) library creates a function named `$`. The [lodash](https://lodash.com) library creates a function `_`, and then adds `_.clone`, `_.keyBy` and other properties to it (see the [docs](https://lodash.com/docs) when you want to learn more about them). Actually, they do it to lessen their pollution of the global space, so that a single library gives only one global variable. That reduces the possibility of naming conflicts.
+โดยจะสร้างฟังก์ชัน "หลัก" ขึ้นมาตัวหนึ่ง แล้วผูกฟังก์ชัน "ผู้ช่วย" ไว้เป็นพร็อพเพอร์ตี้ ตัวอย่างเช่น ไลบรารี [jQuery](https://jquery.com) สร้างฟังก์ชันชื่อ `$` ส่วนไลบรารี [lodash](https://lodash.com) สร้างฟังก์ชัน `_` แล้วเพิ่ม `_.clone`, `_.keyBy` เป็นต้น (ดู[เอกสาร](https://lodash.com/docs)เพิ่มเติม) วิธีนี้ช่วยลดการใช้ global space เพราะไลบรารีทั้งหมดใช้ตัวแปร global แค่ตัวเดียว ทำให้โอกาสที่ชื่อจะชนกันน้อยลง
 
 
-So, a function can do a useful job by itself and also carry a bunch of other functionality in properties.
+สรุปแล้ว ฟังก์ชันไม่ได้แค่ทำงานได้อย่างเดียว แต่ยังเก็บฟังก์ชันอื่นๆ ไว้เป็นพร็อพเพอร์ตี้ได้ด้วย
diff --git a/1-js/06-advanced-functions/07-new-function/article.md b/1-js/06-advanced-functions/07-new-function/article.md
index ffe264a4e..ed02c496b 100644
--- a/1-js/06-advanced-functions/07-new-function/article.md
+++ b/1-js/06-advanced-functions/07-new-function/article.md
@@ -1,19 +1,20 @@
 
-# The "new Function" syntax
 
-There's one more way to create a function. It's rarely used, but sometimes there's no alternative.
+# ไวยากรณ์ "new Function"
 
-## Syntax
+มีอีกวิธีหนึ่งในการสร้างฟังก์ชัน ไม่ค่อยได้ใช้บ่อยนัก แต่บางครั้งก็ไม่มีทางเลือกอื่น
 
-The syntax for creating a function:
+## ไวยากรณ์
+
+ไวยากรณ์สำหรับสร้างฟังก์ชัน:
 
 ```js
 let func = new Function ([arg1, arg2, ...argN], functionBody);
 ```
 
-The function is created with the arguments `arg1...argN` and the given `functionBody`.
+ฟังก์ชันจะถูกสร้างขึ้นโดยรับอาร์กิวเมนต์ `arg1...argN` และ `functionBody` ที่กำหนดให้
 
-It's easier to understand by looking at an example. Here's a function with two arguments:
+ลองดูตัวอย่างจะเข้าใจง่ายกว่า นี่คือฟังก์ชันที่มีพารามิเตอร์สองตัว:
 
 ```js run
 let sum = new Function('a', 'b', 'return a + b');
@@ -21,7 +22,7 @@ let sum = new Function('a', 'b', 'return a + b');
 alert( sum(1, 2) ); // 3
 ```
 
-And here there's a function without arguments, with only the function body:
+แล้วนี่คือฟังก์ชันที่ไม่มีพารามิเตอร์ มีแค่ส่วน body:
 
 ```js run
 let sayHi = new Function('alert("Hello")');
@@ -29,11 +30,11 @@ let sayHi = new Function('alert("Hello")');
 sayHi(); // Hello
 ```
 
-The major difference from other ways we've seen is that the function is created literally from a string, that is passed at run time.
+ข้อแตกต่างหลักจากวิธีอื่นๆ ที่เราเคยเห็นมา คือฟังก์ชันนี้ถูกสร้างจากสตริงโดยตรง ซึ่งส่งเข้ามาตอนรันไทม์
 
-All previous declarations required us, programmers, to write the function code in the script.
+วิธีประกาศฟังก์ชันแบบเดิมๆ ทั้งหมดนั้น เราต้องเขียนโค้ดของฟังก์ชันไว้ในสคริปต์ล่วงหน้า
 
-But `new Function` allows to turn any string into a function. For example, we can receive a new function from a server and then execute it:
+แต่ `new Function` ช่วยให้เราเปลี่ยนสตริงอะไรก็ได้ให้กลายเป็นฟังก์ชัน เช่น เราอาจรับฟังก์ชันใหม่จากเซิร์ฟเวอร์แล้วนำมารันได้เลย:
 
 ```js
 let str = ... receive the code from a server dynamically ...
@@ -42,15 +43,15 @@ let func = new Function(str);
 func();
 ```
 
-It is used in very specific cases, like when we receive code from a server, or to dynamically compile a function from a template, in complex web-applications.
+วิธีนี้ใช้ในกรณีเฉพาะทางมากๆ เช่น เมื่อต้องรับโค้ดจากเซิร์ฟเวอร์ หรือต้องคอมไพล์ฟังก์ชันจาก template แบบไดนามิกในเว็บแอปพลิเคชันที่ซับซ้อน
 
-## Closure
+## คลอเชอร์
 
-Usually, a function remembers where it was born in the special property `[[Environment]]`. It references the Lexical Environment from where it's created  (we covered that in the chapter <info:closure>).
+ปกติแล้วฟังก์ชันจะจดจำว่าตัวเองถูกสร้างที่ไหน ผ่านพร็อพเพอร์ตี้พิเศษ `[[Environment]]` ซึ่งอ้างอิงไปยัง Lexical Environment ของที่ที่ฟังก์ชันถูกสร้างขึ้นมา (เราเคยอธิบายเรื่องนี้ไปในบท <info:closure>)
 
-But when a function is created using `new Function`, its `[[Environment]]` is set to reference not the current Lexical Environment, but the global one.
+แต่เมื่อสร้างฟังก์ชันด้วย `new Function` ตัว `[[Environment]]` จะถูกตั้งค่าให้อ้างอิงไปยัง Lexical Environment ระดับ global แทน ไม่ใช่ตัวที่อยู่รอบๆ
 
-So, such function doesn't have access to outer variables, only to the global ones.
+ดังนั้นฟังก์ชันแบบนี้จะเข้าถึงตัวแปรภายนอกไม่ได้ เข้าถึงได้แค่ตัวแปร global เท่านั้น
 
 ```js run
 function getFunc() {
@@ -66,7 +67,7 @@ function getFunc() {
 getFunc()(); // error: value is not defined
 ```
 
-Compare it with the regular behavior:
+ลองเทียบกับพฤติกรรมปกติดู:
 
 ```js run
 function getFunc() {
@@ -79,45 +80,45 @@ function getFunc() {
   return func;
 }
 
-getFunc()(); // *!*"test"*/!*, from the Lexical Environment of getFunc
+getFunc()(); // *!*"test"*/!*, จาก Lexical Environment ของ getFunc
 ```
 
-This special feature of `new Function` looks strange, but appears very useful in practice.
+ฟีเจอร์พิเศษของ `new Function` ตรงนี้อาจดูแปลกๆ แต่ในทางปฏิบัติกลับมีประโยชน์มาก
 
-Imagine that we must create a function from a string. The code of that function is not known at the time of writing the script (that's why we don't use regular functions), but will be known in the process of execution. We may receive it from the server or from another source.
+ลองนึกภาพว่าเราต้องสร้างฟังก์ชันจากสตริง โดยที่โค้ดของฟังก์ชันนั้นยังไม่รู้ตอนเขียนสคริปต์ (จึงใช้ฟังก์ชันแบบปกติไม่ได้) แต่จะรู้ตอนรันโปรแกรมจริง อาจรับมาจากเซิร์ฟเวอร์หรือแหล่งอื่นก็ได้
 
-Our new function needs to interact with the main script.
+ฟังก์ชันใหม่ของเราจำเป็นต้องทำงานร่วมกับสคริปต์หลัก
 
-What if it could access the outer variables?
+แล้วถ้ามันเข้าถึงตัวแปรภายนอกได้ล่ะ จะเกิดอะไรขึ้น?
 
-The problem is that before JavaScript is published to production, it's compressed using a *minifier* -- a special program that shrinks code by removing extra comments, spaces and -- what's important, renames local variables into shorter ones.
+ปัญหาคือ ก่อนที่ JavaScript จะถูกนำไปใช้งานจริง (production) โค้ดจะถูกบีบอัดด้วย *minifier* ซึ่งเป็นโปรแกรมที่ย่อโค้ดให้เล็กลง โดยตัดคอมเมนต์ ช่องว่าง และที่สำคัญคือ เปลี่ยนชื่อตัวแปรภายในฟังก์ชันให้สั้นลง
 
-For instance, if a function has `let userName`, minifier replaces it with `let a` (or another letter if this one is occupied), and does it everywhere. That's usually a safe thing to do, because the variable is local, nothing outside the function can access it. And inside the function, minifier replaces every mention of it. Minifiers are smart, they analyze the code structure, so they don't break anything. They're not just a dumb find-and-replace.
+ยกตัวอย่างเช่น ถ้าฟังก์ชันมี `let userName` ตัว minifier จะเปลี่ยนเป็น `let a` (หรือตัวอักษรอื่นถ้า a ถูกใช้ไปแล้ว) และเปลี่ยนทุกที่ที่ใช้ตัวแปรนี้ด้วย ปกติทำแบบนี้ปลอดภัย เพราะตัวแปรเป็นแบบ local ไม่มีอะไรข้างนอกฟังก์ชันเข้าถึงได้ ส่วนภายในฟังก์ชัน minifier ก็เปลี่ยนชื่อทุกจุดที่ใช้ตัวแปรนั้น Minifier ฉลาดพอที่จะวิเคราะห์โครงสร้างโค้ดได้ จึงไม่ทำอะไรพัง ไม่ใช่แค่ find-and-replace แบบสุ่มสี่สุ่มห้า
 
-So if `new Function` had access to outer variables, it would be unable to find renamed  `userName`.
+ดังนั้นถ้า `new Function` เข้าถึงตัวแปรภายนอกได้ มันก็จะหา `userName` ที่ถูกเปลี่ยนชื่อแล้วไม่เจอ
 
-**If `new Function` had access to outer variables, it would have problems with minifiers.**
+**ถ้า `new Function` เข้าถึงตัวแปรภายนอกได้ จะเกิดปัญหากับ minifier**
 
-Besides, such code would be architecturally bad and prone to errors.
+นอกจากนี้ โค้ดแบบนั้นยังออกแบบมาไม่ดีและมีโอกาสเกิดข้อผิดพลาดสูงอีกด้วย
 
-To pass something to a function, created as `new Function`, we should use its arguments.
+หากต้องการส่งข้อมูลเข้าไปในฟังก์ชันที่สร้างด้วย `new Function` ให้ส่งผ่านอาร์กิวเมนต์แทน
 
-## Summary
+## สรุป
 
-The syntax:
+ไวยากรณ์:
 
 ```js
 let func = new Function ([arg1, arg2, ...argN], functionBody);
 ```
 
-For historical reasons, arguments can also be given as a comma-separated list.
+ด้วยเหตุผลทางประวัติศาสตร์ อาร์กิวเมนต์สามารถส่งเป็นรายการคั่นด้วยจุลภาคก็ได้
 
-These three declarations mean the same:
+ทั้งสามแบบนี้มีความหมายเหมือนกัน:
 
 ```js
-new Function('a', 'b', 'return a + b'); // basic syntax
-new Function('a,b', 'return a + b'); // comma-separated
-new Function('a , b', 'return a + b'); // comma-separated with spaces
+new Function('a', 'b', 'return a + b'); // ไวยากรณ์พื้นฐาน
+new Function('a,b', 'return a + b'); // คั่นด้วยจุลภาค
+new Function('a , b', 'return a + b'); // คั่นด้วยจุลภาคและช่องว่าง
 ```
 
-Functions created with `new Function`, have `[[Environment]]` referencing the global Lexical Environment, not the outer one. Hence, they cannot use outer variables. But that's actually good, because it insures us from errors. Passing parameters explicitly is a much better method architecturally and causes no problems with minifiers.
+ฟังก์ชันที่สร้างด้วย `new Function` จะมี `[[Environment]]` อ้างอิงไปยัง Lexical Environment ระดับ global ไม่ใช่ตัวภายนอก ดังนั้นจึงใช้ตัวแปรภายนอกไม่ได้ ซึ่งจริงๆ แล้วเป็นเรื่องดี เพราะช่วยป้องกันข้อผิดพลาด การส่งพารามิเตอร์เข้าไปอย่างชัดเจนนั้นเป็นวิธีที่ดีกว่าทั้งในแง่สถาปัตยกรรม และไม่มีปัญหากับ minifier ด้วย
diff --git a/1-js/06-advanced-functions/08-settimeout-setinterval/1-output-numbers-100ms/solution.md b/1-js/06-advanced-functions/08-settimeout-setinterval/1-output-numbers-100ms/solution.md
index b5b1da7a6..794aa403e 100644
--- a/1-js/06-advanced-functions/08-settimeout-setinterval/1-output-numbers-100ms/solution.md
+++ b/1-js/06-advanced-functions/08-settimeout-setinterval/1-output-numbers-100ms/solution.md
@@ -1,5 +1,5 @@
 
-Using `setInterval`:
+ใช้ `setInterval`:
 
 ```js run
 function printNumbers(from, to) {
@@ -14,11 +14,11 @@ function printNumbers(from, to) {
   }, 1000);
 }
 
-// usage:
+// ตัวอย่างการใช้งาน:
 printNumbers(5, 10);
 ```
 
-Using nested `setTimeout`:
+ใช้ `setTimeout` แบบซ้อน:
 
 
 ```js run
@@ -34,13 +34,13 @@ function printNumbers(from, to) {
   }, 1000);
 }
 
-// usage:
+// ตัวอย่างการใช้งาน:
 printNumbers(5, 10);
 ```
 
-Note that in both solutions, there is an initial delay before the first output. The function is called after `1000ms` the first time.
+สังเกตว่าทั้งสองแบบจะมีการหน่วงเวลาก่อนแสดงผลครั้งแรก เพราะฟังก์ชันจะถูกเรียกหลังจากผ่านไป `1000ms` ในครั้งแรก
 
-If we also want the function to run immediately, then we can add an additional call on a separate line, like this:
+ถ้าต้องการให้ฟังก์ชันทำงานทันทีด้วย ก็เพิ่มการเรียกอีกครั้งแยกออกมาแบบนี้:
 
 ```js run
 function printNumbers(from, to) {
diff --git a/1-js/06-advanced-functions/08-settimeout-setinterval/1-output-numbers-100ms/task.md b/1-js/06-advanced-functions/08-settimeout-setinterval/1-output-numbers-100ms/task.md
index 84bb0c39c..c1b39c93d 100644
--- a/1-js/06-advanced-functions/08-settimeout-setinterval/1-output-numbers-100ms/task.md
+++ b/1-js/06-advanced-functions/08-settimeout-setinterval/1-output-numbers-100ms/task.md
@@ -2,11 +2,11 @@ importance: 5
 
 ---
 
-# Output every second
+# แสดงผลทุกวินาที
 
-Write a function `printNumbers(from, to)` that outputs a number every second, starting from `from` and ending with `to`.
+เขียนฟังก์ชัน `printNumbers(from, to)` ที่แสดงตัวเลขทุกๆ หนึ่งวินาที เริ่มจาก `from` ไปจนถึง `to`
 
-Make two variants of the solution.
+ให้เขียนคำตอบสองแบบ
 
-1. Using `setInterval`.
-2. Using nested `setTimeout`.
+1. ใช้ `setInterval`
+2. ใช้ `setTimeout` แบบซ้อน
diff --git a/1-js/06-advanced-functions/08-settimeout-setinterval/4-settimeout-result/solution.md b/1-js/06-advanced-functions/08-settimeout-setinterval/4-settimeout-result/solution.md
index e652a3b36..405ff3000 100644
--- a/1-js/06-advanced-functions/08-settimeout-setinterval/4-settimeout-result/solution.md
+++ b/1-js/06-advanced-functions/08-settimeout-setinterval/4-settimeout-result/solution.md
@@ -1,15 +1,15 @@
 
-Any `setTimeout` will run only after the current code has finished.
+`setTimeout` จะทำงานก็ต่อเมื่อโค้ดปัจจุบันรันเสร็จแล้วเท่านั้น
 
-The `i` will be the last one: `100000000`.
+ดังนั้น `i` จะเป็นค่าสุดท้าย คือ `100000000`
 
 ```js run
 let i = 0;
 
 setTimeout(() => alert(i), 100); // 100000000
 
-// assume that the time to execute this function is >100ms
+// สมมติว่าโค้ดในฟังก์ชันนี้ใช้เวลาทำงานมากกว่า 100ms
 for(let j = 0; j < 100000000; j++) {
-  i++; 
+  i++;
 }
 ```
diff --git a/1-js/06-advanced-functions/08-settimeout-setinterval/4-settimeout-result/task.md b/1-js/06-advanced-functions/08-settimeout-setinterval/4-settimeout-result/task.md
index 667c8ffa6..1af14fd88 100644
--- a/1-js/06-advanced-functions/08-settimeout-setinterval/4-settimeout-result/task.md
+++ b/1-js/06-advanced-functions/08-settimeout-setinterval/4-settimeout-result/task.md
@@ -2,26 +2,26 @@ importance: 5
 
 ---
 
-# What will setTimeout show?
+# setTimeout จะแสดงผลอะไร?
 
-In the code below there's a `setTimeout` call scheduled, then a heavy calculation is run, that takes more than 100ms to finish.
+ในโค้ดด้านล่างมีการตั้ง `setTimeout` ไว้ จากนั้นก็มีการคำนวณหนักๆ ที่ใช้เวลามากกว่า 100ms
 
-When will the scheduled function run?
+ฟังก์ชันที่ตั้งเวลาไว้จะทำงานเมื่อไหร่?
 
-1. After the loop.
-2. Before the loop.
-3. In the beginning of the loop.
+1. หลังลูปจบ
+2. ก่อนลูปเริ่ม
+3. ตอนลูปเริ่มต้น
 
 
-What is `alert` going to show?
+`alert` จะแสดงค่าอะไร?
 
 ```js
 let i = 0;
 
 setTimeout(() => alert(i), 100); // ?
 
-// assume that the time to execute this function is >100ms
+// สมมติว่าโค้ดในฟังก์ชันนี้ใช้เวลาทำงานมากกว่า 100ms
 for(let j = 0; j < 100000000; j++) {
-  i++; 
+  i++;
 }
 ```
diff --git a/1-js/06-advanced-functions/08-settimeout-setinterval/article.md b/1-js/06-advanced-functions/08-settimeout-setinterval/article.md
index fc033c5e2..a2488f64c 100644
--- a/1-js/06-advanced-functions/08-settimeout-setinterval/article.md
+++ b/1-js/06-advanced-functions/08-settimeout-setinterval/article.md
@@ -1,35 +1,35 @@
-# Scheduling: setTimeout and setInterval
+# การตั้งเวลา: setTimeout และ setInterval
 
-We may decide to execute a function not right now, but at a certain time later. That's called "scheduling a call".
+บางครั้งเราไม่ได้ต้องการให้ฟังก์ชันทำงานทันที แต่ต้องการให้ทำงานในอีกสักพักหนึ่ง ซึ่งก็คือ "การตั้งเวลาเรียกฟังก์ชัน" (scheduling a call) นั่นเอง
 
-There are two methods for it:
+เมธอดที่ใช้กันมี 2 ตัวด้วยกัน:
 
-- `setTimeout` allows us to run a function once after the interval of time.
-- `setInterval` allows us to run a function repeatedly, starting after the interval of time, then repeating continuously at that interval.
+- `setTimeout` ใช้เรียกฟังก์ชัน **ครั้งเดียว** หลังจากผ่านไปตามเวลาที่กำหนด
+- `setInterval` ใช้เรียกฟังก์ชัน **ซ้ำไปเรื่อยๆ** ตามช่วงเวลาที่กำหนด
 
-These methods are not a part of JavaScript specification. But most environments have the internal scheduler and provide these methods. In particular, they are supported in all browsers and Node.js.
+เมธอดเหล่านี้ไม่ได้อยู่ในสเปกของ JavaScript โดยตรง แต่สภาพแวดล้อมส่วนใหญ่ก็มี internal scheduler และรองรับเมธอดเหล่านี้ โดยเฉพาะเบราว์เซอร์ทุกตัวและ Node.js
 
 ## setTimeout
 
-The syntax:
+ไวยากรณ์:
 
 ```js
 let timerId = setTimeout(func|code, [delay], [arg1], [arg2], ...)
 ```
 
-Parameters:
+พารามิเตอร์:
 
 `func|code`
-: Function or a string of code to execute.
-Usually, that's a function. For historical reasons, a string of code can be passed, but that's not recommended.
+: ฟังก์ชันหรือสตริงของโค้ดที่ต้องการเรียก
+โดยปกติจะส่งเป็นฟังก์ชัน ส่งเป็นสตริงก็ได้เหมือนกัน (เนื่องจากเหตุผลทางประวัติศาสตร์) แต่ไม่แนะนำ
 
 `delay`
-: The delay before run, in milliseconds (1000 ms = 1 second), by default 0.
+: ระยะเวลาหน่วงก่อนเรียก หน่วยเป็นมิลลิวินาที (1000 ms = 1 วินาที) ค่าเริ่มต้นคือ 0
 
 `arg1`, `arg2`...
-: Arguments for the function
+: อาร์กิวเมนต์ที่จะส่งให้ฟังก์ชัน
 
-For instance, this code calls `sayHi()` after one second:
+ตัวอย่างนี้จะเรียก `sayHi()` หลังจากผ่านไป 1 วินาที:
 
 ```js run
 function sayHi() {
@@ -41,7 +41,7 @@ setTimeout(sayHi, 1000);
 */!*
 ```
 
-With arguments:
+พร้อมส่งอาร์กิวเมนต์:
 
 ```js run
 function sayHi(phrase, who) {
@@ -53,93 +53,93 @@ setTimeout(sayHi, 1000, "Hello", "John"); // Hello, John
 */!*
 ```
 
-If the first argument is a string, then JavaScript creates a function from it.
+ถ้าอาร์กิวเมนต์ตัวแรกเป็นสตริง JavaScript จะสร้างฟังก์ชันขึ้นมาจากสตริงนั้น
 
-So, this will also work:
+ดังนั้นโค้ดนี้ก็ใช้ได้เหมือนกัน:
 
 ```js run no-beautify
 setTimeout("alert('Hello')", 1000);
 ```
 
-But using strings is not recommended, use arrow functions instead of them, like this:
+แต่ไม่แนะนำให้ส่งเป็นสตริง ให้ใช้ arrow function แทนแบบนี้:
 
 ```js run no-beautify
 setTimeout(() => alert('Hello'), 1000);
 ```
 
-````smart header="Pass a function, but don't run it"
-Novice developers sometimes make a mistake by adding brackets `()` after the function:
+````smart header="ส่งฟังก์ชันเข้าไป ไม่ใช่เรียกฟังก์ชัน"
+มือใหม่มักพลาดตรงที่ใส่วงเล็บ `()` ต่อท้ายฟังก์ชัน:
 
 ```js
-// wrong!
+// ผิด!
 setTimeout(sayHi(), 1000);
 ```
-That doesn't work, because `setTimeout` expects a reference to a function. And here `sayHi()` runs the function, and the *result of its execution* is passed to `setTimeout`. In our case the result of `sayHi()` is `undefined` (the function returns nothing), so nothing is scheduled.
+แบบนี้ไม่ทำงาน เพราะ `setTimeout` ต้องการ **reference** ไปยังฟังก์ชัน แต่ `sayHi()` คือการเรียกฟังก์ชันทันที แล้วส่ง *ผลลัพธ์ที่ได้* ไปให้ `setTimeout` ซึ่งในกรณีนี้ `sayHi()` คืนค่า `undefined` (เพราะไม่ได้ return อะไร) จึงไม่มีอะไรถูกตั้งเวลาไว้เลย
 ````
 
-### Canceling with clearTimeout
+### ยกเลิกด้วย clearTimeout
 
-A call to `setTimeout` returns a "timer identifier" `timerId` that we can use to cancel the execution.
+เมื่อเรียก `setTimeout` จะได้ "ตัวระบุ timer" (`timerId`) กลับมา ซึ่งใช้ยกเลิกการทำงานได้
 
-The syntax to cancel:
+ไวยากรณ์สำหรับยกเลิก:
 
 ```js
 let timerId = setTimeout(...);
 clearTimeout(timerId);
 ```
 
-In the code below, we schedule the function and then cancel it (changed our mind). As a result, nothing happens:
+โค้ดด้านล่างตั้งเวลาเรียกฟังก์ชัน แล้วยกเลิกทิ้ง (เปลี่ยนใจ) ผลคือไม่มีอะไรเกิดขึ้น:
 
 ```js run no-beautify
 let timerId = setTimeout(() => alert("never happens"), 1000);
-alert(timerId); // timer identifier
+alert(timerId); // ตัวระบุ timer
 
 clearTimeout(timerId);
-alert(timerId); // same identifier (doesn't become null after canceling)
+alert(timerId); // ตัวระบุเดิม (ไม่ได้กลายเป็น null หลังยกเลิก)
 ```
 
-As we can see from `alert` output, in a browser the timer identifier is a number. In other environments, this can be something else. For instance, Node.js returns a timer object with additional methods.
+จะเห็นจาก `alert` ว่าในเบราว์เซอร์ ตัวระบุ timer จะเป็นตัวเลข ส่วนสภาพแวดล้อมอื่นอาจเป็นอย่างอื่นก็ได้ เช่น Node.js จะคืนค่าเป็น timer object ที่มีเมธอดเพิ่มเติม
 
-Again, there is no universal specification for these methods, so that's fine.
+เมธอดเหล่านี้ไม่มีสเปกกลาง จึงไม่มีปัญหาอะไร
 
-For browsers, timers are described in the [timers section](https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#timers) of HTML Living Standard.
+สำหรับเบราว์เซอร์ timer อธิบายไว้ใน [ส่วน timers](https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#timers) ของ HTML Living Standard
 
 ## setInterval
 
-The `setInterval` method has the same syntax as `setTimeout`:
+เมธอด `setInterval` มีไวยากรณ์เหมือน `setTimeout`:
 
 ```js
 let timerId = setInterval(func|code, [delay], [arg1], [arg2], ...)
 ```
 
-All arguments have the same meaning. But unlike `setTimeout` it runs the function not only once, but regularly after the given interval of time.
+อาร์กิวเมนต์ทุกตัวมีความหมายเหมือนกัน แต่ต่างจาก `setTimeout` ตรงที่ `setInterval` จะเรียกฟังก์ชัน **ซ้ำไปเรื่อยๆ** ตามช่วงเวลาที่กำหนด ไม่ใช่แค่ครั้งเดียว
 
-To stop further calls, we should call `clearInterval(timerId)`.
+หยุดการเรียกซ้ำได้ด้วย `clearInterval(timerId)`
 
-The following example will show the message every 2 seconds. After 5 seconds, the output is stopped:
+ตัวอย่างนี้จะแสดงข้อความทุกๆ 2 วินาที แล้วหยุดหลังจาก 5 วินาที:
 
 ```js run
-// repeat with the interval of 2 seconds
+// ทำซ้ำทุก 2 วินาที
 let timerId = setInterval(() => alert('tick'), 2000);
 
-// after 5 seconds stop
+// หยุดหลังจาก 5 วินาที
 setTimeout(() => { clearInterval(timerId); alert('stop'); }, 5000);
 ```
 
-```smart header="Time goes on while `alert` is shown"
-In most browsers, including Chrome and Firefox the internal timer continues "ticking" while showing `alert/confirm/prompt`.
+```smart header="เวลายังเดินต่อขณะที่ `alert` แสดงอยู่"
+ในเบราว์เซอร์ส่วนใหญ่ รวมถึง Chrome และ Firefox ตัวจับเวลาภายในจะยังคง "เดิน" อยู่ขณะที่แสดง `alert/confirm/prompt`
 
-So if you run the code above and don't dismiss the `alert` window for some time, then the next `alert` will be shown immediately as you do it. The actual interval between alerts will be shorter than 2 seconds.
+ดังนั้น ถ้ารันโค้ดด้านบนแล้วไม่ปิดหน้าต่าง `alert` สักพัก พอปิดปุ๊บ `alert` ถัดไปจะแสดงขึ้นมาทันที ทำให้ช่วงเวลาระหว่าง alert แต่ละครั้งสั้นกว่า 2 วินาที
 ```
 
-## Nested setTimeout
+## setTimeout แบบซ้อน
 
-There are two ways of running something regularly.
+การทำอะไรสักอย่างซ้ำๆ ตามเวลาทำได้ 2 วิธี
 
-One is `setInterval`. The other one is a nested `setTimeout`, like this:
+วิธีแรกคือใช้ `setInterval` อีกวิธีคือใช้ `setTimeout` แบบซ้อน แบบนี้:
 
 ```js
-/** instead of:
+/** แทนที่จะใช้:
 let timerId = setInterval(() => alert('tick'), 2000);
 */
 
@@ -151,13 +151,13 @@ let timerId = setTimeout(function tick() {
 }, 2000);
 ```
 
-The `setTimeout` above schedules the next call right at the end of the current one `(*)`.
+`setTimeout` ด้านบนจะตั้งเวลาเรียกครั้งถัดไปตรงท้ายของการเรียกปัจจุบัน `(*)`
 
-The nested `setTimeout` is a more flexible method than `setInterval`. This way the next call may be scheduled differently, depending on the results of the current one.
+`setTimeout` แบบซ้อนยืดหยุ่นกว่า `setInterval` ตรงที่เราปรับเวลาของการเรียกครั้งถัดไปได้ตามผลลัพธ์ของครั้งปัจจุบัน
 
-For instance, we need to write a service that sends a request to the server every 5 seconds asking for data, but in case the server is overloaded, it should increase the interval to 10, 20, 40 seconds...
+สมมติว่าเราต้องเขียนเซอร์วิสที่ส่ง request ไปยังเซิร์ฟเวอร์ทุกๆ 5 วินาทีเพื่อขอข้อมูล แต่ถ้าเซิร์ฟเวอร์โหลดหนัก ก็ค่อยๆ ยืดช่วงเวลาออกเป็น 10, 20, 40 วินาที...
 
-Here's the pseudocode:
+pseudocode จะเป็นแบบนี้:
 ```js
 let delay = 5000;
 
@@ -165,7 +165,7 @@ let timerId = setTimeout(function request() {
   ...send request...
 
   if (request failed due to server overload) {
-    // increase the interval to the next run
+    // ยืดช่วงเวลาสำหรับการเรียกครั้งถัดไป
     delay *= 2;
   }
 
@@ -175,11 +175,11 @@ let timerId = setTimeout(function request() {
 ```
 
 
-And if the functions that we're scheduling are CPU-hungry, then we can measure the time taken by the execution and plan the next call sooner or later.
+นอกจากนี้ ถ้าฟังก์ชันที่ตั้งเวลาไว้ใช้ CPU หนัก เราก็สามารถวัดเวลาที่ใช้ในการประมวลผลแล้วปรับเวลาเรียกครั้งถัดไปได้อีกด้วย
 
-**Nested `setTimeout` allows to set the delay between the executions more precisely than `setInterval`.**
+**`setTimeout` แบบซ้อนช่วยให้กำหนดเวลาหน่วงระหว่างการเรียกแต่ละครั้งได้แม่นยำกว่า `setInterval`**
 
-Let's compare two code fragments. The first one uses `setInterval`:
+มาเปรียบเทียบโค้ด 2 แบบกัน แบบแรกใช้ `setInterval`:
 
 ```js
 let i = 1;
@@ -188,7 +188,7 @@ setInterval(function() {
 }, 100);
 ```
 
-The second one uses nested `setTimeout`:
+แบบที่สองใช้ `setTimeout` แบบซ้อน:
 
 ```js
 let i = 1;
@@ -198,52 +198,52 @@ setTimeout(function run() {
 }, 100);
 ```
 
-For `setInterval` the internal scheduler will run `func(i++)` every 100ms:
+สำหรับ `setInterval` ตัว internal scheduler จะเรียก `func(i++)` ทุกๆ 100ms:
 
 ![](setinterval-interval.svg)
 
-Did you notice?
+สังเกตเห็นอะไรไหม?
 
-**The real delay between `func` calls for `setInterval` is less than in the code!**
+**เวลาหน่วงจริงระหว่างการเรียก `func` แต่ละครั้งของ `setInterval` จะ *น้อยกว่า* ที่กำหนดไว้ในโค้ด!**
 
-That's normal, because the time taken by `func`'s execution "consumes" a part of the interval.
+เป็นเรื่องปกติ เพราะเวลาที่ `func` ใช้ประมวลผลจะ "กินเวลา" ส่วนหนึ่งของช่วงเวลาที่กำหนดไว้
 
-It is possible that `func`'s execution turns out to be longer than we expected and takes more than 100ms.
+อาจเกิดกรณีที่ `func` ใช้เวลาประมวลผลนานกว่าที่คาดไว้ คือเกิน 100ms
 
-In this case the engine waits for `func` to complete, then checks the scheduler and if the time is up, runs it again *immediately*.
+ในกรณีนี้ engine จะรอให้ `func` ทำงานเสร็จก่อน แล้วค่อยเช็ค scheduler ถ้าถึงเวลาแล้วก็จะเรียกอีกครั้ง *ทันที*
 
-In the edge case, if the function always executes longer than `delay` ms, then the calls will happen without a pause at all.
+ในกรณีสุดโต่ง ถ้าฟังก์ชันทำงานนานกว่า `delay` ทุกครั้ง ก็จะถูกเรียกซ้ำโดยไม่มีช่วงหยุดเลย
 
-And here is the picture for the nested `setTimeout`:
+สำหรับ `setTimeout` แบบซ้อน ภาพจะเป็นแบบนี้:
 
 ![](settimeout-interval.svg)
 
-**The nested `setTimeout` ensures a minimum delay (100ms here) between the end of one call and the beginning of the subsequent one.**
+**`setTimeout` แบบซ้อนรับประกันว่าจะมีเวลาหน่วงขั้นต่ำ (100ms ในตัวอย่างนี้) ระหว่างจุดสิ้นสุดของการเรียกครั้งหนึ่งกับจุดเริ่มต้นของการเรียกครั้งถัดไป**
 
-That's because a new call is planned at the end of the previous one.
+เนื่องจากการเรียกครั้งใหม่จะถูกตั้งเวลาไว้ตอนท้ายของการเรียกครั้งก่อนเสมอ
 
-````smart header="Garbage collection and setInterval/setTimeout callback"
-When a function is passed in `setInterval/setTimeout`, an internal reference is created to it and saved in the scheduler. It prevents the function from being garbage collected, even if there are no other references to it.
+````smart header="การเก็บขยะกับคอลแบ็กของ setInterval/setTimeout"
+เมื่อส่งฟังก์ชันเข้าไปใน `setInterval/setTimeout` ระบบจะสร้าง internal reference ไปยังฟังก์ชันนั้นและเก็บไว้ใน scheduler ซึ่งป้องกันไม่ให้ฟังก์ชันถูกเก็บขยะ แม้จะไม่มี reference อื่นไปยังฟังก์ชันนั้นอยู่เลย
 
 ```js
-// the function stays in memory until the scheduler calls it
+// ฟังก์ชันจะอยู่ในหน่วยความจำจนกว่า scheduler จะเรียก
 setTimeout(function() {...}, 100);
 ```
 
-For `setInterval` the function stays in memory until `clearInterval` is called.
+สำหรับ `setInterval` ฟังก์ชันจะอยู่ในหน่วยความจำจนกว่าจะเรียก `clearInterval`
 
-There's a side effect. A function references the outer lexical environment, so, while it lives, outer variables live too. They may take much more memory than the function itself. So when we don't need the scheduled function anymore, it's better to cancel it, even if it's very small.
+แต่มีผลข้างเคียงอยู่ ฟังก์ชันจะอ้างอิงถึง outer Lexical Environment ด้วย ดังนั้นตราบใดที่ฟังก์ชันยังอยู่ ตัวแปรภายนอกก็จะยังอยู่เช่นกัน ซึ่งอาจกินหน่วยความจำมากกว่าตัวฟังก์ชันเสียอีก เพราะฉะนั้นเมื่อไม่ต้องการฟังก์ชันที่ตั้งเวลาไว้แล้ว ควรยกเลิกทิ้ง แม้ว่าฟังก์ชันจะเล็กก็ตาม
 ````
 
-## Zero delay setTimeout
+## setTimeout แบบหน่วงศูนย์
 
-There's a special use case: `setTimeout(func, 0)`, or just `setTimeout(func)`.
+มีกรณีพิเศษคือ `setTimeout(func, 0)` หรือเขียนสั้นๆ ว่า `setTimeout(func)`
 
-This schedules the execution of `func` as soon as possible. But the scheduler will invoke it only after the currently executing script is complete.
+วิธีนี้จะตั้งเวลาให้ `func` ทำงานเร็วที่สุดเท่าที่จะเป็นไปได้ แต่ scheduler จะเรียกฟังก์ชันหลังจากสคริปต์ปัจจุบันทำงานเสร็จแล้วเท่านั้น
 
-So the function is scheduled to run "right after" the current script.
+พูดง่ายๆ ก็คือ ฟังก์ชันจะถูกเรียก "ทันที" หลังจากโค้ดปัจจุบันจบ
 
-For instance, this outputs "Hello", then immediately "World":
+ตัวอย่างนี้จะแสดง "Hello" ก่อน แล้วตามด้วย "World" ทันที:
 
 ```js run
 setTimeout(() => alert("World"));
@@ -251,52 +251,52 @@ setTimeout(() => alert("World"));
 alert("Hello");
 ```
 
-The first line "puts the call into calendar after 0ms". But the scheduler will only "check the calendar" after the current script is complete, so `"Hello"` is first, and `"World"` -- after it.
+บรรทัดแรก "จองคิวเรียกฟังก์ชันหลังจาก 0ms" แต่ scheduler จะ "เช็คคิว" หลังจากสคริปต์ปัจจุบันเสร็จแล้วเท่านั้น ดังนั้น `"Hello"` จึงแสดงก่อน แล้ว `"World"` ถึงจะตามมา
 
-There are also advanced browser-related use cases of zero-delay timeout, that we'll discuss in the chapter <info:event-loop>.
+กรณีใช้งาน setTimeout แบบหน่วงศูนย์ในเบราว์เซอร์ขั้นสูงขึ้นจะกล่าวถึงในบท <info:event-loop>
 
-````smart header="Zero delay is in fact not zero (in a browser)"
-In the browser, there's a limitation of how often nested timers can run. The [HTML Living Standard](https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#timers) says: "after five nested timers, the interval is forced to be at least 4 milliseconds.".
+````smart header="หน่วงศูนย์จริงๆ แล้วไม่ใช่ศูนย์ (ในเบราว์เซอร์)"
+ในเบราว์เซอร์มีข้อจำกัดเรื่องความถี่ที่ timer ซ้อนกันจะทำงานได้ ตาม [HTML Living Standard](https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#timers) ระบุว่า: "หลังจาก timer ซ้อนกัน 5 ชั้น ช่วงเวลาจะถูกบังคับให้เป็นอย่างน้อย 4 มิลลิวินาที"
 
-Let's demonstrate what it means with the example below. The `setTimeout` call in it re-schedules itself with zero delay. Each call remembers the real time from the previous one in the `times` array. What do the real delays look like? Let's see:
+มาดูว่าหมายความว่าอย่างไรจากตัวอย่างด้านล่าง `setTimeout` ในโค้ดนี้จะตั้งเวลาเรียกตัวเองซ้ำด้วย delay เป็นศูนย์ แต่ละครั้งจะบันทึกเวลาจริงจากการเรียกครั้งก่อนไว้ในอาร์เรย์ `times` มาดูกันว่า delay จริงๆ เป็นเท่าไหร่:
 
 ```js run
 let start = Date.now();
 let times = [];
 
 setTimeout(function run() {
-  times.push(Date.now() - start); // remember delay from the previous call
+  times.push(Date.now() - start); // บันทึก delay จากการเรียกครั้งก่อน
 
-  if (start + 100 < Date.now()) alert(times); // show the delays after 100ms
-  else setTimeout(run); // else re-schedule
+  if (start + 100 < Date.now()) alert(times); // แสดง delay ทั้งหมดหลังจากผ่านไป 100ms
+  else setTimeout(run); // ถ้ายังไม่ถึง ตั้งเวลาเรียกใหม่
 });
 
-// an example of the output:
+// ตัวอย่างผลลัพธ์:
 // 1,1,1,1,9,15,20,24,30,35,40,45,50,55,59,64,70,75,80,85,90,95,100
 ```
 
-First timers run immediately (just as written in the spec), and then we see `9, 15, 20, 24...`. The 4+ ms obligatory delay between invocations comes into play.
+timer รอบแรกๆ จะทำงานทันที (ตามที่สเปกระบุไว้) หลังจากนั้นจะเริ่มเห็น `9, 15, 20, 24...` ซึ่งเป็นผลจาก delay บังคับขั้นต่ำ 4ms ขึ้นไปนั่นเอง
 
-The similar thing happens if we use `setInterval` instead of `setTimeout`: `setInterval(f)` runs `f` few times with zero-delay, and afterwards with 4+ ms delay.
+ใช้ `setInterval` แทน `setTimeout` ก็ได้ผลเหมือนกัน: `setInterval(f)` จะเรียก `f` รอบแรกๆ ด้วย delay เป็นศูนย์ แล้วหลังจากนั้นจะมี delay 4ms ขึ้นไป
 
-That limitation comes from ancient times and many scripts rely on it, so it exists for historical reasons.
+ข้อจำกัดนี้มีมาตั้งแต่สมัยก่อน และสคริปต์จำนวนมากพึ่งพาพฤติกรรมนี้อยู่ จึงยังคงอยู่ด้วยเหตุผลทางประวัติศาสตร์
 
-For server-side JavaScript, that limitation does not exist, and there exist other ways to schedule an immediate asynchronous job, like [setImmediate](https://nodejs.org/api/timers.html#timers_setimmediate_callback_args) for Node.js. So this note is browser-specific.
+สำหรับ JavaScript ฝั่งเซิร์ฟเวอร์ไม่มีข้อจำกัดนี้ และยังมีวิธีอื่นในการตั้งเวลา asynchronous job แบบทันทีอีกด้วย เช่น [setImmediate](https://nodejs.org/api/timers.html#timers_setimmediate_callback_args) ใน Node.js ข้อจำกัดนี้จึงเป็นเรื่องเฉพาะเบราว์เซอร์เท่านั้น
 ````
 
-## Summary
+## สรุป
 
-- Methods `setTimeout(func, delay, ...args)` and `setInterval(func, delay, ...args)` allow us to run the `func` once/regularly after `delay` milliseconds.
-- To cancel the execution, we should call `clearTimeout/clearInterval` with the value returned by `setTimeout/setInterval`.
-- Nested `setTimeout` calls are a more flexible alternative to `setInterval`, allowing us to set the time *between* executions more precisely.
-- Zero delay scheduling with `setTimeout(func, 0)` (the same as `setTimeout(func)`) is used to schedule the call "as soon as possible, but after the current script is complete".
-- The browser limits the minimal delay for five or more nested calls of `setTimeout` or for `setInterval` (after 5th call) to 4ms. That's for historical reasons.
+- เมธอด `setTimeout(func, delay, ...args)` และ `setInterval(func, delay, ...args)` ช่วยให้เรียกฟังก์ชันครั้งเดียว/ซ้ำๆ หลังจากผ่านไป `delay` มิลลิวินาที
+- ยกเลิกการทำงานได้ด้วย `clearTimeout/clearInterval` โดยส่งค่าที่ได้จาก `setTimeout/setInterval` เข้าไป
+- `setTimeout` แบบซ้อนเป็นทางเลือกที่ยืดหยุ่นกว่า `setInterval` และยังกำหนดเวลา *ระหว่าง* การเรียกแต่ละครั้งได้แม่นยำกว่าด้วย
+- การตั้งเวลาแบบหน่วงศูนย์ด้วย `setTimeout(func, 0)` (หรือ `setTimeout(func)`) ใช้เมื่อต้องการเรียกฟังก์ชัน "เร็วที่สุดเท่าที่จะได้ แต่ต้องรอให้สคริปต์ปัจจุบันเสร็จก่อน"
+- เบราว์เซอร์จำกัด delay ขั้นต่ำของ `setTimeout` หรือ `setInterval` ที่ซ้อนกันตั้งแต่ 5 ชั้นขึ้นไปไว้ที่ 4ms ด้วยเหตุผลทางประวัติศาสตร์
 
-Please note that all scheduling methods do not *guarantee* the exact delay.
+อย่าลืมว่าเมธอดตั้งเวลาทั้งหมดไม่ได้ *รับประกัน* ว่า delay จะตรงเป๊ะ
 
-For example, the in-browser timer may slow down for a lot of reasons:
-- The CPU is overloaded.
-- The browser tab is in the background mode.
-- The laptop is on battery saving mode.
+ตัวอย่างเช่น timer ในเบราว์เซอร์อาจช้าลงได้จากหลายสาเหตุ:
+- CPU โหลดหนัก
+- แท็บเบราว์เซอร์อยู่ในโหมดพื้นหลัง
+- แล็ปท็อปอยู่ในโหมดประหยัดแบตเตอรี่
 
-All that may increase the minimal timer resolution (the minimal delay) to 300ms or even 1000ms depending on the browser and OS-level performance settings.
+ทั้งหมดนี้อาจทำให้ความละเอียดขั้นต่ำของ timer (delay ขั้นต่ำ) เพิ่มขึ้นเป็น 300ms หรือแม้แต่ 1000ms ขึ้นอยู่กับเบราว์เซอร์และการตั้งค่าประสิทธิภาพระดับ OS
diff --git a/1-js/06-advanced-functions/09-call-apply-decorators/01-spy-decorator/_js.view/solution.js b/1-js/06-advanced-functions/09-call-apply-decorators/01-spy-decorator/_js.view/solution.js
index d5a09efb3..070eba825 100644
--- a/1-js/06-advanced-functions/09-call-apply-decorators/01-spy-decorator/_js.view/solution.js
+++ b/1-js/06-advanced-functions/09-call-apply-decorators/01-spy-decorator/_js.view/solution.js
@@ -1,7 +1,7 @@
 function spy(func) {
 
   function wrapper(...args) {
-    // using ...args instead of arguments to store "real" array in wrapper.calls
+    // ใช้ ...args แทน arguments เพื่อเก็บอาร์เรย์ "จริงๆ" ใน wrapper.calls
     wrapper.calls.push(args);
     return func.apply(this, args);
   }
diff --git a/1-js/06-advanced-functions/09-call-apply-decorators/01-spy-decorator/_js.view/source.js b/1-js/06-advanced-functions/09-call-apply-decorators/01-spy-decorator/_js.view/source.js
index 38da0105f..02926bf65 100644
--- a/1-js/06-advanced-functions/09-call-apply-decorators/01-spy-decorator/_js.view/source.js
+++ b/1-js/06-advanced-functions/09-call-apply-decorators/01-spy-decorator/_js.view/source.js
@@ -1,5 +1,5 @@
 function spy(func) {
-  // your code
+  // โค้ดของคุณ
 }
 
 
diff --git a/1-js/06-advanced-functions/09-call-apply-decorators/01-spy-decorator/solution.md b/1-js/06-advanced-functions/09-call-apply-decorators/01-spy-decorator/solution.md
index 0c8a211b4..fd3e53ed7 100644
--- a/1-js/06-advanced-functions/09-call-apply-decorators/01-spy-decorator/solution.md
+++ b/1-js/06-advanced-functions/09-call-apply-decorators/01-spy-decorator/solution.md
@@ -1 +1 @@
-The wrapper returned by `spy(f)` should store all arguments and then use `f.apply` to forward the call.
+wrapper ที่คืนค่าจาก `spy(f)` ควรเก็บอาร์กิวเมนต์ทั้งหมดไว้ แล้วใช้ `f.apply` เพื่อส่งต่อการเรียกไปยังฟังก์ชันเดิม
diff --git a/1-js/06-advanced-functions/09-call-apply-decorators/01-spy-decorator/task.md b/1-js/06-advanced-functions/09-call-apply-decorators/01-spy-decorator/task.md
index a3843107c..6cf559134 100644
--- a/1-js/06-advanced-functions/09-call-apply-decorators/01-spy-decorator/task.md
+++ b/1-js/06-advanced-functions/09-call-apply-decorators/01-spy-decorator/task.md
@@ -4,15 +4,15 @@ importance: 5
 
 # Spy decorator
 
-Create a decorator `spy(func)` that should return a wrapper that saves all calls to function in its `calls` property.
+สร้าง decorator `spy(func)` ที่คืนค่า wrapper ซึ่งบันทึกทุกการเรียกใช้ฟังก์ชันไว้ในพร็อพเพอร์ตี้ `calls`
 
-Every call is saved as an array of arguments.
+แต่ละการเรียกจะถูกบันทึกเป็นอาร์เรย์ของอาร์กิวเมนต์
 
-For instance:
+ตัวอย่าง:
 
 ```js
 function work(a, b) {
-  alert( a + b ); // work is an arbitrary function or method
+  alert( a + b ); // work เป็นฟังก์ชันหรือเมธอดอะไรก็ได้
 }
 
 *!*
@@ -27,4 +27,4 @@ for (let args of work.calls) {
 }
 ```
 
-P.S. That decorator is sometimes useful for unit-testing. Its advanced form is `sinon.spy` in [Sinon.JS](http://sinonjs.org/) library.
+P.S. decorator ตัวนี้มีประโยชน์สำหรับ unit testing บางครั้ง รูปแบบขั้นสูงของมันคือ `sinon.spy` ในไลบรารี [Sinon.JS](http://sinonjs.org/)
diff --git a/1-js/06-advanced-functions/09-call-apply-decorators/02-delay/solution.md b/1-js/06-advanced-functions/09-call-apply-decorators/02-delay/solution.md
index 24bb4d448..62c6f99dd 100644
--- a/1-js/06-advanced-functions/09-call-apply-decorators/02-delay/solution.md
+++ b/1-js/06-advanced-functions/09-call-apply-decorators/02-delay/solution.md
@@ -1,4 +1,4 @@
-The solution:
+คำตอบ:
 
 ```js run demo
 function delay(f, ms) {
@@ -11,22 +11,22 @@ function delay(f, ms) {
 
 let f1000 = delay(alert, 1000);
 
-f1000("test"); // shows "test" after 1000ms
+f1000("test"); // แสดง "test" หลังจาก 1000ms
 ```
 
-Please note how an arrow function is used here. As we know, arrow functions do not have own `this` and `arguments`, so `f.apply(this, arguments)` takes `this` and `arguments` from the wrapper.
+สังเกตว่าตรงนี้ใช้ arrow function เพราะอย่างที่เรารู้กัน arrow function ไม่มี `this` และ `arguments` เป็นของตัวเอง ดังนั้น `f.apply(this, arguments)` จะดึง `this` และ `arguments` มาจาก wrapper ภายนอก
 
-If we pass a regular function, `setTimeout` would call it without arguments and `this=window` (assuming we're in the browser).
+ถ้าเราส่งฟังก์ชันปกติเข้าไปแทน `setTimeout` จะเรียกฟังก์ชันนั้นโดยไม่มีอาร์กิวเมนต์ และ `this=window` (ในกรณีที่อยู่บนเบราว์เซอร์)
 
-We still can pass the right `this` by using an intermediate variable, but that's a little bit more cumbersome:
+เราก็ยังส่ง `this` ที่ถูกต้องได้โดยใช้ตัวแปรตัวกลาง แต่โค้ดจะยุ่งยากกว่าหน่อย:
 
 ```js
 function delay(f, ms) {
 
   return function(...args) {
-    let savedThis = this; // store this into an intermediate variable
+    let savedThis = this; // เก็บ this ไว้ในตัวแปรตัวกลาง
     setTimeout(function() {
-      f.apply(savedThis, args); // use it here
+      f.apply(savedThis, args); // แล้วเอามาใช้ตรงนี้
     }, ms);
   };
 
diff --git a/1-js/06-advanced-functions/09-call-apply-decorators/02-delay/task.md b/1-js/06-advanced-functions/09-call-apply-decorators/02-delay/task.md
index c04c68d7e..d3abe709e 100644
--- a/1-js/06-advanced-functions/09-call-apply-decorators/02-delay/task.md
+++ b/1-js/06-advanced-functions/09-call-apply-decorators/02-delay/task.md
@@ -4,23 +4,23 @@ importance: 5
 
 # Delaying decorator
 
-Create a decorator `delay(f, ms)` that delays each call of `f` by `ms` milliseconds.
+สร้าง decorator `delay(f, ms)` ที่หน่วงเวลาทุกการเรียก `f` ออกไป `ms` มิลลิวินาที
 
-For instance:
+ตัวอย่าง:
 
 ```js
 function f(x) {
   alert(x);
 }
 
-// create wrappers
+// สร้าง wrapper
 let f1000 = delay(f, 1000);
 let f1500 = delay(f, 1500);
 
-f1000("test"); // shows "test" after 1000ms
-f1500("test"); // shows "test" after 1500ms
+f1000("test"); // แสดง "test" หลังจาก 1000ms
+f1500("test"); // แสดง "test" หลังจาก 1500ms
 ```
 
-In other words, `delay(f, ms)` returns a "delayed by `ms`" variant of `f`.
+พูดง่ายๆ ก็คือ `delay(f, ms)` จะคืนค่าเป็น `f` เวอร์ชัน "หน่วงเวลา `ms`"
 
-In the code above, `f` is a function of a single argument, but your solution should pass all arguments and the context `this`.
+ในโค้ดด้านบน `f` เป็นฟังก์ชันที่รับอาร์กิวเมนต์ตัวเดียว แต่คำตอบของคุณควรส่งต่ออาร์กิวเมนต์ทั้งหมดและ context `this` ด้วย
diff --git a/1-js/06-advanced-functions/09-call-apply-decorators/03-debounce/debounce.view/index.html b/1-js/06-advanced-functions/09-call-apply-decorators/03-debounce/debounce.view/index.html
index e3b4d5842..ec9352abf 100644
--- a/1-js/06-advanced-functions/09-call-apply-decorators/03-debounce/debounce.view/index.html
+++ b/1-js/06-advanced-functions/09-call-apply-decorators/03-debounce/debounce.view/index.html
@@ -1,18 +1,18 @@
 <!doctype html>
 <script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.11/lodash.js"></script>
 
-Function <code>handler</code> is called on this input:
+ฟังก์ชัน <code>handler</code> ถูกเรียกจาก input นี้:
 <br>
-<input id="input1" placeholder="type here">
+<input id="input1" placeholder="พิมพ์ตรงนี้">
 
 <p>
 
-Debounced function <code>debounce(handler, 1000)</code> is called on this input:
+ฟังก์ชันที่ debounce แล้ว <code>debounce(handler, 1000)</code> ถูกเรียกจาก input นี้:
 <br>
-<input id="input2" placeholder="type here">
+<input id="input2" placeholder="พิมพ์ตรงนี้">
 
 <p>
-<button id="result">The <code>handler</code> puts the result here</button>
+<button id="result"><code>handler</code> จะแสดงผลลัพธ์ตรงนี้</button>
 
 <script>
   function handler(event) {
diff --git a/1-js/06-advanced-functions/09-call-apply-decorators/03-debounce/solution.md b/1-js/06-advanced-functions/09-call-apply-decorators/03-debounce/solution.md
index 83e75f315..cb2ae3707 100644
--- a/1-js/06-advanced-functions/09-call-apply-decorators/03-debounce/solution.md
+++ b/1-js/06-advanced-functions/09-call-apply-decorators/03-debounce/solution.md
@@ -9,5 +9,5 @@ function debounce(func, ms) {
 
 ```
 
-A call to `debounce` returns a wrapper. When called, it schedules the original function call after given `ms` and cancels the previous such timeout.
+การเรียก `debounce` จะคืนค่า wrapper เมื่อถูกเรียก wrapper จะตั้ง timeout สำหรับเรียกฟังก์ชันเดิมหลังจาก `ms` ที่กำหนด แล้วยกเลิก timeout เก่าที่ตั้งไว้ก่อนหน้า
 
diff --git a/1-js/06-advanced-functions/09-call-apply-decorators/03-debounce/task.md b/1-js/06-advanced-functions/09-call-apply-decorators/03-debounce/task.md
index 5b0fcc5f8..ff3f78a28 100644
--- a/1-js/06-advanced-functions/09-call-apply-decorators/03-debounce/task.md
+++ b/1-js/06-advanced-functions/09-call-apply-decorators/03-debounce/task.md
@@ -4,19 +4,19 @@ importance: 5
 
 # Debounce decorator
 
-The result of `debounce(f, ms)` decorator is a wrapper that suspends calls to `f` until there's `ms` milliseconds of inactivity (no calls, "cooldown period"), then invokes `f` once with the latest arguments.
+ผลลัพธ์ของ decorator `debounce(f, ms)` คือ wrapper ที่จะระงับการเรียก `f` จนกว่าจะผ่านไป `ms` มิลลิวินาทีโดยไม่มีการเรียกเข้ามาอีก (ช่วง "พักเย็น") จากนั้นจึงเรียก `f` หนึ่งครั้งด้วยอาร์กิวเมนต์ล่าสุด
 
-In other words, `debounce` is like a secretary that accepts "phone calls", and waits until there's `ms` milliseconds of being quiet. And only then it transfers the latest call information to "the boss" (calls the actual `f`).
+พูดง่ายๆ `debounce` ก็เหมือนเลขาที่รับ "สายโทรศัพท์" แล้วรอจนกว่าจะเงียบไป `ms` มิลลิวินาที จากนั้นจึงส่งต่อข้อมูลจากสายล่าสุดให้ "เจ้านาย" (เรียกฟังก์ชัน `f` จริงๆ)
 
-For instance, we had a function `f` and replaced it with `f = debounce(f, 1000)`.
+ยกตัวอย่าง สมมติเรามีฟังก์ชัน `f` แล้วแทนที่ด้วย `f = debounce(f, 1000)`
 
-Then if the wrapped function is called at 0ms, 200ms and 500ms, and then there are no calls, then the actual `f` will be only called once, at 1500ms. That is: after the cooldown period of 1000ms from the last call.
+ถ้า wrapped function ถูกเรียกที่ 0ms, 200ms และ 500ms แล้วไม่มีการเรียกอีก ฟังก์ชัน `f` จริงจะถูกเรียกแค่ครั้งเดียวที่ 1500ms คือหลังจากช่วงพักเย็น 1000ms นับจากการเรียกครั้งสุดท้าย
 
 ![](debounce.svg)
 
-...And it will get the arguments of the very last call, other calls are ignored.
+...และจะได้รับอาร์กิวเมนต์ของการเรียกครั้งสุดท้ายเท่านั้น การเรียกก่อนหน้าจะถูกเพิกเฉย
 
-Here's the code for it (uses the debounce decorator from the [Lodash library](https://lodash.com/docs/4.17.15#debounce)):
+นี่คือตัวอย่างโค้ด (ใช้ debounce decorator จาก[ไลบรารี Lodash](https://lodash.com/docs/4.17.15#debounce)):
 
 ```js
 let f = _.debounce(alert, 1000);
@@ -24,28 +24,28 @@ let f = _.debounce(alert, 1000);
 f("a");
 setTimeout( () => f("b"), 200);
 setTimeout( () => f("c"), 500);
-// debounced function waits 1000ms after the last call and then runs: alert("c")
+// debounced function รอ 1000ms หลังการเรียกครั้งสุดท้าย แล้วจึงรัน: alert("c")
 ```
 
-Now a practical example. Let's say, the user types something, and we'd like to send a request to the server when the input is finished.
+ทีนี้มาดูตัวอย่างจริง สมมติผู้ใช้กำลังพิมพ์อะไรบางอย่าง แล้วเราต้องการส่ง request ไปเซิร์ฟเวอร์เมื่อพิมพ์เสร็จ
 
-There's no point in sending the request for every character typed. Instead we'd like to wait, and then process the whole result.
+ไม่มีประโยชน์ที่จะส่ง request ทุกครั้งที่กดตัวอักษร เราควรรอ แล้วค่อยส่งผลลัพธ์ทั้งหมดไปทีเดียว
 
-In a web-browser, we can setup an event handler -- a function that's called on every change of an input field. Normally, an event handler is called very often, for every typed key. But if we `debounce` it by 1000ms, then it will be only called once, after 1000ms after the last input.
+ในเว็บเบราว์เซอร์ เราตั้ง event handler ได้ ซึ่งก็คือฟังก์ชันที่ถูกเรียกทุกครั้งที่ input field เปลี่ยนแปลง ปกติ event handler จะถูกเรียกถี่มาก ทุกครั้งที่กดปุ่ม แต่ถ้าเรา `debounce` มันด้วย 1000ms จะถูกเรียกแค่ครั้งเดียว หลังจาก 1000ms นับจากการพิมพ์ครั้งสุดท้าย
 
 ```online
 
-In this live example, the handler puts the result into a box below, try it:
+ในตัวอย่าง live นี้ handler จะแสดงผลลัพธ์ในกล่องด้านล่าง ลองพิมพ์ดู:
 
 [iframe border=1 src="debounce" height=200]
 
-See? The second input calls the debounced function, so its content is processed after 1000ms from the last input.
+เห็นไหม? input ช่องที่สองเรียก debounced function ดังนั้นเนื้อหาจะถูกประมวลผลหลังจาก 1000ms นับจากการพิมพ์ครั้งสุดท้าย
 ```
 
-So, `debounce` is a great way to process a sequence of events: be it a sequence of key presses, mouse movements or something else.
+สรุปแล้ว `debounce` เหมาะสำหรับจัดการเหตุการณ์ที่มาต่อเนื่อง ไม่ว่าจะเป็นการกดปุ่ม การเลื่อนเมาส์ หรืออื่นๆ
 
-It waits the given time after the last call, and then runs its function, that can process the result.
+มันจะรอตามเวลาที่กำหนดหลังจากการเรียกครั้งสุดท้าย แล้วจึงรันฟังก์ชันเพื่อประมวลผลลัพธ์
 
-The task is to implement `debounce` decorator.
+โจทย์คือให้เขียน `debounce` decorator
 
-Hint: that's just a few lines if you think about it :)
+คำใบ้: ถ้าคิดดีๆ แล้วใช้แค่ไม่กี่บรรทัดเอง :)
diff --git a/1-js/06-advanced-functions/09-call-apply-decorators/04-throttle/_js.view/solution.js b/1-js/06-advanced-functions/09-call-apply-decorators/04-throttle/_js.view/solution.js
index 8071be9d4..849df49d3 100644
--- a/1-js/06-advanced-functions/09-call-apply-decorators/04-throttle/_js.view/solution.js
+++ b/1-js/06-advanced-functions/09-call-apply-decorators/04-throttle/_js.view/solution.js
@@ -7,23 +7,23 @@ function throttle(func, ms) {
   function wrapper() {
 
     if (isThrottled) {
-      // memo last arguments to call after the cooldown
+      // จำอาร์กิวเมนต์ล่าสุดไว้เรียกหลังช่วงพักเย็น
       savedArgs = arguments;
       savedThis = this;
       return;
     }
 
-    // otherwise go to cooldown state
+    // ถ้าไม่ได้อยู่ในช่วงพักเย็น ให้เข้าสู่สถานะพักเย็น
     func.apply(this, arguments);
 
     isThrottled = true;
 
-    // plan to reset isThrottled after the delay
+    // วางแผนรีเซ็ต isThrottled หลังจากหน่วงเวลา
     setTimeout(function() {
       isThrottled = false;
       if (savedArgs) {
-        // if there were calls, savedThis/savedArgs have the last one
-        // recursive call runs the function and sets cooldown again
+        // ถ้ามีการเรียกที่ถูกเพิกเฉย savedThis/savedArgs จะเก็บค่าล่าสุดไว้
+        // เรียก wrapper แบบ recursive เพื่อรันฟังก์ชันและตั้งช่วงพักเย็นอีกครั้ง
         wrapper.apply(savedThis, savedArgs);
         savedArgs = savedThis = null;
       }
diff --git a/1-js/06-advanced-functions/09-call-apply-decorators/04-throttle/solution.md b/1-js/06-advanced-functions/09-call-apply-decorators/04-throttle/solution.md
index 6950664be..b280f4c19 100644
--- a/1-js/06-advanced-functions/09-call-apply-decorators/04-throttle/solution.md
+++ b/1-js/06-advanced-functions/09-call-apply-decorators/04-throttle/solution.md
@@ -29,10 +29,10 @@ function throttle(func, ms) {
 }
 ```
 
-A call to `throttle(func, ms)` returns `wrapper`.
+การเรียก `throttle(func, ms)` จะคืนค่า `wrapper`
 
-1. During the first call, the `wrapper` just runs `func` and sets the cooldown state (`isThrottled = true`).
-2. In this state all calls are memorized in `savedArgs/savedThis`. Please note that both the context and the arguments are equally important and should be memorized. We need them simultaneously to reproduce the call.
-3. After `ms` milliseconds pass, `setTimeout` triggers. The cooldown state is removed (`isThrottled = false`) and, if we had ignored calls, `wrapper` is executed with the last memorized arguments and context.
+1. ในการเรียกครั้งแรก `wrapper` จะรัน `func` ทันที แล้วตั้งสถานะพักเย็น (`isThrottled = true`)
+2. ในสถานะนี้ ทุกการเรียกจะถูกจำไว้ใน `savedArgs/savedThis` สังเกตว่าทั้ง context และอาร์กิวเมนต์สำคัญเท่าๆ กัน ต้องจำไว้ทั้งคู่เพื่อจำลองการเรียกได้ถูกต้อง
+3. เมื่อผ่านไป `ms` มิลลิวินาที `setTimeout` จะทำงาน สถานะพักเย็นจะถูกยกเลิก (`isThrottled = false`) และถ้ามีการเรียกที่ถูกเพิกเฉยไว้ `wrapper` จะถูกรันด้วยอาร์กิวเมนต์และ context ล่าสุดที่จำไว้
 
-The 3rd step runs not `func`, but `wrapper`, because we not only need to execute `func`, but once again enter the cooldown state and setup the timeout to reset it.
+ขั้นตอนที่ 3 รัน `wrapper` ไม่ใช่ `func` โดยตรง เพราะเราไม่ใช่แค่ต้องรัน `func` แต่ต้องเข้าสู่สถานะพักเย็นอีกครั้ง พร้อมตั้ง timeout เพื่อรีเซ็ตมันด้วย
diff --git a/1-js/06-advanced-functions/09-call-apply-decorators/04-throttle/task.md b/1-js/06-advanced-functions/09-call-apply-decorators/04-throttle/task.md
index cbd473196..3929e4e6f 100644
--- a/1-js/06-advanced-functions/09-call-apply-decorators/04-throttle/task.md
+++ b/1-js/06-advanced-functions/09-call-apply-decorators/04-throttle/task.md
@@ -4,50 +4,50 @@ importance: 5
 
 # Throttle decorator
 
-Create a "throttling" decorator `throttle(f, ms)` -- that returns a wrapper.
+สร้าง "throttling" decorator `throttle(f, ms)` ที่คืนค่า wrapper
 
-When it's called multiple times, it passes the call to `f` at maximum once per `ms` milliseconds.
+เมื่อถูกเรียกหลายครั้ง จะส่งต่อการเรียกไปยัง `f` ได้มากสุดครั้งเดียวต่อ `ms` มิลลิวินาที
 
-Compared to the debounce decorator, the behavior is completely different:
-- `debounce` runs the function once after the "cooldown" period. Good for processing the final result.
-- `throttle` runs it not more often than given `ms` time. Good for regular updates that shouldn't be very often.
+เมื่อเทียบกับ debounce decorator แล้ว พฤติกรรมต่างกันโดยสิ้นเชิง:
+- `debounce` รันฟังก์ชันหนึ่งครั้งหลังช่วง "พักเย็น" เหมาะสำหรับประมวลผลลัพธ์สุดท้าย
+- `throttle` รันฟังก์ชันไม่เกินหนึ่งครั้งต่อ `ms` ที่กำหนด เหมาะสำหรับอัปเดตเป็นระยะๆ ที่ไม่ต้องการให้ถี่เกินไป
 
-In other words, `throttle` is like a secretary that accepts phone calls, but bothers the boss (calls the actual `f`) not more often than once per `ms` milliseconds.
+พูดง่ายๆ `throttle` ก็เหมือนเลขาที่รับสายโทรศัพท์ แต่จะรบกวนเจ้านาย (เรียก `f` จริง) ได้ไม่เกินหนึ่งครั้งต่อ `ms` มิลลิวินาที
 
-Let's check the real-life application to better understand that requirement and to see where it comes from.
+มาดูตัวอย่างจากชีวิตจริงเพื่อทำความเข้าใจให้ดีขึ้น
 
-**For instance, we want to track mouse movements.**
+**ยกตัวอย่าง เราต้องการติดตามการเลื่อนเมาส์**
 
-In a browser we can setup a function to run at every mouse movement and get the pointer location as it moves. During an active mouse usage, this function usually runs very frequently, can be something like 100 times per second (every 10 ms).
-**We'd like to update some information on the web-page when the pointer moves.**
+ในเบราว์เซอร์เราตั้งฟังก์ชันให้ทำงานทุกครั้งที่เมาส์ขยับได้ และดึงตำแหน่งเคอร์เซอร์ขณะเลื่อน ขณะใช้เมาส์อยู่ ฟังก์ชันนี้จะถูกเรียกถี่มาก อาจถึง 100 ครั้งต่อวินาที (ทุก 10ms)
+**แต่เราแค่ต้องการอัปเดตข้อมูลบนหน้าเว็บเมื่อเมาส์ขยับ**
 
-...But updating function `update()` is too heavy to do it on every micro-movement. There is also no sense in updating more often than once per 100ms.
+...แต่ฟังก์ชัน `update()` นั้นหนักเกินกว่าจะรันทุกครั้งที่เมาส์ขยับนิดเดียว และไม่จำเป็นต้องอัปเดตบ่อยเกินกว่าหนึ่งครั้งต่อ 100ms
 
-So we'll wrap it into the decorator: use `throttle(update, 100)` as the function to run on each mouse move instead of the original `update()`. The decorator will be called often, but forward the call to `update()` at maximum once per 100ms.
+เราจึงครอบมันด้วย decorator: ใช้ `throttle(update, 100)` เป็นฟังก์ชันที่จะรันทุกครั้งที่เมาส์ขยับ แทนที่จะเรียก `update()` ตรงๆ โดย decorator จะถูกเรียกบ่อยแต่ส่งต่อไปยัง `update()` ได้มากสุดครั้งเดียวต่อ 100ms
 
-Visually, it will look like this:
+ถ้ามองเป็นภาพจะเป็นแบบนี้:
 
-1. For the first mouse movement the decorated variant immediately passes the call to `update`. That's important, the user sees our reaction to their move immediately.
-2. Then as the mouse moves on, until `100ms` nothing happens. The decorated variant ignores calls.
-3. At the end of `100ms` -- one more `update` happens with the last coordinates.
-4. Then, finally, the mouse stops somewhere. The decorated variant waits until `100ms` expire and then runs `update` with last coordinates. So, quite important, the final mouse coordinates are processed.
+1. เมื่อเมาส์ขยับครั้งแรก decorated variant จะส่งต่อไปยัง `update` ทันที ซึ่งสำคัญมาก เพราะผู้ใช้จะเห็นผลตอบสนองจากการขยับเมาส์ทันที
+2. จากนั้นเมื่อเมาส์ขยับต่อ จนกว่าจะผ่าน `100ms` จะไม่มีอะไรเกิดขึ้น decorated variant จะเพิกเฉยการเรียกทั้งหมด
+3. เมื่อครบ `100ms` -- จะเรียก `update` อีกครั้งด้วยพิกัดล่าสุด
+4. สุดท้าย เมื่อเมาส์หยุดนิ่ง decorated variant จะรอจนครบ `100ms` แล้วเรียก `update` ครั้งสุดท้ายด้วยพิกัดล่าสุด สิ่งสำคัญคือ พิกัดสุดท้ายของเมาส์จะถูกประมวลผลเสมอ
 
-A code example:
+ตัวอย่างโค้ด:
 
 ```js
 function f(a) {
   console.log(a);
 }
 
-// f1000 passes calls to f at maximum once per 1000 ms
+// f1000 ส่งต่อการเรียกไปยัง f ได้มากสุดครั้งเดียวต่อ 1000ms
 let f1000 = throttle(f, 1000);
 
-f1000(1); // shows 1
-f1000(2); // (throttling, 1000ms not out yet)
-f1000(3); // (throttling, 1000ms not out yet)
+f1000(1); // แสดง 1
+f1000(2); // (ถูก throttle, ยังไม่ครบ 1000ms)
+f1000(3); // (ถูก throttle, ยังไม่ครบ 1000ms)
 
-// when 1000 ms time out...
-// ...outputs 3, intermediate value 2 was ignored
+// เมื่อครบ 1000ms...
+// ...แสดง 3 ส่วนค่า 2 ที่อยู่ระหว่างกลางถูกข้ามไป
 ```
 
-P.S. Arguments and the context `this` passed to `f1000` should be passed to the original `f`.
+P.S. อาร์กิวเมนต์และ context `this` ที่ส่งให้ `f1000` ต้องถูกส่งต่อไปยัง `f` ดั้งเดิมด้วย
diff --git a/1-js/06-advanced-functions/09-call-apply-decorators/article.md b/1-js/06-advanced-functions/09-call-apply-decorators/article.md
index c5d785493..2515a5415 100644
--- a/1-js/06-advanced-functions/09-call-apply-decorators/article.md
+++ b/1-js/06-advanced-functions/09-call-apply-decorators/article.md
@@ -1,20 +1,20 @@
-# Decorators and forwarding, call/apply
+# Decorator และการส่งต่อด้วย call/apply
 
-JavaScript gives exceptional flexibility when dealing with functions. They can be passed around, used as objects, and now we'll see how to *forward* calls between them and *decorate* them.
+JavaScript มีความยืดหยุ่นสูงมากเวลาจัดการกับฟังก์ชัน เราสามารถส่งฟังก์ชันไปมา ใช้เป็นออบเจ็กต์ได้ และในบทนี้เราจะมาดูวิธี *ส่งต่อ* การเรียกฟังก์ชัน (forwarding) และ *ตกแต่ง* ฟังก์ชัน (decorating) กัน
 
 ## Transparent caching
 
-Let's say we have a function `slow(x)` which is CPU-heavy, but its results are stable. In other words, for the same `x` it always returns the same result.
+สมมติว่าเรามีฟังก์ชัน `slow(x)` ที่ใช้ CPU หนักมาก แต่ผลลัพธ์คงที่ — สำหรับค่า `x` เดิมจะได้ผลลัพธ์เดิมเสมอ
 
-If the function is called often, we may want to cache (remember) the results to avoid spending extra-time on recalculations.
+ถ้าฟังก์ชันนี้ถูกเรียกบ่อยๆ เราอาจจะอยากแคช (จดจำ) ผลลัพธ์เอาไว้ จะได้ไม่ต้องคำนวณซ้ำ
 
-But instead of adding that functionality into `slow()` we'll create a wrapper function, that adds caching. As we'll see, there are many benefits of doing so.
+แต่แทนที่จะไปเพิ่มฟีเจอร์นี้เข้าไปใน `slow()` ตรงๆ เราจะสร้างฟังก์ชัน wrapper ครอบอีกที เพื่อเพิ่มความสามารถด้านการแคชเข้าไป ซึ่งวิธีนี้มีข้อดีหลายอย่างอย่างที่เราจะได้เห็นกัน
 
-Here's the code, and explanations follow:
+มาดูโค้ดกัน แล้วค่อยอธิบายทีหลัง:
 
 ```js run
 function slow(x) {
-  // there can be a heavy CPU-intensive job here
+  // อาจมีงานหนักๆ ที่ใช้ CPU สูงอยู่ตรงนี้
   alert(`Called with ${x}`);
   return x;
 }
@@ -23,65 +23,65 @@ function cachingDecorator(func) {
   let cache = new Map();
 
   return function(x) {
-    if (cache.has(x)) {    // if there's such key in cache
-      return cache.get(x); // read the result from it
+    if (cache.has(x)) {    // ถ้ามี key นี้ในแคชแล้ว
+      return cache.get(x); // ก็อ่านผลลัพธ์จากแคชเลย
     }
 
-    let result = func(x);  // otherwise call func
+    let result = func(x);  // ถ้ายังไม่มี ก็เรียกฟังก์ชันจริง
 
-    cache.set(x, result);  // and cache (remember) the result
+    cache.set(x, result);  // แล้วเก็บผลลัพธ์ลงแคช
     return result;
   };
 }
 
 slow = cachingDecorator(slow);
 
-alert( slow(1) ); // slow(1) is cached and the result returned
-alert( "Again: " + slow(1) ); // slow(1) result returned from cache
+alert( slow(1) ); // slow(1) ถูกแคชไว้ แล้วคืนค่าผลลัพธ์
+alert( "Again: " + slow(1) ); // คืนค่าผลลัพธ์ของ slow(1) จากแคช
 
-alert( slow(2) ); // slow(2) is cached and the result returned
-alert( "Again: " + slow(2) ); // slow(2) result returned from cache
+alert( slow(2) ); // slow(2) ถูกแคชไว้ แล้วคืนค่าผลลัพธ์
+alert( "Again: " + slow(2) ); // คืนค่าผลลัพธ์ของ slow(2) จากแคช
 ```
 
-In the code above `cachingDecorator` is a *decorator*: a special function that takes another function and alters its behavior.
+จากโค้ดด้านบน `cachingDecorator` คือ *decorator* — ฟังก์ชันพิเศษที่รับฟังก์ชันอื่นเข้ามาแล้วปรับเปลี่ยนพฤติกรรมของมัน
 
-The idea is that we can call `cachingDecorator` for any function, and it will return the caching wrapper. That's great, because we can have many functions that could use such a feature, and all we need to do is to apply `cachingDecorator` to them.
+แนวคิดก็คือ เราสามารถเรียก `cachingDecorator` กับฟังก์ชันไหนก็ได้ แล้วมันจะคืน wrapper ที่มีการแคชให้ สะดวกมากเพราะถ้ามีหลายฟังก์ชันที่ต้องการฟีเจอร์นี้ เราแค่เอา `cachingDecorator` ไปครอบมันก็พอ
 
-By separating caching from the main function code we also keep the main code simpler.
+นอกจากนี้ การแยกโลจิกการแคชออกจากฟังก์ชันหลัก ยังทำให้โค้ดของฟังก์ชันหลักเรียบง่ายขึ้นด้วย
 
-The result of `cachingDecorator(func)` is a "wrapper": `function(x)` that "wraps" the call of `func(x)` into caching logic:
+ผลลัพธ์ของ `cachingDecorator(func)` คือ "wrapper" — `function(x)` ที่ "ครอบ" การเรียก `func(x)` ด้วยโลจิกการแคช:
 
 ![](decorator-makecaching-wrapper.svg)
 
-From an outside code, the wrapped `slow` function still does the same. It just got a caching aspect added to its behavior.
+จากมุมมองของโค้ดภายนอก ฟังก์ชัน `slow` ที่ถูกครอบแล้วยังทำงานเหมือนเดิม แค่เพิ่มความสามารถด้านการแคชเข้ามา
 
-To summarize, there are several benefits of using a separate `cachingDecorator` instead of altering the code of `slow` itself:
+สรุปแล้ว การใช้ `cachingDecorator` แยกต่างหากแทนที่จะไปแก้โค้ดของ `slow` โดยตรง มีข้อดีหลายอย่าง:
 
-- The `cachingDecorator` is reusable. We can apply it to another function.
-- The caching logic is separate, it did not increase the complexity of `slow` itself (if there was any).
-- We can combine multiple decorators if needed (other decorators will follow).
+- `cachingDecorator` นำกลับมาใช้ซ้ำได้ เอาไปใช้กับฟังก์ชันอื่นได้เลย
+- โลจิกการแคชแยกออกมาต่างหาก ไม่ไปเพิ่มความซับซ้อนให้กับ `slow`
+- สามารถรวม decorator หลายตัวเข้าด้วยกันได้ ถ้าต้องการ (จะเห็นตัวอย่างเพิ่มเติมภายหลัง)
 
-## Using "func.call" for the context
+## ใช้ "func.call" เพื่อกำหนด context
 
-The caching decorator mentioned above is not suited to work with object methods.
+decorator สำหรับแคชที่เราสร้างไว้ด้านบน ยังใช้กับเมธอดของออบเจ็กต์ไม่ได้
 
-For instance, in the code below `worker.slow()` stops working after the decoration:
+ตัวอย่างเช่น ในโค้ดด้านล่าง `worker.slow()` จะพังหลังจากถูก decorate:
 
 ```js run
-// we'll make worker.slow caching
+// เราจะเพิ่มแคชให้ worker.slow
 let worker = {
   someMethod() {
     return 1;
   },
 
   slow(x) {
-    // scary CPU-heavy task here  
+    // งานหนักที่ใช้ CPU สูงอยู่ตรงนี้
     alert("Called with " + x);
     return x * this.someMethod(); // (*)
   }
 };
 
-// same code as before
+// โค้ดเหมือนเดิม
 function cachingDecorator(func) {
   let cache = new Map();
   return function(x) {
@@ -96,49 +96,49 @@ function cachingDecorator(func) {
   };
 }
 
-alert( worker.slow(1) ); // the original method works
+alert( worker.slow(1) ); // เมธอดเดิมทำงานได้ปกติ
 
-worker.slow = cachingDecorator(worker.slow); // now make it caching
+worker.slow = cachingDecorator(worker.slow); // เพิ่มแคชเข้าไป
 
 *!*
-alert( worker.slow(2) ); // Whoops! Error: Cannot read property 'someMethod' of undefined
+alert( worker.slow(2) ); // เกิดข้อผิดพลาด! Cannot read property 'someMethod' of undefined
 */!*
 ```
 
-The error occurs in the line `(*)` that tries to access `this.someMethod` and fails. Can you see why?
+error เกิดขึ้นที่บรรทัด `(*)` ตอนที่พยายามเข้าถึง `this.someMethod` แล้วล้มเหลว เห็นสาเหตุไหม?
 
-The reason is that the wrapper calls the original function as `func(x)` in the line `(**)`. And, when called like that, the function gets `this = undefined`.
+เหตุผลก็เพราะ wrapper เรียกฟังก์ชันเดิมด้วย `func(x)` ที่บรรทัด `(**)` ซึ่งเมื่อเรียกแบบนี้ ฟังก์ชันจะได้ `this = undefined`
 
-We would observe a similar symptom if we tried to run:
+จะเห็นอาการเดียวกันถ้าลองรัน:
 
 ```js
 let func = worker.slow;
 func(2);
 ```
 
-So, the wrapper passes the call to the original method, but without the context `this`. Hence the error.
+wrapper ส่งต่อการเรียกไปยังเมธอดเดิม แต่ไม่ได้ส่ง context `this` ไปด้วย จึงเกิด error
 
-Let's fix it.
+มาแก้ปัญหานี้กัน
 
-There's a special built-in function method [func.call(context, ...args)](mdn:js/Function/call) that allows to call a function explicitly setting `this`.
+มีเมธอด built-in อยู่ตัวหนึ่งคือ [func.call(context, ...args)](mdn:js/Function/call) ที่ช่วยให้เราเรียกฟังก์ชันพร้อมกำหนดค่า `this` ได้เอง
 
-The syntax is:
+ไวยากรณ์คือ:
 
 ```js
 func.call(context, arg1, arg2, ...)
 ```
 
-It runs `func` providing the first argument as `this`, and the next as the arguments.
+มันจะรัน `func` โดยกำหนด `this` เป็นอาร์กิวเมนต์ตัวแรก และตัวถัดไปเป็นอาร์กิวเมนต์ของฟังก์ชัน
 
-To put it simply, these two calls do almost the same:
+พูดง่ายๆ ก็คือ สองบรรทัดนี้ทำงานเกือบเหมือนกัน:
 ```js
 func(1, 2, 3);
 func.call(obj, 1, 2, 3)
 ```
 
-They both call `func` with arguments `1`, `2` and `3`. The only difference is that `func.call` also sets `this` to `obj`.
+ทั้งสองเรียก `func` ด้วยอาร์กิวเมนต์ `1`, `2` และ `3` ต่างกันแค่ `func.call` จะกำหนด `this` เป็น `obj` ด้วย
 
-As an example, in the code below we call `sayHi` in the context of different objects: `sayHi.call(user)` runs `sayHi` providing `this=user`, and the next line sets `this=admin`:
+ลองดูตัวอย่าง เราเรียก `sayHi` ในบริบทของออบเจ็กต์ต่างกัน: `sayHi.call(user)` จะรัน `sayHi` โดยกำหนด `this=user` และบรรทัดถัดไปกำหนด `this=admin`:
 
 ```js run
 function sayHi() {
@@ -148,12 +148,12 @@ function sayHi() {
 let user = { name: "John" };
 let admin = { name: "Admin" };
 
-// use call to pass different objects as "this"
+// ใช้ call เพื่อส่งออบเจ็กต์ต่างๆ เข้าไปเป็น "this"
 sayHi.call( user ); // John
 sayHi.call( admin ); // Admin
 ```
 
-And here we use `call` to call `say` with the given context and phrase:
+และตรงนี้เราใช้ `call` เพื่อเรียก `say` พร้อมกำหนด context และข้อความ:
 
 
 ```js run
@@ -163,11 +163,11 @@ function say(phrase) {
 
 let user = { name: "John" };
 
-// user becomes this, and "Hello" becomes the first argument
+// user กลายเป็น this และ "Hello" เป็นอาร์กิวเมนต์ตัวแรก
 say.call( user, "Hello" ); // John: Hello
 ```
 
-In our case, we can use `call` in the wrapper to pass the context to the original function:
+ในกรณีของเรา สามารถใช้ `call` ใน wrapper เพื่อส่ง context ไปยังฟังก์ชันเดิมได้แบบนี้:
 
 ```js run
 let worker = {
@@ -188,57 +188,57 @@ function cachingDecorator(func) {
       return cache.get(x);
     }
 *!*
-    let result = func.call(this, x); // "this" is passed correctly now
+    let result = func.call(this, x); // ตอนนี้ "this" ถูกส่งต่อไปอย่างถูกต้องแล้ว
 */!*
     cache.set(x, result);
     return result;
   };
 }
 
-worker.slow = cachingDecorator(worker.slow); // now make it caching
+worker.slow = cachingDecorator(worker.slow); // เพิ่มแคชเข้าไป
 
-alert( worker.slow(2) ); // works
-alert( worker.slow(2) ); // works, doesn't call the original (cached)
+alert( worker.slow(2) ); // ทำงานได้แล้ว
+alert( worker.slow(2) ); // ทำงานได้ ไม่ได้เรียกฟังก์ชันเดิม (ใช้จากแคช)
 ```
 
-Now everything is fine.
+ตอนนี้ทุกอย่างทำงานได้ถูกต้องแล้ว
 
-To make it all clear, let's see more deeply how `this` is passed along:
+เพื่อให้เห็นภาพชัดๆ มาดูกันว่า `this` ถูกส่งต่อไปอย่างไร:
 
-1. After the decoration `worker.slow` is now the wrapper `function (x) { ... }`.
-2. So when `worker.slow(2)` is executed, the wrapper gets `2` as an argument and `this=worker` (it's the object before dot).
-3. Inside the wrapper, assuming the result is not yet cached, `func.call(this, x)` passes the current `this` (`=worker`) and the current argument (`=2`) to the original method.
+1. หลังจาก decorate แล้ว `worker.slow` จะกลายเป็น wrapper `function (x) { ... }`
+2. เมื่อเรียก `worker.slow(2)` wrapper จะได้ `2` เป็นอาร์กิวเมนต์ และ `this=worker` (เป็นออบเจ็กต์ที่อยู่ก่อนจุด)
+3. ภายใน wrapper ถ้ายังไม่มีผลลัพธ์ในแคช `func.call(this, x)` จะส่ง `this` ปัจจุบัน (`=worker`) และอาร์กิวเมนต์ (`=2`) ไปยังเมธอดเดิม
 
-## Going multi-argument
+## รองรับหลายอาร์กิวเมนต์
 
-Now let's make `cachingDecorator` even more universal. Till now it was working only with single-argument functions.
+ทีนี้มาทำให้ `cachingDecorator` ใช้งานได้หลากหลายขึ้น ตอนนี้มันรองรับแค่ฟังก์ชันที่รับอาร์กิวเมนต์ตัวเดียว
 
-Now how to cache the multi-argument `worker.slow` method?
+แล้วถ้าต้องการแคชเมธอด `worker.slow` ที่รับหลายอาร์กิวเมนต์ล่ะ?
 
 ```js
 let worker = {
   slow(min, max) {
-    return min + max; // scary CPU-hogger is assumed
+    return min + max; // สมมติว่าเป็นงานหนัก
   }
 };
 
-// should remember same-argument calls
+// ต้องจำผลลัพธ์สำหรับอาร์กิวเมนต์ชุดเดียวกัน
 worker.slow = cachingDecorator(worker.slow);
 ```
 
-Previously, for a single argument `x` we could just `cache.set(x, result)` to save the result and `cache.get(x)` to retrieve it. But now we need to remember the result for a *combination of arguments* `(min,max)`. The native `Map` takes single value only as the key.
+ก่อนหน้านี้ เราแค่ใช้ `cache.set(x, result)` เพื่อบันทึกผลลัพธ์ และ `cache.get(x)` เพื่อดึงมาใช้ แต่ตอนนี้เราต้องจำผลลัพธ์สำหรับ *การรวมกัน* ของอาร์กิวเมนต์ `(min,max)` ซึ่ง `Map` รับค่าเดียวเป็น key เท่านั้น
 
-There are many solutions possible:
+มีวิธีแก้หลายทาง:
 
-1. Implement a new (or use a third-party) map-like data structure that is more versatile and allows multi-keys.
-2. Use nested maps: `cache.set(min)` will be a `Map` that stores the pair `(max, result)`. So we can get `result` as `cache.get(min).get(max)`.
-3. Join two values into one. In our particular case we can just use a string `"min,max"` as the `Map` key. For flexibility, we can allow to provide a *hashing function* for the decorator, that knows how to make one value from many.
+1. สร้างโครงสร้างข้อมูลแบบ map-like ใหม่ (หรือใช้ third-party) ที่รองรับหลาย key
+2. ใช้ map ซ้อนกัน: `cache.set(min)` จะเป็น `Map` ที่เก็บคู่ `(max, result)` แล้วดึงผลลัพธ์ด้วย `cache.get(min).get(max)`
+3. รวมสองค่าเป็นค่าเดียว ในกรณีนี้เราใช้สตริง `"min,max"` เป็น key ของ `Map` ได้เลย และเพื่อความยืดหยุ่น เราสามารถให้ decorator รับ *hashing function* ที่ช่วยรวมหลายค่าเป็นค่าเดียว
 
-For many practical applications, the 3rd variant is good enough, so we'll stick to it.
+สำหรับงานจริงส่วนใหญ่ วิธีที่ 3 ก็เพียงพอแล้ว เราจะใช้วิธีนี้
 
-Also we need to pass not just `x`, but all arguments in `func.call`. Let's recall that in a `function()` we can get a pseudo-array of its arguments as `arguments`, so `func.call(this, x)` should be replaced with `func.call(this, ...arguments)`.
+อีกอย่างที่ต้องแก้คือ แทนที่จะส่งแค่ `x` เราต้องส่งอาร์กิวเมนต์ทั้งหมดเข้า `func.call` ใน `function()` เราสามารถดึง pseudo-array ของอาร์กิวเมนต์ได้จาก `arguments` ดังนั้น `func.call(this, x)` จะเปลี่ยนเป็น `func.call(this, ...arguments)`
 
-Here's a more powerful `cachingDecorator`:
+นี่คือ `cachingDecorator` เวอร์ชันที่ทรงพลังขึ้น:
 
 ```js run
 let worker = {
@@ -273,50 +273,50 @@ function hash(args) {
 
 worker.slow = cachingDecorator(worker.slow, hash);
 
-alert( worker.slow(3, 5) ); // works
-alert( "Again " + worker.slow(3, 5) ); // same (cached)
+alert( worker.slow(3, 5) ); // ทำงานได้
+alert( "Again " + worker.slow(3, 5) ); // เหมือนเดิม (จากแคช)
 ```
 
-Now it works with any number of arguments (though the hash function would also need to be adjusted to allow any number of arguments. An interesting way to handle this will be covered below).
+ตอนนี้รองรับอาร์กิวเมนต์กี่ตัวก็ได้แล้ว (แต่ hash function ต้องปรับให้รองรับด้วย ซึ่งเราจะพูดถึงวิธีที่น่าสนใจด้านล่าง)
 
-There are two changes:
+มีการเปลี่ยนแปลงสองจุด:
 
-- In the line `(*)` it calls `hash` to create a single key from `arguments`. Here we use a simple "joining" function that turns arguments `(3, 5)` into the key `"3,5"`. More complex cases may require other hashing functions.
-- Then `(**)` uses `func.call(this, ...arguments)` to pass both the context and all arguments the wrapper got (not just the first one) to the original function.
+- บรรทัด `(*)` เรียก `hash` เพื่อสร้าง key เดียวจาก `arguments` ตรงนี้เราใช้ฟังก์ชัน "joining" ง่ายๆ ที่แปลงอาร์กิวเมนต์ `(3, 5)` เป็น key `"3,5"` กรณีที่ซับซ้อนกว่านี้อาจต้องใช้ hashing function แบบอื่น
+- จากนั้นบรรทัด `(**)` ใช้ `func.call(this, ...arguments)` เพื่อส่งทั้ง context และอาร์กิวเมนต์ทั้งหมดที่ wrapper ได้รับ (ไม่ใช่แค่ตัวแรก) ไปยังฟังก์ชันเดิม
 
 ## func.apply
 
-Instead of `func.call(this, ...arguments)` we could use `func.apply(this, arguments)`.
+แทนที่จะใช้ `func.call(this, ...arguments)` เราสามารถใช้ `func.apply(this, arguments)` ก็ได้
 
-The syntax of built-in method [func.apply](mdn:js/Function/apply) is:
+ไวยากรณ์ของเมธอด built-in [func.apply](mdn:js/Function/apply) คือ:
 
 ```js
 func.apply(context, args)
 ```
 
-It runs the `func` setting `this=context` and using an array-like object `args` as the list of arguments.
+มันจะรัน `func` โดยกำหนด `this=context` และใช้ออบเจ็กต์แบบ array-like `args` เป็นรายการอาร์กิวเมนต์
 
-The only syntax difference between `call` and `apply` is that `call` expects a list of arguments, while `apply` takes an array-like object with them.
+ข้อแตกต่างทางไวยากรณ์ระหว่าง `call` กับ `apply` มีแค่อย่างเดียว — `call` รับอาร์กิวเมนต์เป็นรายการ ส่วน `apply` รับเป็นออบเจ็กต์แบบ array-like
 
-So these two calls are almost equivalent:
+ดังนั้นสองบรรทัดนี้จึงเกือบเหมือนกัน:
 
 ```js
 func.call(context, ...args);
 func.apply(context, args);
 ```
 
-They perform the same call of `func` with given context and arguments.
+ทั้งสองเรียก `func` ด้วย context และอาร์กิวเมนต์เดียวกัน
 
-There's only a subtle difference regarding `args`:
+มีข้อแตกต่างเล็กน้อยเกี่ยวกับ `args`:
 
-- The spread syntax `...` allows to pass *iterable* `args` as the list to `call`.
-- The `apply` accepts only *array-like* `args`.
+- spread syntax `...` สามารถส่ง *iterable* `args` เป็นรายการให้ `call` ได้
+- `apply` รับเฉพาะ *array-like* `args` เท่านั้น
 
-...And for objects that are both iterable and array-like, such as a real array, we can use any of them, but `apply` will probably be faster, because most JavaScript engines internally optimize it better.
+...สำหรับออบเจ็กต์ที่เป็นทั้ง iterable และ array-like (เช่นอาร์เรย์จริงๆ) จะใช้ตัวไหนก็ได้ แต่ `apply` น่าจะเร็วกว่า เพราะ JavaScript engine ส่วนใหญ่ optimize ไว้ดีกว่า
 
-Passing all arguments along with the context to another function is called *call forwarding*.
+การส่งต่ออาร์กิวเมนต์ทั้งหมดพร้อม context ไปยังอีกฟังก์ชันหนึ่ง เรียกว่า *call forwarding*
 
-That's the simplest form of it:
+รูปแบบที่ง่ายที่สุดก็คือ:
 
 ```js
 let wrapper = function() {
@@ -324,11 +324,11 @@ let wrapper = function() {
 };
 ```
 
-When an external code calls such `wrapper`, it is indistinguishable from the call of the original function `func`.
+เมื่อโค้ดภายนอกเรียก `wrapper` ดังกล่าว จะแยกไม่ออกเลยว่ากำลังเรียก wrapper หรือฟังก์ชันเดิม `func`
 
-## Borrowing a method [#method-borrowing]
+## ยืมเมธอดมาใช้ (Method borrowing) [#method-borrowing]
 
-Now let's make one more minor improvement in the hashing function:
+ทีนี้มาปรับปรุง hashing function กันอีกนิด:
 
 ```js
 function hash(args) {
@@ -336,9 +336,9 @@ function hash(args) {
 }
 ```
 
-As of now, it works only on two arguments. It would be better if it could glue any number of `args`.
+ตอนนี้มันรองรับแค่สองอาร์กิวเมนต์ ถ้าทำให้รวมอาร์กิวเมนต์กี่ตัวก็ได้จะดีกว่า
 
-The natural solution would be to use [arr.join](mdn:js/Array/join) method:
+วิธีที่น่าจะนึกออกก่อนคือใช้เมธอด [arr.join](mdn:js/Array/join):
 
 ```js
 function hash(args) {
@@ -346,9 +346,9 @@ function hash(args) {
 }
 ```
 
-...Unfortunately, that won't work. Because we are calling `hash(arguments)`, and `arguments` object is both iterable and array-like, but not a real array.
+...แต่ว่าใช้ไม่ได้ เพราะเราเรียก `hash(arguments)` ซึ่งออบเจ็กต์ `arguments` เป็นทั้ง iterable และ array-like แต่ไม่ใช่อาร์เรย์จริงๆ
 
-So calling `join` on it would fail, as we can see below:
+การเรียก `join` จึงล้มเหลว ดังที่เห็นด้านล่าง:
 
 ```js run
 function hash() {
@@ -360,7 +360,7 @@ function hash() {
 hash(1, 2);
 ```
 
-Still, there's an easy way to use array join:
+แต่ก็ยังมีวิธีง่ายๆ ที่จะใช้ array join ได้:
 
 ```js run
 function hash() {
@@ -372,48 +372,48 @@ function hash() {
 hash(1, 2);
 ```
 
-The trick is called *method borrowing*.
+เทคนิคนี้เรียกว่า *method borrowing* (การยืมเมธอด)
 
-We take (borrow) a join method from a regular array (`[].join`) and use `[].join.call` to run it in the context of `arguments`.
+เราหยิบ (ยืม) เมธอด join มาจากอาร์เรย์ธรรมดา (`[].join`) แล้วใช้ `[].join.call` เพื่อรันมันในบริบทของ `arguments`
 
-Why does it work?
+ทำไมถึงใช้ได้?
 
-That's because the internal algorithm of the native method `arr.join(glue)` is very simple.
+เพราะอัลกอริทึมภายในของเมธอด `arr.join(glue)` นั้นเรียบง่ายมาก
 
-Taken from the specification almost "as-is":
+ตามสเปกคร่าวๆ ทำงานดังนี้:
 
-1. Let `glue` be the first argument or, if no arguments, then a comma `","`.
-2. Let `result` be an empty string.
-3. Append `this[0]` to `result`.
-4. Append `glue` and `this[1]`.
-5. Append `glue` and `this[2]`.
-6. ...Do so until `this.length` items are glued.
-7. Return `result`.
+1. กำหนดให้ `glue` เป็นอาร์กิวเมนต์ตัวแรก หรือถ้าไม่มีก็ใช้จุลภาค `","`
+2. กำหนดให้ `result` เป็นสตริงว่าง
+3. ต่อ `this[0]` เข้ากับ `result`
+4. ต่อ `glue` และ `this[1]`
+5. ต่อ `glue` และ `this[2]`
+6. ...ทำแบบนี้ไปจนถึง `this.length` รายการ
+7. คืนค่า `result`
 
-So, technically it takes `this` and joins `this[0]`, `this[1]` ...etc together. It's intentionally written in a way that allows any array-like `this` (not a coincidence, many methods follow this practice). That's why it also works with `this=arguments`.
+จะเห็นว่า join เอา `this` มาเชื่อม `this[0]`, `this[1]` ...เข้าด้วยกัน มันถูกเขียนมาให้รองรับ array-like `this` ตัวใดก็ได้ (ไม่ใช่เรื่องบังเอิญ เมธอดหลายตัวก็ทำแบบนี้) จึงใช้กับ `this=arguments` ได้เช่นกัน
 
-## Decorators and function properties
+## Decorator กับพร็อพเพอร์ตี้ของฟังก์ชัน
 
-It is generally safe to replace a function or a method with a decorated one, except for one little thing. If the original function had properties on it, like `func.calledCount` or whatever, then the decorated one will not provide them. Because that is a wrapper. So one needs to be careful if one uses them.
+โดยทั่วไปการแทนที่ฟังก์ชันหรือเมธอดด้วยเวอร์ชันที่ decorate แล้วจะปลอดภัย ยกเว้นอยู่อย่างหนึ่ง — ถ้าฟังก์ชันเดิมมีพร็อพเพอร์ตี้ติดอยู่ เช่น `func.calledCount` หรืออะไรก็ตาม ตัว decorator จะไม่มีพร็อพเพอร์ตี้เหล่านั้น เพราะมันเป็นแค่ wrapper จึงต้องระวังตรงนี้ด้วย
 
-E.g. in the example above if `slow` function had any properties on it, then `cachingDecorator(slow)` is a wrapper without them.
+ยกตัวอย่าง ถ้า `slow` มีพร็อพเพอร์ตี้ติดอยู่ `cachingDecorator(slow)` ที่ได้มาจะเป็น wrapper ที่ไม่มีพร็อพเพอร์ตี้เหล่านั้น
 
-Some decorators may provide their own properties. E.g. a decorator may count how many times a function was invoked and how much time it took, and expose this information via wrapper properties.
+decorator บางตัวอาจมีพร็อพเพอร์ตี้ของตัวเอง เช่น decorator ที่นับจำนวนครั้งที่ฟังก์ชันถูกเรียก หรือใช้เวลานานเท่าไหร่ แล้วเปิดให้เข้าถึงข้อมูลเหล่านี้ผ่านพร็อพเพอร์ตี้ของ wrapper
 
-There exists a way to create decorators that keep access to function properties, but this requires using a special `Proxy` object to wrap a function. We'll discuss it later in the article <info:proxy#proxy-apply>.
+มีวิธีสร้าง decorator ที่เข้าถึงพร็อพเพอร์ตี้ของฟังก์ชันเดิมได้ แต่ต้องใช้ออบเจ็กต์ `Proxy` พิเศษมาครอบฟังก์ชัน ซึ่งเราจะพูดถึงในบทความ <info:proxy#proxy-apply>
 
-## Summary
+## สรุป
 
-*Decorator* is a wrapper around a function that alters its behavior. The main job is still carried out by the function.
+*Decorator* คือ wrapper ที่ครอบฟังก์ชันเพื่อปรับเปลี่ยนพฤติกรรม โดยงานหลักยังคงเป็นของฟังก์ชันเดิม
 
-Decorators can be seen as "features" or "aspects" that can be added to a function. We can add one or add many. And all this without changing its code!
+มองว่า decorator เป็น "ฟีเจอร์" หรือ "ความสามารถ" ที่เพิ่มเข้าไปในฟังก์ชันก็ได้ จะเพิ่มกี่ตัวก็ได้ โดยไม่ต้องแก้โค้ดเดิมเลย!
 
-To implement `cachingDecorator`, we studied methods:
+ในการสร้าง `cachingDecorator` เราได้เรียนรู้เมธอดเหล่านี้:
 
-- [func.call(context, arg1, arg2...)](mdn:js/Function/call) -- calls `func` with given context and arguments.
-- [func.apply(context, args)](mdn:js/Function/apply) -- calls `func` passing `context` as `this` and array-like `args` into a list of arguments.
+- [func.call(context, arg1, arg2...)](mdn:js/Function/call) -- เรียก `func` ด้วย context และอาร์กิวเมนต์ที่กำหนด
+- [func.apply(context, args)](mdn:js/Function/apply) -- เรียก `func` โดยส่ง `context` เป็น `this` และ array-like `args` เป็นรายการอาร์กิวเมนต์
 
-The generic *call forwarding* is usually done with `apply`:
+*call forwarding* ทั่วไปจะใช้ `apply`:
 
 ```js
 let wrapper = function() {
@@ -421,6 +421,6 @@ let wrapper = function() {
 };
 ```
 
-We also saw an example of *method borrowing* when we take a method from an object and `call` it in the context of another object. It is quite common to take array methods and apply them to `arguments`. The alternative is to use rest parameters object that is a real array.
+เรายังได้เห็นตัวอย่างของ *method borrowing* ที่เราหยิบเมธอดจากออบเจ็กต์หนึ่งมา `call` ในบริบทของอีกออบเจ็กต์หนึ่ง การหยิบเมธอดของอาร์เรย์มาใช้กับ `arguments` เป็นเรื่องที่พบได้บ่อย อีกทางเลือกหนึ่งคือใช้ rest parameters ซึ่งเป็นอาร์เรย์จริง
 
-There are many decorators there in the wild. Check how well you got them by solving the tasks of this chapter.
+Decorator มีอีกหลายรูปแบบนอกจากนี้ ลองทดสอบความเข้าใจด้วยโจทย์ฝึกหัดในบทนี้กัน
diff --git a/1-js/06-advanced-functions/10-bind/2-write-to-object-after-bind/solution.md b/1-js/06-advanced-functions/10-bind/2-write-to-object-after-bind/solution.md
index 737a14481..08f3e17b5 100644
--- a/1-js/06-advanced-functions/10-bind/2-write-to-object-after-bind/solution.md
+++ b/1-js/06-advanced-functions/10-bind/2-write-to-object-after-bind/solution.md
@@ -1,4 +1,4 @@
-The answer: `null`.
+คำตอบ: `null`
 
 
 ```js run
@@ -13,6 +13,6 @@ let user = {
 user.g();
 ```
 
-The context of a bound function is hard-fixed. There's just no way to further change it.
+context ของฟังก์ชันที่ผูกแล้วจะถูกล็อกอยู่อย่างนั้น ไม่มีทางเปลี่ยนได้อีก
 
-So even while we run `user.g()`, the original function is called with `this=null`.
+ดังนั้นแม้เราจะเรียก `user.g()` ฟังก์ชันตัวเดิมก็จะถูกเรียกด้วย `this=null` อยู่ดี
diff --git a/1-js/06-advanced-functions/10-bind/2-write-to-object-after-bind/task.md b/1-js/06-advanced-functions/10-bind/2-write-to-object-after-bind/task.md
index 6d7e1fb24..2b90765aa 100644
--- a/1-js/06-advanced-functions/10-bind/2-write-to-object-after-bind/task.md
+++ b/1-js/06-advanced-functions/10-bind/2-write-to-object-after-bind/task.md
@@ -2,9 +2,9 @@ importance: 5
 
 ---
 
-# Bound function as a method
+# ฟังก์ชันที่ผูกแล้วใช้เป็นเมธอด
 
-What will be the output?
+ผลลัพธ์จะเป็นอะไร?
 
 ```js
 function f() {
diff --git a/1-js/06-advanced-functions/10-bind/3-second-bind/solution.md b/1-js/06-advanced-functions/10-bind/3-second-bind/solution.md
index 97e1c2809..af282d3f8 100644
--- a/1-js/06-advanced-functions/10-bind/3-second-bind/solution.md
+++ b/1-js/06-advanced-functions/10-bind/3-second-bind/solution.md
@@ -1,4 +1,4 @@
-The answer: **John**.
+คำตอบ: **John**
 
 ```js run no-beautify
 function f() {
@@ -10,6 +10,6 @@ f = f.bind( {name: "John"} ).bind( {name: "Pete"} );
 f(); // John
 ```
 
-The exotic [bound function](https://tc39.github.io/ecma262/#sec-bound-function-exotic-objects) object returned by `f.bind(...)` remembers the context (and arguments if provided) only at creation time. 
+[bound function](https://tc39.github.io/ecma262/#sec-bound-function-exotic-objects) (exotic object) ที่ `f.bind(...)` คืนมา จะจำ context (และอาร์กิวเมนต์ถ้ามี) เฉพาะตอนที่สร้างเท่านั้น
 
-A function cannot be re-bound.
+ฟังก์ชันที่ผูกแล้วจะผูกซ้ำอีกไม่ได้
diff --git a/1-js/06-advanced-functions/10-bind/3-second-bind/task.md b/1-js/06-advanced-functions/10-bind/3-second-bind/task.md
index 5daf053c6..35dae29ef 100644
--- a/1-js/06-advanced-functions/10-bind/3-second-bind/task.md
+++ b/1-js/06-advanced-functions/10-bind/3-second-bind/task.md
@@ -2,11 +2,11 @@ importance: 5
 
 ---
 
-# Second bind
+# bind ซ้ำ
 
-Can we change `this` by additional binding?
+เราสามารถเปลี่ยน `this` ด้วยการ bind ซ้ำอีกครั้งได้ไหม?
 
-What will be the output?
+ผลลัพธ์จะเป็นอะไร?
 
 ```js no-beautify
 function f() {
diff --git a/1-js/06-advanced-functions/10-bind/4-function-property-after-bind/solution.md b/1-js/06-advanced-functions/10-bind/4-function-property-after-bind/solution.md
index 181555d95..e3342a7c0 100644
--- a/1-js/06-advanced-functions/10-bind/4-function-property-after-bind/solution.md
+++ b/1-js/06-advanced-functions/10-bind/4-function-property-after-bind/solution.md
@@ -1,4 +1,3 @@
-The answer: `undefined`.
-
-The result of `bind` is another object. It does not have the `test` property.
+คำตอบ: `undefined`
 
+ผลลัพธ์ของ `bind` คือออบเจ็กต์ตัวใหม่ ซึ่งไม่มีพร็อพเพอร์ตี้ `test`
diff --git a/1-js/06-advanced-functions/10-bind/4-function-property-after-bind/task.md b/1-js/06-advanced-functions/10-bind/4-function-property-after-bind/task.md
index d6cfb44bf..2837d101f 100644
--- a/1-js/06-advanced-functions/10-bind/4-function-property-after-bind/task.md
+++ b/1-js/06-advanced-functions/10-bind/4-function-property-after-bind/task.md
@@ -2,9 +2,9 @@ importance: 5
 
 ---
 
-# Function property after bind
+# พร็อพเพอร์ตี้ของฟังก์ชันหลัง bind
 
-There's a value in the property of a function. Will it change after `bind`? Why, or why not?
+ฟังก์ชันมีค่าเก็บอยู่ในพร็อพเพอร์ตี้ หลังจาก `bind` แล้วค่านั้นจะเปลี่ยนไหม? เพราะอะไร?
 
 ```js run
 function sayHi() {
@@ -17,7 +17,7 @@ let bound = sayHi.bind({
   name: "John"
 });
 
-alert( bound.test ); // what will be the output? why?
+alert( bound.test ); // ผลลัพธ์จะเป็นอะไร? ทำไม?
 */!*
 ```
 
diff --git a/1-js/06-advanced-functions/10-bind/5-question-use-bind/solution.md b/1-js/06-advanced-functions/10-bind/5-question-use-bind/solution.md
index 4a381c0b4..1426f659c 100644
--- a/1-js/06-advanced-functions/10-bind/5-question-use-bind/solution.md
+++ b/1-js/06-advanced-functions/10-bind/5-question-use-bind/solution.md
@@ -1,9 +1,9 @@
 
-The error occurs because `askPassword` gets functions `loginOk/loginFail` without the object.
+ที่เกิดข้อผิดพลาดเพราะ `askPassword` ได้รับฟังก์ชัน `loginOk/loginFail` ไปลอยๆ โดยไม่ได้ผูกกับออบเจ็กต์
 
-When it calls them, they naturally assume `this=undefined`.
+พอเรียกฟังก์ชันเหล่านี้ `this` จึงกลายเป็น `undefined`
 
-Let's `bind` the context:
+มาใช้ `bind` ผูก context กัน:
 
 ```js run
 function askPassword(ok, fail) {
@@ -30,14 +30,14 @@ askPassword(user.loginOk.bind(user), user.loginFail.bind(user));
 */!*
 ```
 
-Now it works.
+ทีนี้ก็ทำงานได้แล้ว
 
-An alternative solution could be:
+อีกวิธีหนึ่งคือใช้ arrow function:
 ```js
 //...
 askPassword(() => user.loginOk(), () => user.loginFail());
 ```
 
-Usually that also works and looks good.
+วิธีนี้ก็ใช้ได้ดีเหมือนกัน
 
-It's a bit less reliable though in more complex situations where `user` variable might change *after* `askPassword` is called, but *before* the visitor answers and calls `() => user.loginOk()`. 
+แต่จะมีความเสี่ยงเล็กน้อยในกรณีที่ซับซ้อนกว่านี้ คือถ้า `user` เปลี่ยนค่า*หลัง*เรียก `askPassword` แต่*ก่อน*ที่ผู้ใช้จะตอบรหัสผ่านและเรียก `() => user.loginOk()` ค่าของ `user` ก็อาจจะไม่ใช่ตัวเดิมแล้ว
diff --git a/1-js/06-advanced-functions/10-bind/5-question-use-bind/task.md b/1-js/06-advanced-functions/10-bind/5-question-use-bind/task.md
index fe6a9b4eb..a627e3136 100644
--- a/1-js/06-advanced-functions/10-bind/5-question-use-bind/task.md
+++ b/1-js/06-advanced-functions/10-bind/5-question-use-bind/task.md
@@ -2,13 +2,13 @@ importance: 5
 
 ---
 
-# Fix a function that loses "this"
+# แก้ฟังก์ชันที่ this หาย
 
-The call to `askPassword()` in the code below should check the password and then call `user.loginOk/loginFail` depending on the answer.
+การเรียก `askPassword()` ในโค้ดด้านล่างควรเช็ครหัสผ่าน แล้วเรียก `user.loginOk/loginFail` ตามผลลัพธ์
 
-But it leads to an error. Why?
+แต่กลับเกิดข้อผิดพลาด ทำไม?
 
-Fix the highlighted line for everything to start working right (other lines are not to be changed).
+ให้แก้บรรทัดที่ไฮไลต์ให้ทุกอย่างทำงานถูกต้อง (ห้ามแก้บรรทัดอื่น)
 
 ```js run
 function askPassword(ok, fail) {
diff --git a/1-js/06-advanced-functions/10-bind/6-ask-partial/solution.md b/1-js/06-advanced-functions/10-bind/6-ask-partial/solution.md
index 3284c943b..9ae0fdedb 100644
--- a/1-js/06-advanced-functions/10-bind/6-ask-partial/solution.md
+++ b/1-js/06-advanced-functions/10-bind/6-ask-partial/solution.md
@@ -1,16 +1,16 @@
 
 
-1. Either use a wrapper function, an arrow to be concise:
+1. ใช้ wrapper function หรือ arrow function ก็ได้:
 
-    ```js 
-    askPassword(() => user.login(true), () => user.login(false)); 
+    ```js
+    askPassword(() => user.login(true), () => user.login(false));
     ```
 
-    Now it gets `user` from outer variables and runs it the normal way.
+    วิธีนี้จะเข้าถึง `user` จากตัวแปรภายนอก แล้วเรียกเมธอดตามปกติ
 
-2. Or create a partial function from `user.login` that uses `user` as the context and has the correct first argument:
+2. หรือสร้าง partial function จาก `user.login` โดยผูก `user` เป็น context พร้อมกำหนดอาร์กิวเมนต์ตัวแรกไว้:
 
 
-    ```js 
-    askPassword(user.login.bind(user, true), user.login.bind(user, false)); 
+    ```js
+    askPassword(user.login.bind(user, true), user.login.bind(user, false));
     ```
diff --git a/1-js/06-advanced-functions/10-bind/6-ask-partial/task.md b/1-js/06-advanced-functions/10-bind/6-ask-partial/task.md
index c90851c2b..f9c891518 100644
--- a/1-js/06-advanced-functions/10-bind/6-ask-partial/task.md
+++ b/1-js/06-advanced-functions/10-bind/6-ask-partial/task.md
@@ -2,13 +2,13 @@ importance: 5
 
 ---
 
-# Partial application for login
+# Partial application สำหรับ login
 
-The task is a little more complex variant of <info:task/question-use-bind>. 
+โจทย์นี้เป็นเวอร์ชันที่ซับซ้อนขึ้นจาก <info:task/question-use-bind>
 
-The `user` object was modified. Now instead of two functions `loginOk/loginFail`, it has a single function `user.login(true/false)`.
+ออบเจ็กต์ `user` ถูกแก้ไข ตอนนี้แทนที่จะมีสองฟังก์ชัน `loginOk/loginFail` กลับมีฟังก์ชันเดียวคือ `user.login(true/false)`
 
-What should we pass `askPassword` in the code below, so that it calls `user.login(true)` as `ok` and `user.login(false)` as `fail`?
+เราควรส่งอะไรให้ `askPassword` ในโค้ดด้านล่าง เพื่อให้เรียก `user.login(true)` เมื่อรหัสถูก และ `user.login(false)` เมื่อรหัสผิด?
 
 ```js
 function askPassword(ok, fail) {
@@ -30,5 +30,5 @@ askPassword(?, ?); // ?
 */!*
 ```
 
-Your changes should only modify the highlighted fragment.
+ให้แก้เฉพาะส่วนที่ไฮไลต์เท่านั้น
 
diff --git a/1-js/06-advanced-functions/10-bind/article.md b/1-js/06-advanced-functions/10-bind/article.md
index 7a6e47b90..d2e959ef5 100644
--- a/1-js/06-advanced-functions/10-bind/article.md
+++ b/1-js/06-advanced-functions/10-bind/article.md
@@ -3,17 +3,17 @@ libs:
 
 ---
 
-# Function binding
+# การผูกฟังก์ชัน (Function binding)
 
-When passing object methods as callbacks, for instance to `setTimeout`, there's a known problem: "losing `this`".
+เวลาส่งเมธอดของออบเจ็กต์ไปเป็นคอลแบ็ก เช่น ส่งให้ `setTimeout` จะมีปัญหาที่เจอบ่อยอย่างหนึ่งคือ "this หาย"
 
-In this chapter we'll see the ways to fix it.
+ในบทนี้เราจะมาดูวิธีแก้ปัญหานี้กัน
 
-## Losing "this"
+## this หายได้อย่างไร
 
-We've already seen examples of losing `this`. Once a method is passed somewhere separately from the object -- `this` is lost.
+เราเคยเห็นตัวอย่างที่ `this` หายไปมาก่อนแล้ว พอส่งเมธอดออกไปจากออบเจ็กต์ `this` ก็จะหายตามไปด้วย
 
-Here's how it may happen with `setTimeout`:
+ลองดูตัวอย่างกับ `setTimeout`:
 
 ```js run
 let user = {
@@ -28,22 +28,22 @@ setTimeout(user.sayHi, 1000); // Hello, undefined!
 */!*
 ```
 
-As we can see, the output shows not "John" as `this.firstName`, but `undefined`!
+จะเห็นว่าผลลัพธ์ไม่ได้แสดง "John" อย่างที่คาดหวัง แต่กลับได้ `undefined` แทน!
 
-That's because `setTimeout` got the function `user.sayHi`, separately from the object. The last line can be rewritten as:
+ทั้งนี้เพราะ `setTimeout` ได้รับแค่ฟังก์ชัน `user.sayHi` ไปลอยๆ โดยไม่ได้ผูกกับออบเจ็กต์ บรรทัดสุดท้ายเขียนใหม่ได้แบบนี้:
 
 ```js
 let f = user.sayHi;
-setTimeout(f, 1000); // lost user context
+setTimeout(f, 1000); // สูญเสีย context ของ user
 ```
 
-The method `setTimeout` in-browser is a little special: it sets `this=window` for the function call (for Node.js, `this` becomes the timer object, but doesn't really matter here). So for `this.firstName` it tries to get `window.firstName`, which does not exist. In other similar cases, usually `this` just becomes `undefined`.
+เมธอด `setTimeout` ในเบราว์เซอร์มีพฤติกรรมพิเศษอยู่อย่างหนึ่ง คือจะตั้งค่า `this=window` ให้กับฟังก์ชันที่เรียก (ส่วน Node.js จะได้ timer object แทน แต่ไม่สำคัญในตอนนี้) ดังนั้น `this.firstName` จึงพยายามดึง `window.firstName` ซึ่งไม่มีอยู่จริง กรณีอื่นๆ ที่คล้ายกัน `this` มักจะกลายเป็น `undefined` ไปเลย
 
-The task is quite typical -- we want to pass an object method somewhere else (here -- to the scheduler) where it will be called. How to make sure that it will be called in the right context?
+โจทย์แบบนี้เจอได้บ่อย คือเราอยากส่งเมธอดของออบเจ็กต์ไปให้ที่อื่น (ในที่นี้คือ scheduler) เรียกใช้ แล้วจะทำยังไงให้ context ถูกต้อง?
 
-## Solution 1: a wrapper
+## วิธีที่ 1: ใช้ wrapper function
 
-The simplest solution is to use a wrapping function:
+วิธีง่ายที่สุดคือครอบด้วยฟังก์ชัน:
 
 ```js run
 let user = {
@@ -60,17 +60,17 @@ setTimeout(function() {
 */!*
 ```
 
-Now it works, because it receives `user` from the outer lexical environment, and then calls the method normally.
+ทีนี้ก็ใช้ได้แล้ว เพราะฟังก์ชันที่ครอบไว้จะเข้าถึง `user` จาก Lexical Environment ภายนอก แล้วเรียกเมธอดตามปกติ
 
-The same, but shorter:
+เขียนสั้นลงด้วย arrow function ก็ได้:
 
 ```js
 setTimeout(() => user.sayHi(), 1000); // Hello, John!
 ```
 
-Looks fine, but a slight vulnerability appears in our code structure.
+ดูดีแล้ว แต่มีจุดอ่อนอยู่นิดหนึ่ง
 
-What if before `setTimeout` triggers (there's one second delay!) `user` changes value? Then, suddenly, it will call the wrong object!
+ถ้า `user` เปลี่ยนค่าก่อนที่ `setTimeout` จะทำงาน (มีดีเลย์ 1 วินาทีนะ!) ก็จะเรียกผิดออบเจ็กต์ไปเลย!
 
 
 ```js run
@@ -83,7 +83,7 @@ let user = {
 
 setTimeout(() => user.sayHi(), 1000);
 
-// ...the value of user changes within 1 second
+// ...ค่าของ user เปลี่ยนภายใน 1 วินาที
 user = {
   sayHi() { alert("Another user in setTimeout!"); }
 };
@@ -91,26 +91,26 @@ user = {
 // Another user in setTimeout!
 ```
 
-The next solution guarantees that such thing won't happen.
+วิธีถัดไปจะช่วยป้องกันปัญหานี้ได้
 
-## Solution 2: bind
+## วิธีที่ 2: bind
 
-Functions provide a built-in method [bind](mdn:js/Function/bind) that allows to fix `this`.
+ฟังก์ชันมีเมธอดในตัวชื่อ [bind](mdn:js/Function/bind) ที่ช่วยล็อก `this` ไว้ได้
 
-The basic syntax is:
+ไวยากรณ์เบื้องต้น:
 
 ```js
-// more complex syntax will come a little later
+// ไวยากรณ์แบบเต็มจะอธิบายทีหลัง
 let boundFunc = func.bind(context);
 ```
 
-The result of `func.bind(context)` is a special function-like "exotic object", that is callable as function and transparently passes the call to `func` setting `this=context`.
+ผลลัพธ์จาก `func.bind(context)` คือ "exotic object" พิเศษที่เรียกใช้ได้เหมือนฟังก์ชัน โดยจะส่งต่อการเรียกไปยัง `func` พร้อมตั้ง `this=context` ให้
 
-In other words, calling `boundFunc` is like `func` with fixed `this`.
+พูดง่ายๆ คือ เรียก `boundFunc` ก็เหมือนเรียก `func` แต่ `this` ถูกล็อกไว้แล้ว
 
-For instance, here `funcUser` passes a call to `func` with `this=user`:
+ยกตัวอย่าง `funcUser` จะส่งต่อการเรียกไปยัง `func` พร้อมตั้ง `this=user`:
 
-```js run  
+```js run
 let user = {
   firstName: "John"
 };
@@ -121,15 +121,15 @@ function func() {
 
 *!*
 let funcUser = func.bind(user);
-funcUser(); // John  
+funcUser(); // John
 */!*
 ```
 
-Here `func.bind(user)` is a "bound variant" of `func`, with fixed `this=user`.
+ตรงนี้ `func.bind(user)` สร้าง "เวอร์ชันที่ผูกแล้ว" ของ `func` โดยล็อก `this=user` ไว้
 
-All arguments are passed to the original `func` "as is", for instance:
+อาร์กิวเมนต์ทั้งหมดจะถูกส่งต่อไปยัง `func` ตามเดิม เช่น:
 
-```js run  
+```js run
 let user = {
   firstName: "John"
 };
@@ -138,15 +138,15 @@ function func(phrase) {
   alert(phrase + ', ' + this.firstName);
 }
 
-// bind this to user
+// ผูก this ไว้กับ user
 let funcUser = func.bind(user);
 
 *!*
-funcUser("Hello"); // Hello, John (argument "Hello" is passed, and this=user)
+funcUser("Hello"); // Hello, John (อาร์กิวเมนต์ "Hello" ถูกส่งต่อ และ this=user)
 */!*
 ```
 
-Now let's try with an object method:
+ทีนี้มาลองกับเมธอดของออบเจ็กต์ดู:
 
 
 ```js run
@@ -161,21 +161,21 @@ let user = {
 let sayHi = user.sayHi.bind(user); // (*)
 */!*
 
-// can run it without an object
+// เรียกได้โดยไม่ต้องมีออบเจ็กต์
 sayHi(); // Hello, John!
 
 setTimeout(sayHi, 1000); // Hello, John!
 
-// even if the value of user changes within 1 second
-// sayHi uses the pre-bound value which is reference to the old user object
+// ถึง user จะเปลี่ยนค่าภายใน 1 วินาที
+// sayHi ก็ยังใช้ค่าที่ผูกไว้ตั้งแต่แรก ซึ่งอ้างอิงไปยังออบเจ็กต์ user ตัวเดิม
 user = {
   sayHi() { alert("Another user in setTimeout!"); }
 };
 ```
 
-In the line `(*)` we take the method `user.sayHi` and bind it to `user`. The `sayHi` is a "bound" function, that can be called alone or passed to `setTimeout` -- doesn't matter, the context will be right.
+ที่บรรทัด `(*)` เราดึงเมธอด `user.sayHi` มาแล้วผูกกับ `user` ด้วย `bind` ตัว `sayHi` ที่ได้จึงเป็นฟังก์ชันที่ "ผูก" ไว้แล้ว จะเรียกเดี่ยวๆ หรือส่งให้ `setTimeout` ก็ได้ context จะถูกต้องเสมอ
 
-Here we can see that arguments are passed "as is", only `this` is fixed by `bind`:
+ตัวอย่างนี้แสดงให้เห็นว่าอาร์กิวเมนต์ถูกส่งต่อตามเดิม มีแค่ `this` เท่านั้นที่ `bind` ล็อกไว้:
 
 ```js run
 let user = {
@@ -187,12 +187,12 @@ let user = {
 
 let say = user.say.bind(user);
 
-say("Hello"); // Hello, John! ("Hello" argument is passed to say)
-say("Bye"); // Bye, John! ("Bye" is passed to say)
+say("Hello"); // Hello, John! (อาร์กิวเมนต์ "Hello" ถูกส่งให้ say)
+say("Bye"); // Bye, John! ("Bye" ถูกส่งให้ say)
 ```
 
-````smart header="Convenience method: `bindAll`"
-If an object has many methods and we plan to actively pass it around, then we could bind them all in a loop:
+````smart header="เมธอดสะดวก: `bindAll`"
+ถ้าออบเจ็กต์มีหลายเมธอดและเราจะส่งออบเจ็กต์นี้ไปใช้ที่อื่นบ่อยๆ ก็ผูกทุกเมธอดด้วยลูปได้เลย:
 
 ```js
 for (let key in user) {
@@ -202,24 +202,24 @@ for (let key in user) {
 }
 ```
 
-JavaScript libraries also provide functions for convenient mass binding , e.g. [_.bindAll(object, methodNames)](https://lodash.com/docs#bindAll) in lodash.
+ไลบรารี JavaScript อย่าง lodash ก็มีฟังก์ชันสำหรับผูกเมธอดทีเดียวหลายตัว เช่น [_.bindAll(object, methodNames)](https://lodash.com/docs#bindAll)
 ````
 
 ## Partial functions
 
-Until now we have only been talking about binding `this`. Let's take it a step further.
+ที่ผ่านมาเราพูดถึงแค่การผูก `this` ทีนี้มาดูเรื่องที่ลึกขึ้นอีกนิดกัน
 
-We can bind not only `this`, but also arguments. That's rarely done, but sometimes can be handy.
+เราสามารถผูกไม่ใช่แค่ `this` แต่ยังผูกอาร์กิวเมนต์ได้ด้วย ไม่ค่อยได้ใช้บ่อย แต่บางทีก็มีประโยชน์
 
-The full syntax of `bind`:
+ไวยากรณ์แบบเต็มของ `bind`:
 
 ```js
 let bound = func.bind(context, [arg1], [arg2], ...);
 ```
 
-It allows to bind context as `this` and starting arguments of the function.
+ช่วยให้เราผูกทั้ง context (`this`) และอาร์กิวเมนต์ตัวแรกๆ ของฟังก์ชันได้
 
-For instance, we have a multiplication function `mul(a, b)`:
+ยกตัวอย่าง สมมติมีฟังก์ชันคูณเลข `mul(a, b)`:
 
 ```js
 function mul(a, b) {
@@ -227,7 +227,7 @@ function mul(a, b) {
 }
 ```
 
-Let's use `bind` to create a function `double` on its base:
+มาลองใช้ `bind` สร้างฟังก์ชัน `double` จากฟังก์ชัน `mul`:
 
 ```js run
 function mul(a, b) {
@@ -243,13 +243,13 @@ alert( double(4) ); // = mul(2, 4) = 8
 alert( double(5) ); // = mul(2, 5) = 10
 ```
 
-The call to `mul.bind(null, 2)` creates a new function `double` that passes calls to `mul`, fixing `null` as the context and `2` as the first argument. Further arguments are passed "as is".
+`mul.bind(null, 2)` สร้างฟังก์ชันใหม่ `double` ที่ส่งต่อการเรียกไปยัง `mul` โดยล็อก `null` เป็น context และ `2` เป็นอาร์กิวเมนต์ตัวแรก อาร์กิวเมนต์ที่เหลือจะส่งต่อตามเดิม
 
-That's called [partial function application](https://en.wikipedia.org/wiki/Partial_application) -- we create a new function by fixing some parameters of the existing one.
+เทคนิคนี้เรียกว่า [partial function application](https://en.wikipedia.org/wiki/Partial_application) คือการสร้างฟังก์ชันใหม่โดยกำหนดพารามิเตอร์บางตัวของฟังก์ชันเดิมไว้ล่วงหน้า
 
-Please note that we actually don't use `this` here. But `bind` requires it, so we must put in something like `null`.
+สังเกตว่าตรงนี้เราไม่ได้ใช้ `this` เลย แต่ `bind` บังคับให้ใส่ จึงต้องส่ง `null` ไปแทน
 
-The function `triple` in the code below triples the value:
+ฟังก์ชัน `triple` ด้านล่างนี้ทำหน้าที่คูณค่าด้วย 3:
 
 ```js run
 function mul(a, b) {
@@ -265,23 +265,21 @@ alert( triple(4) ); // = mul(3, 4) = 12
 alert( triple(5) ); // = mul(3, 5) = 15
 ```
 
-Why do we usually make a partial function?
-
-The benefit is that we can create an independent function with a readable name (`double`, `triple`). We can use it and not provide the first argument every time as it's fixed with `bind`.
+ทำไมถึงนิยมสร้าง partial function?
 
-In other cases, partial application is useful when we have a very generic function and want a less universal variant of it for convenience.
+ข้อดีคือเราได้ฟังก์ชันแยกออกมาพร้อมชื่อที่อ่านเข้าใจง่าย (`double`, `triple`) เรียกใช้ได้เลยโดยไม่ต้องส่งอาร์กิวเมนต์ตัวแรกทุกครั้ง เพราะ `bind` ล็อกไว้ให้แล้ว
 
-For instance, we have a function `send(from, to, text)`. Then, inside a `user` object we may want to use a partial variant of it: `sendTo(to, text)` that sends from the current user.
+นอกจากนี้ partial application ยังมีประโยชน์ตอนที่เรามีฟังก์ชันกว้างๆ แล้วอยากสร้างเวอร์ชันเฉพาะทางที่ใช้สะดวกกว่า
 
-## Going partial without context
+เช่น สมมติมีฟังก์ชัน `send(from, to, text)` ถ้าอยู่ในออบเจ็กต์ `user` เราอาจสร้าง partial เป็น `sendTo(to, text)` ที่ล็อก `from` เป็นผู้ใช้ปัจจุบันไว้เลย
 
-What if we'd like to fix some arguments, but not the context `this`? For example, for an object method.
+## สร้าง partial โดยไม่ผูก context
 
-The native `bind` does not allow that. We can't just omit the context and jump to arguments.
+จะทำยังไงถ้าอยากล็อกแค่อาร์กิวเมนต์บางตัว แต่ไม่ต้องการผูก context (`this`)? เช่น กรณีที่ใช้กับเมธอดของออบเจ็กต์
 
-Fortunately, a function `partial` for binding only arguments can be easily implemented.
+`bind` ตัวเดิมทำไม่ได้ เพราะเราไม่สามารถข้ามพารามิเตอร์ context ไปใส่แค่อาร์กิวเมนต์ได้
 
-Like this:
+แต่เราเขียนฟังก์ชัน `partial` ที่ผูกแค่อาร์กิวเมนต์อย่างเดียวได้ไม่ยาก:
 
 ```js run
 *!*
@@ -292,7 +290,7 @@ function partial(func, ...argsBound) {
 }
 */!*
 
-// Usage:
+// การใช้งาน:
 let user = {
   firstName: "John",
   say(time, phrase) {
@@ -300,29 +298,29 @@ let user = {
   }
 };
 
-// add a partial method with fixed time
+// เพิ่มเมธอด partial ที่ล็อกเวลาไว้แล้ว
 user.sayNow = partial(user.say, new Date().getHours() + ':' + new Date().getMinutes());
 
 user.sayNow("Hello");
-// Something like:
+// ผลลัพธ์ประมาณนี้:
 // [10:00] John: Hello!
 ```
 
-The result of `partial(func[, arg1, arg2...])` call is a wrapper `(*)` that calls `func` with:
-- Same `this` as it gets (for `user.sayNow` call it's `user`)
-- Then gives it `...argsBound` -- arguments from the `partial` call (`"10:00"`)
-- Then gives it `...args` -- arguments given to the wrapper (`"Hello"`)
+ผลลัพธ์จาก `partial(func[, arg1, arg2...])` คือ wrapper `(*)` ที่เรียก `func` โดย:
+- ใช้ `this` เดียวกับที่ได้รับ (กรณีเรียก `user.sayNow` ก็คือ `user`)
+- จากนั้นส่ง `...argsBound` ซึ่งเป็นอาร์กิวเมนต์จากตอนเรียก `partial` (เช่น `"10:00"`)
+- แล้วก็ส่ง `...args` ซึ่งเป็นอาร์กิวเมนต์ที่ส่งให้ wrapper (เช่น `"Hello"`)
 
-So easy to do it with the spread syntax, right?
+ใช้ spread syntax ทำได้ง่ายเลยใช่ไหม?
 
-Also there's a ready [_.partial](https://lodash.com/docs#partial) implementation from lodash library.
+นอกจากนี้ไลบรารี lodash ก็มี [_.partial](https://lodash.com/docs#partial) ให้ใช้ได้เลยเช่นกัน
 
-## Summary
+## สรุป
 
-Method `func.bind(context, ...args)` returns a "bound variant" of function `func` that fixes the context `this` and first arguments if given.
+เมธอด `func.bind(context, ...args)` คืนค่า "เวอร์ชันที่ผูกแล้ว" ของฟังก์ชัน `func` โดยล็อก `this` และอาร์กิวเมนต์ตัวแรกๆ ไว้ (ถ้ามีการระบุ)
 
-Usually we apply `bind` to fix `this` for an object method, so that we can pass it somewhere. For example, to `setTimeout`.
+โดยทั่วไปเราใช้ `bind` เพื่อล็อก `this` ให้เมธอดของออบเจ็กต์ เพื่อจะได้ส่งไปใช้ที่อื่นได้ เช่น ส่งให้ `setTimeout`
 
-When we fix some arguments of an existing function, the resulting (less universal) function is called *partially applied* or *partial*.
+เมื่อเราล็อกอาร์กิวเมนต์บางตัวของฟังก์ชันเดิมไว้ ฟังก์ชันที่ได้จะเรียกว่า *partially applied* หรือ *partial*
 
-Partials are convenient when we don't want to repeat the same argument over and over again. Like if we have a `send(from, to)` function, and `from` should always be the same for our task, we can get a partial and go on with it.
+Partial มีประโยชน์ตอนที่เราไม่อยากส่งอาร์กิวเมนต์ตัวเดิมซ้ำแล้วซ้ำอีก เช่น ถ้ามีฟังก์ชัน `send(from, to)` และ `from` ควรเป็นค่าเดิมเสมอ ก็สร้าง partial แล้วใช้ต่อได้เลย
diff --git a/1-js/06-advanced-functions/12-arrow-functions/article.md b/1-js/06-advanced-functions/12-arrow-functions/article.md
index 8730277ad..f59f8506b 100644
--- a/1-js/06-advanced-functions/12-arrow-functions/article.md
+++ b/1-js/06-advanced-functions/12-arrow-functions/article.md
@@ -1,26 +1,26 @@
-# Arrow functions revisited
+# ทบทวนเรื่อง Arrow function
 
-Let's revisit arrow functions.
+มาทบทวนเรื่อง arrow function กันอีกครั้ง
 
-Arrow functions are not just a "shorthand" for writing small stuff. They have some very specific and useful features.
+Arrow function ไม่ได้เป็นแค่ "ชื่อย่อ" สำหรับเขียนฟังก์ชันสั้นๆ เท่านั้น แต่ยังมีคุณลักษณะเฉพาะตัวที่น่าสนใจอีกด้วย
 
-JavaScript is full of situations where we need to write a small function that's executed somewhere else.
+JavaScript เต็มไปด้วยสถานการณ์ที่เราต้องเขียนฟังก์ชันเล็กๆ แล้วส่งไปทำงานที่อื่น
 
-For instance:
+ยกตัวอย่างเช่น:
 
-- `arr.forEach(func)` -- `func` is executed by `forEach` for every array item.
-- `setTimeout(func)` -- `func` is executed by the built-in scheduler.
-- ...there are more.
+- `arr.forEach(func)` -- `func` จะถูกเรียกโดย `forEach` สำหรับทุกสมาชิกในอาร์เรย์
+- `setTimeout(func)` -- `func` จะถูกเรียกโดยตัวจัดกำหนดเวลาที่มีอยู่ในตัว
+- ...และอื่นๆ อีกมาก
 
-It's in the very spirit of JavaScript to create a function and pass it somewhere.
+การสร้างฟังก์ชันแล้วส่งไปใช้ที่อื่นถือเป็นหัวใจสำคัญของ JavaScript เลยก็ว่าได้
 
-And in such functions we usually don't want to leave the current context. That's where arrow functions come in handy.
+และในฟังก์ชันเหล่านั้น เรามักไม่อยากให้บริบท (context) เปลี่ยนไป นี่แหละคือจุดที่ arrow function เข้ามาช่วยได้อย่างดี
 
-## Arrow functions have no "this"
+## Arrow function ไม่มี "this"
 
-As we remember from the chapter <info:object-methods>, arrow functions do not have `this`. If `this` is accessed, it is taken from the outside.
+อย่างที่เราจำได้จากบท <info:object-methods> ว่า arrow function ไม่มี `this` เป็นของตัวเอง ถ้ามีการเข้าถึง `this` จะไปดึงค่ามาจากสโคปภายนอกแทน
 
-For instance, we can use it to iterate inside an object method:
+ลองดูตัวอย่างการใช้งานภายในเมธอดของออบเจ็กต์:
 
 ```js run
 let group = {
@@ -39,9 +39,9 @@ let group = {
 group.showList();
 ```
 
-Here in `forEach`, the arrow function is used, so `this.title` in it is exactly the same as in the outer method `showList`. That is: `group.title`.
+ใน `forEach` ตรงนี้ เราใช้ arrow function ทำให้ `this.title` ข้างในอ้างอิงไปยัง `this` ตัวเดียวกับเมธอด `showList` ภายนอก ซึ่งก็คือ `group.title` นั่นเอง
 
-If we used a "regular" function, there would be an error:
+แต่ถ้าเราใช้ฟังก์ชันแบบปกติ จะเกิด error ขึ้น:
 
 ```js run
 let group = {
@@ -61,28 +61,28 @@ let group = {
 group.showList();
 ```
 
-The error occurs because `forEach` runs functions with `this=undefined` by default, so the attempt to access `undefined.title` is made.
+error เกิดขึ้นเพราะ `forEach` จะรันฟังก์ชันโดยกำหนด `this=undefined` เป็นค่าเริ่มต้น จึงเกิดการเข้าถึง `undefined.title` ขึ้น
 
-That doesn't affect arrow functions, because they just don't have `this`.
+แต่ arrow function ไม่ได้รับผลกระทบ เพราะไม่มี `this` เป็นของตัวเองตั้งแต่แรก
 
-```warn header="Arrow functions can't run with `new`"
-Not having `this` naturally means another limitation: arrow functions can't be used as constructors. They can't be called with `new`.
+```warn header="Arrow function ใช้กับ `new` ไม่ได้"
+เนื่องจาก arrow function ไม่มี `this` จึงไม่สามารถใช้เป็นคอนสตรักเตอร์ได้ ดังนั้นจึงเรียกด้วย `new` ไม่ได้
 ```
 
-```smart header="Arrow functions VS bind"
-There's a subtle difference between an arrow function `=>` and a regular function called with `.bind(this)`:
+```smart header="Arrow function กับ bind ต่างกันอย่างไร"
+มีความแตกต่างเล็กน้อยระหว่าง arrow function `=>` กับฟังก์ชันปกติที่เรียกผ่าน `.bind(this)`:
 
-- `.bind(this)` creates a "bound version" of the function.
-- The arrow `=>` doesn't create any binding. The function simply doesn't have `this`. The lookup of `this` is made exactly the same way as a regular variable search: in the outer lexical environment.
+- `.bind(this)` สร้าง "เวอร์ชันที่ผูก this ไว้แล้ว" ของฟังก์ชัน
+- Arrow function `=>` ไม่ได้สร้างการผูกใดๆ ทั้งสิ้น ฟังก์ชันนี้ไม่มี `this` เป็นของตัวเอง การค้นหา `this` จะทำเหมือนกับการค้นหาตัวแปรทั่วไป คือไล่หาใน lexical environment ภายนอก
 ```
 
-## Arrows have no "arguments"
+## Arrow function ไม่มี "arguments"
 
-Arrow functions also have no `arguments` variable.
+Arrow function ไม่มีตัวแปร `arguments` เช่นกัน
 
-That's great for decorators, when we need to forward a call with the current `this` and `arguments`.
+สิ่งนี้มีประโยชน์มากสำหรับ decorator เพราะเราสามารถส่งต่อการเรียกพร้อมกับ `this` และ `arguments` ของบริบทปัจจุบันได้เลย
 
-For instance, `defer(f, ms)` gets a function and returns a wrapper around it that delays the call by `ms` milliseconds:
+ยกตัวอย่าง `defer(f, ms)` รับฟังก์ชันเข้ามาแล้วคืนค่า wrapper ที่หน่วงเวลาการเรียกไป `ms` มิลลิวินาที:
 
 ```js run
 function defer(f, ms) {
@@ -96,10 +96,10 @@ function sayHi(who) {
 }
 
 let sayHiDeferred = defer(sayHi, 2000);
-sayHiDeferred("John"); // Hello, John after 2 seconds
+sayHiDeferred("John"); // Hello, John หลังจากผ่านไป 2 วินาที
 ```
 
-The same without an arrow function would look like:
+ถ้าเขียนแบบเดียวกันโดยไม่ใช้ arrow function จะได้แบบนี้:
 
 ```js
 function defer(f, ms) {
@@ -112,15 +112,15 @@ function defer(f, ms) {
 }
 ```
 
-Here we had to create additional variables `args` and `ctx` so that the function inside `setTimeout` could take them.
+สังเกตว่าเราต้องสร้างตัวแปร `args` และ `ctx` เพิ่มเพื่อให้ฟังก์ชันใน `setTimeout` เข้าถึงค่าเหล่านี้ได้
 
-## Summary
+## สรุป
 
-Arrow functions:
+Arrow function:
 
-- Do not have `this`
-- Do not have `arguments`
-- Can't be called with `new`
-- They also don't have `super`, but we didn't study it yet. We will on the chapter <info:class-inheritance>
+- ไม่มี `this`
+- ไม่มี `arguments`
+- เรียกด้วย `new` ไม่ได้
+- ไม่มี `super` เช่นกัน แต่เรายังไม่ได้เรียนเรื่องนี้ จะได้เรียนในบท <info:class-inheritance>
 
-That's because they are meant for short pieces of code that do not have their own "context", but rather work in the current one. And they really shine in that use case.
+ทั้งหมดนี้เป็นเพราะ arrow function ถูกออกแบบมาสำหรับโค้ดสั้นๆ ที่ไม่ต้องการ "บริบท" เป็นของตัวเอง แต่ใช้บริบทจากที่ที่มันอยู่แทน และ arrow function ก็ทำหน้าที่นี้ได้ดีมากจริงๆ
diff --git a/1-js/06-advanced-functions/index.md b/1-js/06-advanced-functions/index.md
index 7800dcc42..815e05e19 100644
--- a/1-js/06-advanced-functions/index.md
+++ b/1-js/06-advanced-functions/index.md
@@ -1 +1 @@
-# Advanced working with functions
+# การทำงานกับฟังก์ชันขั้นสูง