diff --git a/1-js/11-async/01-callbacks/article.md b/1-js/11-async/01-callbacks/article.md
index 57115a909..bab5811a9 100644
--- a/1-js/11-async/01-callbacks/article.md
+++ b/1-js/11-async/01-callbacks/article.md
@@ -1,68 +1,67 @@
 
+# บทนำ: callback
 
-# Introduction: callbacks
+```warn header="ตัวอย่างในบทนี้ใช้ browser methods"
+เพื่ออธิบาย callback, promise และ concept ที่เกี่ยวข้อง เราจะหยิบ browser methods มาใช้ โดยเฉพาะการโหลด script และจัดการ document เบื้องต้น
 
-```warn header="We use browser methods in examples here"
-To demonstrate the use of callbacks, promises and other abstract concepts, we'll be using some browser methods: specifically, loading scripts and performing simple document manipulations.
+ถ้ายังไม่คุ้นเคยกับพวกนี้และอ่านแล้วงง ลองข้ามไปอ่าน [ส่วนถัดไป](/document) ของ tutorial ก่อนก็ได้
 
-If you're not familiar with these methods, and their usage in the examples is confusing, you may want to read a few chapters from the [next part](/document) of the tutorial.
-
-Although, we'll try to make things clear anyway. There won't be anything really complex browser-wise.
+แต่เราจะพยายามอธิบายให้ชัดอยู่ดี — ไม่มีอะไรที่ซับซ้อนมากในแง่ browser
 ```
 
-Many functions are provided by JavaScript host environments that allow you to schedule *asynchronous* actions. In other words, actions that we initiate now, but they finish later.
+JavaScript host environment มีฟังก์ชันหลายตัวที่ช่วยให้เรา schedule งาน *asynchronous* ได้ — พูดง่ายๆ คือ "สั่งให้ทำ แต่ไม่ต้องรอ ทำเสร็จแล้วค่อยบอก"
 
-For instance, one such function is the `setTimeout` function.
+ตัวอย่างที่คุ้นกันดีที่สุดคือ `setTimeout`
 
-There are other real-world examples of asynchronous actions, e.g. loading scripts and modules (we'll cover them in later chapters).
+งาน asynchronous ในชีวิตจริงยังมีอีก เช่น การโหลด script หรือ module (จะพูดถึงในบทหลัง)
 
-Take a look at the function `loadScript(src)`, that loads a script with the given `src`:
+ลองดูฟังก์ชัน `loadScript(src)` ที่โหลด script จาก `src` ที่กำหนด:
 
 ```js
 function loadScript(src) {
-  // creates a <script> tag and append it to the page
-  // this causes the script with given src to start loading and run when complete
+  // สร้าง tag <script> แล้วแปะไว้ในหน้า
+  // พอแปะแล้ว browser จะเริ่มโหลด script ทันที และรันเมื่อโหลดเสร็จ
   let script = document.createElement('script');
   script.src = src;
   document.head.append(script);
 }
 ```
 
-It inserts into the document a new, dynamically created, tag `<script src="…">` with the given `src`. The browser automatically starts loading it and executes when complete.
+ฟังก์ชันนี้สร้าง tag `<script src="…">` แล้วแทรกเข้าไปใน document browser จะโหลดและรัน script นั้นให้เองโดยอัตโนมัติ
 
-We can use this function like this:
+เรียกใช้แบบนี้:
 
 ```js
-// load and execute the script at the given path
+// โหลดและรัน script จาก path ที่กำหนด
 loadScript('/my/script.js');
 ```
 
-The script is executed "asynchronously", as it starts loading now, but runs later, when the function has already finished.
+ประเด็นคือ script นี้รัน "แบบ asynchronous" — เริ่มโหลดตอนนี้ แต่รันจริงทีหลัง หลังจากโค้ดที่เหลือทำงานเสร็จแล้ว
 
-If there's any code below `loadScript(…)`, it doesn't wait until the script loading finishes.
+โค้ดที่เขียนหลัง `loadScript(…)` ไม่รอให้โหลดเสร็จก่อน:
 
 ```js
 loadScript('/my/script.js');
-// the code below loadScript
-// doesn't wait for the script loading to finish
+// โค้ดที่อยู่ต่อจาก loadScript
+// ไม่รอให้ script โหลดเสร็จ
 // ...
 ```
 
-Let's say we need to use the new script as soon as it loads. It declares new functions, and we want to run them.
+สมมติเราอยากใช้ฟังก์ชันใน script ที่โหลดมา ทันทีที่มันโหลดเสร็จ
 
-But if we do that immediately after the `loadScript(…)` call, that wouldn't work:
+แต่ถ้าเรียกมันต่อจาก `loadScript(…)` เลย มันจะเจ๊ง:
 
 ```js
-loadScript('/my/script.js'); // the script has "function newFunction() {…}"
+loadScript('/my/script.js'); // ใน script มี "function newFunction() {…}"
 
 *!*
-newFunction(); // no such function!
+newFunction(); // ไม่มีฟังก์ชันนี้!
 */!*
 ```
 
-Naturally, the browser probably didn't have time to load the script. As of now, the `loadScript` function doesn't provide a way to track the load completion. The script loads and eventually runs, that's all. But we'd like to know when it happens, to use new functions and variables from that script.
+เหตุผลก็ชัดเจน — browser ยังโหลดไม่เสร็จเลย ตอนนี้ `loadScript` ยังไม่มีทางบอกเราได้ว่า "โหลดเสร็จแล้วนะ" script จะโหลดเสร็จแล้วรัน แค่นั้น แต่เราไม่รู้ว่า "เมื่อไหร่" — เลยเรียกฟังก์ชันใน script นั้นไม่ได้
 
-Let's add a `callback` function as a second argument to `loadScript` that should execute when the script loads:
+แก้ได้ด้วยการเพิ่ม `callback` เป็นอาร์กิวเมนต์ตัวที่สองของ `loadScript` ฟังก์ชันนี้จะรันหลัง script โหลดเสร็จ:
 
 ```js
 function loadScript(src, *!*callback*/!*) {
@@ -77,21 +76,21 @@ function loadScript(src, *!*callback*/!*) {
 }
 ```
 
-The `onload` event is described in the article <info:onload-onerror#loading-a-script>, it basically executes a function after the script is loaded and executed.
+อีเวนต์ `onload` อธิบายไว้ในบทความ <info:onload-onerror#loading-a-script> — โดยย่อคือมันจะเรียกฟังก์ชันหลัง script โหลดและรันเสร็จ
 
-Now if we want to call new functions from the script, we should write that in the callback:
+ทีนี้ถ้าอยากเรียกฟังก์ชันจาก script ที่โหลดมา ก็เขียนไว้ใน callback:
 
 ```js
 loadScript('/my/script.js', function() {
-  // the callback runs after the script is loaded
-  newFunction(); // so now it works
+  // callback รันหลัง script โหลดเสร็จ
+  newFunction(); // ตอนนี้ใช้ได้แล้ว
   ...
 });
 ```
 
-That's the idea: the second argument is a function (usually anonymous) that runs when the action is completed.
+พูดง่ายๆ คือ อาร์กิวเมนต์ตัวที่สองเป็นฟังก์ชัน (มักเป็น anonymous function) ที่จะรันเมื่อ action นั้นทำเสร็จ
 
-Here's a runnable example with a real script:
+ลองดูตัวอย่างที่รันได้จริงกับ script จริงๆ:
 
 ```js run
 function loadScript(src, callback) {
@@ -103,39 +102,39 @@ function loadScript(src, callback) {
 
 *!*
 loadScript('https://cdnjs.cloudflare.com/ajax/libs/lodash.js/3.2.0/lodash.js', script => {
-  alert(`Cool, the script ${script.src} is loaded`);
-  alert( _ ); // _ is a function declared in the loaded script
+  alert(`เยี่ยม! script ${script.src} โหลดเสร็จแล้ว`);
+  alert( _ ); // _ คือฟังก์ชันที่ประกาศไว้ใน script ที่เพิ่งโหลดมา
 });
 */!*
 ```
 
-That's called a "callback-based" style of asynchronous programming. A function that does something asynchronously should provide a `callback` argument where we put the function to run after it's complete.
+ท่านี้เรียกว่า "callback-based" style — ฟังก์ชันที่ทำงาน asynchronous จะรับ `callback` เป็นอาร์กิวเมนต์ไว้ เพื่อเรียกตอนทำเสร็จ
 
-Here we did it in `loadScript`, but of course it's a general approach.
+เราใช้แนวทางนี้กับ `loadScript` แต่จริงๆ เป็น pattern ทั่วไปที่ใช้กันในหลายที่มากๆ
 
-## Callback in callback
+## Callback ซ้อน callback
 
-How can we load two scripts sequentially: the first one, and then the second one after it?
+จะโหลด script สองตัวตามลำดับยังไงล่ะ? ตัวแรกก่อน แล้วค่อยโหลดตัวที่สอง
 
-The natural solution would be to put the second `loadScript` call inside the callback, like this:
+วิธีที่ตรงไปตรงมาคือเอา `loadScript` ตัวที่สองไปใส่ไว้ใน callback ของตัวแรก:
 
 ```js
 loadScript('/my/script.js', function(script) {
 
-  alert(`Cool, the ${script.src} is loaded, let's load one more`);
+  alert(`เยี่ยม! ${script.src} โหลดเสร็จแล้ว โหลดอีกตัวนึงเลย`);
 
 *!*
   loadScript('/my/script2.js', function(script) {
-    alert(`Cool, the second script is loaded`);
+    alert(`เยี่ยม! script ตัวที่สองโหลดเสร็จแล้ว`);
   });
 */!*
 
 });
 ```
 
-After the outer `loadScript` is complete, the callback initiates the inner one.
+พอ `loadScript` ตัวนอกทำเสร็จ callback ก็จะเรียก `loadScript` ตัวใน
 
-What if we want one more script...?
+แล้วถ้าต้องการโหลด script ตัวที่สามด้วยล่ะ...?
 
 ```js
 loadScript('/my/script.js', function(script) {
@@ -144,7 +143,7 @@ loadScript('/my/script.js', function(script) {
 
 *!*
     loadScript('/my/script3.js', function(script) {
-      // ...continue after all scripts are loaded
+      // ...ทำต่อหลังจากทุก script โหลดเสร็จ
     });
 */!*
 
@@ -153,13 +152,13 @@ loadScript('/my/script.js', function(script) {
 });
 ```
 
-So, every new action is inside a callback. That's fine for few actions, but not good for many, so we'll see other variants soon.
+action ใหม่ทุกอันก็ต้องซ้อนเข้าไปใน callback ถ้ามีแค่ 2-3 อันก็ยังพอไหว แต่ถ้าเยอะกว่านี้จะเริ่มมีปัญหา — เดี๋ยวจะเห็นกัน
 
-## Handling errors
+## จัดการ error
 
-In the above examples we didn't consider errors. What if the script loading fails? Our callback should be able to react on that.
+ตัวอย่างที่ผ่านมาไม่ได้คิดเรื่อง error เลย ถ้า script โหลดไม่ขึ้นล่ะ? callback ต้องรับมือกับกรณีนี้ได้ด้วย
 
-Here's an improved version of `loadScript` that tracks loading errors:
+นี่คือ `loadScript` เวอร์ชันที่จัดการ error ด้วย:
 
 ```js
 function loadScript(src, callback) {
@@ -175,32 +174,32 @@ function loadScript(src, callback) {
 }
 ```
 
-It calls `callback(null, script)` for successful load and `callback(error)` otherwise.
+โหลดสำเร็จก็เรียก `callback(null, script)` โหลดเจ๊งก็เรียก `callback(error)`
 
-The usage:
+การใช้งาน:
 ```js
 loadScript('/my/script.js', function(error, script) {
   if (error) {
-    // handle error
+    // จัดการ error
   } else {
-    // script loaded successfully
+    // script โหลดสำเร็จ
   }
 });
 ```
 
-Once again, the recipe that we used for `loadScript` is actually quite common. It's called the "error-first callback" style.
+pattern นี้ใช้กันบ่อยมากจนมีชื่อเรียกว่า "error-first callback"
 
-The convention is:
-1. The first argument of the `callback` is reserved for an error if it occurs. Then `callback(err)` is called.
-2. The second argument (and the next ones if needed) are for the successful result. Then `callback(null, result1, result2…)` is called.
+กฎก็คือ:
+1. อาร์กิวเมนต์ตัวแรกของ `callback` สงวนไว้สำหรับ error — ถ้ามีปัญหาก็เรียก `callback(err)`
+2. อาร์กิวเมนต์ตัวที่สอง (และตัวถัดๆ ไปถ้ามี) ไว้สำหรับผลลัพธ์เมื่อสำเร็จ — เรียก `callback(null, result1, result2…)`
 
-So the single `callback` function is used both for reporting errors and passing back results.
+`callback` ตัวเดียวเลยทำหน้าที่ได้ทั้งรายงาน error และส่งผลลัพธ์กลับ
 
 ## Pyramid of Doom
 
-At first glance, it looks like a viable approach to asynchronous coding. And indeed it is. For one or maybe two nested calls it looks fine.
+มองแวบแรก callback-based style ดูเป็นแนวทางที่ใช้ได้ — และก็ใช้ได้จริงถ้ามีแค่ 1-2 ชั้น
 
-But for multiple asynchronous actions that follow one after another, we'll have code like this:
+แต่พอมี async action หลายอันต่อกัน โค้ดจะหน้าตาแบบนี้:
 
 ```js
 loadScript('1.js', function(error, script) {
@@ -219,7 +218,7 @@ loadScript('1.js', function(error, script) {
             handleError(error);
           } else {
   *!*
-            // ...continue after all scripts are loaded (*)
+            // ...ทำต่อหลังจากทุก script โหลดเสร็จ (*)
   */!*
           }
         });
@@ -230,14 +229,14 @@ loadScript('1.js', function(error, script) {
 });
 ```
 
-In the code above:
-1. We load `1.js`, then if there's no error...
-2. We load `2.js`, then if there's no error...
-3. We load `3.js`, then if there's no error -- do something else `(*)`.
+ไล่ดูโค้ดข้างบน:
+1. โหลด `1.js` ถ้าไม่มี error...
+2. โหลด `2.js` ถ้าไม่มี error...
+3. โหลด `3.js` ถ้าไม่มี error — ค่อยทำอย่างอื่น `(*)`
 
-As calls become more nested, the code becomes deeper and increasingly more difficult to manage, especially if we have real code instead of `...` that may include more loops, conditional statements and so on.
+ยิ่ง callback ซ้อนกันเยอะ โค้ดก็ยิ่งลึกและจัดการยาก โดยเฉพาะถ้าแทน `...` ด้วยโค้ดจริงๆ ที่มีทั้ง loop, if/else ต่างๆ
 
-That's sometimes called "callback hell" or "pyramid of doom."
+นี่แหละที่เรียกว่า "callback hell" หรือ "pyramid of doom"
 
 <!--
 loadScript('1.js', function(error, script) {
@@ -265,11 +264,11 @@ loadScript('1.js', function(error, script) {
 
 ![](callback-hell.svg)
 
-The "pyramid" of nested calls grows to the right with every asynchronous action. Soon it spirals out of control.
+"พีระมิด" ของ callback ที่ซ้อนกันจะขยายออกทางขวาเรื่อยๆ ทุกครั้งที่มี async action เพิ่ม — ไม่นานก็เอาไม่อยู่
 
-So this way of coding isn't very good.
+วิธีนี้เลยไม่ดีนัก
 
-We can try to alleviate the problem by making every action a standalone function, like this:
+เราพอแก้ได้นิดหน่อยด้วยการแยกแต่ละ action ออกเป็นฟังก์ชัน top-level แบบนี้:
 
 ```js
 loadScript('1.js', step1);
@@ -296,17 +295,17 @@ function step3(error, script) {
   if (error) {
     handleError(error);
   } else {
-    // ...continue after all scripts are loaded (*)
+    // ...ทำต่อหลังจากทุก script โหลดเสร็จ (*)
   }
 }
 ```
 
-See? It does the same thing, and there's no deep nesting now because we made every action a separate top-level function.
+เห็นไหม? ทำได้เหมือนกัน และไม่ซ้อนลึกแล้ว เพราะแยกแต่ละ action เป็นฟังก์ชันของตัวเอง
 
-It works, but the code looks like a torn apart spreadsheet. It's difficult to read, and you probably noticed that one needs to eye-jump between pieces while reading it. That's inconvenient, especially if the reader is not familiar with the code and doesn't know where to eye-jump.
+แต่ก็มีปัญหา — โค้ดมันดูเหมือน spreadsheet ที่ถูกฉีกทิ้ง อ่านยาก ตาต้องกระโดดไปมาระหว่างฟังก์ชัน ยิ่งถ้าคนอ่านไม่คุ้นกับโค้ดนี้มาก่อน ยิ่งงงหนัก
 
-Also, the functions named `step*` are all of single use, they are created only to avoid the "pyramid of doom." No one is going to reuse them outside of the action chain. So there's a bit of namespace cluttering here.
+แถมฟังก์ชัน `step*` พวกนี้ใช้ครั้งเดียวทิ้ง สร้างขึ้นมาเพื่อหนี "pyramid of doom" โดยเฉพาะ ไม่มีใครเอาไปใช้ที่อื่นอีก — namespace ก็เลยรก
 
-We'd like to have something better.
+เราอยากได้วิธีที่ดีกว่านี้
 
-Luckily, there are other ways to avoid such pyramids. One of the best ways is to use "promises", described in the next chapter.
+โชคดีที่มีทางเลือกอื่น วิธีที่ดีที่สุดวิธีหนึ่งคือการใช้ promise ซึ่งจะพูดถึงในบทถัดไป
diff --git a/1-js/11-async/02-promise-basics/01-re-resolve/solution.md b/1-js/11-async/02-promise-basics/01-re-resolve/solution.md
index 57046a257..8d01f17b6 100644
--- a/1-js/11-async/02-promise-basics/01-re-resolve/solution.md
+++ b/1-js/11-async/02-promise-basics/01-re-resolve/solution.md
@@ -1,3 +1,3 @@
-The output is: `1`.
+ผลลัพธ์คือ `1`
 
-The second call to `resolve` is ignored, because only the first call of `reject/resolve` is taken into account. Further calls are ignored.
+การเรียก `resolve` ครั้งที่สองถูกเพิกเฉย เพราะจะนับแค่การเรียก `reject/resolve` ครั้งแรกเท่านั้น การเรียกครั้งต่อๆ ไปจะถูกเพิกเฉยทั้งหมด
diff --git a/1-js/11-async/02-promise-basics/01-re-resolve/task.md b/1-js/11-async/02-promise-basics/01-re-resolve/task.md
index 185806ed6..526ea270c 100644
--- a/1-js/11-async/02-promise-basics/01-re-resolve/task.md
+++ b/1-js/11-async/02-promise-basics/01-re-resolve/task.md
@@ -2,7 +2,7 @@
 # Re-resolve a promise?
 
 
-What's the output of the code below? 
+ผลลัพธ์ของโค้ดด้านล่างคืออะไร?
 
 ```js
 let promise = new Promise(function(resolve, reject) {
diff --git a/1-js/11-async/02-promise-basics/02-delay-promise/solution.md b/1-js/11-async/02-promise-basics/02-delay-promise/solution.md
index 85e8baa44..3ae00f023 100644
--- a/1-js/11-async/02-promise-basics/02-delay-promise/solution.md
+++ b/1-js/11-async/02-promise-basics/02-delay-promise/solution.md
@@ -3,7 +3,7 @@ function delay(ms) {
   return new Promise(resolve => setTimeout(resolve, ms));
 }
 
-delay(3000).then(() => alert('runs after 3 seconds'));
+delay(3000).then(() => alert('รันหลัง 3 วินาที'));
 ```
 
-Please note that in this task `resolve` is called without arguments. We don't return any value from `delay`, just ensure the delay.
+สังเกตว่าในโจทย์นี้ `resolve` ถูกเรียกโดยไม่มีอาร์กิวเมนต์ เราไม่ได้คืนค่าอะไรจาก `delay` แค่แน่ใจว่ามีการหน่วงเวลาก็พอ
diff --git a/1-js/11-async/02-promise-basics/02-delay-promise/task.md b/1-js/11-async/02-promise-basics/02-delay-promise/task.md
index 0d74cf45d..aa146cccd 100644
--- a/1-js/11-async/02-promise-basics/02-delay-promise/task.md
+++ b/1-js/11-async/02-promise-basics/02-delay-promise/task.md
@@ -1,14 +1,14 @@
 
-# Delay with a promise
+# หน่วงเวลาด้วย promise
 
-The built-in function `setTimeout` uses callbacks. Create a promise-based alternative.
+ฟังก์ชัน `setTimeout` ในตัวใช้ callback ลองสร้างอีกแบบที่ใช้ promise แทน
 
-The function `delay(ms)` should return a promise. That promise should resolve after `ms` milliseconds, so that we can add `.then` to it, like this:
+ฟังก์ชัน `delay(ms)` ควรคืน promise โดย promise นั้นจะ resolve หลังจากผ่านไป `ms` มิลลิวินาที เพื่อให้เราต่อ `.then` ได้ แบบนี้:
 
 ```js
 function delay(ms) {
-  // your code
+  // โค้ดของเรา
 }
 
-delay(3000).then(() => alert('runs after 3 seconds'));
+delay(3000).then(() => alert('รันหลัง 3 วินาที'));
 ```
diff --git a/1-js/11-async/02-promise-basics/03-animate-circle-promise/solution.view/index.html b/1-js/11-async/02-promise-basics/03-animate-circle-promise/solution.view/index.html
index 6052f009e..030a79f43 100644
--- a/1-js/11-async/02-promise-basics/03-animate-circle-promise/solution.view/index.html
+++ b/1-js/11-async/02-promise-basics/03-animate-circle-promise/solution.view/index.html
@@ -22,7 +22,7 @@
 
 <body>
 
-  <button onclick="go()">Click me</button>
+  <button onclick="go()">คลิกที่นี่</button>
 
   <script>
 
diff --git a/1-js/11-async/02-promise-basics/03-animate-circle-promise/task.md b/1-js/11-async/02-promise-basics/03-animate-circle-promise/task.md
index 7860a71dc..9913ee0ba 100644
--- a/1-js/11-async/02-promise-basics/03-animate-circle-promise/task.md
+++ b/1-js/11-async/02-promise-basics/03-animate-circle-promise/task.md
@@ -1,9 +1,9 @@
 
-# Animated circle with promise
+# วงกลมเคลื่อนไหวด้วย promise
 
-Rewrite the `showCircle` function in the solution of the task <info:task/animate-circle-callback> so that it returns a promise instead of accepting a callback.
+เขียนฟังก์ชัน `showCircle` ใน solution ของโจทย์ <info:task/animate-circle-callback> ใหม่ โดยให้คืน promise แทนที่จะรับ callback
 
-The new usage:
+การใช้งานแบบใหม่:
 
 ```js
 showCircle(150, 150, 100).then(div => {
@@ -12,4 +12,4 @@ showCircle(150, 150, 100).then(div => {
 });
 ```
 
-Take the solution of the task <info:task/animate-circle-callback> as the base.
+ให้เอา solution ของโจทย์ <info:task/animate-circle-callback> เป็นฐาน
diff --git a/1-js/11-async/02-promise-basics/article.md b/1-js/11-async/02-promise-basics/article.md
index 66d9538fc..1775a1976 100644
--- a/1-js/11-async/02-promise-basics/article.md
+++ b/1-js/11-async/02-promise-basics/article.md
@@ -1,92 +1,96 @@
 # Promise
 
-Imagine that you're a top singer, and fans ask day and night for your upcoming song.
+สมมติว่าเราเป็นนักร้องชื่อดัง แล้วแฟนๆ ทวงเพลงใหม่กันทั้งวันทั้งคืน
 
-To get some relief, you promise to send it to them when it's published. You give your fans a list. They can fill in their email addresses, so that when the song becomes available, all subscribed parties instantly receive it. And even if something goes very wrong, say, a fire in the studio, so that you can't publish the song, they will still be notified.
+แทนที่จะให้ทุกคนมารุมถามตลอด เราบอกว่า "ได้เลย พอเพลงออก จะส่งให้ทันที" แล้วแจกฟอร์มให้แฟนๆ กรอกอีเมลไว้ พอเพลงพร้อม — ทุกคนที่ลงชื่อจะได้รับพร้อมกัน
 
-Everyone is happy: you, because the people don't crowd you anymore, and fans, because they won't miss the song.
+ถ้าเกิดเหตุสุดวิสัยอย่างไฟไหม้สตูดิโอจนออกเพลงไม่ได้ ก็จะแจ้งให้รู้เช่นกัน
 
-This is a real-life analogy for things we often have in programming:
+ทุกคนพอใจ — แฟนๆ ไม่พลาดเพลง เราก็ไม่โดนรุมถาม
 
-1. A "producing code" that does something and takes time. For instance, some code that loads the data over a network. That's a "singer".
-2. A "consuming code" that wants the result of the "producing code" once it's ready. Many functions  may need that result. These are the "fans".
-3. A *promise* is a special JavaScript object that links the "producing code" and the "consuming code" together. In terms of our analogy: this is the "subscription list". The "producing code" takes whatever time it needs to produce the promised result, and the "promise" makes that result available to all of the subscribed code when it's ready.
+เรื่องนี้คล้ายกับสิ่งที่เราเจอบ่อยในโปรแกรมมิ่ง:
 
-The analogy isn't terribly accurate, because JavaScript promises are more complex than a simple subscription list: they have additional features and limitations. But it's fine to begin with.
+1. **"producing code"** คือโค้ดที่ทำงานบางอย่างและใช้เวลา เช่น โหลดข้อมูลจากเน็ต — นั่นคือ "นักร้อง"
+2. **"consuming code"** คือโค้ดที่ต้องการผลลัพธ์จาก producing code ตอนที่พร้อมแล้ว จะมีหลายฟังก์ชันก็ได้ที่รออยู่ — นั่นคือ "แฟนๆ"
+3. ***promise*** คือออบเจ็กต์ JavaScript พิเศษที่เชื่อม producing code กับ consuming code เข้าหากัน — นั่นคือ "รายชื่อผู้ติดตาม" นั่นเอง
 
-The constructor syntax for a promise object is:
+    producing code ใช้เวลาเท่าไรก็ได้เพื่อทำงานให้เสร็จ แล้ว promise จะส่งผลลัพธ์ไปให้ทุกโค้ดที่รออยู่พร้อมกัน
+
+การเปรียบเทียบนี้ไม่ได้ตรงแบบ 100% เพราะ promise ใน JavaScript ทำได้มากกว่าแค่รายชื่อผู้ติดตาม แต่ใช้เป็นภาพตั้งต้นก็พอ
+
+เขียน promise แบบนี้:
 
 ```js
 let promise = new Promise(function(resolve, reject) {
-  // executor (the producing code, "singer")
+  // executor (producing code, "นักร้อง")
 });
 ```
 
-The function passed to `new Promise` is called the *executor*. When `new Promise` is created, the executor runs automatically. It contains the producing code which should eventually produce the result. In terms of the analogy above: the executor is the "singer".
+ฟังก์ชันที่ส่งให้ `new Promise` เรียกว่า *executor* พอสร้าง `new Promise` ขึ้นมา executor จะรันทันทีเลย — มันคือโค้ดที่จะทำงานจนได้ผลลัพธ์ออกมา เปรียบได้กับ "นักร้อง" นั่นเอง
 
-Its arguments `resolve` and `reject` are callbacks provided by JavaScript itself. Our code is only inside the executor.
+พารามิเตอร์ `resolve` และ `reject` คือคอลแบ็กที่ JavaScript เตรียมให้เราเอง เราไม่ต้องสร้างเอง แค่เรียกใช้
 
-When the executor obtains the result, be it soon or late, doesn't matter, it should call one of these callbacks:
+พอ executor ทำงานเสร็จ ไม่ว่าจะเร็วหรือช้า ให้เรียกอันใดอันหนึ่ง:
 
-- `resolve(value)` — if the job is finished successfully, with result `value`.
-- `reject(error)` — if an error has occurred, `error` is the error object.
+- `resolve(value)` — ถ้าทำสำเร็จ โดย `value` คือผลลัพธ์
+- `reject(error)` — ถ้าเกิด error โดย `error` คือออบเจ็กต์ error
 
-So to summarize: the executor runs automatically and attempts to perform a job. When it is finished with the attempt, it calls `resolve` if it was successful or `reject` if there was an error.
+สรุปง่ายๆ คือ executor รันอัตโนมัติแล้วพยายามทำงาน พอเสร็จก็เรียก `resolve` ถ้าสำเร็จ หรือ `reject` ถ้าพัง
 
-The `promise` object returned by the `new Promise` constructor has these internal properties:
+ออบเจ็กต์ `promise` ที่ได้จาก `new Promise` มีพร็อพเพอร์ตี้ภายในดังนี้:
 
-- `state` — initially `"pending"`, then changes to either `"fulfilled"` when `resolve` is called or `"rejected"` when `reject` is called.
-- `result` — initially `undefined`, then changes to `value` when `resolve(value)` is called or `error` when `reject(error)` is called.
+- `state` — เริ่มต้นเป็น `"pending"` จากนั้นเปลี่ยนเป็น `"fulfilled"` เมื่อเรียก `resolve` หรือ `"rejected"` เมื่อเรียก `reject`
+- `result` — เริ่มต้นเป็น `undefined` จากนั้นเปลี่ยนเป็น `value` เมื่อเรียก `resolve(value)` หรือ `error` เมื่อเรียก `reject(error)`
 
-So the executor eventually moves `promise` to one of these states:
+executor จะพา promise ไปสู่สถานะใดสถานะหนึ่งในที่สุด:
 
 ![](promise-resolve-reject.svg)
 
-Later we'll see how "fans" can subscribe to these changes.
+แฟนๆ จะ subscribe การเปลี่ยนแปลงพวกนี้ยังไงล่ะ? เดี๋ยวดูกัน
 
-Here's an example of a promise constructor and a simple executor function with  "producing code" that takes time (via `setTimeout`):
+ลองดูตัวอย่าง promise ที่มี producing code ซึ่งใช้เวลา (ผ่าน `setTimeout`):
 
 ```js
 let promise = new Promise(function(resolve, reject) {
-  // the function is executed automatically when the promise is constructed
+  // ฟังก์ชันนี้รันอัตโนมัติตอนสร้าง promise
 
-  // after 1 second signal that the job is done with the result "done"
+  // หลัง 1 วินาที แจ้งว่าทำเสร็จแล้ว พร้อมผลลัพธ์ "done"
   setTimeout(() => *!*resolve("done")*/!*, 1000);
 });
 ```
 
-We can see two things by running the code above:
+รันโค้ดด้านบนแล้วจะเห็น 2 อย่าง:
 
-1. The executor is called automatically and immediately (by `new Promise`).
-2. The executor receives two arguments: `resolve` and `reject`. These functions are pre-defined by the JavaScript engine, so we don't need to create them. We should only call one of them when ready.
+1. `new Promise` เรียก executor ทันทีโดยอัตโนมัติ
+2. executor ได้รับ 2 อาร์กิวเมนต์ คือ `resolve` และ `reject` ซึ่ง JavaScript engine เตรียมไว้ให้แล้ว ไม่ต้องสร้างเอง แค่เรียกอันใดอันหนึ่งตอนพร้อม
 
-    After one second of "processing", the executor calls `resolve("done")` to produce the result. This changes the state of the `promise` object:
+    หลัง "ประมวลผล" ไป 1 วินาที executor เรียก `resolve("done")` เพื่อส่งผลลัพธ์ สถานะของ `promise` เปลี่ยนเป็น:
 
     ![](promise-resolve-1.svg)
 
-That was an example of a successful job completion, a "fulfilled promise".
+นั่นคือตัวอย่างที่ทำสำเร็จ — "fulfilled promise"
 
-And now an example of the executor rejecting the promise with an error:
+ทีนี้ดูตัวอย่างที่ executor reject promise ด้วย error:
 
 ```js
 let promise = new Promise(function(resolve, reject) {
-  // after 1 second signal that the job is finished with an error
+  // หลัง 1 วินาที แจ้งว่าเกิด error
   setTimeout(() => *!*reject(new Error("Whoops!"))*/!*, 1000);
 });
 ```
 
-The call to `reject(...)` moves the promise object to `"rejected"` state:
+การเรียก `reject(...)` จะพา promise ไปสู่สถานะ `"rejected"`:
 
 ![](promise-reject-1.svg)
 
-To summarize, the executor should perform a job (usually something that takes time) and then call `resolve` or `reject` to change the state of the corresponding promise object.
+สรุปแล้ว executor ทำงานบางอย่าง (มักใช้เวลา) จากนั้นเรียก `resolve` หรือ `reject` เพื่อเปลี่ยนสถานะของ promise
 
-A promise that is either resolved or rejected is called "settled", as opposed to an initially "pending" promise.
+promise ที่ resolve หรือ reject ไปแล้วเรียกว่า "settled" — ต่างจากตอนแรกที่ยัง "pending" อยู่
 
-````smart header="There can be only a single result or an error"
-The executor should call only one `resolve` or one `reject`. Any state change is final.
+````smart header="ได้แค่ผลลัพธ์เดียวหรือ error เดียวเท่านั้น"
+executor ควรเรียก `resolve` หรือ `reject` แค่ครั้งเดียว การเปลี่ยนสถานะจะเกิดขึ้นครั้งเดียวแล้วจบ
 
-All further calls of `resolve` and `reject` are ignored:
+การเรียก `resolve` และ `reject` ครั้งต่อๆ ไปจะถูกเพิกเฉย:
 
 ```js
 let promise = new Promise(function(resolve, reject) {
@@ -94,95 +98,97 @@ let promise = new Promise(function(resolve, reject) {
   resolve("done");
 */!*
 
-  reject(new Error("…")); // ignored
-  setTimeout(() => resolve("…")); // ignored
+  reject(new Error("…")); // ถูกเพิกเฉย
+  setTimeout(() => resolve("…")); // ถูกเพิกเฉย
 });
 ```
 
-The idea is that a job done by the executor may have only one result or an error.
+ก็เพราะงานที่ executor ทำนั้นมีได้แค่ผลลัพธ์เดียวหรือ error เดียวเท่านั้น
 
-Also, `resolve`/`reject` expect only one argument (or none) and will ignore additional arguments.
+แถม `resolve`/`reject` รับแค่อาร์กิวเมนต์เดียว (หรือไม่รับเลยก็ได้) อาร์กิวเมนต์เพิ่มเติมจะถูกเพิกเฉย
 ````
 
-```smart header="Reject with `Error` objects"
-In case something goes wrong, the executor should call `reject`. That can be done with any type of argument (just like `resolve`). But it is recommended to use `Error` objects (or objects that inherit from `Error`). The reasoning for that will soon become apparent.
+```smart header="Reject ด้วย Error objects"
+ถ้าเกิดอะไรผิดพลาด executor ควรเรียก `reject` โดยส่งอาร์กิวเมนต์ประเภทไหนก็ได้ (เหมือนกับ `resolve`) แต่แนะนำให้ใช้ออบเจ็กต์ `Error` (หรือออบเจ็กต์ที่ inherit จาก `Error`) เหตุผลจะชัดขึ้นในภายหลัง
 ```
 
-````smart header="Immediately calling `resolve`/`reject`"
-In practice, an executor usually does something asynchronously and calls `resolve`/`reject` after some time, but it doesn't have to. We also can call `resolve` or `reject` immediately, like this:
+````smart header="เรียก `resolve`/`reject` ได้ทันทีเลย"
+จริงๆ แล้ว executor มักทำงาน asynchronous แล้วค่อยเรียก `resolve`/`reject` ทีหลัง แต่ก็ไม่จำเป็นต้องรอ เรียกทันทีเลยก็ได้ แบบนี้:
 
 ```js
 let promise = new Promise(function(resolve, reject) {
-  // not taking our time to do the job
-  resolve(123); // immediately give the result: 123
+  // ไม่รอเลย resolve ทันที
+  resolve(123); // ส่งผลลัพธ์ทันที: 123
 });
 ```
 
-For instance, this might happen when we start to do a job but then see that everything has already been completed and cached.
+เช่น กรณีที่เริ่มทำงานแล้วพบว่าทุกอย่าง cache ไว้แล้ว resolve ทันทีก็ได้เลย
 
-That's fine. We immediately have a resolved promise.
+promise ก็จะ resolved ทันที
 ````
 
-```smart header="The `state` and `result` are internal"
-The properties `state` and `result` of the Promise object are internal. We can't directly access them. We can use the methods `.then`/`.catch`/`.finally` for that. They are described below.
+```smart header="`state` และ `result` เป็นพร็อพเพอร์ตี้ภายใน"
+พร็อพเพอร์ตี้ `state` และ `result` ของออบเจ็กต์ Promise เป็นพร็อพเพอร์ตี้ภายใน เข้าถึงตรงๆ ไม่ได้ ต้องใช้เมธอด `.then`/`.catch`/`.finally` แทน ซึ่งจะอธิบายด้านล่าง
 ```
 
 ## Consumers: then, catch
 
-A Promise object serves as a link between the executor (the "producing code" or "singer") and the consuming functions (the "fans"), which will receive the result or error. Consuming functions can be registered (subscribed) using the methods `.then` and `.catch`.
+ทำงานเสร็จแล้ว — แฟนๆ รับผลได้ยังไง?
+
+ฟังก์ชันที่รอรับผลลัพธ์หรือ error เรียกว่า consuming functions ลงทะเบียน (subscribe) ผ่านเมธอด `.then` และ `.catch` ได้เลย
 
 ### then
 
-The most important, fundamental one is `.then`.
+`.then` คือเมธอดที่สำคัญที่สุด
 
-The syntax is:
+เขียนแบบนี้:
 
 ```js
 promise.then(
-  function(result) { *!*/* handle a successful result */*/!* },
-  function(error) { *!*/* handle an error */*/!* }
+  function(result) { *!*/* จัดการกรณีสำเร็จ */*/!* },
+  function(error) { *!*/* จัดการกรณี error */*/!* }
 );
 ```
 
-The first argument of `.then` is a function that runs when the promise is resolved and receives the result.
+อาร์กิวเมนต์แรกของ `.then` คือฟังก์ชันที่รันเมื่อ promise resolved และรับผลลัพธ์มา
 
-The second argument of `.then` is a function that runs when the promise is rejected and receives the error.
+อาร์กิวเมนต์ที่สองคือฟังก์ชันที่รันเมื่อ promise rejected และรับ error มา
 
-For instance, here's a reaction to a successfully resolved promise:
+ตัวอย่างเมื่อ promise resolved สำเร็จ:
 
 ```js run
 let promise = new Promise(function(resolve, reject) {
   setTimeout(() => resolve("done!"), 1000);
 });
 
-// resolve runs the first function in .then
+// resolve จะรันฟังก์ชันแรกใน .then
 promise.then(
 *!*
-  result => alert(result), // shows "done!" after 1 second
+  result => alert(result), // แสดง "done!" หลัง 1 วินาที
 */!*
-  error => alert(error) // doesn't run
+  error => alert(error) // ไม่รัน
 );
 ```
 
-The first function was executed.
+ฟังก์ชันแรกทำงาน
 
-And in the case of a rejection, the second one:
+ส่วนกรณี rejection จะรันฟังก์ชันที่สอง:
 
 ```js run
 let promise = new Promise(function(resolve, reject) {
   setTimeout(() => reject(new Error("Whoops!")), 1000);
 });
 
-// reject runs the second function in .then
+// reject จะรันฟังก์ชันที่สองใน .then
 promise.then(
-  result => alert(result), // doesn't run
+  result => alert(result), // ไม่รัน
 *!*
-  error => alert(error) // shows "Error: Whoops!" after 1 second
+  error => alert(error) // แสดง "Error: Whoops!" หลัง 1 วินาที
 */!*
 );
 ```
 
-If we're interested only in successful completions, then we can provide only one function argument to `.then`:
+ถ้าสนใจแค่กรณีสำเร็จ ส่งแค่ฟังก์ชันเดียวเป็นอาร์กิวเมนต์ได้เลย:
 
 ```js run
 let promise = new Promise(resolve => {
@@ -190,13 +196,13 @@ let promise = new Promise(resolve => {
 });
 
 *!*
-promise.then(alert); // shows "done!" after 1 second
+promise.then(alert); // แสดง "done!" หลัง 1 วินาที
 */!*
 ```
 
 ### catch
 
-If we're interested only in errors, then we can use `null` as the first argument: `.then(null, errorHandlingFunction)`. Or we can use `.catch(errorHandlingFunction)`, which is exactly the same:
+ถ้าสนใจแค่ error อย่างเดียว ใช้ `null` เป็นอาร์กิวเมนต์แรกได้: `.then(null, errorHandlingFunction)` หรือจะใช้ `.catch(errorHandlingFunction)` ก็เหมือนกัน:
 
 
 ```js run
@@ -205,110 +211,106 @@ let promise = new Promise((resolve, reject) => {
 });
 
 *!*
-// .catch(f) is the same as promise.then(null, f)
-promise.catch(alert); // shows "Error: Whoops!" after 1 second
+// .catch(f) เหมือนกับ promise.then(null, f)
+promise.catch(alert); // แสดง "Error: Whoops!" หลัง 1 วินาที
 */!*
 ```
 
-The call `.catch(f)` is a complete analog of `.then(null, f)`, it's just a shorthand.
+`.catch(f)` เป็นแค่ shorthand ของ `.then(null, f)` นั่นเอง
 
 ## Cleanup: finally
 
-Just like there's a `finally` clause in a regular `try {...} catch {...}`, there's `finally` in promises.
+เหมือนกับที่มี `finally` ใน `try {...} catch {...}` promise ก็มี `finally` เช่นกัน
 
-The call `.finally(f)` is similar to `.then(f, f)` in the sense that `f` runs always, when the promise is settled: be it resolve or reject.
+`.finally(f)` คล้ายกับ `.then(f, f)` ตรงที่ `f` จะรันเสมอ ไม่ว่า promise จะ settled แบบ resolve หรือ reject
 
-The idea of `finally` is to set up a handler for performing cleanup/finalizing after the previous operations are complete.
+ไว้ใช้ทำ cleanup หลังจากงานเสร็จ ไม่ว่าจะสำเร็จหรือพัง
 
-E.g. stopping loading indicators, closing no longer needed connections, etc.
+ตัวอย่างเช่น — หยุด loading indicator ปิด connection ที่ไม่ใช้แล้ว ฯลฯ
 
-Think of it as a party finisher. Irresepective of whether a party was good or bad, how many friends were in it, we still need (or at least should) do a cleanup after it.
+นึกภาพว่าเหมือนคนที่มาเก็บงานปาร์ตี้ ไม่ว่าปาร์ตี้จะสนุกหรือเงียบเหงาแค่ไหน ก็ต้องเก็บกวาดทุกครั้ง
 
-The code may look like this:
+โค้ดหน้าตาแบบนี้:
 
 ```js
 new Promise((resolve, reject) => {
-  /* do something that takes time, and then call resolve or maybe reject */
+  /* ทำงานบางอย่างที่ใช้เวลา แล้วเรียก resolve หรือ reject */
 })
 *!*
-  // runs when the promise is settled, doesn't matter successfully or not
-  .finally(() => stop loading indicator)
-  // so the loading indicator is always stopped before we go on
+  // รันเมื่อ promise settled ไม่สนว่าสำเร็จหรือพัง
+  .finally(() => หยุด loading indicator)
+  // loading indicator จะหยุดก่อนเสมอ แล้วค่อยไปต่อ
 */!*
-  .then(result => show result, err => show error)
+  .then(result => แสดงผลลัพธ์, err => แสดง error)
 ```
 
-Please note that `finally(f)` isn't exactly an alias of `then(f,f)` though.
+แต่ `finally(f)` ไม่ได้เหมือน `then(f,f)` ซะทีเดียว มีข้อแตกต่างสำคัญ:
 
-There are important differences:
+1. `finally` handler ไม่รับอาร์กิวเมนต์ เพราะตอนที่อยู่ใน `finally` เราไม่รู้ว่า promise สำเร็จหรือพัง ก็โอเค เพราะงานของ `finally` คือทำ "cleanup ทั่วไป"
 
-1. A `finally` handler has no arguments. In `finally` we don't know whether the promise is successful or not. That's all right, as our task is usually to perform "general" finalizing procedures.
+    ดูตัวอย่างด้านบน จะเห็นว่า `finally` handler ไม่มีอาร์กิวเมนต์ และผลลัพธ์ของ promise จะผ่านไปถึง handler ตัวถัดไปเอง
+2. `finally` handler "ส่งต่อ" ผลลัพธ์หรือ error ไปให้ handler ตัวถัดไปที่เหมาะสม
 
-    Please take a look at the example above: as you can see, the `finally` handler has no arguments, and the promise outcome is handled by the next handler.
-2. A `finally` handler "passes through" the result or error to the next suitable handler.
-
-    For instance, here the result is passed through `finally` to `then`:
+    เช่น ผลลัพธ์จะผ่าน `finally` ไปถึง `then` โดยตรง:
 
     ```js run
     new Promise((resolve, reject) => {
       setTimeout(() => resolve("value"), 2000);
     })
-      .finally(() => alert("Promise ready")) // triggers first
-      .then(result => alert(result)); // <-- .then shows "value"
+      .finally(() => alert("Promise ready")) // รันก่อน
+      .then(result => alert(result)); // <-- .then แสดง "value"
     ```
 
-    As you can see, the `value` returned by the first promise is passed through `finally` to the next `then`.
+    จะเห็นว่า `value` จาก promise แรกผ่าน `finally` ไปถึง `then` ได้เลย
 
-    That's very convenient, because `finally` is not meant to process a promise result. As said, it's a place to do generic cleanup, no matter what the outcome was.
+    สะดวกมาก เพราะ `finally` ไม่ได้ไว้ประมวลผลลัพธ์ของ promise อยู่แล้ว — เป็นที่สำหรับ cleanup ทั่วๆ ไป ไม่ว่าผลจะออกมายังไง
 
-    And here's an example of an error, for us to see how it's passed through `finally` to `catch`:
+    ตัวอย่าง error ที่ผ่าน `finally` ไปถึง `catch`:
 
     ```js run
     new Promise((resolve, reject) => {
       throw new Error("error");
     })
-      .finally(() => alert("Promise ready")) // triggers first
-      .catch(err => alert(err));  // <-- .catch shows the error
+      .finally(() => alert("Promise ready")) // รันก่อน
+      .catch(err => alert(err));  // <-- .catch แสดง error
     ```
 
-3. A `finally` handler also shouldn't return anything. If it does, the returned value is silently ignored.
+3. `finally` handler ไม่ควร return อะไร ถ้า return ค่าที่ return ออกมาจะถูกเพิกเฉยเงียบๆ
 
-    The only exception to this rule is when a `finally` handler throws an error. Then this error goes to the next handler, instead of any previous outcome.
+    ยกเว้นกรณีเดียวคือถ้า `finally` handler throw error — error นั้นจะส่งต่อไปให้ handler ถัดไปแทน
 
-To summarize:
+สรุป:
 
-- A `finally` handler doesn't get the outcome of the previous handler (it has no arguments). This outcome is passed through instead, to the next suitable handler.
-- If a `finally` handler returns something, it's ignored.
-- When `finally` throws an error, then the execution goes to the nearest error handler.
+- `finally` handler ไม่รับผลลัพธ์จาก handler ก่อนหน้า (ไม่มีอาร์กิวเมนต์) แต่ผลลัพธ์นั้นจะผ่านไปถึง handler ที่เหมาะสมตัวถัดไปเอง
+- ถ้า `finally` return อะไร ค่านั้นจะถูกเพิกเฉย
+- ถ้า `finally` throw error จะไปถึง error handler ที่ใกล้ที่สุด
 
-These features are helpful and make things work just the right way if we use `finally` how it's supposed to be used: for generic cleanup procedures.
+พอใช้ `finally` ตามวัตถุประสงค์ — คือ cleanup ทั่วไป — ฟีเจอร์พวกนี้ก็จะเข้ากันได้พอดีเลย
 
-````smart header="We can attach handlers to settled promises"
-If a promise is pending, `.then/catch/finally` handlers wait for its outcome.
+````smart header="ใส่ handler กับ settled promise ได้"
+ถ้า promise ยัง pending อยู่ handler ของ `.then/catch/finally` จะรอจนกว่าผลลัพธ์จะออกมา
 
-Sometimes, it might be that a promise is already settled when we add a handler to it.
+แต่บางครั้ง promise อาจ settled แล้วตอนที่เราใส่ handler เข้าไป
 
-In such case, these handlers just run immediately:
+ในกรณีนั้น handler จะรันทันทีเลย:
 
 ```js run
-// the promise becomes resolved immediately upon creation
+// promise resolved ทันทีตอนสร้าง
 let promise = new Promise(resolve => resolve("done!"));
 
-promise.then(alert); // done! (shows up right now)
+promise.then(alert); // done! (แสดงทันที)
 ```
 
-Note that this makes promises more powerful than the real life "subscription list" scenario. If the singer has already released their song and then a person signs up on the subscription list, they probably won't receive that song. Subscriptions in real life must be done prior to the event.
-
-Promises are more flexible. We can add handlers any time: if the result is already there, they just execute.
+ต่างจากชีวิตจริงที่ถ้านักร้อง release เพลงไปแล้วแล้วมีคนมาสมัครหลัง ก็คงไม่ได้รับเพลงนั้น แต่ promise ยืดหยุ่นกว่า — ใส่ handler เมื่อไรก็ได้ ถ้าผลลัพธ์มีแล้ว handler จะรันทันที
 ````
 
-## Example: loadScript [#loadscript]
+## ตัวอย่าง: loadScript [#loadscript]
 
-Next, let's see more practical examples of how promises can help us write asynchronous code.
+มาดูตัวอย่างจริงๆ ว่า promise ช่วยเขียนโค้ด asynchronous ได้ยังไง
 
-We've got the `loadScript` function for loading a script from the previous chapter.
+เราใช้ฟังก์ชัน `loadScript` สำหรับโหลด script จากบทที่แล้ว
 
-Here's the callback-based variant, just to remind us of it:
+แบบเดิมที่ใช้ callback ดูอีกทีก่อน:
 
 ```js
 function loadScript(src, callback) {
@@ -322,9 +324,9 @@ function loadScript(src, callback) {
 }
 ```
 
-Let's rewrite it using Promises.
+ทีนี้เขียนใหม่ด้วย Promise:
 
-The new function `loadScript` will not require a callback. Instead, it will create and return a Promise object that resolves when the loading is complete. The outer code can add handlers (subscribing functions) to it using `.then`:
+ฟังก์ชัน `loadScript` แบบใหม่ไม่ต้องการ callback แล้ว แต่จะสร้างและคืน Promise object ที่ resolve เมื่อโหลดเสร็จ โค้ดภายนอกใส่ handler ผ่าน `.then` ได้เลย:
 
 ```js run
 function loadScript(src) {
@@ -340,7 +342,7 @@ function loadScript(src) {
 }
 ```
 
-Usage:
+การใช้งาน:
 
 ```js run
 let promise = loadScript("https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.11/lodash.js");
@@ -353,12 +355,11 @@ promise.then(
 promise.then(script => alert('Another handler...'));
 ```
 
-We can immediately see a few benefits over the callback-based pattern:
-
+เห็นข้อดีเมื่อเทียบกับแบบ callback ได้ชัดเลย:
 
-| Promises | Callbacks |
+| Promise | Callback |
 |----------|-----------|
-| Promises allow us to do things in the natural order. First, we run `loadScript(script)`, and `.then` we write what to do with the result. | We must have a `callback` function at our disposal when calling `loadScript(script, callback)`. In other words, we must know what to do with the result *before* `loadScript` is called. |
-| We can call `.then` on a Promise as many times as we want. Each time, we're adding a new "fan", a new subscribing function, to the "subscription list". More about this in the next chapter: [](info:promise-chaining). | There can be only one callback. |
+| Promise ให้เราทำตามลำดับที่เป็นธรรมชาติ — รัน `loadScript(script)` ก่อน แล้วค่อย `.then` บอกว่าจะทำอะไรกับผลลัพธ์ | ต้องมีฟังก์ชัน `callback` พร้อมก่อนเรียก `loadScript(script, callback)` พูดง่ายๆ คือต้องรู้ล่วงหน้าว่าจะทำอะไรกับผลลัพธ์ก่อนเรียกฟังก์ชัน |
+| เรียก `.then` บน Promise กี่ครั้งก็ได้ แต่ละครั้งก็เหมือนเพิ่ม "แฟน" คนใหม่เข้าใน "รายชื่อผู้ติดตาม" อ่านเพิ่มเติมใน <info:promise-chaining> | มี callback ได้แค่อันเดียว |
 
-So promises give us better code flow and flexibility. But there's more. We'll see that in the next chapters.
+Promise ให้ code flow ที่ดีกว่าและยืดหยุ่นกว่า ยังมีอีกมาก จะดูกันในบทต่อๆ ไป
diff --git a/1-js/11-async/03-promise-chaining/01-then-vs-catch/solution.md b/1-js/11-async/03-promise-chaining/01-then-vs-catch/solution.md
index bdd1c643b..50d791efc 100644
--- a/1-js/11-async/03-promise-chaining/01-then-vs-catch/solution.md
+++ b/1-js/11-async/03-promise-chaining/01-then-vs-catch/solution.md
@@ -1,6 +1,6 @@
-The short answer is: **no, they are not equal**:
+คำตอบสั้นๆ คือ: **ไม่เหมือนกัน**
 
-The difference is that if an error happens in `f1`, then it is handled by `.catch` here:
+ความต่างอยู่ที่ — ถ้า `f1` โยน error ออกมา `.catch` จะจัดการ error นั้นได้ในท่อนแรก:
 
 ```js run
 promise
@@ -8,13 +8,13 @@ promise
   .catch(f2);
 ```
 
-...But not here:
+...แต่ท่อนนี้ไม่ได้:
 
 ```js run
 promise
   .then(f1, f2);
 ```
 
-That's because an error is passed down the chain, and in the second code piece there's no chain below `f1`.
+เพราะ error จะถูกส่งต่อลงไปใน chain และในท่อนที่สองไม่มีอะไรต่อใต้ `f1` เลย
 
-In other words, `.then` passes results/errors to the next `.then/catch`. So in the first example, there's a `catch` below, and in the second one there isn't, so the error is unhandled.
+พูดง่ายๆ คือ `.then` ส่งทั้งผลลัพธ์และ error ต่อไปยัง `.then/.catch` ถัดไป ท่อนแรกมี `.catch` รออยู่ด้านล่าง เลยรับ error จาก `f1` ได้ แต่ท่อนที่สองไม่มี error เลยค้างไว้โดยไม่มีใครจัดการ
diff --git a/1-js/11-async/03-promise-chaining/01-then-vs-catch/task.md b/1-js/11-async/03-promise-chaining/01-then-vs-catch/task.md
index cefca60aa..eaa7b8dd5 100644
--- a/1-js/11-async/03-promise-chaining/01-then-vs-catch/task.md
+++ b/1-js/11-async/03-promise-chaining/01-then-vs-catch/task.md
@@ -1,12 +1,12 @@
-# Promise: then versus catch
+# Promise: then กับ catch ต่างกันไหม?
 
-Are these code fragments equal? In other words, do they behave the same way in any circumstances, for any handler functions?
+โค้ดสองท่อนนี้เหมือนกันไหม? พูดง่ายๆ คือในทุกสถานการณ์ ไม่ว่า handler จะเป็นอะไร ผลลัพธ์จะออกมาเหมือนกันเสมอไหม?
 
 ```js
 promise.then(f1).catch(f2);
 ```
 
-Versus:
+กับ:
 
 ```js
 promise.then(f1, f2);
diff --git a/1-js/11-async/03-promise-chaining/article.md b/1-js/11-async/03-promise-chaining/article.md
index a33ca258c..3fd641620 100644
--- a/1-js/11-async/03-promise-chaining/article.md
+++ b/1-js/11-async/03-promise-chaining/article.md
@@ -1,13 +1,13 @@
 
-# Promises chaining
+# Promise Chaining
 
-Let's return to the problem mentioned in the chapter <info:callbacks>: we have a sequence of asynchronous tasks to be performed one after another — for instance, loading scripts. How can we code it well?
+ย้อนกลับไปที่ปัญหาที่เราเจอใน <info:callbacks> กัน — ถ้าต้องรันงาน async หลายอย่างต่อกันเป็นลำดับ เช่น โหลด script ทีละไฟล์ เราจะจัดการยังไงให้โค้ดไม่พัง?
 
-Promises provide a couple of recipes to do that.
+promise มีท่าให้ใช้พอดี
 
-In this chapter we cover promise chaining.
+บทนี้เราจะคุยกันเรื่อง promise chaining โดยเฉพาะ
 
-It looks like this:
+หน้าตาประมาณนี้:
 
 ```js run
 new Promise(function(resolve, reject) {
@@ -32,25 +32,25 @@ new Promise(function(resolve, reject) {
 });
 ```
 
-The idea is that the result is passed through the chain of `.then` handlers.
+หลักก็คือ — ค่าผลลัพธ์จะวิ่งต่อไปเรื่อยๆ ตลอด chain ของ `.then`
 
-Here the flow is:
-1. The initial promise resolves in 1 second `(*)`,
-2. Then the `.then` handler is called `(**)`, which in turn creates a new promise (resolved with `2` value).
-3. The next `then` `(***)` gets the result of the previous one, processes it (doubles) and passes it to the next handler.
-4. ...and so on.
+ลำดับการทำงาน:
+1. promise ตัวแรก resolve หลังจาก 1 วินาที `(*)`
+2. จากนั้น `.then` handler ก็ทำงาน `(**)` แล้วคืนค่า promise ใหม่ (resolve ด้วยค่า `2`)
+3. `.then` ตัวถัดไป `(***)` รับค่าจากตัวก่อน แล้วส่งต่อให้ handler ถัดไปอีก
+4. ...ไปเรื่อยๆ แบบนี้
 
-As the result is passed along the chain of handlers, we can see a sequence of `alert` calls: `1` -> `2` -> `4`.
+ผลที่ได้คือ `alert` จะแสดงตามลำดับ: `1` -> `2` -> `4`
 
 ![](promise-then-chain.svg)
 
-The whole thing works, because every call to a `.then` returns a new promise, so that we can call the next `.then` on it.
+ที่ทำแบบนี้ได้เพราะ `.then` ทุกครั้งคืนค่าเป็น promise ใหม่เสมอ ทำให้เราต่อ `.then` ถัดไปต่อกันเป็นสายได้
 
-When a handler returns a value, it becomes the result of that promise, so the next `.then` is called with it.
+พอ handler คืนค่าอะไรออกมา ค่านั้นก็กลายเป็นผลลัพธ์ของ promise ตัวนั้น แล้ว `.then` ถัดไปก็รับค่านั้นไปทำต่อ
 
-**A classic newbie error: technically we can also add many `.then` to a single promise. This is not chaining.**
+**ข้อผิดพลาดยอดฮิตของมือใหม่: ต่อ `.then` หลายตัวเข้ากับ promise เดียวกัน — อันนี้ไม่ใช่ chaining นะ**
 
-For example:
+ตัวอย่าง:
 ```js run
 let promise = new Promise(function(resolve, reject) {
   setTimeout(() => resolve(1), 1000);
@@ -72,23 +72,23 @@ promise.then(function(result) {
 });
 ```
 
-What we did here is just adding several handlers to one promise. They don't pass the result to each other; instead they process it independently.
+สิ่งที่เราทำที่นี่คือแค่ผูก handler หลายตัวเข้ากับ promise เดียว แต่ละตัวไม่ได้รับค่าต่อจากกัน ต่างคนต่างทำงานแยก
 
-Here's the picture (compare it with the chaining above):
+ดูภาพเปรียบเทียบ (ต่างจาก chaining ด้านบนชัดเลย):
 
 ![](promise-then-many.svg)
 
-All `.then` on the same promise get the same result -- the result of that promise. So in the code above all `alert` show the same: `1`.
+`.then` ทุกตัวที่ผูกกับ promise เดียวกันจะได้ค่าเดิมหมด — ก็คือค่าที่ promise ตัวนั้น resolve มา โค้ดด้านบนเลย `alert` แสดง `1` ทุกตัว
 
-In practice we rarely need multiple handlers for one promise. Chaining is used much more often.
+ในทางปฏิบัติเราแทบไม่ค่อยต้องการ handler หลายตัวต่อ promise เดียวหรอก ใช้ chaining บ่อยกว่าเยอะ
 
-## Returning promises
+## คืนค่าเป็น Promise
 
-A handler, used in `.then(handler)` may create and return a promise.
+handler ใน `.then(handler)` คืนค่าเป็น promise ได้เช่นกัน
 
-In that case further handlers wait until it settles, and then get its result.
+ถ้าทำแบบนั้น handler ตัวถัดไปจะรอจนกว่า promise นั้นจะ settle ก่อน แล้วค่อยรับผลลัพธ์
 
-For instance:
+ดูตัวอย่าง:
 
 ```js run
 new Promise(function(resolve, reject) {
@@ -120,15 +120,17 @@ new Promise(function(resolve, reject) {
 });
 ```
 
-Here the first `.then` shows `1` and returns `new Promise(…)` in the line `(*)`. After one second it resolves, and the result (the argument of `resolve`, here it's `result * 2`) is passed on to the handler of the second `.then`. That handler is in the line `(**)`, it shows `2` and does the same thing.
+`.then` ตัวแรก alert แสดง `1` แล้วคืนค่า `new Promise(…)` ในบรรทัด `(*)` หลังจาก 1 วินาที promise นั้น resolve ค่า `result * 2` ก็ถูกส่งไปให้ handler ของ `.then` ตัวที่สอง
 
-So the output is the same as in the previous example: 1 -> 2 -> 4, but now with 1 second delay between `alert` calls.
+handler นั้นอยู่ที่บรรทัด `(**)` แสดง `2` แล้วก็ทำแบบเดียวกัน
 
-Returning promises allows us to build chains of asynchronous actions.
+ผลลัพธ์เหมือนตัวอย่างก่อนเลย: 1 -> 2 -> 4 แต่คราวนี้มีดีเลย์ 1 วินาทีระหว่างแต่ละ `alert`
 
-## Example: loadScript
+การคืนค่าเป็น promise แบบนี้ทำให้เราสร้าง chain ของงาน async ได้นั่นเอง
 
-Let's use this feature with the promisified `loadScript`, defined in the [previous chapter](info:promise-basics#loadscript), to load scripts one by one, in sequence:
+## ตัวอย่าง: loadScript
+
+ลองใช้ฟีเจอร์นี้กับ `loadScript` ที่แปลงเป็น promise ไว้แล้วใน[บทก่อน](info:promise-basics#loadscript) เพื่อโหลด script ทีละไฟล์ตามลำดับ:
 
 ```js run
 loadScript("/article/promise-chaining/one.js")
@@ -139,40 +141,39 @@ loadScript("/article/promise-chaining/one.js")
     return loadScript("/article/promise-chaining/three.js");
   })
   .then(function(script) {
-    // use functions declared in scripts
-    // to show that they indeed loaded
+    // ใช้ฟังก์ชันที่ประกาศไว้ใน script
+    // เพื่อพิสูจน์ว่าโหลดสำเร็จจริงๆ
     one();
     two();
     three();
   });
 ```
 
-This code can be made bit shorter with arrow functions:
+เขียนสั้นลงได้อีกด้วย arrow function:
 
 ```js run
 loadScript("/article/promise-chaining/one.js")
   .then(script => loadScript("/article/promise-chaining/two.js"))
   .then(script => loadScript("/article/promise-chaining/three.js"))
   .then(script => {
-    // scripts are loaded, we can use functions declared there
+    // script ทุกไฟล์โหลดแล้ว เรียกใช้ฟังก์ชันได้เลย
     one();
     two();
     three();
   });
 ```
 
+แต่ละ `loadScript` คืนค่าเป็น promise พอ promise resolve `.then` ถัดไปก็ทำงาน แล้วก็เริ่มโหลด script ไฟล์ต่อไป script เลยโหลดทีละไฟล์ตามลำดับ
 
-Here each `loadScript` call returns a promise, and the next `.then` runs when it resolves. Then it initiates the loading of the next script. So scripts are loaded one after another.
-
-We can add more asynchronous actions to the chain. Please note that the code is still "flat" — it grows down, not to the right. There are no signs of the "pyramid of doom".
+เราเพิ่มงาน async เข้า chain ได้เรื่อยๆ สังเกตว่าโค้ดยัง "แบน" อยู่ — ยาวลงข้างล่าง ไม่โตไปทางขวา ไม่มีกลิ่น "pyramid of doom" เลย
 
-Technically, we could add `.then` directly to each `loadScript`, like this:
+แต่ถ้าอยากเขียน `.then` แบบ nested ก็ทำได้นะ:
 
 ```js run
 loadScript("/article/promise-chaining/one.js").then(script1 => {
   loadScript("/article/promise-chaining/two.js").then(script2 => {
     loadScript("/article/promise-chaining/three.js").then(script3 => {
-      // this function has access to variables script1, script2 and script3
+      // ฟังก์ชันนี้เข้าถึงตัวแปร script1, script2, script3 ได้ทั้งหมด
       one();
       two();
       three();
@@ -181,19 +182,20 @@ loadScript("/article/promise-chaining/one.js").then(script1 => {
 });
 ```
 
-This code does the same: loads 3 scripts in sequence. But it "grows to the right". So we have the same problem as with callbacks.
+โค้ดนี้ทำงานเหมือนกัน: โหลด 3 script ตามลำดับ แต่มันโตไปทางขวา กลับมามีปัญหาเดิมเหมือน callback เลย
 
-People who start to use promises sometimes don't know about chaining, so they write it this way. Generally, chaining is preferred.
+คนที่เพิ่งเริ่มใช้ promise บางทีไม่รู้ว่ามี chaining เลยเขียนแบบ nested แทน โดยทั่วไปการ chain ดีกว่า
 
-Sometimes it's ok to write `.then` directly, because the nested function has access to the outer scope. In the example above the most nested callback has access to all variables `script1`, `script2`, `script3`. But that's an exception rather than a rule.
+แต่ก็มีบางกรณีที่เขียน `.then` แบบ nested โอเคนะ เพราะฟังก์ชันด้านในเข้าถึง scope ด้านนอกได้
 
+จากตัวอย่างด้านบน callback ที่ nested ลึกสุดเข้าถึง `script1`, `script2`, `script3` ได้ครบ — แต่นี่เป็นข้อยกเว้น ไม่ใช่กฎ
 
 ````smart header="Thenables"
-To be precise, a handler may return not exactly a promise, but a so-called "thenable" object - an arbitrary object that has a method `.then`. It will be treated the same way as a promise.
+จริงๆ แล้ว handler ไม่จำเป็นต้องคืนค่าเป็น promise ก็ได้ — คืนเป็น "thenable" object ก็พอ นั่นคือออบเจ็กต์ที่มีเมธอด `.then` JavaScript จะปฏิบัติกับมันเหมือน promise เลย
 
-The idea is that 3rd-party libraries may implement "promise-compatible" objects of their own. They can have an extended set of methods, but also be compatible with native promises, because they implement `.then`.
+แนวคิดคือ library ของคนอื่นอาจ implement "promise-compatible" object ของตัวเอง ซึ่งมีเมธอดเพิ่มเติมได้ แต่ยังใช้งานร่วมกับ promise มาตรฐานได้ เพราะ implement `.then` ไว้
 
-Here's an example of a thenable object:
+ดูตัวอย่าง thenable object:
 
 ```js run
 class Thenable {
@@ -202,7 +204,7 @@ class Thenable {
   }
   then(resolve, reject) {
     alert(resolve); // function() { native code }
-    // resolve with this.num*2 after the 1 second
+    // resolve ด้วย this.num*2 หลังจาก 1 วินาที
     setTimeout(() => resolve(this.num * 2), 1000); // (**)
   }
 }
@@ -213,70 +215,74 @@ new Promise(resolve => resolve(1))
     return new Thenable(result); // (*)
 */!*
   })
-  .then(alert); // shows 2 after 1000ms
+  .then(alert); // แสดง 2 หลังจาก 1000ms
 ```
 
-JavaScript checks the object returned by the `.then` handler in line `(*)`: if it has a callable method named `then`, then it calls that method providing native functions `resolve`, `reject` as arguments (similar to an executor) and waits until one of them is called. In the example above `resolve(2)` is called after 1 second `(**)`. Then the result is passed further down the chain.
+JavaScript เช็คออบเจ็กต์ที่ handler คืนมาในบรรทัด `(*)`: ถ้ามีเมธอด `then` ที่เรียกได้ ก็จะเรียกเมธอดนั้นโดยส่ง native `resolve` และ `reject` เป็น argument (เหมือน executor) แล้วรอจนกว่าจะมีการเรียกหนึ่งในนั้น
+
+จากตัวอย่าง `resolve(2)` ถูกเรียกหลัง 1 วินาที `(**)` แล้วค่าก็ถูกส่งต่อลง chain
 
-This feature allows us to integrate custom objects with promise chains without having to inherit from `Promise`.
+ฟีเจอร์นี้ทำให้เราผสาน custom object เข้ากับ promise chain ได้ โดยไม่ต้องสืบทอด (inherit) จาก `Promise` เลย
 ````
 
 
-## Bigger example: fetch
+## ตัวอย่างใหญ่: fetch
 
-In frontend programming, promises are often used for network requests. So let's see an extended example of that.
+ใน frontend เราใช้ promise กับ network request กันบ่อยมาก ลองดูตัวอย่างที่เจาะลึกขึ้นกัน
 
-We'll use the [fetch](info:fetch) method to load the information about the user from the remote server. It has a lot of optional parameters covered in [separate chapters](info:fetch), but the basic syntax is quite simple:
+เราจะใช้เมธอด [fetch](info:fetch) ดึงข้อมูล user จาก server มา พารามิเตอร์เสริมมีเยอะ (ดูใน[บทที่แยกออกมา](info:fetch)) แต่รูปแบบพื้นฐานง่ายมาก:
 
 ```js
 let promise = fetch(url);
 ```
 
-This makes a network request to the `url` and returns a promise. The promise resolves with a `response` object when the remote server responds with headers, but *before the full response is downloaded*.
+แค่นี้ก็ส่ง network request ไปที่ `url` แล้วคืนค่าเป็น promise
 
-To read the full response, we should call the method `response.text()`: it returns a promise that resolves when the full text is downloaded from the remote server, with that text as a result.
+promise นั้นจะ resolve ด้วย `response` object เมื่อ server ตอบกลับมาพร้อม header — แต่ยังไม่ได้ดาวน์โหลดข้อมูลทั้งหมดนะ
 
-The code below makes a request to `user.json` and loads its text from the server:
+ถ้าต้องการอ่านข้อมูลทั้งหมด ต้องเรียก `response.text()`: ซึ่งคืนค่าเป็น promise ที่จะ resolve เมื่อดาวน์โหลด text ครบแล้ว
+
+โค้ดนี้ request ไปที่ `user.json` แล้วโหลด text จาก server:
 
 ```js run
 fetch('/article/promise-chaining/user.json')
-  // .then below runs when the remote server responds
+  // .then ด้านล่างทำงานเมื่อ server ตอบกลับ
   .then(function(response) {
-    // response.text() returns a new promise that resolves with the full response text
-    // when it loads
+    // response.text() คืนค่าเป็น promise ใหม่ที่ resolve ด้วย text ทั้งหมด
+    // เมื่อโหลดเสร็จ
     return response.text();
   })
   .then(function(text) {
-    // ...and here's the content of the remote file
+    // ...นี่คือเนื้อหาของไฟล์บน server
     alert(text); // {"name": "iliakan", "isAdmin": true}
   });
 ```
 
-The `response` object returned from `fetch` also includes the method `response.json()` that reads the remote data and parses it as JSON. In our case that's even more convenient, so let's switch to it.
+`response` object ที่ได้จาก `fetch` มีเมธอด `response.json()` ด้วย — อ่านข้อมูลแล้ว parse เป็น JSON ให้เลย ในกรณีนี้สะดวกกว่า ลองเปลี่ยนไปใช้แทน
 
-We'll also use arrow functions for brevity:
+ใช้ arrow function ให้กระชับขึ้นด้วย:
 
 ```js run
-// same as above, but response.json() parses the remote content as JSON
+// เหมือนด้านบน แต่ response.json() parse เป็น JSON ให้เลย
 fetch('/article/promise-chaining/user.json')
   .then(response => response.json())
-  .then(user => alert(user.name)); // iliakan, got user name
+  .then(user => alert(user.name)); // iliakan, ได้ชื่อ user แล้ว
 ```
 
-Now let's do something with the loaded user.
+ทีนี้ลองทำอะไรกับ user ที่โหลดมาดูบ้าง
 
-For instance, we can make one more request to GitHub, load the user profile and show the avatar:
+เช่น ส่ง request อีกอันไปที่ GitHub โหลดโปรไฟล์ user แล้วแสดงรูป avatar:
 
 ```js run
-// Make a request for user.json
+// Request user.json
 fetch('/article/promise-chaining/user.json')
-  // Load it as json
+  // โหลดเป็น json
   .then(response => response.json())
-  // Make a request to GitHub
+  // Request ไปที่ GitHub
   .then(user => fetch(`https://api.github.com/users/${user.name}`))
-  // Load the response as json
+  // โหลด response เป็น json
   .then(response => response.json())
-  // Show the avatar image (githubUser.avatar_url) for 3 seconds (maybe animate it)
+  // แสดงรูป avatar (githubUser.avatar_url) นาน 3 วินาที (อาจเพิ่ม animation ด้วย)
   .then(githubUser => {
     let img = document.createElement('img');
     img.src = githubUser.avatar_url;
@@ -287,13 +293,13 @@ fetch('/article/promise-chaining/user.json')
   });
 ```
 
-The code works; see comments about the details. However, there's a potential problem in it, a typical error for those who begin to use promises.
+โค้ดทำงานได้ ดูคอมเมนต์สำหรับรายละเอียด แต่มีจุดพลาดแอบซ่อนอยู่ — เป็นกับดักยอดฮิตของคนที่เพิ่งหัดใช้ promise
 
-Look at the line `(*)`: how can we do something *after* the avatar has finished showing and gets removed? For instance, we'd like to show a form for editing that user or something else. As of now, there's no way.
+ดูบรรทัด `(*)` สิ: ถ้าอยากทำอะไรสักอย่าง *หลังจาก* รูป avatar แสดงครบแล้วและถูกลบออกไป จะทำได้ยังไง? เช่น อยากแสดง form แก้ไขข้อมูล user ตอนนี้ยังไม่มีทางทำได้เลย
 
-To make the chain extendable, we need to return a promise that resolves when the avatar finishes showing.
+ถ้าต้องการให้ chain ต่อได้ ต้องคืนค่าเป็น promise ที่ resolve ตอนที่ avatar แสดงครบแล้ว
 
-Like this:
+แบบนี้:
 
 ```js run
 fetch('/article/promise-chaining/user.json')
@@ -315,15 +321,17 @@ fetch('/article/promise-chaining/user.json')
 */!*
     }, 3000);
   }))
-  // triggers after 3 seconds
+  // ทำงานหลังจาก 3 วินาที
   .then(githubUser => alert(`Finished showing ${githubUser.name}`));
 ```
 
-That is, the `.then` handler in line `(*)` now returns `new Promise`, that becomes settled only after the call of `resolve(githubUser)` in `setTimeout` `(**)`. The next `.then` in the chain will wait for that.
+`.then` handler ในบรรทัด `(*)` คืนค่า `new Promise` ซึ่งจะ settled ก็ต่อเมื่อ `resolve(githubUser)` ใน `setTimeout` ถูกเรียกที่บรรทัด `(**)`
+
+`.then` ถัดไปใน chain จะรอก่อนเสมอ
 
-As a good practice, an asynchronous action should always return a promise. That makes it possible to plan actions after it; even if we don't plan to extend the chain now, we may need it later.
+แนวปฏิบัติที่ดีคือ งาน async ควรคืนค่าเป็น promise เสมอ ทำให้เราวางแผนงานต่อไปได้ แม้ตอนนี้ยังไม่ได้ต่อ chain แต่ก็อาจต้องการภายหลัง
 
-Finally, we can split the code into reusable functions:
+สุดท้าย แยกโค้ดออกเป็นฟังก์ชันที่นำกลับมาใช้ได้:
 
 ```js run
 function loadJson(url) {
@@ -349,7 +357,7 @@ function showAvatar(githubUser) {
   });
 }
 
-// Use them:
+// ใช้งาน:
 loadJson('/article/promise-chaining/user.json')
   .then(user => loadGithubUser(user.name))
   .then(showAvatar)
@@ -357,10 +365,10 @@ loadJson('/article/promise-chaining/user.json')
   // ...
 ```
 
-## Summary
+## สรุป
 
-If a `.then` (or `catch/finally`, doesn't matter) handler returns a promise, the rest of the chain waits until it settles. When it does, its result (or error) is passed further.
+ถ้า handler ใน `.then` (หรือ `catch/finally` ก็ตาม) คืนค่าเป็น promise ส่วนที่เหลือของ chain จะรอจนกว่ามันจะ settle แล้วค่อยรับผลลัพธ์ (หรือ error) ไปทำต่อ
 
-Here's a full picture:
+ดูภาพรวมทั้งหมดได้ที่นี่:
 
 ![](promise-handler-variants.svg)
diff --git a/1-js/11-async/03-promise-chaining/getMessage.js b/1-js/11-async/03-promise-chaining/getMessage.js
index 6c5893433..6601e3a47 100644
--- a/1-js/11-async/03-promise-chaining/getMessage.js
+++ b/1-js/11-async/03-promise-chaining/getMessage.js
@@ -1,3 +1,3 @@
 function getMessage() {
-  return "Hello, world!";
+  return "สวัสดีชาวโลก!";
 }
diff --git a/1-js/11-async/03-promise-chaining/head.html b/1-js/11-async/03-promise-chaining/head.html
index 0a0075fb9..e64dbca56 100644
--- a/1-js/11-async/03-promise-chaining/head.html
+++ b/1-js/11-async/03-promise-chaining/head.html
@@ -5,7 +5,7 @@
     script.src = src;
 
     script.onload = () => resolve(script);
-    script.onerror = () => reject(new Error("Script load error: " + src));
+    script.onerror = () => reject(new Error("โหลด script ไม่สำเร็จ: " + src));
 
     document.head.append(script);
   });
diff --git a/1-js/11-async/04-promise-error-handling/01-error-async/solution.md b/1-js/11-async/04-promise-error-handling/01-error-async/solution.md
index 0d43f55e0..c25b654ab 100644
--- a/1-js/11-async/04-promise-error-handling/01-error-async/solution.md
+++ b/1-js/11-async/04-promise-error-handling/01-error-async/solution.md
@@ -1,4 +1,4 @@
-The answer is: **no, it won't**:
+คำตอบคือ: **ไม่ `.catch` จะไม่ทำงาน**:
 
 ```js run
 new Promise(function(resolve, reject) {
@@ -8,6 +8,6 @@ new Promise(function(resolve, reject) {
 }).catch(alert);
 ```
 
-As said in the chapter, there's an "implicit `try..catch`" around the function code. So all synchronous errors are handled.
+อย่างที่อธิบายไปในบท executor มี `try..catch` ล่องหนครอบอยู่ เลย error แบบ synchronous จะโดนดักจับได้หมด
 
-But here the error is generated not while the executor is running, but later. So the promise can't handle it. 
+แต่ตรงนี้ error ไม่ได้เกิดขึ้นตอนที่ executor กำลังทำงาน — มันเกิดทีหลัง ตอนที่ `setTimeout` callback รัน promise จึงจัดการ error ตัวนี้ไม่ได้
diff --git a/1-js/11-async/04-promise-error-handling/01-error-async/task.md b/1-js/11-async/04-promise-error-handling/01-error-async/task.md
index bafc47ce9..b699625f0 100644
--- a/1-js/11-async/04-promise-error-handling/01-error-async/task.md
+++ b/1-js/11-async/04-promise-error-handling/01-error-async/task.md
@@ -1,6 +1,6 @@
-# Error in setTimeout
+# Error ใน setTimeout
 
-What do you think? Will the `.catch` trigger? Explain your answer.
+ลองดูว่า `.catch` จะทำงานไหม? ช่วยอธิบายคำตอบด้วย
 
 ```js
 new Promise(function(resolve, reject) {
diff --git a/1-js/11-async/04-promise-error-handling/article.md b/1-js/11-async/04-promise-error-handling/article.md
index c5b4206ab..cc0a99466 100644
--- a/1-js/11-async/04-promise-error-handling/article.md
+++ b/1-js/11-async/04-promise-error-handling/article.md
@@ -1,21 +1,21 @@
 
-# Error handling with promises
+# การจัดการ error ใน promise
 
-Promise chains are great at error handling. When a promise rejects, the control jumps to the closest rejection handler. That's very convenient in practice.
+promise chain เก่งเรื่อง error handling มาก — พอ promise reject ปุ๊บ handler ที่ใกล้ที่สุดจะรับงานต่อทันทีเลย
 
-For instance, in the code below the URL to `fetch` is wrong (no such site) and `.catch` handles the error:
+ลองดูตัวอย่าง URL ที่ `fetch` ไปไม่ถึง (เซิร์ฟเวอร์ไม่มีอยู่จริง) — `.catch` จัดการ error ให้เราได้เลย:
 
 ```js run
 *!*
 fetch('https://no-such-server.blabla') // rejects
 */!*
   .then(response => response.json())
-  .catch(err => alert(err)) // TypeError: failed to fetch (the text may vary)
+  .catch(err => alert(err)) // TypeError: failed to fetch (ข้อความอาจต่างกัน)
 ```
 
-As you can see, the `.catch` doesn't have to be immediate. It may appear after one or maybe several `.then`.
+จะเห็นว่า `.catch` ไม่ต้องอยู่ติดกัน — วางไว้หลัง `.then` หนึ่งตัวหรือหลายตัวก็ได้
 
-Or, maybe, everything is all right with the site, but the response is not valid JSON. The easiest way to catch all errors is to append `.catch` to the end of chain:
+อีกกรณีที่พบบ่อยคือเซิร์ฟเวอร์ตอบกลับปกติ แต่ข้อมูลที่ได้ไม่ใช่ JSON ที่ถูกต้อง วิธีที่ง่ายที่สุดคือเติม `.catch` ไว้ท้าย chain:
 
 ```js run
 fetch('/article/promise-chaining/user.json')
@@ -38,13 +38,15 @@ fetch('/article/promise-chaining/user.json')
 */!*
 ```
 
-Normally, such `.catch` doesn't trigger at all. But if any of the promises above rejects (a network problem or invalid json or whatever), then it would catch it.
+ปกติ `.catch` นี้จะไม่ทำงานเลย แต่ถ้า promise ตัวไหนตัวหนึ่ง reject — ไม่ว่าจะเป็นปัญหาเครือข่าย JSON ผิดรูปแบบ หรืออะไรก็แล้วแต่ — `.catch` ตัวเดียวนี้จะรับหมด
 
 ## Implicit try..catch
 
-The code of a promise executor and promise handlers has an "invisible `try..catch`" around it. If an exception happens, it gets caught and treated as a rejection.
+ลองคิดดูว่าถ้าเราโยน error ตรงๆ ใน executor มันจะเป็นยังไงล่ะ?
 
-For instance, this code:
+executor และ handler ของ promise มี `try..catch` "ล่องหน" ครอบอยู่ด้วยกันทุกตัว ถ้ามี exception เกิดขึ้น JavaScript จะดักจับแล้วแปลงเป็น rejected promise ให้อัตโนมัติ
+
+เช่น โค้ดนี้:
 
 ```js run
 new Promise((resolve, reject) => {
@@ -54,7 +56,7 @@ new Promise((resolve, reject) => {
 }).catch(alert); // Error: Whoops!
 ```
 
-...Works exactly the same as this:
+...ทำงานเหมือนกันทุกอย่างกับแบบนี้:
 
 ```js run
 new Promise((resolve, reject) => {
@@ -64,11 +66,9 @@ new Promise((resolve, reject) => {
 }).catch(alert); // Error: Whoops!
 ```
 
-The "invisible `try..catch`" around the executor automatically catches the error and turns it into rejected promise.
-
-This happens not only in the executor function, but in its handlers as well. If we `throw` inside a `.then` handler, that means a rejected promise, so the control jumps to the nearest error handler.
+`try..catch` ล่องหนใน executor จัดการ error แล้วเปลี่ยนเป็น rejected promise ให้เองเลย
 
-Here's an example:
+แต่ไม่ใช่แค่ใน executor — ใน handler ก็เช่นกัน ถ้าเรา `throw` ใน `.then` ตัวไหน promise ตัวนั้นจะกลาย reject แล้วโยนไปให้ error handler ที่ใกล้ที่สุด:
 
 ```js run
 new Promise((resolve, reject) => {
@@ -80,49 +80,49 @@ new Promise((resolve, reject) => {
 }).catch(alert); // Error: Whoops!
 ```
 
-This happens for all errors, not just those caused by the `throw` statement. For example, a programming error:
+ไม่ใช่แค่ `throw` ด้วย — error ที่เกิดจากโค้ดผิดพลาดก็โดนดักเหมือนกัน เช่น เรียกฟังก์ชันที่ไม่มีอยู่:
 
 ```js run
 new Promise((resolve, reject) => {
   resolve("ok");
 }).then((result) => {
 *!*
-  blabla(); // no such function
+  blabla(); // ไม่มีฟังก์ชันนี้
 */!*
 }).catch(alert); // ReferenceError: blabla is not defined
 ```
 
-The final `.catch` not only catches explicit rejections, but also accidental errors in the handlers above.
+`.catch` ตัวสุดท้ายรับได้ทั้ง rejection ที่ตั้งใจ throw และ error ที่เกิดขึ้นโดยไม่ตั้งใจในทุก handler ด้านบน
 
 ## Rethrowing
 
-As we already noticed, `.catch` at the end of the chain is similar to `try..catch`. We may have as many `.then` handlers as we want, and then use a single `.catch` at the end to handle errors in all of them.
+`.catch` ท้าย chain ก็คล้ายกับ `try..catch` ธรรมดานั่นเอง — เราจะมี `.then` กี่ตัวก็ได้ แล้วใส่ `.catch` ตัวเดียวตอนท้ายเพื่อรับ error ทั้งหมด
 
-In a regular `try..catch` we can analyze the error and maybe rethrow it if it can't be handled. The same thing is possible for promises.
+ใน `try..catch` ธรรมดา เราเช็ค error แล้วโยนต่อ (rethrow) ได้ถ้าจัดการเองไม่ได้ promise ก็ทำแบบเดียวกันได้
 
-If we `throw` inside `.catch`, then the control goes to the next closest error handler. And if we handle the error and finish normally, then it continues to the next closest successful `.then` handler.
+ถ้า `throw` ใน `.catch` การทำงานจะกระโดดไปหา error handler ตัวต่อไป แต่ถ้าจัดการ error ได้และทำงานปกติจนจบ การทำงานจะไหลต่อไปหา `.then` ที่ใกล้ที่สุด
 
-In the example below the `.catch` successfully handles the error:
+ตัวอย่างแรก — `.catch` จัดการ error ได้จบ:
 
 ```js run
-// the execution: catch -> then
+// การทำงาน: catch -> then
 new Promise((resolve, reject) => {
 
   throw new Error("Whoops!");
 
 }).catch(function(error) {
 
-  alert("The error is handled, continue normally");
+  alert("จัดการ error เรียบร้อยแล้ว ทำงานต่อได้เลย");
 
-}).then(() => alert("Next successful handler runs"));
+}).then(() => alert("handler ถัดไปที่สำเร็จทำงาน"));
 ```
 
-Here the `.catch` block finishes normally. So the next successful `.then` handler is called.
+`.catch` ทำงานจบปกติ เลย `.then` ถัดไปก็ทำงานต่อ
 
-In the example below we see the other situation with `.catch`. The handler `(*)` catches the error and just can't handle it (e.g. it only knows how to handle `URIError`), so it throws it again:
+ตัวอย่างที่สอง — handler `(*)` รับ error มาแต่จัดการไม่ได้ (รู้จักแค่ `URIError`) เลยโยนต่อ:
 
 ```js run
-// the execution: catch -> catch
+// การทำงาน: catch -> catch
 new Promise((resolve, reject) => {
 
   throw new Error("Whoops!");
@@ -130,76 +130,76 @@ new Promise((resolve, reject) => {
 }).catch(function(error) { // (*)
 
   if (error instanceof URIError) {
-    // handle it
+    // จัดการได้
   } else {
-    alert("Can't handle such error");
+    alert("จัดการ error แบบนี้ไม่ได้");
 
 *!*
-    throw error; // throwing this or another error jumps to the next catch
+    throw error; // โยน error นี้หรือ error อื่นต่อไปยัง catch ถัดไป
 */!*
   }
 
 }).then(function() {
-  /* doesn't run here */
+  /* ไม่ทำงานตรงนี้ */
 }).catch(error => { // (**)
 
-  alert(`The unknown error has occurred: ${error}`);
-  // don't return anything => execution goes the normal way
+  alert(`เกิด error ที่ไม่รู้จัก: ${error}`);
+  // ไม่ return อะไร => การทำงานเดินต่อตามปกติ
 
 });
 ```
 
-The execution jumps from the first `.catch` `(*)` to the next one `(**)` down the chain.
+การทำงานกระโดดจาก `.catch` ตัวแรก `(*)` ไปตัวที่สอง `(**)` ลงมาใน chain
 
 ## Unhandled rejections
 
-What happens when an error is not handled? For instance, we forgot to append `.catch` to the end of the chain, like here:
+แล้วถ้าไม่มีอะไรมาจัดการ error เลยล่ะ? เช่น เราลืมต่อ `.catch` ท้าย chain:
 
 ```js untrusted run refresh
 new Promise(function() {
-  noSuchFunction(); // Error here (no such function)
+  noSuchFunction(); // เกิด error ตรงนี้ (ไม่มีฟังก์ชันนี้)
 })
   .then(() => {
-    // successful promise handlers, one or more
-  }); // without .catch at the end!
+    // handler ที่สำเร็จ หนึ่งตัวหรือมากกว่า
+  }); // ไม่มี .catch ตอนท้าย!
 ```
 
-In case of an error, the promise becomes rejected, and the execution should jump to the closest rejection handler. But there is none. So the error gets "stuck". There's no code to handle it.
+พอเกิด error ขึ้น promise จะกลายเป็น rejected แล้วการทำงานควรกระโดดไปหา rejection handler ที่ใกล้ที่สุด — แต่ไม่มีเลย เลย error ค้างอยู่อย่างนั้น ไม่มีโค้ดใดมาจัดการ
 
-In practice, just like with regular unhandled errors in code, it means that something has gone terribly wrong.
+สถานการณ์แบบนี้ก็เหมือนกับ unhandled error ทั่วไปในโปรแกรม — แปลว่ามีอะไรผิดพลาดหนักมาก
 
-What happens when a regular error occurs and is not caught by `try..catch`? The script dies with a message in the console. A similar thing happens with unhandled promise rejections.
+ปกติถ้า error เกิดขึ้นโดยไม่มี `try..catch` รับ สคริปต์จะพังพร้อม error ใน console — promise rejection ที่ไม่มีใครจัดการก็คล้ายกัน
 
-The JavaScript engine tracks such rejections and generates a global error in that case. You can see it in the console if you run the example above.
+JavaScript engine ติดตาม rejection พวกนี้อยู่ และจะสร้าง global error ขึ้นมา ลองรันตัวอย่างด้านบนดูแล้วเช็ค console ได้เลย
 
-In the browser we can catch such errors using the event `unhandledrejection`:
+บน browser เราดักจับ error แบบนี้ได้ผ่านอีเวนต์ `unhandledrejection`:
 
 ```js run
 *!*
 window.addEventListener('unhandledrejection', function(event) {
-  // the event object has two special properties:
-  alert(event.promise); // [object Promise] - the promise that generated the error
-  alert(event.reason); // Error: Whoops! - the unhandled error object
+  // event object มีสองพร็อพเพอร์ตี้พิเศษ:
+  alert(event.promise); // [object Promise] - promise ที่ทำให้เกิด error
+  alert(event.reason); // Error: Whoops! - ออบเจ็กต์ error ที่ไม่มีใครจัดการ
 });
 */!*
 
 new Promise(function() {
   throw new Error("Whoops!");
-}); // no catch to handle the error
+}); // ไม่มี catch มารับ error
 ```
 
-The event is the part of the [HTML standard](https://html.spec.whatwg.org/multipage/webappapis.html#unhandled-promise-rejections).
+อีเวนต์นี้เป็นส่วนหนึ่งของ [HTML standard](https://html.spec.whatwg.org/multipage/webappapis.html#unhandled-promise-rejections)
 
-If an error occurs, and there's no `.catch`, the `unhandledrejection` handler triggers, and gets the `event` object with the information about the error, so we can do something.
+เมื่อเกิด error แล้วไม่มี `.catch` รับ handler `unhandledrejection` จะทำงานและได้รับออบเจ็กต์ `event` พร้อมข้อมูล error ครบ — เอาไปทำอะไรต่อก็ได้
 
-Usually such errors are unrecoverable, so our best way out is to inform the user about the problem and probably report the incident to the server.
+Error แบบนี้ส่วนใหญ่แก้ไขไม่ได้แล้ว ทางออกที่ดีที่สุดคือแจ้ง user และส่ง log ไปที่เซิร์ฟเวอร์
 
-In non-browser environments like Node.js there are other ways to track unhandled errors.
+สำหรับ Node.js และ environment อื่นที่ไม่ใช่ browser ก็มีวิธีติดตาม unhandled error เช่นกัน แต่รูปแบบต่างกัน
 
-## Summary
+## สรุป
 
-- `.catch` handles errors in promises of all kinds: be it a `reject()` call, or an error thrown in a handler.
-- `.then` also catches errors in the same manner, if given the second argument (which is the error handler).
-- We should place `.catch` exactly in places where we want to handle errors and know how to handle them. The handler should analyze errors (custom error classes help) and rethrow unknown ones (maybe they are programming mistakes).
-- It's ok not to use `.catch` at all, if there's no way to recover from an error.
-- In any case we should have the `unhandledrejection` event handler (for browsers, and analogs for other environments) to track unhandled errors and inform the user (and probably our server) about them, so that our app never "just dies".
+- `.catch` รับ error ได้ทุกแบบ — ทั้งจากการเรียก `reject()` และจาก error ที่โยนใน handler
+- `.then` ก็รับ error ได้เหมือนกัน ถ้าส่งฟังก์ชันรับ error เข้าไปเป็นอาร์กิวเมนต์ที่สอง
+- ควรวาง `.catch` ตรงจุดที่รู้วิธีจัดการ error และ handler ควรวิเคราะห์ error (คลาส error แบบ custom ช่วยได้) แล้วโยนต่อถ้าจัดการไม่ได้ (เผื่อเป็น programming bug)
+- ถ้าไม่มีทางกู้คืนจาก error ได้เลย จะไม่ใช้ `.catch` เลยก็โอเค
+- แต่ไม่ว่ากรณีไหน ควรมี handler สำหรับ `unhandledrejection` เสมอ (บน browser) หรือรูปแบบที่เทียบเท่าใน environment อื่น เพื่อติดตาม error ที่หลุดรอด แจ้ง user และบันทึก log ไปที่เซิร์ฟเวอร์ — เพื่อให้แอปไม่ "ดับเงียบ" โดยไม่มีใครรู้
diff --git a/1-js/11-async/05-promise-api/article.md b/1-js/11-async/05-promise-api/article.md
index 7be84ce2c..21b61ec9c 100644
--- a/1-js/11-async/05-promise-api/article.md
+++ b/1-js/11-async/05-promise-api/article.md
@@ -1,40 +1,38 @@
 # Promise API
 
-There are 6 static methods in the `Promise` class. We'll quickly cover their use cases here.
+คลาส `Promise` มี static method อยู่ 6 ตัว แต่ละตัวออกแบบมาสำหรับสถานการณ์ต่างกัน มาดูกันทีละตัวเลย
 
 ## Promise.all
 
-Let's say we want many promises to execute in parallel and wait until all of them are ready.
+สมมติว่าเราต้องรัน promise หลายตัวพร้อมกัน แล้วรอให้ทุกตัวเสร็จก่อนค่อยทำต่อ
 
-For instance, download several URLs in parallel and process the content once they are all done.
+เช่น ดาวน์โหลดหลาย URL พร้อมกัน แล้วประมวลผลเมื่อได้ข้อมูลครบทุก URL — นี่คืองานของ `Promise.all` นั่นเอง
 
-That's what `Promise.all` is for.
-
-The syntax is:
+เขียนแบบนี้:
 
 ```js
 let promise = Promise.all(iterable);
 ```
 
-`Promise.all` takes an iterable (usually, an array of promises) and returns a new promise.
+`Promise.all` รับ iterable (ปกติคืออาร์เรย์ของ promise) แล้วคืนค่าเป็น promise ใหม่
 
-The new promise resolves when all listed promises are resolved, and the array of their results becomes its result.
+promise ใหม่นี้จะ resolve ก็ต่อเมื่อทุก promise ใน list resolve แล้ว และผลลัพธ์จะเป็นอาร์เรย์ของค่าที่แต่ละ promise คืนมา
 
-For instance, the `Promise.all` below settles after 3 seconds, and then its result is an array `[1, 2, 3]`:
+ลองดูตัวอย่าง — `Promise.all` นี้จะ settle หลังจาก 3 วินาที แล้วได้ผลลัพธ์เป็น `[1, 2, 3]`:
 
 ```js run
 Promise.all([
   new Promise(resolve => setTimeout(() => resolve(1), 3000)), // 1
   new Promise(resolve => setTimeout(() => resolve(2), 2000)), // 2
   new Promise(resolve => setTimeout(() => resolve(3), 1000))  // 3
-]).then(alert); // 1,2,3 when promises are ready: each promise contributes an array member
+]).then(alert); // 1,2,3 เมื่อ promise พร้อมแล้ว: แต่ละ promise จะกลายเป็นสมาชิกในอาร์เรย์
 ```
 
-Please note that the order of the resulting array members is the same as in its source promises. Even though the first promise takes the longest time to resolve, it's still first in the array of results.
+สังเกตว่าลำดับในอาร์เรย์ผลลัพธ์จะตรงกับลำดับ promise ต้นทางเสมอ แม้ promise ตัวแรกจะใช้เวลานานที่สุด ผลของมันก็ยังอยู่ตำแหน่งแรกในอาร์เรย์
 
-A common trick is to map an array of job data into an array of promises, and then wrap that into `Promise.all`.
+ท่าที่ใช้กันบ่อยคือ map อาร์เรย์ของข้อมูลเป็นอาร์เรย์ของ promise แล้วส่งเข้า `Promise.all` — เจ๋งและกระชับมาก
 
-For instance, if we have an array of URLs, we can fetch them all like this:
+เช่น ถ้ามีอาร์เรย์ของ URL อยู่ ก็ fetch ทุกตัวพร้อมกันได้แบบนี้:
 
 ```js run
 let urls = [
@@ -43,17 +41,17 @@ let urls = [
   'https://api.github.com/users/jeresig'
 ];
 
-// map every url to the promise of the fetch
+// map แต่ละ url ให้เป็น promise ของ fetch
 let requests = urls.map(url => fetch(url));
 
-// Promise.all waits until all jobs are resolved
+// Promise.all รอจนกว่าทุก job จะ resolve แล้ว
 Promise.all(requests)
   .then(responses => responses.forEach(
     response => alert(`${response.url}: ${response.status}`)
   ));
 ```
 
-A bigger example with fetching user information for an array of GitHub users by their names (we could fetch an array of goods by their ids, the logic is identical):
+ตัวอย่างใหญ่กว่านั้น คือดึงข้อมูล user ของ GitHub จากอาร์เรย์ชื่อ (ลอจิกเดียวกับการดึงสินค้าจาก id):
 
 ```js run
 let names = ['iliakan', 'remy', 'jeresig'];
@@ -62,22 +60,22 @@ let requests = names.map(name => fetch(`https://api.github.com/users/${name}`));
 
 Promise.all(requests)
   .then(responses => {
-    // all responses are resolved successfully
+    // ทุก response resolve เรียบร้อยแล้ว
     for(let response of responses) {
-      alert(`${response.url}: ${response.status}`); // shows 200 for every url
+      alert(`${response.url}: ${response.status}`); // แสดง 200 ทุก url
     }
 
     return responses;
   })
-  // map array of responses into an array of response.json() to read their content
+  // map อาร์เรย์ของ response เป็น response.json() เพื่ออ่านเนื้อหา
   .then(responses => Promise.all(responses.map(r => r.json())))
-  // all JSON answers are parsed: "users" is the array of them
+  // parse JSON ครบแล้ว: "users" คืออาร์เรย์ของข้อมูล user ทั้งหมด
   .then(users => users.forEach(user => alert(user.name)));
 ```
 
-**If any of the promises is rejected, the promise returned by `Promise.all` immediately rejects with that error.**
+**ถ้า promise ตัวไหนตัวหนึ่ง reject ขึ้นมา `Promise.all` จะ reject ทันทีพร้อม error นั้นเลย**
 
-For instance:
+เช่น:
 
 ```js run
 Promise.all([
@@ -89,20 +87,20 @@ Promise.all([
 ]).catch(alert); // Error: Whoops!
 ```
 
-Here the second promise rejects in two seconds. That leads to an immediate rejection of `Promise.all`, so `.catch` executes: the rejection error becomes the outcome of the entire `Promise.all`.
+promise ตัวที่สอง reject หลัง 2 วินาที ทำให้ `Promise.all` reject ทันทีแล้ว `.catch` ก็ทำงาน — error ตัวนั้นกลายเป็นผลลัพธ์สุดท้ายของ `Promise.all` ทั้งก้อนเลย
 
-```warn header="In case of an error, other promises are ignored"
-If one promise rejects, `Promise.all` immediately rejects, completely forgetting about the other ones in the list. Their results are ignored.
+```warn header="เมื่อ error เกิดขึ้น promise ตัวอื่นจะถูกมองข้ามหมด"
+ถ้า promise ตัวใดตัวหนึ่ง reject ขึ้นมา `Promise.all` จะ reject ทันที และหยุดสนใจ promise ตัวที่เหลือทั้งหมด ผลลัพธ์ของพวกนั้นจะถูกทิ้งไปเลย
 
-For example, if there are multiple `fetch` calls, like in the example above, and one fails, the others will still continue to execute, but `Promise.all` won't watch them anymore. They will probably settle, but their results will be ignored.
+เช่น ถ้ามีหลาย `fetch` กำลังทำงานอยู่แล้วตัวหนึ่งพัง ตัวที่เหลือก็ยังรันต่อไปได้ตามปกติ แต่ `Promise.all` จะไม่ติดตามผลของพวกนั้นอีกต่อไป ถึงจะ settle ก็ถูกเพิกเฉย
 
-`Promise.all` does nothing to cancel them, as there's no concept of "cancellation" in promises. In [another chapter](info:fetch-abort) we'll cover `AbortController` that can help with that, but it's not a part of the Promise API.
+`Promise.all` ไม่มีทางยกเลิก promise เหล่านั้นได้ เพราะ promise ไม่มี concept ของ "การยกเลิก" ถ้าต้องการ cancel ลองดู `AbortController` ใน[บทอื่น](info:fetch-abort) แต่นั่นไม่ใช่ส่วนหนึ่งของ Promise API
 ```
 
-````smart header="`Promise.all(iterable)` allows non-promise \"regular\" values in `iterable`"
-Normally, `Promise.all(...)` accepts an iterable (in most cases an array) of promises. But if any of those objects is not a promise, it's passed to the resulting array "as is".
+````smart header="`Promise.all(iterable)` รับค่าธรรมดาที่ไม่ใช่ promise ได้ด้วย"
+ปกติ `Promise.all(...)` รับ iterable ของ promise แต่ถ้าค่าไหนไม่ใช่ promise ก็จะส่งผ่านไปยังอาร์เรย์ผลลัพธ์ "ตามที่เป็น" เลย
 
-For instance, here the results are `[1, 2, 3]`:
+เช่น ผลลัพธ์ที่ได้คือ `[1, 2, 3]`:
 
 ```js run
 Promise.all([
@@ -114,31 +112,31 @@ Promise.all([
 ]).then(alert); // 1, 2, 3
 ```
 
-So we are able to pass ready values to `Promise.all` where convenient.
+ก็คือเราส่งค่าที่พร้อมใช้อยู่แล้วเข้าไปใน `Promise.all` ตรงๆ ได้เลย
 ````
 
 ## Promise.allSettled
 
 [recent browser="new"]
 
-`Promise.all` rejects as a whole if any promise rejects. That's good for "all or nothing" cases, when we need *all* results successful to proceed:
+`Promise.all` จะ reject ทันทีถ้า promise ตัวไหนพัง — เหมาะสำหรับงานแบบ "ได้ทั้งหมดหรือไม่ได้เลย" เช่นต้องมีครบทุกอย่างถึงจะเดินหน้าได้:
 
 ```js
 Promise.all([
   fetch('/template.html'),
   fetch('/style.css'),
   fetch('/data.json')
-]).then(render); // render method needs results of all fetches
+]).then(render); // เมธอด render ต้องการผลลัพธ์จากทุก fetch
 ```
 
-`Promise.allSettled` just waits for all promises to settle, regardless of the result. The resulting array has:
+แต่ถ้าต้องการรอให้ทุก promise จบ ไม่ว่าจะสำเร็จหรือพัง — ใช้ `Promise.allSettled` แทน
 
-- `{status:"fulfilled", value:result}` for successful responses,
-- `{status:"rejected", reason:error}` for errors.
+ผลลัพธ์ที่ได้จะเป็นอาร์เรย์โดยแต่ละตัวมีรูปแบบแบบนี้:
 
-For example, we'd like to fetch the information about multiple users. Even if one request fails, we're still interested in the others.
+- `{status:"fulfilled", value:result}` สำหรับ response ที่สำเร็จ
+- `{status:"rejected", reason:error}` สำหรับ error
 
-Let's use `Promise.allSettled`:
+ลองนึกสถานการณ์นี้ — เราอยากดึงข้อมูล user หลายคน แม้ request บางตัวจะพัง เราก็ยังอยากได้ข้อมูลของตัวที่รอดมาล่ะ:
 
 ```js run
 let urls = [
@@ -160,7 +158,7 @@ Promise.allSettled(urls.map(url => fetch(url)))
   });
 ```
 
-The `results` in the line `(*)` above will be:
+ค่าของ `results` ที่บรรทัด `(*)` จะหน้าตาแบบนี้:
 ```js
 [
   {status: 'fulfilled', value: ...response...},
@@ -169,11 +167,11 @@ The `results` in the line `(*)` above will be:
 ]
 ```
 
-So for each promise we get its status and `value/error`.
+แต่ละ promise ได้ทั้ง status และ `value` หรือ `reason` กลับมาครบเลย — เห็นไหมว่าต่างกับ `Promise.all` ยังไง?
 
 ### Polyfill
 
-If the browser doesn't support `Promise.allSettled`, it's easy to polyfill:
+ถ้าเบราว์เซอร์ยังไม่รองรับ `Promise.allSettled` ก็เขียน polyfill เองได้ไม่ยาก:
 
 ```js
 if (!Promise.allSettled) {
@@ -188,23 +186,23 @@ if (!Promise.allSettled) {
 }
 ```
 
-In this code, `promises.map` takes input values, turns them into promises (just in case a non-promise was passed) with `p => Promise.resolve(p)`, and then adds `.then` handler to every one.
+โค้ดนี้ใช้ `promises.map` รับค่าเข้ามาแล้วแปลงเป็น promise ทุกตัว (กันกรณีที่ส่งค่าธรรมดาเข้ามา) ด้วย `p => Promise.resolve(p)` จากนั้นเพิ่ม `.then` handler ให้ทุกตัว
 
-That handler turns a successful result `value` into `{status:'fulfilled', value}`, and an error `reason` into `{status:'rejected', reason}`. That's exactly the format of `Promise.allSettled`.
+handler นั้นจะแปลง value ที่สำเร็จให้เป็น `{status:'fulfilled', value}` และแปลง reason ที่พังให้เป็น `{status:'rejected', reason}` — ตรงกับ format ของ `Promise.allSettled` พอดี
 
-Now we can use `Promise.allSettled` to get the results of *all* given promises, even if some of them reject.
+ทีนี้เราก็ใช้ `Promise.allSettled` ดึงผลลัพธ์จาก *ทุก* promise ที่ให้มาได้แล้ว ไม่ว่าบางตัวจะ reject หรือไม่
 
 ## Promise.race
 
-Similar to `Promise.all`, but waits only for the first settled promise and gets its result (or error).
+คล้ายกับ `Promise.all` แต่รอแค่ promise *ตัวแรก* ที่ settle แล้วเอาผลลัพธ์ (หรือ error) ของตัวนั้น
 
-The syntax is:
+เขียนแบบนี้:
 
 ```js
 let promise = Promise.race(iterable);
 ```
 
-For instance, here the result will be `1`:
+เช่น ผลลัพธ์ที่ได้คือ `1`:
 
 ```js run
 Promise.race([
@@ -214,20 +212,22 @@ Promise.race([
 ]).then(alert); // 1
 ```
 
-The first promise here was fastest, so it became the result. After the first settled promise "wins the race", all further results/errors are ignored.
+promise ตัวแรกเร็วที่สุดเลยกลายเป็นผลลัพธ์ หลังจาก promise แรก "ชนะการแข่ง" แล้ว ผลลัพธ์และ error ของตัวที่เหลือก็โดนมองข้ามหมดเลย
 
 
 ## Promise.any
 
-Similar to `Promise.race`, but waits only for the first fulfilled promise and gets its result. If all of the given promises are rejected, then the returned promise is rejected with [`AggregateError`](mdn:js/AggregateError) - a special error object that stores all promise errors in its `errors` property.
+`Promise.race` รอ promise แรกที่ settle ไม่ว่าจะสำเร็จหรือพัง แต่ `Promise.any` ใจดีกว่า — รอแค่ promise *ตัวแรก* ที่ *fulfill* แล้วข้ามตัวที่ reject ไปเรื่อยๆ
+
+ถ้า promise ทุกตัว reject หมดเลย จะได้ [`AggregateError`](mdn:js/AggregateError) กลับมา — เป็น error object พิเศษที่เก็บ error ของทุก promise ไว้ใน property `errors`
 
-The syntax is:
+เขียนแบบนี้:
 
 ```js
 let promise = Promise.any(iterable);
 ```
 
-For instance, here the result will be `1`:
+เช่น ผลลัพธ์ที่ได้คือ `1`:
 
 ```js run
 Promise.any([
@@ -237,9 +237,9 @@ Promise.any([
 ]).then(alert); // 1
 ```
 
-The first promise here was fastest, but it was rejected, so the second promise became the result. After the first fulfilled promise "wins the race", all further results are ignored.
+promise ตัวแรกเร็วที่สุดก็จริง แต่ reject เลยข้ามไป — promise ตัวที่สองกลายเป็นผลลัพธ์แทน หลังจาก promise แรกที่ fulfill "ชนะการแข่ง" ตัวที่เหลือก็โดนมองข้ามหมด
 
-Here's an example when all promises fail:
+ทีนี้ลองดูกรณีที่ promise ทุกตัวพังพร้อมกัน:
 
 ```js run
 Promise.any([
@@ -252,27 +252,27 @@ Promise.any([
 });
 ```
 
-As you can see, error objects for failed promises are available in the `errors` property of the `AggregateError` object.
+จะเห็นว่า error ของแต่ละ promise ที่พังไปจะเก็บอยู่ใน property `errors` ของ `AggregateError`
 
 ## Promise.resolve/reject
 
-Methods `Promise.resolve` and `Promise.reject` are rarely needed in modern code, because `async/await` syntax (we'll cover it [a bit later](info:async-await)) makes them somewhat obsolete.
+`Promise.resolve` กับ `Promise.reject` นั้นแทบไม่ค่อยต้องใช้ในโค้ดยุคใหม่แล้ว เพราะ `async/await` (จะพูดถึง[ในบทถัดไป](info:async-await)) ทำให้สองตัวนี้ไม่ค่อยจำเป็นอีก
 
-We cover them here for completeness and for those who can't use `async/await` for some reason.
+แต่เรายังอธิบายไว้ให้ครบ สำหรับคนที่ยังใช้ `async/await` ไม่ได้ด้วยเหตุผลบางอย่าง
 
 ### Promise.resolve
 
-`Promise.resolve(value)` creates a resolved promise with the result `value`.
+`Promise.resolve(value)` สร้าง promise ที่ resolve แล้วพร้อมค่า `value`
 
-Same as:
+เทียบเท่ากับ:
 
 ```js
 let promise = new Promise(resolve => resolve(value));
 ```
 
-The method is used for compatibility, when a function is expected to return a promise.
+ใช้เพื่อความเข้ากันได้ (compatibility) ในกรณีที่ฟังก์ชันจำเป็นต้องคืนค่าเป็น promise เสมอ
 
-For example, the `loadCached` function below fetches a URL and remembers (caches) its content. For future calls with the same URL it immediately gets the previous content from cache, but uses `Promise.resolve` to make a promise of it, so the returned value is always a promise:
+ดูตัวอย่าง — ฟังก์ชัน `loadCached` ด้านล่างดึงข้อมูลจาก URL แล้ว cache ไว้ ถ้าเรียกซ้ำด้วย URL เดิม จะดึงจาก cache ทันที แต่ยังต้องคืนค่าเป็น promise ด้วย เลยใช้ `Promise.resolve` ห่อค่านั้นไว้:
 
 ```js
 let cache = new Map();
@@ -293,31 +293,31 @@ function loadCached(url) {
 }
 ```
 
-We can write `loadCached(url).then(…)`, because the function is guaranteed to return a promise. We can always use `.then` after `loadCached`. That's the purpose of `Promise.resolve` in the line `(*)`.
+ด้วยวิธีนี้ เราเขียน `loadCached(url).then(…)` ได้เสมอ เพราะฟังก์ชันการันตีว่าจะคืนค่าเป็น promise ทุกกรณี — นั่นคือจุดประสงค์ของ `Promise.resolve` ที่บรรทัด `(*)`
 
 ### Promise.reject
 
-`Promise.reject(error)` creates a rejected promise with `error`.
+`Promise.reject(error)` สร้าง promise ที่ reject แล้วพร้อม `error`
 
-Same as:
+เทียบเท่ากับ:
 
 ```js
 let promise = new Promise((resolve, reject) => reject(error));
 ```
 
-In practice, this method is almost never used.
+แทบไม่ได้ใช้จริงๆ ในทางปฏิบัติ
 
-## Summary
+## สรุป
 
-There are 6 static methods of `Promise` class:
+`Promise` class มี static method อยู่ 6 ตัว:
 
-1. `Promise.all(promises)` -- waits for all promises to resolve and returns an array of their results. If any of the given promises rejects, it becomes the error of `Promise.all`, and all other results are ignored.
-2. `Promise.allSettled(promises)` (recently added method) -- waits for all promises to settle and returns their results as an array of objects with:
-    - `status`: `"fulfilled"` or `"rejected"`
-    - `value` (if fulfilled) or `reason` (if rejected).
-3. `Promise.race(promises)` -- waits for the first promise to settle, and its result/error becomes the outcome.
-4. `Promise.any(promises)` (recently added method) -- waits for the first promise to fulfill, and its result becomes the outcome. If all of the given promises are rejected, [`AggregateError`](mdn:js/AggregateError) becomes the error of `Promise.any`.
-5. `Promise.resolve(value)` -- makes a resolved promise with the given value.
-6. `Promise.reject(error)` -- makes a rejected promise with the given error.
+1. `Promise.all(promises)` -- รอให้ promise ทุกตัว resolve แล้วคืนอาร์เรย์ผลลัพธ์ ถ้าตัวไหน reject จะกลายเป็น error ของ `Promise.all` และผลลัพธ์อื่นทั้งหมดถูกทิ้ง
+2. `Promise.allSettled(promises)` (method ที่เพิ่งเพิ่มมา) -- รอให้ promise ทุกตัว settle แล้วคืนผลลัพธ์เป็นอาร์เรย์ของออบเจ็กต์ที่มี:
+    - `status`: `"fulfilled"` หรือ `"rejected"`
+    - `value` (ถ้า fulfilled) หรือ `reason` (ถ้า rejected)
+3. `Promise.race(promises)` -- รอแค่ promise ตัวแรกที่ settle ผลลัพธ์หรือ error ของตัวนั้นกลายเป็นผลลัพธ์ทั้งหมด
+4. `Promise.any(promises)` (method ที่เพิ่งเพิ่มมา) -- รอแค่ promise ตัวแรกที่ fulfill แล้วผลลัพธ์ของตัวนั้นกลายเป็นผลลัพธ์ทั้งหมด ถ้าทุกตัว reject จะได้ [`AggregateError`](mdn:js/AggregateError) กลับมา
+5. `Promise.resolve(value)` -- สร้าง promise ที่ resolve แล้วด้วยค่าที่กำหนด
+6. `Promise.reject(error)` -- สร้าง promise ที่ reject แล้วด้วย error ที่กำหนด
 
-Of all these, `Promise.all` is probably the most common in practice.
+บรรดา 6 ตัวนี้ `Promise.all` น่าจะเป็นตัวที่ใช้บ่อยที่สุดในทางปฏิบัติ
diff --git a/1-js/11-async/06-promisify/article.md b/1-js/11-async/06-promisify/article.md
index 855678e5b..389c8daf1 100644
--- a/1-js/11-async/06-promisify/article.md
+++ b/1-js/11-async/06-promisify/article.md
@@ -1,12 +1,12 @@
 # Promisification
 
-"Promisification" is a long word for a simple transformation. It's the conversion of a function that accepts a callback into a function that returns a promise.
+ชื่อมันยาวหน่อย แต่ concept ง่ายมาก — Promisification แค่แปลงฟังก์ชันที่รับ callback ให้กลายเป็นฟังก์ชันที่คืนค่าเป็น promise แทน
 
-Such transformations are often required in real-life, as many functions and libraries are callback-based. But promises are more convenient, so it makes sense to promisify them.
+ทำไมต้องทำแบบนี้ล่ะ? ก็เพราะโค้ดในโลกจริงเต็มไปด้วย library และฟังก์ชันที่ใช้ callback-based อยู่เยอะมาก แต่ promise ใช้งานได้สะดวกกว่า — เลยต้อง promisify มันซะ
 
-For better understanding, let's see an example.
+มาดูตัวอย่างกัน
 
-For instance, we have `loadScript(src, callback)` from the chapter <info:callbacks>.
+เราเคยเห็นฟังก์ชัน `loadScript(src, callback)` จากบท <info:callbacks> กันมาแล้ว:
 
 ```js run
 function loadScript(src, callback) {
@@ -19,19 +19,18 @@ function loadScript(src, callback) {
   document.head.append(script);
 }
 
-// usage:
+// การใช้งาน:
 // loadScript('path/script.js', (err, script) => {...})
 ```
 
-The function loads a script with the given `src`, and then calls `callback(err)` in case of an error, or `callback(null, script)` in case of successful loading. That's a widespread agreement for using callbacks, we saw it before.
+ฟังก์ชันนี้โหลด script จาก `src` ที่กำหนด แล้วเรียก `callback(err)` ถ้า error หรือ `callback(null, script)` ถ้าโหลดสำเร็จ — เป็น pattern มาตรฐานของ callback-based ที่เราคุ้นเคยกันดี
 
-Let's promisify it.
+ทีนี้ลอง promisify มันดู
 
-We'll make a new function `loadScriptPromise(src)`, that does the same (loads the script), but returns a promise instead of using callbacks.
+เราจะสร้างฟังก์ชันใหม่ชื่อ `loadScriptPromise(src)` ที่ทำหน้าที่เดิม (โหลด script) แต่คืนค่าเป็น promise แทน ไม่รับ callback อีกต่อไป
 
-In other words, we pass it only `src` (no `callback`) and get a promise in return, that resolves with `script` when the load is successful, and rejects with the error otherwise.
+พูดง่ายๆ คือ — รับแค่ `src` เข้ามา แล้วได้ promise กลับออกไป promise จะ resolve พร้อม `script` ถ้าโหลดสำเร็จ หรือ reject พร้อม error ถ้าโหลดไม่ได้
 
-Here it is:
 ```js
 let loadScriptPromise = function(src) {
   return new Promise((resolve, reject) => {
@@ -42,23 +41,23 @@ let loadScriptPromise = function(src) {
   });
 };
 
-// usage:
+// การใช้งาน:
 // loadScriptPromise('path/script.js').then(...)
 ```
 
-As we can see, the new function is a wrapper around the original `loadScript` function. It calls it providing its own callback that translates to promise `resolve/reject`.
+จะเห็นว่าฟังก์ชันใหม่นี้เป็นแค่ wrapper ครอบ `loadScript` เดิมอีกที — เรียก `loadScript` แล้วใส่ callback ของตัวเองเข้าไป โดย callback นั้นจะแปลงผลลัพธ์ไปเป็น `resolve/reject` ของ promise
 
-Now `loadScriptPromise` fits well in promise-based code. If we like promises more than callbacks (and soon we'll see more reasons for that), then we will use it instead.
+`loadScriptPromise` เข้ากันได้ดีกับโค้ดแบบ promise เลย ถ้าชอบ promise มากกว่า callback (และเดี๋ยวจะเห็นเหตุผลอีกมากในบทต่อๆ ไป) เปลี่ยนมาใช้ตัวนี้ได้เลย
 
-In practice we may need to promisify more than one function, so it makes sense to use a helper.
+แต่ในชีวิตจริง เราคงต้อง promisify หลายฟังก์ชัน — เลยควรทำ helper ขึ้นมาแทน
 
-We'll call it `promisify(f)`: it accepts a to-promisify function `f` and returns a wrapper function.
+เรียกมันว่า `promisify(f)`: รับฟังก์ชัน `f` ที่อยากแปลง แล้วคืน wrapper function กลับมา
 
 ```js
 function promisify(f) {
-  return function (...args) { // return a wrapper-function (*)
+  return function (...args) { // คืน wrapper-function กลับไป (*)
     return new Promise((resolve, reject) => {
-      function callback(err, result) { // our custom callback for f (**)
+      function callback(err, result) { // callback ที่เราสร้างเองสำหรับ f (**)
         if (err) {
           reject(err);
         } else {
@@ -66,41 +65,41 @@ function promisify(f) {
         }
       }
 
-      args.push(callback); // append our custom callback to the end of f arguments
+      args.push(callback); // เอา callback ของเราต่อท้ายอาร์กิวเมนต์ของ f
 
-      f.call(this, ...args); // call the original function
+      f.call(this, ...args); // เรียกฟังก์ชันต้นฉบับ
     });
   };
 }
 
-// usage:
+// การใช้งาน:
 let loadScriptPromise = promisify(loadScript);
 loadScriptPromise(...).then(...);
 ```
 
-The code may look a bit complex, but it's essentially the same that we wrote above, while promisifying `loadScript` function.
+โค้ดอาจดูซับซ้อนหน่อย แต่จริงๆ แล้วทำเหมือนกับที่เราเขียน `loadScriptPromise` ด้านบนเลย เพียงแต่ครอบคลุมฟังก์ชันอื่นๆ ได้ทั่วไปมากกว่า
 
-A call to `promisify(f)` returns a wrapper around `f` `(*)`. That wrapper returns a promise and forwards the call to the original `f`, tracking the result in the custom callback `(**)`.
+ทำงานยังไงล่ะ? `promisify(f)` คืน wrapper รอบ `f` `(*)` ที่พอถูกเรียก จะสร้าง promise ขึ้น แล้ว forward การเรียกไปยัง `f` ต้นฉบับ โดยรับผลลัพธ์ผ่าน custom callback `(**)`
 
-Here, `promisify` assumes that the original function expects a callback with exactly two arguments `(err, result)`. That's what we encounter most often. Then our custom callback is in exactly the right format, and `promisify` works great for such a case.
+`promisify` ตัวนี้สมมติไว้ว่า — `f` ต้นฉบับรับ callback ที่มีอาร์กิวเมนต์แค่ 2 ตัวคือ `(err, result)` ซึ่งเป็น pattern ที่เจอบ่อยที่สุด ถ้าเจอแบบนี้ก็โอเคเลย
 
-But what if the original `f` expects a callback with more arguments `callback(err, res1, res2, ...)`?
+แต่ถ้า `f` ต้นฉบับส่งอาร์กิวเมนต์มากกว่านั้น เช่น `callback(err, res1, res2, ...)` ล่ะ?
 
-We can improve our helper. Let's make a more advanced version of `promisify`.
+ก็ต้องอัปเกรด helper นิดนึง มาทำ version ที่ดีกว่าเดิม:
 
-- When called as `promisify(f)` it should work similar to the version above.
-- When called as `promisify(f, true)`, it should return the promise that resolves with the array of callback results. That's exactly for callbacks with many arguments.
+- เรียก `promisify(f)` แบบปกติ → ทำงานเหมือนเดิม
+- เรียก `promisify(f, true)` → คืน promise ที่ resolve พร้อม *อาร์เรย์* ของผลลัพธ์ทั้งหมด เหมาะกับ callback ที่ส่งค่ากลับมาหลายตัว
 
 ```js
-// promisify(f, true) to get array of results
+// promisify(f, true) เพื่อรับผลลัพธ์เป็นอาร์เรย์
 function promisify(f, manyArgs = false) {
   return function (...args) {
     return new Promise((resolve, reject) => {
-      function *!*callback(err, ...results*/!*) { // our custom callback for f
+      function *!*callback(err, ...results*/!*) { // callback ที่เราสร้างเองสำหรับ f
         if (err) {
           reject(err);
         } else {
-          // resolve with all callback results if manyArgs is specified
+          // resolve ด้วยผลลัพธ์ทั้งหมด ถ้ากำหนด manyArgs ไว้
           *!*resolve(manyArgs ? results : results[0]);*/!*
         }
       }
@@ -112,21 +111,21 @@ function promisify(f, manyArgs = false) {
   };
 }
 
-// usage:
+// การใช้งาน:
 f = promisify(f, true);
 f(...).then(arrayOfResults => ..., err => ...);
 ```
 
-As you can see it's essentially the same as above, but `resolve` is called with only one or all arguments depending on whether `manyArgs` is truthy.
+โค้ดแทบไม่ต่างกันเลย ต่างแค่ตอน resolve — ถ้า `manyArgs` เป็น true จะ resolve ด้วย `results` ทั้งอาร์เรย์ ถ้าไม่ก็รับแค่ `results[0]` ตัวเดียว
 
-For more exotic callback formats, like those without `err` at all: `callback(result)`, we can promisify such functions manually without using the helper.
+สำหรับ callback แปลกๆ พิเศษ เช่น ไม่มี `err` เลย อย่าง `callback(result)` — แบบนี้ก็ promisify เองด้วยมือได้โดยไม่ต้องพึ่ง helper
 
-There are also modules with a bit more flexible promisification functions, e.g. [es6-promisify](https://github.com/digitaldesignlabs/es6-promisify). In Node.js, there's a built-in `util.promisify` function for that.
+แถมยังมี module ภายนอกที่ทำ promisification ได้ยืดหยุ่นกว่านี้อีก เช่น [es6-promisify](https://github.com/digitaldesignlabs/es6-promisify) และถ้าใช้ Node.js ก็มีฟังก์ชัน `util.promisify` ติดมาให้เลย ไม่ต้องติดตั้งเพิ่ม
 
 ```smart
-Promisification is a great approach, especially when you use `async/await` (covered later in the chapter <info:async-await>), but not a total replacement for callbacks.
+Promisification เป็นท่าที่ดีมาก โดยเฉพาะตอนใช้ `async/await` (ดูเพิ่มเติมในบท <info:async-await>) แต่ไม่ได้แทน callback ได้ทุกกรณีนะ
 
-Remember, a promise may have only one result, but a callback may technically be called many times.
+อย่าลืมว่า — promise มีผลลัพธ์ได้แค่ครั้งเดียว แต่ callback เรียกซ้ำกี่รอบก็ได้
 
-So promisification is only meant for functions that call the callback once. Further calls will be ignored.
+เพราะฉะนั้น promisification เหมาะกับฟังก์ชันที่เรียก callback แค่ครั้งเดียวเท่านั้น ถ้าเรียกซ้ำ ครั้งหลังๆ promise จะเพิกเฉยไป
 ```
diff --git a/1-js/11-async/07-microtask-queue/article.md b/1-js/11-async/07-microtask-queue/article.md
index 014dd93c0..ad40b288c 100644
--- a/1-js/11-async/07-microtask-queue/article.md
+++ b/1-js/11-async/07-microtask-queue/article.md
@@ -1,48 +1,54 @@
 
 # Microtasks
 
-Promise handlers `.then`/`.catch`/`.finally` are always asynchronous.
+handler ของ Promise อย่าง `.then`/`.catch`/`.finally` นั้น asynchronous เสมอ
 
-Even when a Promise is immediately resolved, the code on the lines *below* `.then`/`.catch`/`.finally` will still execute before these handlers.
+แม้ promise จะ resolve ทันทีตั้งแต่ต้น โค้ดที่อยู่ *ใต้* `.then`/`.catch`/`.finally` ก็ยังรันก่อน handler เสมอ
 
-Here's a demo:
+ลองดูตัวอย่างนี้:
 
 ```js run
 let promise = Promise.resolve();
 
 promise.then(() => alert("promise done!"));
 
-alert("code finished"); // this alert shows first
+alert("code finished"); // alert นี้โผล่ขึ้นมาก่อน
 ```
 
-If you run it, you see `code finished` first, and then `promise done!`.
+รันแล้วจะเห็น `code finished` ขึ้นมาก่อน แล้วค่อยตามมาด้วย `promise done!`
 
-That's strange, because the promise is definitely done from the beginning.
+แปลกดีใช่ไหม? ก็ promise นี้ resolve ไปแล้วตั้งแต่แรกนี่
 
-Why did the `.then` trigger afterwards? What's going on?
+แล้วทำไม `.then` ถึงยังรอก่อน? เกิดอะไรขึ้นล่ะ?
 
-## Microtasks queue
+## คิวของ Microtask
 
-Asynchronous tasks need proper management. For that, the ECMA standard specifies an internal queue `PromiseJobs`, more often referred to as the "microtask queue" (V8 term).
+งาน asynchronous ต้องการระบบจัดการที่ดีพอ มาตรฐาน ECMA จึงกำหนดให้มีคิว internal ชื่อ `PromiseJobs`
 
-As stated in the [specification](https://tc39.github.io/ecma262/#sec-jobs-and-job-queues):
+คนส่วนใหญ่เรียกกันสั้นๆ ว่า "microtask queue" — คำที่ใช้กันใน V8
 
-- The queue is first-in-first-out: tasks enqueued first are run first.
-- Execution of a task is initiated only when nothing else is running.
+ตาม [specification](https://tc39.github.io/ecma262/#sec-jobs-and-job-queues) บอกไว้ว่า:
 
-Or, to put it more simply, when a promise is ready, its `.then/catch/finally` handlers are put into the queue; they are not executed yet. When the JavaScript engine becomes free from the current code, it takes a task from the queue and executes it.
+- คิวเป็นแบบ first-in-first-out: งานที่เข้าคิวก่อนก็รันก่อน
+- งานชิ้นหนึ่งจะเริ่มรันได้ก็ต่อเมื่อไม่มีอะไรกำลังรันอยู่
 
-That's why "code finished" in the example above shows first.
+พูดง่ายๆ คือ พอ promise พร้อมแล้ว handler `.then/catch/finally` จะโดนโยนเข้าคิว — ยังไม่รันทันที
+
+รอจนกว่า JavaScript engine จะว่างจากโค้ดปัจจุบันก่อน แล้วถึงค่อยดึงงานจากคิวมารัน
+
+เลยเป็นเหตุผลว่าทำไม "code finished" ถึงโผล่ขึ้นมาก่อนในตัวอย่างข้างบน
 
 ![](promiseQueue.svg)
 
-Promise handlers always go through this internal queue.
+handler ของ promise ทุกตัวต้องผ่านคิว internal นี้เสมอ
 
-If there's a chain with multiple `.then/catch/finally`, then every one of them is executed asynchronously. That is, it first gets queued, then executed when the current code is complete and previously queued handlers are finished.
+ถ้ามี chain ที่ต่อ `.then/catch/finally` หลายตัว แต่ละตัวก็รัน asynchronous เหมือนกัน
 
-**What if the order matters for us? How can we make `code finished` appear after `promise done`?**
+เข้าคิวก่อน แล้วรอจนโค้ดปัจจุบันเสร็จและ handler ก่อนหน้ารันครบแล้วค่อยรัน
 
-Easy, just put it into the queue with `.then`:
+**แล้วถ้าเราต้องการให้ลำดับถูกต้องล่ะ? จะให้ `code finished` ขึ้นหลัง `promise done` ได้ยังไง?**
+
+ง่ายมาก — โยนเข้าคิวด้วย `.then` เลย:
 
 ```js run
 Promise.resolve()
@@ -50,17 +56,17 @@ Promise.resolve()
   .then(() => alert("code finished"));
 ```
 
-Now the order is as intended.
+ได้ลำดับตามที่ต้องการเลย
 
 ## Unhandled rejection
 
-Remember the `unhandledrejection` event from the article <info:promise-error-handling>?
+ยังจำ event `unhandledrejection` จากบทความ <info:promise-error-handling> ได้ไหม?
 
-Now we can see exactly how JavaScript finds out that there was an unhandled rejection.
+ทีนี้เราเข้าใจแล้วว่า JavaScript รู้ได้ยังไงว่ามี rejection ที่ไม่มีใครจัดการ
 
-**An "unhandled rejection" occurs when a promise error is not handled at the end of the microtask queue.**
+**"unhandled rejection" เกิดขึ้นเมื่อ error ใน promise ไม่ถูกจัดการก่อนที่คิว microtask จะหมด**
 
-Normally, if we expect an error, we add `.catch` to the promise chain to handle it:
+ปกติถ้าเราคาดว่าจะมี error ก็แค่ต่อ `.catch` เข้าไปใน promise chain:
 
 ```js run
 let promise = Promise.reject(new Error("Promise Failed!"));
@@ -68,11 +74,11 @@ let promise = Promise.reject(new Error("Promise Failed!"));
 promise.catch(err => alert('caught'));
 */!*
 
-// doesn't run: error handled
+// ไม่รัน: error ถูกจัดการแล้ว
 window.addEventListener('unhandledrejection', event => alert(event.reason));
 ```
 
-But if we forget to add `.catch`, then, after the microtask queue is empty, the engine triggers the event:
+แต่ถ้าลืมต่อ `.catch` เอาไว้ พอคิว microtask ว่าง engine จะยิง event นั้นขึ้นมา:
 
 ```js run
 let promise = Promise.reject(new Error("Promise Failed!"));
@@ -81,7 +87,7 @@ let promise = Promise.reject(new Error("Promise Failed!"));
 window.addEventListener('unhandledrejection', event => alert(event.reason));
 ```
 
-What if we handle the error later? Like this:
+แล้วถ้าเราจัดการ error ทีหลังล่ะ? แบบนี้:
 
 ```js run
 let promise = Promise.reject(new Error("Promise Failed!"));
@@ -93,20 +99,22 @@ setTimeout(() => promise.catch(err => alert('caught')), 1000);
 window.addEventListener('unhandledrejection', event => alert(event.reason));
 ```
 
-Now, if we run it, we'll see `Promise Failed!` first and then `caught`.
+รันแล้วจะเห็น `Promise Failed!` ขึ้นก่อน แล้วค่อยตามด้วย `caught`
+
+ถ้าไม่รู้เรื่องคิว microtask ก็คงงงว่า "ทำไม `unhandledrejection` ถึงยิง? เราจัดการ error แล้วนี่!"
 
-If we didn't know about the microtasks queue, we could wonder: "Why did `unhandledrejection` handler run? We did catch and handle the error!"
+แต่ตอนนี้เราเข้าใจแล้ว — `unhandledrejection` จะยิงขึ้นมาตอนที่คิว microtask ว่างหมด
 
-But now we understand that `unhandledrejection` is generated when the microtask queue is complete: the engine examines promises and, if any of them is in the "rejected" state, then the event triggers.
+engine จะสแกน promise ทั้งหมด ถ้าเจออันไหนยังอยู่ในสถานะ "rejected" ก็ยิง event ทันที
 
-In the example above, `.catch` added by `setTimeout` also triggers. But it does so later, after `unhandledrejection` has already occurred, so it doesn't change anything.
+ในตัวอย่างข้างบน `.catch` ที่ใส่ผ่าน `setTimeout` ก็รันได้นะ — แต่รันทีหลัง ตอน `unhandledrejection` เกิดขึ้นไปแล้ว เลยไม่เปลี่ยนอะไรทั้งนั้น
 
-## Summary
+## สรุป
 
-Promise handling is always asynchronous, as all promise actions pass through the internal "promise jobs" queue, also called "microtask queue" (V8 term).
+การจัดการ promise นั้น asynchronous เสมอ — ทุก action ของ promise ต้องผ่านคิว internal "promise jobs" หรือที่เรียกว่า "microtask queue" (คำของ V8)
 
-So `.then/catch/finally` handlers are always called after the current code is finished.
+เลยแปลว่า handler `.then/catch/finally` จะรันหลังจากโค้ดปัจจุบันเสร็จสิ้นเสมอ
 
-If we need to guarantee that a piece of code is executed after `.then/catch/finally`, we can add it into a chained `.then` call.
+ถ้าต้องการให้โค้ดบางส่วนรันหลัง `.then/catch/finally` แน่นอน ก็ต่อ `.then` เพิ่มเข้าไปใน chain ได้เลย
 
-In most Javascript engines, including browsers and Node.js, the concept of microtasks is closely tied with the "event loop" and "macrotasks". As these have no direct relation to promises, they are covered in another part of the tutorial, in the article <info:event-loop>.
+ใน JavaScript engine ส่วนใหญ่ ทั้งเบราว์เซอร์และ Node.js แนวคิดของ microtask ผูกติดกับ "event loop" และ "macrotasks" อย่างแนบแน่น แต่เรื่องพวกนั้นไม่ได้เกี่ยวกับ promise โดยตรง เราไปคุยกันต่อในบทความ <info:event-loop>
diff --git a/1-js/11-async/08-async-await/01-rewrite-async/solution.md b/1-js/11-async/08-async-await/01-rewrite-async/solution.md
index 3337ef3c4..4167ac78f 100644
--- a/1-js/11-async/08-async-await/01-rewrite-async/solution.md
+++ b/1-js/11-async/08-async-await/01-rewrite-async/solution.md
@@ -1,5 +1,5 @@
 
-The notes are below the code:
+โน้ตอธิบายอยู่ใต้โค้ด:
 
 ```js run
 async function loadJson(url) { // (1)
@@ -17,11 +17,11 @@ loadJson('https://javascript.info/no-such-user.json')
   .catch(alert); // Error: 404 (4)
 ```
 
-Notes:
+โน้ต:
 
-1. The function `loadJson` becomes `async`.
-2. All `.then` inside are replaced with `await`.
-3. We can `return response.json()` instead of awaiting for it, like this:
+1. ฟังก์ชัน `loadJson` กลายเป็น `async`
+2. แทนที่ `.then` ทั้งหมดด้วย `await`
+3. เขียน `return response.json()` แทนการ await ก็ได้ แบบนี้:
 
     ```js
     if (response.status == 200) {
@@ -29,5 +29,5 @@ Notes:
     }
     ```
 
-    Then the outer code would have to `await` for that promise to resolve. In our case it doesn't matter.
-4. The error thrown from `loadJson` is handled by `.catch`. We can't use `await loadJson(…)` there, because we're not in an `async` function.
+    โค้ดด้านนอกก็ต้อง `await` promise นั้นเองอยู่ดี ในกรณีนี้ผลไม่ต่างกัน
+4. error ที่โยนออกมาจาก `loadJson` ถูกจัดการด้วย `.catch` ที่ด้านนอก ใช้ `await loadJson(…)` ตรงนั้นไม่ได้ เพราะไม่ได้อยู่ใน `async` function
diff --git a/1-js/11-async/08-async-await/01-rewrite-async/task.md b/1-js/11-async/08-async-await/01-rewrite-async/task.md
index 0c31737da..bee2fd751 100644
--- a/1-js/11-async/08-async-await/01-rewrite-async/task.md
+++ b/1-js/11-async/08-async-await/01-rewrite-async/task.md
@@ -1,7 +1,7 @@
 
-# Rewrite using async/await
+# เขียนใหม่ด้วย async/await
 
-Rewrite this example code from the chapter <info:promise-chaining> using `async/await` instead of `.then/catch`:
+เขียนโค้ดตัวอย่างนี้จากบท <info:promise-chaining> ใหม่โดยใช้ `async/await` แทน `.then/catch`:
 
 ```js run
 function loadJson(url) {
diff --git a/1-js/11-async/08-async-await/02-rewrite-async-2/solution.md b/1-js/11-async/08-async-await/02-rewrite-async-2/solution.md
index aa462dbf7..3368706cc 100644
--- a/1-js/11-async/08-async-await/02-rewrite-async-2/solution.md
+++ b/1-js/11-async/08-async-await/02-rewrite-async-2/solution.md
@@ -1,5 +1,5 @@
 
-There are no tricks here. Just replace `.catch` with `try..catch` inside `demoGithubUser` and add `async/await` where needed:
+ไม่มีเทคนิคพิเศษอะไรเลย แค่เปลี่ยน `.catch` เป็น `try..catch` ใน `demoGithubUser` แล้วใส่ `async/await` ในจุดที่จำเป็น:
 
 ```js run
 class HttpError extends Error {
@@ -19,29 +19,29 @@ async function loadJson(url) {
   }
 }
 
-// Ask for a user name until github returns a valid user
+// ถามชื่อผู้ใช้ซ้ำจนกว่า github จะคืน user ที่ถูกต้อง
 async function demoGithubUser() {
 
   let user;
   while(true) {
-    let name = prompt("Enter a name?", "iliakan");
+    let name = prompt("ใส่ชื่อ?", "iliakan");
 
     try {
       user = await loadJson(`https://api.github.com/users/${name}`);
-      break; // no error, exit loop
+      break; // ไม่มี error ออกจาก loop
     } catch(err) {
       if (err instanceof HttpError && err.response.status == 404) {
-        // loop continues after the alert
-        alert("No such user, please reenter.");
+        // loop ทำงานต่อหลัง alert
+        alert("ไม่พบผู้ใช้นี้ กรุณาลองใหม่อีกครั้ง");
       } else {
-        // unknown error, rethrow
+        // error ที่ไม่รู้จัก โยนต่อออกไป
         throw err;
       }
-    }      
+    }
   }
 
 
-  alert(`Full name: ${user.name}.`);
+  alert(`ชื่อเต็ม: ${user.name}.`);
   return user;
 }
 
diff --git a/1-js/11-async/08-async-await/02-rewrite-async-2/task.md b/1-js/11-async/08-async-await/02-rewrite-async-2/task.md
index 13d625d2a..5936e26b5 100644
--- a/1-js/11-async/08-async-await/02-rewrite-async-2/task.md
+++ b/1-js/11-async/08-async-await/02-rewrite-async-2/task.md
@@ -1,9 +1,9 @@
 
-# Rewrite "rethrow" with async/await
+# เขียน "rethrow" ใหม่ด้วย async/await
 
-Below you can find the "rethrow" example. Rewrite it using `async/await` instead of `.then/catch`.
+ด้านล่างคือตัวอย่าง "rethrow" เขียนมันใหม่โดยใช้ `async/await` แทน `.then/catch`
 
-And get rid of the recursion in favour of a loop in `demoGithubUser`: with `async/await` that becomes easy to do.
+แถมยังให้ตัดการ recursion ออก แล้วเปลี่ยนเป็น loop ใน `demoGithubUser` แทน — ด้วย `async/await` ทำได้ง่ายมาก
 
 ```js run
 class HttpError extends Error {
@@ -25,18 +25,18 @@ function loadJson(url) {
     });
 }
 
-// Ask for a user name until github returns a valid user
+// ถามชื่อผู้ใช้ซ้ำจนกว่า github จะคืน user ที่ถูกต้อง
 function demoGithubUser() {
-  let name = prompt("Enter a name?", "iliakan");
+  let name = prompt("ใส่ชื่อ?", "iliakan");
 
   return loadJson(`https://api.github.com/users/${name}`)
     .then(user => {
-      alert(`Full name: ${user.name}.`);
+      alert(`ชื่อเต็ม: ${user.name}.`);
       return user;
     })
     .catch(err => {
       if (err instanceof HttpError && err.response.status == 404) {
-        alert("No such user, please reenter.");
+        alert("ไม่พบผู้ใช้นี้ กรุณาลองใหม่อีกครั้ง");
         return demoGithubUser();
       } else {
         throw err;
diff --git a/1-js/11-async/08-async-await/03-async-from-regular/solution.md b/1-js/11-async/08-async-await/03-async-from-regular/solution.md
index 7e2ab597e..0edc119a8 100644
--- a/1-js/11-async/08-async-await/03-async-from-regular/solution.md
+++ b/1-js/11-async/08-async-await/03-async-from-regular/solution.md
@@ -1,7 +1,8 @@
 
-That's the case when knowing how it works inside is helpful.
+ถ้าเข้าใจว่ามันทำงานยังไงข้างใน คำตอบมาเลย
+
+แค่มองการเรียก `async` function เป็น promise แล้วต่อ `.then` ต่อท้าย:
 
-Just treat `async` call as promise and attach `.then` to it:
 ```js run
 async function wait() {
   await new Promise(resolve => setTimeout(resolve, 1000));
@@ -10,7 +11,7 @@ async function wait() {
 }
 
 function f() {
-  // shows 10 after 1 second
+  // แสดง 10 หลังจาก 1 วินาที
 *!*
   wait().then(result => alert(result));
 */!*
diff --git a/1-js/11-async/08-async-await/03-async-from-regular/task.md b/1-js/11-async/08-async-await/03-async-from-regular/task.md
index ca7c186ff..dfdb6a3dd 100644
--- a/1-js/11-async/08-async-await/03-async-from-regular/task.md
+++ b/1-js/11-async/08-async-await/03-async-from-regular/task.md
@@ -1,7 +1,7 @@
 
-# Call async from non-async
+# เรียก async จากฟังก์ชันปกติ
 
-We have a "regular" function called `f`. How can you call the `async` function `wait()` and use its result inside of `f`?
+มีฟังก์ชัน "ปกติ" ชื่อ `f` อยู่ จะเรียกใช้ `async` function `wait()` และนำผลลัพธ์มาใช้ใน `f` ได้ยังไง?
 
 ```js
 async function wait() {
@@ -11,10 +11,10 @@ async function wait() {
 }
 
 function f() {
-  // ...what should you write here?
-  // we need to call async wait() and wait to get 10
-  // remember, we can't use "await"
+  // ...เขียนอะไรที่นี่ดี?
+  // เราต้องเรียก async wait() แล้วรอผลลัพธ์ที่เป็น 10
+  // จำไว้ว่าใช้ "await" ไม่ได้
 }
 ```
 
-P.S. The task is technically very simple, but the question is quite common for developers new to async/await.
+P.S. โจทย์นี้ง่ายมากในแง่เทคนิค แต่เป็นคำถามที่คนที่เพิ่งเริ่มเรียน async/await ถามบ่อยมาก
diff --git a/1-js/11-async/08-async-await/04-promise-all-failure/solution.md b/1-js/11-async/08-async-await/04-promise-all-failure/solution.md
index 9fda8e000..a0ab1c446 100644
--- a/1-js/11-async/08-async-await/04-promise-all-failure/solution.md
+++ b/1-js/11-async/08-async-await/04-promise-all-failure/solution.md
@@ -1,52 +1,54 @@
 
-The root of the problem is that `Promise.all` immediately rejects when one of its promises rejects, but it do nothing to cancel the other promises.
+ต้นตอของปัญหาคือ `Promise.all` reject ทันทีเมื่อ promise ตัวใดตัวหนึ่ง reject แต่ไม่ได้ยกเลิก promise ตัวอื่นแต่อย่างใด
 
-In our case, the second query fails, so `Promise.all` rejects, and the `try...catch` block catches this error.Meanwhile, other promises are *not affected* - they independently continue their execution. In our case, the third query throws an error of its own after a bit of time. And that error is never caught, we can see it in the console.
+ในกรณีนี้ query ที่สองพัง `Promise.all` เลย reject แล้วบล็อก `try...catch` ดักจับ error นั้นได้
 
-The problem is especially dangerous in server-side environments, such as Node.js, when an uncaught error may cause the process to crash.
+แต่ขณะเดียวกัน promise ที่เหลือ *ยังไม่ได้รับผลกระทบ* — ยังทำงานต่อแบบอิสระ query ที่สามโยน error ของตัวเองออกมาหลังจากนั้นไม่นาน และ error นั้นไม่มีใครดักจับ เราเลยเห็นมันใน console
 
-How to fix it?
+ปัญหานี้อันตรายโดยเฉพาะในฝั่ง server อย่าง Node.js เพราะ uncaught error อาจทำให้ process พังได้เลย
 
-An ideal solution would be to cancel all unfinished queries when one of them fails. This way we avoid any potential errors.
+แก้ยังไงดี?
 
-However, the bad news is that service calls (such as `database.query`) are often implemented by a 3rd-party library which doesn't support cancellation. Then there's no way to cancel a call.
+ถ้าแก้ได้ดีที่สุดคือยกเลิก query ที่ยังค้างอยู่ทั้งหมดเมื่อ query ใดหนึ่งพัง วิธีนี้กำจัดโอกาสเกิด error ที่หลุดออกไปได้
 
-As an alternative, we can write our own wrapper function around `Promise.all` which adds a custom `then/catch` handler to each promise to track them: results are gathered and, if an error occurs, all subsequent promises are ignored.
+แต่ข่าวร้ายคือ service call อย่าง `database.query` มักมาจาก library ของ third-party ที่ไม่รองรับการยกเลิก เลยไม่มีทางยกเลิกการเรียกนั้นได้
+
+ทางเลือกอื่นคือเขียน wrapper function รอบ `Promise.all` ของเราเองที่เพิ่ม `then/catch` handler ให้กับแต่ละ promise เพื่อติดตามผล: รวบรวมผลลัพธ์ไว้ และถ้าเกิด error ขึ้น promise ที่เหลือก็จะถูกข้ามไป
 
 ```js
 function customPromiseAll(promises) {
   return new Promise((resolve, reject) => {
     const results = [];
     let resultsCount = 0;
-    let hasError = false; // we'll set it to true upon first error
+    let hasError = false; // จะเซ็ตเป็น true เมื่อเจอ error ครั้งแรก
 
     promises.forEach((promise, index) => {
       promise
         .then(result => {
-          if (hasError) return; // ignore the promise if already errored
+          if (hasError) return; // ละเว้น promise ถ้าเกิด error ไปแล้ว
           results[index] = result;
           resultsCount++;
           if (resultsCount === promises.length) {
-            resolve(results); // when all results are ready - successs
+            resolve(results); // เมื่อได้ผลลัพธ์ครบทุกตัว — สำเร็จ
           }
         })
         .catch(error => {
-          if (hasError) return; // ignore the promise if already errored
-          hasError = true; // wops, error!
-          reject(error); // fail with rejection
+          if (hasError) return; // ละเว้น promise ถ้าเกิด error ไปแล้ว
+          hasError = true; // โอ้โห มี error!
+          reject(error); // reject ด้วย error นั้น
         });
     });
   });
 }
 ```
 
-This approach has an issue of its own - it's often undesirable to `disconnect()` when queries are still in the process.
+แนวทางนี้ก็มีปัญหาของตัวเอง — มักไม่ต้องการให้ `disconnect()` ในขณะที่ query ยังค้างอยู่
 
-It may be important that all queries complete, especially if some of them make important updates.
+บางทีสำคัญมากที่ต้องให้ query ทุกตัวทำงานเสร็จ โดยเฉพาะถ้ามี query ที่อัปเดตข้อมูลสำคัญ
 
-So we should wait until all promises are settled before going further with the execution and eventually disconnecting.
+เลยควรรอจนกว่า promise ทั้งหมดจะ settle ก่อน ค่อยทำงานต่อแล้วค่อย disconnect
 
-Here's another implementation. It behaves similar to `Promise.all` - also resolves with the first error, but waits until all promises are settled.
+นี่คือ implementation อีกแบบ ทำงานคล้าย `Promise.all` — reject ด้วย error แรก แต่รอจนกว่า promise ทั้งหมดจะ settle ก่อน:
 
 ```js
 function customPromiseAllWait(promises) {
@@ -80,16 +82,16 @@ function customPromiseAllWait(promises) {
 }
 ```
 
-Now `await customPromiseAllWait(...)` will stall the execution until all queries are processed.
+ทีนี้ `await customPromiseAllWait(...)` จะหยุดรอจนกว่า query ทุกตัวจะประมวลผลเสร็จ
 
-This is a more reliable approach, as it guarantees a predictable execution flow.
+เป็นแนวทางที่เชื่อถือได้มากกว่า เพราะรับประกัน flow การทำงานที่คาดเดาได้
 
-Lastly, if we'd like to process all errors, we can use either use `Promise.allSettled` or write a wrapper around it to gathers all errors in a single [AggregateError](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/AggregateError) object and rejects with it.
+สุดท้าย ถ้าต้องการจัดการ error ทั้งหมด ใช้ `Promise.allSettled` หรือเขียน wrapper รอบมันเพื่อรวบรวม error ทั้งหมดไว้ใน [AggregateError](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/AggregateError) ตัวเดียวแล้ว reject ด้วยมัน:
 
 ```js
-// wait for all promises to settle
-// return results if no errors
-// throw AggregateError with all errors if any
+// รอให้ promise ทั้งหมด settle
+// คืนผลลัพธ์ถ้าไม่มี error
+// โยน AggregateError พร้อม error ทั้งหมดถ้ามี
 function allOrAggregateError(promises) {
   return Promise.allSettled(promises).then(results => {
     const errors = [];
diff --git a/1-js/11-async/08-async-await/04-promise-all-failure/task.md b/1-js/11-async/08-async-await/04-promise-all-failure/task.md
index 74571c43e..ec9715498 100644
--- a/1-js/11-async/08-async-await/04-promise-all-failure/task.md
+++ b/1-js/11-async/08-async-await/04-promise-all-failure/task.md
@@ -1,17 +1,17 @@
 
-# Dangerous Promise.all
+# อันตรายของ Promise.all
 
-`Promise.all` is a great way to parallelize multiple operations. It's especially useful when we need to make parallel requests to multiple services.
+`Promise.all` เป็นท่าที่ดีมากสำหรับรัน operation หลายอย่างพร้อมกัน โดยเฉพาะเวลาต้องส่ง request ไปหลาย service พร้อมกัน
 
-However, there's a hidden danger. We'll see an example in this task and explore how to avoid it.
+แต่มันมีกับดักซ่อนอยู่ โจทย์นี้จะให้เห็นตัวอย่างและแนวทางแก้ไข
 
-Let's say we have a connection to a remote service, such as a database.
+สมมติเราเชื่อมต่อกับ remote service อย่างเช่น database
 
-There're two functions: `connect()` and `disconnect()`.
+มีสองฟังก์ชัน: `connect()` และ `disconnect()`
 
-When connected, we can send requests using `database.query(...)` - an async function which usually returns the result but also may throw an error.
+เมื่อเชื่อมต่อแล้ว ส่ง request ได้ด้วย `database.query(...)` — เป็น async function ที่ปกติจะคืนผลลัพธ์ แต่ก็อาจโยน error ได้
 
-Here's a simple implementation:
+implementation อย่างง่ายหน้าตาแบบนี้:
 
 ```js
 let database;
@@ -28,21 +28,21 @@ function disconnect() {
   database = null;
 }
 
-// intended usage:
+// วิธีใช้ที่ตั้งใจไว้:
 // connect()
 // ...
-// database.query(true) to emulate a successful call
-// database.query(false) to emulate a failed call
+// database.query(true) เพื่อจำลองการเรียกที่สำเร็จ
+// database.query(false) เพื่อจำลองการเรียกที่พัง
 // ...
 // disconnect()
 ```
 
-Now here's the problem.
+ทีนี้มาดูปัญหา
 
-We wrote the code to connect and send 3 queries in parallel (all of them take different time, e.g. 100, 200 and 300ms), then disconnect:
+เราเขียนโค้ดเชื่อมต่อแล้วส่ง 3 query พร้อมกัน (แต่ละอันใช้เวลาต่างกัน เช่น 100, 200 และ 300ms) แล้วค่อย disconnect:
 
 ```js
-// Helper function to call async function `fn` after `ms` milliseconds
+// ฟังก์ชัน helper สำหรับเรียก async function `fn` หลังจาก `ms` มิลลิวินาที
 function delay(fn, ms) {
   return new Promise((resolve, reject) => {
     setTimeout(() => fn().then(resolve, reject), ms);
@@ -54,8 +54,8 @@ async function run() {
 
   try {
     await Promise.all([
-      // these 3 parallel jobs take different time: 100, 200 and 300 ms
-      // we use the `delay` helper to achieve this effect
+      // 3 งานที่รันพร้อมกัน ใช้เวลา 100, 200 และ 300 ms ตามลำดับ
+      // ใช้ `delay` helper เพื่อจำลองเวลา
 *!*
       delay(() => database.query(true), 100),
       delay(() => database.query(false), 200),
@@ -72,8 +72,8 @@ async function run() {
 run();
 ```
 
-Two of these queries happen to be unsuccessful, but we're smart enough to wrap the `Promise.all` call into a `try..catch` block.
+สอง query เกิด error แต่เราฉลาดพอที่จะครอบ `Promise.all` ไว้ในบล็อก `try..catch`
 
-However, this doesn't help! This script actually leads to an uncaught error in console!
+แต่มันไม่ได้ช่วยเลย! สคริปต์นี้ยังเจอ uncaught error ใน console อยู่ดี!
 
-Why? How to avoid it?
\ No newline at end of file
+ทำไม? และจะแก้ยังไง?
diff --git a/1-js/11-async/08-async-await/article.md b/1-js/11-async/08-async-await/article.md
index e679b1c4c..9641b96fc 100644
--- a/1-js/11-async/08-async-await/article.md
+++ b/1-js/11-async/08-async-await/article.md
@@ -1,10 +1,10 @@
 # Async/await
 
-There's a special syntax to work with promises in a more comfortable fashion, called "async/await". It's surprisingly easy to understand and use.
+มี syntax พิเศษที่ทำให้การทำงานกับ promise สบายขึ้นมาก — เรียกว่า "async/await" และที่น่าแปลกใจคือมันเข้าใจง่ายกว่าที่คิด
 
 ## Async functions
 
-Let's start with the `async` keyword. It can be placed before a function, like this:
+เริ่มจาก keyword `async` กันก่อน ใส่ไว้หน้าฟังก์ชันได้เลย แบบนี้:
 
 ```js
 async function f() {
@@ -12,9 +12,9 @@ async function f() {
 }
 ```
 
-The word "async" before a function means one simple thing: a function always returns a promise. Other values are wrapped in a resolved promise automatically.
+`async` บอกแค่สิ่งเดียวว่า — ฟังก์ชันนี้จะคืนค่าเป็น promise เสมอ ถ้าคืนค่าที่ไม่ใช่ promise JavaScript จะห่อมันไว้ใน resolved promise ให้อัตโนมัติ
 
-For instance, this function returns a resolved promise with the result of `1`; let's test it:
+ลองดูตัวอย่าง ฟังก์ชันนี้คืนค่าเป็น resolved promise ที่มีผลลัพธ์เป็น `1`:
 
 ```js run
 async function f() {
@@ -24,7 +24,7 @@ async function f() {
 f().then(alert); // 1
 ```
 
-...We could explicitly return a promise, which would be the same:
+...จะ return เป็น promise ตรงๆ เลยก็ได้ ผลเหมือนกัน:
 
 ```js run
 async function f() {
@@ -34,20 +34,21 @@ async function f() {
 f().then(alert); // 1
 ```
 
-So, `async` ensures that the function returns a promise, and wraps non-promises in it. Simple enough, right? But not only that. There's another keyword, `await`, that works only inside `async` functions, and it's pretty cool.
+`async` รับประกันว่าฟังก์ชันจะคืนค่าเป็น promise เสมอ และห่อค่าที่ไม่ใช่ promise ไว้ในนั้น เข้าใจง่ายใช่ไหม? แต่ยังไม่หมดแค่นั้น — ยังมี keyword อีกตัวคือ `await` ที่ใช้ได้แค่ภายใน `async` function และมันเจ๋งมาก
 
 ## Await
 
-The syntax:
+เขียนแบบนี้:
 
 ```js
-// works only inside async functions
+// ใช้ได้แค่ภายใน async function เท่านั้น
 let value = await promise;
 ```
 
-The keyword `await` makes JavaScript wait until that promise settles and returns its result.
+`await` ทำให้ JavaScript หยุดรอจนกว่า promise จะ settle แล้วค่อยคืนผลลัพธ์มา
+
+ดูตัวอย่างกับ promise ที่ resolve หลังจาก 1 วินาที:
 
-Here's an example with a promise that resolves in 1 second:
 ```js run
 async function f() {
 
@@ -56,7 +57,7 @@ async function f() {
   });
 
 *!*
-  let result = await promise; // wait until the promise resolves (*)
+  let result = await promise; // รอจนกว่า promise จะ resolve (*)
 */!*
 
   alert(result); // "done!"
@@ -65,14 +66,14 @@ async function f() {
 f();
 ```
 
-The function execution "pauses" at the line `(*)` and resumes when the promise settles, with `result` becoming its result. So the code above shows "done!" in one second.
+การทำงานของฟังก์ชันจะ "หยุดนิ่ง" ที่บรรทัด `(*)` แล้วค่อยทำงานต่อเมื่อ promise settle โดย `result` รับค่าผลลัพธ์นั้นมา โค้ดด้านบนจึงแสดง "done!" หลังจาก 1 วินาที
 
-Let's emphasize: `await` literally suspends the function execution until the promise settles, and then resumes it with the promise result. That doesn't cost any CPU resources, because the JavaScript engine can do other jobs in the meantime: execute other scripts, handle events, etc.
+ย้ำให้ชัด: `await` หยุดการทำงานของฟังก์ชันจนกว่า promise จะ settle จากนั้นค่อยทำงานต่อพร้อมผลลัพธ์ ไม่ได้กิน CPU เลยนะ เพราะ JavaScript engine ยังทำงานอื่นได้ระหว่างรอ — รันสคริปต์อื่น จัดการ event ฯลฯ
 
-It's just a more elegant syntax of getting the promise result than `promise.then`. And, it's easier to read and write.
+เป็นแค่ syntax ที่หรูกว่า `promise.then` ในการรับผลลัพธ์จาก promise อ่านและเขียนก็ง่ายกว่าด้วย
 
-````warn header="Can't use `await` in regular functions"
-If we try to use `await` in a non-async function, there would be a syntax error:
+````warn header="ใช้ `await` ใน regular function ไม่ได้"
+ถ้าลองใช้ `await` ในฟังก์ชันที่ไม่ใช่ async จะเจอ syntax error ทันที:
 
 ```js run
 function f() {
@@ -83,32 +84,32 @@ function f() {
 }
 ```
 
-We may get this error if we forget to put `async` before a function. As stated earlier, `await` only works inside an `async` function.
+error แบบนี้มักเกิดเพราะลืมใส่ `async` ไว้หน้าฟังก์ชัน อย่าลืมว่า `await` ใช้ได้แค่ภายใน `async` function เท่านั้น
 ````
 
-Let's take the `showAvatar()` example from the chapter <info:promise-chaining> and rewrite it using `async/await`:
+มาลองเอาตัวอย่าง `showAvatar()` จากบทที่แล้ว <info:promise-chaining> มาเขียนใหม่ด้วย `async/await` กัน:
 
-1. We'll need to replace `.then` calls with `await`.
-2. Also we should make the function `async` for them to work.
+1. แทนที่การเรียก `.then` ทั้งหมดด้วย `await`
+2. ใส่ `async` หน้าฟังก์ชันด้วย
 
 ```js run
 async function showAvatar() {
 
-  // read our JSON
+  // อ่าน JSON
   let response = await fetch('/article/promise-chaining/user.json');
   let user = await response.json();
 
-  // read github user
+  // อ่านข้อมูล github user
   let githubResponse = await fetch(`https://api.github.com/users/${user.name}`);
   let githubUser = await githubResponse.json();
 
-  // show the avatar
+  // แสดงรูป avatar
   let img = document.createElement('img');
   img.src = githubUser.avatar_url;
   img.className = "promise-avatar-example";
   document.body.append(img);
 
-  // wait 3 seconds
+  // รอ 3 วินาที
   await new Promise((resolve, reject) => setTimeout(resolve, 3000));
 
   img.remove();
@@ -119,24 +120,22 @@ async function showAvatar() {
 showAvatar();
 ```
 
-Pretty clean and easy to read, right? Much better than before.
+อ่านง่ายกว่าเดิมมากใช่ไหม? ไม่มี `.then` ซ้อนๆ ให้งงอีกแล้ว
 
-````smart header="Modern browsers allow top-level `await` in modules"
-In modern browsers, `await` on top level works just fine, when we're inside a module. We'll cover modules in article <info:modules-intro>.
+````smart header="เบราว์เซอร์สมัยใหม่รองรับ top-level `await` ใน module"
+ใน module เราใช้ `await` ที่ระดับบนสุดได้เลย ไม่ต้องห่อด้วยฟังก์ชัน รายละเอียดเรื่อง module อยู่ในบท <info:modules-intro>
 
-For instance:
+เช่น:
 
 ```js run module
-// we assume this code runs at top level, inside a module
+// สมมติโค้ดนี้รันที่ระดับบนสุดของ module
 let response = await fetch('/article/promise-chaining/user.json');
 let user = await response.json();
 
 console.log(user);
 ```
 
-If we're not using modules, or [older browsers](https://caniuse.com/mdn-javascript_operators_await_top_level) must be supported, there's a universal recipe: wrapping into an anonymous async function.
-
-Like this:
+ถ้าไม่ได้ใช้ module หรือต้องรองรับ [เบราว์เซอร์เก่า](https://caniuse.com/mdn-javascript_operators_await_top_level) ก็มีท่าสากลคือห่อด้วย anonymous async function แบบนี้:
 
 ```js
 (async () => {
@@ -148,10 +147,10 @@ Like this:
 
 ````
 
-````smart header="`await` accepts \"thenables\""
-Like `promise.then`, `await` allows us to use thenable objects (those with a callable `then` method). The idea is that a third-party object may not be a promise, but promise-compatible: if it supports `.then`, that's enough to use it with `await`.
+````smart header="`await` รับ \"thenable\" ได้ด้วย"
+เหมือนกับ `promise.then`, `await` ใช้กับ thenable object (ออบเจ็กต์ที่มีเมธอด `then`) ได้เช่นกัน แนวคิดคือถึงแม้ออบเจ็กต์จาก third-party จะไม่ใช่ promise แต่ถ้ามี `.then` ก็ใช้กับ `await` ได้เลย
 
-Here's a demo `Thenable` class; the `await` below accepts its instances:
+ดูตัวอย่างคลาส `Thenable` — `await` ด้านล่างรับ instance ของมันได้:
 
 ```js run
 class Thenable {
@@ -160,13 +159,13 @@ class Thenable {
   }
   then(resolve, reject) {
     alert(resolve);
-    // resolve with this.num*2 after 1000ms
+    // resolve ด้วย this.num*2 หลังจาก 1000ms
     setTimeout(() => resolve(this.num * 2), 1000); // (*)
   }
 }
 
 async function f() {
-  // waits for 1 second, then result becomes 2
+  // รอ 1 วินาที แล้ว result กลายเป็น 2
   let result = await new Thenable(1);
   alert(result);
 }
@@ -174,11 +173,11 @@ async function f() {
 f();
 ```
 
-If `await` gets a non-promise object with `.then`, it calls that method providing the built-in functions `resolve` and `reject` as arguments (just as it does for a regular `Promise` executor). Then `await` waits until one of them is called (in the example above it happens in the line `(*)`) and then proceeds with the result.
+ถ้า `await` ได้รับออบเจ็กต์ที่ไม่ใช่ promise แต่มี `.then` จะเรียกเมธอดนั้นโดยส่ง `resolve` และ `reject` เป็นอาร์กิวเมนต์ (เหมือนกับที่ทำกับ `Promise` executor ทั่วไป) จากนั้น `await` รอจนกว่าหนึ่งในนั้นจะถูกเรียก (ในตัวอย่างเกิดที่บรรทัด `(*)`) แล้วค่อยทำงานต่อพร้อมผลลัพธ์
 ````
 
-````smart header="Async class methods"
-To declare an async class method, just prepend it with `async`:
+````smart header="Async class method"
+ประกาศ async method ในคลาสได้เลย แค่ใส่ `async` ไว้ข้างหน้า:
 
 ```js run
 class Waiter {
@@ -191,16 +190,16 @@ class Waiter {
 
 new Waiter()
   .wait()
-  .then(alert); // 1 (this is the same as (result => alert(result)))
+  .then(alert); // 1 (เหมือนกับ (result => alert(result)))
 ```
-The meaning is the same: it ensures that the returned value is a promise and enables `await`.
+ความหมายเหมือนเดิม: รับประกันว่าค่าที่คืนมาเป็น promise และเปิดใช้งาน `await` ได้
 
 ````
 ## Error handling
 
-If a promise resolves normally, then `await promise` returns the result. But in the case of a rejection, it throws the error, just as if there were a `throw` statement at that line.
+ถ้า promise resolve ปกติ `await promise` ก็คืนผลลัพธ์มาเลย แต่ถ้า reject จะโยน error ออกมาเหมือนมีคำสั่ง `throw` อยู่ที่บรรทัดนั้น
 
-This code:
+โค้ดนี้:
 
 ```js
 async function f() {
@@ -210,7 +209,7 @@ async function f() {
 }
 ```
 
-...is the same as this:
+...มีความหมายเดียวกันกับอันนี้:
 
 ```js
 async function f() {
@@ -220,9 +219,9 @@ async function f() {
 }
 ```
 
-In real situations, the promise may take some time before it rejects. In that case there will be a delay before `await` throws an error.
+ในสถานการณ์จริง promise อาจใช้เวลาสักพักก่อนจะ reject ก็จะมีช่วงหน่วงก่อนที่ `await` จะโยน error ออกมา
 
-We can catch that error using `try..catch`, the same way as a regular `throw`:
+จับ error ได้ด้วย `try..catch` เหมือนกับ `throw` ทั่วไปเลย:
 
 ```js run
 async function f() {
@@ -239,7 +238,7 @@ async function f() {
 f();
 ```
 
-In the case of an error, the control jumps to the `catch` block. We can also wrap multiple lines:
+เมื่อเกิด error การทำงานจะกระโดดไปที่บล็อก `catch` ทันที ครอบหลายบรรทัดในบล็อก `try` เดียวกันก็ได้:
 
 ```js run
 async function f() {
@@ -248,7 +247,7 @@ async function f() {
     let response = await fetch('/no-user-here');
     let user = await response.json();
   } catch(err) {
-    // catches errors both in fetch and response.json
+    // ดักจับ error จากทั้ง fetch และ response.json
     alert(err);
   }
 }
@@ -256,33 +255,33 @@ async function f() {
 f();
 ```
 
-If we don't have `try..catch`, then the promise generated by the call of the async function `f()` becomes rejected. We can append `.catch` to handle it:
+ถ้าไม่มี `try..catch` promise ที่ได้จากการเรียก async function `f()` จะกลายเป็น rejected promise ต่อ `.catch` ท้ายได้เลย:
 
 ```js run
 async function f() {
   let response = await fetch('http://no-such-url');
 }
 
-// f() becomes a rejected promise
+// f() กลายเป็น rejected promise
 *!*
 f().catch(alert); // TypeError: failed to fetch // (*)
 */!*
 ```
 
-If we forget to add `.catch` there, then we get an unhandled promise error (viewable in the console). We can catch such errors using a global `unhandledrejection` event handler as described in the chapter <info:promise-error-handling>.
+ถ้าลืมต่อ `.catch` ไว้ จะเจอ unhandled promise error ใน console จัดการด้วย global `unhandledrejection` event handler ได้ ตามที่อธิบายในบท <info:promise-error-handling>
 
 
-```smart header="`async/await` and `promise.then/catch`"
-When we use `async/await`, we rarely need `.then`, because `await` handles the waiting for us. And we can use a regular `try..catch` instead of `.catch`. That's usually (but not always) more convenient.
+```smart header="`async/await` กับ `promise.then/catch`"
+เวลาใช้ `async/await` แทบไม่ต้องเขียน `.then` เพราะ `await` จัดการการรอให้แล้ว และใช้ `try..catch` แทน `.catch` ได้เลย ซึ่งปกติแล้วสะดวกกว่า (แต่ไม่ทุกกรณี)
 
-But at the top level of the code, when we're outside any `async` function, we're syntactically unable to use `await`, so it's a normal practice to add `.then/catch` to handle the final result or falling-through error, like in the line `(*)` of the example above.
+แต่ที่ระดับบนสุดของโค้ด ตอนที่อยู่นอก `async` function ทุกอัน ใช้ `await` ตรงๆ ไม่ได้ เลยเป็นเรื่องปกติที่จะต่อ `.then/catch` เพื่อจัดการผลลัพธ์สุดท้ายหรือ error ที่หลุดออกมา เหมือนบรรทัด `(*)` ในตัวอย่างด้านบน
 ```
 
-````smart header="`async/await` works well with `Promise.all`"
-When we need to wait for multiple promises, we can wrap them in `Promise.all` and then `await`:
+````smart header="`async/await` ทำงานร่วมกับ `Promise.all` ได้ดี"
+เวลาต้องรอหลาย promise พร้อมกัน ห่อด้วย `Promise.all` แล้ว `await` ได้เลย:
 
 ```js
-// wait for the array of results
+// รอผลลัพธ์จากอาร์เรย์ทั้งหมด
 let results = await Promise.all([
   fetch(url1),
   fetch(url2),
@@ -290,22 +289,22 @@ let results = await Promise.all([
 ]);
 ```
 
-In the case of an error, it propagates as usual, from the failed promise to `Promise.all`, and then becomes an exception that we can catch using `try..catch` around the call.
+ถ้าเกิด error ก็จะกระจายตามปกติ จาก promise ที่พัง ไปยัง `Promise.all` แล้วกลายเป็น exception ที่จับได้ด้วย `try..catch` รอบนอก
 
 ````
 
-## Summary
+## สรุป
 
-The `async` keyword before a function has two effects:
+`async` ที่ใส่หน้าฟังก์ชันมีผลสองอย่าง:
 
-1. Makes it always return a promise.
-2. Allows `await` to be used in it.
+1. ฟังก์ชันจะคืนค่าเป็น promise เสมอ
+2. เปิดใช้ `await` ภายในฟังก์ชันได้
 
-The `await` keyword before a promise makes JavaScript wait until that promise settles, and then:
+`await` ที่ใส่หน้า promise ทำให้ JavaScript รอจนกว่า promise จะ settle จากนั้น:
 
-1. If it's an error, an exception is generated — same as if `throw error` were called at that very place.
-2. Otherwise, it returns the result.
+1. ถ้าเป็น error จะโยน exception ออกมา — เหมือนมีคำสั่ง `throw error` อยู่ตรงนั้น
+2. ถ้าไม่ใช่ error จะคืนผลลัพธ์มา
 
-Together they provide a great framework to write asynchronous code that is easy to both read and write.
+ทั้งสองตัวทำงานร่วมกันได้ดีมาก เขียนโค้ด asynchronous แบบ synchronous ได้เลย อ่านง่าย เขียนง่าย
 
-With `async/await` we rarely need to write `promise.then/catch`, but we still shouldn't forget that they are based on promises, because sometimes (e.g. in the outermost scope) we have to use these methods. Also `Promise.all` is nice when we are waiting for many tasks simultaneously.
+ใช้ `async/await` แล้วแทบไม่ต้องเขียน `promise.then/catch` อีกต่อไป แต่อย่าลืมว่ามันยังสร้างอยู่บน promise อยู่ดี เพราะบางครั้ง (เช่น ที่ระดับสโคปด้านนอกสุด) จำเป็นต้องใช้เมธอดเหล่านั้น แล้วก็ `Promise.all` ยังเป็นตัวเลือกที่ดีเมื่อต้องรอ async หลายอย่างพร้อมๆ กัน