+```
diff --git a/curriculum/challenges/chinese-traditional/01-responsive-web-design/basic-html-and-html5/say-hello-to-html-elements.md b/curriculum/challenges/chinese-traditional/01-responsive-web-design/basic-html-and-html5/say-hello-to-html-elements.md
new file mode 100644
index 0000000000..bf44b69e75
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/01-responsive-web-design/basic-html-and-html5/say-hello-to-html-elements.md
@@ -0,0 +1,60 @@
+---
+id: bd7123c8c441eddfaeb5bdef
+title: 向 HTML 元素問好
+challengeType: 0
+videoUrl: 'https://scrimba.com/p/pVMPUv/cE8Gpt2'
+forumTopicId: 18276
+dashedName: say-hello-to-html-elements
+---
+
+# --description--
+
+歡迎訪問 freeCodeCamp 的 HTML 編程挑戰。 這些挑戰將會幫助你逐步掌握 Web 開發。
+
+首先，我們來用 HTML 製作一個簡單的網頁。 你可以直接在網頁內置的代碼編輯器中編輯代碼。
+
+你看到編輯器中的 `
+```
+
+開始標籤和結束標籤的唯一區別就是結束標籤多了一個斜槓。
+
+每個挑戰都有測試，任何時候你點擊“運行測試”按鈕，就可以運行測試。 如果代碼通過測試，將會彈出一個窗口，你就可以進入下一個挑戰。
+
+# --instructions--
+
+要通過這個挑戰的測試，需要修改 `h1` 元素的文本爲 `Hello World`。
+
+# --hints--
+
+`h1` 元素的內容文本應爲 `Hello World`。
+
+```js
+assert.isTrue(/hello(\s)+world/gi.test($('h1').text()));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+```
diff --git a/curriculum/challenges/chinese-traditional/01-responsive-web-design/basic-html-and-html5/turn-an-image-into-a-link.md b/curriculum/challenges/chinese-traditional/01-responsive-web-design/basic-html-and-html5/turn-an-image-into-a-link.md
new file mode 100644
index 0000000000..8ec3d15f11
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/01-responsive-web-design/basic-html-and-html5/turn-an-image-into-a-link.md
@@ -0,0 +1,80 @@
+---
+id: bad87fee1348bd9aedf08820
+title: 給圖片添加鏈接
+challengeType: 0
+videoUrl: 'https://scrimba.com/p/pVMPUv/cRdBnUr'
+forumTopicId: 18327
+dashedName: turn-an-image-into-a-link
+---
+
+# --description--
+
+你可以通過把元素嵌套進 `a` 裏使其變成一個鏈接。
+
+如果我們要把圖片嵌套進 `a` 元素， 可以這樣寫：
+
+```html
+
+```
+
+如果把 `a` 的 `href` 屬性值設置爲 `#`，創建的是一個死鏈接（不跳轉到其他畫面）。
+
+# --instructions--
+
+請把現存的圖片嵌套進 `a`（ *錨點*）元素中。
+
+完成後，請你把鼠標光標懸停在你的圖像上， 鼠標光標將變成點擊光標。 於是圖片就變成了鏈接。
+
+# --hints--
+
+應將 `img` 嵌套進 `a` 元素中。
+
+```js
+assert($('a').children('img').length > 0);
+```
+
+`a` 的 `href` 屬性值應爲 `#`。
+
+```js
+assert(new RegExp('#').test($('a').children('img').parent().attr('href')));
+```
+
+每個 `a` 元素都應該有一個結束標籤。
+
+```js
+assert(
+ code.match(/<\/a>/g) &&
+ code.match(/
CatPhotoApp
+
+ Click here to view more cat photos .
+
+ Kitty ipsum dolor sit amet, shed everywhere shed everywhere stretching attack your ankles chase the red dot, hairball run catnip eat the grass sniff.
+ Purr jump eat the grass rip the couch scratched sunbathe, shed everywhere rip the couch sleep in the sink fluffy fur catnip scratched.
+
+```
+
+# --solutions--
+
+```html
+CatPhotoApp
+
+ Click here to view more cat photos .
+
+ Kitty ipsum dolor sit amet, shed everywhere shed everywhere stretching attack your ankles chase the red dot, hairball run catnip eat the grass sniff.
+ Purr jump eat the grass rip the couch scratched sunbathe, shed everywhere rip the couch sleep in the sink fluffy fur catnip scratched.
+
+```
diff --git a/curriculum/challenges/chinese-traditional/01-responsive-web-design/basic-html-and-html5/uncomment-html.md b/curriculum/challenges/chinese-traditional/01-responsive-web-design/basic-html-and-html5/uncomment-html.md
new file mode 100644
index 0000000000..377df9e157
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/01-responsive-web-design/basic-html-and-html5/uncomment-html.md
@@ -0,0 +1,70 @@
+---
+id: bad87fee1348bd9aedf08802
+title: 去除 HTML 的註釋
+challengeType: 0
+videoUrl: 'https://scrimba.com/p/pVMPUv/cBmG9T7'
+forumTopicId: 18329
+dashedName: uncomment-html
+---
+
+# --description--
+
+註釋的作用是給代碼添加一些說明，方便團隊合作或日後自己查看，但又不影響代碼本身。
+
+註釋的另一個用途就是在不刪除代碼的前提下，讓代碼不起作用。
+
+在 HTML 中，註釋的開始標籤是 ``。
+
+# --instructions--
+
+現在我們反其道而行之，去掉 `h1` 元素、`h2` 元素、`p` 元素的註釋。
+
+# --hints--
+
+頁面上應存在 `h1` 元素。
+
+```js
+assert($('h1').length > 0);
+```
+
+頁面上應存在 `h2` 元素。
+
+```js
+assert($('h2').length > 0);
+```
+
+頁面上應存在 `p` 元素。
+
+```js
+assert($('p').length > 0);
+```
+
+應刪除註釋的結束標籤 `-->`。
+
+```js
+assert(!$('*:contains("-->")')[1]);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+```
+
+# --solutions--
+
+```html
+Hello World
+
+CatPhotoApp
+
+Kitty ipsum dolor sit amet, shed everywhere shed everywhere stretching attack your ankles chase the red dot, hairball run catnip eat the grass sniff.
+```
diff --git a/curriculum/challenges/chinese-traditional/01-responsive-web-design/basic-html-and-html5/use-html5-to-require-a-field.md b/curriculum/challenges/chinese-traditional/01-responsive-web-design/basic-html-and-html5/use-html5-to-require-a-field.md
new file mode 100644
index 0000000000..457e855e5d
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/01-responsive-web-design/basic-html-and-html5/use-html5-to-require-a-field.md
@@ -0,0 +1,86 @@
+---
+id: bad87fee1348bd9aedc08830
+title: 給表單添加一個必填字段
+challengeType: 0
+videoUrl: 'https://scrimba.com/p/pVMPUv/cMd4EcQ'
+forumTopicId: 18360
+dashedName: use-html5-to-require-a-field
+---
+
+# --description--
+
+當你設計表單時，你可以指定某些字段爲必填項（required），只有當用戶填寫了該字段後，纔可以提交表單。
+
+如果你想把文本輸入框設置爲必填項，在 `input` 元素中加上 `required` 屬性就可以了，例如：`CatPhotoApp
+
+ Click here to view more cat photos .
+
+ Things cats love:
+
+ cat nip
+ laser pointers
+ lasagna
+
+ Top 3 things cats hate:
+
+ flea treatment
+ thunder
+ other cats
+
+
+
+```
+
+# --solutions--
+
+```html
+CatPhotoApp
+
+ Click here to view more cat photos .
+
+ Things cats love:
+
+ cat nip
+ laser pointers
+ lasagna
+
+ Top 3 things cats hate:
+
+ flea treatment
+ thunder
+ other cats
+
+
+
+```
diff --git a/curriculum/challenges/chinese-traditional/01-responsive-web-design/basic-html-and-html5/use-the-value-attribute-with-radio-buttons-and-checkboxes.md b/curriculum/challenges/chinese-traditional/01-responsive-web-design/basic-html-and-html5/use-the-value-attribute-with-radio-buttons-and-checkboxes.md
new file mode 100644
index 0000000000..7457c8dc1f
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/01-responsive-web-design/basic-html-and-html5/use-the-value-attribute-with-radio-buttons-and-checkboxes.md
@@ -0,0 +1,148 @@
+---
+id: 5c6c06847491271903d37cfd
+title: 使用單選框和複選框的 value 屬性
+challengeType: 0
+forumTopicId: 301099
+dashedName: use-the-value-attribute-with-radio-buttons-and-checkboxes
+---
+
+# --description--
+
+提交表單時，所選項的值會發送給服務端。 `radio` 和 `checkbox` 的 `value` 屬性值決定了發送到服務端的實際內容。
+
+例如：
+
+```html
+
+
+
+
+```
+
+這裏有兩個 `radio` 單選框。 當用戶提交表單時，如果 `indoor` 選項被選中，表單數據會包含：`indoor-outdoor=indoor`。 也就是所選項的 `name` 和 `value` 屬性值。
+
+如果沒有指明 `value` 屬性值，則會使用默認值做爲表單數據提交，也就是 `on`。 在這種情況下，如果用戶選中 "indoor" 選項然後提交表單，表單數據則會包含 `indoor-outdoor=on`。 這樣的表單數據看起來不夠直觀，因此最好將 `value` 屬性值設置爲一些有意義的內容。
+
+# --instructions--
+
+給每一個 `radio` 和 `checkbox` 輸入框添加 `value` 屬性。 使用輸入標籤的文本，小寫形式，作爲屬性的值。
+
+# --hints--
+
+應有一個單選按鈕的 `value` 屬性值爲 `indoor`。
+
+```js
+assert(
+ $('label:contains("Indoor") > input[type="radio"]').filter("[value='indoor']")
+ .length > 0
+);
+```
+
+應有一個單選按鈕的 `value` 屬性值爲 `outdoor`。
+
+```js
+assert(
+ $('label:contains("Outdoor") > input[type="radio"]').filter(
+ "[value='outdoor']"
+ ).length > 0
+);
+```
+
+應有一個複選框的 `value` 屬性值爲 `loving`。
+
+```js
+assert(
+ $('label:contains("Loving") > input[type="checkbox"]').filter(
+ "[value='loving']"
+ ).length > 0
+);
+```
+
+應有一個複選框的 `value` 屬性值爲 `lazy`。
+
+```js
+assert(
+ $('label:contains("Lazy") > input[type="checkbox"]').filter("[value='lazy']")
+ .length > 0
+);
+```
+
+應有一個複選框的 `value` 屬性值爲 `energetic`。
+
+```js
+assert(
+ $('label:contains("Energetic") > input[type="checkbox"]').filter(
+ "[value='energetic']"
+ ).length > 0
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+CatPhotoApp
+
+ Click here to view more cat photos .
+
+ Things cats love:
+
+ cat nip
+ laser pointers
+ lasagna
+
+ Top 3 things cats hate:
+
+ flea treatment
+ thunder
+ other cats
+
+
+
+```
+
+# --solutions--
+
+```html
+CatPhotoApp
+
+ Click here to view more cat photos .
+
+ Things cats love:
+
+ cat nip
+ laser pointers
+ lasagna
+
+ Top 3 things cats hate:
+
+ flea treatment
+ thunder
+ other cats
+
+
+
+```
diff --git a/curriculum/challenges/chinese-traditional/01-responsive-web-design/css-flexbox/add-flex-superpowers-to-the-tweet-embed.md b/curriculum/challenges/chinese-traditional/01-responsive-web-design/css-flexbox/add-flex-superpowers-to-the-tweet-embed.md
new file mode 100644
index 0000000000..a80ed7bc4d
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/01-responsive-web-design/css-flexbox/add-flex-superpowers-to-the-tweet-embed.md
@@ -0,0 +1,258 @@
+---
+id: 587d78ab367417b2b2512af1
+title: 在推文中添加彈性盒子佈局
+challengeType: 0
+videoUrl: 'https://scrimba.com/p/pVaDAv/c9W7MhM'
+forumTopicId: 301100
+dashedName: add-flex-superpowers-to-the-tweet-embed
+---
+
+# --description--
+
+以右邊的嵌入推文爲例， 一些元素換一個佈局方式或許更好看。 上一個挑戰演示了 `display: flex`， 現在你需要把它添加到推文內嵌的多個組件中，調整它們的位置。
+
+# --instructions--
+
+請爲下列項目添加 CSS 屬性 `display: flex`。 注意，以下 CSS 選擇器已爲你寫好：
+
+`header`、header 中的 `.profile-name`、header 中的 `.follow-btn`、header 中的 `h3` 和 `h4`、`footer` 以及 footer 中的 `.stats`。
+
+# --hints--
+
+`.follow-btn` 應在頁面上呈現。 請關閉廣告攔截器等任何擴展。
+
+```js
+assert($('.follow-btn').length > 0 && $('.follow-btn').css('display') !== 'none');
+```
+
+`header` 的 `display` 屬性值應爲 `flex`。
+
+```js
+assert($('header').css('display') == 'flex');
+```
+
+`footer` 的 `display` 屬性值應爲 `flex`。
+
+```js
+assert($('footer').css('display') == 'flex');
+```
+
+`h3` 的 `display` 屬性值應爲 `flex`。
+
+```js
+assert($('h3').css('display') == 'flex');
+```
+
+`h4` 的 `display` 屬性值應爲 `flex`。
+
+```js
+assert($('h4').css('display') == 'flex');
+```
+
+`.profile-name` 的 `display` 屬性值應爲 `flex`。
+
+```js
+assert($('.profile-name').css('display') == 'flex');
+```
+
+`.follow-btn` 的 `display` 屬性值應爲 `flex`。
+
+```js
+assert($('.follow-btn').css('display') == 'flex');
+```
+
+`.stats` 的 `display` 屬性值應爲 `flex`。
+
+```js
+assert($('.stats').css('display') == 'flex');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+
+
+
I meet so many people who are in search of that one trick that will help them work smart. Even if you work smart, you still have to work hard.
+
1:32 PM - 12 Jan 2018
+
+
+
I meet so many people who are in search of that one trick that will help them work smart. Even if you work smart, you still have to work hard.
+
1:32 PM - 12 Jan 2018
+
+
flex-start：從 flex 容器的起始位置開始對齊項目。 對行來說，把項目移至容器頂部； 對列來說，是把項目移至容器左邊。flex-end：從 flex 容器的終止位置開始對齊項目。 對行來說，把項目移至容器底部； 對列來說，把項目移至容器右邊。center：把項目居中放置。 對行來說，垂直居中（項目距離頂部和底部的距離相等）； 對列來說，水平居中（項目距離左邊和右邊的距離相等）。stretch：拉伸項目，填滿 flex 容器。 例如，排成行的項目從容器頂部拉伸到底部。 如未設置align-items的值，那麼這就是默認值。baseline：沿基線對齊。 基線是文本相關的概念，可以認爲它是字母排列的下端基準線。flex-start：從 flex 容器的起始位置開始排列項目。 對行來說是把項目移至左邊， 對於列是把項目移至頂部。 如未設置 justify-content 的值，那麼這就是默認值。flex-end：從 flex 容器的終止位置開始排列項目。 對行來說是把項目移至右邊， 對於列是把項目移至底部。space-between：項目間保留一定間距地沿主軸居中排列。 第一個和最後一個項目被放置在容器邊沿。 例如，在行中第一個項目會緊貼着容器左邊，最後一個項目會緊貼着容器右邊，然後其他項目均勻排布。space-around：與space-between相似，但頭尾兩個項目不會緊貼容器邊緣，所有項目之間的空間均勻排布。space-evenly：頭尾兩個項目不會緊貼容器邊緣，所有項目之間的空間均勻排布。
+
I meet so many people who are in search of that one trick that will help them work smart. Even if you work smart, you still have to work hard.
+
1:32 PM - 12 Jan 2018
+
+
+
I meet so many people who are in search of that one trick that will help them work smart. Even if you work smart, you still have to work hard.
+
1:32 PM - 12 Jan 2018
+
+
+
I meet so many people who are in search of that one trick that will help them work smart. Even if you work smart, you still have to work hard.
+
1:32 PM - 12 Jan 2018
+
+
+
I meet so many people who are in search of that one trick that will help them work smart. Even if you work smart, you still have to work hard.
+
1:32 PM - 12 Jan 2018
+
+
+
I meet so many people who are in search of that one trick that will help them work smart. Even if you work smart, you still have to work hard.
+
1:32 PM - 12 Jan 2018
+
+
+
I meet so many people who are in search of that one trick that will help them work smart. Even if you work smart, you still have to work hard.
+
1:32 PM - 12 Jan 2018
+
+
nowrap：默認值，不換行。wrap：如果排列以行爲基準，就將行從上往下排列；如果排列以列爲基準，就將列從左往右排列。wrap-reverse：如果排列以行爲基準，就將行從下往上排列；如果排列以列爲基準，就將列從右往左排列。
+
I meet so many people who are in search of that one trick that will help them work smart. Even if you work smart, you still have to work hard.
+
1:32 PM - 12 Jan 2018
+
+
+
I meet so many people who are in search of that one trick that will help them work smart. Even if you work smart, you still have to work hard.
+
1:32 PM - 12 Jan 2018
+
+
單元格（cell） 的框內。 你可以使用網格項的 `justify-self` 屬性，設置其內容的位置在單元格內沿水平軸的對齊方式。 默認情況下，這個屬性的值是 `stretch`，這將使內容佔滿整個單元格的寬度。 該 CSS 網格屬性也可以使用其他的值：
+
+`start`：使內容在單元格左側對齊，
+
+`center`：使內容在單元格居中對齊，
+
+`end`：使內容在單元格右側對齊，
+
+# --instructions--
+
+請使用 `justify-self` 屬性讓 class 爲 `item2` 的網格項居中。
+
+# --hints--
+
+class 爲 `item2` 的元素應具有 `justify-self` 屬性且屬性值應爲 `center`。
+
+```js
+assert(
+ code.match(/.item2\s*?{[\s\S]*justify-self\s*?:\s*?center\s*?;[\s\S]*}/gi)
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+
+
+```
+
+# --solutions--
+
+```html
+
+```
diff --git a/curriculum/challenges/chinese-traditional/01-responsive-web-design/css-grid/align-an-item-vertically-using-align-self.md b/curriculum/challenges/chinese-traditional/01-responsive-web-design/css-grid/align-an-item-vertically-using-align-self.md
new file mode 100644
index 0000000000..48b39baa1e
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/01-responsive-web-design/css-grid/align-an-item-vertically-using-align-self.md
@@ -0,0 +1,71 @@
+---
+id: 5a90375238fddaf9a66b5d3b
+title: 使用 align-self 垂直對齊項目
+challengeType: 0
+videoUrl: 'https://scrimba.com/p/pByETK/cmzd4fz'
+forumTopicId: 301123
+dashedName: align-an-item-vertically-using-align-self
+---
+
+# --description--
+
+正如能設置網格項沿水平方向的對齊方式一樣，我們也可以設置網格項沿豎直方向的對齊方式。 爲此，我們可以對網格項使用 `align-self` 屬性來實現。 在上一個挑戰中適用於 `justify-self` 屬性的屬性值同樣也可用於這個屬性。
+
+# --instructions--
+
+請使用值 `end` 來讓 class 爲 `item3` 的網格項沿底端對齊。
+
+# --hints--
+
+class 爲 `item3` 的元素應具有 `align-self` 屬性且屬性值應爲 `end`。
+
+```js
+assert(code.match(/.item3\s*?{[\s\S]*align-self\s*?:\s*?end\s*?;[\s\S]*}/gi));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+
+
+```
+
+# --solutions--
+
+```html
+
+```
diff --git a/curriculum/challenges/chinese-traditional/01-responsive-web-design/css-grid/create-a-column-gap-using-grid-column-gap.md b/curriculum/challenges/chinese-traditional/01-responsive-web-design/css-grid/create-a-column-gap-using-grid-column-gap.md
new file mode 100644
index 0000000000..9980095285
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/01-responsive-web-design/css-grid/create-a-column-gap-using-grid-column-gap.md
@@ -0,0 +1,76 @@
+---
+id: 5a9036ee38fddaf9a66b5d35
+title: 使用 grid-column-gap 創建多列之間的間距
+challengeType: 0
+videoUrl: 'https://scrimba.com/p/pByETK/cVZ8vfD'
+forumTopicId: 301124
+dashedName: create-a-column-gap-using-grid-column-gap
+---
+
+# --description--
+
+目前爲止，在你所創建的網格中，每列都相互緊挨着。 有時候你想要列之間有一個間距。 如果需要在列與列之間添加一些間距，我們可以使用 `grid-column-gap`：
+
+```css
+grid-column-gap: 10px;
+```
+
+這會爲我們創建的所有列之間都添加 10px 的空白間距。
+
+# --instructions--
+
+請爲網格中的所有列添加寬度爲 `20px` 的間距。
+
+# --hints--
+
+class 爲 `container` 的元素應具有 `grid-column-gap` 屬性且屬性值應爲 `20px`。
+
+```js
+assert(
+ code.match(
+ /.container\s*?{[\s\S]*grid-column-gap\s*?:\s*?20px\s*?;[\s\S]*}/gi
+ )
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+
+
+```
+
+# --solutions--
+
+```html
+
+```
diff --git a/curriculum/challenges/chinese-traditional/01-responsive-web-design/css-grid/create-a-row-gap-using-grid-row-gap.md b/curriculum/challenges/chinese-traditional/01-responsive-web-design/css-grid/create-a-row-gap-using-grid-row-gap.md
new file mode 100644
index 0000000000..40bdfe5c3d
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/01-responsive-web-design/css-grid/create-a-row-gap-using-grid-row-gap.md
@@ -0,0 +1,68 @@
+---
+id: 5a9036ee38fddaf9a66b5d36
+title: 使用 grid-row-gap 創建多行之間的間距
+challengeType: 0
+videoUrl: 'https://scrimba.com/p/pByETK/cPbJ2Cv'
+forumTopicId: 301125
+dashedName: create-a-row-gap-using-grid-row-gap
+---
+
+# --description--
+
+和上個挑戰在兩列之間添加間距一樣，我們還可以用 `grid-row-gap` 設置行間距。
+
+# --instructions--
+
+請爲網格中的行添加高度爲 `5px` 的間距。
+
+# --hints--
+
+class 爲 `container` 的元素應具有 `grid-row-gap` 屬性且屬性值應爲 `5px`。
+
+```js
+assert(
+ code.match(/.container\s*?{[\s\S]*grid-row-gap\s*?:\s*?5px\s*?;[\s\S]*}/gi)
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+
+
+```
+
+# --solutions--
+
+```html
+
+```
diff --git a/curriculum/challenges/chinese-traditional/01-responsive-web-design/css-grid/create-flexible-layouts-using-auto-fill.md b/curriculum/challenges/chinese-traditional/01-responsive-web-design/css-grid/create-flexible-layouts-using-auto-fill.md
new file mode 100644
index 0000000000..4afa758dd0
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/01-responsive-web-design/css-grid/create-flexible-layouts-using-auto-fill.md
@@ -0,0 +1,140 @@
+---
+id: 5a94fe5469fb03452672e461
+title: 使用 auto-fill 創建彈性佈局
+challengeType: 0
+videoUrl: 'https://scrimba.com/p/pByETK/cmzdycW'
+forumTopicId: 301126
+dashedName: create-flexible-layouts-using-auto-fill
+---
+
+# --description--
+
+repeat 方法帶有一個名爲自動填充（auto-fill） 的功能。 它的功能是根據容器的大小，儘可能多地放入指定大小的行或列。 你可以通過結合 `auto-fill` 和 `minmax` 來更靈活地佈局。
+
+```css
+repeat(auto-fill, minmax(60px, 1fr));
+```
+
+上面的代碼效果是這樣：首先，列的寬度會隨容器大小改變。其次，只要容器寬度不足以插入一個寬爲 60px 的列，當前行的所有列就都會一直拉伸。請自己調整寬度，動手試一下就不難理解了。 **注意：**如果容器寬度不足以將所有網格項放在同一行，餘下的網格項將會移至新的一行。
+
+# --instructions--
+
+在第一個網格中，請使用 `auto-fill` 和 `repeat` 來填充網格。 其中列寬的最小值爲 `60px`，最大值爲 `1fr`。 你可以調整最右側的預覽區大小，查看自動填充的效果。
+
+# --hints--
+
+class 爲 `container` 的元素應具有 `grid-template-columns` 屬性，且屬性值應使用 `repeat` 和 `auto-fill`，以便將最小寬度爲 `60px`、最大寬度爲 `1fr` 的列填充至網格。
+
+```js
+assert(
+ code.match(
+ /.container\s*?{[\s\S]*grid-template-columns\s*?:\s*?repeat\s*?\(\s*?auto-fill\s*?,\s*?minmax\s*?\(\s*?60px\s*?,\s*?1fr\s*?\)\s*?\)\s*?;[\s\S]*}/gi
+ )
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+
+
+```
+
+# --solutions--
+
+```html
+
+
+
+```
diff --git a/curriculum/challenges/chinese-traditional/01-responsive-web-design/css-grid/create-flexible-layouts-using-auto-fit.md b/curriculum/challenges/chinese-traditional/01-responsive-web-design/css-grid/create-flexible-layouts-using-auto-fit.md
new file mode 100644
index 0000000000..5646cb20ca
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/01-responsive-web-design/css-grid/create-flexible-layouts-using-auto-fit.md
@@ -0,0 +1,91 @@
+---
+id: 5a94fe6269fb03452672e462
+title: 使用 auto-fit 創建彈性佈局
+challengeType: 0
+videoUrl: 'https://scrimba.com/p/pByETK/c3dPph8'
+forumTopicId: 301127
+dashedName: create-flexible-layouts-using-auto-fit
+---
+
+# --description--
+
+`auto-fit` 效果幾乎和 `auto-fill` 一樣。 不同點僅在於，當容器的大小大於各網格項之和時，`auto-fill` 會持續地在一端放入空行或空列，這樣就會使所有網格項擠到另一邊；而 `auto-fit` 則不會在一端放入空行或空列，而是會將所有網格項拉伸至合適的大小。
+
+**注意：**如果容器寬度不足以將所有網格項放在同一行，餘下的網格項將會移至新的一行。
+
+# --instructions--
+
+在第二個網格中，請用 `auto-fit` 和 `repeat` 來填充網格，其中列寬的最小值爲 `60px`，最大值爲`1fr`。 你可以調整最右側的預覽區來查看效果。
+
+# --hints--
+
+`container2` class 應該有一個 `grid-template-columns` 屬性，通過 `repeat` 和 `auto-fit` 將網格中的列的寬度設置爲最小 `60px`，最大 `1fr`。
+
+```js
+assert(
+ code.match(
+ /.container2\s*?{[\s\S]*grid-template-columns\s*?:\s*?repeat\s*?\(\s*?auto-fit\s*?,\s*?minmax\s*?\(\s*?60px\s*?,\s*?1fr\s*?\)\s*?\)\s*?;[\s\S]*}/gi
+ )
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+
+
+
+```
+
+# --solutions--
+
+```html
+
+```
diff --git a/curriculum/challenges/chinese-traditional/01-responsive-web-design/css-grid/create-grids-within-grids.md b/curriculum/challenges/chinese-traditional/01-responsive-web-design/css-grid/create-grids-within-grids.md
new file mode 100644
index 0000000000..94574fcf48
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/01-responsive-web-design/css-grid/create-grids-within-grids.md
@@ -0,0 +1,106 @@
+---
+id: 5a94fe8569fb03452672e464
+title: 在網格中創建網格
+challengeType: 0
+forumTopicId: 301128
+dashedName: create-grids-within-grids
+---
+
+# --description--
+
+將元素轉換爲網格只會影響其子元素（即直接後代元素，英文爲 direct descendants。意思是一個元素的所有後代元素中，父級元素爲該元素的所有元素）。 因此，如果我們把某個子元素設置爲網格，就會得到一個嵌套的網格。
+
+例如，如果我們設置 class 爲 `item3` 的元素的 `display` 和 `grid-template-columns` 屬性，就會得到一個嵌套的網格。
+
+# --instructions--
+
+請設置 `display` 和 `grid-template-columns`，使類爲 `item3` 元素轉換爲有兩列且寬度爲 `auto` 和 `1fr` 的網格。
+
+# --hints--
+
+class 爲 `item3` 的元素應具有 `grid-template-columns` 屬性且屬性值應爲 `auto` 和 `1fr`。
+
+```js
+assert(
+ code.match(
+ /.item3\s*?{[\s\S]*grid-template-columns\s*?:\s*?auto\s*?1fr\s*?;[\s\S]*}/gi
+ )
+);
+```
+
+class 爲 `item3` 的元素應具有 `display` 屬性且屬性值應爲 `grid`。
+
+```js
+assert(code.match(/.item3\s*?{[\s\S]*display\s*?:\s*?grid\s*?;[\s\S]*}/gi));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+
+
+
header
+
advert
+
+
paragraph1
+
paragraph2
+
+
footer
+
容器（container） ，它的子元素稱爲項（items） 。
+
+# --instructions--
+
+請將 class 爲 `container` 的 div 的 display 屬性值設置爲 `grid`。
+
+# --hints--
+
+`container` class 應具有 `display` 屬性，屬性值應爲 `grid`。
+
+```js
+assert(code.match(/.container\s*?{[\s\S]*display\s*?:\s*?grid\s*?;[\s\S]*}/gi));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+
+
+```
+
+# --solutions--
+
+```html
+
+```
diff --git a/curriculum/challenges/chinese-traditional/01-responsive-web-design/css-grid/divide-the-grid-into-an-area-template.md b/curriculum/challenges/chinese-traditional/01-responsive-web-design/css-grid/divide-the-grid-into-an-area-template.md
new file mode 100644
index 0000000000..b812874f00
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/01-responsive-web-design/css-grid/divide-the-grid-into-an-area-template.md
@@ -0,0 +1,114 @@
+---
+id: 5a94fe0569fb03452672e45c
+title: 將網格劃分爲區域模板
+challengeType: 0
+videoUrl: 'https://scrimba.com/p/pByETK/cLLpGAy'
+forumTopicId: 301130
+dashedName: divide-the-grid-into-an-area-template
+---
+
+# --description--
+
+你可以將網格中的一些單元格組合成一個區域（area） ，併爲該區域指定一個自定義名稱。 可以通過給容器加上 `grid-template-areas` 來實現：
+
+```css
+grid-template-areas:
+ "header header header"
+ "advert content content"
+ "footer footer footer";
+```
+
+上面的代碼將頂部三個單元格合併成一個名爲 `header` 的區域，將底部三個單元格合併爲一個名爲 `footer` 的區域，並在中間行創建了兩個區域：`advert` 和 `content`。 **注意：**在代碼中，每個單詞代表一個網格單元格，每對引號代表一行。 除了自定義標籤，你還能使用句點（`.`）來表示一個空單元格。
+
+# --instructions--
+
+請放置區域模板，讓名爲 `advert` 的區域變成空單元格。
+
+# --hints--
+
+class 爲 `container` 的元素應具有 `grid-template-areas` 屬性，在其屬性值中，應使用 `.` 代替 `advert`。
+
+```js
+assert(
+ __helpers
+ .removeCssComments(code)
+ .match(
+ /.container\s*?{[\s\S]*grid-template-areas\s*?:\s*?"\s*?header\s*?header\s*?header\s*?"\s*?"\s*?.\s*?content\s*?content\s*?"\s*?"\s*?footer\s*?footer\s*?footer\s*?"\s*?;[\s\S]*}/gi
+ )
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+
+
+```
+
+# --solutions--
+
+```html
+
+
+
+```
diff --git a/curriculum/challenges/chinese-traditional/01-responsive-web-design/css-grid/limit-item-size-using-the-minmax-function.md b/curriculum/challenges/chinese-traditional/01-responsive-web-design/css-grid/limit-item-size-using-the-minmax-function.md
new file mode 100644
index 0000000000..cac094a48b
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/01-responsive-web-design/css-grid/limit-item-size-using-the-minmax-function.md
@@ -0,0 +1,77 @@
+---
+id: 5a94fe4469fb03452672e460
+title: 使用 minmax 函數限制項目大小
+challengeType: 0
+videoUrl: 'https://scrimba.com/p/pByETK/cD97RTv'
+forumTopicId: 301131
+dashedName: limit-item-size-using-the-minmax-function
+---
+
+# --description--
+
+此外，內置函數 `minmax` 也可用於設置 `grid-template-columns` 和 `grid-template-rows` 的值。 它的作用是在網格容器改變大小時限制網格項的大小。 爲此，你需要指定網格項允許的尺寸範圍。 例如：
+
+```css
+grid-template-columns: 100px minmax(50px, 200px);
+```
+
+在上面的代碼中，我們通過 `grid-template-columns` 添加了兩列，第一列寬度爲 100px，第二列寬度最小值是 50px，最大值是 200px。
+
+# --instructions--
+
+請用 `minmax` 函數替換 `repeat` 函數中的 `1fr`，限定其最小值爲 `90px`，最大值爲`1fr`。 你可以調整最右側的預覽面板查看效果。
+
+# --hints--
+
+class 爲 `container` 的元素應使用 `grid-template-columns` 屬性設置 3 列，其中，每列最小寬度應爲 `90px`，最大寬度應爲 `1fr`。
+
+```js
+assert(
+ code.match(
+ /.container\s*?{[\s\S]*grid-template-columns\s*?:\s*?repeat\s*?\(\s*?3\s*?,\s*?minmax\s*?\(\s*?90px\s*?,\s*?1fr\s*?\)\s*?\)\s*?;[\s\S]*}/gi
+ )
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+
+
+```
+
+# --solutions--
+
+```html
+
+```
diff --git a/curriculum/challenges/chinese-traditional/01-responsive-web-design/css-grid/place-items-in-grid-areas-using-the-grid-area-property.md b/curriculum/challenges/chinese-traditional/01-responsive-web-design/css-grid/place-items-in-grid-areas-using-the-grid-area-property.md
new file mode 100644
index 0000000000..af1df38e53
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/01-responsive-web-design/css-grid/place-items-in-grid-areas-using-the-grid-area-property.md
@@ -0,0 +1,86 @@
+---
+id: 5a94fe1369fb03452672e45d
+title: 使用 grid-area 屬性將項目放置在網格區域中
+challengeType: 0
+videoUrl: 'https://scrimba.com/p/pByETK/cRrqmtV'
+forumTopicId: 301132
+dashedName: place-items-in-grid-areas-using-the-grid-area-property
+---
+
+# --description--
+
+像上一個挑戰那樣，在爲網格添加區域模板後，可以通過引用你所定義的區域的名稱，將元素放入相應的區域。 爲此，你需要對網格項使用 `grid-area`：
+
+```css
+.item1 {
+ grid-area: header;
+}
+```
+
+這樣，class 爲 `item1` 的網格項就被放到了 `header` 區域裏。 在這個示例中，網格項將佔用第一行整行，因爲這一整行都被命名爲標題區域。
+
+# --instructions--
+
+請使用 `grid-area` 屬性，把 class 爲 `item5` 的元素放到 `footer` 區域。
+
+# --hints--
+
+class 爲 `item5` 的元素應具有 `grid-area` 屬性且屬性值應爲 `footer`。
+
+```js
+assert(
+ __helpers
+ .removeCssComments(code)
+ .match(/.item5\s*?{[\s\S]*grid-area\s*?:\s*?footer\s*?;[\s\S]*}/gi)
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+
+
+```
+
+# --solutions--
+
+```html
+
+```
diff --git a/curriculum/challenges/chinese-traditional/01-responsive-web-design/css-grid/reduce-repetition-using-the-repeat-function.md b/curriculum/challenges/chinese-traditional/01-responsive-web-design/css-grid/reduce-repetition-using-the-repeat-function.md
new file mode 100644
index 0000000000..98f8fa1af2
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/01-responsive-web-design/css-grid/reduce-repetition-using-the-repeat-function.md
@@ -0,0 +1,93 @@
+---
+id: 5a94fe3669fb03452672e45f
+title: 使用 repeat 函數減少重複
+challengeType: 0
+videoUrl: 'https://scrimba.com/p/pByETK/cQvqyHR'
+forumTopicId: 301133
+dashedName: reduce-repetition-using-the-repeat-function
+---
+
+# --description--
+
+使用 `grid-template-columns` 或 `grid-template-rows` 定義網格結構時，你需要爲添加的每一行或每一列都輸入一個值。
+
+如果一個網格共有 100 行且每行高度相同， 那我們就需要輸入 100 個值，這顯然不太實際。 爲此，更好的方式是使用 `repeat` 方法指定行或列的重複次數，後面加上逗號以及需要重複的值。
+
+以下爲添加 100 行網格的例子，每行高度均爲 50px：
+
+```css
+grid-template-rows: repeat(100, 50px);
+```
+
+你還可以用 repeat 方法重複多個值，並在定義網格結構時與其他值一起使用。 比如：
+
+```css
+grid-template-columns: repeat(2, 1fr 50px) 20px;
+```
+
+效果相當於：
+
+```css
+grid-template-columns: 1fr 50px 1fr 50px 20px;
+```
+
+**注意：**`1fr 50px` 重複了兩次，後面跟着 20px。
+
+# --instructions--
+
+請用 `repeat` 代替 `grid-template-columns` 屬性值中的重複代碼。
+
+# --hints--
+
+class 爲 `container` 的元素應具有 `grid-template-columns` 屬性，其屬性值應設置爲重複 3 列，且每列寬度爲 `1fr`。
+
+```js
+assert(
+ code.match(
+ /.container\s*?{[\s\S]*grid-template-columns\s*?:\s*?repeat\s*?\(\s*?3\s*?,\s*?1fr\s*?\)\s*?;[\s\S]*}/gi
+ )
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+
+
+```
+
+# --solutions--
+
+```html
+
+```
diff --git a/curriculum/challenges/chinese-traditional/01-responsive-web-design/css-grid/use-css-grid-units-to-change-the-size-of-columns-and-rows.md b/curriculum/challenges/chinese-traditional/01-responsive-web-design/css-grid/use-css-grid-units-to-change-the-size-of-columns-and-rows.md
new file mode 100644
index 0000000000..5eb6ad0470
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/01-responsive-web-design/css-grid/use-css-grid-units-to-change-the-size-of-columns-and-rows.md
@@ -0,0 +1,83 @@
+---
+id: 5a9036ee38fddaf9a66b5d34
+title: 使用 CSS 網格單位來更改列和行的大小
+challengeType: 0
+videoUrl: 'https://scrimba.com/p/pByETK/cvE8phd'
+forumTopicId: 301134
+dashedName: use-css-grid-units-to-change-the-size-of-columns-and-rows
+---
+
+# --description--
+
+在 CSS 網格中，可以使用絕對單位（如 `px`）或相對單位（如 `em`）來定義行或列的大小。 下面的單位也可以使用：
+
+`fr`：設置列或行佔剩餘空間的比例，
+
+`auto`：設置列寬或行高自動等於它的內容的寬度或高度，
+
+`%`：將列或行調整爲它的容器寬度或高度的百分比，
+
+以下代碼爲右側預覽區中的效果：
+
+```css
+grid-template-columns: auto 50px 10% 2fr 1fr;
+```
+
+這段代碼添加了五個列。 第一列的寬與它的內容寬度相等；第二列寬 50px；第三列寬是它容器的 10%；最後兩列，將剩餘的寬度平均分成三份，第四列佔兩份，第五列佔一份。
+
+# --instructions--
+
+生成一個包含三列的網格，每列寬度分別爲：1fr、100px、2fr。
+
+# --hints--
+
+class 爲 `container` 的元素應具有 `grid-template-columns` 屬性且屬性值應爲 `1fr 100px 2fr`。
+
+```js
+assert(
+ code.match(
+ /.container\s*?{[\s\S]*grid-template-columns\s*?:\s*?1fr\s*?100px\s*?2fr\s*?;[\s\S]*}/gi
+ )
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+
+
+```
+
+# --solutions--
+
+```html
+
+```
diff --git a/curriculum/challenges/chinese-traditional/01-responsive-web-design/css-grid/use-grid-area-without-creating-an-areas-template.md b/curriculum/challenges/chinese-traditional/01-responsive-web-design/css-grid/use-grid-area-without-creating-an-areas-template.md
new file mode 100644
index 0000000000..7a4caf8963
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/01-responsive-web-design/css-grid/use-grid-area-without-creating-an-areas-template.md
@@ -0,0 +1,86 @@
+---
+id: 5a94fe2669fb03452672e45e
+title: 使用 grid-area 創建區域模板
+challengeType: 0
+videoUrl: 'https://scrimba.com/p/pByETK/c6N7VhK'
+forumTopicId: 301135
+dashedName: use-grid-area-without-creating-an-areas-template
+---
+
+# --description--
+
+我們在上一次挑戰中學到的 `grid-area` 屬性還有另一種使用方式。 如果網格中沒有定義區域模板，你也可以像這樣爲它添加一個模板：
+
+```css
+item1 { grid-area: 1/1/2/4; }
+```
+
+這裏使用了你之前學習的網格線編號來定義網格項的區域。 上例中數字代表這些值：
+
+```css
+grid-area: horizontal line to start at / vertical line to start at / horizontal line to end at / vertical line to end at;
+```
+
+因此，示例中的網格項將佔用第 1 條水平網格線（起始）和第 2 條水平網格線（終止）之間的行，及第 1 條垂直網格線（起始）和第 4 條垂直網格線（終止）之間的列。
+
+# --instructions--
+
+請用 `grid-area` 屬性將 class 爲 `item5` 的元素放置在第 3 條和第 4 條水平網格線，以及第 1 條和第 4 條垂直網格線之間的區域內。
+
+# --hints--
+
+class 爲 `item5` 的元素應具有 `grid-area` 屬性，且位於水平第三和第四條線、垂直第一和第四條線之間的區域。
+
+```js
+assert(
+ code.match(
+ /.item5\s*?{[\s\S]*grid-area\s*?:\s*?3\s*?\/\s*?1\s*?\/\s*?4\s*?\/\s*?4\s*?;[\s\S]*}/gi
+ )
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+
+
+```
+
+# --solutions--
+
+```html
+
+```
diff --git a/curriculum/challenges/chinese-traditional/01-responsive-web-design/css-grid/use-grid-column-to-control-spacing.md b/curriculum/challenges/chinese-traditional/01-responsive-web-design/css-grid/use-grid-column-to-control-spacing.md
new file mode 100644
index 0000000000..16a9985c3e
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/01-responsive-web-design/css-grid/use-grid-column-to-control-spacing.md
@@ -0,0 +1,139 @@
+---
+id: 5a90372638fddaf9a66b5d38
+title: 使用 grid-column 來控制空間大小
+challengeType: 0
+videoUrl: 'https://scrimba.com/p/pByETK/cnzkDSr'
+forumTopicId: 301136
+dashedName: use-grid-column-to-control-spacing
+---
+
+# --description--
+
+到目前爲止，所有的討論都是圍繞網格容器的。 `grid-column` 屬性是我們要討論的，第一個用於網格項本身的屬性。
+
+網格中，假想的水平線和垂直線被稱爲線（lines） 。 這些線在網格的左上角從 1 開始編號，垂直線向右、水平線向下累加計數。
+
+這是一個 3x3 網格的線條：
+
+
+
+要設置一個網格項佔據幾列，你可以使用 `grid-column` 屬性加上網格線條的編號來定義網格項開始和結束的位置。
+
+示例如下：
+
+```css
+grid-column: 1 / 3;
+```
+
+這會讓網格項從左側第一條線開始到第三條線結束，佔用兩列。
+
+# --instructions--
+
+請讓 class 爲 `item5` 的網格項佔用網格的最後兩列。
+
+# --hints--
+
+class 爲 `item5` 的元素應具有 `grid-column` 屬性。
+
+```js
+assert(
+ __helpers
+ .removeWhiteSpace($('style').text())
+ .match(/\.item5{.*grid-column:.*}/g)
+);
+```
+
+class 爲 `item5` 的元素應具有 `grid-column` 屬性，其屬性值應將元素設置爲佔用網格的最後兩列。
+
+```js
+const colStart = getComputedStyle($('.item5')[0]).gridColumnStart;
+const colEnd = getComputedStyle($('.item5')[0]).gridColumnEnd;
+const result = colStart.toString() + colEnd.toString();
+const correctResults = [
+ '24',
+ '2-1',
+ '2span 2',
+ '2span2',
+ 'span 2-1',
+ '-12',
+ 'span 2span 2',
+ 'span 2auto',
+ 'autospan 2'
+];
+assert(correctResults.includes(result));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+
+
+```
+
+# --solutions--
+
+```html
+
+
+
+```
diff --git a/curriculum/challenges/chinese-traditional/01-responsive-web-design/css-grid/use-grid-row-to-control-spacing.md b/curriculum/challenges/chinese-traditional/01-responsive-web-design/css-grid/use-grid-row-to-control-spacing.md
new file mode 100644
index 0000000000..0139014fdf
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/01-responsive-web-design/css-grid/use-grid-row-to-control-spacing.md
@@ -0,0 +1,122 @@
+---
+id: 5a90373638fddaf9a66b5d39
+title: 使用 grid-row 來控制空間大小
+challengeType: 0
+videoUrl: 'https://scrimba.com/p/pByETK/c9WBLU4'
+forumTopicId: 301137
+dashedName: use-grid-row-to-control-spacing
+---
+
+# --description--
+
+和設置一個網格項佔用多列類似，你也可以設置它佔用多行。 你可以使用 `grid-row` 屬性來定義一個網格項開始和結束的水平線。
+
+# --instructions--
+
+請讓 class 爲 `item5` 的元素佔用最後兩行。
+
+# --hints--
+
+class 爲 `item5` 的元素應具有 `grid-row` 屬性。
+
+```js
+assert(
+ __helpers.removeWhiteSpace($('style').text()).match(/\.item5{.*grid-row:.*}/g)
+);
+```
+
+class 爲 `item5` 的元素應具有 `grid-row` 屬性，其屬性值應將元素設置爲佔用網格的最後兩行。
+
+```js
+const rowStart = getComputedStyle($('.item5')[0]).gridRowStart;
+const rowEnd = getComputedStyle($('.item5')[0]).gridRowEnd;
+const result = rowStart.toString() + rowEnd.toString();
+const correctResults = [
+ '24',
+ '2-1',
+ '2span 2',
+ '2span2',
+ 'span 2-1',
+ '-12',
+ 'span 2span 2',
+ 'span 2auto',
+ 'autospan 2'
+];
+assert(correctResults.includes(result));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+
+
+```
+
+# --solutions--
+
+```html
+
+
+
+```
diff --git a/curriculum/challenges/chinese-traditional/01-responsive-web-design/css-grid/use-media-queries-to-create-responsive-layouts.md b/curriculum/challenges/chinese-traditional/01-responsive-web-design/css-grid/use-media-queries-to-create-responsive-layouts.md
new file mode 100644
index 0000000000..888572ec1e
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/01-responsive-web-design/css-grid/use-media-queries-to-create-responsive-layouts.md
@@ -0,0 +1,174 @@
+---
+id: 5a94fe7769fb03452672e463
+title: 使用媒體查詢創建響應式佈局
+challengeType: 0
+videoUrl: 'https://scrimba.com/p/pByETK/cMbqeHk'
+forumTopicId: 301138
+dashedName: use-media-queries-to-create-responsive-layouts
+---
+
+# --description--
+
+將 CSS 網格與使用媒體查詢結合使用，如使用媒體查詢重新排列網格區域、更改網格尺寸以及重新排列網格項位置，我們可以讓製作出的網站更具響應性。
+
+在右側的預覽區中，當網頁可視區域的寬不小於 300px 時，列數從 1 變爲 2。 並且，廣告（advertisement）區域會完全佔據左列。
+
+# --instructions--
+
+當網頁可視區域的寬不小於 `400px` 時，請讓 header 區域完全佔據最頂行，footer 區域完全佔據最底行。
+
+# --hints--
+
+當網頁可視區域的寬度爲 `400px` 或以上時，class 爲 `container` 的元素應具有 `grid-template-areas` 屬性，其屬性值能夠使 footer 和 header 區域分別佔據頂行和底行，advert 和 content 區域分別佔據中間行的左列和右列。
+
+```js
+assert(
+ __helpers
+ .removeCssComments(code)
+ .match(
+ /@media\s*?\(\s*?min-width\s*?:\s*?400px\s*?\)[\s\S]*.container\s*?{[\s\S]*grid-template-areas\s*?:\s*?"\s*?header\s*?header\s*?"\s*?"\s*?advert\s*?content\s*?"\s*?"\s*?footer\s*?footer\s*?"\s*?;[\s\S]*}/gi
+ )
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+
+
+
header
+
advert
+
content
+
footer
+
+
header
+
advert
+
content
+
footer
+
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vivamus quis tempus massa. Aenean erat nisl, gravida vel vestibulum cursus, interdum sit amet lectus. Sed sit amet quam nibh. Suspendisse quis tincidunt nulla. In hac habitasse platea dictumst. Ut sit amet pretium nisl. Vivamus vel mi sem. Aenean sit amet consectetur sem. Suspendisse pretium, purus et gravida consequat, nunc ligula ultricies diam, at aliquet velit libero a dui.
+```
+
+# --solutions--
+
+```html
+
+
+Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vivamus quis tempus massa. Aenean erat nisl, gravida vel vestibulum cursus, interdum sit amet lectus. Sed sit amet quam nibh. Suspendisse quis tincidunt nulla. In hac habitasse platea dictumst. Ut sit amet pretium nisl. Vivamus vel mi sem. Aenean sit amet consectetur sem. Suspendisse pretium, purus et gravida consequat, nunc ligula ultricies diam, at aliquet velit libero a dui.
+```
diff --git a/curriculum/challenges/chinese-traditional/01-responsive-web-design/responsive-web-design-principles/make-an-image-responsive.md b/curriculum/challenges/chinese-traditional/01-responsive-web-design/responsive-web-design-principles/make-an-image-responsive.md
new file mode 100644
index 0000000000..4bd99cab1b
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/01-responsive-web-design/responsive-web-design-principles/make-an-image-responsive.md
@@ -0,0 +1,77 @@
+---
+id: 587d78b1367417b2b2512b09
+title: 使圖片自適應設備尺寸
+challengeType: 0
+videoUrl: 'https://scrimba.com/p/pzrPu4/cz763UD'
+forumTopicId: 301140
+dashedName: make-an-image-responsive
+---
+
+# --description--
+
+用 CSS 來讓圖片自適應其實很簡單。 你只需要給圖片添加這些屬性:
+
+```css
+img {
+ max-width: 100%;
+ height: auto;
+}
+```
+
+設置 `max-width` 值爲 `100%` 可確保圖片不超出父容器的範圍；設置 `height` 屬性爲 `auto` 可以保持圖片的原始寬高比。
+
+# --instructions--
+
+給 `responsive-img` 添加樣式規則，使其成爲響應式的圖片。 它不應該超出父容器（在本例中，即預覽窗口）的範圍，並保持寬高比不變。 添加代碼後，拖動瀏覽器窗口，看看圖片發生什麼變化。
+
+# --hints--
+
+`responsive-img` 類應將 `max-width` 設置爲 `100%`。
+
+```js
+assert(getComputedStyle($('.responsive-img')[0]).maxWidth === '100%');
+```
+
+`responsive-img` 類應將 `height` 設置爲 `auto`。
+
+```js
+assert(code.match(/height:\s*?auto;/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+
+vw：如 10vw 的意思是視窗寬度的 10%。vh： 如 3vh 的意思是視窗高度的 3%。vmin： 如 70vmin 的意思是視窗的高度和寬度中較小一個的 70%。vmax： 如 100vmax 的意思是視窗的高度和寬度中較大一個的 100%。Importantus Ipsum
+Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vivamus quis tempus massa. Aenean erat nisl, gravida vel vestibulum cursus, interdum sit amet lectus. Sed sit amet quam nibh. Suspendisse quis tincidunt nulla. In hac habitasse platea dictumst. Ut sit amet pretium nisl. Vivamus vel mi sem. Aenean sit amet consectetur sem. Suspendisse pretium, purus et gravida consequat, nunc ligula ultricies diam, at aliquet velit libero a dui.
+```
+
+# --solutions--
+
+```html
+
+
+Importantus Ipsum
+Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vivamus quis tempus massa. Aenean erat nisl, gravida vel vestibulum cursus, interdum sit amet lectus. Sed sit amet quam nibh. Suspendisse quis tincidunt nulla. In hac habitasse platea dictumst. Ut sit amet pretium nisl. Vivamus vel mi sem. Aenean sit amet consectetur sem. Suspendisse pretium, purus et gravida consequat, nunc ligula ultricies diam, at aliquet velit libero a dui.
+```
diff --git a/curriculum/challenges/chinese-traditional/01-responsive-web-design/responsive-web-design-principles/use-a-retina-image-for-higher-resolution-displays.md b/curriculum/challenges/chinese-traditional/01-responsive-web-design/responsive-web-design-principles/use-a-retina-image-for-higher-resolution-displays.md
new file mode 100644
index 0000000000..b6007c8866
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/01-responsive-web-design/responsive-web-design-principles/use-a-retina-image-for-higher-resolution-displays.md
@@ -0,0 +1,64 @@
+---
+id: 587d78b1367417b2b2512b0a
+title: 針對高分辨率屏幕應使用視網膜圖片
+challengeType: 0
+videoUrl: 'https://scrimba.com/p/pzrPu4/cVZ4Rfp'
+forumTopicId: 301142
+dashedName: use-a-retina-image-for-higher-resolution-displays
+---
+
+# --description--
+
+隨着聯網設備的增加，設備間的區別不僅發生在尺寸和規格上，還發生在用於顯示的設備上。 像素密度就是區分不同顯示設備的一個指標，它一般會以 PPI（Pixel Per Inch，即每英寸像素）或 DPI（每英寸點數）爲計量單位。 最著名的顯示器就是 Apple MacBook Pro 筆記本電腦上的“視網膜顯示屏”（現亦用於 iMac）。 由於“視網膜顯示屏”和“非視網膜顯示屏”顯示器之間像素密度的不同，某些未考慮高分辨率顯示器的圖像在高分辨率顯示器上渲染時，可能因出現“像素化”而不夠清晰。
+
+讓圖像正確出現在高分辨率顯示器（例如 MacBook Pros “Revistina display”）上的最簡單方式， 是定義它們的 `width` 和 `height` 值爲原始值的一半。 下面是一個僅使用原始高度和寬度一半的圖像示例：
+
+```html
+
+。
+
+在滿足以下[需求](https://en.wikipedia.org/wiki/User_story)並能通過所有測試的前提下， 你可以根據自己的喜好來美化你的 app。
+
+你可以使用 HTML、JavaScript 以及 CSS 來完成項目。 由於目前你只學到了 CSS 課程，所以我們建議你只使用 CSS 來完成這個項目，同時鞏固一下你之前所學的內容。 你也可以使用 Bootstrap 或者 SASS。 我們不推薦你在這個項目中使用其他技術（比如 jQuery、React、Angular 或 Vue）。 在後續的其他項目中，你將有機會使用像是 React 等其他技術棧。 我們會接受並嘗試修復你在使用推薦技術棧創建項目時報告的問題。 祝你編碼愉快！
+
+**需求 1：** 此 app 中應存在一個 id 爲 `welcome-section` 的歡迎區。
+
+**需求 2：** 歡迎區內應存在一個包含標題文本的 `h1` 元素。
+
+**需求 3：** 此 app 中應存在一個 id 爲 `projects` 的項目展示區。
+
+**需求 4：** 項目展示區應至少包含一個 class 爲 `project-tile` 的元素來展示項目。
+
+**需求 5：** 項目展示區應至少包含一個鏈接到項目的超鏈接元素。
+
+**需求 6：** 此 app 中應存在一個 id 爲 `navbar` 的導航欄。
+
+**需求 7：** 導航欄中應包含一個可以滾動到本頁面不同區域的鏈接。
+
+**需求 8：** 此 app 中應包含一個 id 爲 `profile-link` 的鏈接。 點擊這個鏈接時，它應在瀏覽器的新標籤頁內打開我的 GitHub 或者 FCC 作品集頁面。
+
+**需求 9：** 在此 app 中，應至少使用一次媒體查詢。
+
+**需求 10：** 歡迎區的高度應該與視口的高度保持一致。
+
+**需求 11：** 導航欄應始終保持在視口頂部。
+
+你可以使用這個 CodePen 模版 創建你自己的項目，點擊 `Save` 即可創建你的新項目。 也可以使用此 CDN 鏈接在任何你喜歡的環境中運行測試：`https://cdn.freecodecamp.org/testable-projects-fcc/v1/bundle.js`。
+
+完成項目並通過所有測試後，請輸入你的項目在 CodePen 上的鏈接並提交。
+
+# --solutions--
+
+```html
+// solution required
+```
diff --git a/curriculum/challenges/chinese-traditional/01-responsive-web-design/responsive-web-design-projects/build-a-product-landing-page.md b/curriculum/challenges/chinese-traditional/01-responsive-web-design/responsive-web-design-projects/build-a-product-landing-page.md
new file mode 100644
index 0000000000..d9f6fe7aa6
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/01-responsive-web-design/responsive-web-design-projects/build-a-product-landing-page.md
@@ -0,0 +1,55 @@
+---
+id: 587d78af367417b2b2512b04
+title: 製作一個產品登錄頁
+challengeType: 3
+forumTopicId: 301144
+dashedName: build-a-product-landing-page
+---
+
+# --description--
+
+**目標：** 在 [CodePen.io](https://codepen.io) 上創建一個與這個功能類似的 app：。
+
+在滿足以下[需求](https://en.wikipedia.org/wiki/User_story)並能通過所有測試的前提下， 你可以根據自己的喜好來美化你的 app。
+
+你可以使用 HTML、JavaScript 以及 CSS 來完成項目。 由於目前你只學到了 CSS 課程，所以我們建議你只使用 CSS 來完成這個項目，同時鞏固一下你之前所學的內容。 你也可以使用 Bootstrap 或者 SASS。 我們不推薦你在這個項目中使用其他技術（比如 jQuery、React、Angular 或 Vue）。 在後續的其他項目中，你將有機會使用像是 React 等其他技術棧。 我們會接受並嘗試修復你在使用推薦技術棧創建項目時報告的問題。 祝你編碼愉快！
+
+**需求 1：** 產品登陸頁應存在 `id="header"` 的 `header` 元素。
+
+**需求 2：** 在 `header` 元素內應存在 `id="header-img"` 的圖像， 這裏通常用來放置公司的 logo。
+
+**需求 3：** 在 `#header` 元素內，應存在一個 `id="nav-bar"` 的 `nav` 元素。
+
+**需求 4：** `nav` 元素中應至少包含三個 class 爲 `nav-link` 且可點擊的元素。
+
+**需求 5：** 當點擊 `nav` 內的 `.nav-link` 按鈕時，應滾動到產品主頁上相應的部分。
+
+**需求 6：** 頁面上應存在 `id="video"` 的嵌入式視頻播放區域。
+
+**需求 7：** 產品登陸頁應存在一個 `id="form"` 的 `form` 元素。
+
+**需求 8：** 在表單中，應存在一個 `id="email"` 的 `input` 輸入框供用戶填寫郵箱。
+
+**需求 9：** `#email` 輸入框內應存在描述該區域用途的佔位符文字。
+
+**需求 10：** `#email` 輸入框應使用 HTML5 驗證來確認輸入的內容是否爲郵箱。
+
+**需求 11：** 在表單中，應存在一個 `id="submit"` 的 `input` 提交按鈕。
+
+**需求 12：** 當點擊 `#submit` 元素時，應將郵箱信息提交到一個靜態頁面（請使用這個模擬的 URL：）。
+
+**需求 13：** navbar 應保持在視口（viewport）的頂部。
+
+**需求 14：** 在此 app 中，應至少使用一次媒體查詢。
+
+**需求 15：** 在此 app 中，應至少使用一次 CSS 的 flexbox 佈局。
+
+你可以使用這個 CodePen 模版 創建你自己的項目，點擊 `Save` 即可創建你的新項目。 也可以使用此 CDN 鏈接在任何你喜歡的環境中運行測試：`https://cdn.freecodecamp.org/testable-projects-fcc/v1/bundle.js`。
+
+完成項目並通過所有測試後，請輸入你的項目在 CodePen 上的鏈接並提交。
+
+# --solutions--
+
+```html
+// solution required
+```
diff --git a/curriculum/challenges/chinese-traditional/01-responsive-web-design/responsive-web-design-projects/build-a-survey-form.md b/curriculum/challenges/chinese-traditional/01-responsive-web-design/responsive-web-design-projects/build-a-survey-form.md
new file mode 100644
index 0000000000..aece4b7737
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/01-responsive-web-design/responsive-web-design-projects/build-a-survey-form.md
@@ -0,0 +1,57 @@
+---
+id: 587d78af367417b2b2512b03
+title: 製作一個調查表格
+challengeType: 3
+forumTopicId: 301145
+dashedName: build-a-survey-form
+---
+
+# --description--
+
+**目標：** 在 [CodePen.io](https://codepen.io) 上創建一個與這個功能類似的 app：。
+
+在滿足以下 [需求](https://en.wikipedia.org/wiki/User_story) 並能通過所有測試的前提下， 你可以根據自己的喜好來美化你的 app。
+
+你可以使用 HTML、JavaScript 以及 CSS 來完成項目。 由於目前你只學到了 CSS 課程，所以我們建議你只使用 CSS 來完成這個項目，同時鞏固一下你之前所學的內容。 你也可以使用 Bootstrap 或者 SASS。 我們不推薦你在這個項目中使用其他技術（比如 jQuery、React、Angular 或 Vue）。 在後續的其他項目中，你將有機會使用像是 React 等其他技術棧。 我們會接受並嘗試修復你在使用推薦技術棧創建項目時報告的問題。 祝你編碼愉快！
+
+**需求 1：** 此 app 中應存在一個 `id="title"` 的大小爲 H1 的標題。
+
+**需求 2：** 此 app 中應存在一段 `id="description"` 的大小爲 P 的短小的描述。
+
+**需求 3：** 此 app 中應存在一個 `id="survey-form"` 的 `form` 元素。
+
+**需求 4：** 在表單元素內，應存在 `id="name"` 的輸入框（必填項），以便用戶輸入姓名。
+
+**需求 5：** 在表單元素內，應存在 `id="email"` 的輸入框（必填項），以便用戶輸入郵箱。
+
+**需求 6：** 如果用戶輸入了格式不正確的郵箱，則應出現來自 HTML5 表單數據校驗的錯誤信息。
+
+**需求 7：** 在表單內，用戶應可以在 `id="number"` 的輸入框中輸入數字。
+
+**需求 8：** 如果用戶在數字輸入框內輸入非數字內容，則應出現來自 HTML5 表單數據校驗的錯誤信息。
+
+**需求 9：** 如果用戶輸入的數字超出了使用 `min` 和 `max` 屬性定義的範圍，則應出現來自 HTML5 表單數據校驗的錯誤信息。
+
+**需求 10：** 表單中的姓名、郵箱和數字輸入框需有對應的包含描述輸入框用途的標籤。這些標籤的 id 應分別爲 `id="name-label"`、`id="email-label"` 和 `id="number-label"`。
+
+**需求 11：** 表單中的姓名、郵箱和數字輸入框需有對應的描述文字作爲佔位符。
+
+**需求 12：** 在表單元素內，應存在一個 `id="dropdown"` 的下拉列表，用戶可以從中選取一個選項。
+
+**需求 13：** 在表單元素內，應至少存在一組單選按鈕，用戶可以從中選取一個選項。 每組應使用 `name` 屬性進行分組。
+
+**需求 14：** 在表單元素內，應存在幾個複選框，且每個複選框都應有 `value` 屬性。
+
+**需求 15：** 在表單元素的最後，應存在一個 `textarea` 元素，以便用戶輸入額外的批註。
+
+**需求 16：** 在表單元素內，應存在一個 `id="submit"` 的按鈕，以便用戶提交表單。
+
+你可以使用這個 CodePen 模版 創建你自己的項目，點擊 `Save` 即可創建你的新項目。 也可以使用此 CDN 鏈接在任何你喜歡的環境中運行測試：`https://cdn.freecodecamp.org/testable-projects-fcc/v1/bundle.js`。
+
+完成項目並通過所有測試後，請輸入你的項目在 CodePen 上的鏈接並提交。
+
+# --solutions--
+
+```html
+// solution required
+```
diff --git a/curriculum/challenges/chinese-traditional/01-responsive-web-design/responsive-web-design-projects/build-a-technical-documentation-page.md b/curriculum/challenges/chinese-traditional/01-responsive-web-design/responsive-web-design-projects/build-a-technical-documentation-page.md
new file mode 100644
index 0000000000..a7aa06ba99
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/01-responsive-web-design/responsive-web-design-projects/build-a-technical-documentation-page.md
@@ -0,0 +1,55 @@
+---
+id: 587d78b0367417b2b2512b05
+title: 製作一個技術文檔頁面
+challengeType: 3
+forumTopicId: 301146
+dashedName: build-a-technical-documentation-page
+---
+
+# --description--
+
+**目標：** 在 [CodePen.io](https://codepen.io) 上創建一個與這個功能類似的 app：。
+
+在滿足以下 [需求](https://en.wikipedia.org/wiki/User_story) 並能通過所有測試的前提下， 你可以根據自己的喜好來美化你的 app。
+
+你可以使用 HTML、JavaScript 以及 CSS 來完成項目。 由於目前你只學到了 CSS 課程，所以我們建議你只使用 CSS 來完成這個項目，同時鞏固一下你之前所學的內容。 你也可以使用 Bootstrap 或者 SASS。 我們不推薦你在這個項目中使用其他技術（比如 jQuery、React、Angular 或 Vue）。 在後續的其他項目中，你將有機會使用像是 React 等其他技術棧。 我們會接受並嘗試修復你在使用推薦技術棧創建項目時報告的問題。 祝你編碼愉快！
+
+**需求 1：** 此 app 中應存在一個 `id="main-doc"` 的 `main` 元素，它包含頁面的主要內容（技術文檔）。
+
+**需求 2：** 在 `#main-doc` 元素內，應有一些 `section` 元素，每個元素的 class 都應爲 `main-section`。 應存在至少 5 個這樣的元素。
+
+**需求 3：** 每個 `.main-section` 內的第一個元素應爲 `header` 元素，其中包含描述該部分主題的內容文本。
+
+**需求 4：** 類名爲 `main-section` 的每個 `section` 元素都應有一個與包含在其中的每個 `header` 的文本相對應的 id， 所有空格都應該被替換爲下劃線（例如，包含標題 “JavaScript and Java” 的 `section` 應有一個相應的 `id="JavaScript_and_Java"`）。
+
+**需求 5：** 所有 `.main-section` 元素內總計應有至少 10 個 `p` 元素。
+
+**需求 6：** 所有 `.main-section` 元素內總計應有至少 5 個 `code` 元素。
+
+**需求 7：** 所有 `.main-section` 元素內總計應有至少 5 個 `li` 元素。
+
+**需求 8：** 此 app 中應存在一個 `id="navbar"` 的 `nav` 元素。
+
+**需求 9：** navbar 元素內應有一個 `header` 元素，其中包含描述技術文檔主題的內容文本。
+
+**需求 10：** 此外，navbar 元素應包含 class 爲 `nav-link` 的 `a` 元素， 每個 class 爲 `main-section` 的元素都需要有一個。
+
+**需求 11：** navbar 中的 `header` 元素應置於 navbar 中所有 `a` 元素之前。
+
+**需求 12：** 所有 class 爲 `nav-link` 的元素都需要包含與 `section` 中 `header` 相應的內容文本。例如，對於一個文本爲 "Hello world" 的一節或標題，你的 navbar 中也應存在一個內容文本爲 "Hello world" 的元素。
+
+**需求 13：** 當點擊 navbar 中一個元素時，頁面應滾動到 `main-doc` 中的相應部分。例如，點擊文本爲 "Hello world" 的 `nav-link` 元素的時候，頁面應滾動到包含相同內容的 `header` 和 id 所處的 `section` 元素。
+
+**需求 14：** 在常規尺寸的設備上（如筆記本電腦和臺式機），`id="navbar"` 的元素應顯示在屏幕左側，且始終對用戶可見。
+
+**需求 15：** 在此 app 中，應至少使用一次媒體查詢。
+
+你可以使用這個 CodePen 模版 創建你自己的項目，點擊 `Save` 即可創建你的新項目。 也可以使用此 CDN 鏈接在任何你喜歡的環境中運行測試：`https://cdn.freecodecamp.org/testable-projects-fcc/v1/bundle.js`。
+
+完成項目並通過所有測試後，請輸入你的項目在 CodePen 上的鏈接並提交。
+
+# --solutions--
+
+```html
+// solution required
+```
diff --git a/curriculum/challenges/chinese-traditional/01-responsive-web-design/responsive-web-design-projects/build-a-tribute-page.md b/curriculum/challenges/chinese-traditional/01-responsive-web-design/responsive-web-design-projects/build-a-tribute-page.md
new file mode 100644
index 0000000000..240b3bf3e8
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/01-responsive-web-design/responsive-web-design-projects/build-a-tribute-page.md
@@ -0,0 +1,43 @@
+---
+id: bd7158d8c442eddfaeb5bd18
+title: 製作一個致敬頁
+challengeType: 3
+forumTopicId: 301147
+dashedName: build-a-tribute-page
+---
+
+# --description--
+
+**目標：** 在 [CodePen.io](https://codepen.io) 上創建一個與這個功能類似的 app：。
+
+在滿足以下 [需求](https://en.wikipedia.org/wiki/User_story) 並能通過所有測試的前提下， 你可以根據自己的喜好來美化你的 app。
+
+你可以使用 HTML、JavaScript 以及 CSS 來完成項目。 由於目前你只學到了 CSS 課程，所以我們建議你只使用 CSS 來完成這個項目，同時鞏固一下你之前所學的內容。 你也可以使用 Bootstrap 或者 SASS。 我們不推薦你在這個項目中使用其他技術（比如 jQuery、React、Angular 或 Vue）。 在後續的其他項目中，你將有機會使用像是 React 等其他技術棧。 我們會接受並嘗試修復你在使用推薦技術棧創建項目時報告的問題。 祝你編碼愉快！
+
+**需求 1：** 此 app 中應存在一個 `id="main"` 的元素，頁面上的所有元素都應置於這個元素中。
+
+**需求 2：** 此 app 中應存在一個 `id="title"` 的元素，其中包含描述致敬頁主題的字符串文本，如 "Dr. Norman Borlaug"。
+
+**需求 3：** 此 app 中應存在一個 `id="img-div"` 的 `div` 元素。
+
+**需求 4：** 在 `img-div` 元素內，應存在一個 `id="image"` 的 `img` 元素。
+
+**需求 5：** 在 `img-div` 元素內，應存在一個相應的 `id="img-caption"` 的元素，其中包含對 `img-div` 中圖像的描述文本。
+
+**需求 6：** 此 app 中應存在一個 `id="tribute-info"` 的元素，其中應包含描述致敬頁主題的內容文本。
+
+**需求 7：** 此 app 中應存在一個 `id="tribute-link"` 的 `a` 元素，它應鏈接到一個包含有關致敬頁主題額外信息的外部網頁。 提示：你必須爲 a 元素提供 `target` 屬性，並將其屬性值設置爲 `_blank`（即 `target="_blank"`），這樣纔可以在新選項卡中打開鏈接。
+
+**需求 8：** `img` 元素應相對於其父元素的寬度自動調整大小，但不超過圖片的原始大小。
+
+**需求 9：** `img` 應在其父元素內居中。
+
+你可以使用這個 CodePen 模版 創建你的新項目，點擊 `Save` 即可創建你的新項目。 也可以使用此 CDN 鏈接在任何你喜歡的環境中運行測試：`https://cdn.freecodecamp.org/testable-projects-fcc/v1/bundle.js`。
+
+完成項目並通過所有測試後，請輸入你的項目在 CodePen 上的鏈接並提交。
+
+# --solutions--
+
+```html
+// solution required
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/boo-who.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/boo-who.md
new file mode 100644
index 0000000000..ea3efe0f93
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/boo-who.md
@@ -0,0 +1,97 @@
+---
+id: a77dbc43c33f39daa4429b4f
+title: 基本類型布爾值的檢查
+challengeType: 5
+forumTopicId: 16000
+dashedName: boo-who
+---
+
+# --description--
+
+檢查一個值是否是基本類型中的布爾值（boolean）類型。 函數應返回 `true` 或者 `false`。
+
+基本類型中的布爾值爲 `true` 或者 `false`。
+
+# --hints--
+
+`booWho(true)` 應返回 `true`。
+
+```js
+assert.strictEqual(booWho(true), true);
+```
+
+`booWho(false)` 應該返回 `true`。
+
+```js
+assert.strictEqual(booWho(false), true);
+```
+
+`booWho([1, 2, 3])` 應該返回 `false`。
+
+```js
+assert.strictEqual(booWho([1, 2, 3]), false);
+```
+
+`booWho([].slice)` 應該返回 `false`。
+
+```js
+assert.strictEqual(booWho([].slice), false);
+```
+
+`booWho({ "a": 1 })` 應該返回 `false`。
+
+```js
+assert.strictEqual(booWho({ a: 1 }), false);
+```
+
+`booWho(1)` 應該返回 `false`。
+
+```js
+assert.strictEqual(booWho(1), false);
+```
+
+`booWho(NaN)` 應該返回 `false`。
+
+```js
+assert.strictEqual(booWho(NaN), false);
+```
+
+`booWho("a")` 應該返回 `false`。
+
+```js
+assert.strictEqual(booWho('a'), false);
+```
+
+`booWho("true")` 應該返回 `false`。
+
+```js
+assert.strictEqual(booWho('true'), false);
+```
+
+`booWho("false")` 應該返回 `false`。
+
+```js
+assert.strictEqual(booWho('false'), false);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function booWho(bool) {
+ return bool;
+}
+
+booWho(null);
+```
+
+# --solutions--
+
+```js
+function booWho(bool) {
+ return typeof bool === "boolean";
+}
+
+booWho(null);
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/chunky-monkey.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/chunky-monkey.md
new file mode 100644
index 0000000000..2ac50346ef
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/chunky-monkey.md
@@ -0,0 +1,110 @@
+---
+id: a9bd25c716030ec90084d8a1
+title: 分割數組
+challengeType: 5
+forumTopicId: 16005
+dashedName: chunky-monkey
+---
+
+# --description--
+
+請編寫一個函數，該函數將一個數組（第一個參數）拆分成若干長度爲 `size`（第二個參數）的子數組，並將它們作爲二維數組返回。
+
+# --hints--
+
+`chunkArrayInGroups(["a", "b", "c", "d"], 2)` 應返回 `[["a", "b"], ["c", "d"]]`。
+
+```js
+assert.deepEqual(chunkArrayInGroups(['a', 'b', 'c', 'd'], 2), [
+ ['a', 'b'],
+ ['c', 'd']
+]);
+```
+
+`chunkArrayInGroups([0, 1, 2, 3, 4, 5], 3)` 應返回 `[[0, 1, 2], [3, 4, 5]]`。
+
+```js
+assert.deepEqual(chunkArrayInGroups([0, 1, 2, 3, 4, 5], 3), [
+ [0, 1, 2],
+ [3, 4, 5]
+]);
+```
+
+`chunkArrayInGroups([0, 1, 2, 3, 4, 5], 2)` 應返回 `[[0, 1], [2, 3], [4, 5]]`。
+
+```js
+assert.deepEqual(chunkArrayInGroups([0, 1, 2, 3, 4, 5], 2), [
+ [0, 1],
+ [2, 3],
+ [4, 5]
+]);
+```
+
+`chunkArrayInGroups([0, 1, 2, 3, 4, 5], 4)` 應返回 `[[0, 1, 2, 3], [4, 5]]`。
+
+```js
+assert.deepEqual(chunkArrayInGroups([0, 1, 2, 3, 4, 5], 4), [
+ [0, 1, 2, 3],
+ [4, 5]
+]);
+```
+
+`chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6], 3)` 應返回 `[[0, 1, 2], [3, 4, 5], [6]]`。
+
+```js
+assert.deepEqual(chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6], 3), [
+ [0, 1, 2],
+ [3, 4, 5],
+ [6]
+]);
+```
+
+`chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6, 7, 8], 4)` 應返回 `[[0, 1, 2, 3], [4, 5, 6, 7], [8]]`。
+
+```js
+assert.deepEqual(chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6, 7, 8], 4), [
+ [0, 1, 2, 3],
+ [4, 5, 6, 7],
+ [8]
+]);
+```
+
+`chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6, 7, 8], 2)` 應返回 `[[0, 1], [2, 3], [4, 5], [6, 7], [8]]`。
+
+```js
+assert.deepEqual(chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6, 7, 8], 2), [
+ [0, 1],
+ [2, 3],
+ [4, 5],
+ [6, 7],
+ [8]
+]);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function chunkArrayInGroups(arr, size) {
+ return arr;
+}
+
+chunkArrayInGroups(["a", "b", "c", "d"], 2);
+```
+
+# --solutions--
+
+```js
+function chunkArrayInGroups(arr, size) {
+ let out = [];
+
+ for (let i = 0; i < arr.length; i += size) {
+ out.push(arr.slice(i, i + size));
+ }
+
+ return out;
+}
+
+chunkArrayInGroups(["a", "b", "c", "d"], 2);
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/confirm-the-ending.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/confirm-the-ending.md
new file mode 100644
index 0000000000..31e280744b
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/confirm-the-ending.md
@@ -0,0 +1,113 @@
+---
+id: acda2fb1324d9b0fa741e6b5
+title: 確認結尾
+challengeType: 5
+forumTopicId: 16006
+dashedName: confirm-the-ending
+---
+
+# --description--
+
+檢查字符串（第一個參數 `str`）是否以給定的目標字符串（第二個參數 `target`）結束。
+
+這個挑戰 *可以* 用 ES2015 引入的 `.endsWith()` 方法來解決。但在這個挑戰中，請使用 JavaScript 的字符串子串方法。
+
+# --hints--
+
+`confirmEnding("Bastian", "n")` 應返回 `true`。
+
+```js
+assert(confirmEnding('Bastian', 'n') === true);
+```
+
+`confirmEnding("Congratulation", "on")` 應返回 `true`。
+
+```js
+assert(confirmEnding('Congratulation', 'on') === true);
+```
+
+`confirmEnding("Connor", "n")` 應返回 `false`。
+
+```js
+assert(confirmEnding('Connor', 'n') === false);
+```
+
+`confirmEnding("Walking on water and developing software from a specification are easy if both are frozen", "specification")` 應返回 `false`。
+
+```js
+assert(
+ confirmEnding(
+ 'Walking on water and developing software from a specification are easy if both are frozen',
+ 'specification'
+ ) === false
+);
+```
+
+`confirmEnding("He has to give me a new name", "name")` 應返回 `true`。
+
+```js
+assert(confirmEnding('He has to give me a new name', 'name') === true);
+```
+
+`confirmEnding("Open sesame", "same")` 應返回 `true`。
+
+```js
+assert(confirmEnding('Open sesame', 'same') === true);
+```
+
+`confirmEnding("Open sesame", "sage")` 應返回 `false`。
+
+```js
+assert(confirmEnding('Open sesame', 'sage') === false);
+```
+
+`confirmEnding("Open sesame", "game")` 應返回 `false`。
+
+```js
+assert(confirmEnding('Open sesame', 'game') === false);
+```
+
+`confirmEnding("If you want to save our world, you must hurry. We dont know how much longer we can withstand the nothing", "mountain")` 應返回 `false`。
+
+```js
+assert(
+ confirmEnding(
+ 'If you want to save our world, you must hurry. We dont know how much longer we can withstand the nothing',
+ 'mountain'
+ ) === false
+);
+```
+
+`confirmEnding("Abstraction", "action")` 應該返回 `true`。
+
+```js
+assert(confirmEnding('Abstraction', 'action') === true);
+```
+
+不應使用內置方法 `.endsWith()` 來完成挑戰。
+
+```js
+assert(!/\.endsWith\(.*?\)\s*?;?/.test(code) && !/\['endsWith'\]/.test(code));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function confirmEnding(str, target) {
+ return str;
+}
+
+confirmEnding("Bastian", "n");
+```
+
+# --solutions--
+
+```js
+function confirmEnding(str, target) {
+ return str.substring(str.length - target.length) === target;
+}
+
+confirmEnding("Bastian", "n");
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/convert-celsius-to-fahrenheit.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/convert-celsius-to-fahrenheit.md
new file mode 100644
index 0000000000..2d320ffa6c
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/convert-celsius-to-fahrenheit.md
@@ -0,0 +1,76 @@
+---
+id: 56533eb9ac21ba0edf2244b3
+title: 將攝氏度轉換爲華氏度
+challengeType: 1
+forumTopicId: 16806
+dashedName: convert-celsius-to-fahrenheit
+---
+
+# --description--
+
+將攝氏度轉換爲華氏度的計算方式爲：攝氏度乘以 `9/5` 然後加上 `32`。
+
+輸入參數 `celsius` 代表一個攝氏度的溫度。 使用已定義的變量 `fahrenheit`，並賦值爲相應的華氏度的溫度值。 根據上述轉換公式來進行轉換。
+
+# --hints--
+
+`convertToF(0)` 應返回一個數字。
+
+```js
+assert(typeof convertToF(0) === 'number');
+```
+
+`convertToF(-30)` 應返回 `-22`。
+
+```js
+assert(convertToF(-30) === -22);
+```
+
+`convertToF(-10)` 應返回 `14`。
+
+```js
+assert(convertToF(-10) === 14);
+```
+
+`convertToF(0)` 應返回 `32`。
+
+```js
+assert(convertToF(0) === 32);
+```
+
+`convertToF(20)` 應返回 `68`。
+
+```js
+assert(convertToF(20) === 68);
+```
+
+`convertToF(30)` 應返回 `86`。
+
+```js
+assert(convertToF(30) === 86);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function convertToF(celsius) {
+ let fahrenheit;
+ return fahrenheit;
+}
+
+convertToF(30);
+```
+
+# --solutions--
+
+```js
+function convertToF(celsius) {
+ let fahrenheit = celsius * 9/5 + 32;
+
+ return fahrenheit;
+}
+
+convertToF(30);
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/factorialize-a-number.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/factorialize-a-number.md
new file mode 100644
index 0000000000..73ec1d66a0
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/factorialize-a-number.md
@@ -0,0 +1,73 @@
+---
+id: a302f7aae1aa3152a5b413bc
+title: 計算整數的階乘
+challengeType: 5
+forumTopicId: 16013
+dashedName: factorialize-a-number
+---
+
+# --description--
+
+返回一個給定整數的階乘計算結果。
+
+對於整數 `n`，n 的階乘就是所有小於等於 `n` 的正整數的乘積。
+
+階乘通常用符號 `n!` 來表示。
+
+例如：`5! = 1 * 2 * 3 * 4 * 5 = 120`
+
+在這個挑戰中，只有非負整數會作爲參數傳入函數。
+
+# --hints--
+
+`factorialize(5)` 應返回一個數字。
+
+```js
+assert(typeof factorialize(5) === 'number');
+```
+
+`factorialize(5)` 應該返回 `120`。
+
+```js
+assert(factorialize(5) === 120);
+```
+
+`factorialize(10)` 應該返回 `3628800`。
+
+```js
+assert(factorialize(10) === 3628800);
+```
+
+`factorialize(20)` 應該返回 `2432902008176640000`。
+
+```js
+assert(factorialize(20) === 2432902008176640000);
+```
+
+`factorialize(0)` 應該返回 `1`。
+
+```js
+assert(factorialize(0) === 1);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function factorialize(num) {
+ return num;
+}
+
+factorialize(5);
+```
+
+# --solutions--
+
+```js
+function factorialize(num) {
+ return num < 1 ? 1 : num * factorialize(num - 1);
+}
+
+factorialize(5);
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/falsy-bouncer.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/falsy-bouncer.md
new file mode 100644
index 0000000000..12f812154e
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/falsy-bouncer.md
@@ -0,0 +1,63 @@
+---
+id: adf08ec01beb4f99fc7a68f2
+title: 過濾數組中的假值
+challengeType: 5
+forumTopicId: 16014
+dashedName: falsy-bouncer
+---
+
+# --description--
+
+從數組中移除所有假值（falsy values）。
+
+JavaScript 中的假值有 `false`、`null`、`0`、`""`、`undefined`、`NaN`。
+
+提示：可以考慮將每個值都轉換爲布爾值（boolean）。
+
+# --hints--
+
+`bouncer([7, "ate", "", false, 9])` 應返回 `[7, "ate", 9]`。
+
+```js
+assert.deepEqual(bouncer([7, 'ate', '', false, 9]), [7, 'ate', 9]);
+```
+
+`bouncer(["a", "b", "c"])` 應返回 `["a", "b", "c"]`。
+
+```js
+assert.deepEqual(bouncer(['a', 'b', 'c']), ['a', 'b', 'c']);
+```
+
+`bouncer([false, null, 0, NaN, undefined, ""])` 應返回 `[]`。
+
+```js
+assert.deepEqual(bouncer([false, null, 0, NaN, undefined, '']), []);
+```
+
+`bouncer([null, NaN, 1, 2, undefined])` 應返回 `[1, 2]`。
+
+```js
+assert.deepEqual(bouncer([null, NaN, 1, 2, undefined]), [1, 2]);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function bouncer(arr) {
+ return arr;
+}
+
+bouncer([7, "ate", "", false, 9]);
+```
+
+# --solutions--
+
+```js
+function bouncer(arr) {
+ return arr.filter(e => e);
+}
+
+bouncer([7, "ate", "", false, 9]);
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/find-the-longest-word-in-a-string.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/find-the-longest-word-in-a-string.md
new file mode 100644
index 0000000000..c51b7e6fdc
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/find-the-longest-word-in-a-string.md
@@ -0,0 +1,87 @@
+---
+id: a26cbbe9ad8655a977e1ceb5
+title: 找出字符串中的最長單詞
+challengeType: 5
+forumTopicId: 16015
+dashedName: find-the-longest-word-in-a-string
+---
+
+# --description--
+
+返回給出的句子中，最長單詞的長度。
+
+函數的返回值應是一個數字。
+
+# --hints--
+
+`findLongestWordLength("The quick brown fox jumped over the lazy dog")` 應返回一個數字。
+
+```js
+assert(
+ typeof findLongestWordLength(
+ 'The quick brown fox jumped over the lazy dog'
+ ) === 'number'
+);
+```
+
+`findLongestWordLength("The quick brown fox jumped over the lazy dog")` 應返回 `6`。
+
+```js
+assert(
+ findLongestWordLength('The quick brown fox jumped over the lazy dog') === 6
+);
+```
+
+`findLongestWordLength("May the force be with you")` 應返回 `5`。
+
+```js
+assert(findLongestWordLength('May the force be with you') === 5);
+```
+
+`findLongestWordLength("Google do a barrel roll")` 應返回 `6`。
+
+```js
+assert(findLongestWordLength('Google do a barrel roll') === 6);
+```
+
+`findLongestWordLength("What is the average airspeed velocity of an unladen swallow")` 應返回 `8`。
+
+```js
+assert(
+ findLongestWordLength(
+ 'What is the average airspeed velocity of an unladen swallow'
+ ) === 8
+);
+```
+
+`findLongestWordLength("What if we try a super-long word such as otorhinolaryngology")` 應返回 `19`。
+
+```js
+assert(
+ findLongestWordLength(
+ 'What if we try a super-long word such as otorhinolaryngology'
+ ) === 19
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function findLongestWordLength(str) {
+ return str.length;
+}
+
+findLongestWordLength("The quick brown fox jumped over the lazy dog");
+```
+
+# --solutions--
+
+```js
+function findLongestWordLength(str) {
+ return str.split(' ').sort((a, b) => b.length - a.length)[0].length;
+}
+
+findLongestWordLength("The quick brown fox jumped over the lazy dog");
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/finders-keepers.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/finders-keepers.md
new file mode 100644
index 0000000000..5dd75719f5
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/finders-keepers.md
@@ -0,0 +1,58 @@
+---
+id: a6e40f1041b06c996f7b2406
+title: 按參數過濾數組
+challengeType: 5
+forumTopicId: 16016
+dashedName: finders-keepers
+---
+
+# --description--
+
+請寫一個函數來檢查數組（第一個參數 `arr`）中的元素，並返回數組中第一個通過校驗測試的元素。 其中，“通過校驗測試”指的是對於數組中的一個元素 `x`，若 `func(x)` 返回的結果爲 `true`，則校驗測試通過。 如果沒有元素通過測試，請返回 `undefined`。
+
+# --hints--
+
+`findElement([1, 3, 5, 8, 9, 10], function(num) { return num % 2 === 0; })` 應返回 `8`。
+
+```js
+assert.strictEqual(
+ findElement([1, 3, 5, 8, 9, 10], function (num) {
+ return num % 2 === 0;
+ }),
+ 8
+);
+```
+
+`findElement([1, 3, 5, 9], function(num) { return num % 2 === 0; })` 應返回 `undefined`。
+
+```js
+assert.strictEqual(
+ findElement([1, 3, 5, 9], function (num) {
+ return num % 2 === 0;
+ }),
+ undefined
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function findElement(arr, func) {
+ let num = 0;
+ return num;
+}
+
+findElement([1, 2, 3, 4], num => num % 2 === 0);
+```
+
+# --solutions--
+
+```js
+function findElement(arr, func) {
+ return arr.filter(func)[0];
+}
+
+findElement([1, 2, 3, 4], num => num % 2 === 0);
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/mutations.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/mutations.md
new file mode 100644
index 0000000000..ae8906b0c9
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/mutations.md
@@ -0,0 +1,117 @@
+---
+id: af2170cad53daa0770fabdea
+title: 比較字符串
+challengeType: 5
+forumTopicId: 16025
+dashedName: mutations
+---
+
+# --description--
+
+如果數組裏的第一個字符串包含了第二個字符串中的所有字母，則返回 `true`。
+
+例如，`["hello", "Hello"]` 應該返回 `true`。因爲在忽略大小寫的情況下，第一個字符串包含了第二個字符串裏出現的所有字母。
+
+`["hello", "hey"]` 應該返回 `false`。因爲 `hello` 並不包含字符 `y`。
+
+最後，`["Alien", "line"]` 應該返回 `true`。因爲 `line` 中的所有字母都出現在了 `Alien` 中。
+
+# --hints--
+
+`mutation(["hello", "hey"])` 應返回 `false`。
+
+```js
+assert(mutation(['hello', 'hey']) === false);
+```
+
+`mutation(["hello", "Hello"])` 應返回 `true`。
+
+```js
+assert(mutation(['hello', 'Hello']) === true);
+```
+
+`mutation(["zyxwvutsrqponmlkjihgfedcba", "qrstu"])` 應返回 `true`。
+
+```js
+assert(mutation(['zyxwvutsrqponmlkjihgfedcba', 'qrstu']) === true);
+```
+
+`mutation(["Mary", "Army"])` 應返回 `true`。
+
+```js
+assert(mutation(['Mary', 'Army']) === true);
+```
+
+`mutation(["Mary", "Aarmy"])` 應返回 `true`。
+
+```js
+assert(mutation(['Mary', 'Aarmy']) === true);
+```
+
+`mutation(["Alien", "line"])` 應返回 `true`。
+
+```js
+assert(mutation(['Alien', 'line']) === true);
+```
+
+`mutation(["floor", "for"])` 應返回 `true`。
+
+```js
+assert(mutation(['floor', 'for']) === true);
+```
+
+`mutation(["hello", "neo"])` 應返回 `false`。
+
+```js
+assert(mutation(['hello', 'neo']) === false);
+```
+
+`mutation(["voodoo", "no"])` 應返回 `false`。
+
+```js
+assert(mutation(['voodoo', 'no']) === false);
+```
+
+`mutation(["ate", "date"])` 應返回 `false`。
+
+```js
+assert(mutation(['ate', 'date']) === false);
+```
+
+`mutation(["Tiger", "Zebra"])` 應返回 `false`。
+
+```js
+assert(mutation(['Tiger', 'Zebra']) === false);
+```
+
+`mutation(["Noel", "Ole"])` 應返回 `true`。
+
+```js
+assert(mutation(['Noel', 'Ole']) === true);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function mutation(arr) {
+ return arr;
+}
+
+mutation(["hello", "hey"]);
+```
+
+# --solutions--
+
+```js
+function mutation(arr) {
+ let hash = Object.create(null);
+
+ arr[0].toLowerCase().split('').forEach(c => hash[c] = true);
+
+ return !arr[1].toLowerCase().split('').filter(c => !hash[c]).length;
+}
+
+mutation(["hello", "hey"]);
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/repeat-a-string-repeat-a-string.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/repeat-a-string-repeat-a-string.md
new file mode 100644
index 0000000000..74d7292bb9
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/repeat-a-string-repeat-a-string.md
@@ -0,0 +1,84 @@
+---
+id: afcc8d540bea9ea2669306b6
+title: 重複輸出字符串
+challengeType: 5
+forumTopicId: 16041
+dashedName: repeat-a-string-repeat-a-string
+---
+
+# --description--
+
+將一個給定的字符串 `str`（第一個參數）重複輸出 `num`（第二個參數）次。 如果 `num` 不是正數，返回空字符串。 在這個挑戰中，請*不要*使用 JavaScript 內置的 `.repeat()` 方法。
+
+# --hints--
+
+`repeatStringNumTimes("*", 3)` 應返回 `***`。
+
+```js
+assert(repeatStringNumTimes('*', 3) === '***');
+```
+
+`repeatStringNumTimes("abc", 3)` 應返回 `abcabcabc`。
+
+```js
+assert(repeatStringNumTimes('abc', 3) === 'abcabcabc');
+```
+
+`repeatStringNumTimes("abc", 4)` 應返回 `abcabcabcabc`。
+
+```js
+assert(repeatStringNumTimes('abc', 4) === 'abcabcabcabc');
+```
+
+`repeatStringNumTimes("abc", 1)` 應返回 `abc`。
+
+```js
+assert(repeatStringNumTimes('abc', 1) === 'abc');
+```
+
+`repeatStringNumTimes("*", 8)` 應返回 `********`。
+
+```js
+assert(repeatStringNumTimes('*', 8) === '********');
+```
+
+`repeatStringNumTimes("abc", -2)` 應返回 `""`。
+
+```js
+assert(repeatStringNumTimes('abc', -2) === '');
+```
+
+不應使用內置的 `repeat()` 方法。
+
+```js
+assert(!/\.repeat/g.test(code));
+```
+
+`repeatStringNumTimes("abc", 0)` 應返回 `""`。
+
+```js
+assert(repeatStringNumTimes('abc', 0) === '');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function repeatStringNumTimes(str, num) {
+ return str;
+}
+
+repeatStringNumTimes("abc", 3);
+```
+
+# --solutions--
+
+```js
+function repeatStringNumTimes(str, num) {
+ if (num < 1) return '';
+ return num === 1 ? str : str + repeatStringNumTimes(str, num-1);
+}
+
+repeatStringNumTimes("abc", 3);
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/return-largest-numbers-in-arrays.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/return-largest-numbers-in-arrays.md
new file mode 100644
index 0000000000..b627126157
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/return-largest-numbers-in-arrays.md
@@ -0,0 +1,92 @@
+---
+id: a789b3483989747d63b0e427
+title: 找出多個數組中的最大數字
+challengeType: 5
+forumTopicId: 16042
+dashedName: return-largest-numbers-in-arrays
+---
+
+# --description--
+
+請返回一個數組，該數組由參數中每個子數組中的最大數字組成。 爲簡單起見，給出的數組總會包含 4 個子數組。
+
+別忘了，你可以通過 for 循環遍歷一個數組，並用 `arr[i]` 的寫法來訪問數組中的元素。
+
+# --hints--
+
+`largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]])` 應返回一個數組。
+
+```js
+assert(
+ largestOfFour([
+ [4, 5, 1, 3],
+ [13, 27, 18, 26],
+ [32, 35, 37, 39],
+ [1000, 1001, 857, 1]
+ ]).constructor === Array
+);
+```
+
+`largestOfFour([[13, 27, 18, 26], [4, 5, 1, 3], [32, 35, 37, 39], [1000, 1001, 857, 1]])` 應返回 `[27, 5, 39, 1001]`。
+
+```js
+assert.deepEqual(
+ largestOfFour([
+ [13, 27, 18, 26],
+ [4, 5, 1, 3],
+ [32, 35, 37, 39],
+ [1000, 1001, 857, 1]
+ ]),
+ [27, 5, 39, 1001]
+);
+```
+
+`largestOfFour([[4, 9, 1, 3], [13, 35, 18, 26], [32, 35, 97, 39], [1000000, 1001, 857, 1]])` 應返回 `[9, 35, 97, 1000000]`。
+
+```js
+assert.deepEqual(
+ largestOfFour([
+ [4, 9, 1, 3],
+ [13, 35, 18, 26],
+ [32, 35, 97, 39],
+ [1000000, 1001, 857, 1]
+ ]),
+ [9, 35, 97, 1000000]
+);
+```
+
+`largestOfFour([[17, 23, 25, 12], [25, 7, 34, 48], [4, -10, 18, 21], [-72, -3, -17, -10]])` 應返回 `[25, 48, 21, -3]`。
+
+```js
+assert.deepEqual(
+ largestOfFour([
+ [17, 23, 25, 12],
+ [25, 7, 34, 48],
+ [4, -10, 18, 21],
+ [-72, -3, -17, -10]
+ ]),
+ [25, 48, 21, -3]
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function largestOfFour(arr) {
+ return arr;
+}
+
+largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]]);
+```
+
+# --solutions--
+
+```js
+function largestOfFour(arr) {
+ return arr.map(subArr => Math.max.apply(null, subArr));
+}
+
+largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]]);
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/reverse-a-string.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/reverse-a-string.md
new file mode 100644
index 0000000000..683a249d75
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/reverse-a-string.md
@@ -0,0 +1,63 @@
+---
+id: a202eed8fc186c8434cb6d61
+title: 反轉字符串
+challengeType: 5
+forumTopicId: 16043
+dashedName: reverse-a-string
+---
+
+# --description--
+
+請反轉傳入函數的字符串。
+
+在反轉字符串之前，你可能需要將其切分成包含字符的數組。
+
+函數的返回結果應爲字符串。
+
+# --hints--
+
+`reverseString("hello")` 應返回一個字符串。
+
+```js
+assert(typeof reverseString('hello') === 'string');
+```
+
+`reverseString("hello")` 應返回 `olleh`。
+
+```js
+assert(reverseString('hello') === 'olleh');
+```
+
+`reverseString("Howdy")` 應返回 `ydwoH`。
+
+```js
+assert(reverseString('Howdy') === 'ydwoH');
+```
+
+`reverseString("Greetings from Earth")` 應返回 `htraE morf sgniteerG`。
+
+```js
+assert(reverseString('Greetings from Earth') === 'htraE morf sgniteerG');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function reverseString(str) {
+ return str;
+}
+
+reverseString("hello");
+```
+
+# --solutions--
+
+```js
+function reverseString(str) {
+ return str.split('').reverse().join('');
+}
+
+reverseString("hello");
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/slice-and-splice.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/slice-and-splice.md
new file mode 100644
index 0000000000..4f517261c5
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/slice-and-splice.md
@@ -0,0 +1,98 @@
+---
+id: 579e2a2c335b9d72dd32e05c
+title: Slice 與 Splice
+challengeType: 5
+forumTopicId: 301148
+dashedName: slice-and-splice
+---
+
+# --description--
+
+本挑戰的輸入參數爲兩個數組和一個索引值。
+
+將第一個數組中的所有元素依次複製到第二個數組中。
+
+請注意，你需要從第二個數組索引值爲 `n` 的地方開始插入。
+
+最後，請返回插入元素後的數組。 作爲輸入參數的兩個數組在函數執行前後應保持不變。
+
+# --hints--
+
+`frankenSplice([1, 2, 3], [4, 5], 1)` 應返回 `[4, 1, 2, 3, 5]`。
+
+```js
+assert.deepEqual(frankenSplice([1, 2, 3], [4, 5], 1), [4, 1, 2, 3, 5]);
+```
+
+`frankenSplice([1, 2], ["a", "b"], 1)` 應返回 `["a", 1, 2, "b"]`。
+
+```js
+assert.deepEqual(frankenSplice(testArr1, testArr2, 1), ['a', 1, 2, 'b']);
+```
+
+`frankenSplice(["claw", "tentacle"], ["head", "shoulders", "knees", "toes"], 2)` 應返回 `["head", "shoulders", "claw", "tentacle", "knees", "toes"]`。
+
+```js
+assert.deepEqual(
+ frankenSplice(
+ ['claw', 'tentacle'],
+ ['head', 'shoulders', 'knees', 'toes'],
+ 2
+ ),
+ ['head', 'shoulders', 'claw', 'tentacle', 'knees', 'toes']
+);
+```
+
+第一個數組中的所有元素都應按原始順序添加到第二個數組中。
+
+```js
+assert.deepEqual(frankenSplice([1, 2, 3, 4], [], 0), [1, 2, 3, 4]);
+```
+
+函數運行後，第一個數組應保持不變。
+
+```js
+frankenSplice(testArr1, testArr2, 1);
+assert.deepEqual(testArr1, [1, 2]);
+```
+
+函數運行後，第二個數組應保持不變。
+
+```js
+frankenSplice(testArr1, testArr2, 1);
+assert.deepEqual(testArr2, ['a', 'b']);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+let testArr1 = [1, 2];
+let testArr2 = ["a", "b"];
+```
+
+## --seed-contents--
+
+```js
+function frankenSplice(arr1, arr2, n) {
+ return arr2;
+}
+
+frankenSplice([1, 2, 3], [4, 5, 6], 1);
+```
+
+# --solutions--
+
+```js
+function frankenSplice(arr1, arr2, n) {
+ // It's alive. It's alive!
+ let result = arr2.slice();
+ for (let i = 0; i < arr1.length; i++) {
+ result.splice(n+i, 0, arr1[i]);
+ }
+ return result;
+}
+
+frankenSplice([1, 2, 3], [4, 5], 1);
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/title-case-a-sentence.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/title-case-a-sentence.md
new file mode 100644
index 0000000000..45ebb86f62
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/title-case-a-sentence.md
@@ -0,0 +1,64 @@
+---
+id: ab6137d4e35944e21037b769
+title: 句中單詞首字母大寫
+challengeType: 5
+forumTopicId: 16088
+dashedName: title-case-a-sentence
+---
+
+# --description--
+
+請將傳入的字符串中，每個單詞的第一個字母變成大寫並返回。 注意除首字母外，其餘的字符都應是小寫的。
+
+在這個挑戰中，我們還需要將諸如 `the` 和 `of` 之類的連接詞大寫。
+
+# --hints--
+
+`titleCase("I'm a little tea pot")` 應返回一個字符串。
+
+```js
+assert(typeof titleCase("I'm a little tea pot") === 'string');
+```
+
+`titleCase("I'm a little tea pot")` 應返回 `I'm A Little Tea Pot`。
+
+```js
+assert(titleCase("I'm a little tea pot") === "I'm A Little Tea Pot");
+```
+
+`titleCase("sHoRt AnD sToUt")` 應返回 `Short And Stout`。
+
+```js
+assert(titleCase('sHoRt AnD sToUt') === 'Short And Stout');
+```
+
+`titleCase("HERE IS MY HANDLE HERE IS MY SPOUT")` 應返回 `Here Is My Handle Here Is My Spout`。
+
+```js
+assert(
+ titleCase('HERE IS MY HANDLE HERE IS MY SPOUT') ===
+ 'Here Is My Handle Here Is My Spout'
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function titleCase(str) {
+ return str;
+}
+
+titleCase("I'm a little tea pot");
+```
+
+# --solutions--
+
+```js
+function titleCase(str) {
+ return str.split(' ').map(word => word.charAt(0).toUpperCase() + word.substring(1).toLowerCase()).join(' ');
+}
+
+titleCase("I'm a little tea pot");
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/truncate-a-string.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/truncate-a-string.md
new file mode 100644
index 0000000000..a045e88031
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/truncate-a-string.md
@@ -0,0 +1,91 @@
+---
+id: ac6993d51946422351508a41
+title: 截斷字符串
+challengeType: 5
+forumTopicId: 16089
+dashedName: truncate-a-string
+---
+
+# --description--
+
+如果傳入的字符串（第一個參數）的長度大於傳入的值（第二個參數），請在這個位置截斷它， 並在後面加上 `...`，然後返回結果。
+
+# --hints--
+
+`truncateString("A-tisket a-tasket A green and yellow basket", 8)` 應返回 `A-tisket...`。
+
+```js
+assert(
+ truncateString('A-tisket a-tasket A green and yellow basket', 8) ===
+ 'A-tisket...'
+);
+```
+
+`truncateString("Peter Piper picked a peck of pickled peppers", 11)` 應返回 `Peter Piper...`。
+
+```js
+assert(
+ truncateString('Peter Piper picked a peck of pickled peppers', 11) ===
+ 'Peter Piper...'
+);
+```
+
+`truncateString("A-tisket a-tasket A green and yellow basket", "A-tisket a-tasket A green and yellow basket".length)` 應返回 `A-tisket a-tasket A green and yellow basket`。
+
+```js
+assert(
+ truncateString(
+ 'A-tisket a-tasket A green and yellow basket',
+ 'A-tisket a-tasket A green and yellow basket'.length
+ ) === 'A-tisket a-tasket A green and yellow basket'
+);
+```
+
+`truncateString("A-tisket a-tasket A green and yellow basket", "A-tisket a-tasket A green and yellow basket".length + 2)` 應返回 `A-tisket a-tasket A green and yellow basket`。
+
+```js
+assert(
+ truncateString(
+ 'A-tisket a-tasket A green and yellow basket',
+ 'A-tisket a-tasket A green and yellow basket'.length + 2
+ ) === 'A-tisket a-tasket A green and yellow basket'
+);
+```
+
+`truncateString("A-", 1)` 應返回字符串 `A...`。
+
+```js
+assert(truncateString('A-', 1) === 'A...');
+```
+
+`truncateString("Absolutely Longer", 2)` 應返回 `Ab...`。
+
+```js
+assert(truncateString('Absolutely Longer', 2) === 'Ab...');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function truncateString(str, num) {
+ return str;
+}
+
+truncateString("A-tisket a-tasket A green and yellow basket", 8);
+```
+
+# --solutions--
+
+```js
+function truncateString(str, num) {
+ if (num >= str.length) {
+ return str;
+ }
+
+ return str.slice(0, num) + '...';
+}
+
+truncateString("A-tisket a-tasket A green and yellow basket", 8);
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/where-do-i-belong.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/where-do-i-belong.md
new file mode 100644
index 0000000000..764a23af32
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/where-do-i-belong.md
@@ -0,0 +1,143 @@
+---
+id: a24c1a4622e3c05097f71d67
+title: 找出元素在排序後數組中的索引
+challengeType: 5
+forumTopicId: 16094
+dashedName: where-do-i-belong
+---
+
+# --description--
+
+數組（第一個參數）在排序後，將一個值（第二個參數）插入該數組，並使數組保持有序。返回這個新插入元素的最小索引值。 返回值應爲一個數字。
+
+例如，`getIndexToIns([1,2,3,4], 1.5)` 應該返回 `1` 因爲1.5 大於 `1`（索引爲 0）且小於 `2`（索引爲 1）。
+
+同樣地，`getIndexToIns([20,3,5], 19)` 應該返回 `2`。 因爲數組排序後會變成 `[3,5,20]`，而 `19` 小於 `20`（索引爲 2）且大於 `5`（索引爲 1）。
+
+# --hints--
+
+`getIndexToIns([10, 20, 30, 40, 50], 35)` 應返回 `3`。
+
+```js
+assert(getIndexToIns([10, 20, 30, 40, 50], 35) === 3);
+```
+
+`getIndexToIns([10, 20, 30, 40, 50], 35)` 應返回一個數字。
+
+```js
+assert(typeof getIndexToIns([10, 20, 30, 40, 50], 35) === 'number');
+```
+
+`getIndexToIns([10, 20, 30, 40, 50], 30)` 應返回 `2`。
+
+```js
+assert(getIndexToIns([10, 20, 30, 40, 50], 30) === 2);
+```
+
+`getIndexToIns([10, 20, 30, 40, 50], 30)` 應返回一個數字。
+
+```js
+assert(typeof getIndexToIns([10, 20, 30, 40, 50], 30) === 'number');
+```
+
+`getIndexToIns([40, 60], 50)` 應返回 `1`。
+
+```js
+assert(getIndexToIns([40, 60], 50) === 1);
+```
+
+`getIndexToIns([40, 60], 50)` 應返回一個數字。
+
+```js
+assert(typeof getIndexToIns([40, 60], 50) === 'number');
+```
+
+`getIndexToIns([3, 10, 5], 3)` 應返回 `0`。
+
+```js
+assert(getIndexToIns([3, 10, 5], 3) === 0);
+```
+
+`getIndexToIns([3, 10, 5], 3)` 應返回一個數字。
+
+```js
+assert(typeof getIndexToIns([3, 10, 5], 3) === 'number');
+```
+
+`getIndexToIns([5, 3, 20, 3], 5)` 應返回 `2`。
+
+```js
+assert(getIndexToIns([5, 3, 20, 3], 5) === 2);
+```
+
+`getIndexToIns([5, 3, 20, 3], 5)` 應返回一個數字。
+
+```js
+assert(typeof getIndexToIns([5, 3, 20, 3], 5) === 'number');
+```
+
+`getIndexToIns([2, 20, 10], 19)` 應返回 `2`。
+
+```js
+assert(getIndexToIns([2, 20, 10], 19) === 2);
+```
+
+`getIndexToIns([2, 20, 10], 19)` 應返回一個數字。
+
+```js
+assert(typeof getIndexToIns([2, 20, 10], 19) === 'number');
+```
+
+`getIndexToIns([2, 5, 10], 15)` 應返回 `3`。
+
+```js
+assert(getIndexToIns([2, 5, 10], 15) === 3);
+```
+
+`getIndexToIns([2, 5, 10], 15)` 應返回一個數字。
+
+```js
+assert(typeof getIndexToIns([2, 5, 10], 15) === 'number');
+```
+
+`getIndexToIns([], 1)`應該返回 `0`。
+
+```js
+assert(getIndexToIns([], 1) === 0);
+```
+
+`getIndexToIns([], 1)` 應返回一個數字。
+
+```js
+assert(typeof getIndexToIns([], 1) === 'number');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function getIndexToIns(arr, num) {
+ return num;
+}
+
+getIndexToIns([40, 60], 50);
+```
+
+# --solutions--
+
+```js
+function getIndexToIns(arr, num) {
+ arr = arr.sort((a, b) => a - b);
+
+ for (let i = 0; i < arr.length; i++) {
+ if (arr[i] >= num) {
+ return i;
+ }
+ }
+
+ return arr.length;
+}
+
+getIndexToIns([40, 60], 50);
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-data-structures/access-an-arrays-contents-using-bracket-notation.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-data-structures/access-an-arrays-contents-using-bracket-notation.md
new file mode 100644
index 0000000000..4f4b8f3673
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-data-structures/access-an-arrays-contents-using-bracket-notation.md
@@ -0,0 +1,82 @@
+---
+id: 5a661e0f1068aca922b3ef17
+title: 使用方括號訪問數組的元素
+challengeType: 1
+forumTopicId: 301149
+dashedName: access-an-arrays-contents-using-bracket-notation
+---
+
+# --description--
+
+所有數據結構的基本特性是，它們不僅可以存儲數據，還可以讓我們按需訪問存放在其中的數據。 我們已經學習瞭如何創建數組，現在讓我們來學習如何訪問數組中的數據。
+
+我們先定義一個包含 3 個元素的數組：
+
+```js
+let ourArray = ["a", "b", "c"];
+```
+
+在數組中，內部的每個元素都有一個與之對應的索引（index ）。 索引既是該元素在數組中的位置，也是我們訪問該元素的引用。 需要注意的是，JavaScript 數組的索引是從 0 開始的（這種從 0 開始的規則叫做 zero-indexed ），即數組的第一個元素是在數組中的***第 0 個***位置，而不是第 1 個位置。 要從數組中獲取一個元素，我們可以在數組字面量後面加一個用方括號括起來的索引。不過習慣上，我們會通過表示數組的變量名來訪問，而不是直接通過字面量。 這種從數組中讀取元素的方式叫做方括號表示法（bracket notation ）。 如果我們要從數組 `ourArray` 中取出數據 `a` 並將其賦值給另一個變量，可以這樣寫：
+
+```js
+let ourVariable = ourArray[0];
+```
+
+現在，變量 `ourVariable` 的值也爲 `a`。
+
+通過索引，我們不僅可以獲取某個元素值，還可以用類似的寫法來*設置*一個索引位置的元素值：
+
+```js
+ourArray[1] = "not b anymore";
+```
+
+在上面的代碼中，我們用方括號表示法把索引爲 1 的元素從 `b` 改成了 `not b anymore`。 現在 `ourArray` 的值是 `["a", "not b anymore", "c"]`。
+
+# --instructions--
+
+在本挑戰中，請將 `myArray` 中的第二個元素（索引爲 `1`）設置爲除了 `b` 以外的任意值。
+
+# --hints--
+
+`myArray[0]` 應爲 `a`。
+
+```js
+assert.strictEqual(myArray[0], 'a');
+```
+
+`myArray[1]` 不應爲 `b`。
+
+```js
+assert.notStrictEqual(myArray[1], 'b');
+```
+
+`myArray[2]` 應爲 `c`。
+
+```js
+assert.strictEqual(myArray[2], 'c');
+```
+
+`myArray[3]` 應爲 `d`。
+
+```js
+assert.strictEqual(myArray[3], 'd');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let myArray = ["a", "b", "c", "d"];
+// Only change code below this line
+
+// Only change code above this line
+console.log(myArray);
+```
+
+# --solutions--
+
+```js
+let myArray = ["a", "b", "c", "d"];
+myArray[1] = "e";
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-data-structures/access-property-names-with-bracket-notation.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-data-structures/access-property-names-with-bracket-notation.md
new file mode 100644
index 0000000000..8f501e5c58
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-data-structures/access-property-names-with-bracket-notation.md
@@ -0,0 +1,101 @@
+---
+id: 587d7b7c367417b2b2512b1a
+title: 使用方括號訪問屬性名稱
+challengeType: 1
+forumTopicId: 301150
+dashedName: access-property-names-with-bracket-notation
+---
+
+# --description--
+
+在關於對象的第一個挑戰中，我們提到可以在一對方括號中用一個變量作爲屬性名來訪問屬性的值。 假設一個超市收銀臺程序中有一個 `foods` 對象, 並且有一個函數會設置 `selectedFood`；如果我們需要查詢 `foods` 對象中，某種食物是否存在， 可以這樣實現：
+
+```js
+let selectedFood = getCurrentFood(scannedItem);
+let inventory = foods[selectedFood];
+```
+
+上述代碼會先讀取 `selectedFood` 變量的值，並返回 `foods` 對象中以該值命名的屬性所對應的屬性值。 若沒有以該值命名的屬性，則會返回 `undefined`。 有時候對象的屬性名在運行之前是不確定的，或者我們需要動態地訪問對象的屬性值。在這些場景下，方括號表示法就變得十分有用。
+
+# --instructions--
+
+我們已經定義了 `checkInventory` 函數，它接受一個被掃描到的商品名作爲輸入參數。 請讓這個函數返回 `foods` 對象中，以 `scannedItem` 的值所命名的屬性對應的屬性值。 在本挑戰中，只有合理有效的屬性名會作爲參數傳入 `checkInventory`，因此你不需要處理參數無效的情況。
+
+# --hints--
+
+`checkInventory` 應是一個函數。
+
+```js
+assert.strictEqual(typeof checkInventory, 'function');
+```
+
+`foods` 對象應只包含以下鍵值對：`apples: 25`、`oranges: 32`、`plums: 28`、`bananas: 13`、`grapes: 35`、`strawberries: 27`。
+
+```js
+assert.deepEqual(foods, {
+ apples: 25,
+ oranges: 32,
+ plums: 28,
+ bananas: 13,
+ grapes: 35,
+ strawberries: 27
+});
+```
+
+`checkInventory("apples")` 應返回 `25`。
+
+```js
+assert.strictEqual(checkInventory('apples'), 25);
+```
+
+`checkInventory("bananas")` 應返回 `13`。
+
+```js
+assert.strictEqual(checkInventory('bananas'), 13);
+```
+
+`checkInventory("strawberries")` 應返回 `27`。
+
+```js
+assert.strictEqual(checkInventory('strawberries'), 27);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let foods = {
+ apples: 25,
+ oranges: 32,
+ plums: 28,
+ bananas: 13,
+ grapes: 35,
+ strawberries: 27
+};
+
+function checkInventory(scannedItem) {
+ // Only change code below this line
+
+ // Only change code above this line
+}
+
+console.log(checkInventory("apples"));
+```
+
+# --solutions--
+
+```js
+let foods = {
+ apples: 25,
+ oranges: 32,
+ plums: 28,
+ bananas: 13,
+ grapes: 35,
+ strawberries: 27
+};
+
+function checkInventory(scannedItem) {
+ return foods[scannedItem];
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-data-structures/add-items-to-an-array-with-push-and-unshift.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-data-structures/add-items-to-an-array-with-push-and-unshift.md
new file mode 100644
index 0000000000..5a28657295
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-data-structures/add-items-to-an-array-with-push-and-unshift.md
@@ -0,0 +1,87 @@
+---
+id: 587d78b2367417b2b2512b0e
+title: 使用 push() 和 unshift() 爲數組添加元素
+challengeType: 1
+forumTopicId: 301151
+dashedName: add-items-to-an-array-with-push-and-unshift
+---
+
+# --description--
+
+數組的長度與數組能包含的數據類型一樣，都是不固定的。 數組可以包含任意數量的元素，可以不限次數地往數組中添加元素或者從中移除元素。 總之，數組是可變的（mutable ）。 在本挑戰中，我們要學習兩種修改數組的方法：`Array.push()` 和 `Array.unshift()`。
+
+這兩個方法都接收一個或多個元素作爲參數，並會將參數中的元素添加到該數組中。 `push()` 方法會將元素插入到數組的末尾，而 `unshift()` 方法會將元素插入到數組的開頭。 請看以下例子：
+
+```js
+let twentyThree = 'XXIII';
+let romanNumerals = ['XXI', 'XXII'];
+
+romanNumerals.unshift('XIX', 'XX');
+```
+
+`romanNumerals` 的值就變成了 `['XIX', 'XX', 'XXI', 'XXII']`。
+
+```js
+romanNumerals.push(twentyThree);
+```
+
+`romanNumerals` 的值現在就變成了 `['XIX', 'XX', 'XXI', 'XXII', 'XXIII']`。 請注意這裏，我們也可以使用變量作爲參數，這讓我們在動態修改數組數據時更加靈活。
+
+# --instructions--
+
+我們已經定義了一個 `mixedNumbers` 函數，它接收一個數組作爲參數。 請修改這個函數，使用 `push()` 和 `unshift()` 來將 `'I', 2, 'three'` 插入到數組開頭；將 `7, 'VIII', 9` 插入到數組的末尾。最終這個函數的返回值就會是一個依次包含不同形式的 1-9 的數組。
+
+# --hints--
+
+`mixedNumbers(["IV", 5, "six"])` 應返回 `["I", 2, "three", "IV", 5, "six", 7, "VIII", 9]`。
+
+```js
+assert.deepEqual(mixedNumbers(['IV', 5, 'six']), [
+ 'I',
+ 2,
+ 'three',
+ 'IV',
+ 5,
+ 'six',
+ 7,
+ 'VIII',
+ 9
+]);
+```
+
+`mixedNumbers` 函數中應調用 `push()` 方法。
+
+```js
+assert(mixedNumbers.toString().match(/\.push/));
+```
+
+`mixedNumbers` 函數中應調用 `unshift()` 方法。
+
+```js
+assert(mixedNumbers.toString().match(/\.unshift/));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function mixedNumbers(arr) {
+ // Only change code below this line
+
+ // Only change code above this line
+ return arr;
+}
+
+console.log(mixedNumbers(['IV', 5, 'six']));
+```
+
+# --solutions--
+
+```js
+function mixedNumbers(arr) {
+ arr.push(7,'VIII',9);
+ arr.unshift('I',2,'three');
+ return arr;
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-data-structures/add-items-using-splice.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-data-structures/add-items-using-splice.md
new file mode 100644
index 0000000000..62b87d6e55
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-data-structures/add-items-using-splice.md
@@ -0,0 +1,93 @@
+---
+id: 587d78b3367417b2b2512b11
+title: 使用 splice() 添加元素
+challengeType: 1
+forumTopicId: 301152
+dashedName: add-items-using-splice
+---
+
+# --description--
+
+還記得在上個挑戰中我們提到 `splice()` 方法最多可以接收 3 個參數嗎？ 第三個參數可以是一個或多個元素，這些元素會被添加到數組中。 這樣，我們能夠便捷地將數組中的一個或多個連續元素換成其他的元素。
+
+```js
+const numbers = [10, 11, 12, 12, 15];
+const startIndex = 3;
+const amountToDelete = 1;
+
+numbers.splice(startIndex, amountToDelete, 13, 14);
+console.log(numbers);
+```
+
+`12` 的第二個條目已被刪除，我們在同一索引處添加 `13` 和 `14`。 `numbers` 數組現在將會是 `[ 10, 11, 12, 13, 14, 15 ]`。
+
+在上面的代碼中，數組一開始包含了若干數字。 接着，我們調用 `splice()` 方法，索引爲 (3) 的地方開始刪除元素，刪除的元素數量是 (1)。然後，(13, 14) 是在刪除位置插入的元素。 可以在 `amountToDelete` 後面傳入任意數量的元素（以逗號分隔），每個都會被插入到數組中。
+
+# --instructions--
+
+我們已經定義了一個 `htmlColorNames` 函數，它以一個 HTML 顏色的數組作爲輸入參數。 請修改這個函數，使用 `splice()` 來移除數組中的前兩個元素，並在對應的位置上添加 `'DarkSalmon'` 和 `'BlanchedAlmond'`。
+
+# --hints--
+
+`htmlColorNames` 應返回 `["DarkSalmon", "BlanchedAlmond", "LavenderBlush", "PaleTurquoise", "FireBrick"]`。
+
+```js
+assert.deepEqual(
+ htmlColorNames([
+ 'DarkGoldenRod',
+ 'WhiteSmoke',
+ 'LavenderBlush',
+ 'PaleTurquoise',
+ 'FireBrick'
+ ]),
+ [
+ 'DarkSalmon',
+ 'BlanchedAlmond',
+ 'LavenderBlush',
+ 'PaleTurquoise',
+ 'FireBrick'
+ ]
+);
+```
+
+`htmlColorNames` 函數中應調用 `splice()` 方法。
+
+```js
+assert(/.splice/.test(code));
+```
+
+不應使用 `shift()` 或 `unshift()`。
+
+```js
+assert(!/shift|unshift/.test(code));
+```
+
+不應使用數組的方括號表示法。
+
+```js
+assert(!/\[\d\]\s*=/.test(code));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function htmlColorNames(arr) {
+ // Only change code below this line
+
+ // Only change code above this line
+ return arr;
+}
+
+console.log(htmlColorNames(['DarkGoldenRod', 'WhiteSmoke', 'LavenderBlush', 'PaleTurquoise', 'FireBrick']));
+```
+
+# --solutions--
+
+```js
+function htmlColorNames(arr) {
+ arr.splice(0,2,'DarkSalmon', 'BlanchedAlmond');
+ return arr;
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-data-structures/add-key-value-pairs-to-javascript-objects.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-data-structures/add-key-value-pairs-to-javascript-objects.md
new file mode 100644
index 0000000000..2384cf10eb
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-data-structures/add-key-value-pairs-to-javascript-objects.md
@@ -0,0 +1,124 @@
+---
+id: 587d7b7c367417b2b2512b18
+title: 將鍵值對添加到對象中
+challengeType: 1
+forumTopicId: 301153
+dashedName: add-key-value-pairs-to-javascript-objects
+---
+
+# --description--
+
+對象（object）本質上是鍵值對（key-value pair ）的集合。 或者說，一系列被映射到唯一標識符的數據就是對象；習慣上，唯一標識符叫做屬性（property ）或者鍵（key ）；數據叫做值（value ）。 讓我們來看一個簡單的例子：
+
+```js
+const tekkenCharacter = {
+ player: 'Hwoarang',
+ fightingStyle: 'Tae Kwon Doe',
+ human: true
+};
+```
+
+上面的代碼定義了一個叫做 `tekkenCharacter` 的“鐵拳”遊戲人物對象。 它有三個屬性，每個屬性都對應一個特定的值。 如果我們想爲它再添加一個叫做 `origin` 的屬性，可以這樣寫：
+
+```js
+tekkenCharacter.origin = 'South Korea';
+```
+
+上面的代碼中，我們使用了點號表示法。 如果我們現在輸出 `tekkenCharacter` 對象，便可以看到它具有 `origin` 屬性。 接下來，因爲這個人物在遊戲中有着與衆不同的橘色頭髮， 我們可以通過方括號表示法來爲它添加這個屬性，像這樣：
+
+```js
+tekkenCharacter['hair color'] = 'dyed orange';
+```
+
+如果要設置的屬性中存在空格，或者要設置的屬性是一個變量，那我們必須使用方括號表示法（bracket notation）來爲對象添加屬性。 在上面的代碼中，我們把屬性（hair color）放到引號裏，以此來表示整個字符串都是需要設置的屬性。 如果我們不加上引號，那麼中括號裏的內容會被當作一個變量來解析，這個變量對應的值就會作爲要設置的屬性， 請看這段代碼：
+
+```js
+const eyes = 'eye color';
+
+tekkenCharacter[eyes] = 'brown';
+```
+
+執行以上所有示例代碼後，對象會變成這樣：
+
+```js
+{
+ player: 'Hwoarang',
+ fightingStyle: 'Tae Kwon Doe',
+ human: true,
+ origin: 'South Korea',
+ 'hair color': 'dyed orange',
+ 'eye color': 'brown'
+};
+```
+
+# --instructions--
+
+我們已經爲你創建了包含三個項目的 `foods` 對象。 請使用上述任意語法，來爲 foods 對象添加如下三個鍵值對：`bananas` 屬性，值爲 `13`；`grapes` 屬性，值爲 `35`；`strawberries` 屬性，值爲 `27`。
+
+# --hints--
+
+`foods` 應爲一個對象。
+
+```js
+assert(typeof foods === 'object');
+```
+
+`foods` 應有一個值爲 `13` 的 `bananas` 屬性。
+
+```js
+assert(foods.bananas === 13);
+```
+
+`foods` 應有一個值爲 `35` 的 `grapes` 屬性。
+
+```js
+assert(foods.grapes === 35);
+```
+
+`foods` 應有一個值爲 `27` 的 `strawberries` 屬性。
+
+```js
+assert(foods.strawberries === 27);
+```
+
+應使用點號表示法或方括號表示法來設置對象的屬性。
+
+```js
+assert(
+ code.search(/bananas:/) === -1 &&
+ code.search(/grapes:/) === -1 &&
+ code.search(/strawberries:/) === -1
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let foods = {
+ apples: 25,
+ oranges: 32,
+ plums: 28
+};
+
+// Only change code below this line
+
+// Only change code above this line
+
+console.log(foods);
+```
+
+# --solutions--
+
+```js
+let foods = {
+ apples: 25,
+ oranges: 32,
+ plums: 28
+};
+
+foods['bananas'] = 13;
+foods['grapes'] = 35;
+foods['strawberries'] = 27;
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-data-structures/check-for-the-presence-of-an-element-with-indexof.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-data-structures/check-for-the-presence-of-an-element-with-indexof.md
new file mode 100644
index 0000000000..b3aac0f2d0
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-data-structures/check-for-the-presence-of-an-element-with-indexof.md
@@ -0,0 +1,93 @@
+---
+id: 587d7b7b367417b2b2512b14
+title: 使用 indexOf() 檢查元素是否存在
+challengeType: 1
+forumTopicId: 301154
+dashedName: check-for-the-presence-of-an-element-with-indexof
+---
+
+# --description--
+
+由於數組隨時都可以修改或發生 *mutated*，我們很難保證某個數據始終處於數組中的特定位置，甚至不能保證該元素是否還存在於該數組中。 好消息是，JavaScript 爲我們提供了內置方法 `indexOf()`。 這個方法讓我們可以方便地檢查某個元素是否存在於數組中。 `indexOf()` 方法接受一個元素作爲輸入參數，並返回該元素在數組中的位置（索引）；若該元素不存在於數組中則返回 `-1`。
+
+例如：
+
+```js
+let fruits = ['apples', 'pears', 'oranges', 'peaches', 'pears'];
+
+fruits.indexOf('dates');
+fruits.indexOf('oranges');
+fruits.indexOf('pears');
+```
+
+`indexOf('dates')` 返回 `-1`，`indexOf('oranges')` 返回 `2`，`indexOf('pears')` 返回 `1` (每個元素存在的第一個索引)。
+
+# --instructions--
+
+`indexOf()` 在快速檢查一個數組中是否存在某個元素時非常有用。 我們已經定義了一個 `quickCheck` 函數，它接受一個數組和一個元素作爲輸入參數。 請通過 `indexOf()` 方法修改這個函數，使得當傳入的參數在數組中存在時返回 `true`，否則返回 `false`。
+
+# --hints--
+
+`quickCheck` 函數應返回一個布爾值（`true` 或 `false`），而不是一個字符串（`"true"` 或 `"false"`）。
+
+```js
+assert.isBoolean(quickCheck(['squash', 'onions', 'shallots'], 'mushrooms'));
+```
+
+`quickCheck(["squash", "onions", "shallots"], "mushrooms")` 應返回 `false`。
+
+```js
+assert.strictEqual(
+ quickCheck(['squash', 'onions', 'shallots'], 'mushrooms'),
+ false
+);
+```
+
+`quickCheck(["onions", "squash", "shallots"], "onions")` 應返回 `true`。
+
+```js
+assert.strictEqual(
+ quickCheck(['onions', 'squash', 'shallots'], 'onions'),
+ true
+);
+```
+
+`quickCheck([3, 5, 9, 125, 45, 2], 125)` 應返回 `true`。
+
+```js
+assert.strictEqual(quickCheck([3, 5, 9, 125, 45, 2], 125), true);
+```
+
+`quickCheck([true, false, false], undefined)` 應返回 `false`。
+
+```js
+assert.strictEqual(quickCheck([true, false, false], undefined), false);
+```
+
+`quickCheck` 函數中應使用 `indexOf()` 方法。
+
+```js
+assert.notStrictEqual(quickCheck.toString().search(/\.indexOf\(/), -1);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function quickCheck(arr, elem) {
+ // Only change code below this line
+
+ // Only change code above this line
+}
+
+console.log(quickCheck(['squash', 'onions', 'shallots'], 'mushrooms'));
+```
+
+# --solutions--
+
+```js
+function quickCheck(arr, elem) {
+ return arr.indexOf(elem) >= 0;
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-data-structures/check-if-an-object-has-a-property.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-data-structures/check-if-an-object-has-a-property.md
new file mode 100644
index 0000000000..3e426b4cc7
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-data-structures/check-if-an-object-has-a-property.md
@@ -0,0 +1,153 @@
+---
+id: 587d7b7d367417b2b2512b1c
+title: 檢查對象是否具有某個屬性
+challengeType: 1
+forumTopicId: 301155
+dashedName: check-if-an-object-has-a-property
+---
+
+# --description--
+
+我們已經學習瞭如何添加、修改和移除對象中的屬性。 但如果我們想知道一個對象中是否包含某個屬性呢？ JavaScript 爲我們提供了兩種不同的方式來實現這個功能： 一個是通過 `hasOwnProperty()` 方法，另一個是使用 `in` 關鍵字。 假如我們有一個 `users` 對象，爲檢查它是否含有 `Alan` 屬性，可以這樣寫：
+
+```js
+users.hasOwnProperty('Alan');
+'Alan' in users;
+```
+
+這兩者結果都應該爲 `true`。
+
+# --instructions--
+
+我們已經定義了一個包含若干用戶信息的 `users` 對象和一個 `isEveryoneHere` 函數，該函數接收 `users` 對象作爲參數。 請完成該函數使其在 `users` 對象中同時包含 `Alan`、`Jeff`、`Sarah`、`Ryan` 四個屬性時才返回 `true`，否則返回 `false`。
+
+# --hints--
+
+`users` 對象應該只包含 `Alan`、`Jeff`、`Sarah`、`Ryan` 4 個屬性。
+
+```js
+assert(
+ 'Alan' in users &&
+ 'Jeff' in users &&
+ 'Sarah' in users &&
+ 'Ryan' in users &&
+ Object.keys(users).length === 4
+);
+```
+
+`isEveryoneHere` 函數在 `users` 對象包含 `Alan`、`Jeff`、`Sarah`、`Ryan` 4 個屬性時應返回 `true`。
+
+```js
+assert(isEveryoneHere(users) === true);
+```
+
+`isEveryoneHere` 函數在 `users` 對象不包含 `Alan` 時應返回 `false`。
+
+```js
+assert(
+ (function () {
+ delete users.Alan;
+ return isEveryoneHere(users);
+ })() === false
+);
+```
+
+`isEveryoneHere` 函數在 `users` 對象不包含 `Jeff` 時應返回 `false`。
+
+```js
+assert(
+ (function () {
+ delete users.Jeff;
+ return isEveryoneHere(users);
+ })() === false
+);
+```
+
+`isEveryoneHere` 函數在 `users` 對象不包含 `Sarah` 時應返回 `false`。
+
+```js
+assert(
+ (function () {
+ delete users.Sarah;
+ return isEveryoneHere(users);
+ })() === false
+);
+```
+
+`isEveryoneHere` 函數在 `users` 對象不包含 `Ryan` 時應返回 `false`。
+
+```js
+assert(
+ (function () {
+ delete users.Ryan;
+ return isEveryoneHere(users);
+ })() === false
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let users = {
+ Alan: {
+ age: 27,
+ online: true
+ },
+ Jeff: {
+ age: 32,
+ online: true
+ },
+ Sarah: {
+ age: 48,
+ online: true
+ },
+ Ryan: {
+ age: 19,
+ online: true
+ }
+};
+
+function isEveryoneHere(obj) {
+ // Only change code below this line
+
+ // Only change code above this line
+}
+
+console.log(isEveryoneHere(users));
+```
+
+# --solutions--
+
+```js
+let users = {
+ Alan: {
+ age: 27,
+ online: true
+ },
+ Jeff: {
+ age: 32,
+ online: true
+ },
+ Sarah: {
+ age: 48,
+ online: true
+ },
+ Ryan: {
+ age: 19,
+ online: true
+ }
+};
+
+function isEveryoneHere(obj) {
+ return [
+ 'Alan',
+ 'Jeff',
+ 'Sarah',
+ 'Ryan'
+ ].every(i => obj.hasOwnProperty(i));
+}
+
+console.log(isEveryoneHere(users));
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-data-structures/combine-arrays-with-the-spread-operator.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-data-structures/combine-arrays-with-the-spread-operator.md
new file mode 100644
index 0000000000..d9e81ae47f
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-data-structures/combine-arrays-with-the-spread-operator.md
@@ -0,0 +1,63 @@
+---
+id: 587d7b7b367417b2b2512b17
+title: 使用展開運算符合並數組
+challengeType: 1
+forumTopicId: 301156
+dashedName: combine-arrays-with-the-spread-operator
+---
+
+# --description--
+
+展開語法（spread ）的另一個重要用途是合併數組，或者將某個數組的所有元素插入到另一個數組的任意位置。 我們也可以使用 ES5 的語法連接兩個數組，但只能讓它們首尾相接。 而展開語法可以讓這樣的操作變得極其簡單：
+
+```js
+let thisArray = ['sage', 'rosemary', 'parsley', 'thyme'];
+
+let thatArray = ['basil', 'cilantro', ...thisArray, 'coriander'];
+```
+
+`thatArray` 會有值 `['basil', 'cilantro', 'sage', 'rosemary', 'parsley', 'thyme', 'coriander']`
+
+使用展開語法，我們就可以很方便的實現一個用傳統方法會寫得很複雜且冗長的操作。
+
+# --instructions--
+
+我們已經定義了一個返回 `sentence` 變量的 `spreadOut` 函數。 請修改這個函數，利用 spread 使該函數返回數組 `['learning', 'to', 'code', 'is', 'fun']`。
+
+# --hints--
+
+`spreadOut` 應返回 `["learning", "to", "code", "is", "fun"]`。
+
+```js
+assert.deepEqual(spreadOut(), ['learning', 'to', 'code', 'is', 'fun']);
+```
+
+`spreadOut` 函數裏應用到展開語法。
+
+```js
+assert.notStrictEqual(spreadOut.toString().search(/[...]/), -1);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function spreadOut() {
+ let fragment = ['to', 'code'];
+ let sentence; // Change this line
+ return sentence;
+}
+
+console.log(spreadOut());
+```
+
+# --solutions--
+
+```js
+function spreadOut() {
+ let fragment = ['to', 'code'];
+ let sentence = ['learning', ...fragment, 'is', 'fun'];
+ return sentence;
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-data-structures/copy-an-array-with-the-spread-operator.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-data-structures/copy-an-array-with-the-spread-operator.md
new file mode 100644
index 0000000000..13a3b4f8e1
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-data-structures/copy-an-array-with-the-spread-operator.md
@@ -0,0 +1,102 @@
+---
+id: 587d7b7b367417b2b2512b13
+title: 使用展開運算符複製數組
+challengeType: 1
+forumTopicId: 301157
+dashedName: copy-an-array-with-the-spread-operator
+---
+
+# --description--
+
+`slice()` 可以讓我們從一個數組中選擇一些元素來複制到新數組中，而 ES6 中又引入了一個簡潔且可讀性強的語法：展開運算符（spread operator ），它能讓我們方便地複製數組中的*所有*元素。 展開語法寫出來是這樣：`...`
+
+我們可以用展開運算符來複制數組：
+
+```js
+let thisArray = [true, true, undefined, false, null];
+let thatArray = [...thisArray];
+```
+
+`thatArray` 等於 `[true, true, undefined, false, null]`。 `thisArray` 保持不變， `thatArray` 包含與 `thisArray` 相同的元素。
+
+# --instructions--
+
+我們已經定義了一個 `copyMachine` 函數，它接受 `arr`（一個數組）和 `num`（一個數字）作爲輸入參數。 該函數需要返回一個由 `num` 個 `arr` 組成的新的二維數組。 同時，我們寫好了大致的流程，只是細節實現還沒有寫完。 請修改這個函數，使用展開語法，使該函數能正常工作（提示：我們已經學到過的一個方法很適合用在這裏）！
+
+# --hints--
+
+`copyMachine([true, false, true], 2)` 應返回 `[[true, false, true], [true, false, true]]`。
+
+```js
+assert.deepEqual(copyMachine([true, false, true], 2), [
+ [true, false, true],
+ [true, false, true]
+]);
+```
+
+`copyMachine([1, 2, 3], 5)` 應返回 `[[1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3]]`。
+
+```js
+assert.deepEqual(copyMachine([1, 2, 3], 5), [
+ [1, 2, 3],
+ [1, 2, 3],
+ [1, 2, 3],
+ [1, 2, 3],
+ [1, 2, 3]
+]);
+```
+
+`copyMachine([true, true, null], 1)` 應返回 `[[true, true, null]]`。
+
+```js
+assert.deepEqual(copyMachine([true, true, null], 1), [[true, true, null]]);
+```
+
+`copyMachine(["it works"], 3)` 應返回 `[["it works"], ["it works"], ["it works"]]`。
+
+```js
+assert.deepEqual(copyMachine(['it works'], 3), [
+ ['it works'],
+ ['it works'],
+ ['it works']
+]);
+```
+
+`copyMachine` 函數中應對 `arr` 使用展開運算符（`spread operator`）。
+
+```js
+assert(code.match(/\.\.\.arr/));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function copyMachine(arr, num) {
+ let newArr = [];
+ while (num >= 1) {
+ // Only change code below this line
+
+ // Only change code above this line
+ num--;
+ }
+ return newArr;
+}
+
+console.log(copyMachine([true, false, true], 2));
+```
+
+# --solutions--
+
+```js
+function copyMachine(arr,num){
+ let newArr=[];
+ while(num >=1){
+ newArr.push([...arr]);
+ num--;
+ }
+ return newArr;
+}
+console.log(copyMachine([true, false, true], 2));
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-data-structures/copy-array-items-using-slice.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-data-structures/copy-array-items-using-slice.md
new file mode 100644
index 0000000000..368423b796
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-data-structures/copy-array-items-using-slice.md
@@ -0,0 +1,65 @@
+---
+id: 587d7b7a367417b2b2512b12
+title: 使用 slice() 複製數組元素
+challengeType: 1
+forumTopicId: 301158
+dashedName: copy-array-items-using-slice
+---
+
+# --description--
+
+接下來我們要介紹 `slice()` 方法。 `slice()` 不會修改數組，而是會複製，或者說*提取（extract）*給定數量的元素到一個新數組。 `slice()` 只接收 2 個輸入參數：第一個是開始提取元素的位置（索引），第二個是提取元素的結束位置（索引）。 提取的元素中不包括第二個參數所對應的元素。 如下示例：
+
+```js
+let weatherConditions = ['rain', 'snow', 'sleet', 'hail', 'clear'];
+
+let todaysWeather = weatherConditions.slice(1, 3);
+```
+
+`todaysWeather` 值爲 `['snow', 'sleet']`，`weatherConditions` 值仍然爲 `['rain', 'snow', 'sleet', 'hail', 'clear']`。
+
+在上面的代碼中，我們從一個數組中提取了一些元素，並用這些元素創建了一個新數組。
+
+# --instructions--
+
+我們已經定義了一個 `forecast` 函數，它接受一個數組作爲參數。 請修改這個函數，利用 `slice()` 從輸入的數組中提取信息，最終返回一個包含元素 `warm` 和 `sunny` 的新數組。
+
+# --hints--
+
+`forecast` 應返回 `["warm", "sunny"]`。
+
+```js
+assert.deepEqual(
+ forecast(['cold', 'rainy', 'warm', 'sunny', 'cool', 'thunderstorms']),
+ ['warm', 'sunny']
+);
+```
+
+`forecast` 函數中應使用 `slice()` 方法。
+
+```js
+assert(/\.slice\(/.test(code));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function forecast(arr) {
+ // Only change code below this line
+
+ return arr;
+}
+
+// Only change code above this line
+console.log(forecast(['cold', 'rainy', 'warm', 'sunny', 'cool', 'thunderstorms']));
+```
+
+# --solutions--
+
+```js
+function forecast(arr) {
+ return arr.slice(2,4);
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-data-structures/create-complex-multi-dimensional-arrays.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-data-structures/create-complex-multi-dimensional-arrays.md
new file mode 100644
index 0000000000..31cdc54b5d
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-data-structures/create-complex-multi-dimensional-arrays.md
@@ -0,0 +1,218 @@
+---
+id: 587d7b7b367417b2b2512b16
+title: 創建複雜的多維數組
+challengeType: 1
+forumTopicId: 301159
+dashedName: create-complex-multi-dimensional-arrays
+---
+
+# --description--
+
+很好！ 你現在已經學到很多關於數組的知識了， 但這些只是個開始。我們將在接下來的中挑戰中學到更多與數組相關的知識。 在繼續學習對象（Objects ）之前，讓我們再花一點時間瞭解下更復雜的數組嵌套。
+
+數組的一個強大的特性是，它可以包含其他數組，甚至完全由其他數組組成。 在上一個挑戰中，我們已經接觸到了包含數組的數組，但它還算是比較簡單的。 數組中的數組還可以再包含其他數組，即可以嵌套任意多層數組。 習慣上，我們稱這種數據結構爲多維（multi-dimensional）數組 或嵌套（nested）數組。 請看如下的示例：
+
+```js
+let nestedArray = [
+ ['deep'],
+ [
+ ['deeper'], ['deeper']
+ ],
+ [
+ [
+ ['deepest'], ['deepest']
+ ],
+ [
+ [
+ ['deepest-est?']
+ ]
+ ]
+ ]
+];
+```
+
+`deep` 數組已嵌套 2 層。 `deeper` 數組嵌套了 3 層。 `deepest` 數組嵌套了 3 層， `deepest-est?` 嵌套了 5 層。
+
+雖然這個例子看起來錯綜複雜，不過，尤其是在處理大量數據的時候，這種數據結構還是會用到的。 儘管結構複雜，不過我們仍可以通過方括號表示法來訪問嵌套得最深的數組：
+
+```js
+console.log(nestedArray[2][1][0][0][0]);
+```
+
+控制檯打印的是字符串 `deepest-est?`。 既然我們知道數據的位置，當然，我們也可以修改它：
+
+```js
+nestedArray[2][1][0][0][0] = 'deeper still';
+
+console.log(nestedArray[2][1][0][0][0]);
+```
+
+現在控制檯打印的是 `deeper still`。
+
+# --instructions--
+
+我們已經定義了一個叫做 `myNestedArray` 的數組變量。 請修改 `myNestedArray`，使用字符串（string ）、數字（number ）或布爾值（boolean ）的任意組合作爲數組的元素，並讓 myNestedArray 剛好有 5 層（注意，最外層的數組是第 1 層）。 同時，請在第 3 層的數組中包含字符串 `deep`；在第 4 層的數組中包含字符串 `deeper`，在第 5 層的數組中包含字符串 `deepest`。
+
+# --hints--
+
+`myNestedArray` 中的數據元素應只包含字符串、數字或者布爾值。
+
+```js
+assert.strictEqual(
+ (function (arr) {
+ let flattened = (function flatten(arr) {
+ const flat = [].concat(...arr);
+ return flat.some(Array.isArray) ? flatten(flat) : flat;
+ })(arr);
+ for (let i = 0; i < flattened.length; i++) {
+ if (
+ typeof flattened[i] !== 'number' &&
+ typeof flattened[i] !== 'string' &&
+ typeof flattened[i] !== 'boolean'
+ ) {
+ return false;
+ }
+ }
+ return true;
+ })(myNestedArray),
+ true
+);
+```
+
+`myNestedArray` 應剛好包含 5 層嵌套數組。
+
+```js
+assert.strictEqual(
+ (function (arr) {
+ let depth = 0;
+ function arrayDepth(array, i, d) {
+ if (Array.isArray(array[i])) {
+ arrayDepth(array[i], 0, d + 1);
+ } else {
+ depth = d > depth ? d : depth;
+ }
+ if (i < array.length) {
+ arrayDepth(array, i + 1, d);
+ }
+ }
+ arrayDepth(arr, 0, 0);
+ return depth;
+ })(myNestedArray),
+ 4
+);
+```
+
+`myNestedArray` 中應只有一個字符串 `deep`，並且應出現在第 3 層數組中。
+
+```js
+assert(
+ (function howDeep(array, target, depth = 0) {
+ return array.reduce((combined, current) => {
+ if (Array.isArray(current)) {
+ return combined.concat(howDeep(current, target, depth + 1));
+ } else if (current === target) {
+ return combined.concat(depth);
+ } else {
+ return combined;
+ }
+ }, []);
+ })(myNestedArray, 'deep').length === 1 &&
+ (function howDeep(array, target, depth = 0) {
+ return array.reduce((combined, current) => {
+ if (Array.isArray(current)) {
+ return combined.concat(howDeep(current, target, depth + 1));
+ } else if (current === target) {
+ return combined.concat(depth);
+ } else {
+ return combined;
+ }
+ }, []);
+ })(myNestedArray, 'deep')[0] === 2
+);
+```
+
+`myNestedArray` 中應只有一個字符串 `deeper`，並且應出現在第 4 層數組中。
+
+```js
+assert(
+ (function howDeep(array, target, depth = 0) {
+ return array.reduce((combined, current) => {
+ if (Array.isArray(current)) {
+ return combined.concat(howDeep(current, target, depth + 1));
+ } else if (current === target) {
+ return combined.concat(depth);
+ } else {
+ return combined;
+ }
+ }, []);
+ })(myNestedArray, 'deeper').length === 1 &&
+ (function howDeep(array, target, depth = 0) {
+ return array.reduce((combined, current) => {
+ if (Array.isArray(current)) {
+ return combined.concat(howDeep(current, target, depth + 1));
+ } else if (current === target) {
+ return combined.concat(depth);
+ } else {
+ return combined;
+ }
+ }, []);
+ })(myNestedArray, 'deeper')[0] === 3
+);
+```
+
+`myNestedArray` 中應只有一個字符串 `deepest`，並且應出現在第 5 層數組中。
+
+```js
+assert(
+ (function howDeep(array, target, depth = 0) {
+ return array.reduce((combined, current) => {
+ if (Array.isArray(current)) {
+ return combined.concat(howDeep(current, target, depth + 1));
+ } else if (current === target) {
+ return combined.concat(depth);
+ } else {
+ return combined;
+ }
+ }, []);
+ })(myNestedArray, 'deepest').length === 1 &&
+ (function howDeep(array, target, depth = 0) {
+ return array.reduce((combined, current) => {
+ if (Array.isArray(current)) {
+ return combined.concat(howDeep(current, target, depth + 1));
+ } else if (current === target) {
+ return combined.concat(depth);
+ } else {
+ return combined;
+ }
+ }, []);
+ })(myNestedArray, 'deepest')[0] === 4
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let myNestedArray = [
+ // Only change code below this line
+ ['unshift', false, 1, 2, 3, 'complex', 'nested'],
+ ['loop', 'shift', 6, 7, 1000, 'method'],
+ ['concat', false, true, 'spread', 'array'],
+ ['mutate', 1327.98, 'splice', 'slice', 'push'],
+ ['iterate', 1.3849, 7, '8.4876', 'arbitrary', 'depth']
+ // Only change code above this line
+];
+```
+
+# --solutions--
+
+```js
+let myNestedArray = [
+ ['unshift', ['deep', ['deeper', ['deepest']]],false, 1, 2, 3, 'complex', 'nested'],
+ ['loop', 'shift', 6, 7, 1000, 'method'],
+ ['concat', false, true, 'spread', 'array'],
+ ['mutate', 1327.98, 'splice', 'slice', 'push'],
+ ['iterate', 1.3849, 7, '8.4876', 'arbitrary', 'depth']
+];
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-data-structures/generate-an-array-of-all-object-keys-with-object.keys.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-data-structures/generate-an-array-of-all-object-keys-with-object.keys.md
new file mode 100644
index 0000000000..0c9c3c5166
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-data-structures/generate-an-array-of-all-object-keys-with-object.keys.md
@@ -0,0 +1,111 @@
+---
+id: 587d7b7d367417b2b2512b1e
+title: 使用 Object.keys() 生成由對象的所有屬性組成的數組
+challengeType: 1
+forumTopicId: 301160
+dashedName: generate-an-array-of-all-object-keys-with-object-keys
+---
+
+# --description--
+
+我們可以給 `Object.keys()` 方法傳入一個對象作爲參數，來生成包含對象所有鍵的數組。 這會返回一個由對象中所有屬性（字符串）組成的數組。 需要注意的是，數組中元素的順序是不確定的。
+
+# --instructions--
+
+請完成 `getArrayOfUsers` 函數的實現，使其返回一個由輸入對象中的所有屬性所組成的數組。
+
+# --hints--
+
+`users` 對象應該只包含 `Alan`、`Jeff`、`Sarah`、`Ryan` 這 4 個屬性。
+
+```js
+assert(
+ 'Alan' in users &&
+ 'Jeff' in users &&
+ 'Sarah' in users &&
+ 'Ryan' in users &&
+ Object.keys(users).length === 4
+);
+```
+
+`getArrayOfUsers` 函數應返回一個包含 `users` 對象中所有屬性的數組。
+
+```js
+assert(
+ (function () {
+ users.Sam = {};
+ users.Lewis = {};
+ let R = getArrayOfUsers(users);
+ return (
+ R.indexOf('Alan') !== -1 &&
+ R.indexOf('Jeff') !== -1 &&
+ R.indexOf('Sarah') !== -1 &&
+ R.indexOf('Ryan') !== -1 &&
+ R.indexOf('Sam') !== -1 &&
+ R.indexOf('Lewis') !== -1
+ );
+ })() === true
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let users = {
+ Alan: {
+ age: 27,
+ online: false
+ },
+ Jeff: {
+ age: 32,
+ online: true
+ },
+ Sarah: {
+ age: 48,
+ online: false
+ },
+ Ryan: {
+ age: 19,
+ online: true
+ }
+};
+
+function getArrayOfUsers(obj) {
+ // Only change code below this line
+
+ // Only change code above this line
+}
+
+console.log(getArrayOfUsers(users));
+```
+
+# --solutions--
+
+```js
+let users = {
+ Alan: {
+ age: 27,
+ online: false
+ },
+ Jeff: {
+ age: 32,
+ online: true
+ },
+ Sarah: {
+ age: 48,
+ online: false
+ },
+ Ryan: {
+ age: 19,
+ online: true
+ }
+};
+
+function getArrayOfUsers(obj) {
+ return Object.keys(obj);
+}
+
+console.log(getArrayOfUsers(users));
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-data-structures/iterate-through-all-an-arrays-items-using-for-loops.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-data-structures/iterate-through-all-an-arrays-items-using-for-loops.md
new file mode 100644
index 0000000000..b306d36360
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-data-structures/iterate-through-all-an-arrays-items-using-for-loops.md
@@ -0,0 +1,138 @@
+---
+id: 587d7b7b367417b2b2512b15
+title: 使用 for 循環遍歷數組中的全部元素
+challengeType: 1
+forumTopicId: 301161
+dashedName: iterate-through-all-an-arrays-items-using-for-loops
+---
+
+# --description--
+
+使用數組時，我們經常需要遍歷數組的所有元素來找出我們需要的一個或多個元素，抑或是對數組執行一些特定的操作。 JavaScript 爲我們提供了幾個內置的方法，它們以不同的方式遍歷數組，以便我們可以用於不同的場景（如 `every()`、`forEach()`、`map()` 等等）。 然而，最簡單的 `for` 循環不僅能實現上述這些方法的功能，而且相比之下也會更加靈活。
+
+請看以下的例子：
+
+```js
+function greaterThanTen(arr) {
+ let newArr = [];
+ for (let i = 0; i < arr.length; i++) {
+ if (arr[i] > 10) {
+ newArr.push(arr[i]);
+ }
+ }
+ return newArr;
+}
+
+greaterThanTen([2, 12, 8, 14, 80, 0, 1]);
+```
+
+在這個函數中，我們用一個 `for` 循環來遍歷數組，逐一對其中的元素進行判斷。 通過上面的代碼，我們可以找出數組中大於 `10` 的所有元素，並返回一個包含這些元素的新數組 `[12, 14, 80]`。
+
+# --instructions--
+
+我們已經定義了 `filteredArray` 函數，它接受一個嵌套的數組 `arr` 和一個 `elem` 作爲參數，並要返回一個新數組。 `arr` 數組中嵌套的數組裏可能包含 `elem` 元素，也可能不包含。 請修改該函數，用一個 `for` 循環來做篩選，使函數返回一個由 `arr` 中不包含 `elem` 的數組所組成的新數組。
+
+# --hints--
+
+`filteredArray([[10, 8, 3], [14, 6, 23], [3, 18, 6]], 18)` 應返回 `[[10, 8, 3], [14, 6, 23]]`。
+
+```js
+assert.deepEqual(
+ filteredArray(
+ [
+ [10, 8, 3],
+ [14, 6, 23],
+ [3, 18, 6]
+ ],
+ 18
+ ),
+ [
+ [10, 8, 3],
+ [14, 6, 23]
+ ]
+);
+```
+
+`filteredArray([["trumpets", 2], ["flutes", 4], ["saxophones", 2]], 2)` 應返回 `[["flutes", 4]]`。
+
+```js
+assert.deepEqual(
+ filteredArray(
+ [
+ ['trumpets', 2],
+ ['flutes', 4],
+ ['saxophones', 2]
+ ],
+ 2
+ ),
+ [['flutes', 4]]
+);
+```
+
+`filteredArray([["amy", "beth", "sam"], ["dave", "sean", "peter"]], "peter")` 應返回 `[["amy", "beth", "sam"]]`。
+
+```js
+assert.deepEqual(
+ filteredArray(
+ [
+ ['amy', 'beth', 'sam'],
+ ['dave', 'sean', 'peter']
+ ],
+ 'peter'
+ ),
+ [['amy', 'beth', 'sam']]
+);
+```
+
+`filteredArray([[3, 2, 3], [1, 6, 3], [3, 13, 26], [19, 3, 9]], 3)` 應返回 `[]`。
+
+```js
+assert.deepEqual(
+ filteredArray(
+ [
+ [3, 2, 3],
+ [1, 6, 3],
+ [3, 13, 26],
+ [19, 3, 9]
+ ],
+ 3
+ ),
+ []
+);
+```
+
+`filteredArray` 函數中應使用 `for` 循環。
+
+```js
+assert.notStrictEqual(filteredArray.toString().search(/for/), -1);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function filteredArray(arr, elem) {
+ let newArr = [];
+ // Only change code below this line
+
+ // Only change code above this line
+ return newArr;
+}
+
+console.log(filteredArray([[3, 2, 3], [1, 6, 3], [3, 13, 26], [19, 3, 9]], 3));
+```
+
+# --solutions--
+
+```js
+function filteredArray(arr, elem) {
+ let newArr = [];
+ for (let i = 0; ifor...in 語句即可。 以遍歷 `users` 對象的屬性爲例：
+
+```js
+for (let user in users) {
+ console.log(user);
+}
+```
+
+這將在控制檯打印 `Alan`、`Jeff`、`Sarah` 和 `Ryan` - 每個值佔一行。
+
+在上面的代碼中，我們定義了一個 `user` 變量。 可以觀察到，這個變量在遍歷對象的語句執行過程中會一直被重置並賦予新值，結果就是不同的用戶名打印到了 console 中。
+
+**注意：**對象中的鍵是無序的，這與數組不同。 因此，一個對象中某個屬性的位置，或者說它出現的相對順序，在引用或訪問該屬性時是不確定的。
+
+# --instructions--
+
+我們已經定義了一個 `countOnline` 函數，它接收一個 users 對象參數。 請在其中使用 for...in 語句來遍歷傳入函數的 users 對象中的用戶，並返回 `online` 屬性爲 `true` 的用戶數量。 以下是一個傳入 `countOnline` 函數的對象示例， 注意每個用戶都有 `online` 屬性，其屬性值爲 `true` 或 `false`：
+
+```js
+{
+ Alan: {
+ online: false
+ },
+ Jeff: {
+ online: true
+ },
+ Sarah: {
+ online: false
+ }
+}
+```
+
+# --hints--
+
+函數 `countOnline` 中應使用 `for in` 語句遍歷傳入的對象的對象鍵。
+
+```js
+assert(
+ code.match(
+ /for\s*\(\s*(var|let|const)\s+[a-zA-Z_$]\w*\s+in\s+[a-zA-Z_$]\w*\s*\)/
+ )
+);
+```
+
+當傳入 `{ Alan: { online: false }, Jeff: { online: true }, Sarah: { online: false } }` 時，函數 `countOnline` 應該返回 `1`。
+
+```js
+assert(countOnline(usersObj1) === 1);
+```
+
+當傳入 `{ Alan: { online: true }, Jeff: { online: false }, Sarah: { online: true } }` 時，函數 `countOnline` 應該返回 `2`。
+
+```js
+assert(countOnline(usersObj2) === 2);
+```
+
+當傳入 `{ Alan: { online: false }, Jeff: { online: false }, Sarah: { online: false } }` 時，函數 `countOnline` 應該返回 `0`。
+
+```js
+assert(countOnline(usersObj3) === 0);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+const usersObj1 = {
+ Alan: {
+ online: false
+ },
+ Jeff: {
+ online: true
+ },
+ Sarah: {
+ online: false
+ }
+}
+
+const usersObj2 = {
+ Alan: {
+ online: true
+ },
+ Jeff: {
+ online: false
+ },
+ Sarah: {
+ online: true
+ }
+}
+
+
+const usersObj3 = {
+ Alan: {
+ online: false
+ },
+ Jeff: {
+ online: false
+ },
+ Sarah: {
+ online: false
+ }
+}
+```
+
+## --seed-contents--
+
+```js
+function countOnline(usersObj) {
+ // Only change code below this line
+
+ // Only change code above this line
+}
+```
+
+# --solutions--
+
+```js
+function countOnline(usersObj) {
+ let online = 0;
+ for(let user in usersObj){
+ if(usersObj[user].online) {
+ online++;
+ }
+ }
+ return online;
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-data-structures/modify-an-array-stored-in-an-object.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-data-structures/modify-an-array-stored-in-an-object.md
new file mode 100644
index 0000000000..43d7690ba5
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-data-structures/modify-an-array-stored-in-an-object.md
@@ -0,0 +1,112 @@
+---
+id: 587d7b7d367417b2b2512b1f
+title: 修改存儲在對象中的數組
+challengeType: 1
+forumTopicId: 301163
+dashedName: modify-an-array-stored-in-an-object
+---
+
+# --description--
+
+我們已經學習了 JavaScript 對象的這些基本操作： 添加、修改、移除鍵值對、檢查某個屬性是否存在、遍歷對象的所有屬性。 在繼續學習 JavaScript 的過程中，我們會了解對象的更多用法。 另外，在之後的數據結構課程中，我們還會學習 ES6 的 Map 和 Set 。 這兩種數據結構與我們現在學到的對象十分類似，但它們在對象的基礎上提供了一些額外的功能。 目前，我們已經學習了數組和對象的基礎知識，讓我們試着來用所學的知識解決一些更復雜的問題。
+
+# --instructions--
+
+請看一下代碼編輯器中我們爲你寫好的對象。 `user` 對象包含 3 個屬性； `data` 對象包含 5 個屬性，其中包含一個叫做 `friends` 的數組。 這就是對象作爲數據結構所展現出的靈活性。 我們已經寫好了 `addFriend` 函數的一部分， 請你完成這個函數，使其接受一個 `user` 對象，將 `friend` 參數中的名字添加到 `user.data.friends` 數組中並返回該數組。
+
+# --hints--
+
+`user` 對象應該包含 `name`、`age` 和 `data` 三個屬性。
+
+```js
+assert('name' in user && 'age' in user && 'data' in user);
+```
+
+`addFriend` 函數應該接受一個 `user` 對象和一個 `friend` 字符串作爲輸入參數，並將這個字符串插入到 `user` 對象的 `friends` 數組中。
+
+```js
+assert(
+ (function () {
+ let L1 = user.data.friends.length;
+ addFriend(user, 'Sean');
+ let L2 = user.data.friends.length;
+ return L2 === L1 + 1;
+ })()
+);
+```
+
+`addFriend(user, "Pete")` 應該返回 `["Sam", "Kira", "Tomo", "Pete"]`。
+
+```js
+assert.deepEqual(
+ (function () {
+ delete user.data.friends;
+ user.data.friends = ['Sam', 'Kira', 'Tomo'];
+ return addFriend(user, 'Pete');
+ })(),
+ ['Sam', 'Kira', 'Tomo', 'Pete']
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let user = {
+ name: 'Kenneth',
+ age: 28,
+ data: {
+ username: 'kennethCodesAllDay',
+ joinDate: 'March 26, 2016',
+ organization: 'freeCodeCamp',
+ friends: [
+ 'Sam',
+ 'Kira',
+ 'Tomo'
+ ],
+ location: {
+ city: 'San Francisco',
+ state: 'CA',
+ country: 'USA'
+ }
+ }
+};
+
+function addFriend(userObj, friend) {
+ // Only change code below this line
+
+ // Only change code above this line
+}
+
+console.log(addFriend(user, 'Pete'));
+```
+
+# --solutions--
+
+```js
+let user = {
+ name: 'Kenneth',
+ age: 28,
+ data: {
+ username: 'kennethCodesAllDay',
+ joinDate: 'March 26, 2016',
+ organization: 'freeCodeCamp',
+ friends: [
+ 'Sam',
+ 'Kira',
+ 'Tomo'
+ ],
+ location: {
+ city: 'San Francisco',
+ state: 'CA',
+ country: 'USA'
+ }
+ }
+};
+
+function addFriend(userObj, friend) {
+ userObj.data.friends.push(friend);
+ return userObj.data.friends;
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-data-structures/modify-an-object-nested-within-an-object.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-data-structures/modify-an-object-nested-within-an-object.md
new file mode 100644
index 0000000000..55e52abdf8
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-data-structures/modify-an-object-nested-within-an-object.md
@@ -0,0 +1,101 @@
+---
+id: 587d7b7c367417b2b2512b19
+title: 修改嵌套在對象中的對象
+challengeType: 1
+forumTopicId: 301164
+dashedName: modify-an-object-nested-within-an-object
+---
+
+# --description--
+
+現在我們來看一個稍複雜的對象。 在對象中，我們也可以嵌套任意層數的對象，對象的屬性值可以是 JavaScript 支持的任意類型，包括數組和其他對象。 請看以下例子：
+
+```js
+let nestedObject = {
+ id: 28802695164,
+ date: 'December 31, 2016',
+ data: {
+ totalUsers: 99,
+ online: 80,
+ onlineStatus: {
+ active: 67,
+ away: 13,
+ busy: 8
+ }
+ }
+};
+```
+
+`nestedObject` 有 3 個屬性：`id`（屬性值爲數字）、`date`（屬性值爲字符串）、`data`（屬性值爲嵌套的對象）。 雖然對象中的數據可能很複雜，我們仍能使用上一個挑戰中講到的寫法來訪問我們需要的信息。 如果我們想把嵌套在 `onlineStatus` 中 `busy` 的屬性值改爲 `10`，可以用點號表示法來這樣實現：
+
+```js
+nestedObject.data.onlineStatus.busy = 10;
+```
+
+# --instructions--
+
+我們已經定義了一個 `userActivity` 對象，它包含了另一個對象。 請將 `online` 的屬性值改爲 `45`。
+
+# --hints--
+
+`userActivity` 應包含 `id`、`date` 和 `data` 屬性。
+
+```js
+assert(
+ 'id' in userActivity && 'date' in userActivity && 'data' in userActivity
+);
+```
+
+`userActivity` 應包含 `data` 屬性，其屬性值應爲包含 `totalUsers` 和 `online` 屬性的對象。
+
+```js
+assert('totalUsers' in userActivity.data && 'online' in userActivity.data);
+```
+
+`userActivity` 的 `data` 屬性值中的 `online` 屬性值應被改爲 `45`。
+
+```js
+assert(userActivity.data.online === 45);
+```
+
+應使用點號表示法或方括號表示法來修改 `online` 屬性值。
+
+```js
+assert.strictEqual(code.search(/online: 45/), -1);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let userActivity = {
+ id: 23894201352,
+ date: 'January 1, 2017',
+ data: {
+ totalUsers: 51,
+ online: 42
+ }
+};
+
+// Only change code below this line
+
+// Only change code above this line
+
+console.log(userActivity);
+```
+
+# --solutions--
+
+```js
+let userActivity = {
+ id: 23894201352,
+ date: 'January 1, 2017',
+ data: {
+ totalUsers: 51,
+ online: 42
+ }
+};
+
+userActivity.data.online = 45;
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-data-structures/remove-items-from-an-array-with-pop-and-shift.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-data-structures/remove-items-from-an-array-with-pop-and-shift.md
new file mode 100644
index 0000000000..d72c8cc033
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-data-structures/remove-items-from-an-array-with-pop-and-shift.md
@@ -0,0 +1,86 @@
+---
+id: 587d78b2367417b2b2512b0f
+title: 使用 pop() 和 shift() 從數組中刪除元素
+challengeType: 1
+forumTopicId: 301165
+dashedName: remove-items-from-an-array-with-pop-and-shift
+---
+
+# --description--
+
+`push()` 和 `unshift()` 都有一個與它們作用相反的函數：`pop()` 和 `shift()`。 與插入元素相反，`pop()` 會從數組的末尾*移除*一個元素，而 `shift()` 會從數組的開頭移除一個元素。 `pop()` 和 `shift()` 與 `push()` 和 `unshift()` 的關鍵區別在於，用於刪除元素的方法不接收參數，而且每次只能刪除數組中的一個元素。
+
+讓我們來看以下的例子：
+
+```js
+let greetings = ['whats up?', 'hello', 'see ya!'];
+
+greetings.pop();
+```
+
+`greetings` 值爲 `['whats up?', 'hello']`。
+
+```js
+greetings.shift();
+```
+
+`greetings` 值爲 `['hello']`。
+
+這些用於刪除數組元素的方法會返回被刪除的元素：
+
+```js
+let popped = greetings.pop();
+```
+
+`greetings` 值爲 `[]`，`popped` 值爲 `hello`。
+
+# --instructions--
+
+我們已經定義了一個 `popShift` 函數，它接收一個數組作爲輸入參數並返回一個新的數組。 請修改這個函數，使用 `pop()` 和 `shift()` 來移除輸入的數組中的第一個元素和最後一個元素，並將這兩個被移除的元素分別賦值給對應的變量，使得最終返回的數組裏包含這兩個值。
+
+# --hints--
+
+`popShift(["challenge", "is", "not", "complete"])` 應返回 `["challenge", "complete"]`。
+
+```js
+assert.deepEqual(popShift(['challenge', 'is', 'not', 'complete']), [
+ 'challenge',
+ 'complete'
+]);
+```
+
+`popShift` 函數中應使用 `pop()` 方法。
+
+```js
+assert.notStrictEqual(popShift.toString().search(/\.pop\(/), -1);
+```
+
+`popShift` 函數中應使用 `shift()` 方法。
+
+```js
+assert.notStrictEqual(popShift.toString().search(/\.shift\(/), -1);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function popShift(arr) {
+ let popped; // Change this line
+ let shifted; // Change this line
+ return [shifted, popped];
+}
+
+console.log(popShift(['challenge', 'is', 'not', 'complete']));
+```
+
+# --solutions--
+
+```js
+function popShift(arr) {
+ let popped = arr.pop(); // Change this line
+ let shifted = arr.shift(); // Change this line
+ return [shifted, popped];
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-data-structures/remove-items-using-splice.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-data-structures/remove-items-using-splice.md
new file mode 100644
index 0000000000..8e0fd29240
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-data-structures/remove-items-using-splice.md
@@ -0,0 +1,87 @@
+---
+id: 587d78b2367417b2b2512b10
+title: 使用 splice() 刪除元素
+challengeType: 1
+forumTopicId: 301166
+dashedName: remove-items-using-splice
+---
+
+# --description--
+
+在之前的挑戰中，我們已經學習瞭如何用 `shift()` 和 `pop()` 從數組的開頭或末尾移除元素。 但如果我們想刪除數組中間的一個元素， 或者想一次刪除多個元素，該如何操作呢？ 這時候我們就需要使用 `splice()` 方法了， `splice()` 可以讓我們從數組中的任意位置**連續刪除任意數量的元素**。
+
+`splice()` 最多可以接受 3 個參數，但現在我們先關注前兩個。 `splice()` 接收的前兩個參數是整數，表示正在調用 的`splice()` 數組中的元素的索引或位置。 別忘了，數組的索引是*從 0 開始的*，所以我們要用 `0` 來表示數組中的第一個元素。 `splice()` 的第一個參數代表從數組中的哪個索引開始移除元素，而第二個參數表示要從數組中的這個位置開始刪除多少個元素。 例如：
+
+```js
+let array = ['today', 'was', 'not', 'so', 'great'];
+
+array.splice(2, 2);
+```
+
+這裏我們移除 2 個元素，首先是第三個元素（索引爲 2）。 `array` 會有值 `['today', 'was', 'great']`。
+
+`splice()` 不僅會修改調用該方法的數組，還會返回一個包含被移除元素的數組：
+
+```js
+let array = ['I', 'am', 'feeling', 'really', 'happy'];
+
+let newArray = array.splice(3, 2);
+```
+
+`newArray` 值爲 `['really', 'happy']`。
+
+# --instructions--
+
+我們已經定義了數組 `arr`。 請使用 `splice()` 從 `arr` 裏移除元素，使剩餘的元素之和爲 `10`。
+
+# --hints--
+
+不應修改這一行 `const arr = [2, 4, 5, 1, 7, 5, 2, 1];`。
+
+```js
+assert(
+ __helpers.removeWhiteSpace(code).match(/constarr=\[2,4,5,1,7,5,2,1\];?/)
+);
+```
+
+`arr` 的剩餘元素之和應爲 `10`。
+
+```js
+assert.strictEqual(
+ arr.reduce((a, b) => a + b),
+ 10
+);
+```
+
+應對 `arr` 調用 `splice()` 方法。
+
+```js
+assert(__helpers.removeWhiteSpace(code).match(/arr\.splice\(/));
+```
+
+splice 應只刪除 `arr` 裏面的元素，不能給 `arr` 添加元素。
+
+```js
+assert(
+ !__helpers.removeWhiteSpace(code).match(/arr\.splice\(\d+,\d+,\d+.*\)/g)
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+const arr = [2, 4, 5, 1, 7, 5, 2, 1];
+// Only change code below this line
+
+// Only change code above this line
+console.log(arr);
+```
+
+# --solutions--
+
+```js
+const arr = [2, 4, 5, 1, 7, 5, 2, 1];
+arr.splice(1, 4);
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-data-structures/use-an-array-to-store-a-collection-of-data.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-data-structures/use-an-array-to-store-a-collection-of-data.md
new file mode 100644
index 0000000000..a570afa7ab
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-data-structures/use-an-array-to-store-a-collection-of-data.md
@@ -0,0 +1,95 @@
+---
+id: 587d7b7e367417b2b2512b20
+title: 使用數組存儲不同類型的數據
+challengeType: 1
+forumTopicId: 301167
+dashedName: use-an-array-to-store-a-collection-of-data
+---
+
+# --description--
+
+以下是最簡單的數組（Array）示例： 這是一個一維數組（one-dimensional array ），它只有一層，或者說它裏面沒有包含其它數組。 可以觀察到，這個數組中只包含了布爾值（booleans ）、字符串（strings ）、數字（numbers ）以及 JavaScript 中的其他數據類型：
+
+```js
+let simpleArray = ['one', 2, 'three', true, false, undefined, null];
+console.log(simpleArray.length);
+```
+
+調用 `console.log` 顯示 `7`。
+
+所有數組都有一個表示長度的屬性，我們可以通過 `Array.length` 來訪問它。 下面是一個關於數組的更復雜的例子。 這是一個多維數組 （multi-dimensional Array ），或者說是一個包含了其他數組的數組。 可以注意到，在它的內部還包含了 JavaScript 中的對象（objects ）結構。 我們會在後面的小節中討論該數據結構，但現在你只需要知道數組能夠存儲複雜的對象類型數據。
+
+```js
+let complexArray = [
+ [
+ {
+ one: 1,
+ two: 2
+ },
+ {
+ three: 3,
+ four: 4
+ }
+ ],
+ [
+ {
+ a: "a",
+ b: "b"
+ },
+ {
+ c: "c",
+ d: "d"
+ }
+ ]
+];
+```
+
+# --instructions--
+
+我們已經定義了一個名爲 `yourArray` 的變量。 請修改代碼，將一個含有至少 5 個元素的數組賦值給 `yourArray` 變量。 你的數組中應包含至少一個 string 類型的數據、一個 number 類型的數據和一個 boolean 類型的數據。
+
+# --hints--
+
+`yourArray` 應爲數組。
+
+```js
+assert.strictEqual(Array.isArray(yourArray), true);
+```
+
+`yourArray` 應包含至少 5 個元素。
+
+```js
+assert.isAtLeast(yourArray.length, 5);
+```
+
+`yourArray` 應包含至少一個 `boolean`。
+
+```js
+assert(yourArray.filter((el) => typeof el === 'boolean').length >= 1);
+```
+
+`yourArray` 應包含至少一個 `number`。
+
+```js
+assert(yourArray.filter((el) => typeof el === 'number').length >= 1);
+```
+
+`yourArray` 應包含至少一個 `string`。
+
+```js
+assert(yourArray.filter((el) => typeof el === 'string').length >= 1);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let yourArray; // Change this line
+```
+
+# --solutions--
+
+```js
+let yourArray = ['a string', 100, true, ['one', 2], 'another string'];
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-data-structures/use-the-delete-keyword-to-remove-object-properties.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-data-structures/use-the-delete-keyword-to-remove-object-properties.md
new file mode 100644
index 0000000000..5bdab287a9
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-data-structures/use-the-delete-keyword-to-remove-object-properties.md
@@ -0,0 +1,86 @@
+---
+id: 587d7b7c367417b2b2512b1b
+title: 使用 delete 關鍵字刪除對象屬性
+challengeType: 1
+forumTopicId: 301168
+dashedName: use-the-delete-keyword-to-remove-object-properties
+---
+
+# --description--
+
+現在我們已經學習了什麼是對象以及對象的基本特性和用途。 總之，對象是以鍵值對的形式，靈活、直觀地存儲結構化數據的一種方式，***而且***，通過對象的屬性查找屬性值是速度很快的操作。 在本章餘下的挑戰中，我們來了解一下對象的幾種常用操作，這樣你能更好地在代碼中使用這個十分有用的數據結構：對象。
+
+在之前的挑戰中，我們已經試過添加和修改對象中的鍵值對。 現在我們來看看如何從一個對象中*移除*一個鍵值對。
+
+我們再來回顧一下上一個挑戰中的 `foods` 對象。 如果我們想移除 `apples` 屬性，可以像這樣使用 `delete` 關鍵字：
+
+```js
+delete foods.apples;
+```
+
+# --instructions--
+
+請使用 delete 關鍵字來移除 `foods` 中的 `oranges`、`plums` 和 `strawberries` 屬性。
+
+# --hints--
+
+`foods` 對象應只包含 3 個屬性：`apples`、`grapes` 和 `bananas`。
+
+```js
+assert(
+ !foods.hasOwnProperty('oranges') &&
+ !foods.hasOwnProperty('plums') &&
+ !foods.hasOwnProperty('strawberries') &&
+ Object.keys(foods).length === 3
+);
+```
+
+應使用 `delete` 關鍵字來移除 `oranges`、`plums` 和 `strawberries` 屬性。
+
+```js
+assert(
+ code.search(/oranges:/) !== -1 &&
+ code.search(/plums:/) !== -1 &&
+ code.search(/strawberries:/) !== -1
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let foods = {
+ apples: 25,
+ oranges: 32,
+ plums: 28,
+ bananas: 13,
+ grapes: 35,
+ strawberries: 27
+};
+
+// Only change code below this line
+
+// Only change code above this line
+
+console.log(foods);
+```
+
+# --solutions--
+
+```js
+let foods = {
+ apples: 25,
+ oranges: 32,
+ plums: 28,
+ bananas: 13,
+ grapes: 35,
+ strawberries: 27
+};
+
+delete foods.oranges;
+delete foods.plums;
+delete foods.strawberries;
+
+console.log(foods);
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/access-array-data-with-indexes.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/access-array-data-with-indexes.md
new file mode 100644
index 0000000000..3bc677b78c
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/access-array-data-with-indexes.md
@@ -0,0 +1,89 @@
+---
+id: 56bbb991ad1ed5201cd392ca
+title: 通過索引訪問數組中的數據
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cBZQbTz'
+forumTopicId: 16158
+dashedName: access-array-data-with-indexes
+---
+
+# --description--
+
+我們可以使用索引（indexes ）來訪問數組中的數據。
+
+數組索引與字符串一樣使用方括號來表示，不同的是，它們不是指定字符，而是指定數組中的一個條目。 數組索引與字符串索引一樣是從 0 開始（zero-based ）的，所以數組中第一個元素的索引編號是 `0`。
+
+多維 數組看作成是*數組中的數組*。 使用方括號表示法訪問數組時，第一個方括號訪問的是數組的最外層（第一層），第二個方括號訪問的是數組的第二層，以此類推。
+
+**例如：**
+
+```js
+var arr = [
+ [1,2,3],
+ [4,5,6],
+ [7,8,9],
+ [[10,11,12], 13, 14]
+];
+arr[3];
+arr[3][0];
+arr[3][0][1];
+```
+
+`arr[3]` 爲 `[[10, 11, 12], 13, 14]`，`arr[3][0]` 爲 `[10, 11, 12]`，並且 `arr[3][0][1]` 爲 `11`。
+
+**注意：** 數組名與方括號之間不應該有任何空格，比如`array [0][0]` 甚至是 `array [0] [0]` 都是不允許的。 儘管 JavaScript 能夠正確處理這種情況，但是當其他程序員閱讀你寫的代碼時，這可能讓他們感到困惑。
+
+# --instructions--
+
+使用方括號從 `myArray` 中選取一個值，使得 `myData` 等於 `8`。
+
+# --hints--
+
+`myData` 應該等於 `8`。
+
+```js
+assert(myData === 8);
+```
+
+你應該使用方括號從 `myArray` 中讀取正確的值。
+
+```js
+assert(/myData=myArray\[2\]\[1\]/.test(__helpers.removeWhiteSpace(code)));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+if(typeof myArray !== "undefined"){(function(){return "myData: " + myData + " myArray: " + JSON.stringify(myArray);})();}
+```
+
+## --seed-contents--
+
+```js
+var myArray = [[1,2,3], [4,5,6], [7,8,9], [[10,11,12], 13, 14]];
+
+var myData = myArray[0][0];
+```
+
+# --solutions--
+
+```js
+var myArray = [[1,2,3],[4,5,6], [7,8,9], [[10,11,12], 13, 14]];
+var myData = myArray[2][1];
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-nested-arrays.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-nested-arrays.md
new file mode 100644
index 0000000000..59d2b9f723
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-nested-arrays.md
@@ -0,0 +1,125 @@
+---
+id: 56533eb9ac21ba0edf2244cd
+title: 訪問嵌套數組
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cLeGDtZ'
+forumTopicId: 16160
+dashedName: accessing-nested-arrays
+---
+
+# --description--
+
+在之前的挑戰中，我們學習了在對象中嵌套對象和數組。 與訪問嵌套對象類似，數組的方括號可以用來對嵌套數組進行鏈式訪問。
+
+下面是訪問嵌套數組的例子：
+
+```js
+var ourPets = [
+ {
+ animalType: "cat",
+ names: [
+ "Meowzer",
+ "Fluffy",
+ "Kit-Cat"
+ ]
+ },
+ {
+ animalType: "dog",
+ names: [
+ "Spot",
+ "Bowser",
+ "Frankie"
+ ]
+ }
+];
+ourPets[0].names[1];
+ourPets[1].names[0];
+```
+
+`ourPets[0].names[1]` 應該是字符串 `Fluffy`， 並且 `ourPets[1].names[0]` 應該是字符串 `Spot`。
+
+# --instructions--
+
+使用對象的點號和數組的方括號從變量 `myPlants` 檢索出第二棵樹。
+
+# --hints--
+
+`secondTree` 應該等於字符串 `pine`。
+
+```js
+assert(secondTree === 'pine');
+```
+
+你的代碼應該使用點號和方括號訪問 `myPlants`。
+
+```js
+assert(/=\s*myPlants\[1\].list\[1\]/.test(code));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(x) {
+ if(typeof x != 'undefined') {
+ return "secondTree = " + x;
+ }
+ return "secondTree is undefined";
+})(secondTree);
+```
+
+## --seed-contents--
+
+```js
+// Setup
+var myPlants = [
+ {
+ type: "flowers",
+ list: [
+ "rose",
+ "tulip",
+ "dandelion"
+ ]
+ },
+ {
+ type: "trees",
+ list: [
+ "fir",
+ "pine",
+ "birch"
+ ]
+ }
+];
+
+// Only change code below this line
+
+var secondTree = ""; // Change this line
+```
+
+# --solutions--
+
+```js
+var myPlants = [
+ {
+ type: "flowers",
+ list: [
+ "rose",
+ "tulip",
+ "dandelion"
+ ]
+ },
+ {
+ type: "trees",
+ list: [
+ "fir",
+ "pine",
+ "birch"
+ ]
+ }
+];
+
+// Only change code below this line
+
+var secondTree = myPlants[1].list[1];
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-nested-objects.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-nested-objects.md
new file mode 100644
index 0000000000..5f02f3269c
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-nested-objects.md
@@ -0,0 +1,99 @@
+---
+id: 56533eb9ac21ba0edf2244cc
+title: 訪問嵌套對象
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cRnRnfa'
+forumTopicId: 16161
+dashedName: accessing-nested-objects
+---
+
+# --description--
+
+我們可以通過連續使用點號表示法和方括號表示法來訪問對象的嵌套屬性。
+
+這是一個嵌套對象：
+
+```js
+var ourStorage = {
+ "desk": {
+ "drawer": "stapler"
+ },
+ "cabinet": {
+ "top drawer": {
+ "folder1": "a file",
+ "folder2": "secrets"
+ },
+ "bottom drawer": "soda"
+ }
+};
+ourStorage.cabinet["top drawer"].folder2;
+ourStorage.desk.drawer;
+```
+
+`ourStorage.cabinet["top drawer"].folder2` 將會是字符串 `secrets`，並且 `ourStorage.desk.drawer` 將會是字符串 `stapler`。
+
+# --instructions--
+
+訪問 `myStorage` 對象並將 `glove box` 屬性的內容賦值給 `gloveBoxContents` 變量。 在可能的情況下，對所有的屬性使用點號，否則使用方括號。
+
+# --hints--
+
+`gloveBoxContents` 應該等於字符串 `maps`。
+
+```js
+assert(gloveBoxContents === 'maps');
+```
+
+你的代碼應該使用點號和方括號來訪問 `myStorage`。
+
+```js
+assert(/=\s*myStorage\.car\.inside\[\s*("|')glove box\1\s*\]/g.test(code));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(x) {
+ if(typeof x != 'undefined') {
+ return "gloveBoxContents = " + x;
+ }
+ return "gloveBoxContents is undefined";
+})(gloveBoxContents);
+```
+
+## --seed-contents--
+
+```js
+var myStorage = {
+ "car": {
+ "inside": {
+ "glove box": "maps",
+ "passenger seat": "crumbs"
+ },
+ "outside": {
+ "trunk": "jack"
+ }
+ }
+};
+
+var gloveBoxContents = undefined;
+```
+
+# --solutions--
+
+```js
+var myStorage = {
+ "car":{
+ "inside":{
+ "glove box":"maps",
+ "passenger seat":"crumbs"
+ },
+ "outside":{
+ "trunk":"jack"
+ }
+ }
+};
+var gloveBoxContents = myStorage.car.inside["glove box"];
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-object-properties-with-bracket-notation.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-object-properties-with-bracket-notation.md
new file mode 100644
index 0000000000..9e95bc1935
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-object-properties-with-bracket-notation.md
@@ -0,0 +1,103 @@
+---
+id: 56533eb9ac21ba0edf2244c8
+title: 使用方括號表示法訪問對象屬性
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cBvmEHP'
+forumTopicId: 16163
+dashedName: accessing-object-properties-with-bracket-notation
+---
+
+# --description--
+
+訪問對象屬性的第二種方式是方括號表示法（`[]`）。 如果你想訪問的屬性名中包含空格，就必須使用方括號表示法來獲取它的屬性值。
+
+當然，如果屬性名不包含空格，也可以使用方括號表示法。
+
+這是一個使用方括號表示法讀取對象屬性的例子：
+
+```js
+var myObj = {
+ "Space Name": "Kirk",
+ "More Space": "Spock",
+ "NoSpace": "USS Enterprise"
+};
+myObj["Space Name"];
+myObj['More Space'];
+myObj["NoSpace"];
+```
+
+`myObj["Space Name"]` 將會是字符串 `Kirk`，`myObj['More Space']` 將會是字符串 `Spock`，並且`myObj["NoSpace"]` 將會是字符串 `USS Enterprise`。
+
+注意，如果屬性名中包含空格，就必須使用引號（單引號或雙引號）將它們包裹起來。
+
+# --instructions--
+
+使用方括號讀取 `testObj` 中 `an entree` 和 `the drink` 的屬性值，並分別將它們賦值給 `entreeValue` 和 `drinkValue`。
+
+# --hints--
+
+`entreeValue` 應該是一個字符串。
+
+```js
+assert(typeof entreeValue === 'string');
+```
+
+`entreeValue` 的值應該爲字符串 `hamburger`
+
+```js
+assert(entreeValue === 'hamburger');
+```
+
+`drinkValue` 應該是一個字符串
+
+```js
+assert(typeof drinkValue === 'string');
+```
+
+`drinkValue` 的值應該爲字符串 `water`
+
+```js
+assert(drinkValue === 'water');
+```
+
+你應該使用兩次方括號
+
+```js
+assert(code.match(/testObj\s*?\[('|")[^'"]+\1\]/g).length > 1);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(a,b) { return "entreeValue = '" + a + "', drinkValue = '" + b + "'"; })(entreeValue,drinkValue);
+```
+
+## --seed-contents--
+
+```js
+// Setup
+var testObj = {
+ "an entree": "hamburger",
+ "my side": "veggies",
+ "the drink": "water"
+};
+
+// Only change code below this line
+
+var entreeValue = testObj; // Change this line
+var drinkValue = testObj; // Change this line
+```
+
+# --solutions--
+
+```js
+var testObj = {
+ "an entree": "hamburger",
+ "my side": "veggies",
+ "the drink": "water"
+};
+var entreeValue = testObj["an entree"];
+var drinkValue = testObj['the drink'];
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-object-properties-with-dot-notation.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-object-properties-with-dot-notation.md
new file mode 100644
index 0000000000..e7e0008a15
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-object-properties-with-dot-notation.md
@@ -0,0 +1,99 @@
+---
+id: 56533eb9ac21ba0edf2244c7
+title: 通過點號表示法訪問對象屬性
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cGryJs8'
+forumTopicId: 16164
+dashedName: accessing-object-properties-with-dot-notation
+---
+
+# --description--
+
+和訪問數組類似，訪問對象屬性有兩種方式：點號表示法（`.`）和方括號表示法（`[]`）。
+
+如果我們已經提前知道要訪問的屬性名，使用點號表示法是最方便的。
+
+這裏是一個用點符號（`.`）讀取對象屬性的示例：
+
+```js
+var myObj = {
+ prop1: "val1",
+ prop2: "val2"
+};
+var prop1val = myObj.prop1;
+var prop2val = myObj.prop2;
+```
+
+`prop1val` 的值將爲字符串 `val1`，並且`prop2val` 的值將爲字符串 `val2`。
+# --instructions--
+
+使用點號讀取 `testObj` 的屬性值。 將變量 `hatValue` 的值設置爲該對象的 `hat` 屬性的值，並將變量 `shirtValue` 的值設置爲該對象的 `shirt` 屬性的值。
+
+# --hints--
+
+`hatValue` 應該是一個字符串
+
+```js
+assert(typeof hatValue === 'string');
+```
+
+`hatValue` 的值應該爲字符串 `ballcap`
+
+```js
+assert(hatValue === 'ballcap');
+```
+
+`shirtValue` 應該是一個字符串
+
+```js
+assert(typeof shirtValue === 'string');
+```
+
+`shirtValue` 的值應該爲字符串 `jersey`
+
+```js
+assert(shirtValue === 'jersey');
+```
+
+你應該使用兩個點號
+
+```js
+assert(code.match(/testObj\.\w+/g).length > 1);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(a,b) { return "hatValue = '" + a + "', shirtValue = '" + b + "'"; })(hatValue,shirtValue);
+```
+
+## --seed-contents--
+
+```js
+// Setup
+var testObj = {
+ "hat": "ballcap",
+ "shirt": "jersey",
+ "shoes": "cleats"
+};
+
+// Only change code below this line
+
+var hatValue = testObj; // Change this line
+var shirtValue = testObj; // Change this line
+```
+
+# --solutions--
+
+```js
+var testObj = {
+ "hat": "ballcap",
+ "shirt": "jersey",
+ "shoes": "cleats"
+};
+
+var hatValue = testObj.hat;
+var shirtValue = testObj.shirt;
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-object-properties-with-variables.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-object-properties-with-variables.md
new file mode 100644
index 0000000000..4209de1bec
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-object-properties-with-variables.md
@@ -0,0 +1,121 @@
+---
+id: 56533eb9ac21ba0edf2244c9
+title: 通過變量訪問對象屬性
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cnQyKur'
+forumTopicId: 16165
+dashedName: accessing-object-properties-with-variables
+---
+
+# --description--
+
+對對象上使用方括號表示法，還可以訪問對象上作爲變量值存儲的屬性。 當你需要遍歷對象的所有屬性，或者根據一個變量的值查找對應的屬性值時，這種寫法尤其適用。
+
+以下是一個使用變量來訪問屬性的例子：
+
+```js
+var dogs = {
+ Fido: "Mutt", Hunter: "Doberman", Snoopie: "Beagle"
+};
+var myDog = "Hunter";
+var myBreed = dogs[myDog];
+console.log(myBreed);
+```
+
+字符串 `Doberman` 將會出現在控制檯中。
+
+使用這一概念的另一種情況是：屬性的名字是在程序運行期間動態收集得到的。如下所示：
+
+```js
+var someObj = {
+ propName: "John"
+};
+function propPrefix(str) {
+ var s = "prop";
+ return s + str;
+}
+var someProp = propPrefix("Name");
+console.log(someObj[someProp]);
+```
+
+`someProp` 的值將爲字符串 `propName`，並且字符串 `John` 將會出現在控制檯中。
+
+注意，當使用變量名訪問屬性時，我們*沒有*使用引號包裹它，因爲我們正在使用的是變量的*值*，而不是變量的*名字*。
+
+# --instructions--
+
+將變量 `playerNumber` 設置爲 `16`。 然後，使用該變量查找玩家的名字，並將其賦值給`player`。
+
+# --hints--
+
+`playerNumber` 應該是一個數字
+
+```js
+assert(typeof playerNumber === 'number');
+```
+
+變量 `player` 應該是一個字符串
+
+```js
+assert(typeof player === 'string');
+```
+
+`player` 的值應該爲字符串 `Montana`
+
+```js
+assert(player === 'Montana');
+```
+
+你應該使用方括號訪問 `testObj`
+
+```js
+assert(/testObj\s*?\[.*?\]/.test(code));
+```
+
+你不應該直接將值 `Montana` 賦給變量 `player`。
+
+```js
+assert(!code.match(/player\s*=\s*"|\'\s*Montana\s*"|\'\s*;/gi));
+```
+
+你應該在你的方括號內使用變量 `playerNumber`。
+
+```js
+assert(/testObj\s*?\[\s*playerNumber\s*\]/.test(code));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+if(typeof player !== "undefined"){(function(v){return v;})(player);}
+```
+
+## --seed-contents--
+
+```js
+// Setup
+var testObj = {
+ 12: "Namath",
+ 16: "Montana",
+ 19: "Unitas"
+};
+
+// Only change code below this line
+
+var playerNumber; // Change this line
+var player = testObj; // Change this line
+```
+
+# --solutions--
+
+```js
+var testObj = {
+ 12: "Namath",
+ 16: "Montana",
+ 19: "Unitas"
+};
+var playerNumber = 16;
+var player = testObj[playerNumber];
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/add-new-properties-to-a-javascript-object.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/add-new-properties-to-a-javascript-object.md
new file mode 100644
index 0000000000..75f5ed0d00
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/add-new-properties-to-a-javascript-object.md
@@ -0,0 +1,91 @@
+---
+id: 56bbb991ad1ed5201cd392d2
+title: 給 JavaScript 對象添加新屬性
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cQe38UD'
+forumTopicId: 301169
+dashedName: add-new-properties-to-a-javascript-object
+---
+
+# --description--
+
+你也可以像更改屬性一樣給 JavaScript 對象添加屬性。
+
+這裏展示瞭如何給 `ourDog` 添加一個屬性 `bark`：
+
+```js
+ourDog.bark = "bow-wow";
+```
+
+或者
+
+```js
+ourDog["bark"] = "bow-wow";
+```
+
+現在，當我們執行 `ourDog.bark` 時，就能得到他的叫聲，`bow-wow`。
+
+例如：
+
+```js
+var ourDog = {
+ "name": "Camper",
+ "legs": 4,
+ "tails": 1,
+ "friends": ["everything!"]
+};
+
+ourDog.bark = "bow-wow";
+```
+
+# --instructions--
+
+給 `myDog` 添加一個屬性 `bark` ，並將其設置爲狗的聲音，比如 “woof“。 可以使用點操作符或者中括號操作符。
+
+# --hints--
+
+應該給 `myDog` 添加屬性 `bark`。
+
+```js
+assert(myDog.bark !== undefined);
+```
+
+不應該在初始化部分添加 `bark`。
+
+```js
+assert(!/bark[^\n]:/.test(code));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(z){return z;})(myDog);
+```
+
+## --seed-contents--
+
+```js
+// Setup
+var myDog = {
+ "name": "Happy Coder",
+ "legs": 4,
+ "tails": 1,
+ "friends": ["freeCodeCamp Campers"]
+};
+
+// Only change code below this line
+```
+
+# --solutions--
+
+```js
+var myDog = {
+ "name": "Happy Coder",
+ "legs": 4,
+ "tails": 1,
+ "friends": ["freeCodeCamp Campers"]
+};
+myDog.bark = "Woof Woof";
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/add-two-numbers-with-javascript.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/add-two-numbers-with-javascript.md
new file mode 100644
index 0000000000..233f3fd80c
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/add-two-numbers-with-javascript.md
@@ -0,0 +1,62 @@
+---
+id: cf1111c1c11feddfaeb3bdef
+title: 加法運算
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cM2KBAG'
+forumTopicId: 16650
+dashedName: add-two-numbers-with-javascript
+---
+
+# --description--
+
+`Number` 是 JavaScript 中的一種數據類型，用來表示數值。
+
+現在我們來嘗試在 JavaScript 中做加法運算。
+
+JavaScript 中，我們通過符號 `+` 來進行加法運算。
+
+**代碼示例:**
+
+```js
+myVar = 5 + 10;
+```
+
+現在，變量 `myVar` 的值爲 `15`。
+
+# --instructions--
+
+請改變數字 `0` 讓變量 sum 的值爲 `20`。
+
+# --hints--
+
+`sum` 的值應該等於 `20`。
+
+```js
+assert(sum === 20);
+```
+
+請使用 `+` 運算符。
+
+```js
+assert(/\+/.test(code));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(z){return 'sum = '+z;})(sum);
+```
+
+## --seed-contents--
+
+```js
+var sum = 10 + 0;
+```
+
+# --solutions--
+
+```js
+var sum = 10 + 10;
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/adding-a-default-option-in-switch-statements.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/adding-a-default-option-in-switch-statements.md
new file mode 100644
index 0000000000..433b0df9a6
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/adding-a-default-option-in-switch-statements.md
@@ -0,0 +1,128 @@
+---
+id: 56533eb9ac21ba0edf2244de
+title: 在 switch 語句中添加默認選項
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c3JvVfg'
+forumTopicId: 16653
+dashedName: adding-a-default-option-in-switch-statements
+---
+
+# --description--
+
+在 `switch` 語句中，你可能無法用 `case` 枚舉出所有可能的值。 相反，你可以添加 `default` 語句，它會在找不到相匹配的 `case` 語句之後執行。 你可以把它看作是 `if/else` 鏈中最後的那個 `else` 語句。
+
+`default` 語句應該被放到最後。
+
+```js
+switch (num) {
+ case value1:
+ statement1;
+ break;
+ case value2:
+ statement2;
+ break;
+...
+ default:
+ defaultStatement;
+ break;
+}
+```
+
+# --instructions--
+
+寫一個 switch 語句，設置以下條件設置 `answer`：
+`a` - `apple`
+`b` - `bird`
+`c` - `cat`
+`default` - `stuff`
+
+# --hints--
+
+`switchOfStuff("a")` 應該返回字符串 `apple`
+
+```js
+assert(switchOfStuff('a') === 'apple');
+```
+
+`switchOfStuff("b")` 應該返回字符串 `bird`
+
+```js
+assert(switchOfStuff('b') === 'bird');
+```
+
+`switchOfStuff("c")` 應該返回字符串 `cat`
+
+```js
+assert(switchOfStuff('c') === 'cat');
+```
+
+`switchOfStuff("d")` 應該返回字符串 `stuff`
+
+```js
+assert(switchOfStuff('d') === 'stuff');
+```
+
+`switchOfStuff(4)` 應該返回字符串 `stuff`
+
+```js
+assert(switchOfStuff(4) === 'stuff');
+```
+
+不能使用 `if` 或 `else` 語句。
+
+```js
+assert(!/else/g.test(code) || !/if/g.test(code));
+```
+
+你應該使用 `default` 語句。
+
+```js
+assert(switchOfStuff('string-to-trigger-default-case') === 'stuff');
+```
+
+你至少應該寫 3 個 `break` 語句。
+
+```js
+assert(code.match(/break/g).length > 2);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function switchOfStuff(val) {
+ var answer = "";
+ // Only change code below this line
+
+
+
+ // Only change code above this line
+ return answer;
+}
+
+switchOfStuff(1);
+```
+
+# --solutions--
+
+```js
+function switchOfStuff(val) {
+ var answer = "";
+
+ switch(val) {
+ case "a":
+ answer = "apple";
+ break;
+ case "b":
+ answer = "bird";
+ break;
+ case "c":
+ answer = "cat";
+ break;
+ default:
+ answer = "stuff";
+ }
+ return answer;
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/appending-variables-to-strings.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/appending-variables-to-strings.md
new file mode 100644
index 0000000000..d23fb4ecf1
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/appending-variables-to-strings.md
@@ -0,0 +1,78 @@
+---
+id: 56533eb9ac21ba0edf2244ed
+title: 將變量追加到字符串
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cbQmZfa'
+forumTopicId: 16656
+dashedName: appending-variables-to-strings
+---
+
+# --description--
+
+就像我們可以用多行字符串字面量 構建單個字符串一樣，我們還可以使用加且賦值（`+=`）運算符將字符串追加到字符串的末尾。
+
+示例：
+
+```js
+var anAdjective = "awesome!";
+var ourStr = "freeCodeCamp is ";
+ourStr += anAdjective;
+```
+
+`ourStr` 值爲 `freeCodeCamp is awesome!`。
+
+# --instructions--
+
+將 `someAdjective` 設置爲一個至少包含 3 個字符的字符串，然後使用 `+=` 運算符將它追加到 `myStr`。
+
+# --hints--
+
+`someAdjective` 應當爲包含至少三個字符的字符串。
+
+```js
+assert(typeof someAdjective !== 'undefined' && someAdjective.length > 2);
+```
+
+你應該使用 `+=` 運算符將 `someAdjective` 追加到 `myStr`。
+
+```js
+assert(code.match(/myStr\s*\+=\s*someAdjective\s*/).length > 0);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(){
+ var output = [];
+ if(typeof someAdjective === 'string') {
+ output.push('someAdjective = "' + someAdjective + '"');
+ } else {
+ output.push('someAdjective is not a string');
+ }
+ if(typeof myStr === 'string') {
+ output.push('myStr = "' + myStr + '"');
+ } else {
+ output.push('myStr is not a string');
+ }
+ return output.join('\n');
+})();
+```
+
+## --seed-contents--
+
+```js
+// Change code below this line
+
+var someAdjective;
+var myStr = "Learning to code is ";
+```
+
+# --solutions--
+
+```js
+var someAdjective = "neat";
+var myStr = "Learning to code is ";
+myStr += someAdjective;
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/assigning-the-value-of-one-variable-to-another.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/assigning-the-value-of-one-variable-to-another.md
new file mode 100644
index 0000000000..758384331f
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/assigning-the-value-of-one-variable-to-another.md
@@ -0,0 +1,86 @@
+---
+id: 5ee127a03c3b35dd45426493
+title: 將一個變量的值賦給另一個
+challengeType: 1
+videoUrl: ''
+forumTopicId: 418265
+dashedName: assigning-the-value-of-one-variable-to-another
+---
+
+# --description--
+
+在使用賦值 運算符賦予變量某個值後，你可以使用賦值 運算符將該變量的值賦給另一個變量。
+
+```js
+var myVar;
+myVar = 5;
+var myNum;
+myNum = myVar;
+```
+
+以上代碼聲明瞭一個沒有初始值的變量 `myVar`，然後給它賦值爲 `5`。 緊接着，又聲明瞭一個沒有初始值的變量 `myNum`。 然後，變量 `myVar` 的內容（也就是 `5`）被賦給了變量 `myNum`。 現在，變量 `myNum` 的值也爲 `5`。
+
+# --instructions--
+
+把變量 `a` 的內容賦給變量 `b`。
+
+# --hints--
+
+你不應該修改註釋上面的代碼。
+
+```js
+assert(/var a;/.test(code) && /a = 7;/.test(code) && /var b;/.test(code));
+```
+
+`b` 的值應該爲 `7`。
+
+```js
+assert(typeof b === 'number' && b === 7);
+```
+
+應該使用 `=` 將 `a` 賦給 `b`。
+
+```js
+assert(/b\s*=\s*a\s*/g.test(code));
+```
+
+# --seed--
+
+## --before-user-code--
+
+```js
+if (typeof a != 'undefined') {
+ a = undefined;
+}
+if (typeof b != 'undefined') {
+ b = undefined;
+}
+```
+
+## --after-user-code--
+
+```js
+(function(a, b) {
+ return 'a = ' + a + ', b = ' + b;
+})(a, b);
+```
+
+## --seed-contents--
+
+```js
+// Setup
+var a;
+a = 7;
+var b;
+
+// Only change code below this line
+```
+
+# --solutions--
+
+```js
+var a;
+a = 7;
+var b;
+b = a;
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/assignment-with-a-returned-value.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/assignment-with-a-returned-value.md
new file mode 100644
index 0000000000..a82d8634ae
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/assignment-with-a-returned-value.md
@@ -0,0 +1,71 @@
+---
+id: 56533eb9ac21ba0edf2244c3
+title: 使用返回值賦值
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/ce2pEtB'
+forumTopicId: 16658
+dashedName: assignment-with-a-returned-value
+---
+
+# --description--
+
+如果你還記得我們在[使用賦值運算符存儲值](/learn/javascript-algorithms-and-data-structures/basic-javascript/storing-values-with-the-assignment-operator)中的討論的話，等號右側的所有操作都會在賦值之前完成。 這意味着我們可以獲取函數的返回值，並將其賦值給一個變量。
+
+假設我們有一個預先定義的函數 `sum` ，它將兩個數相加，然後：
+
+```js
+ourSum = sum(5, 12);
+```
+
+將會調用函數 `sum`，函數返回值 `17`，然後將該值賦給變量 `ourSum`。
+
+# --instructions--
+
+調用 `processArg` 函數，參數爲 `7`，然後把返回的值賦值給變量 `processed`。
+
+# --hints--
+
+`processed` 的值應爲 `2`。
+
+```js
+assert(processed === 2);
+```
+
+應該將 `processArg` 賦值給 `processed`。
+
+```js
+assert(/processed\s*=\s*processArg\(\s*7\s*\)/.test(code));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(){return "processed = " + processed})();
+```
+
+## --seed-contents--
+
+```js
+// Setup
+var processed = 0;
+
+function processArg(num) {
+ return (num + 3) / 5;
+}
+
+// Only change code below this line
+```
+
+# --solutions--
+
+```js
+var processed = 0;
+
+function processArg(num) {
+ return (num + 3) / 5;
+}
+
+processed = processArg(7);
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/build-javascript-objects.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/build-javascript-objects.md
new file mode 100644
index 0000000000..3a4e7bc62f
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/build-javascript-objects.md
@@ -0,0 +1,159 @@
+---
+id: 56bbb991ad1ed5201cd392d0
+title: 創建 JavaScript 對象
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cWGkbtd'
+forumTopicId: 16769
+dashedName: build-javascript-objects
+---
+
+# --description--
+
+你之前可能聽過 `object` 這個詞。
+
+對象和 `arrays` 類似，區別在於數組使用索引來訪問和修改數據，而對象中的數據是通過 `properties` 訪問的。
+
+對象非常適合用來存儲結構化數據，可以表示真實世界中的物體，比如一隻貓。
+
+這裏是一個貓對象的樣本：
+
+```js
+var cat = {
+ "name": "Whiskers",
+ "legs": 4,
+ "tails": 1,
+ "enemies": ["Water", "Dogs"]
+};
+```
+
+在這個示例中，所有的屬性都被純屬爲字符串，比如 `name`、`legs` 和 `tails`。 然而，你也可以使用數字作爲屬性。 你甚至可以省略單字字符串屬性中的引號，如下所示：
+
+```js
+var anotherObject = {
+ make: "Ford",
+ 5: "five",
+ "model": "focus"
+};
+```
+
+然而，如果你的對象有非字符串屬性的話，JavaScript 會自動將它們轉爲字符串。
+
+# --instructions--
+
+確保對象表示一隻名爲 `myDog` 的狗，包含屬性 `name`（字符串）、`legs`、`tails` 和 `friends`。
+
+你可以隨意設置這些對象的屬性值，只要 `name` 是字符串，`legs` 和 `tails` 是數字，`friends` 是數組即可。
+
+# --hints--
+
+`myDog` 應該包含 `name` 屬性，並且它應該是一個 `string`。
+
+```js
+assert(
+ (function (z) {
+ if (
+ z.hasOwnProperty('name') &&
+ z.name !== undefined &&
+ typeof z.name === 'string'
+ ) {
+ return true;
+ } else {
+ return false;
+ }
+ })(myDog)
+);
+```
+
+`myDog`應該包含 `legs` 屬性，並且它應該是一個 `number`。
+
+```js
+assert(
+ (function (z) {
+ if (
+ z.hasOwnProperty('legs') &&
+ z.legs !== undefined &&
+ typeof z.legs === 'number'
+ ) {
+ return true;
+ } else {
+ return false;
+ }
+ })(myDog)
+);
+```
+
+`myDog` 應該包含 `tails` 屬性，並且它應該是一個 `number`。
+
+```js
+assert(
+ (function (z) {
+ if (
+ z.hasOwnProperty('tails') &&
+ z.tails !== undefined &&
+ typeof z.tails === 'number'
+ ) {
+ return true;
+ } else {
+ return false;
+ }
+ })(myDog)
+);
+```
+
+`myDog` 應該包含 `friends` 屬性，並且它應該是一個 `array`。
+
+```js
+assert(
+ (function (z) {
+ if (
+ z.hasOwnProperty('friends') &&
+ z.friends !== undefined &&
+ Array.isArray(z.friends)
+ ) {
+ return true;
+ } else {
+ return false;
+ }
+ })(myDog)
+);
+```
+
+`myDog` 只應該包含所有給定的屬性。
+
+```js
+assert(
+ (function (z) {
+ return Object.keys(z).length === 4;
+ })(myDog)
+);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(z){return z;})(myDog);
+```
+
+## --seed-contents--
+
+```js
+var myDog = {
+// Only change code below this line
+
+
+// Only change code above this line
+};
+```
+
+# --solutions--
+
+```js
+var myDog = {
+ "name": "Camper",
+ "legs": 4,
+ "tails": 1,
+ "friends": ["everything!"]
+};
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/chaining-if-else-statements.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/chaining-if-else-statements.md
new file mode 100644
index 0000000000..3d646d0b33
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/chaining-if-else-statements.md
@@ -0,0 +1,149 @@
+---
+id: 56533eb9ac21ba0edf2244dc
+title: 多個 if else 語句
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/caeJgsw'
+forumTopicId: 16772
+dashedName: chaining-if-else-statements
+---
+
+# --description--
+
+`if/else` 語句串聯在一起可以實現複雜的邏輯。 這是多個 `if` / `else if` 語句串聯在一起的僞代碼 ：
+
+```js
+if (condition1) {
+ statement1
+} else if (condition2) {
+ statement2
+} else if (condition3) {
+ statement3
+. . .
+} else {
+ statementN
+}
+```
+
+# --instructions--
+
+請將 `if`/`else if` 語句串聯起來，實現下面的邏輯：
+
+`num < 5` - 返回 `Tiny`
+`num < 10` - 返回 `Small`
+`num < 15` - 返回 `Medium`
+`num < 20` - 返回 `Large`
+`num >= 20` - 返回 `Huge`
+
+# --hints--
+
+應至少有 4 個 `else` 語句。
+
+```js
+assert(code.match(/else/g).length > 3);
+```
+
+應至少有 4 個 `if` 語句。
+
+```js
+assert(code.match(/if/g).length > 3);
+```
+
+應至少有 1 個 `return` 語句。
+
+```js
+assert(code.match(/return/g).length >= 1);
+```
+
+`testSize(0)` 應該返回字符串 `Tiny`
+
+```js
+assert(testSize(0) === 'Tiny');
+```
+
+`testSize(4)` 應該返回字符串 `Tiny`
+
+```js
+assert(testSize(4) === 'Tiny');
+```
+
+`testSize(5)` 應該返回字符串 `Small`
+
+```js
+assert(testSize(5) === 'Small');
+```
+
+`testSize(8)` 應該返回字符串 `Small`
+
+```js
+assert(testSize(8) === 'Small');
+```
+
+`testSize(10)` 應該返回字符串 `Medium`
+
+```js
+assert(testSize(10) === 'Medium');
+```
+
+`testSize(14)` 應該返回字符串 `Medium`
+
+```js
+assert(testSize(14) === 'Medium');
+```
+
+`testSize(15)` 應該返回字符串 `Large`
+
+```js
+assert(testSize(15) === 'Large');
+```
+
+`testSize(17)` 應該返回字符串 `Large`
+
+```js
+assert(testSize(17) === 'Large');
+```
+
+`testSize(20)` 應該返回字符串 `Huge`
+
+```js
+assert(testSize(20) === 'Huge');
+```
+
+`testSize(25)` 應該返回字符串 `Huge`
+
+```js
+assert(testSize(25) === 'Huge');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function testSize(num) {
+ // Only change code below this line
+
+
+ return "Change Me";
+ // Only change code above this line
+}
+
+testSize(7);
+```
+
+# --solutions--
+
+```js
+function testSize(num) {
+ if (num < 5) {
+ return "Tiny";
+ } else if (num < 10) {
+ return "Small";
+ } else if (num < 15) {
+ return "Medium";
+ } else if (num < 20) {
+ return "Large";
+ } else {
+ return "Huge";
+ }
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/comment-your-javascript-code.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/comment-your-javascript-code.md
new file mode 100644
index 0000000000..61423f6698
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/comment-your-javascript-code.md
@@ -0,0 +1,63 @@
+---
+id: bd7123c9c441eddfaeb4bdef
+title: 給代碼添加註釋
+challengeType: 1
+removeComments: false
+videoUrl: 'https://scrimba.com/c/c7ynnTp'
+forumTopicId: 16783
+dashedName: comment-your-javascript-code
+---
+
+# --description--
+
+被註釋的代碼塊在 JavaScript 之中是不會執行的。 在代碼中寫註釋，是一個可以讓你自己和以後的其他人理解代碼作用的好方法。
+
+JavaScript有兩種寫註釋的方法。
+
+使用 `//` 註釋掉當前行的代碼。 這是一個行內註釋：
+
+```js
+// This is an in-line comment.
+```
+
+你也可以使用多行註釋來註釋你的代碼，使用 `/*` 開始， `*/` 結束. 這是一個多行註釋：
+
+```js
+/* This is a
+multi-line comment */
+```
+
+**最佳實踐**當你寫代碼的時候，你應該時不時的添加註釋來解釋你寫的代碼的作用。 適當的註釋能讓別人*和*你未來的自己更容易看懂代碼。
+
+# --instructions--
+
+嘗試創建這兩種類型的註釋。
+
+# --hints--
+
+創建一個 `//` 樣式的註釋，被註釋的文本至少要包含 5 個字符。
+
+```js
+assert(code.match(/(\/\/)...../g));
+```
+
+創建一個 `/* */` 樣式的註釋，被註釋的文本至少要包含 5 個字符。
+
+```js
+assert(code.match(/(\/\*)([^\/]{5,})(?=\*\/)/gm));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+
+```
+
+# --solutions--
+
+```js
+// Fake Comment
+/* Another Comment */
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-equality-operator.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-equality-operator.md
new file mode 100644
index 0000000000..1a4b2e96a8
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-equality-operator.md
@@ -0,0 +1,91 @@
+---
+id: 56533eb9ac21ba0edf2244d0
+title: 相等運算符
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cKyVMAL'
+forumTopicId: 16784
+dashedName: comparison-with-the-equality-operator
+---
+
+# --description--
+
+在 JavaScript 中，有很多 相互比較的操作 。 所有這些操作符都返回一個 `true` 或 `false` 值。
+
+最基本的運算符是相等運算符：`==`。 相等運算符比較兩個值，如果它們是相等，返回 `true`，如果它們不相等，返回 `false`。 值得注意的是相等運算符不同於賦值運算符（`=`），賦值運算符是把等號右邊的值賦給左邊的變量。
+
+```js
+function equalityTest(myVal) {
+ if (myVal == 10) {
+ return "Equal";
+ }
+ return "Not Equal";
+}
+```
+
+如果 `myVal` 等於 `10`，相等運算符會返回 `true`，因此大括號裏面的代碼會被執行，函數將返回 `Equal`。 否則，函數返回 `Not Equal`。 在 JavaScript 中，爲了讓兩個不同的數據類型 （例如 `numbers` 和 `strings`）的值可以作比較，它必須把一種類型轉換爲另一種類型。 這叫作 “類型強制轉換”。 轉換之後，可以像下面這樣來比較：
+
+```js
+1 == 1
+1 == 2
+1 == '1'
+"3" == 3
+```
+
+按順序，這些表達式會返回 `true`、`false`、`true`、`true`。
+
+# --instructions--
+
+把相等運算符添加到指定的行，這樣當 `val` 的值爲 `12` 的時候，函數會返回 `Equal`。
+
+# --hints--
+
+`testEqual(10)` 應該返回字符串 `Not Equal`
+
+```js
+assert(testEqual(10) === 'Not Equal');
+```
+
+`testEqual(12)` 應該返回字符串 `Equal`
+
+```js
+assert(testEqual(12) === 'Equal');
+```
+
+`testEqual("12")` 應該返回字符串 `Equal`
+
+```js
+assert(testEqual('12') === 'Equal');
+```
+
+應該使用 `==` 運算符。
+
+```js
+assert(code.match(/==/g) && !code.match(/===/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// Setup
+function testEqual(val) {
+ if (val) { // Change this line
+ return "Equal";
+ }
+ return "Not Equal";
+}
+
+testEqual(10);
+```
+
+# --solutions--
+
+```js
+function testEqual(val) {
+ if (val == 12) {
+ return "Equal";
+ }
+ return "Not Equal";
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-greater-than-operator.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-greater-than-operator.md
new file mode 100644
index 0000000000..c0a973e639
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-greater-than-operator.md
@@ -0,0 +1,113 @@
+---
+id: 56533eb9ac21ba0edf2244d4
+title: 大於運算符
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cp6GbH4'
+forumTopicId: 16786
+dashedName: comparison-with-the-greater-than-operator
+---
+
+# --description--
+
+使用大於運算符（`>`）來比較兩個數字。 如果大於運算符左邊的數字大於右邊的數字，將會返回 `true`。 否則，它返回 `false`。
+
+與相等運算符一樣，大於運算符在比較的時候，會轉換值的數據類型。
+
+**例如：**
+
+```js
+5 > 3
+7 > '3'
+2 > 3
+'1' > 9
+```
+
+按順序，這些表達式會返回 `true`、`true`、`false` 和 `false`。
+
+# --instructions--
+
+添加大於運算符到指定的行，使得返回的語句是有意義的。
+
+# --hints--
+
+`testGreaterThan(0)` 應該返回字符串 `10 or Under`。
+
+```js
+assert(testGreaterThan(0) === '10 or Under');
+```
+
+`testGreaterThan(10)` 應該返回字符串 `10 or Under`。
+
+```js
+assert(testGreaterThan(10) === '10 or Under');
+```
+
+`testGreaterThan(11)` 應該返回字符串 `Over 10`。
+
+```js
+assert(testGreaterThan(11) === 'Over 10');
+```
+
+`testGreaterThan(99)` 應該返回字符串 `Over 10`。
+
+```js
+assert(testGreaterThan(99) === 'Over 10');
+```
+
+`testGreaterThan(100)` 應該返回字符串 `Over 10`。
+
+```js
+assert(testGreaterThan(100) === 'Over 10');
+```
+
+`testGreaterThan(101)` 應該返回字符串 `Over 100`。
+
+```js
+assert(testGreaterThan(101) === 'Over 100');
+```
+
+`testGreaterThan(150)` 應該返回字符串 `Over 100`。
+
+```js
+assert(testGreaterThan(150) === 'Over 100');
+```
+
+應該使用 `>` 運算符至少兩次。
+
+```js
+assert(code.match(/val\s*>\s*('|")*\d+('|")*/g).length > 1);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function testGreaterThan(val) {
+ if (val) { // Change this line
+ return "Over 100";
+ }
+
+ if (val) { // Change this line
+ return "Over 10";
+ }
+
+ return "10 or Under";
+}
+
+testGreaterThan(10);
+```
+
+# --solutions--
+
+```js
+function testGreaterThan(val) {
+ if (val > 100) { // Change this line
+ return "Over 100";
+ }
+ if (val > 10) { // Change this line
+ return "Over 10";
+ }
+ return "10 or Under";
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-greater-than-or-equal-to-operator.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-greater-than-or-equal-to-operator.md
new file mode 100644
index 0000000000..6b7516dbfe
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-greater-than-or-equal-to-operator.md
@@ -0,0 +1,115 @@
+---
+id: 56533eb9ac21ba0edf2244d5
+title: 大於或等於運算符
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c6KBqtV'
+forumTopicId: 16785
+dashedName: comparison-with-the-greater-than-or-equal-to-operator
+---
+
+# --description--
+
+使用大於等於運算符（`>=`）來比較兩個數字的大小。 如果大於等於運算符左邊的數字比右邊的數字大或者相等，會返回 `true`。 否則，會返回 `false`。
+
+與相等運算符相似，大於等於運算符在比較的時候會轉換值的數據類型。
+
+**例如：**
+
+```js
+6 >= 6
+7 >= '3'
+2 >= 3
+'7' >= 9
+```
+
+按順序，這些表達式會返回 `true`、`true`、`false` 和 `false`。
+
+# --instructions--
+
+添加大於等於運算符到指定行，使得函數的返回語句有意義。
+
+# --hints--
+
+`testGreaterOrEqual(0)` 應該返回字符串 `Less than 10`。
+
+```js
+assert(testGreaterOrEqual(0) === 'Less than 10');
+```
+
+`testGreaterOrEqual(9)` 應該返回字符串 `Less than 10`。
+
+```js
+assert(testGreaterOrEqual(9) === 'Less than 10');
+```
+
+`testGreaterOrEqual(10)` 應該返回字符串 `10 or Over`。
+
+```js
+assert(testGreaterOrEqual(10) === '10 or Over');
+```
+
+`testGreaterOrEqual(11)` 應該返回字符串 `10 or Over`。
+
+```js
+assert(testGreaterOrEqual(11) === '10 or Over');
+```
+
+`testGreaterOrEqual(19)` 應該返回字符串 `10 or Over`。
+
+```js
+assert(testGreaterOrEqual(19) === '10 or Over');
+```
+
+`testGreaterOrEqual(100)` 應該返回字符串 `20 or Over`。
+
+```js
+assert(testGreaterOrEqual(100) === '20 or Over');
+```
+
+`testGreaterOrEqual(21)` 應該返回字符串 `20 or Over`。
+
+```js
+assert(testGreaterOrEqual(21) === '20 or Over');
+```
+
+應該使用 `>=` 運算符至少兩次。
+
+```js
+assert(code.match(/val\s*>=\s*('|")*\d+('|")*/g).length > 1);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function testGreaterOrEqual(val) {
+ if (val) { // Change this line
+ return "20 or Over";
+ }
+
+ if (val) { // Change this line
+ return "10 or Over";
+ }
+
+ return "Less than 10";
+}
+
+testGreaterOrEqual(10);
+```
+
+# --solutions--
+
+```js
+function testGreaterOrEqual(val) {
+ if (val >= 20) { // Change this line
+ return "20 or Over";
+ }
+
+ if (val >= 10) { // Change this line
+ return "10 or Over";
+ }
+
+ return "Less than 10";
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-inequality-operator.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-inequality-operator.md
new file mode 100644
index 0000000000..262e82c16f
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-inequality-operator.md
@@ -0,0 +1,93 @@
+---
+id: 56533eb9ac21ba0edf2244d2
+title: 不等運算符
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cdBm9Sr'
+forumTopicId: 16787
+dashedName: comparison-with-the-inequality-operator
+---
+
+# --description--
+
+不相等運算符（`!=`）與相等運算符是相反的。 這意味着嚴格不相等並返回 `false` 的地方，用嚴格相等運算符會返回 `true`，*反之亦然*。 與相等運算符類似，不相等運算符在比較的時候也會轉換值的數據類型。
+
+**例如**
+
+```js
+1 != 2
+1 != "1"
+1 != '1'
+1 != true
+0 != false
+```
+
+按順序，這些表達式會返回 `true`、`false`、`false`、`false` 和 `false`。
+
+# --instructions--
+
+在 `if` 語句中，添加不相等運算符 `!=`，這樣函數在當 `val` 不等於 `99` 的時候，會返回 `Not Equal`。
+
+# --hints--
+
+`testNotEqual(99)` 應該返回字符串 `Equal`
+
+```js
+assert(testNotEqual(99) === 'Equal');
+```
+
+`testNotEqual("99")` 應該返回字符串 `Equal`
+
+```js
+assert(testNotEqual('99') === 'Equal');
+```
+
+`testNotEqual(12)` 應該返回字符串 `Not Equal`
+
+```js
+assert(testNotEqual(12) === 'Not Equal');
+```
+
+`testNotEqual("12")` 應該返回字符串 `Not Equal`
+
+```js
+assert(testNotEqual('12') === 'Not Equal');
+```
+
+`testNotEqual("bob")` 應該返回字符串 `Not Equal`
+
+```js
+assert(testNotEqual('bob') === 'Not Equal');
+```
+
+你應該使用 `!=` 運算符。
+
+```js
+assert(code.match(/(?!!==)!=/));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// Setup
+function testNotEqual(val) {
+ if (val) { // Change this line
+ return "Not Equal";
+ }
+ return "Equal";
+}
+
+testNotEqual(10);
+```
+
+# --solutions--
+
+```js
+function testNotEqual(val) {
+ if (val != 99) {
+ return "Not Equal";
+ }
+ return "Equal";
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-less-than-operator.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-less-than-operator.md
new file mode 100644
index 0000000000..894ffb329d
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-less-than-operator.md
@@ -0,0 +1,108 @@
+---
+id: 56533eb9ac21ba0edf2244d6
+title: 小於運算符
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cNVRWtB'
+forumTopicId: 16789
+dashedName: comparison-with-the-less-than-operator
+---
+
+# --description--
+
+使用小於運算符（`<`）來比較兩個數字。 如果小於運算符左邊的數字比右邊的數字小，它會返回 `true`。 否則會返回 `false`。 與相等運算符類似，小於運算符在做比較的時候會轉換值的數據類型。
+
+**例如：**
+
+```js
+2 < 5
+'3' < 7
+5 < 5
+3 < 2
+'8' < 4
+```
+
+按順序，這些表達式會返回 `true`、`true`、`false`、`false` 和 `false`。
+
+# --instructions--
+
+添加小於運算符到指定行，使得函數的返回語句有意義。
+
+# --hints--
+
+`testLessThan(0)` 應該返回字符串 `Under 25`。
+
+```js
+assert(testLessThan(0) === 'Under 25');
+```
+
+`testLessThan(24)` 應該返回字符串 `Under 25`。
+
+```js
+assert(testLessThan(24) === 'Under 25');
+```
+
+`testLessThan(25)` 應該返回字符串 `Under 55`。
+
+```js
+assert(testLessThan(25) === 'Under 55');
+```
+
+`testLessThan(54)` 應該返回字符串 `Under 55`。
+
+```js
+assert(testLessThan(54) === 'Under 55');
+```
+
+`testLessThan(55)` 應該返回字符串 `55 or Over`。
+
+```js
+assert(testLessThan(55) === '55 or Over');
+```
+
+`testLessThan(99)` 應該返回字符串 `55 or Over`。
+
+```js
+assert(testLessThan(99) === '55 or Over');
+```
+
+應該使用 `<` 運算符至少兩次。
+
+```js
+assert(code.match(/val\s*<\s*('|")*\d+('|")*/g).length > 1);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function testLessThan(val) {
+ if (val) { // Change this line
+ return "Under 25";
+ }
+
+ if (val) { // Change this line
+ return "Under 55";
+ }
+
+ return "55 or Over";
+}
+
+testLessThan(10);
+```
+
+# --solutions--
+
+```js
+function testLessThan(val) {
+ if (val < 25) { // Change this line
+ return "Under 25";
+ }
+
+ if (val < 55) { // Change this line
+ return "Under 55";
+ }
+
+ return "55 or Over";
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-less-than-or-equal-to-operator.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-less-than-or-equal-to-operator.md
new file mode 100644
index 0000000000..02a099677b
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-less-than-or-equal-to-operator.md
@@ -0,0 +1,114 @@
+---
+id: 56533eb9ac21ba0edf2244d7
+title: 小於或等於運算符
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cNVR7Am'
+forumTopicId: 16788
+dashedName: comparison-with-the-less-than-or-equal-to-operator
+---
+
+# --description--
+
+使用小於等於運算符（`<=`）比較兩個數字的大小。 如果在小於等於運算符左邊的數字小於或者等於右邊的數字，它會返回 `true`。 如果在小於等於運算符左邊的數字大於右邊的數字，它會返回 `false`。 與相等運算符類似，小於或等於運算符會轉換數據類型。
+
+**例如**
+
+```js
+4 <= 5
+'7' <= 7
+5 <= 5
+3 <= 2
+'8' <= 4
+```
+
+按順序，這些表達式會返回 `true`、`true`、`true`、`false` 和 `false`。
+
+# --instructions--
+
+添加小於等於運算符到指定行，使得函數的返回語句有意義。
+
+# --hints--
+
+`testLessOrEqual(0)` 應該返回 `Smaller Than or Equal to 12`
+
+```js
+assert(testLessOrEqual(0) === 'Smaller Than or Equal to 12');
+```
+
+`testLessOrEqual(11)` 應該返回 `Smaller Than or Equal to 12`
+
+```js
+assert(testLessOrEqual(11) === 'Smaller Than or Equal to 12');
+```
+
+`testLessOrEqual(12)` 應該返回 `Smaller Than or Equal to 12`
+
+```js
+assert(testLessOrEqual(12) === 'Smaller Than or Equal to 12');
+```
+
+`testLessOrEqual(23)` 應該返回 `Smaller Than or Equal to 24`
+
+```js
+assert(testLessOrEqual(23) === 'Smaller Than or Equal to 24');
+```
+
+`testLessOrEqual(24)` 應該返回 `Smaller Than or Equal to 24`
+
+```js
+assert(testLessOrEqual(24) === 'Smaller Than or Equal to 24');
+```
+
+`testLessOrEqual(25)` 應該返回 `More Than 24`
+
+```js
+assert(testLessOrEqual(25) === 'More Than 24');
+```
+
+`testLessOrEqual(55)` 應該返回 `More Than 24`
+
+```js
+assert(testLessOrEqual(55) === 'More Than 24');
+```
+
+應該使用 `<=` 運算符至少兩次
+
+```js
+assert(code.match(/val\s*<=\s*('|")*\d+('|")*/g).length > 1);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function testLessOrEqual(val) {
+ if (val) { // Change this line
+ return "Smaller Than or Equal to 12";
+ }
+
+ if (val) { // Change this line
+ return "Smaller Than or Equal to 24";
+ }
+
+ return "More Than 24";
+}
+
+testLessOrEqual(10);
+```
+
+# --solutions--
+
+```js
+function testLessOrEqual(val) {
+ if (val <= 12) { // Change this line
+ return "Smaller Than or Equal to 12";
+ }
+
+ if (val <= 24) { // Change this line
+ return "Smaller Than or Equal to 24";
+ }
+
+ return "More Than 24";
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-strict-equality-operator.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-strict-equality-operator.md
new file mode 100644
index 0000000000..7b41d61ce3
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-strict-equality-operator.md
@@ -0,0 +1,82 @@
+---
+id: 56533eb9ac21ba0edf2244d1
+title: 嚴格相等運算符
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cy87atr'
+forumTopicId: 16790
+dashedName: comparison-with-the-strict-equality-operator
+---
+
+# --description--
+
+嚴格相等運算符（`===`）是相對相等操作符（`==`）的另一種比較操作符。 與相等操作符轉換數據兩類型不同，嚴格相等運算符不會做類型轉換。
+
+如果比較的值類型不同，那麼在嚴格相等運算符比較下它們是不相等的，會返回 false 。
+
+**示例**
+
+```js
+3 === 3
+3 === '3'
+```
+
+這些條件將分別返回 `true` and `false`。
+
+在第二個例子中，`3` 是一個 `Number` 類型，而 `'3'` 是一個 `String` 類型。
+
+# --instructions--
+
+在 `if` 語句中，添加不相等運算符，這樣函數在當 `val` 嚴格等於 `7` 的時候，會返回 `Equal`。
+
+# --hints--
+
+`testStrict(10)` 應該返回字符串 `Not Equal`
+
+```js
+assert(testStrict(10) === 'Not Equal');
+```
+
+`testStrict(7)` 應該返回字符串 `Equal`
+
+```js
+assert(testStrict(7) === 'Equal');
+```
+
+`testStrict("7")` 應該返回字符串 `Not Equal`
+
+```js
+assert(testStrict('7') === 'Not Equal');
+```
+
+你應該使用 `===` 運算符。
+
+```js
+assert(code.match(/(val\s*===\s*\d+)|(\d+\s*===\s*val)/g).length > 0);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// Setup
+function testStrict(val) {
+ if (val) { // Change this line
+ return "Equal";
+ }
+ return "Not Equal";
+}
+
+testStrict(10);
+```
+
+# --solutions--
+
+```js
+function testStrict(val) {
+ if (val === 7) {
+ return "Equal";
+ }
+ return "Not Equal";
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-strict-inequality-operator.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-strict-inequality-operator.md
new file mode 100644
index 0000000000..89487b9757
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-strict-inequality-operator.md
@@ -0,0 +1,85 @@
+---
+id: 56533eb9ac21ba0edf2244d3
+title: 嚴格不等運算符
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cKekkUy'
+forumTopicId: 16791
+dashedName: comparison-with-the-strict-inequality-operator
+---
+
+# --description--
+
+嚴格不相等運算符（`!==`）與全等運算符是相反的。 這意味着嚴格不相等並返回 `false` 的地方，用嚴格相等運算符會返回 `true`，*反之亦然*。 嚴格不相等運算符不會轉換值的數據類型。
+
+**示例**
+
+```js
+3 !== 3
+3 !== '3'
+4 !== 3
+```
+
+按順序，這些表達式會返回 `false`、`true`、`true`。
+
+# --instructions--
+
+在 `if` 語句中，添加嚴格不相等運算符，這樣函數在當 `val` 不嚴格等於 `17` 的時候，會返回 `Not Equal`。
+
+# --hints--
+
+`testStrictNotEqual(17)` 應該返回字符串 `Equal`
+
+```js
+assert(testStrictNotEqual(17) === 'Equal');
+```
+
+`testStrictNotEqual("17")` 應該返回字符串 `Not Equal`
+
+```js
+assert(testStrictNotEqual('17') === 'Not Equal');
+```
+
+`testStrictNotEqual(12)` 應該返回字符串 `Not Equal`
+
+```js
+assert(testStrictNotEqual(12) === 'Not Equal');
+```
+
+`testStrictNotEqual("bob")` 應該返回字符串 `Not Equal`
+
+```js
+assert(testStrictNotEqual('bob') === 'Not Equal');
+```
+
+應該使用 `!==` 運算符。
+
+```js
+assert(code.match(/(val\s*!==\s*\d+)|(\d+\s*!==\s*val)/g).length > 0);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// Setup
+function testStrictNotEqual(val) {
+ if (val) { // Change this line
+ return "Not Equal";
+ }
+ return "Equal";
+}
+
+testStrictNotEqual(10);
+```
+
+# --solutions--
+
+```js
+function testStrictNotEqual(val) {
+ if (val !== 17) {
+ return "Not Equal";
+ }
+ return "Equal";
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/comparisons-with-the-logical-and-operator.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/comparisons-with-the-logical-and-operator.md
new file mode 100644
index 0000000000..b111f3c631
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/comparisons-with-the-logical-and-operator.md
@@ -0,0 +1,130 @@
+---
+id: 56533eb9ac21ba0edf2244d8
+title: 邏輯與運算符
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cvbRVtr'
+forumTopicId: 16799
+dashedName: comparisons-with-the-logical-and-operator
+---
+
+# --description--
+
+有時你需要在一次判斷中做多個操作。 當且僅當運算符 的左邊和右邊都是 true，邏輯與 運算符（`&&`）纔會返回`true`。
+
+同樣的效果可以通過 if 語句的嵌套來實現：
+
+```js
+if (num > 5) {
+ if (num < 10) {
+ return "Yes";
+ }
+}
+return "No";
+```
+
+只有當 `num` 的值大於 `5` 並且小於`10` 時纔會返回 `Yes`。 相同的邏輯可被寫爲：
+
+```js
+if (num > 5 && num < 10) {
+ return "Yes";
+}
+return "No";
+```
+
+# --instructions--
+
+請使用 `&&` 運算符把兩個 if 語句合併爲一個 if 語句，如果 `val` 小於或等於`50` 並且大於或等於 `25` 時，返回 `Yes`。 否則，將返回`No`。
+
+# --hints--
+
+你應該使用 `&&` 運算符一次。
+
+```js
+assert(code.match(/&&/g).length === 1);
+```
+
+你應該只有一個 `if` 表達式。
+
+```js
+assert(code.match(/if/g).length === 1);
+```
+
+`testLogicalAnd(0)` 應該返回字符串 `No`
+
+```js
+assert(testLogicalAnd(0) === 'No');
+```
+
+`testLogicalAnd(24)` 應該返回字符串 `No`
+
+```js
+assert(testLogicalAnd(24) === 'No');
+```
+
+`testLogicalAnd(25)` 應該返回字符串 `Yes`
+
+```js
+assert(testLogicalAnd(25) === 'Yes');
+```
+
+`testLogicalAnd(30)` 應該返回字符串 `Yes`
+
+```js
+assert(testLogicalAnd(30) === 'Yes');
+```
+
+`testLogicalAnd(50)` 應該返回字符串 `Yes`
+
+```js
+assert(testLogicalAnd(50) === 'Yes');
+```
+
+`testLogicalAnd(51)` 應該返回字符串 `No`
+
+```js
+assert(testLogicalAnd(51) === 'No');
+```
+
+`testLogicalAnd(75)` 應該返回字符串 `No`
+
+```js
+assert(testLogicalAnd(75) === 'No');
+```
+
+`testLogicalAnd(80)` 應該返回字符串 `No`
+
+```js
+assert(testLogicalAnd(80) === 'No');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function testLogicalAnd(val) {
+ // Only change code below this line
+
+ if (val) {
+ if (val) {
+ return "Yes";
+ }
+ }
+
+ // Only change code above this line
+ return "No";
+}
+
+testLogicalAnd(10);
+```
+
+# --solutions--
+
+```js
+function testLogicalAnd(val) {
+ if (val >= 25 && val <= 50) {
+ return "Yes";
+ }
+ return "No";
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/comparisons-with-the-logical-or-operator.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/comparisons-with-the-logical-or-operator.md
new file mode 100644
index 0000000000..811357c74c
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/comparisons-with-the-logical-or-operator.md
@@ -0,0 +1,135 @@
+---
+id: 56533eb9ac21ba0edf2244d9
+title: 邏輯或運算符
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cEPrGTN'
+forumTopicId: 16800
+dashedName: comparisons-with-the-logical-or-operator
+---
+
+# --description--
+
+只要邏輯或 運算符（`||`）兩邊的任何一個運算 的結果是 `true`，則返回 `true`。 否則，返回 `false`。
+
+邏輯或 運算符由兩個豎線（`||`）組成。 這個按鍵位於退格鍵和回車鍵之間。
+
+下面這樣的語句你應該很熟悉：
+
+```js
+if (num > 10) {
+ return "No";
+}
+if (num < 5) {
+ return "No";
+}
+return "Yes";
+```
+
+只有當 `num` 大於等於 `5` 或小於等於 `10` 時，函數才返回 `Yes`。 相同的邏輯可以簡寫成：
+
+```js
+if (num > 10 || num < 5) {
+ return "No";
+}
+return "Yes";
+```
+
+# --instructions--
+
+請使用邏輯或運算符把兩個 `if` 語句合併爲一個語句，如果 `val` 不在 `10` 和 `20` 之間（包括 10 和 20），返回 `Outside`。 否則，返回 `Inside`。
+
+# --hints--
+
+應該使用一次 `||` 操作符。
+
+```js
+assert(code.match(/\|\|/g).length === 1);
+```
+
+應該只有一個 `if` 表達式。
+
+```js
+assert(code.match(/if/g).length === 1);
+```
+
+`testLogicalOr(0)` 應該返回字符串 `Outside`
+
+```js
+assert(testLogicalOr(0) === 'Outside');
+```
+
+`testLogicalOr(9)` 應該返回字符串 `Outside`
+
+```js
+assert(testLogicalOr(9) === 'Outside');
+```
+
+`testLogicalOr(10)` 應該返回字符串 `Inside`
+
+```js
+assert(testLogicalOr(10) === 'Inside');
+```
+
+`testLogicalOr(15)` 應該返回字符串 `Inside`
+
+```js
+assert(testLogicalOr(15) === 'Inside');
+```
+
+`testLogicalOr(19)` 應該返回字符串 `Inside`
+
+```js
+assert(testLogicalOr(19) === 'Inside');
+```
+
+`testLogicalOr(20)` 應該返回字符串 `Inside`
+
+```js
+assert(testLogicalOr(20) === 'Inside');
+```
+
+`testLogicalOr(21)` 應該返回字符串 `Outside`
+
+```js
+assert(testLogicalOr(21) === 'Outside');
+```
+
+`testLogicalOr(25)` 應該返回字符串 `Outside`
+
+```js
+assert(testLogicalOr(25) === 'Outside');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function testLogicalOr(val) {
+ // Only change code below this line
+
+ if (val) {
+ return "Outside";
+ }
+
+ if (val) {
+ return "Outside";
+ }
+
+ // Only change code above this line
+ return "Inside";
+}
+
+testLogicalOr(15);
+```
+
+# --solutions--
+
+```js
+function testLogicalOr(val) {
+ if (val < 10 || val > 20) {
+ return "Outside";
+ }
+ return "Inside";
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/compound-assignment-with-augmented-addition.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/compound-assignment-with-augmented-addition.md
new file mode 100644
index 0000000000..c571ebc638
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/compound-assignment-with-augmented-addition.md
@@ -0,0 +1,101 @@
+---
+id: 56533eb9ac21ba0edf2244af
+title: 複合賦值之 +=
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cDR6LCb'
+forumTopicId: 16661
+dashedName: compound-assignment-with-augmented-addition
+---
+
+# --description--
+
+在編程中，通常通過賦值來修改變量的內容。 記住，賦值時 JavaScript 會先計算等號右邊的內容，所以我們可以寫這樣的語句：
+
+```js
+myVar = myVar + 5;
+```
+
+給 `myVar` 加上 `5`。 這是最常見的運算賦值語句，即先運算、再賦值。還有一類操作符是一步到位，既做運算也賦值的。
+
+其中一種就是 `+=` 運算符。
+
+```js
+var myVar = 1;
+myVar += 5;
+console.log(myVar);
+```
+
+控制檯將會顯示 `6`。
+
+# --instructions--
+
+使用 `+=` 操作符對 `a`、`b` 和 `c` 賦值。
+
+# --hints--
+
+`a` 應該等於 `15`。
+
+```js
+assert(a === 15);
+```
+
+`b` 應該等於 `26`。
+
+```js
+assert(b === 26);
+```
+
+`c` 應該等於 `19`。
+
+```js
+assert(c === 19);
+```
+
+應該對每個變量使用 `+=` 操作符。
+
+```js
+assert(code.match(/\+=/g).length === 3);
+```
+
+不要修改註釋上面的代碼。
+
+```js
+assert(
+ /var a = 3;/.test(code) &&
+ /var b = 17;/.test(code) &&
+ /var c = 12;/.test(code)
+);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(a,b,c){ return "a = " + a + ", b = " + b + ", c = " + c; })(a,b,c);
+```
+
+## --seed-contents--
+
+```js
+var a = 3;
+var b = 17;
+var c = 12;
+
+// Only change code below this line
+a = a + 12;
+b = 9 + b;
+c = c + 7;
+```
+
+# --solutions--
+
+```js
+var a = 3;
+var b = 17;
+var c = 12;
+
+a += 12;
+b += 9;
+c += 7;
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/compound-assignment-with-augmented-division.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/compound-assignment-with-augmented-division.md
new file mode 100644
index 0000000000..ce826e7084
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/compound-assignment-with-augmented-division.md
@@ -0,0 +1,95 @@
+---
+id: 56533eb9ac21ba0edf2244b2
+title: 複合賦值之 /=
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c2QvKT2'
+forumTopicId: 16659
+dashedName: compound-assignment-with-augmented-division
+---
+
+# --description--
+
+`/=` 操作符是讓變量與另一個數相除並賦值。
+
+```js
+myVar = myVar / 5;
+```
+
+將 `myVar` 除以 `5`。 等價於：
+
+```js
+myVar /= 5;
+```
+
+# --instructions--
+
+使用 `/=` 操作符對 `a`，`b` 和 `c` 實現相除賦值操作。
+
+# --hints--
+
+`a` 應該等於 `4`。
+
+```js
+assert(a === 4);
+```
+
+`b` 應該等於 `27`。
+
+```js
+assert(b === 27);
+```
+
+`c` 應該等於`3`。
+
+```js
+assert(c === 3);
+```
+
+應該對每個變量使用 `/=` 操作符。
+
+```js
+assert(code.match(/\/=/g).length === 3);
+```
+
+不要修改註釋上面的代碼。
+
+```js
+assert(
+ /var a = 48;/.test(code) &&
+ /var b = 108;/.test(code) &&
+ /var c = 33;/.test(code)
+);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(a,b,c){ return "a = " + a + ", b = " + b + ", c = " + c; })(a,b,c);
+```
+
+## --seed-contents--
+
+```js
+var a = 48;
+var b = 108;
+var c = 33;
+
+// Only change code below this line
+a = a / 12;
+b = b / 4;
+c = c / 11;
+```
+
+# --solutions--
+
+```js
+var a = 48;
+var b = 108;
+var c = 33;
+
+a /= 12;
+b /= 4;
+c /= 11;
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/compound-assignment-with-augmented-multiplication.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/compound-assignment-with-augmented-multiplication.md
new file mode 100644
index 0000000000..d416d51a24
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/compound-assignment-with-augmented-multiplication.md
@@ -0,0 +1,95 @@
+---
+id: 56533eb9ac21ba0edf2244b1
+title: 複合賦值之 *=
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c83vrfa'
+forumTopicId: 16662
+dashedName: compound-assignment-with-augmented-multiplication
+---
+
+# --description--
+
+`*=` 操作符是讓變量與一個數相乘並賦值。
+
+```js
+myVar = myVar * 5;
+```
+
+將 `myVar` 乘以 `5`。 等價於：
+
+```js
+myVar *= 5;
+```
+
+# --instructions--
+
+使用 `*=` 操作符對 `a`、`b` 和 `c` 實現賦值相乘操作。
+
+# --hints--
+
+`a` 應該等於`25`。
+
+```js
+assert(a === 25);
+```
+
+`b` 應該等於`36`。
+
+```js
+assert(b === 36);
+```
+
+`c` 應該等於`46`。
+
+```js
+assert(c === 46);
+```
+
+應該對每個變量使用 `*=` 操作符。
+
+```js
+assert(code.match(/\*=/g).length === 3);
+```
+
+不要修改註釋上面的代碼。
+
+```js
+assert(
+ /var a = 5;/.test(code) &&
+ /var b = 12;/.test(code) &&
+ /var c = 4\.6;/.test(code)
+);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(a,b,c){ return "a = " + a + ", b = " + b + ", c = " + c; })(a,b,c);
+```
+
+## --seed-contents--
+
+```js
+var a = 5;
+var b = 12;
+var c = 4.6;
+
+// Only change code below this line
+a = a * 5;
+b = 3 * b;
+c = c * 10;
+```
+
+# --solutions--
+
+```js
+var a = 5;
+var b = 12;
+var c = 4.6;
+
+a *= 5;
+b *= 3;
+c *= 10;
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/compound-assignment-with-augmented-subtraction.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/compound-assignment-with-augmented-subtraction.md
new file mode 100644
index 0000000000..0f5b4749ae
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/compound-assignment-with-augmented-subtraction.md
@@ -0,0 +1,93 @@
+---
+id: 56533eb9ac21ba0edf2244b0
+title: 複合賦值之 -=
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c2Qv7AV'
+forumTopicId: 16660
+dashedName: compound-assignment-with-augmented-subtraction
+---
+
+# --description--
+
+與 `+=` 操作符類似，`-=` 操作符用來對一個變量進行減法賦值操作。
+
+```js
+myVar = myVar - 5;
+```
+
+將從 `myVar` 中減去 `5`。 等價於：
+
+```js
+myVar -= 5;
+```
+
+# --instructions--
+
+使用 `-=` 操作符對 `a`、`b` 和 `c` 實現相減賦值操作。
+
+# --hints--
+
+`a` 應該等於 `5`。
+
+```js
+assert(a === 5);
+```
+
+`b` 應該等於 `-6`。
+
+```js
+assert(b === -6);
+```
+
+`c` 應該等於 `2`。
+
+```js
+assert(c === 2);
+```
+
+應該對每個變量使用 `-=` 操作符。
+
+```js
+assert(code.match(/-=/g).length === 3);
+```
+
+不要修改註釋上面的代碼。
+
+```js
+assert(
+ /var a = 11;/.test(code) && /var b = 9;/.test(code) && /var c = 3;/.test(code)
+);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(a,b,c){ return "a = " + a + ", b = " + b + ", c = " + c; })(a,b,c);
+```
+
+## --seed-contents--
+
+```js
+var a = 11;
+var b = 9;
+var c = 3;
+
+// Only change code below this line
+a = a - 6;
+b = b - 15;
+c = c - 1;
+```
+
+# --solutions--
+
+```js
+var a = 11;
+var b = 9;
+var c = 3;
+
+a -= 6;
+b -= 15;
+c -= 1;
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/concatenating-strings-with-plus-operator.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/concatenating-strings-with-plus-operator.md
new file mode 100644
index 0000000000..4b9c23295c
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/concatenating-strings-with-plus-operator.md
@@ -0,0 +1,83 @@
+---
+id: 56533eb9ac21ba0edf2244b7
+title: 用加號運算符連接字符串
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cNpM8AN'
+forumTopicId: 16802
+dashedName: concatenating-strings-with-plus-operator
+---
+
+# --description--
+
+在 JavaScript 中，當 `+` 操作符被用於一個 `String` 類型的值的時候，它被稱作拼接 操作符。 你可以通過拼接 其他字符串來創建一個新的字符串。
+
+**例如：**
+
+```js
+'My name is Alan,' + ' I concatenate.'
+```
+
+**提示：**注意空格。 拼接操作不會在兩個字符串之間添加空格。所以，如果想加上空格的話，你需要自己在字符串裏面添加。
+
+例如：
+
+```js
+var ourStr = "I come first. " + "I come second.";
+```
+
+字符串 `I come first. I come second.` 將顯示在控制檯中。
+# --instructions--
+
+使用 `+` 操作符連接字符串`This is the start.` 和 `This is the end.` 賦值給 `myStr` 。
+
+# --hints--
+
+`myStr` 的值應該是 `This is the start. This is the end.`
+
+```js
+assert(myStr === 'This is the start. This is the end.');
+```
+
+應使用 `+` 操作符創建 `myStr`。
+
+```js
+assert(code.match(/(["']).*\1\s*\+\s*(["']).*\2/g));
+```
+
+應使用 `var` 關鍵字創建 `myStr`。
+
+```js
+assert(/var\s+myStr/.test(code));
+```
+
+應把結果賦值給 `myStr` 變量。
+
+```js
+assert(/myStr\s*=/.test(code));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(){
+ if(typeof myStr === 'string') {
+ return 'myStr = "' + myStr + '"';
+ } else {
+ return 'myStr is not a string';
+ }
+})();
+```
+
+## --seed-contents--
+
+```js
+var myStr; // Change this line
+```
+
+# --solutions--
+
+```js
+var myStr = "This is the start. " + "This is the end.";
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/concatenating-strings-with-the-plus-equals-operator.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/concatenating-strings-with-the-plus-equals-operator.md
new file mode 100644
index 0000000000..23425c1f8c
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/concatenating-strings-with-the-plus-equals-operator.md
@@ -0,0 +1,70 @@
+---
+id: 56533eb9ac21ba0edf2244b8
+title: 用 += 運算符連接字符串
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cbQmmC4'
+forumTopicId: 16803
+dashedName: concatenating-strings-with-the-plus-equals-operator
+---
+
+# --description--
+
+我們還可以使用 `+=` 運算符來拼接 字符串到現有字符串變量的結尾。 對於那些被分割成幾段的長的字符串來說，這一操作是非常有用的。
+
+**提示：**注意空格。 拼接操作不會在兩個字符串之間添加空格，所以，如果想要加上空格的話，你需要自己在字符串裏面添加。
+
+例如：
+
+```js
+var ourStr = "I come first. ";
+ourStr += "I come second.";
+```
+
+`ourStr` 現在內容爲字符串 `I come first. I come second.`
+
+# --instructions--
+
+使用 `+=` 操作符，多行合併字符串 `This is the first sentence.` 和 `This is the second sentence.` ，並賦值給 `myStr` 。 像編輯器裏顯示的那樣使用 `+=` 操作符。 先把第一個字符串賦值給 `myStr`，然後拼接第二個字符串。
+
+# --hints--
+
+`myStr` 的值應該是 `This is the first sentence. This is the second sentence.`
+
+```js
+assert(myStr === 'This is the first sentence. This is the second sentence.');
+```
+
+應該使用 `+=` 操作符創建 `myStr` 變量。
+
+```js
+assert(code.match(/myStr\s*\+=\s*(["']).*\1/g));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(){
+ if(typeof myStr === 'string') {
+ return 'myStr = "' + myStr + '"';
+ } else {
+ return 'myStr is not a string';
+ }
+})();
+```
+
+## --seed-contents--
+
+```js
+// Only change code below this line
+
+var myStr;
+```
+
+# --solutions--
+
+```js
+var myStr = "This is the first sentence. ";
+myStr += "This is the second sentence.";
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/constructing-strings-with-variables.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/constructing-strings-with-variables.md
new file mode 100644
index 0000000000..496537114d
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/constructing-strings-with-variables.md
@@ -0,0 +1,75 @@
+---
+id: 56533eb9ac21ba0edf2244b9
+title: 用變量構造字符串
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cqk8rf4'
+forumTopicId: 16805
+dashedName: constructing-strings-with-variables
+---
+
+# --description--
+
+有時候你需要創建一個類似 [Mad Libs](https://en.wikipedia.org/wiki/Mad_Libs)（填詞遊戲）風格的字符串。 通過使用連接運算符（`+`），你可以插入一個或多個變量來組成一個字符串。
+
+例如：
+
+```js
+var ourName = "freeCodeCamp";
+var ourStr = "Hello, our name is " + ourName + ", how are you?";
+```
+
+`ourStr` 值爲 `Hello, our name is freeCodeCamp, how are you?`
+
+# --instructions--
+
+把你的名字賦值給變量 `myName`，然後把變量 `myName` 插入到字符串 `My name is` 和 `and I am well!` 之間，並把連接後的結果賦值給變量 `myStr`。
+
+# --hints--
+
+`myName` 應該是一個至少有 3 個字符的字符串。
+
+```js
+assert(typeof myName !== 'undefined' && myName.length > 2);
+```
+
+使用兩個 `+` 操作符創建包含 `myName` 的 `myStr` 變量。
+
+```js
+assert(code.match(/["']\s*\+\s*myName\s*\+\s*["']/g).length > 0);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(){
+ var output = [];
+ if(typeof myName === 'string') {
+ output.push('myName = "' + myName + '"');
+ } else {
+ output.push('myName is not a string');
+ }
+ if(typeof myStr === 'string') {
+ output.push('myStr = "' + myStr + '"');
+ } else {
+ output.push('myStr is not a string');
+ }
+ return output.join('\n');
+})();
+```
+
+## --seed-contents--
+
+```js
+// Only change code below this line
+var myName;
+var myStr;
+```
+
+# --solutions--
+
+```js
+var myName = "Bob";
+var myStr = "My name is " + myName + " and I am well!";
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/count-backwards-with-a-for-loop.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/count-backwards-with-a-for-loop.md
new file mode 100644
index 0000000000..0159ea1318
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/count-backwards-with-a-for-loop.md
@@ -0,0 +1,75 @@
+---
+id: 56105e7b514f539506016a5e
+title: 使用 For 循環反向遍歷數組
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c2R6BHa'
+forumTopicId: 16808
+dashedName: count-backwards-with-a-for-loop
+---
+
+# --description--
+
+只要我們定義好合適的條件，for 循環也可以反向遍歷。
+
+爲了讓每次遞減 2，我們需要改變 initialization、condition 和 final-expression。
+
+設置 `i = 10`，並且當 `i > 0` 的時候才繼續循環。 我們使用 `i -= 2` 來讓 `i` 每次循環遞減 2。
+
+```js
+var ourArray = [];
+for (var i = 10; i > 0; i -= 2) {
+ ourArray.push(i);
+}
+```
+
+循環結束後，`ourArray` 的值爲 `[10,8,6,4,2]`。 讓我們改變初始值和最後的表達式，這樣我們就可以按照奇數從後往前兩兩倒着數。
+
+# --instructions--
+
+使用一個 `for`循環，把從 9 到 1 的奇數添加到 `myArray`。
+
+# --hints--
+
+應該使用 `for` 循環。
+
+```js
+assert(/for\s*\([^)]+?\)/.test(code));
+```
+
+應該使用數組方法 `push`。
+
+```js
+assert(code.match(/myArray.push/));
+```
+
+`myArray` 應該等於 `[9,7,5,3,1]`。
+
+```js
+assert.deepEqual(myArray, [9, 7, 5, 3, 1]);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+if(typeof myArray !== "undefined"){(function(){return myArray;})();}
+```
+
+## --seed-contents--
+
+```js
+// Setup
+var myArray = [];
+
+// Only change code below this line
+```
+
+# --solutions--
+
+```js
+var myArray = [];
+for (var i = 9; i > 0; i -= 2) {
+ myArray.push(i);
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/counting-cards.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/counting-cards.md
new file mode 100644
index 0000000000..5a75fe2de2
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/counting-cards.md
@@ -0,0 +1,201 @@
+---
+id: 565bbe00e9cc8ac0725390f4
+title: 21 點遊戲
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c6KE7ty'
+forumTopicId: 16809
+dashedName: counting-cards
+---
+
+# --description--
+
+在賭場 21 點遊戲中，玩家可以通過計算牌桌上已經發放的卡牌的高低值來讓自己在遊戲中保持優勢。 這就叫 [21 點算法](https://en.wikipedia.org/wiki/Card_counting)。
+
+牌桌上的大值的卡牌更多，對玩家有利。 根據下面的表格，每張卡牌都被分配了一個值。 如果卡牌的值大於 0，那麼玩家應該追加賭注。 如果卡牌的值爲 0 或負數，玩家應該追加少許賭注甚至不追加賭注。
+
+計數 卡牌 +1 2, 3, 4, 5, 6 0 7, 8, 9 -1 10, 'J', 'Q', 'K', 'A'
+
+請寫一個函數實現 21 點算法。 它根據參數 `card` 的值（見表格，可能是數字或者字符串）來遞增或遞減全局變量 `count`。 然後函數返回一個由當前 count（計數）和 `Bet`（當 count > 0 時）或 `Hold`（當 count <= 0 時) 拼接的字符串。 注意 count（計數）和玩家的決定（`Bet` 或 `Hold`）之間應該有空格。
+
+**示例輸出：**`-3 Hold` 或者 `5 Bet`
+
+**提示：**
+當卡牌爲 7、8、9 時，不要把 `count` 值重置爲 0。 不要返回一個數組。
+輸出結果中不要包含單引號或雙引號。
+
+# --hints--
+
+卡牌序列 2、3、4、5、6 應該返回 `5 Bet`
+
+```js
+assert(
+ (function () {
+ count = 0;
+ cc(2);
+ cc(3);
+ cc(4);
+ cc(5);
+ var out = cc(6);
+ if (out === '5 Bet') {
+ return true;
+ }
+ return false;
+ })()
+);
+```
+
+卡牌序列 7、8、9 應該返回 `0 Hold`
+
+```js
+assert(
+ (function () {
+ count = 0;
+ cc(7);
+ cc(8);
+ var out = cc(9);
+ if (out === '0 Hold') {
+ return true;
+ }
+ return false;
+ })()
+);
+```
+
+卡牌序列 10、J、Q、K、A 應該返回 `-5 Hold`
+
+```js
+assert(
+ (function () {
+ count = 0;
+ cc(10);
+ cc('J');
+ cc('Q');
+ cc('K');
+ var out = cc('A');
+ if (out === '-5 Hold') {
+ return true;
+ }
+ return false;
+ })()
+);
+```
+
+卡牌序列 3、7、Q、8、A 應該返回 `-1 Hold`
+
+```js
+assert(
+ (function () {
+ count = 0;
+ cc(3);
+ cc(7);
+ cc('Q');
+ cc(8);
+ var out = cc('A');
+ if (out === '-1 Hold') {
+ return true;
+ }
+ return false;
+ })()
+);
+```
+
+卡牌序列 2、J、9、2、7 應該返回 `1 Bet`
+
+```js
+assert(
+ (function () {
+ count = 0;
+ cc(2);
+ cc('J');
+ cc(9);
+ cc(2);
+ var out = cc(7);
+ if (out === '1 Bet') {
+ return true;
+ }
+ return false;
+ })()
+);
+```
+
+卡牌序列 2、2、10 應該返回 `1 Bet`
+
+```js
+assert(
+ (function () {
+ count = 0;
+ cc(2);
+ cc(2);
+ var out = cc(10);
+ if (out === '1 Bet') {
+ return true;
+ }
+ return false;
+ })()
+);
+```
+
+卡牌序列 3、2、A、10、K 應該返回 `-1 Hold`
+
+```js
+assert(
+ (function () {
+ count = 0;
+ cc(3);
+ cc(2);
+ cc('A');
+ cc(10);
+ var out = cc('K');
+ if (out === '-1 Hold') {
+ return true;
+ }
+ return false;
+ })()
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+var count = 0;
+
+function cc(card) {
+ // Only change code below this line
+
+
+ return "Change Me";
+ // Only change code above this line
+}
+
+cc(2); cc(3); cc(7); cc('K'); cc('A');
+```
+
+# --solutions--
+
+```js
+var count = 0;
+function cc(card) {
+ switch(card) {
+ case 2:
+ case 3:
+ case 4:
+ case 5:
+ case 6:
+ count++;
+ break;
+ case 10:
+ case 'J':
+ case 'Q':
+ case 'K':
+ case 'A':
+ count--;
+ }
+ if(count > 0) {
+ return count + " Bet";
+ } else {
+ return count + " Hold";
+ }
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/create-decimal-numbers-with-javascript.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/create-decimal-numbers-with-javascript.md
new file mode 100644
index 0000000000..dae017b076
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/create-decimal-numbers-with-javascript.md
@@ -0,0 +1,54 @@
+---
+id: cf1391c1c11feddfaeb4bdef
+title: 創建一個小數
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/ca8GEuW'
+forumTopicId: 16826
+dashedName: create-decimal-numbers-with-javascript
+---
+
+# --description--
+
+我們也可以把小數存儲到變量中。 小數有時候也被稱作浮點數 或者 floats 。
+
+**提示：**不是所有的實數都可以用浮點數（floating point ）來表示。 因爲可能產生四捨五入的錯誤， [查看詳情](https://en.wikipedia.org/wiki/Floating_point#Accuracy_problems)。
+
+# --instructions--
+
+創建一個變量 `myDecimal`，並給它賦值一個浮點數（例如 `5.7`)。
+
+# --hints--
+
+`myDecimal` 應該是一個數字。
+
+```js
+assert(typeof myDecimal === 'number');
+```
+
+`myDecimal` 應該包含小數點。
+
+```js
+assert(myDecimal % 1 != 0);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(){if(typeof myDecimal !== "undefined"){return myDecimal;}})();
+```
+
+## --seed-contents--
+
+```js
+var ourDecimal = 5.7;
+
+// Only change code below this line
+```
+
+# --solutions--
+
+```js
+var myDecimal = 9.9;
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/declare-javascript-variables.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/declare-javascript-variables.md
new file mode 100644
index 0000000000..7ba3b3194b
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/declare-javascript-variables.md
@@ -0,0 +1,61 @@
+---
+id: bd7123c9c443eddfaeb5bdef
+title: 聲明變量
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cNanrHq'
+forumTopicId: 17556
+dashedName: declare-javascript-variables
+---
+
+# --description--
+
+在計算機科學中，數據 就是一切，它對於計算機意義重大。 JavaScript 提供七種不同的數據類型 ，它們是 `undefined`（未定義）、`null`（空）、`boolean`（布爾型）、`string`（字符串）、`symbol`、`number`（數字）、`bigint`（可以表示任意大的整數）和 `object`（對象）。
+
+例如，計算機區分數字，例如 `12`，和由字符組成的字符串 `strings`，例如 `"12"`、`"dog"` 或 `"123 cats"`。 計算機可以對數字執行數學運算，但不能對字符串執行數學運算。
+
+變量 允許計算機以一種動態的形式來存儲和操作數據， 即通過操作指向數據的指針而不是數據本身來實現。 以上八種數據類型中的任何一種都可以存儲到一個變量中。
+
+變量非常類似於你在數學中使用的 x、y 變量，都是以一個簡單命名的名稱來代替我們賦值給它的數據。 計算機中的變量與數學中的變量不同的是，計算機可以在不同的時間存儲不同類型的變量。
+
+通過在變量前面使用關鍵字 `var`，聲明 一個變量，例如：
+
+```js
+var ourName;
+```
+
+上面代碼的意思是創建一個名爲 `ourName` 的變量。 在 JavaScript 中我們以分號結束語句。 變量名稱可以由數字、字母、美元符號 `$` 或者下劃線 `_` 組成，但是不能包含空格或者以數字爲開頭。
+
+# --instructions--
+
+使用 `var` 關鍵字來創建一個名爲 `myName` 的變量。
+
+**提示：**
+如果遇到困難了，請看下 `ourName` 的例子是怎麼寫的。
+
+# --hints--
+
+使用 `var` 關鍵字定義一個變量 `myName`，並使用分號結尾。
+
+```js
+assert(/var\s+myName\s*;/.test(code));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+if(typeof myName !== "undefined"){(function(v){return v;})(myName);}
+```
+
+## --seed-contents--
+
+```js
+
+```
+
+# --solutions--
+
+```js
+var myName;
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/declare-string-variables.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/declare-string-variables.md
new file mode 100644
index 0000000000..c6a9902cf6
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/declare-string-variables.md
@@ -0,0 +1,81 @@
+---
+id: bd7123c9c444eddfaeb5bdef
+title: 聲明字符串變量
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c2QvWU6'
+forumTopicId: 17557
+dashedName: declare-string-variables
+---
+
+# --description--
+
+之前我們寫過這樣的代碼：
+
+```js
+var myName = "your name";
+```
+
+`"your name"` 被稱作字符串 字面量 。 這是一個字符串，因爲它是一系列包含在單引號或雙引號中的零或多個字符。
+
+# --instructions--
+
+創建兩個新的字符串變量：`myFirstName` 和 `myLastName`，並用你的姓和名分別爲它們賦值。
+
+# --hints--
+
+`myFirstName` 應該是一個字符串，至少包含一個字符。
+
+```js
+assert(
+ (function () {
+ if (
+ typeof myFirstName !== 'undefined' &&
+ typeof myFirstName === 'string' &&
+ myFirstName.length > 0
+ ) {
+ return true;
+ } else {
+ return false;
+ }
+ })()
+);
+```
+
+`myLastName` 應該是一個字符串，至少包含一個字符。
+
+```js
+assert(
+ (function () {
+ if (
+ typeof myLastName !== 'undefined' &&
+ typeof myLastName === 'string' &&
+ myLastName.length > 0
+ ) {
+ return true;
+ } else {
+ return false;
+ }
+ })()
+);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+if(typeof myFirstName !== "undefined" && typeof myLastName !== "undefined"){(function(){return myFirstName + ', ' + myLastName;})();}
+```
+
+## --seed-contents--
+
+```js
+
+```
+
+# --solutions--
+
+```js
+var myFirstName = "Alan";
+var myLastName = "Turing";
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/decrement-a-number-with-javascript.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/decrement-a-number-with-javascript.md
new file mode 100644
index 0000000000..e573f61d88
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/decrement-a-number-with-javascript.md
@@ -0,0 +1,80 @@
+---
+id: 56533eb9ac21ba0edf2244ad
+title: 數字遞減
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cM2KeS2'
+forumTopicId: 17558
+dashedName: decrement-a-number-with-javascript
+---
+
+# --description--
+
+使用自減符號 `--`，你可以很方便地對一個變量執行自減 或者 -1 運算。
+
+```js
+i--;
+```
+
+等效於：
+
+```js
+i = i - 1;
+```
+
+**注意：**`i--;` 這種寫法省去了書寫等號的必要。
+
+# --instructions--
+
+修改代碼，使用 `--` 符號對 `myVar` 執行自減操作。
+
+# --hints--
+
+`myVar` 應該等於`10`。
+
+```js
+assert(myVar === 10);
+```
+
+應該修改 `myVar = myVar - 1;`。
+
+```js
+assert(
+ /var\s*myVar\s*=\s*11;\s*\/*.*\s*([-]{2}\s*myVar|myVar\s*[-]{2});/.test(code)
+);
+```
+
+應該對 `myVar` 使用 `--` 運算符。
+
+```js
+assert(/[-]{2}\s*myVar|myVar\s*[-]{2}/.test(code));
+```
+
+不應修改註釋上方的代碼。
+
+```js
+assert(/var myVar = 11;/.test(code));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(z){return 'myVar = ' + z;})(myVar);
+```
+
+## --seed-contents--
+
+```js
+var myVar = 11;
+
+// Only change code below this line
+myVar = myVar - 1;
+```
+
+# --solutions--
+
+```js
+var myVar = 11;
+myVar--;
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/delete-properties-from-a-javascript-object.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/delete-properties-from-a-javascript-object.md
new file mode 100644
index 0000000000..639da32315
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/delete-properties-from-a-javascript-object.md
@@ -0,0 +1,95 @@
+---
+id: 56bbb991ad1ed5201cd392d3
+title: 刪除對象的屬性
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cDqKdTv'
+forumTopicId: 17560
+dashedName: delete-properties-from-a-javascript-object
+---
+
+# --description--
+
+我們同樣可以刪除對象的屬性，例如：
+
+```js
+delete ourDog.bark;
+```
+
+例如：
+
+```js
+var ourDog = {
+ "name": "Camper",
+ "legs": 4,
+ "tails": 1,
+ "friends": ["everything!"],
+ "bark": "bow-wow"
+};
+
+delete ourDog.bark;
+```
+
+在上面代碼的最後一行中，`ourDog` 是這樣的：
+
+```js
+{
+ "name": "Camper",
+ "legs": 4,
+ "tails": 1,
+ "friends": ["everything!"]
+}
+```
+
+# --instructions--
+
+刪除 `myDog` 對象的 `tails` 屬性。 可以使用點操作符或者中括號操作符。
+
+# --hints--
+
+應該從 `myDog` 中刪除 `tails` 屬性。
+
+```js
+assert(typeof myDog === 'object' && myDog.tails === undefined);
+```
+
+不要修改 `myDog` 的初始化代碼。
+
+```js
+assert(code.match(/"tails": 1/g).length > 0);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(z){return z;})(myDog);
+```
+
+## --seed-contents--
+
+```js
+// Setup
+var myDog = {
+ "name": "Happy Coder",
+ "legs": 4,
+ "tails": 1,
+ "friends": ["freeCodeCamp Campers"],
+ "bark": "woof"
+};
+
+// Only change code below this line
+```
+
+# --solutions--
+
+```js
+var myDog = {
+ "name": "Happy Coder",
+ "legs": 4,
+ "tails": 1,
+ "friends": ["freeCodeCamp Campers"],
+ "bark": "woof"
+};
+delete myDog.tails;
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/divide-one-decimal-by-another-with-javascript.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/divide-one-decimal-by-another-with-javascript.md
new file mode 100644
index 0000000000..13331312e7
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/divide-one-decimal-by-another-with-javascript.md
@@ -0,0 +1,56 @@
+---
+id: bd7993c9ca9feddfaeb7bdef
+title: 兩個小數相除
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cBZe9AW'
+forumTopicId: 18255
+dashedName: divide-one-decimal-by-another-with-javascript
+---
+
+# --description--
+
+現在讓我們將一個小數除以另一個小數。
+
+# --instructions--
+
+改變數值 `0.0` 的值讓變量 `quotient` 的值等於 `2.2`。
+
+# --hints--
+
+`quotient` 的值應該等於`2.2`。
+
+```js
+assert(quotient === 2.2);
+```
+
+使用 `/` 運算符將 4.4 除以 2。
+
+```js
+assert(/4\.40*\s*\/\s*2\.*0*/.test(code));
+```
+
+quotient 變量應該只被賦值一次。
+
+```js
+assert(code.match(/quotient/g).length === 1);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(y){return 'quotient = '+y;})(quotient);
+```
+
+## --seed-contents--
+
+```js
+var quotient = 0.0 / 2.0; // Change this line
+```
+
+# --solutions--
+
+```js
+var quotient = 4.4 / 2.0;
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/divide-one-number-by-another-with-javascript.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/divide-one-number-by-another-with-javascript.md
new file mode 100644
index 0000000000..4852f262ed
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/divide-one-number-by-another-with-javascript.md
@@ -0,0 +1,59 @@
+---
+id: cf1111c1c11feddfaeb6bdef
+title: 除法運算
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cqkbdAr'
+forumTopicId: 17566
+dashedName: divide-one-number-by-another-with-javascript
+---
+
+# --description--
+
+我們可以在 JavaScript 中做除法運算。
+
+JavaScript 中使用 `/` 符號做除法運算。
+
+**示例**
+
+```js
+myVar = 16 / 2;
+```
+
+現在，變量 `myVar` 的值爲 `8`。
+# --instructions--
+
+改變數值 `0` 來讓變量 `quotient` 的值等於 `2`。
+
+# --hints--
+
+要使 `quotient` 的值等於 2。
+
+```js
+assert(quotient === 2);
+```
+
+使用 `/` 運算符。
+
+```js
+assert(/\d+\s*\/\s*\d+/.test(code));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(z){return 'quotient = '+z;})(quotient);
+```
+
+## --seed-contents--
+
+```js
+var quotient = 66 / 0;
+```
+
+# --solutions--
+
+```js
+var quotient = 66 / 33;
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/escape-sequences-in-strings.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/escape-sequences-in-strings.md
new file mode 100644
index 0000000000..41c95ea283
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/escape-sequences-in-strings.md
@@ -0,0 +1,99 @@
+---
+id: 56533eb9ac21ba0edf2244b6
+title: 轉義字符
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cvmqRh6'
+forumTopicId: 17567
+dashedName: escape-sequences-in-strings
+---
+
+# --description--
+
+引號不是字符串中唯一可以被轉義（escaped ）的字符。 使用轉義字符有兩個原因：
+
+1. 首先是可以讓你使用無法輸入的字符，例如退格。
+2. 其次是可以讓你在一個字符串中表示多個引號，而不會出錯。
+
+我們在之前的挑戰中學到了這個。
+
+代碼 輸出 \'單引號 \"雙引號 \\反斜槓 \n換行符 \r回車符 \t製表符 \b退格 \f換頁符
+
+*請注意，必須對反斜槓本身進行轉義，它才能顯示爲反斜槓。*
+
+# --instructions--
+
+使用轉義序列把下面三行文本賦值給一個變量 `myStr`。
+
+FirstLine
+
+你需要使用轉義字符正確地插入特殊字符。 確保間距與上面文本一致，並且單詞或轉義字符之間沒有空格。
+
+**注意：** `SecondLine` 是因爲鍵入了轉義字符（而不是空格），所以在那個位置。
+
+# --hints--
+
+`myStr` 不能包含空格。
+
+```js
+assert(!/ /.test(myStr));
+```
+
+`myStr` 應包含字符串 `FirstLine`、`SecondLine` 和 `ThirdLine`（記得區分大小寫）。
+
+```js
+assert(
+ /FirstLine/.test(myStr) && /SecondLine/.test(myStr) && /ThirdLine/.test(myStr)
+);
+```
+
+`FirstLine` 後面應該是一個換行符 `\n`。
+
+```js
+assert(/FirstLine\n/.test(myStr));
+```
+
+`myStr` 應該包含一個製表符 `\t`，它在換行符後面。
+
+```js
+assert(/\n\t/.test(myStr));
+```
+
+`SecondLine` 前面應該是反斜槓 `\`。
+
+```js
+assert(/\\SecondLine/.test(myStr));
+```
+
+`SecondLine` 和 `ThirdLine` 之間應該是換行符。
+
+```js
+assert(/SecondLine\nThirdLine/.test(myStr));
+```
+
+`myStr` 應該只包含上面要求的字符。
+
+```js
+assert(myStr === 'FirstLine\n\t\\SecondLine\nThirdLine');
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(){
+if (myStr !== undefined){
+console.log('myStr:\n' + myStr);}})();
+```
+
+## --seed-contents--
+
+```js
+var myStr; // Change this line
+```
+
+# --solutions--
+
+```js
+var myStr = "FirstLine\n\t\\SecondLine\nThirdLine";
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/escaping-literal-quotes-in-strings.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/escaping-literal-quotes-in-strings.md
new file mode 100644
index 0000000000..45942bb07b
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/escaping-literal-quotes-in-strings.md
@@ -0,0 +1,72 @@
+---
+id: 56533eb9ac21ba0edf2244b5
+title: 轉義字符串中的引號
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c2QvgSr'
+forumTopicId: 17568
+dashedName: escaping-literal-quotes-in-strings
+---
+
+# --description--
+
+定義一個字符串必須要用單引號或雙引號來包裹它。 那麼當你的字符串裏面包含引號 `"` 或者 `'` 時該怎麼辦呢?
+
+在 JavaScript 中，可以通過在引號前面使用反斜槓 （`\`）來轉義 引號。
+
+```js
+var sampleStr = "Alan said, \"Peter is learning JavaScript\".";
+```
+
+有了轉義符號，JavaScript 就知道這個單引號或雙引號並不是字符串的結尾，而是字符串內的字符。 所以，上面的字符串打印到控制檯的結果爲：
+
+```js
+Alan said, "Peter is learning JavaScript".
+```
+
+# --instructions--
+
+使用反斜槓 給 `myStr` 變量賦值一個字符串，這樣如果你要打印它到控制檯，將會看到：
+
+```js
+I am a "double quoted" string inside "double quotes".
+```
+
+# --hints--
+
+你的代碼中應該包含兩個雙引號（`"`）以及四個轉義的雙引號（`\"`）。
+
+```js
+assert(code.match(/\\"/g).length === 4 && code.match(/[^\\]"/g).length === 2);
+```
+
+變量 myStr 應該包含字符串 `I am a "double quoted" string inside "double quotes".`
+
+```js
+assert(/I am a "double quoted" string inside "double quotes(\."|"\.)$/.test(myStr));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(){
+ if(typeof myStr === 'string') {
+ console.log("myStr = \"" + myStr + "\"");
+ } else {
+ console.log("myStr is undefined");
+ }
+})();
+```
+
+## --seed-contents--
+
+```js
+var myStr = ""; // Change this line
+```
+
+# --solutions--
+
+```js
+var myStr = "I am a \"double quoted\" string inside \"double quotes\".";
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/find-the-length-of-a-string.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/find-the-length-of-a-string.md
new file mode 100644
index 0000000000..3976633cdd
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/find-the-length-of-a-string.md
@@ -0,0 +1,69 @@
+---
+id: bd7123c9c448eddfaeb5bdef
+title: 查找字符串的長度
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cvmqEAd'
+forumTopicId: 18182
+dashedName: find-the-length-of-a-string
+---
+
+# --description--
+
+你可以通過在字符串變量或字符串後面寫上 `.length` 來獲得 `String` 的長度。
+
+```js
+console.log("Alan Peter".length);
+```
+
+字符串 `10` 將會出現在控制檯中。
+
+例如，我們創建了一個變量 `var firstName = "Charles"`，我們就可以通過使用 `firstName.length` 來獲得 `Charles` 字符串的長度。
+
+# --instructions--
+
+使用 `.length` 屬性來獲得變量 `lastName` 的長度，並把它賦值給變量 `lastNameLength`。
+
+# --hints--
+
+不能改變 `// Setup` 部分聲明的變量。
+
+```js
+assert(
+ code.match(/var lastNameLength = 0;/) &&
+ code.match(/var lastName = "Lovelace";/)
+);
+```
+
+`lastNameLength` 應該等於 8。
+
+```js
+assert(typeof lastNameLength !== 'undefined' && lastNameLength === 8);
+```
+
+你應該使用 `.length` 獲取 `lastName` 的長度，像這樣 `lastName.length`。
+
+```js
+assert(code.match(/=\s*lastName\.length/g) && !code.match(/lastName\s*=\s*8/));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// Setup
+var lastNameLength = 0;
+var lastName = "Lovelace";
+
+// Only change code below this line
+
+lastNameLength = lastName;
+```
+
+# --solutions--
+
+```js
+var lastNameLength = 0;
+var lastName = "Lovelace";
+lastNameLength = lastName.length;
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/finding-a-remainder-in-javascript.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/finding-a-remainder-in-javascript.md
new file mode 100644
index 0000000000..b00b736b66
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/finding-a-remainder-in-javascript.md
@@ -0,0 +1,69 @@
+---
+id: 56533eb9ac21ba0edf2244ae
+title: 求餘運算
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cWP24Ub'
+forumTopicId: 18184
+dashedName: finding-a-remainder-in-javascript
+---
+
+# --description--
+
+remainder 求餘運算符 `%` 返回兩個數相除得到的餘數
+
+**示例**
+
+5 % 2 = 1 因爲
+
+**用法**
+在數學中，判斷一個數是奇數還是偶數，只需要判斷這個數除以 `2` 得到的餘數是 0 還是 1。
+
+17 % 2 = 1（17 是奇數）
+
+**提示**餘數運算符（remainder ）有時被錯誤地稱爲“模數”運算符。 它與模數非常相似，但不能用於負數的運算。
+
+# --instructions--
+
+使用 remainder （`%`）運算符，計算 `11` 除以 `3` 的餘數，並把餘數賦給變量 `remainder`。
+
+# --hints--
+
+變量 `remainder` 應該被初始化。
+
+```js
+assert(/var\s+?remainder/.test(code));
+```
+
+`remainder` 的值應該等於 `2`。
+
+```js
+assert(remainder === 2);
+```
+
+你應該使用 `%` 運算符。
+
+```js
+assert(/\s+?remainder\s*?=\s*?.*%.*;?/.test(code));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(y){return 'remainder = '+y;})(remainder);
+```
+
+## --seed-contents--
+
+```js
+// Only change code below this line
+
+var remainder;
+```
+
+# --solutions--
+
+```js
+var remainder = 11 % 3;
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/generate-random-fractions-with-javascript.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/generate-random-fractions-with-javascript.md
new file mode 100644
index 0000000000..9d8b51d142
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/generate-random-fractions-with-javascript.md
@@ -0,0 +1,69 @@
+---
+id: cf1111c1c11feddfaeb9bdef
+title: 使用 JavaScript 生成隨機分數
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cyWJJs3'
+forumTopicId: 18185
+dashedName: generate-random-fractions-with-javascript
+---
+
+# --description--
+
+隨機數非常適合用來創建隨機行爲。
+
+在 JavaScript 中，可以用 `Math.random()` 生成一個在`0`（包括 0）到 `1`（不包括 1）之間的隨機小數， 因此 `Math.random()` 可能返回 `0`，但絕不會返回 `1`。
+
+**提示：** [使用賦值運算符存儲值](/learn/javascript-algorithms-and-data-structures/basic-javascript/storing-values-with-the-assignment-operator)這一節講過，所有函數調用將在 `return` 執行之前結束，因此我們可以 `return`（返回）`Math.random()` 函數的值。
+
+# --instructions--
+
+更改 `randomFraction`，使其返回一個隨機數而不是 `0`。
+
+# --hints--
+
+`randomFraction` 應該返回一個隨機數。
+
+```js
+assert(typeof randomFraction() === 'number');
+```
+
+`randomFraction` 應該返回一個小數。
+
+```js
+assert((randomFraction() + '').match(/\./g));
+```
+
+需要使用 `Math.random` 生成隨機的小數。
+
+```js
+assert(code.match(/Math\.random/g).length >= 0);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(){return randomFraction();})();
+```
+
+## --seed-contents--
+
+```js
+function randomFraction() {
+
+ // Only change code below this line
+
+ return 0;
+
+ // Only change code above this line
+}
+```
+
+# --solutions--
+
+```js
+function randomFraction() {
+ return Math.random();
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/generate-random-whole-numbers-with-javascript.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/generate-random-whole-numbers-with-javascript.md
new file mode 100644
index 0000000000..2b05f7fc55
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/generate-random-whole-numbers-with-javascript.md
@@ -0,0 +1,90 @@
+---
+id: cf1111c1c12feddfaeb1bdef
+title: 使用 JavaScript 生成隨機整數
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cRn6bfr'
+forumTopicId: 18186
+dashedName: generate-random-whole-numbers-with-javascript
+---
+
+# --description--
+
+生成隨機小數很棒，但隨機數更有用的地方在於生成隨機整數。
+
+用 Math.random() 生成一個隨機小數。 把這個隨機小數乘以 20。 用 Math.floor() 向下取整，獲得它最近的整數。 作用域 涉及到變量的作用範圍。 在函數外定義的變量具有 全局 作用域。 這意味着，具有全局作用域的變量可以在代碼的任何地方被調用。
+
+這些沒有使用 `var` 關鍵字定義的變量，會被自動創建在 `global` 作用域中，形成全局變量。 當在代碼其他地方無意間定義了一個變量，剛好變量名與全局變量相同，這時會產生意想不到的後果。 因此你應該總是使用 `var` 關鍵字來聲明你的變量。
+
+# --instructions--
+
+使用 `var`，在函數外聲明一個全局變量 `myGlobal`， 並給它一個初始值 `10`。
+
+在函數 `fun1` 的內部，***不***使用 `var` 關鍵字，聲明 `oopsGlobal`，並給它賦值爲 `5`。
+
+# --hints--
+
+應定義 `myGlobal`。
+
+```js
+assert(typeof myGlobal != 'undefined');
+```
+
+`myGlobal` 的值應爲 `10`。
+
+```js
+assert(myGlobal === 10);
+```
+
+應使用 `var` 關鍵字定義 `myGlobal`。
+
+```js
+assert(/var\s+myGlobal/.test(code));
+```
+
+`oopsGlobal` 應爲全局變量，值爲 `5`。
+
+```js
+assert(typeof oopsGlobal != 'undefined' && oopsGlobal === 5);
+```
+
+# --seed--
+
+## --before-user-code--
+
+```js
+var logOutput = "";
+var originalConsole = console
+function capture() {
+ var nativeLog = console.log;
+ console.log = function (message) {
+ logOutput = message;
+ if(nativeLog.apply) {
+ nativeLog.apply(originalConsole, arguments);
+ } else {
+ var nativeMsg = Array.prototype.slice.apply(arguments).join(' ');
+ nativeLog(nativeMsg);
+ }
+ };
+}
+
+function uncapture() {
+ console.log = originalConsole.log;
+}
+var oopsGlobal;
+capture();
+```
+
+## --after-user-code--
+
+```js
+fun1();
+fun2();
+uncapture();
+(function() { return logOutput || "console.log never called"; })();
+```
+
+## --seed-contents--
+
+```js
+// Declare the myGlobal variable below this line
+
+
+function fun1() {
+ // Assign 5 to oopsGlobal Here
+
+}
+
+// Only change code above this line
+
+function fun2() {
+ var output = "";
+ if (typeof myGlobal != "undefined") {
+ output += "myGlobal: " + myGlobal;
+ }
+ if (typeof oopsGlobal != "undefined") {
+ output += " oopsGlobal: " + oopsGlobal;
+ }
+ console.log(output);
+}
+```
+
+# --solutions--
+
+```js
+var myGlobal = 10;
+
+function fun1() {
+ oopsGlobal = 5;
+}
+
+function fun2() {
+ var output = "";
+ if(typeof myGlobal != "undefined") {
+ output += "myGlobal: " + myGlobal;
+ }
+ if(typeof oopsGlobal != "undefined") {
+ output += " oopsGlobal: " + oopsGlobal;
+ }
+ console.log(output);
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/global-vs.-local-scope-in-functions.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/global-vs.-local-scope-in-functions.md
new file mode 100644
index 0000000000..6ecd5113e4
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/global-vs.-local-scope-in-functions.md
@@ -0,0 +1,78 @@
+---
+id: 56533eb9ac21ba0edf2244c0
+title: 函數中的全局作用域和局部作用域
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c2QwKH2'
+forumTopicId: 18194
+dashedName: global-vs--local-scope-in-functions
+---
+
+# --description--
+
+一個程序中有可能具有相同名稱的局部 變量 和全局 變量。 在這種情況下，`local` 變量將會優先於`global`變量。
+
+下面爲例：
+
+```js
+var someVar = "Hat";
+function myFun() {
+ var someVar = "Head";
+ return someVar;
+}
+```
+
+函數 `myFun` 將會返回 `Head`，因爲 `local` 變量優先級更高。
+
+# --instructions--
+
+給 `myOutfit` 添加一個局部變量來將 `outerWear` 的值重載爲 `sweater`。
+
+# --hints--
+
+不要修改全局變量 `outerWear` 的值。
+
+```js
+assert(outerWear === 'T-Shirt');
+```
+
+`myOutfit` 應該返回 `sweater`。
+
+```js
+assert(myOutfit() === 'sweater');
+```
+
+不要修改 return 語句。
+
+```js
+assert(/return outerWear/.test(code));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// Setup
+var outerWear = "T-Shirt";
+
+function myOutfit() {
+ // Only change code below this line
+
+
+
+ // Only change code above this line
+ return outerWear;
+}
+
+myOutfit();
+```
+
+# --solutions--
+
+```js
+var outerWear = "T-Shirt";
+function myOutfit() {
+ var outerWear = "sweater";
+ return outerWear;
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/golf-code.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/golf-code.md
new file mode 100644
index 0000000000..8dade6734c
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/golf-code.md
@@ -0,0 +1,135 @@
+---
+id: 5664820f61c48e80c9fa476c
+title: 高爾夫代碼
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c9ykNUR'
+forumTopicId: 18195
+dashedName: golf-code
+---
+
+# --description--
+
+在[高爾夫](https://en.wikipedia.org/wiki/Golf)遊戲中，每個洞都有自己的標準桿數 `par`，代表着把球打進洞所揮杆的平均次數 `strokes`。 根據你把球打進洞所揮杆的次數 `strokes` 高於或低於 `par` 多少，有一個不同的暱稱（代表打高爾夫球的水平）。
+
+函數將會傳送兩個參數，`par` 和 `strokes`。 根據下表返回正確的字符串。下表列出不同揮杆次數（從高到低）對應的字符串。
+
+揮杆次數 返回字符串 1 "Hole-in-one!" <= par - 2 "Eagle" par - 1 "Birdie" par "Par" par + 1 "Bogey" par + 2 "Double Bogey" >= par + 3 "Go Home!"
+
+`par` 和 `strokes` 必須是數字而且是正數。 題目已定義字符串的數組，便於你操作。
+
+# --hints--
+
+`golfScore(4, 1)` 應該返回字符串 `Hole-in-one!`
+
+```js
+assert(golfScore(4, 1) === 'Hole-in-one!');
+```
+
+`golfScore(4, 2)` 應該返回字符串 `Eagle`
+
+```js
+assert(golfScore(4, 2) === 'Eagle');
+```
+
+`golfScore(5, 2)` 應該返回字符串 `Eagle`
+
+```js
+assert(golfScore(5, 2) === 'Eagle');
+```
+
+`golfScore(4, 3)` 應該返回字符串 `Birdie`
+
+```js
+assert(golfScore(4, 3) === 'Birdie');
+```
+
+`golfScore(4, 4)` 應該返回字符串 `Par`
+
+```js
+assert(golfScore(4, 4) === 'Par');
+```
+
+`golfScore(1, 1)` 應該返回字符串 `Hole-in-one!`
+
+```js
+assert(golfScore(1, 1) === 'Hole-in-one!');
+```
+
+`golfScore(5, 5)` 應該返回字符串 `Par`
+
+```js
+assert(golfScore(5, 5) === 'Par');
+```
+
+`golfScore(4, 5)` 應該返回字符串 `Bogey`
+
+```js
+assert(golfScore(4, 5) === 'Bogey');
+```
+
+`golfScore(4, 6)` 應該返回字符串 `Double Bogey`
+
+```js
+assert(golfScore(4, 6) === 'Double Bogey');
+```
+
+`golfScore(4, 7)` 應該返回字符串 `Go Home!`
+
+```js
+assert(golfScore(4, 7) === 'Go Home!');
+```
+
+`golfScore(5, 9)` 應該返回字符串 `Go Home!`
+
+```js
+assert(golfScore(5, 9) === 'Go Home!');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+var names = ["Hole-in-one!", "Eagle", "Birdie", "Par", "Bogey", "Double Bogey", "Go Home!"];
+function golfScore(par, strokes) {
+ // Only change code below this line
+
+
+ return "Change Me";
+ // Only change code above this line
+}
+
+golfScore(5, 4);
+```
+
+# --solutions--
+
+```js
+function golfScore(par, strokes) {
+ if (strokes === 1) {
+ return "Hole-in-one!";
+ }
+
+ if (strokes <= par - 2) {
+ return "Eagle";
+ }
+
+ if (strokes === par - 1) {
+ return "Birdie";
+ }
+
+ if (strokes === par) {
+ return "Par";
+ }
+
+ if (strokes === par + 1) {
+ return "Bogey";
+ }
+
+ if(strokes === par + 2) {
+ return "Double Bogey";
+ }
+
+ return "Go Home!";
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/increment-a-number-with-javascript.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/increment-a-number-with-javascript.md
new file mode 100644
index 0000000000..777a1bc649
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/increment-a-number-with-javascript.md
@@ -0,0 +1,80 @@
+---
+id: 56533eb9ac21ba0edf2244ac
+title: 數字遞增
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/ca8GLT9'
+forumTopicId: 18201
+dashedName: increment-a-number-with-javascript
+---
+
+# --description--
+
+使用 `++`，我們可以很容易地對變量進行自增 或者 +1 運算。
+
+```js
+i++;
+```
+
+等效於：
+
+```js
+i = i + 1;
+```
+
+**注意：**`i++;` 這種寫法省去了書寫等號的必要。
+
+# --instructions--
+
+修改代碼，使用 `++` 來對變量 `myVar` 進行自增操作。
+
+# --hints--
+
+`myVar` 應該等於 `88`。
+
+```js
+assert(myVar === 88);
+```
+
+不應該使用賦值運算符。
+
+```js
+assert(
+ /var\s*myVar\s*=\s*87;\s*\/*.*\s*([+]{2}\s*myVar|myVar\s*[+]{2});/.test(code)
+);
+```
+
+應該使用 `++` 運算符。
+
+```js
+assert(/[+]{2}\s*myVar|myVar\s*[+]{2}/.test(code));
+```
+
+不應該修改註釋上面的代碼。
+
+```js
+assert(/var myVar = 87;/.test(code));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(z){return 'myVar = ' + z;})(myVar);
+```
+
+## --seed-contents--
+
+```js
+var myVar = 87;
+
+// Only change code below this line
+myVar = myVar + 1;
+```
+
+# --solutions--
+
+```js
+var myVar = 87;
+myVar++;
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/initializing-variables-with-the-assignment-operator.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/initializing-variables-with-the-assignment-operator.md
new file mode 100644
index 0000000000..054a453aee
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/initializing-variables-with-the-assignment-operator.md
@@ -0,0 +1,50 @@
+---
+id: 56533eb9ac21ba0edf2244a9
+title: 使用賦值運算符初始化變量
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cWJ4Bfb'
+forumTopicId: 301171
+dashedName: initializing-variables-with-the-assignment-operator
+---
+
+# --description--
+
+通常在聲明變量的時候會給變量初始化 一個初始值。
+
+```js
+var myVar = 0;
+```
+
+創建一個名爲 `myVar` 的變量，並指定其初始值爲 `0`。
+
+# --instructions--
+
+通過關鍵字 `var` 定義一個變量 `a`，並且給它一個初始值 `9`。
+
+# --hints--
+
+應該初始化 `a` 的值爲 `9`。
+
+```js
+assert(/var\s+a\s*=\s*9(\s*;?\s*)$/.test(code));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+if(typeof a !== 'undefined') {(function(a){return "a = " + a;})(a);} else { (function() {return 'a is undefined';})(); }
+```
+
+## --seed-contents--
+
+```js
+
+```
+
+# --solutions--
+
+```js
+var a = 9;
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/introducing-else-if-statements.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/introducing-else-if-statements.md
new file mode 100644
index 0000000000..33de6be143
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/introducing-else-if-statements.md
@@ -0,0 +1,114 @@
+---
+id: 56533eb9ac21ba0edf2244db
+title: 介紹 else if 語句
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/caeJ2hm'
+forumTopicId: 18206
+dashedName: introducing-else-if-statements
+---
+
+# --description--
+
+如果你有多個條件語句，你可以通過 `else if` 語句把 `if` 語句鏈起來。
+
+```js
+if (num > 15) {
+ return "Bigger than 15";
+} else if (num < 5) {
+ return "Smaller than 5";
+} else {
+ return "Between 5 and 15";
+}
+```
+
+# --instructions--
+
+使用 `else if` 實現同樣的效果。
+
+# --hints--
+
+你應該至少有兩個 `else` 表達式。
+
+```js
+assert(code.match(/else/g).length > 1);
+```
+
+你應該至少有兩個 `if` 表達式。
+
+```js
+assert(code.match(/if/g).length > 1);
+```
+
+應該關閉每一個 `if else` 代碼塊。
+
+```js
+assert(
+ code.match(
+ /if\s*\((.+)\)\s*\{[\s\S]+\}\s*else\s+if\s*\((.+)\)\s*\{[\s\S]+\}\s*else\s*\{[\s\S]+\s*\}/
+ )
+);
+```
+
+`testElseIf(0)` 應該返回字符串 `Smaller than 5`
+
+```js
+assert(testElseIf(0) === 'Smaller than 5');
+```
+
+`testElseIf(5)` 應該返回字符串 `Between 5 and 10`
+
+```js
+assert(testElseIf(5) === 'Between 5 and 10');
+```
+
+`testElseIf(7)` 應該返回字符串 `Between 5 and 10`
+
+```js
+assert(testElseIf(7) === 'Between 5 and 10');
+```
+
+`testElseIf(10)` 應該返回字符串 `Between 5 and 10`
+
+```js
+assert(testElseIf(10) === 'Between 5 and 10');
+```
+
+`testElseIf(12)` 應該返回字符串 `Greater than 10`
+
+```js
+assert(testElseIf(12) === 'Greater than 10');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function testElseIf(val) {
+ if (val > 10) {
+ return "Greater than 10";
+ }
+
+ if (val < 5) {
+ return "Smaller than 5";
+ }
+
+ return "Between 5 and 10";
+}
+
+testElseIf(7);
+```
+
+# --solutions--
+
+```js
+function testElseIf(val) {
+ if(val > 10) {
+ return "Greater than 10";
+ } else if(val < 5) {
+ return "Smaller than 5";
+ } else {
+ return "Between 5 and 10";
+ }
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/introducing-else-statements.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/introducing-else-statements.md
new file mode 100644
index 0000000000..9e3ff3c710
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/introducing-else-statements.md
@@ -0,0 +1,106 @@
+---
+id: 56533eb9ac21ba0edf2244da
+title: 介紹 else 語句
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cek4Efq'
+forumTopicId: 18207
+dashedName: introducing-else-statements
+---
+
+# --description--
+
+當 `if` 語句的條件爲真，會執行大括號裏的代碼。 那如果條件爲假呢？ 正常情況下什麼也不會發生。 使用 `else` 語句，可以執行當條件爲假時相應的代碼。
+
+```js
+if (num > 10) {
+ return "Bigger than 10";
+} else {
+ return "10 or Less";
+}
+```
+
+# --instructions--
+
+請把多個 `if` 語句合併爲一個 `if/else` 語句。
+
+# --hints--
+
+應該只有一個 `if` 語句。
+
+```js
+assert(code.match(/if/g).length === 1);
+```
+
+應該使用一個 `else` 語句。
+
+```js
+assert(/else/g.test(code));
+```
+
+`testElse(4)` 應該返回字符串 `5 or Smaller`
+
+```js
+assert(testElse(4) === '5 or Smaller');
+```
+
+`testElse(5)` 應該返回字符串 `5 or Smaller`
+
+```js
+assert(testElse(5) === '5 or Smaller');
+```
+
+`testElse(6)` 應該返回字符串 `Bigger than 5`
+
+```js
+assert(testElse(6) === 'Bigger than 5');
+```
+
+`testElse(10)` 應該返回字符串 `Bigger than 5`
+
+```js
+assert(testElse(10) === 'Bigger than 5');
+```
+
+不要修改相應註釋的上面或下面的代碼。
+
+```js
+assert(/var result = "";/.test(code) && /return result;/.test(code));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function testElse(val) {
+ var result = "";
+ // Only change code below this line
+
+ if (val > 5) {
+ result = "Bigger than 5";
+ }
+
+ if (val <= 5) {
+ result = "5 or Smaller";
+ }
+
+ // Only change code above this line
+ return result;
+}
+
+testElse(4);
+```
+
+# --solutions--
+
+```js
+function testElse(val) {
+ var result = "";
+ if(val > 5) {
+ result = "Bigger than 5";
+ } else {
+ result = "5 or Smaller";
+ }
+ return result;
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-odd-numbers-with-a-for-loop.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-odd-numbers-with-a-for-loop.md
new file mode 100644
index 0000000000..6bf08261fe
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-odd-numbers-with-a-for-loop.md
@@ -0,0 +1,67 @@
+---
+id: 56104e9e514f539506016a5c
+title: 使用 For 循環遍歷數組的奇數
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cm8n7T9'
+forumTopicId: 18212
+dashedName: iterate-odd-numbers-with-a-for-loop
+---
+
+# --description--
+
+對於循環，一次不必遞增一個。 通過更改我們的 `final-expression`，我們可以用偶數來計數。
+
+初始化 `i = 0`，當 `i < 10` 的時候繼續循環。 `i += 2` 讓 `i` 每次循環之後增加 2。
+
+```js
+var ourArray = [];
+for (var i = 0; i < 10; i += 2) {
+ ourArray.push(i);
+}
+```
+
+循環結束後，`ourArray` 的值爲 `[0,2,4,6,8]`。 改變計數器（`initialization`） ，這樣我們可以用奇數來遞增。
+
+# --instructions--
+
+寫一個 `for` 循環，把從 1 到 9 的奇數添加到 `myArray`。
+
+# --hints--
+
+應該使用 `for` 循環。
+
+```js
+assert(/for\s*\([^)]+?\)/.test(code));
+```
+
+`myArray` 應該等於 `[1,3,5,7,9]`
+
+```js
+assert.deepEqual(myArray, [1, 3, 5, 7, 9]);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+if(typeof myArray !== "undefined"){(function(){return myArray;})();}
+```
+
+## --seed-contents--
+
+```js
+// Setup
+var myArray = [];
+
+// Only change code below this line
+```
+
+# --solutions--
+
+```js
+var myArray = [];
+for (var i = 1; i < 10; i += 2) {
+ myArray.push(i);
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-through-an-array-with-a-for-loop.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-through-an-array-with-a-for-loop.md
new file mode 100644
index 0000000000..ba7b13c655
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-through-an-array-with-a-for-loop.md
@@ -0,0 +1,79 @@
+---
+id: 5675e877dbd60be8ad28edc6
+title: 使用 For 循環遍歷數組
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/caeR3HB'
+forumTopicId: 18216
+dashedName: iterate-through-an-array-with-a-for-loop
+---
+
+# --description--
+
+JavaScript 中的一個常見任務是遍歷數組的內容。 一種方法是使用 `for` 循環。 下面的代碼將輸出數組 `arr` 的每個元素到控制檯：
+
+```js
+var arr = [10, 9, 8, 7, 6];
+for (var i = 0; i < arr.length; i++) {
+ console.log(arr[i]);
+}
+```
+
+記住數組的索引從零開始的，這意味着數組的最後一個元素的下標是：`length - 1`（數組的長度 -1）。 我們這個循環的條件是 `i < arr.length`，當 `i` 的值爲 `length` 的時候循環就停止了。 在這個例子中，最後一個循環是 `i === 4`，也就是說，當 `i` 的值等於 `arr.length` 時，結果輸出 `6`。
+
+# --instructions--
+
+聲明並初始化一個變量 `total` 值爲 `0`。 使用 `for` 循環，使得 `total` 的值爲 `myArr` 的數組中的每個元素的值的總和。
+
+# --hints--
+
+`total` 應該被聲明, 並且初始化值爲 0。
+
+```js
+assert(code.match(/(var|let|const)\s*?total\s*=\s*0.*?;?/));
+```
+
+`total` 應該等於 20。
+
+```js
+assert(total === 20);
+```
+
+你應該使用 `for` 循環在 `myArr` 中遍歷。
+
+```js
+assert(/for\s*\(/g.test(code) && /myArr\s*\[/g.test(code));
+```
+
+不能直接把 `total` 設置成 20。
+
+```js
+assert(!__helpers.removeWhiteSpace(code).match(/total[=+-]0*[1-9]+/gm));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(){if(typeof total !== 'undefined') { return "total = " + total; } else { return "total is undefined";}})()
+```
+
+## --seed-contents--
+
+```js
+// Setup
+var myArr = [ 2, 3, 4, 5, 6];
+
+// Only change code below this line
+```
+
+# --solutions--
+
+```js
+var myArr = [ 2, 3, 4, 5, 6];
+var total = 0;
+
+for (var i = 0; i < myArr.length; i++) {
+ total += myArr[i];
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-with-javascript-do...while-loops.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-with-javascript-do...while-loops.md
new file mode 100644
index 0000000000..b64f2bac08
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-with-javascript-do...while-loops.md
@@ -0,0 +1,102 @@
+---
+id: 5a2efd662fb457916e1fe604
+title: do...while 循環
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cDqWGcp'
+forumTopicId: 301172
+dashedName: iterate-with-javascript-do---while-loops
+---
+
+# --description--
+
+下一種循環叫作 `do...while` 循環。 它被稱爲 `do...while` 循環，是因爲不論什麼情況，它都會首先 `do`（運行）循環裏的第一部分代碼，然後 `while`（當）規定的條件被評估爲 `true`（真）的時候，它會繼續運行循環。
+
+```js
+var ourArray = [];
+var i = 0;
+do {
+ ourArray.push(i);
+ i++;
+} while (i < 5);
+```
+
+上面的示例行爲類似於其他類型的循環，由此產生的數組將看起來像 `[0, 1, 2, 3, 4]`。 然而，`do...while` 不同於其他循環的地方，是第一次循環檢查失敗時的行爲。 讓我們看看代碼中的區別：這裏是一個常規的 `while` 循環，只要 `i < 5`，就會在循環中運行代碼：
+
+```js
+var ourArray = [];
+var i = 5;
+while (i < 5) {
+ ourArray.push(i);
+ i++;
+}
+```
+
+這個例子中，定義了一個空數組 `ourArray` 以及一個值爲 5 的 `i` 。 當執行 `while` 循環時，因爲 `i` 不小於 5，所以循環條件爲 `false`，循環內的代碼將不會執行。 `ourArray` 最終沒有添加任何內容，因此示例中的所有代碼執行完時，ourArray 仍然是`[]`。 現在，看一下 `do...while` 循環。
+
+```js
+var ourArray = [];
+var i = 5;
+do {
+ ourArray.push(i);
+ i++;
+} while (i < 5);
+```
+
+在這裏，和使用 `while` 循環一樣，將 `i` 的值初始化爲 5。 執行下一行時，沒有執行循環檢查，直接執行花括號內的代碼。 數組會添加一個元素，並在進行條件檢查之前遞增 `i`。 然後，在條件檢查時因爲 `i` 等於 6 不符合條件 `i < 5`，所以退出循環。 最終 `ourArray` 的值是 `[5]`。 本質上，`do...while` 循環確保循環內的代碼至少運行一次。 讓我們通過 `do...while` 循環將值添加到數組中。
+
+# --instructions--
+
+將代碼中的 `while` 循環更改爲 `do...while` 循環，將數字 `10` 添加到 `myArray` 中，代碼執行完時，`i` 等於 `11`。
+
+# --hints--
+
+你應該使用 `do...while` 循環。
+
+```js
+assert(code.match(/do/g));
+```
+
+`myArray` 應該等於 `[10]`。
+
+```js
+assert.deepEqual(myArray, [10]);
+```
+
+`i` 應該等於 `11`。
+
+```js
+assert.equal(i, 11);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+if(typeof myArray !== "undefined"){(function(){return myArray;})();}
+```
+
+## --seed-contents--
+
+```js
+// Setup
+var myArray = [];
+var i = 10;
+
+// Only change code below this line
+while (i < 5) {
+ myArray.push(i);
+ i++;
+}
+```
+
+# --solutions--
+
+```js
+var myArray = [];
+var i = 10;
+do {
+ myArray.push(i);
+ i++;
+} while (i < 5)
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-with-javascript-for-loops.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-with-javascript-for-loops.md
new file mode 100644
index 0000000000..8788333453
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-with-javascript-for-loops.md
@@ -0,0 +1,79 @@
+---
+id: cf1111c1c11feddfaeb5bdef
+title: for 循環
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c9yNVCe'
+forumTopicId: 18219
+dashedName: iterate-with-javascript-for-loops
+---
+
+# --description--
+
+你可以使用循環多次執行相同的代碼。
+
+JavaScript 中最常見的循環就是 `for`，它可以循環指定次數。
+
+for 循環中的可選三個表達式用分號隔開：
+
+`for (a; b; c)`，其中 `a` 爲初始化語句，`b` 是循環條件語句，`c` 是終止循環條件表達式。
+
+初始化語句只會在執行循環開始之前執行一次。 它通常用於定義和設置你的循環變量。
+
+循環條件語句會在每一輪循環的開始前執行，只要條件判斷爲 `true` 就會繼續執行循環。 當條件爲 `false` 的時候，循環將停止執行。 這意味着，如果條件在一開始就爲 false，這個循環將不會執行。
+
+終止循環表達式在每次循環迭代結束， 在下一個條件檢查之前時執行，通常用來遞增或遞減循環計數。
+
+在下面的例子中，先初始化 `i = 0`，條件 `i < 5` 爲 true 時，進入循環。 每次循環後 `i` 的值增加 `1`，然後執行終止循環條件表達式 `i++`。
+
+```js
+var ourArray = [];
+for (var i = 0; i < 5; i++) {
+ ourArray.push(i);
+}
+```
+
+最終 `ourArray` 的值爲 `[0,1,2,3,4]`.
+
+# --instructions--
+
+使用 `for` 循環把從 1 到 5 添加進 `myArray` 中。
+
+# --hints--
+
+你應該使用 `for` 循環。
+
+```js
+assert(/for\s*\([^)]+?\)/.test(code));
+```
+
+`myArray` 應該等於 `[1,2,3,4,5]`。
+
+```js
+assert.deepEqual(myArray, [1, 2, 3, 4, 5]);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+if (typeof myArray !== "undefined"){(function(){return myArray;})();}
+```
+
+## --seed-contents--
+
+```js
+// Setup
+var myArray = [];
+
+// Only change code below this line
+```
+
+# --solutions--
+
+```js
+var myArray = [];
+for (var i = 1; i < 6; i++) {
+ myArray.push(i);
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-with-javascript-while-loops.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-with-javascript-while-loops.md
new file mode 100644
index 0000000000..928d8d3473
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-with-javascript-while-loops.md
@@ -0,0 +1,73 @@
+---
+id: cf1111c1c11feddfaeb1bdef
+title: while 循環
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c8QbnCM'
+forumTopicId: 18220
+dashedName: iterate-with-javascript-while-loops
+---
+
+# --description--
+
+你可以使用循環多次執行相同的代碼。
+
+我們將學習的第一種類型的循環稱爲 `while` 循環，當 while 指定的條件爲真，循環纔會執行，反之不執行。
+
+```js
+var ourArray = [];
+var i = 0;
+while(i < 5) {
+ ourArray.push(i);
+ i++;
+}
+```
+
+在上面的代碼裏，`while` 循環執行 5 次把 0 到 4 的數字添加到 `ourArray` 數組裏。
+
+讓我們通過 while 循環將值添加到數組中。
+
+# --instructions--
+
+通過一個 `while` 循環，把從 5 到 0（包括 5 和 0） 的值添加到 `myArray` 中。
+
+# --hints--
+
+你應該使用 `while` 循環。
+
+```js
+assert(code.match(/while/g));
+```
+
+`myArray` 應該等於 `[5,4,3,2,1,0]`。
+
+```js
+assert.deepEqual(myArray, [5, 4, 3, 2, 1, 0]);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+if(typeof myArray !== "undefined"){(function(){return myArray;})();}
+```
+
+## --seed-contents--
+
+```js
+// Setup
+var myArray = [];
+
+// Only change code below this line
+```
+
+# --solutions--
+
+```js
+var myArray = [];
+var i = 5;
+while(i >= 0) {
+ myArray.push(i);
+ i--;
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/local-scope-and-functions.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/local-scope-and-functions.md
new file mode 100644
index 0000000000..a288458974
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/local-scope-and-functions.md
@@ -0,0 +1,86 @@
+---
+id: 56533eb9ac21ba0edf2244bf
+title: 局部作用域和函數
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cd62NhM'
+forumTopicId: 18227
+dashedName: local-scope-and-functions
+---
+
+# --description--
+
+在一個函數內聲明的變量，以及該函數的參數都具有局部（local ）作用域。 這意味着它們只在該函數內可見。
+
+這是在函數 `myTest` 內聲明局部變量 `loc` 的例子：
+
+```js
+function myTest() {
+ var loc = "foo";
+ console.log(loc);
+}
+myTest();
+console.log(loc);
+```
+
+`myTest()` 函數調用將在控制檯中顯示字符串 `foo`。 `console.log(loc)` 行會產生一個錯誤，因爲 `loc` 沒有定義在函數之外。
+
+# --instructions--
+
+編輯器有兩個 `console.log` 來幫助您瞭解正在發生的事情。 檢查控制檯的代碼輸出以查看它是如何改變的。 在 `myLocalScope` 中聲明一個本地變量 `myVar` 並運行測試。
+
+**注意：** 控制檯仍將顯示 `ReferenceError: myVar is not defined`，但這不會導致測試失敗。
+
+# --hints--
+
+不應該包含全局的 `myVar` 變量。
+
+```js
+function declared() {
+ myVar;
+}
+assert.throws(declared, ReferenceError);
+```
+
+需要定義局部的 `myVar` 變量。
+
+```js
+assert(
+ /functionmyLocalScope\(\)\{.*(var|let|const)myVar[\s\S]*}/.test(
+ __helpers.removeWhiteSpace(code)
+ )
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function myLocalScope() {
+
+ // Only change code below this line
+
+ console.log('inside myLocalScope', myVar);
+}
+myLocalScope();
+
+// Run and check the console
+// myVar is not defined outside of myLocalScope
+console.log('outside myLocalScope', myVar);
+```
+
+# --solutions--
+
+```js
+function myLocalScope() {
+
+ // Only change code below this line
+ var myVar;
+ console.log('inside myLocalScope', myVar);
+}
+myLocalScope();
+
+// Run and check the console
+// myVar is not defined outside of myLocalScope
+console.log('outside myLocalScope', myVar);
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/logical-order-in-if-else-statements.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/logical-order-in-if-else-statements.md
new file mode 100644
index 0000000000..a1025bbd5e
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/logical-order-in-if-else-statements.md
@@ -0,0 +1,109 @@
+---
+id: 5690307fddb111c6084545d7
+title: if else 語句中的邏輯順序
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cwNvMUV'
+forumTopicId: 18228
+dashedName: logical-order-in-if-else-statements
+---
+
+# --description--
+
+`if`、`else if` 語句中的代碼順序是很重要的。
+
+在條件判斷語句中，代碼的執行順序是從上到下，所以你需要考慮清楚先執行哪一句，後執行哪一句。
+
+這有兩個例子。
+
+第一個例子：
+
+```js
+function foo(x) {
+ if (x < 1) {
+ return "Less than one";
+ } else if (x < 2) {
+ return "Less than two";
+ } else {
+ return "Greater than or equal to two";
+ }
+}
+```
+
+第二個例子更改了代碼的執行順序：
+
+```js
+function bar(x) {
+ if (x < 2) {
+ return "Less than two";
+ } else if (x < 1) {
+ return "Less than one";
+ } else {
+ return "Greater than or equal to two";
+ }
+}
+```
+
+這兩個函數看起來幾乎一模一樣，我們傳一個值進去看看它們有什麼區別。
+
+```js
+foo(0)
+bar(0)
+```
+
+`foo(0)` 將返回字符串 `Less than one`，`bar(0)` 將返回字符串 `Less than two`。
+
+# --instructions--
+
+更改函數的邏輯順序以便通過所有的測試用例。
+
+# --hints--
+
+`orderMyLogic(4)` 應該返回字符串 `Less than 5`
+
+```js
+assert(orderMyLogic(4) === 'Less than 5');
+```
+
+`orderMyLogic(6)` 應該返回字符串 `Less than 10`
+
+```js
+assert(orderMyLogic(6) === 'Less than 10');
+```
+
+`orderMyLogic(11)`應該返回 `Greater than or equal to 10`。
+
+```js
+assert(orderMyLogic(11) === 'Greater than or equal to 10');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function orderMyLogic(val) {
+ if (val < 10) {
+ return "Less than 10";
+ } else if (val < 5) {
+ return "Less than 5";
+ } else {
+ return "Greater than or equal to 10";
+ }
+}
+
+orderMyLogic(7);
+```
+
+# --solutions--
+
+```js
+function orderMyLogic(val) {
+ if(val < 5) {
+ return "Less than 5";
+ } else if (val < 10) {
+ return "Less than 10";
+ } else {
+ return "Greater than or equal to 10";
+ }
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/manipulate-arrays-with-pop.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/manipulate-arrays-with-pop.md
new file mode 100644
index 0000000000..e051220d18
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/manipulate-arrays-with-pop.md
@@ -0,0 +1,90 @@
+---
+id: 56bbb991ad1ed5201cd392cc
+title: 使用 pop() 操作數組
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cRbVZAB'
+forumTopicId: 18236
+dashedName: manipulate-arrays-with-pop
+---
+
+# --description--
+
+改變數組中數據的另一種方法是用 `.pop()` 函數。
+
+`.pop()` 函數用來彈出一個數組末尾的值。 我們可以把這個彈出的值賦給一個變量存儲起來。 換句話說就是 `.pop()` 函數移除數組末尾的元素並返回這個元素。
+
+數組中任何類型的元素（數值，字符串，甚至是數組）都可以被彈出來 。
+
+```js
+var threeArr = [1, 4, 6];
+var oneDown = threeArr.pop();
+console.log(oneDown);
+console.log(threeArr);
+```
+
+第一個 `console.log` 將顯示值 `6`，第二個將顯示值 `[1, 4]`。
+
+# --instructions--
+
+使用 `.pop()` 函數移除 `myArray` 中的最後一個元素，並且把彈出的值賦給 `removedFromMyArray`。
+
+# --hints--
+
+`myArray` 應該只包含 `[["John", 23]]`。
+
+```js
+assert(
+ (function (d) {
+ if (d[0][0] == 'John' && d[0][1] === 23 && d[1] == undefined) {
+ return true;
+ } else {
+ return false;
+ }
+ })(myArray)
+);
+```
+
+對 `myArray` 使用 `pop()` 函數。
+
+```js
+assert(/removedFromMyArray\s*=\s*myArray\s*.\s*pop\s*(\s*)/.test(code));
+```
+
+`removedFromMyArray` 應該只包含 `["cat", 2]`。
+
+```js
+assert(
+ (function (d) {
+ if (d[0] == 'cat' && d[1] === 2 && d[2] == undefined) {
+ return true;
+ } else {
+ return false;
+ }
+ })(removedFromMyArray)
+);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(y, z){return 'myArray = ' + JSON.stringify(y) + ' & removedFromMyArray = ' + JSON.stringify(z);})(myArray, removedFromMyArray);
+```
+
+## --seed-contents--
+
+```js
+// Setup
+var myArray = [["John", 23], ["cat", 2]];
+
+// Only change code below this line
+var removedFromMyArray;
+```
+
+# --solutions--
+
+```js
+var myArray = [["John", 23], ["cat", 2]];
+var removedFromMyArray = myArray.pop();
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/manipulate-arrays-with-push.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/manipulate-arrays-with-push.md
new file mode 100644
index 0000000000..777ce483d8
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/manipulate-arrays-with-push.md
@@ -0,0 +1,77 @@
+---
+id: 56bbb991ad1ed5201cd392cb
+title: 使用 push() 操作數組
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cnqmVtJ'
+forumTopicId: 18237
+dashedName: manipulate-arrays-with-push
+---
+
+# --description--
+
+一個將數據添加到數組末尾的簡單方法是 `push()` 函數。
+
+`.push()` 接受一個或多個參數（parameters ），並把它壓入到數組的末尾。
+
+示例：
+
+```js
+var arr1 = [1,2,3];
+arr1.push(4);
+
+var arr2 = ["Stimpson", "J", "cat"];
+arr2.push(["happy", "joy"]);
+```
+
+`arr1` 現在值爲 `[1, 2, 3, 4]`，`arr2` 值爲 `["Stimpson", "J", "cat", ["happy", "joy"]]`。
+
+# --instructions--
+
+把`["dog", 3]` 壓入到 `myArray` 變量的末尾。
+
+# --hints--
+
+`myArray` 現在應該等於 `[["John", 23], ["cat", 2], ["dog", 3]]`。
+
+```js
+assert(
+ (function (d) {
+ if (
+ d[2] != undefined &&
+ d[0][0] == 'John' &&
+ d[0][1] === 23 &&
+ d[2][0] == 'dog' &&
+ d[2][1] === 3 &&
+ d[2].length == 2
+ ) {
+ return true;
+ } else {
+ return false;
+ }
+ })(myArray)
+);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(z){return 'myArray = ' + JSON.stringify(z);})(myArray);
+```
+
+## --seed-contents--
+
+```js
+// Setup
+var myArray = [["John", 23], ["cat", 2]];
+
+// Only change code below this line
+```
+
+# --solutions--
+
+```js
+var myArray = [["John", 23], ["cat", 2]];
+myArray.push(["dog",3]);
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/manipulate-arrays-with-shift.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/manipulate-arrays-with-shift.md
new file mode 100644
index 0000000000..76d260f0dc
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/manipulate-arrays-with-shift.md
@@ -0,0 +1,88 @@
+---
+id: 56bbb991ad1ed5201cd392cd
+title: 使用 shift() 操作數組
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cRbVETW'
+forumTopicId: 18238
+dashedName: manipulate-arrays-with-shift
+---
+
+# --description--
+
+`pop()` 函數用來移出數組中最後一個元素。 如果想要移出第一個元素要怎麼辦呢？
+
+這時候我們就需要 `.shift()` 了。 它的工作原理就像 `.pop()`，但它移除的是第一個元素，而不是最後一個。
+
+示例：
+
+```js
+var ourArray = ["Stimpson", "J", ["cat"]];
+var removedFromOurArray = ourArray.shift();
+```
+
+`removedFromOurArray` 值爲 `Stimpson`，`ourArray` 值爲 `["J", ["cat"]]`
+
+# --instructions--
+
+使用 `.shift()` 函數移除 `myArray` 中的第一項，並把移出的值賦給 `removedFromMyArray`。
+
+# --hints--
+
+`myArray` 應該只包含 `[["dog", 3]]`。
+
+```js
+assert(
+ (function (d) {
+ if (d[0][0] == 'dog' && d[0][1] === 3 && d[1] == undefined) {
+ return true;
+ } else {
+ return false;
+ }
+ })(myArray)
+);
+```
+
+`removedFromMyArray` 應該包含 `["John", 23]`。
+
+```js
+assert(
+ (function (d) {
+ if (
+ d[0] == 'John' &&
+ d[1] === 23 &&
+ typeof removedFromMyArray === 'object'
+ ) {
+ return true;
+ } else {
+ return false;
+ }
+ })(removedFromMyArray)
+);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(y, z){return 'myArray = ' + JSON.stringify(y) + ' & removedFromMyArray = ' + JSON.stringify(z);})(myArray, removedFromMyArray);
+```
+
+## --seed-contents--
+
+```js
+// Setup
+var myArray = [["John", 23], ["dog", 3]];
+
+// Only change code below this line
+var removedFromMyArray;
+```
+
+# --solutions--
+
+```js
+var myArray = [["John", 23], ["dog", 3]];
+
+// Only change code below this line
+var removedFromMyArray = myArray.shift();
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/manipulate-arrays-with-unshift.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/manipulate-arrays-with-unshift.md
new file mode 100644
index 0000000000..02f0cc9953
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/manipulate-arrays-with-unshift.md
@@ -0,0 +1,78 @@
+---
+id: 56bbb991ad1ed5201cd392ce
+title: 使用 unshift() 操作數組
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/ckNDESv'
+forumTopicId: 18239
+dashedName: manipulate-arrays-with-unshift
+---
+
+# --description--
+
+不僅可以 `shift`（移出）數組中的第一個元素，也可以 `unshift`（移入）一個元素到數組的頭部。
+
+`.unshift()` 函數用起來就像 `.push()` 函數一樣，但不是在數組的末尾添加元素，`unshift()` 在數組的頭部添加元素。
+
+示例：
+
+```js
+var ourArray = ["Stimpson", "J", "cat"];
+ourArray.shift();
+ourArray.unshift("Happy");
+```
+
+在 `shift`、`ourArray` 後值爲 `["J", "cat"]`。 在 `unshift`、`ourArray` 後值爲 `["Happy", "J", "cat"]`。
+
+# --instructions--
+
+使用 `unshift()` 函數把 `["Paul",35]` 加入到 `myArray` 的頭部。
+
+# --hints--
+
+`myArray` 現在應該等於 `[["Paul", 35], ["dog", 3]]`。
+
+```js
+assert(
+ (function (d) {
+ if (
+ typeof d[0] === 'object' &&
+ d[0][0] == 'Paul' &&
+ d[0][1] === 35 &&
+ d[1][0] != undefined &&
+ d[1][0] == 'dog' &&
+ d[1][1] != undefined &&
+ d[1][1] == 3
+ ) {
+ return true;
+ } else {
+ return false;
+ }
+ })(myArray)
+);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(y, z){return 'myArray = ' + JSON.stringify(y);})(myArray);
+```
+
+## --seed-contents--
+
+```js
+// Setup
+var myArray = [["John", 23], ["dog", 3]];
+myArray.shift();
+
+// Only change code below this line
+```
+
+# --solutions--
+
+```js
+var myArray = [["John", 23], ["dog", 3]];
+myArray.shift();
+myArray.unshift(["Paul", 35]);
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/manipulating-complex-objects.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/manipulating-complex-objects.md
new file mode 100644
index 0000000000..531e08396f
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/manipulating-complex-objects.md
@@ -0,0 +1,176 @@
+---
+id: 56533eb9ac21ba0edf2244cb
+title: 操作複雜對象
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c9yNMfR'
+forumTopicId: 18208
+dashedName: manipulating-complex-objects
+---
+
+# --description--
+
+有時你可能希望將數據存儲在一個靈活的數據結構（Data Structure ）中。 JavaScript 對象是一種靈活的數據結構。 它可以儲存字符串（strings ）、數字（numbers ）、布爾值（booleans ）、數組（arrays ）、函數（functions ）和對象（objects ）以及這些值的任意組合。
+
+這是一個複雜數據結構的示例：
+
+```js
+var ourMusic = [
+ {
+ "artist": "Daft Punk",
+ "title": "Homework",
+ "release_year": 1997,
+ "formats": [
+ "CD",
+ "Cassette",
+ "LP"
+ ],
+ "gold": true
+ }
+];
+```
+
+這是一個包含一個對象的數組。 該對象有關於專輯的各種元數據（metadata ）。 它也有一個嵌套的 `formats` 數組。 可以將專輯添加到頂級數組來增加更多的專輯記錄。 對象將數據以一種鍵 - 值對的形式保存。 在上面的示例中，`"artist": "Daft Punk"` 有一個鍵位 `artist` 值爲 `Daft Punk` 的屬性。 [JavaScript Object Notation](http://www.json.org/) 簡稱 `JSON` 是可以用於存儲數據的數據交換格式。
+
+```json
+{
+ "artist": "Daft Punk",
+ "title": "Homework",
+ "release_year": 1997,
+ "formats": [
+ "CD",
+ "Cassette",
+ "LP"
+ ],
+ "gold": true
+}
+```
+
+**提示：**數組中有多個 JSON 對象的時候，對象與對象之間要用逗號隔開。
+
+# --instructions--
+
+添加一個新專輯到 `myMusic` 數組。 添加 `artist` 和 `title` 字符串，`release_year` 數字和 `formats` 字符串數組。
+
+# --hints--
+
+`myMusic` 應該是一個數組
+
+```js
+assert(Array.isArray(myMusic));
+```
+
+`myMusic` 應該至少包含兩個元素
+
+```js
+assert(myMusic.length > 1);
+```
+
+`myMusic[1]` 應該是一個對象
+
+```js
+assert(typeof myMusic[1] === 'object');
+```
+
+`myMusic[1]` 至少要包含四個屬性
+
+```js
+assert(Object.keys(myMusic[1]).length > 3);
+```
+
+`myMusic[1]` 應該包含一個類型爲字符串的 `artist` 的屬性
+
+```js
+assert(
+ myMusic[1].hasOwnProperty('artist') && typeof myMusic[1].artist === 'string'
+);
+```
+
+`myMusic[1]` 應該包含一個類型爲字符串的 `title` 屬性
+
+```js
+assert(
+ myMusic[1].hasOwnProperty('title') && typeof myMusic[1].title === 'string'
+);
+```
+
+`myMusic[1]` 應該包含一個類型爲數字的 `release_year` 屬性
+
+```js
+assert(
+ myMusic[1].hasOwnProperty('release_year') &&
+ typeof myMusic[1].release_year === 'number'
+);
+```
+
+`myMusic[1]` 應該包含一個類型爲數組的 `formats` 屬性
+
+```js
+assert(
+ myMusic[1].hasOwnProperty('formats') && Array.isArray(myMusic[1].formats)
+);
+```
+
+`formats`應該是一個至少包含兩個字符串元素的數組
+
+```js
+assert(
+ myMusic[1].formats.every(function (item) {
+ return typeof item === 'string';
+ }) && myMusic[1].formats.length > 1
+);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(x){ if (Array.isArray(x)) { return JSON.stringify(x); } return "myMusic is not an array"})(myMusic);
+```
+
+## --seed-contents--
+
+```js
+var myMusic = [
+ {
+ "artist": "Billy Joel",
+ "title": "Piano Man",
+ "release_year": 1973,
+ "formats": [
+ "CD",
+ "8T",
+ "LP"
+ ],
+ "gold": true
+ }
+ // Add a record here
+];
+```
+
+# --solutions--
+
+```js
+var myMusic = [
+ {
+ "artist": "Billy Joel",
+ "title": "Piano Man",
+ "release_year": 1973,
+ "formats": [
+ "CS",
+ "8T",
+ "LP" ],
+ "gold": true
+ },
+ {
+ "artist": "ABBA",
+ "title": "Ring Ring",
+ "release_year": 1973,
+ "formats": [
+ "CS",
+ "8T",
+ "LP",
+ "CD",
+ ]
+ }
+];
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/modify-array-data-with-indexes.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/modify-array-data-with-indexes.md
new file mode 100644
index 0000000000..f5cd6dc5b3
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/modify-array-data-with-indexes.md
@@ -0,0 +1,86 @@
+---
+id: cf1111c1c11feddfaeb8bdef
+title: 通過索引修改數組中的數據
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/czQM4A8'
+forumTopicId: 18241
+dashedName: modify-array-data-with-indexes
+---
+
+# --description--
+
+與字符串的數據不可變不同，數組的數據是可變的（ mutable ），可以自由地改變。
+
+**示例**
+
+```js
+var ourArray = [50,40,30];
+ourArray[0] = 15;
+```
+
+`ourArray` 值爲 `[15, 40, 30]`。
+
+**注意：**數組名與方括號之間不應該有任何空格，比如`array [0]` 。 儘管 JavaScript 能夠正確處理這種情況，但是當其他程序員閱讀你寫的代碼時，這可能讓他們感到困惑。
+
+# --instructions--
+
+將數組 `myArray`中索引爲 `0`上的值修改爲 `45`。
+
+# --hints--
+
+`myArray` 應該等於 `[45,64,99]`。
+
+```js
+assert(
+ (function () {
+ if (
+ typeof myArray != 'undefined' &&
+ myArray[0] == 45 &&
+ myArray[1] == 64 &&
+ myArray[2] == 99
+ ) {
+ return true;
+ } else {
+ return false;
+ }
+ })()
+);
+```
+
+你應該使用正確的索引修改 `myArray` 的值。
+
+```js
+assert(
+ (function () {
+ if (code.match(/myArray\[0\]\s*=\s*/g)) {
+ return true;
+ } else {
+ return false;
+ }
+ })()
+);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+if(typeof myArray !== "undefined"){(function(){return myArray;})();}
+```
+
+## --seed-contents--
+
+```js
+// Setup
+var myArray = [18,64,99];
+
+// Only change code below this line
+```
+
+# --solutions--
+
+```js
+var myArray = [18,64,99];
+myArray[0] = 45;
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/multiple-identical-options-in-switch-statements.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/multiple-identical-options-in-switch-statements.md
new file mode 100644
index 0000000000..fbe5f63ad5
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/multiple-identical-options-in-switch-statements.md
@@ -0,0 +1,149 @@
+---
+id: 56533eb9ac21ba0edf2244df
+title: 在 Switch 語句添加多個相同選項
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cdBKWCV'
+forumTopicId: 18242
+dashedName: multiple-identical-options-in-switch-statements
+---
+
+# --description--
+
+如果你忘了給 `switch` 的每一條 `case` 添加 `break`，那麼後續的 `case` 會一直執行，直到遇見 `break` 爲止。 如果你想爲 `switch` 中的多個不同的輸入設置相同的結果，可以這樣寫：
+
+```js
+var result = "";
+switch(val) {
+ case 1:
+ case 2:
+ case 3:
+ result = "1, 2, or 3";
+ break;
+ case 4:
+ result = "4 alone";
+}
+```
+
+這樣，1、2、3 都會有相同的結果。
+
+# --instructions--
+
+請寫一個 switch 語句，按如下條件設置 `answer` ：
+`1-3` - `Low`
+`4-6` - `Mid`
+`7-9` - `High`
+
+**提示：** 你的 `case` 應寫全範圍中的每一個數字。
+
+# --hints--
+
+`sequentialSizes(1)` 應該返回字符串 `Low`
+
+```js
+assert(sequentialSizes(1) === 'Low');
+```
+
+`sequentialSizes(2)` 應該返回字符串 `Low`
+
+```js
+assert(sequentialSizes(2) === 'Low');
+```
+
+`sequentialSizes(3)` 應該返回字符串 `Low`
+
+```js
+assert(sequentialSizes(3) === 'Low');
+```
+
+`sequentialSizes(4)` 應該返回字符串 `Mid`
+
+```js
+assert(sequentialSizes(4) === 'Mid');
+```
+
+`sequentialSizes(5)` 應該返回字符串 `Mid`
+
+```js
+assert(sequentialSizes(5) === 'Mid');
+```
+
+`sequentialSizes(6)` 應該返回字符串 `Mid`
+
+```js
+assert(sequentialSizes(6) === 'Mid');
+```
+
+`sequentialSizes(7)` 應該返回字符串 `High`
+
+```js
+assert(sequentialSizes(7) === 'High');
+```
+
+`sequentialSizes(8)` 應該返回字符串 `High`
+
+```js
+assert(sequentialSizes(8) === 'High');
+```
+
+`sequentialSizes(9)` 應該返回字符串 `High`
+
+```js
+assert(sequentialSizes(9) === 'High');
+```
+
+你不應使用 `if` 或 `else` 語句。
+
+```js
+assert(!/else/g.test(code) || !/if/g.test(code));
+```
+
+你應該編寫 9 個`case`語句。
+
+```js
+assert(code.match(/case/g).length === 9);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function sequentialSizes(val) {
+ var answer = "";
+ // Only change code below this line
+
+
+
+ // Only change code above this line
+ return answer;
+}
+
+sequentialSizes(1);
+```
+
+# --solutions--
+
+```js
+function sequentialSizes(val) {
+ var answer = "";
+
+ switch(val) {
+ case 1:
+ case 2:
+ case 3:
+ answer = "Low";
+ break;
+ case 4:
+ case 5:
+ case 6:
+ answer = "Mid";
+ break;
+ case 7:
+ case 8:
+ case 9:
+ answer = "High";
+ }
+
+ return answer;
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/multiply-two-decimals-with-javascript.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/multiply-two-decimals-with-javascript.md
new file mode 100644
index 0000000000..c3cfa69726
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/multiply-two-decimals-with-javascript.md
@@ -0,0 +1,52 @@
+---
+id: bd7993c9c69feddfaeb7bdef
+title: 兩個小數相乘
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/ce2GeHq'
+forumTopicId: 301173
+dashedName: multiply-two-decimals-with-javascript
+---
+
+# --description--
+
+在 JavaScript 中，你也可以用小數進行計算，就像整數一樣。
+
+把兩個小數相乘，並得到它們乘積。
+
+# --instructions--
+
+改變 `0.0` 的數值讓變量 product 的值等於 `5.0`。
+
+# --hints--
+
+變量 `product` 應該等於 `5.0`。
+
+```js
+assert(product === 5.0);
+```
+
+要使用 `*` 運算符。
+
+```js
+assert(/\*/.test(code));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(y){return 'product = '+y;})(product);
+```
+
+## --seed-contents--
+
+```js
+var product = 2.0 * 0.0;
+```
+
+# --solutions--
+
+```js
+var product = 2.0 * 2.5;
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/multiply-two-numbers-with-javascript.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/multiply-two-numbers-with-javascript.md
new file mode 100644
index 0000000000..f1a95ec822
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/multiply-two-numbers-with-javascript.md
@@ -0,0 +1,60 @@
+---
+id: cf1231c1c11feddfaeb5bdef
+title: 乘法運算
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cP3y3Aq'
+forumTopicId: 18243
+dashedName: multiply-two-numbers-with-javascript
+---
+
+# --description--
+
+我們也可在 JavaScript 中使用乘法運算。
+
+JavaScript 使用 `*` 符號表示兩數相乘。
+
+**示例**
+
+```js
+myVar = 13 * 13;
+```
+
+現在，變量 `myVar` 的值爲 `169`。
+
+# --instructions--
+
+改變數值 `0`來讓變量 product 的值等於`80`。
+
+# --hints--
+
+變量 `product` 的值應該等於 80。
+
+```js
+assert(product === 80);
+```
+
+使用 `*` 運算符。
+
+```js
+assert(/\*/.test(code));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(z){return 'product = '+z;})(product);
+```
+
+## --seed-contents--
+
+```js
+var product = 8 * 0;
+```
+
+# --solutions--
+
+```js
+var product = 8 * 10;
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/nest-one-array-within-another-array.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/nest-one-array-within-another-array.md
new file mode 100644
index 0000000000..1d1a824772
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/nest-one-array-within-another-array.md
@@ -0,0 +1,51 @@
+---
+id: cf1111c1c11feddfaeb7bdef
+title: 將一個數組嵌套在另一個數組中
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/crZQZf8'
+forumTopicId: 18247
+dashedName: nest-one-array-within-another-array
+---
+
+# --description--
+
+您也可以在其他數組中嵌套數組，如：
+
+```js
+[["Bulls", 23], ["White Sox", 45]]
+```
+
+這也叫做多維數組（multi-dimensional array ）。
+
+# --instructions--
+
+創建一個名爲 `myArray` 的嵌套數組。
+
+# --hints--
+
+`myArray` 應該至少有一個數組嵌套在另一個數組中。
+
+```js
+assert(Array.isArray(myArray) && myArray.some(Array.isArray));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+if(typeof myArray !== "undefined"){(function(){return myArray;})();}
+```
+
+## --seed-contents--
+
+```js
+// Only change code below this line
+var myArray = [];
+```
+
+# --solutions--
+
+```js
+var myArray = [[1,2,3]];
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/nesting-for-loops.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/nesting-for-loops.md
new file mode 100644
index 0000000000..40312fd54a
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/nesting-for-loops.md
@@ -0,0 +1,93 @@
+---
+id: 56533eb9ac21ba0edf2244e1
+title: 循環嵌套
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cRn6GHM'
+forumTopicId: 18248
+dashedName: nesting-for-loops
+---
+
+# --description--
+
+如果你有一個二維數組，可以使用相同的邏輯，先遍歷外面的數組，再遍歷裏面的子數組。 下面是一個例子：
+
+```js
+var arr = [
+ [1,2], [3,4], [5,6]
+];
+for (var i=0; i < arr.length; i++) {
+ for (var j=0; j < arr[i].length; j++) {
+ console.log(arr[i][j]);
+ }
+}
+```
+
+這裏一次輸出了 `arr` 中的每個子元素。 提示，對於內部循環，我們可以通過 `arr[i]` 的 `.length` 來獲得子數組的長度，因爲 `arr[i]` 本身就是一個數組。
+
+# --instructions--
+
+修改函數 `multiplyAll`，獲得 `arr` 內部數組的每個數字相乘的結果 product。
+
+# --hints--
+
+`multiplyAll([[1],[2],[3]])` 應該返回 `6`
+
+```js
+assert(multiplyAll([[1], [2], [3]]) === 6);
+```
+
+`multiplyAll([[1,2],[3,4],[5,6,7]])` 應該返回 `5040`
+
+```js
+assert(
+ multiplyAll([
+ [1, 2],
+ [3, 4],
+ [5, 6, 7]
+ ]) === 5040
+);
+```
+
+`multiplyAll([[5,1],[0.2, 4, 0.5],[3, 9]])` 應該返回 `54`
+
+```js
+assert(
+ multiplyAll([
+ [5, 1],
+ [0.2, 4, 0.5],
+ [3, 9]
+ ]) === 54
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function multiplyAll(arr) {
+ var product = 1;
+ // Only change code below this line
+
+ // Only change code above this line
+ return product;
+}
+
+multiplyAll([[1,2],[3,4],[5,6,7]]);
+```
+
+# --solutions--
+
+```js
+function multiplyAll(arr) {
+ var product = 1;
+ for (var i = 0; i < arr.length; i++) {
+ for (var j = 0; j < arr[i].length; j++) {
+ product *= arr[i][j];
+ }
+ }
+ return product;
+}
+
+multiplyAll([[1,2],[3,4],[5,6,7]]);
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/passing-values-to-functions-with-arguments.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/passing-values-to-functions-with-arguments.md
new file mode 100644
index 0000000000..634b713ee8
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/passing-values-to-functions-with-arguments.md
@@ -0,0 +1,120 @@
+---
+id: 56533eb9ac21ba0edf2244bd
+title: 將值傳遞給帶有參數的函數
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cy8rahW'
+forumTopicId: 18254
+dashedName: passing-values-to-functions-with-arguments
+---
+
+# --description--
+
+函數的參數 （parameters ）在函數中充當調用函數時傳入函數的輸入佔位符（也叫形參）的作用。 函數調用時，參數可以爲一個或多個。 調用函數時輸入（或傳遞 "passed" ）的實際值被稱爲參數（arguments ）。
+
+這是帶有兩個參數的函數，`param1` 和 `param2`：
+
+```js
+function testFun(param1, param2) {
+ console.log(param1, param2);
+}
+```
+
+然後我們可以調用 `testFun`，就像這樣： `testFun("Hello", "World");`。 我們傳入了兩個字符串參數， `Hello` 和`World`。 在函數中，`param1` 等於字符串 `Hello` 和 `param2` 等於字符串 `World`。 請注意，`testFun` 函數可以多次調用，每次調用時傳遞的參數會決定參數的實際值。
+
+# --instructions--
+
+創建一個名爲 functionWithArgs 的函數，它可以接收兩個參數，計算參數的和，將結果輸出到控制檯。 用兩個數字作爲參數調用函數。 字符串 可以使用開始和結束都是同類型的單引號或雙引號表示。 與其他一些編程語言不同的是，單引號和雙引號的功能在 JavaScript 中是相同的。
+
+```js
+doubleQuoteStr = "This is a string";
+singleQuoteStr = 'This is also a string';
+```
+
+當你需要在一個字符串中使用多個引號的時候，你可以使用單引號包裹雙引號或者相反。 常見的場景比如在字符串中包含對話的句子需要用引號包裹。 另外比如在一個包含有 `` 標籤的字符串中，標籤的屬性值需要用引號包裹。
+
+```js
+conversation = 'Finn exclaims to Jake, "Algebraic!"';
+```
+
+然而，如果你需要在其中使用外面的引號，這就成爲一個問題。 記住，一個字符串在開頭和結尾處有相同的引號。 要知道，字符串在開頭和結尾都有相同的引號，如果在中間使用了相同的引號，字符串會提前中止並拋出錯誤。
+
+```js
+goodStr = 'Jake asks Finn, "Hey, let\'s go on an adventure?"';
+badStr = 'Finn responds, "Let's go!"';
+```
+
+在這裏 `badStr` 會產生一個錯誤。
+
+在上面的 goodStr 中，通過使用反斜槓 `\` 轉義字符可以安全地使用兩種引號。
+
+**提示：**不要混淆反斜槓 `\` 和斜槓 `/`。 它們不是一回事。
+
+# --instructions--
+
+把字符串更改爲開頭和結尾使用單引號的字符串，並且不包含轉義字符。
+
+這樣字符串中的 ` ` 標籤裏面任何地方都可以使用雙引號。 你需要將最外層引號更改爲單引號，以便刪除轉義字符。
+
+# --hints--
+
+應該刪除所有反斜槓（`\`）。
+
+```js
+assert(
+ !/\\/g.test(code) &&
+ myStr.match(
+ '\\s* \\s*Link\\s* \\s*'
+ )
+);
+```
+
+應該要有兩個單引號 `'` 和四個雙引號 `"`。
+
+```js
+assert(code.match(/"/g).length === 4 && code.match(/'/g).length === 2);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function() { return "myStr = " + myStr; })();
+```
+
+## --seed-contents--
+
+```js
+var myStr = "Link ";
+```
+
+# --solutions--
+
+```js
+var myStr = 'Link ';
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/record-collection.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/record-collection.md
new file mode 100644
index 0000000000..6ede9ad2ee
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/record-collection.md
@@ -0,0 +1,181 @@
+---
+id: 56533eb9ac21ba0edf2244cf
+title: 記錄集合
+challengeType: 1
+forumTopicId: 18261
+dashedName: record-collection
+---
+
+# --description--
+
+給定一個 JSON 對象，用來表示部分音樂專輯收藏。 每張專輯都有幾個屬性和一個唯一的 id 號作爲鍵值。 並非所有專輯都有完整的信息。
+
+以 `updateRecords` 函數開使，這個函數需要一個對象如 `collection`，一個 `id`，一個 `prop` (如 `artist` 或 `tracks`), 和 `value`。 使用下面的規則完成函數來修改傳遞給函數的對象。
+
+- 你的函數必須始終返回整個對象。
+- 如果 `prop` 不是 `tracks` 並且 `value` 不是一個空字符串， 將相冊的 `prop` 更新或設置爲 `value`。
+- 如果 `prop` 是 `tracks` 但專輯沒有 `tracks` 屬性，則應創建空數組併爲其添加 `value`。
+- 如果 `prop` 是 `tracks` 並且 `value` 不是一個空字符串，將 `value` 添加到相冊現有 `tracks` 數組的末尾。
+- 如果 `value` 是空字符串，從專輯裏刪除指定的 `prop`。
+
+**注意：** 用 `collection` 對象做爲測試參數對象。
+
+# --hints--
+
+執行 `updateRecords(collection, 5439, "artist", "ABBA")` 後, `artist` 應該是字符串 `ABBA`
+
+```js
+assert(
+ updateRecords(_recordCollection, 5439, 'artist', 'ABBA')[5439]['artist'] ===
+ 'ABBA'
+);
+```
+
+執行 `updateRecords(collection, 5439, "tracks", "Take a Chance on Me")` 後，`tracks` 的最後一個元素應該爲字符串 `Take a Chance on Me`。
+
+```js
+assert(
+ updateRecords(_recordCollection, 5439, 'tracks', 'Take a Chance on Me')[5439][
+ 'tracks'
+ ].pop() === 'Take a Chance on Me'
+);
+```
+
+執行 `updateRecords(collection, 2548, "artist", "")` 後， `artist` 不應被設置
+
+```js
+updateRecords(_recordCollection, 2548, 'artist', '');
+assert(!_recordCollection[2548].hasOwnProperty('artist'));
+```
+
+執行 `updateRecords(collection, 1245, "tracks", "Addicted to Love")` 後，`tracks` 的最後一個元素應該爲字符串 `Addicted to Love`。
+
+```js
+assert(
+ updateRecords(_recordCollection, 1245, 'tracks', 'Addicted to Love')[1245][
+ 'tracks'
+ ].pop() === 'Addicted to Love'
+);
+```
+
+執行 `updateRecords(collection, 2468, "tracks", "Free")` 後，`tracks` 的第一個元素應該爲字符串 `1999`。
+
+```js
+assert(
+ updateRecords(_recordCollection, 2468, 'tracks', 'Free')[2468][
+ 'tracks'
+ ][0] === '1999'
+);
+```
+
+執行 `updateRecords(collection, 2548, "tracks", "")` 後， `tracks` 不應被設置
+
+```js
+updateRecords(_recordCollection, 2548, 'tracks', '');
+assert(!_recordCollection[2548].hasOwnProperty('tracks'));
+```
+
+執行 `updateRecords(collection, 1245, "albumTitle", "Riptide")` 後, `albumTitle` 應該是字符串 `Riptide`
+
+```js
+assert(
+ updateRecords(_recordCollection, 1245, 'albumTitle', 'Riptide')[1245][
+ 'albumTitle'
+ ] === 'Riptide'
+);
+```
+
+# --seed--
+
+## --before-user-code--
+
+```js
+const _recordCollection = {
+ 2548: {
+ albumTitle: 'Slippery When Wet',
+ artist: 'Bon Jovi',
+ tracks: ['Let It Rock', 'You Give Love a Bad Name']
+ },
+ 2468: {
+ albumTitle: '1999',
+ artist: 'Prince',
+ tracks: ['1999', 'Little Red Corvette']
+ },
+ 1245: {
+ artist: 'Robert Palmer',
+ tracks: []
+ },
+ 5439: {
+ albumTitle: 'ABBA Gold'
+ }
+};
+```
+
+## --seed-contents--
+
+```js
+// Setup
+var collection = {
+ 2548: {
+ albumTitle: 'Slippery When Wet',
+ artist: 'Bon Jovi',
+ tracks: ['Let It Rock', 'You Give Love a Bad Name']
+ },
+ 2468: {
+ albumTitle: '1999',
+ artist: 'Prince',
+ tracks: ['1999', 'Little Red Corvette']
+ },
+ 1245: {
+ artist: 'Robert Palmer',
+ tracks: []
+ },
+ 5439: {
+ albumTitle: 'ABBA Gold'
+ }
+};
+
+// Only change code below this line
+function updateRecords(object, id, prop, value) {
+ return object;
+}
+
+updateRecords(collection, 5439, 'artist', 'ABBA');
+```
+
+# --solutions--
+
+```js
+var collection = {
+ 2548: {
+ albumTitle: 'Slippery When Wet',
+ artist: 'Bon Jovi',
+ tracks: ['Let It Rock', 'You Give Love a Bad Name']
+ },
+ 2468: {
+ albumTitle: '1999',
+ artist: 'Prince',
+ tracks: ['1999', 'Little Red Corvette']
+ },
+ 1245: {
+ artist: 'Robert Palmer',
+ tracks: []
+ },
+ 5439: {
+ albumTitle: 'ABBA Gold'
+ }
+};
+
+// Only change code below this line
+function updateRecords(object, id, prop, value) {
+ if (value === '') delete object[id][prop];
+ else if (prop === 'tracks') {
+ object[id][prop] = object[id][prop] || [];
+ object[id][prop].push(value);
+ } else {
+ object[id][prop] = value;
+ }
+
+ return object;
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/replace-loops-using-recursion.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/replace-loops-using-recursion.md
new file mode 100644
index 0000000000..b0f92e916b
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/replace-loops-using-recursion.md
@@ -0,0 +1,105 @@
+---
+id: 5cfa3679138e7d9595b9d9d4
+title: 使用遞歸代替循環
+challengeType: 1
+videoUrl: >-
+ https://www.freecodecamp.org/news/how-recursion-works-explained-with-flowcharts-and-a-video-de61f40cb7f9/
+forumTopicId: 301175
+dashedName: replace-loops-using-recursion
+---
+
+# --description--
+
+遞歸是函數調用自身的操作。 爲了便於理解，有如下任務：計算數組內元素前 `n` 的元素乘積。 使用 `for` 循環， 可以這樣做：
+
+```js
+ function multiply(arr, n) {
+ var product = 1;
+ for (var i = 0; i < n; i++) {
+ product *= arr[i];
+ }
+ return product;
+ }
+```
+
+下面是遞歸寫法，注意代碼裏的 `multiply(arr, n) == multiply(arr, n - 1) * arr[n - 1]`。 這意味着可以重寫 `multiply` 以調用自身而無需依賴循環。
+
+```js
+ function multiply(arr, n) {
+ if (n <= 0) {
+ return 1;
+ } else {
+ return multiply(arr, n - 1) * arr[n - 1];
+ }
+ }
+```
+
+遞歸版本的 `multiply` 詳述如下。 在 base case 裏，也就是 `n <= 0` 時，返回 1。 在 `n` 比 0 大的情況裏，函數會調用自身，參數 n 的值爲 `n - 1`。 函數以相同的方式持續調用 `multiply`，直到 `n <= 0` 爲止。 所以，所有函數都可以返回，原始的 `multiply` 返回結果。
+
+**注意：** 遞歸函數在沒有函數調用時（在這個例子是，是當 `n <= 0` 時）必需有一個跳出結構，否則永遠不會執行完畢。
+
+# --instructions--
+
+寫一個遞歸函數，`sum(arr, n)`，返回遞歸調用數組 `arr` 從前 `n` 個元素和。
+
+# --hints--
+
+`sum([1], 0)` 應該返回 0 。
+
+```js
+assert.equal(sum([1], 0), 0);
+```
+
+`sum([2, 3, 4], 1)` 應該返回 2 。
+
+```js
+assert.equal(sum([2, 3, 4], 1), 2);
+```
+
+`sum([2, 3, 4, 5], 3)` 應該等於 9。
+
+```js
+assert.equal(sum([2, 3, 4, 5], 3), 9);
+```
+
+代碼不能包含任意形式的循環（`for`、`while` 或者高階函數如：`forEach`、`map`、`filter` 以及 `reduce`）。
+
+```js
+assert(
+ !code.match(/for|while|forEach|map|filter|reduce/g)
+);
+```
+
+應該用遞歸解決這個問題。
+
+```js
+assert(
+ sum.toString().match(/sum\(.*\)/g).length > 1
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function sum(arr, n) {
+ // Only change code below this line
+
+ // Only change code above this line
+}
+```
+
+# --solutions--
+
+```js
+function sum(arr, n) {
+ // Only change code below this line
+ if(n <= 0) {
+ return 0;
+ } else {
+ return sum(arr, n - 1) + arr[n - 1];
+ }
+ // Only change code above this line
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/replacing-if-else-chains-with-switch.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/replacing-if-else-chains-with-switch.md
new file mode 100644
index 0000000000..3ef0e72f7e
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/replacing-if-else-chains-with-switch.md
@@ -0,0 +1,157 @@
+---
+id: 56533eb9ac21ba0edf2244e0
+title: 用一個 Switch 語句來替代多個 if else 語句
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c3JE8fy'
+forumTopicId: 18266
+dashedName: replacing-if-else-chains-with-switch
+---
+
+# --description--
+
+如果你有多個選項需要選擇，`switch` 語句寫起來會比多個串聯的 `if`/`else if` 語句容易些。 譬如:
+
+```js
+if (val === 1) {
+ answer = "a";
+} else if (val === 2) {
+ answer = "b";
+} else {
+ answer = "c";
+}
+```
+
+可以被下面替代：
+
+```js
+switch(val) {
+ case 1:
+ answer = "a";
+ break;
+ case 2:
+ answer = "b";
+ break;
+ default:
+ answer = "c";
+}
+```
+
+# --instructions--
+
+把串聯的 `if`/`else if` 語句改成 `switch` 語句。
+
+# --hints--
+
+不要使用 `else` 表達式。
+
+```js
+assert(!/else/g.test(code));
+```
+
+不要使用 `if` 表達式。
+
+```js
+assert(!/if/g.test(code));
+```
+
+你應該有至少 4 個 `break` 表達式。
+
+```js
+assert(code.match(/break/g).length >= 4);
+```
+
+`chainToSwitch("bob")` 應該是字符串 `Marley`
+
+```js
+assert(chainToSwitch('bob') === 'Marley');
+```
+
+`chainToSwitch(42)` 應該是字符串 `The Answer`
+
+```js
+assert(chainToSwitch(42) === 'The Answer');
+```
+
+`chainToSwitch(1)` 應該是字符串 `There is no #1`
+
+```js
+assert(chainToSwitch(1) === 'There is no #1');
+```
+
+`chainToSwitch(99)`應該爲 `Missed me by this much!`。
+
+```js
+assert(chainToSwitch(99) === 'Missed me by this much!');
+```
+
+`chainToSwitch(7)` 應該是字符串 `Ate Nine`
+
+```js
+assert(chainToSwitch(7) === 'Ate Nine');
+```
+
+`chainToSwitch("John")` 應該爲 `""` (empty string)。
+
+```js
+assert(chainToSwitch('John') === '');
+```
+
+`chainToSwitch(156)` 應該爲 `""` (empty string)。
+
+```js
+assert(chainToSwitch(156) === '');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function chainToSwitch(val) {
+ var answer = "";
+ // Only change code below this line
+
+ if (val === "bob") {
+ answer = "Marley";
+ } else if (val === 42) {
+ answer = "The Answer";
+ } else if (val === 1) {
+ answer = "There is no #1";
+ } else if (val === 99) {
+ answer = "Missed me by this much!";
+ } else if (val === 7) {
+ answer = "Ate Nine";
+ }
+
+ // Only change code above this line
+ return answer;
+}
+
+chainToSwitch(7);
+```
+
+# --solutions--
+
+```js
+function chainToSwitch(val) {
+ var answer = "";
+
+ switch(val) {
+ case "bob":
+ answer = "Marley";
+ break;
+ case 42:
+ answer = "The Answer";
+ break;
+ case 1:
+ answer = "There is no #1";
+ break;
+ case 99:
+ answer = "Missed me by this much!";
+ break;
+ case 7:
+ answer = "Ate Nine";
+ }
+ return answer;
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/return-a-value-from-a-function-with-return.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/return-a-value-from-a-function-with-return.md
new file mode 100644
index 0000000000..4416139da4
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/return-a-value-from-a-function-with-return.md
@@ -0,0 +1,72 @@
+---
+id: 56533eb9ac21ba0edf2244c2
+title: 使用 return 給函數返回值
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cy87wue'
+forumTopicId: 18271
+dashedName: return-a-value-from-a-function-with-return
+---
+
+# --description--
+
+我們可以通過函數的參數（arguments ）把值傳入函數， 也可以使用 `return` 語句把數據從一個函數中傳出來。
+
+**示例**
+
+```js
+function plusThree(num) {
+ return num + 3;
+}
+var answer = plusThree(5);
+```
+
+`answer` 的值爲 `8`。
+
+`plusThree` 帶有一個參數（argument ）`num`，並返回（return）一個等於 `num + 3` 的值。
+
+# --instructions--
+
+創建一個函數 `timesFive` 接收一個參數，把它乘以 `5` 之後返回。
+
+# --hints--
+
+`timesFive` 應是一個函數
+
+```js
+assert(typeof timesFive === 'function');
+```
+
+`timesFive(5)` 應該返回 `25`
+
+```js
+assert(timesFive(5) === 25);
+```
+
+`timesFive(2)` 應該返回 `10`
+
+```js
+assert(timesFive(2) === 10);
+```
+
+`timesFive(0)` 應該返回 `0`
+
+```js
+assert(timesFive(0) === 0);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+
+```
+
+# --solutions--
+
+```js
+function timesFive(num) {
+ return num * 5;
+}
+timesFive(10);
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/return-early-pattern-for-functions.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/return-early-pattern-for-functions.md
new file mode 100644
index 0000000000..e97cd38423
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/return-early-pattern-for-functions.md
@@ -0,0 +1,106 @@
+---
+id: 56533eb9ac21ba0edf2244c4
+title: 函數執行到 return 語句就結束
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cQe39Sq'
+forumTopicId: 18272
+dashedName: return-early-pattern-for-functions
+---
+
+# --description--
+
+當代碼執行到 `return` 語句時，函數返回一個結果就結束運行了，return 後面的語句不會執行。
+
+**示例**
+
+```js
+function myFun() {
+ console.log("Hello");
+ return "World";
+ console.log("byebye")
+}
+myFun();
+```
+
+以上將在控制檯中顯示字符串 `Hello` 並返回字符串 `World`。 字符串 `byebye` 將永遠不會在控制檯中顯示，因爲函數在 `return` 語句處就退出了。
+
+# --instructions--
+
+修改函數 `abTest` 當 `a` 或 `b` 小於 `0` 時，函數立即返回一個 `undefined` 並退出。
+
+**提示**
+記住 [`undefined` 是一個關鍵字](/javascript-algorithms-and-data-structures/basic-javascript/understanding-uninitialized-variables)，而不是一個字符串。
+
+# --hints--
+
+`abTest(2,2)` 應該返回一個數字
+
+```js
+assert(typeof abTest(2, 2) === 'number');
+```
+
+`abTest(2,2)` 應該返回 `8`
+
+```js
+assert(abTest(2, 2) === 8);
+```
+
+`abTest(-2,2)` 應該返回 `undefined`
+
+```js
+assert(abTest(-2, 2) === undefined);
+```
+
+`abTest(2,-2)` 應該返回 `undefined`
+
+```js
+assert(abTest(2, -2) === undefined);
+```
+
+`abTest(2,8)` 應該返回 `18`
+
+```js
+assert(abTest(2, 8) === 18);
+```
+
+`abTest(3,3)` 應該返回 `12`
+
+```js
+assert(abTest(3, 3) === 12);
+```
+
+`abTest(0,0)` 應該返回 `0`
+
+```js
+assert(abTest(0, 0) === 0);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// Setup
+function abTest(a, b) {
+ // Only change code below this line
+
+
+
+ // Only change code above this line
+
+ return Math.round(Math.pow(Math.sqrt(a) + Math.sqrt(b), 2));
+}
+
+abTest(2,2);
+```
+
+# --solutions--
+
+```js
+function abTest(a, b) {
+ if(a < 0 || b < 0) {
+ return undefined;
+ }
+ return Math.round(Math.pow(Math.sqrt(a) + Math.sqrt(b), 2));
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/returning-boolean-values-from-functions.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/returning-boolean-values-from-functions.md
new file mode 100644
index 0000000000..1974d5c138
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/returning-boolean-values-from-functions.md
@@ -0,0 +1,82 @@
+---
+id: 5679ceb97cbaa8c51670a16b
+title: 從函數返回布爾值
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cp62qAQ'
+forumTopicId: 18273
+dashedName: returning-boolean-values-from-functions
+---
+
+# --description--
+
+你應該還記得[相等運算符](/learn/javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-equality-operator)這道挑戰題。 在那裏我們提到，所有比較操作符都會返回 boolean：要麼是 `true` 要麼是 `false`。
+
+有時人們通過 `if/else` 語句來做比較，像這樣。
+
+```js
+function isEqual(a,b) {
+ if (a === b) {
+ return true;
+ } else {
+ return false;
+ }
+}
+```
+
+但有更好的方式來達到相同的效果。 既然 `===` 返回 `true` 或 `false` 我們可以直接返回比較結果：
+
+```js
+function isEqual(a,b) {
+ return a === b;
+}
+```
+
+# --instructions--
+
+移除 `isLess` 函數的 `if/else` 語句但不影響函數的功能。
+
+# --hints--
+
+`isLess(10,15)` 應該返回 `true`
+
+```js
+assert(isLess(10, 15) === true);
+```
+
+`isLess(15,10)` 應該返回 `false`
+
+```js
+assert(isLess(15, 10) === false);
+```
+
+不應該使用 `if` 或者 `else` 語句
+
+```js
+assert(!/if|else/g.test(code));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function isLess(a, b) {
+ // Only change code below this line
+ if (a < b) {
+ return true;
+ } else {
+ return false;
+ }
+ // Only change code above this line
+}
+
+isLess(10, 15);
+```
+
+# --solutions--
+
+```js
+function isLess(a, b) {
+ return a < b;
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/selecting-from-many-options-with-switch-statements.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/selecting-from-many-options-with-switch-statements.md
new file mode 100644
index 0000000000..fe19b80933
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/selecting-from-many-options-with-switch-statements.md
@@ -0,0 +1,114 @@
+---
+id: 56533eb9ac21ba0edf2244dd
+title: 使用 Switch 語句從許多選項中進行選擇
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c4mv4fm'
+forumTopicId: 18277
+dashedName: selecting-from-many-options-with-switch-statements
+---
+
+# --description--
+
+如果你有非常多的選項需要選擇，可以使用 switch 語句。 `switch` 評估一個表達式，將表達式的值與 case 子句匹配。 從第一個匹配的 `case` 值執行語句，直到遇到 `break`。
+
+這是 `switch` 語句的示例：
+
+```js
+switch(lowercaseLetter) {
+ case "a":
+ console.log("A");
+ break;
+ case "b":
+ console.log("B");
+ break;
+}
+```
+
+測試 `case` 值使用嚴格相等（`===`）運算符進行比較。 `break` 告訴 JavaScript 停止執行 switch 語句。 如果遺漏了 `break` ，下一個語句將會被執行。
+
+# --instructions--
+
+寫一個測試 `val` 的 switch 語句，並且根據下面的條件來設置不同的 `answer`：
+`1` - `alpha`
+`2` - `beta`
+`3` - `gamma`
+`4` - `delta`
+
+# --hints--
+
+`caseInSwitch(1)` 值應該爲字符串 `alpha`
+
+```js
+assert(caseInSwitch(1) === 'alpha');
+```
+
+`caseInSwitch(2)` 值應該爲字符串 `beta`
+
+```js
+assert(caseInSwitch(2) === 'beta');
+```
+
+`caseInSwitch(3)` 值應該爲字符串 `gamma`
+
+```js
+assert(caseInSwitch(3) === 'gamma');
+```
+
+`caseInSwitch(4)` 值應該爲字符串 `delta`
+
+```js
+assert(caseInSwitch(4) === 'delta');
+```
+
+不能使用任何 `if` 或 `else` 表達式
+
+```js
+assert(!/else/g.test(code) || !/if/g.test(code));
+```
+
+你應該有至少 3 個 `break` 表達式
+
+```js
+assert(code.match(/break/g).length > 2);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function caseInSwitch(val) {
+ var answer = "";
+ // Only change code below this line
+
+
+
+ // Only change code above this line
+ return answer;
+}
+
+caseInSwitch(1);
+```
+
+# --solutions--
+
+```js
+function caseInSwitch(val) {
+ var answer = "";
+
+ switch(val) {
+ case 1:
+ answer = "alpha";
+ break;
+ case 2:
+ answer = "beta";
+ break;
+ case 3:
+ answer = "gamma";
+ break;
+ case 4:
+ answer = "delta";
+ }
+ return answer;
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/shopping-list.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/shopping-list.md
new file mode 100644
index 0000000000..3712d37fd3
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/shopping-list.md
@@ -0,0 +1,97 @@
+---
+id: 56533eb9ac21ba0edf2244bc
+title: 購物清單
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c9MEKHZ'
+forumTopicId: 18280
+dashedName: shopping-list
+---
+
+# --description--
+
+創建一個名叫 `myList` 的購物清單。 清單的數據格式就是多維數組。
+
+每個子數組中的第一個元素應該是購買的物品名稱。 第二個元素應該是物品的數量，類似於：
+
+```js
+["Chocolate Bar", 15]
+```
+
+列表中應至少有 5 個子數組。
+
+# --hints--
+
+`myList` 應該是一個數組。
+
+```js
+assert(isArray);
+```
+
+每個子數組的第一個元素都應該是字符串。
+
+```js
+assert(hasString);
+```
+
+每個子數組的第二個元素都應該是數字。
+
+```js
+assert(hasNumber);
+```
+
+列表中至少要包含 5 個元素。
+
+```js
+assert(count > 4);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+var count = 0;
+var isArray = false;
+var hasString = false;
+var hasNumber = false;
+(function(list){
+ if(Array.isArray(myList)) {
+ isArray = true;
+ if(myList.length > 0) {
+ hasString = true;
+ hasNumber = true;
+ for (var elem of myList) {
+ if(!elem || !elem[0] || typeof elem[0] !== 'string') {
+ hasString = false;
+ }
+ if(!elem || typeof elem[1] !== 'number') {
+ hasNumber = false;
+ }
+ }
+ }
+ count = myList.length;
+ return JSON.stringify(myList);
+ } else {
+ return "myList is not an array";
+ }
+
+})(myList);
+```
+
+## --seed-contents--
+
+```js
+var myList = [];
+```
+
+# --solutions--
+
+```js
+var myList = [
+ ["Candy", 10],
+ ["Potatoes", 12],
+ ["Eggs", 12],
+ ["Catfood", 1],
+ ["Toads", 9]
+];
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/stand-in-line.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/stand-in-line.md
new file mode 100644
index 0000000000..5c4ea46a83
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/stand-in-line.md
@@ -0,0 +1,118 @@
+---
+id: 56533eb9ac21ba0edf2244c6
+title: 排隊
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/ca8Q8tP'
+forumTopicId: 18307
+dashedName: stand-in-line
+---
+
+# --description--
+
+在計算機科學中隊列（queue ）是一個抽象的數據結構（Data Structure ），隊列中的條目都是有秩序的。 新的條目會被加到隊列的末尾，舊的條目會從隊列的頭部被移出。
+
+寫一個函數 `nextInLine`，用一個數組（`arr`）和一個數字（`item`）作爲參數。
+
+把數字添加到數組的結尾，然後移出數組的第一個元素。
+
+最後 `nextInLine` 函數應該返回被刪除的元素。
+
+# --hints--
+
+`nextInLine([], 5)` 應該返回一個數字。
+
+```js
+assert.isNumber(nextInLine([], 5));
+```
+
+`nextInLine([], 1)` 應該返回 `1`
+
+```js
+assert(nextInLine([], 1) === 1);
+```
+
+`nextInLine([2], 1)` 應該返回 `2`
+
+```js
+assert(nextInLine([2], 1) === 2);
+```
+
+`nextInLine([5,6,7,8,9], 1)` 應該返回 `5`
+
+```js
+assert(nextInLine([5, 6, 7, 8, 9], 1) === 5);
+```
+
+在 `nextInLine(testArr, 10)` 執行後 `testArr[4]` 應該是 `10`
+
+```js
+nextInLine(testArr, 10);
+assert(testArr[4] === 10);
+```
+
+# --seed--
+
+## --before-user-code--
+
+```js
+var logOutput = [];
+var originalConsole = console
+function capture() {
+ var nativeLog = console.log;
+ console.log = function (message) {
+ logOutput.push(message);
+ if(nativeLog.apply) {
+ nativeLog.apply(originalConsole, arguments);
+ } else {
+ var nativeMsg = Array.prototype.slice.apply(arguments).join(' ');
+ nativeLog(nativeMsg);
+ }
+ };
+}
+
+function uncapture() {
+ console.log = originalConsole.log;
+}
+
+capture();
+```
+
+## --after-user-code--
+
+```js
+uncapture();
+testArr = [1,2,3,4,5];
+(function() { return logOutput.join("\n");})();
+```
+
+## --seed-contents--
+
+```js
+function nextInLine(arr, item) {
+ // Only change code below this line
+
+ return item;
+ // Only change code above this line
+
+
+}
+
+// Setup
+var testArr = [1,2,3,4,5];
+
+// Display code
+console.log("Before: " + JSON.stringify(testArr));
+console.log(nextInLine(testArr, 6));
+console.log("After: " + JSON.stringify(testArr));
+```
+
+# --solutions--
+
+```js
+var testArr = [ 1,2,3,4,5];
+
+function nextInLine(arr, item) {
+ arr.push(item);
+ return arr.shift();
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/store-multiple-values-in-one-variable-using-javascript-arrays.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/store-multiple-values-in-one-variable-using-javascript-arrays.md
new file mode 100644
index 0000000000..a1040592cf
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/store-multiple-values-in-one-variable-using-javascript-arrays.md
@@ -0,0 +1,63 @@
+---
+id: bd7993c9c69feddfaeb8bdef
+title: 使用 JavaScript 數組將多個值存儲在一個變量中
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/crZQWAm'
+forumTopicId: 18309
+dashedName: store-multiple-values-in-one-variable-using-javascript-arrays
+---
+
+# --description--
+
+使用數組（`array`），我們可以在一個地方存儲多個數據。
+
+以左方括號開始定義一個數組，以右方括號結束，裏面每個元素之間用逗號隔開，例如：
+
+```js
+var sandwich = ["peanut butter", "jelly", "bread"]
+```
+
+# --instructions--
+
+創建一個包含字符串（`string`）和數字（ `number`）（按照字符串數字的順序）的數組 `myArray`。
+
+# --hints--
+
+`myArray` 應該是一個數組（`array`）。
+
+```js
+assert(typeof myArray == 'object');
+```
+
+`myArray` 數組的第一個元素應該是一個字符串（`string`）。
+
+```js
+assert(typeof myArray[0] !== 'undefined' && typeof myArray[0] == 'string');
+```
+
+`myArray` 數組的第二個元素應該是一個數字（`number`）。
+
+```js
+assert(typeof myArray[1] !== 'undefined' && typeof myArray[1] == 'number');
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(z){return z;})(myArray);
+```
+
+## --seed-contents--
+
+```js
+// Only change code below this line
+var myArray = [];
+```
+
+# --solutions--
+
+```js
+var myArray = ["The Answer", 42];
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/storing-values-with-the-assignment-operator.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/storing-values-with-the-assignment-operator.md
new file mode 100644
index 0000000000..5408ecdf24
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/storing-values-with-the-assignment-operator.md
@@ -0,0 +1,77 @@
+---
+id: 56533eb9ac21ba0edf2244a8
+title: 使用賦值運算符存儲值
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cEanysE'
+forumTopicId: 18310
+dashedName: storing-values-with-the-assignment-operator
+---
+
+# --description--
+
+在 JavaScript 中，你可以使用賦值（assignment ）運算符 （`=`）將值存儲在變量中。
+
+```js
+myVariable = 5;
+```
+
+這條語句把 `Number` 類型的值 `5` 賦給變量 `myVariable`。
+
+在將值賦給運算符左側的變量之前，將先執行 `=` 運算符右側的所有運算。
+
+```js
+var myVar;
+myVar = 5;
+```
+
+首先，此代碼創建一個名爲 `myVar` 的變量。 然後，數值 `5` 被賦給變量 `myVar`。 現在，如果 `myVar` 再次出現在代碼中，程序將會將它視爲 `5`。
+
+# --instructions--
+
+把數值 `7` 賦給變量 `a`。
+
+# --hints--
+
+不應該修改註釋上面的代碼。
+
+```js
+assert(/var a;/.test(code));
+```
+
+`a` 的值應該爲 7。
+
+```js
+assert(typeof a === 'number' && a === 7);
+```
+
+# --seed--
+
+## --before-user-code--
+
+```js
+if (typeof a != 'undefined') {
+ a = undefined;
+}
+```
+
+## --after-user-code--
+
+```js
+(function(a){return "a = " + a;})(a);
+```
+
+## --seed-contents--
+
+```js
+// Setup
+var a;
+
+// Only change code below this line
+```
+
+# --solutions--
+
+```js
+var a;
+a = 7;
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/subtract-one-number-from-another-with-javascript.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/subtract-one-number-from-another-with-javascript.md
new file mode 100644
index 0000000000..21f07ef062
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/subtract-one-number-from-another-with-javascript.md
@@ -0,0 +1,59 @@
+---
+id: cf1111c1c11feddfaeb4bdef
+title: 減法運算
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cP3yQtk'
+forumTopicId: 18314
+dashedName: subtract-one-number-from-another-with-javascript
+---
+
+# --description--
+
+我們也可以在 JavaScript 中進行減法運算。
+
+JavaScript 中使用 `-` 來做減法運算。
+
+**示例**
+
+```js
+myVar = 12 - 6;
+```
+
+現在，變量 `myVar` 的值爲 `6`。
+# --instructions--
+
+改變數字`0`讓變量 difference 的值爲 `12`。
+
+# --hints--
+
+變量 `difference` 的值應該爲 12。
+
+```js
+assert(difference === 12);
+```
+
+您只能從 45 中減去一個數字。
+
+```js
+assert(/difference=45-33;?/.test(__helpers.removeWhiteSpace(code)));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(z){return 'difference = '+z;})(difference);
+```
+
+## --seed-contents--
+
+```js
+var difference = 45 - 0;
+```
+
+# --solutions--
+
+```js
+var difference = 45 - 33;
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/testing-objects-for-properties.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/testing-objects-for-properties.md
new file mode 100644
index 0000000000..6ffb1fb79a
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/testing-objects-for-properties.md
@@ -0,0 +1,98 @@
+---
+id: 567af2437cbaa8c51670a16c
+title: 測試對象的屬性
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c6Wz4ySr'
+forumTopicId: 18324
+dashedName: testing-objects-for-properties
+---
+
+# --description--
+
+有時檢查一個對象屬性是否存在是非常有用的。 我們可以用對象的 `.hasOwnProperty(propname)` 方法來檢查對象是否有指定的屬性。 `.hasOwnProperty()` 找到該屬性時返回 `true`，找不到該屬性時返回 `false`。
+
+**示例**
+
+```js
+var myObj = {
+ top: "hat",
+ bottom: "pants"
+};
+myObj.hasOwnProperty("top");
+myObj.hasOwnProperty("middle");
+```
+
+第一個 `hasOwnProperty` 返回 `true`，第二個返回 `false`。
+
+# --instructions--
+
+修改函數 `checkObj` 檢查 `obj` 是否有 `checkProp` 屬性。 如果屬性存在，返回屬性對應的值。 如果不存在，返回`"Not Found"`。
+
+# --hints--
+
+`checkObj({gift: "pony", pet: "kitten", bed: "sleigh"}, "gift")` 應該返回字符串 `pony`。
+
+```js
+assert(
+ checkObj({ gift: 'pony', pet: 'kitten', bed: 'sleigh' }, 'gift') === 'pony'
+);
+```
+
+`checkObj({gift: "pony", pet: "kitten", bed: "sleigh"}, "pet")` 應該返回字符串 `kitten`。
+
+```js
+assert(
+ checkObj({ gift: 'pony', pet: 'kitten', bed: 'sleigh' }, 'pet') === 'kitten'
+);
+```
+
+`checkObj({gift: "pony", pet: "kitten", bed: "sleigh"}, "house")` 應該返回字符串 `Not Found`。
+
+```js
+assert(
+ checkObj({ gift: 'pony', pet: 'kitten', bed: 'sleigh' }, 'house') ===
+ 'Not Found'
+);
+```
+
+`checkObj({city: "Seattle"}, "city")` 應該返回字符串 `Seattle`。
+
+```js
+assert(checkObj({ city: 'Seattle' }, 'city') === 'Seattle');
+```
+
+`checkObj({city: "Seattle"}, "district")` 應該返回字符串 `Not Found`。
+
+```js
+assert(checkObj({ city: 'Seattle' }, 'district') === 'Not Found');
+```
+
+`checkObj({pet: "kitten", bed: "sleigh"}, "gift")` 應該返回字符串 `Not Found`。
+
+```js
+assert(checkObj({ pet: 'kitten', bed: 'sleigh' }, 'gift') === 'Not Found');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function checkObj(obj, checkProp) {
+ // Only change code below this line
+ return "Change Me!";
+ // Only change code above this line
+}
+```
+
+# --solutions--
+
+```js
+function checkObj(obj, checkProp) {
+ if(obj.hasOwnProperty(checkProp)) {
+ return obj[checkProp];
+ } else {
+ return "Not Found";
+ }
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/understand-string-immutability.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/understand-string-immutability.md
new file mode 100644
index 0000000000..fa573f673e
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/understand-string-immutability.md
@@ -0,0 +1,70 @@
+---
+id: 56533eb9ac21ba0edf2244ba
+title: 瞭解字符串的不變性
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cWPVaUR'
+forumTopicId: 18331
+dashedName: understand-string-immutability
+---
+
+# --description--
+
+在 JavaScript 中，字符串（`String`）的值是不可變的（immutable ），這意味着一旦字符串被創建就不能被改變。
+
+例如，下面的代碼：
+
+```js
+var myStr = "Bob";
+myStr[0] = "J";
+```
+
+是不會把變量 `myStr` 的值改變成 `Job` 的，因爲變量 `myStr` 是不可變的。 注意，這*並不*意味着 `myStr` 永遠不能被改變，只是字符串字面量 string literal 的各個字符不能被改變。 改變 `myStr` 的唯一方法是重新給它賦一個值，例如：
+
+```js
+var myStr = "Bob";
+myStr = "Job";
+```
+
+# --instructions--
+
+更正對 `myStr` 的分配，使用上面示例中的方法包含 `Hello World` 字符串。
+
+# --hints--
+
+`myStr` 的值應該是字符串 `Hello World`。
+
+```js
+assert(myStr === 'Hello World');
+```
+
+不要修改註釋上面的代碼。
+
+```js
+assert(/myStr = "Jello World"/.test(code));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(v){return "myStr = " + v;})(myStr);
+```
+
+## --seed-contents--
+
+```js
+// Setup
+var myStr = "Jello World";
+
+// Only change code below this line
+myStr[0] = "H"; // Change this line
+// Only change code above this line
+```
+
+# --solutions--
+
+```js
+var myStr = "Jello World";
+myStr = "Hello World";
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-boolean-values.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-boolean-values.md
new file mode 100644
index 0000000000..44bd62bbb1
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-boolean-values.md
@@ -0,0 +1,61 @@
+---
+id: bd7123c9c441eddfaeb5bdef
+title: 理解布爾值
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c9Me8t4'
+forumTopicId: 301176
+dashedName: understanding-boolean-values
+---
+
+# --description--
+
+另一種數據類型是布爾（Boolean ）。 布爾值只能是兩個值中的一個：`true` 或者 `false`。 它非常像電路開關，`true` 是 “開”，`false` 是 “關”。 這兩種狀態是互斥的。
+
+**注意：**布爾值是不帶引號的。 字符串 `"true"` 和 `"false"` 不是布爾值，在 JavaScript 中也沒有特殊含義。
+
+# --instructions--
+
+修改 `welcomeToBooleans` 函數，當 run 按鈕點擊時讓它返回 `true` 而不是 `false`。
+
+# --hints--
+
+`welcomeToBooleans()` 函數應該返回一個布爾值 （`true` 或者 `false`)。
+
+```js
+assert(typeof welcomeToBooleans() === 'boolean');
+```
+
+`welcomeToBooleans()` 應該返回 `true`。
+
+```js
+assert(welcomeToBooleans() === true);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+welcomeToBooleans();
+```
+
+## --seed-contents--
+
+```js
+function welcomeToBooleans() {
+
+ // Only change code below this line
+
+ return false; // Change this line
+
+ // Only change code above this line
+}
+```
+
+# --solutions--
+
+```js
+function welcomeToBooleans() {
+ return true; // Change this line
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-case-sensitivity-in-variables.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-case-sensitivity-in-variables.md
new file mode 100644
index 0000000000..e858f82e0d
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-case-sensitivity-in-variables.md
@@ -0,0 +1,100 @@
+---
+id: 56533eb9ac21ba0edf2244ab
+title: 瞭解變量名區分大小寫
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cd6GDcD'
+forumTopicId: 18334
+dashedName: understanding-case-sensitivity-in-variables
+---
+
+# --description--
+
+在 JavaScript 中所有的變量和函數名都是大小寫敏感的。 要區別對待大寫字母和小寫字母。
+
+`MYVAR` 與 `MyVar` 和 `myvar` 是不同的變量。 這有可能導致出現多個相似名字的的變量。 所以強烈地建議你，爲了保持代碼清晰*不要*使用這一特性。
+
+**最佳實踐**
+
+使用駝峯命名法（camelCase ）來書寫一個 Javascript 變量。 在駝峯命名法（camelCase ）中，變量名的第一個單詞的首寫字母小寫，後面的單詞的第一個字母大寫
+
+**示例：**
+
+```js
+var someVariable;
+var anotherVariableName;
+var thisVariableNameIsSoLong;
+```
+
+# --instructions--
+
+修改已聲明的變量，讓它們的命名符合駝峯命名法（camelCase ）的規範。
+
+不要創建任何新變量。
+
+# --hints--
+
+`studlyCapVar` 應該被定義並且值爲 `10`。
+
+```js
+assert(typeof studlyCapVar !== 'undefined' && studlyCapVar === 10);
+```
+
+`properCamelCase` 應該被定義並且值爲字符串 `A String`。
+
+```js
+assert(
+ typeof properCamelCase !== 'undefined' && properCamelCase === 'A String'
+);
+```
+
+`titleCaseOver` 應該被定義並且值爲 `9000`。
+
+```js
+assert(typeof titleCaseOver !== 'undefined' && titleCaseOver === 9000);
+```
+
+`studlyCapVar` 在聲明和賦值時都應該使用駝峯命名法。
+
+```js
+assert(code.match(/studlyCapVar/g).length === 2);
+```
+
+`properCamelCase` 在聲明和賦值時都應該使用駝峯命名法。
+
+```js
+assert(code.match(/properCamelCase/g).length === 2);
+```
+
+`titleCaseOver` 在聲明和賦值時都應該使用駝峯命名法。
+
+```js
+assert(code.match(/titleCaseOver/g).length === 2);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// Variable declarations
+var StUdLyCapVaR;
+var properCamelCase;
+var TitleCaseOver;
+
+// Variable assignments
+STUDLYCAPVAR = 10;
+PRoperCAmelCAse = "A String";
+tITLEcASEoVER = 9000;
+```
+
+# --solutions--
+
+```js
+var studlyCapVar;
+var properCamelCase;
+var titleCaseOver;
+
+studlyCapVar = 10;
+properCamelCase = "A String";
+titleCaseOver = 9000;
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-undefined-value-returned-from-a-function.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-undefined-value-returned-from-a-function.md
new file mode 100644
index 0000000000..269618c331
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-undefined-value-returned-from-a-function.md
@@ -0,0 +1,94 @@
+---
+id: 598e8944f009e646fc236146
+title: 函數也可以返回 undefined
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/ce2p7cL'
+forumTopicId: 301177
+dashedName: understanding-undefined-value-returned-from-a-function
+---
+
+# --description--
+
+函數一般用 `return` 語句來返回值，但這不是必須的。 在函數沒有 `return` 語句的情況下，當你調用它時，該函數會執行內部代碼，返回的值是 `undefined`。
+
+**示例**
+
+```js
+var sum = 0;
+function addSum(num) {
+ sum = sum + num;
+}
+addSum(3);
+```
+
+`addSum` 是一個沒有 `return` 語句的函數。 該函數將更改全局變量 `sum`，函數的返回值爲 `undefined`。
+
+# --instructions--
+
+創建一個沒有任何參數的函數 `addFive`。 此函數使 `sum` 變量加 5，但其返回值是 `undefined`。
+
+# --hints--
+
+`addFive` 應該是一個函數。
+
+```js
+assert(typeof addFive === 'function');
+```
+
+兩個函數運行後，`sum` 應該等於 `8`。
+
+```js
+assert(sum === 8);
+```
+
+`addFive` 的返回值應該是 `undefined`。
+
+```js
+assert(addFive() === undefined);
+```
+
+在 `addFive` 函數中，應該給 `sum` 變量增加 `5`。
+
+```js
+assert(
+ __helpers.removeWhiteSpace(addFive.toString()).match(/sum=sum\+5|sum\+=5/)
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// Setup
+var sum = 0;
+
+function addThree() {
+ sum = sum + 3;
+}
+
+// Only change code below this line
+
+
+// Only change code above this line
+
+addThree();
+addFive();
+```
+
+# --solutions--
+
+```js
+var sum = 0;
+
+function addThree() {
+ sum = sum + 3;
+}
+
+function addFive() {
+ sum = sum + 5;
+}
+
+addThree();
+addFive();
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-uninitialized-variables.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-uninitialized-variables.md
new file mode 100644
index 0000000000..540036f5c2
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-uninitialized-variables.md
@@ -0,0 +1,79 @@
+---
+id: 56533eb9ac21ba0edf2244aa
+title: 理解未初始化的變量
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cBa2JAL'
+forumTopicId: 18335
+dashedName: understanding-uninitialized-variables
+---
+
+# --description--
+
+當 JavaScript 中的變量被聲明的時候，程序內部會給它一個初始值 `undefined`。 當你對一個值爲 `undefined` 的變量進行運算操作的時候，算出來的結果將會是 `NaN`，它的意思是 "Not a Number" 。 當你用一個值是 `undefined` 的變量來做字符串拼接操作的時候，它會轉換成字符串（string ）`undefined`。
+
+# --instructions--
+
+定義 3 個變量 `a`、`b`、`c`，並且分別給他們賦值：`5`、`10`、`"I am a"`，這樣它們值就不會是 `undefined` 了。
+
+# --hints--
+
+`a` 應該被定義，並且值爲 `6`。
+
+```js
+assert(typeof a === 'number' && a === 6);
+```
+
+`b` 應該被定義，並且值爲 `15`。
+
+```js
+assert(typeof b === 'number' && b === 15);
+```
+
+`c` 的值不能包含 `undefined`，應該爲字符串 `I am a String!`。
+
+```js
+assert(!/undefined/.test(c) && c === 'I am a String!');
+```
+
+不要修改第二條註釋下的代碼。
+
+```js
+assert(
+ /a = a \+ 1;/.test(code) &&
+ /b = b \+ 5;/.test(code) &&
+ /c = c \+ " String!";/.test(code)
+);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(a,b,c){ return "a = " + a + ", b = " + b + ", c = '" + c + "'"; })(a,b,c);
+```
+
+## --seed-contents--
+
+```js
+// Only change code below this line
+var a;
+var b;
+var c;
+// Only change code above this line
+
+a = a + 1;
+b = b + 5;
+c = c + " String!";
+```
+
+# --solutions--
+
+```js
+var a = 5;
+var b = 10;
+var c = "I am a";
+a = a + 1;
+b = b + 5;
+c = c + " String!";
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/updating-object-properties.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/updating-object-properties.md
new file mode 100644
index 0000000000..f16bd068ac
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/updating-object-properties.md
@@ -0,0 +1,77 @@
+---
+id: 56bbb991ad1ed5201cd392d1
+title: 更新對象屬性
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c9yEJT4'
+forumTopicId: 18336
+dashedName: updating-object-properties
+---
+
+# --description--
+
+在你創建了 JavaScript 對象後，你可以隨時更新它的屬性，就像更新任何其他變量那樣。 你可以使用點或中括號操作符來更新。
+
+舉個例子，讓我們看看 `ourDog`：
+
+```js
+var ourDog = {
+ "name": "Camper",
+ "legs": 4,
+ "tails": 1,
+ "friends": ["everything!"]
+};
+```
+
+既然他是一個特別愉快的狗，讓我們將他的名字更改爲字符串 `Happy Camper`。 這有兩種方式來更新對象的 name 屬性： `ourDog.name = "Happy Camper";` 或 `ourDog["name"] = "Happy Camper";`。更新後，`ourDog.name` 的值就不再是 `Camper`，而是 `Happy Camper`。
+
+# --instructions--
+
+更新 `myDog` 對象的 name 屬性。 讓它的名字從 `Coder` 變成 `Happy Coder`。 你可以使用點號表示法或方括號表示法來完成此挑戰。
+
+# --hints--
+
+更新 `myDog` 的 `name` 屬性，使其等於 `Happy Coder`。
+
+```js
+assert(/happy coder/gi.test(myDog.name));
+```
+
+不要修改 `myDog` 的定義。
+
+```js
+assert(/"name": "Coder"/.test(code));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(z){return z;})(myDog);
+```
+
+## --seed-contents--
+
+```js
+// Setup
+var myDog = {
+ "name": "Coder",
+ "legs": 4,
+ "tails": 1,
+ "friends": ["freeCodeCamp Campers"]
+};
+
+// Only change code below this line
+```
+
+# --solutions--
+
+```js
+var myDog = {
+ "name": "Coder",
+ "legs": 4,
+ "tails": 1,
+ "friends": ["freeCodeCamp Campers"]
+};
+myDog.name = "Happy Coder";
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/use-bracket-notation-to-find-the-first-character-in-a-string.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/use-bracket-notation-to-find-the-first-character-in-a-string.md
new file mode 100644
index 0000000000..ccac2b9f36
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/use-bracket-notation-to-find-the-first-character-in-a-string.md
@@ -0,0 +1,74 @@
+---
+id: bd7123c9c549eddfaeb5bdef
+title: 使用方括號查找字符串中的第一個字符
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/ca8JwhW'
+forumTopicId: 18341
+dashedName: use-bracket-notation-to-find-the-first-character-in-a-string
+---
+
+# --description--
+
+方括號表示法（Bracket notation ）是一種在字符串中的特定 index（索引）處獲取字符的方法。
+
+大多數現代編程語言，如JavaScript，不同於人類從 1 開始計數。 它們是從 0 開始計數。 這被稱爲基於零（Zero-based ）的索引。
+
+例如，單詞 `Charles` 的索引 0 的字符是 `C`。 所以在 `var firstName = "Charles"` 中，你可以使用 `firstName[0]` 來獲得第一個位置上的字符。
+
+示例：
+
+```js
+var firstName = "Charles";
+var firstLetter = firstName[0];
+```
+
+`firstLetter` 值爲字符串 `C` 。
+
+# --instructions--
+
+使用方括號獲取變量 `lastName` 中的第一個字符，並賦給變量 `firstLetterOfLastName`。
+
+**提示：** 如果卡住了，請嘗試查看上面的示例。
+
+# --hints--
+
+`firstLetterOfLastName` 變量值應該爲 `L` 。
+
+```js
+assert(firstLetterOfLastName === 'L');
+```
+
+應該使用方括號表示法。
+
+```js
+assert(code.match(/firstLetterOfLastName\s*?=\s*?lastName\[.*?\]/));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(v){return v;})(firstLetterOfLastName);
+```
+
+## --seed-contents--
+
+```js
+// Setup
+var firstLetterOfLastName = "";
+var lastName = "Lovelace";
+
+// Only change code below this line
+firstLetterOfLastName = lastName; // Change this line
+```
+
+# --solutions--
+
+```js
+var firstLetterOfLastName = "";
+var lastName = "Lovelace";
+
+// Only change code below this line
+firstLetterOfLastName = lastName[0];
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/use-bracket-notation-to-find-the-last-character-in-a-string.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/use-bracket-notation-to-find-the-last-character-in-a-string.md
new file mode 100644
index 0000000000..432fb5da83
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/use-bracket-notation-to-find-the-last-character-in-a-string.md
@@ -0,0 +1,68 @@
+---
+id: bd7123c9c451eddfaeb5bdef
+title: 使用方括號查找字符串中的最後一個字符
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cBZQGcv'
+forumTopicId: 18342
+dashedName: use-bracket-notation-to-find-the-last-character-in-a-string
+---
+
+# --description--
+
+要獲取字符串的最後一個字符，可以用字符串的長度減 1 的索引值。
+
+例如，在 `var firstName = "Charles"` 中，可以用 `firstName[firstName.length - 1]` 來得到字符串的最後的一個字符。
+
+示例：
+
+```js
+var firstName = "Charles";
+var lastLetter = firstName[firstName.length - 1];
+```
+
+`lastLetter` 值爲字符串 `s`。
+
+# --instructions--
+
+使用方括號表示法（ bracket notation ）來找到 `lastName` 變量中的最後一個字符。
+
+**提示：** 如果卡住了，請嘗試查看上面的示例。
+
+# --hints--
+
+`lastLetterOfLastName` 應該是字母 `e`。
+
+```js
+assert(lastLetterOfLastName === 'e');
+```
+
+您應該使用 `.length` 獲取最後一個字母。
+
+```js
+assert(code.match(/\.length/g).length > 0);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(v){return v;})(lastLetterOfLastName);
+```
+
+## --seed-contents--
+
+```js
+// Setup
+var lastName = "Lovelace";
+
+// Only change code below this line
+var lastLetterOfLastName = lastName; // Change this line
+```
+
+# --solutions--
+
+```js
+var lastName = "Lovelace";
+var lastLetterOfLastName = lastName[lastName.length - 1];
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/use-bracket-notation-to-find-the-nth-character-in-a-string.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/use-bracket-notation-to-find-the-nth-character-in-a-string.md
new file mode 100644
index 0000000000..3c0dc49284
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/use-bracket-notation-to-find-the-nth-character-in-a-string.md
@@ -0,0 +1,68 @@
+---
+id: bd7123c9c450eddfaeb5bdef
+title: 使用方括號查找字符串中的第 N 個字符
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cWPVJua'
+forumTopicId: 18343
+dashedName: use-bracket-notation-to-find-the-nth-character-in-a-string
+---
+
+# --description--
+
+你也可以使用方括號（ bracket notation ）來獲得一個字符串中的其他位置的字符。
+
+請記住，程序是從 `0` 開始計數，所以獲取第一個字符實際上是第零個字符串。
+
+例如：
+
+```js
+var firstName = "Ada";
+var secondLetterOfFirstName = firstName[1];
+```
+
+`secondLetterOfFirstName` 值應該爲字符串 `d`。
+
+# --instructions--
+
+讓我們使用方括號，把 `lastName` 變量的第三個字符賦值給 `thirdLetterOfLastName`。
+
+**提示：** 如果卡住了，請嘗試查看上面的示例。
+
+# --hints--
+
+`thirdLetterOfLastName` 變量值應該爲 `v` 。
+
+```js
+assert(thirdLetterOfLastName === 'v');
+```
+
+應該使用方括號表示法。
+
+```js
+assert(code.match(/thirdLetterOfLastName\s*?=\s*?lastName\[.*?\]/));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(v){return v;})(thirdLetterOfLastName);
+```
+
+## --seed-contents--
+
+```js
+// Setup
+var lastName = "Lovelace";
+
+// Only change code below this line
+var thirdLetterOfLastName = lastName; // Change this line
+```
+
+# --solutions--
+
+```js
+var lastName = "Lovelace";
+var thirdLetterOfLastName = lastName[2];
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/use-bracket-notation-to-find-the-nth-to-last-character-in-a-string.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/use-bracket-notation-to-find-the-nth-to-last-character-in-a-string.md
new file mode 100644
index 0000000000..b671f379ea
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/use-bracket-notation-to-find-the-nth-to-last-character-in-a-string.md
@@ -0,0 +1,68 @@
+---
+id: bd7123c9c452eddfaeb5bdef
+title: 使用方括號查找字符串中的倒數第 N 個字符
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cw4vkh9'
+forumTopicId: 18344
+dashedName: use-bracket-notation-to-find-the-nth-to-last-character-in-a-string
+---
+
+# --description--
+
+我們既可以獲取字符串的最後一個字符，也可以用獲取字符串的倒數第 N 個字符。
+
+例如，你可以這樣 `firstName[firstName.length - 3]` 來獲得 `var firstName = "Charles"` 字符串中的倒數第三個字符。
+
+例如：
+
+```js
+var firstName = "Charles";
+var thirdToLastLetter = firstName[firstName.length - 3];
+```
+
+`thirdToLastLetter` 的值應該爲字符串 `l`。
+
+# --instructions--
+
+使用方括號（ bracket notation ）來獲得 `lastName` 字符串中的倒數第二個字符。
+
+**提示：** 如果卡住了，請嘗試查看上面的示例。
+
+# --hints--
+
+`secondToLastLetterOfLastName` 應該是字母 `c`。
+
+```js
+assert(secondToLastLetterOfLastName === 'c');
+```
+
+您應該使用 `.length` 獲取倒數第二個字母。
+
+```js
+assert(code.match(/\.length/g).length > 0);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(v){return v;})(secondToLastLetterOfLastName);
+```
+
+## --seed-contents--
+
+```js
+// Setup
+var lastName = "Lovelace";
+
+// Only change code below this line
+var secondToLastLetterOfLastName = lastName; // Change this line
+```
+
+# --solutions--
+
+```js
+var lastName = "Lovelace";
+var secondToLastLetterOfLastName = lastName[lastName.length - 2];
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/use-conditional-logic-with-if-statements.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/use-conditional-logic-with-if-statements.md
new file mode 100644
index 0000000000..f8fdc34837
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/use-conditional-logic-with-if-statements.md
@@ -0,0 +1,97 @@
+---
+id: cf1111c1c12feddfaeb3bdef
+title: 用 if 語句來表達條件邏輯
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cy87mf3'
+forumTopicId: 18348
+dashedName: use-conditional-logic-with-if-statements
+---
+
+# --description--
+
+`If` 語句用於在代碼中做條件判斷。 關鍵字 `if` 告訴 JavaScript 在小括號中的條件爲真的情況下去執行定義在大括號裏面的代碼。 這種條件被稱爲 `Boolean` 條件，因爲他們只可能是 `true`（真）或 `false`（假）。
+
+當條件的計算結果爲 `true`，程序執行大括號內的語句。 當布爾條件的計算結果爲 `false`，大括號內的代碼將不會執行。
+
+**僞代碼**
+
+if（條件爲真 ）{語句被執行
+
+**示例**
+
+```js
+function test (myCondition) {
+ if (myCondition) {
+ return "It was true";
+ }
+ return "It was false";
+}
+test(true);
+test(false);
+```
+
+`test(true)` 返回字符串 `It was true`，`test(false)` 返回字符串 `It was false`。
+
+當 `test` 被調用，並且傳遞進來的參數值爲 `true` 時，`if` 語句會計算 `myCondition` 的結果，看它是否爲 `true`。 如果條件爲 `true`，函數會返回 `It was true`。 當 `test` 被調用，並且傳遞進來的參數值爲 `false` 時，`myCondition` *不* 爲 `true`，並且不執行大括號後面的語句，函數返回 `It was false`。
+
+# --instructions--
+
+在函數內部創建一個 `if` 語句，如果該參數 `wasThatTrue` 值爲 `true`，返回 `Yes, that was true`，否則，返回`No, that was false`。
+
+# --hints--
+
+`trueOrFalse` 應該是一個函數
+
+```js
+assert(typeof trueOrFalse === 'function');
+```
+
+`trueOrFalse(true)` 應該返回一個字符串
+
+```js
+assert(typeof trueOrFalse(true) === 'string');
+```
+
+`trueOrFalse(false)` 應該返回一個字符串
+
+```js
+assert(typeof trueOrFalse(false) === 'string');
+```
+
+`trueOrFalse(true)` 應該返回 `Yes, that was true`
+
+```js
+assert(trueOrFalse(true) === 'Yes, that was true');
+```
+
+`trueOrFalse(false)`應該返回 `No, that was false`
+
+```js
+assert(trueOrFalse(false) === 'No, that was false');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function trueOrFalse(wasThatTrue) {
+ // Only change code below this line
+
+
+
+ // Only change code above this line
+
+}
+```
+
+# --solutions--
+
+```js
+function trueOrFalse(wasThatTrue) {
+ if (wasThatTrue) {
+ return "Yes, that was true";
+ }
+ return "No, that was false";
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/use-multiple-conditional-ternary-operators.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/use-multiple-conditional-ternary-operators.md
new file mode 100644
index 0000000000..7bb646a50a
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/use-multiple-conditional-ternary-operators.md
@@ -0,0 +1,96 @@
+---
+id: 587d7b7e367417b2b2512b21
+title: 使用多個三元運算符
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cyWJBT4'
+forumTopicId: 301179
+dashedName: use-multiple-conditional-ternary-operators
+---
+
+# --description--
+
+在之前的挑戰中，你使用了一個條件運算符。 你也可以將多個運算符串聯在一起以檢查多種條件。
+
+下面的函數使用 `if`，`else if` 和 `else` 語句來檢查多個條件：
+
+```js
+function findGreaterOrEqual(a, b) {
+ if (a === b) {
+ return "a and b are equal";
+ }
+ else if (a > b) {
+ return "a is greater";
+ }
+ else {
+ return "b is greater";
+ }
+}
+```
+
+以上函數可以使用多個三元運算符重寫：
+
+```js
+function findGreaterOrEqual(a, b) {
+ return (a === b) ? "a and b are equal"
+ : (a > b) ? "a is greater"
+ : "b is greater";
+}
+```
+
+如上文所示，對多個三元運算符進行每個條件都是單獨一行的格式化被認爲是最佳做法。 使用多個三元運算符而沒有適當的縮進可能會使您的代碼難以理解。 例如：
+
+```js
+function findGreaterOrEqual(a, b) {
+ return (a === b) ? "a and b are equal" : (a > b) ? "a is greater" : "b is greater";
+}
+```
+
+# --instructions--
+
+在 `checkSign` 函數中使用多個三元運算符來檢查數字是正數 ("positive")、負數 ("negative") 或零 ("zero")，使用 `findGreaterOrEqual` 裏面的建議縮進格式。 函數應返回 `positive`、`negative` 或 `zero`。
+
+# --hints--
+
+`checkSign` 應該使用多個三元運算符。
+
+```js
+assert(/.+?\s*?\?\s*?.+?\s*?:\s*?.+?\s*?\?\s*?.+?\s*?:\s*?.+?/gi.test(code));
+```
+
+`checkSign(10)` 應該返回字符串 `positive`。 注意區分大寫字母和小寫字母。
+
+```js
+assert(checkSign(10) === 'positive');
+```
+
+`checkSign(-12)` 應該返回字符串 `negative`。 注意區分大寫字母和小寫字母。
+
+```js
+assert(checkSign(-12) === 'negative');
+```
+
+`checkSign(0)` 應該返回字符串 `zero`. 注意區分大寫字母和小寫字母。
+
+```js
+assert(checkSign(0) === 'zero');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function checkSign(num) {
+
+}
+
+checkSign(10);
+```
+
+# --solutions--
+
+```js
+function checkSign(num) {
+ return (num > 0) ? 'positive' : (num < 0) ? 'negative' : 'zero';
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/use-recursion-to-create-a-countdown.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/use-recursion-to-create-a-countdown.md
new file mode 100644
index 0000000000..62257d1422
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/use-recursion-to-create-a-countdown.md
@@ -0,0 +1,92 @@
+---
+id: 5cd9a70215d3c4e65518328f
+title: 使用遞歸創建一個倒計時
+challengeType: 1
+forumTopicId: 305925
+dashedName: use-recursion-to-create-a-countdown
+---
+
+# --description--
+
+在上一個[挑戰](/learn/javascript-algorithms-and-data-structures/basic-javascript/replace-loops-using-recursion)，學習了怎樣用遞歸來代替 `for` 循環。 現在來學習一個更復雜的函數，函數返回一個從 `1` 到傳遞給函數的指定數字的連續數字數組。
+
+正如上一個挑戰提到的，會有一個 base case 。 base case 告訴遞歸函數什麼時候不在需要調用其自身。 這是簡單 情況，返回得到的值。 還有 recursive call ，繼續用不同的參數調用自身。 如果函數無誤，一直執行直到 base case 爲止。
+
+比如，如果想寫一個遞歸函數，返回一個數字 `1` 到 `n` 的連續數組。 這個函數需要接收一個參數 `n` 代表最終數字。 然後會持續的調用自身，傳入一個比 `n` 更小的值一直到傳入的值是 `1` 爲止。 函數如下：
+
+```javascript
+function countup(n) {
+ if (n < 1) {
+ return [];
+ } else {
+ const countArray = countup(n - 1);
+ countArray.push(n);
+ return countArray;
+ }
+}
+console.log(countup(5));
+```
+
+值 `[1, 2, 3, 4, 5]` 將顯示在控制檯中。
+
+起初，這似乎是違反直覺的，因爲 `n` 的值*遞減*，但是最終數組中的值卻*遞增*。 之所以發生這種情況，是因爲在遞歸調用返回之後，才調用 push。 在將 `n` pushed 進數組時，`countup(n - 1)` 已經調用賦值成功並返回了 `[1, 2, ..., n - 1]`。
+
+# --instructions--
+
+已經定義了一個函數 `countdown`，函數有一個參數（`n`）。 函數應該基於參數 `n` 遞歸調用返回 `n` 到 `1` 的連續數字的數組。 如果函數以小於 1 的參數調用，函數應該返回空數組。 比如，用 `n = 5` 調用函數應該返回數組 `[5, 4, 3, 2, 1]`。 函數必需使用遞歸函數調用自身，不能使用任何形式的循環。
+
+# --hints--
+
+`countdown(-1)` 應該返回一個空數組。
+
+```js
+assert.isEmpty(countdown(-1));
+```
+
+`countdown(10)` 應該返回 `[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]`。
+
+```js
+assert.deepStrictEqual(countdown(10), [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]);
+```
+
+`countdown(5)` 應該返回 `[5, 4, 3, 2, 1]`。
+
+```js
+assert.deepStrictEqual(countdown(5), [5, 4, 3, 2, 1]);
+```
+
+代碼不能包含任意形式的循環（`for`、`while` 或者高階函數如：`forEach`、`map`、`filter` 以及 `reduce`）。
+
+```js
+assert(
+ !code.match(/for|while|forEach|map|filter|reduce/g)
+);
+```
+
+應該用遞歸解決這個問題。
+
+```js
+assert(
+ countdown.toString().match(/countdown\s*\(.+\)/)
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// Only change code below this line
+function countdown(n){
+ return;
+}
+// Only change code above this line
+```
+
+# --solutions--
+
+```js
+function countdown(n){
+ return n < 1 ? [] : [n].concat(countdown(n - 1));
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/use-recursion-to-create-a-range-of-numbers.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/use-recursion-to-create-a-range-of-numbers.md
new file mode 100644
index 0000000000..3f90aeba41
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/use-recursion-to-create-a-range-of-numbers.md
@@ -0,0 +1,81 @@
+---
+id: 5cc0bd7a49b71cb96132e54c
+title: 使用遞歸來創建一個數字序列
+challengeType: 1
+forumTopicId: 301180
+dashedName: use-recursion-to-create-a-range-of-numbers
+---
+
+# --description--
+
+接着上一個挑戰，有另外一個機會來用遞歸函數解決問題。
+
+# --instructions--
+
+已經定義好了 `rangeOfNumbers` 函數，包含兩個參數。 函數應該返回一個連續數字數組，`startNum` 參數開始 `endNum` 參數截止。 開始的數字小於或等於截止數字。 函數必需遞歸調用自身，不能使用任意形式的循環。 要考慮到 `startNum` 和 `endNum` 相同的情況。
+
+# --hints--
+
+函數應該返回一個數組。
+
+```js
+assert(Array.isArray(rangeOfNumbers(5, 10)));
+```
+
+不能包含循環語句（`for` 或者 `while` 或者高階函數比如 `forEach`、`map`、`filter` 或者 `reduce`）。
+
+```js
+assert(
+ !code.match(/for|while|forEach|map|filter|reduce/g)
+);
+```
+
+`rangeOfNumbers` 應該使用遞歸函數（調用自身）來完成這個挑戰。
+
+```js
+assert(
+ rangeOfNumbers.toString().match(/rangeOfNumbers\s*\(.+\)/)
+);
+```
+
+`rangeOfNumbers(1, 5)` 應該返回 `[1, 2, 3, 4, 5]`。
+
+```js
+assert.deepStrictEqual(rangeOfNumbers(1, 5), [1, 2, 3, 4, 5]);
+```
+
+`rangeOfNumbers(6, 9)` 應該返回 `[6, 7, 8, 9]`。
+
+```js
+assert.deepStrictEqual(rangeOfNumbers(6, 9), [6, 7, 8, 9]);
+```
+
+`rangeOfNumbers(4, 4)` 應該返回 `[4]`。
+
+```js
+assert.deepStrictEqual(rangeOfNumbers(4, 4), [4]);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function rangeOfNumbers(startNum, endNum) {
+ return [];
+};
+```
+
+# --solutions--
+
+```js
+function rangeOfNumbers(startNum, endNum) {
+ if (endNum - startNum === 0) {
+ return [startNum];
+ } else {
+ var numbers = rangeOfNumbers(startNum, endNum - 1);
+ numbers.push(endNum);
+ return numbers;
+ }
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/use-the-conditional-ternary-operator.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/use-the-conditional-ternary-operator.md
new file mode 100644
index 0000000000..f21c47bfed
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/use-the-conditional-ternary-operator.md
@@ -0,0 +1,84 @@
+---
+id: 587d7b7e367417b2b2512b24
+title: 使用三元運算符
+challengeType: 1
+forumTopicId: 301181
+dashedName: use-the-conditional-ternary-operator
+---
+
+# --description--
+
+條件運算符（ conditional operator ,）（也稱爲三元運算符（ ternary operator ））的就像寫成一行的 if-else 表達式
+
+語法是 `a ？ b: c`，其中 `a` 是條件，`b` 是條件返回 `true` 時要運行的代碼，`c` 是條件返回 `false` 時要運行的代碼。
+
+以下函數使用 `if/else` 語句來檢查條件：
+
+```js
+function findGreater(a, b) {
+ if(a > b) {
+ return "a is greater";
+ }
+ else {
+ return "b is greater";
+ }
+}
+```
+
+這可以使用三元運算符重寫：
+
+```js
+function findGreater(a, b) {
+ return a > b ? "a is greater" : "b is greater";
+}
+```
+
+# --instructions--
+
+在 `checkEqual` 函數中使用三元運算符檢查兩個數字是否相等。 函數應該返回 `Equal` 或字符串 `Not Equal`。
+
+# --hints--
+
+`checkEqual` 應該使用條件運算符。
+
+```js
+assert(/.+?\s*?\?\s*?.+?\s*?:\s*?.+?/.test(code));
+```
+
+`checkEqual(1, 2)` 應該返回字符串 `Not Equal`
+
+```js
+assert(checkEqual(1, 2) === 'Not Equal');
+```
+
+`checkEqual(1, 1)` 應該返回字符串 `Equal`
+
+```js
+assert(checkEqual(1, 1) === 'Equal');
+```
+
+`checkEqual(1, -1)` 應該返回字符串 `Not Equal`
+
+```js
+assert(checkEqual(1, -1) === 'Not Equal');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function checkEqual(a, b) {
+
+}
+
+checkEqual(1, 2);
+```
+
+# --solutions--
+
+```js
+function checkEqual(a, b) {
+ return a === b ? "Equal" : "Not Equal";
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/use-the-parseint-function-with-a-radix.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/use-the-parseint-function-with-a-radix.md
new file mode 100644
index 0000000000..609ac68da9
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/use-the-parseint-function-with-a-radix.md
@@ -0,0 +1,82 @@
+---
+id: 587d7b7e367417b2b2512b22
+title: 使用 parseInt 函數並傳入一個基數
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c6K4Kh3'
+forumTopicId: 301182
+dashedName: use-the-parseint-function-with-a-radix
+---
+
+# --description--
+
+`parseInt()` 函數解析一個字符串並返回一個整數。 它還可以傳入第二個參數，指定了字符串中數字的基數。 基數可以是 2 到 36 之間的整數。
+
+函數調用如下所示：
+
+```js
+parseInt(string, radix);
+```
+
+這是一個示例：
+
+```js
+var a = parseInt("11", 2);
+```
+
+變量 radix 表示 `11` 是在二進制系統中。 這個示例將字符串 `11` 轉換爲整數 `3`。
+
+# --instructions--
+
+在 `convertToInteger` 函數中使用 `parseInt()` ，將二進制數轉換爲整數並返回。
+
+# --hints--
+
+`convertToInteger` 應該使用 `parseInt()` 函數。
+
+```js
+assert(/parseInt/g.test(code));
+```
+
+`convertToInteger("10011")` 應該返回一個數字。
+
+```js
+assert(typeof convertToInteger('10011') === 'number');
+```
+
+`convertToInteger("10011")` 應該返回 19。
+
+```js
+assert(convertToInteger('10011') === 19);
+```
+
+`convertToInteger("111001")` 應該返回 57。
+
+```js
+assert(convertToInteger('111001') === 57);
+```
+
+`convertToInteger("JamesBond")`應該返回 `NaN`。
+
+```js
+assert.isNaN(convertToInteger('JamesBond'));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function convertToInteger(str) {
+
+}
+
+convertToInteger("10011");
+```
+
+# --solutions--
+
+```js
+function convertToInteger(str) {
+ return parseInt(str, 2);
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/use-the-parseint-function.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/use-the-parseint-function.md
new file mode 100644
index 0000000000..67934c4d25
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/use-the-parseint-function.md
@@ -0,0 +1,74 @@
+---
+id: 587d7b7e367417b2b2512b23
+title: 使用 parseInt 函數
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cm83LSW'
+forumTopicId: 301183
+dashedName: use-the-parseint-function
+---
+
+# --description--
+
+`parseInt()` 函數解析一個字符串返回一個整數。 下面是一個示例：
+
+```js
+var a = parseInt("007");
+```
+
+上述函數將字符串 `007` 轉換爲整數 `7`。 如果字符串中的第一個字符不能轉換爲數字，則返回 `NaN`。
+
+# --instructions--
+
+在 `convertToInteger` 函數中使用 `parseInt()` 將字符串 `str` 轉換爲一個整數，並返回這個值。
+
+# --hints--
+
+`convertToInteger` 中應該使用 `parseInt()` 函數。
+
+```js
+assert(/parseInt/g.test(code));
+```
+
+`convertToInteger("56")` 應該返回一個數字。
+
+```js
+assert(typeof convertToInteger('56') === 'number');
+```
+
+`convertToInteger("56")` 應該返回 56。
+
+```js
+assert(convertToInteger('56') === 56);
+```
+
+`convertToInteger("77")` 應該返回 77。
+
+```js
+assert(convertToInteger('77') === 77);
+```
+
+`convertToInteger("JamesBond")` 應該返回 `NaN`。
+
+```js
+assert.isNaN(convertToInteger('JamesBond'));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function convertToInteger(str) {
+
+}
+
+convertToInteger("56");
+```
+
+# --solutions--
+
+```js
+function convertToInteger(str) {
+ return parseInt(str);
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/using-objects-for-lookups.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/using-objects-for-lookups.md
new file mode 100644
index 0000000000..0e12a75981
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/using-objects-for-lookups.md
@@ -0,0 +1,154 @@
+---
+id: 56533eb9ac21ba0edf2244ca
+title: 使用對象進行查找
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cdBk8sM'
+forumTopicId: 18373
+dashedName: using-objects-for-lookups
+---
+
+# --description--
+
+對象和字典一樣，可以用來存儲鍵/值對。 如果數據是扁平的，你可以用對象來查找你想要的值，而不是鏈式使用 `switch` 或 `if/else` 語句。 當你知道你的輸入數據在某個範圍時，這種查找方式極爲有效。
+
+這是簡單的反向字母表：
+
+```js
+var alpha = {
+ 1:"Z",
+ 2:"Y",
+ 3:"X",
+ 4:"W",
+ ...
+ 24:"C",
+ 25:"B",
+ 26:"A"
+};
+alpha[2];
+alpha[24];
+
+var value = 2;
+alpha[value];
+```
+
+`alpha[2]` 是字符串 `Y`，`alpha[24]` 是字符串 `C`，`alpha[value]` 是字符串 `Y`。
+
+# --instructions--
+
+把 switch 語句轉化爲對象 `lookup` 調用。 使用它來查找 `val` 屬性的值，並賦值給 `result` 變量。
+
+# --hints--
+
+`phoneticLookup("alpha")` 應該等於 `Adams`
+
+```js
+assert(phoneticLookup('alpha') === 'Adams');
+```
+
+`phoneticLookup("bravo")` 應該等於 `Boston`
+
+```js
+assert(phoneticLookup('bravo') === 'Boston');
+```
+
+`phoneticLookup("charlie")` 應該等於 `Chicago`
+
+```js
+assert(phoneticLookup('charlie') === 'Chicago');
+```
+
+`phoneticLookup("delta")` 應該等於 `Denver`
+
+```js
+assert(phoneticLookup('delta') === 'Denver');
+```
+
+`phoneticLookup("echo")` 應該等於 `Easy`
+
+```js
+assert(phoneticLookup('echo') === 'Easy');
+```
+
+`phoneticLookup("foxtrot")` 應該等於字符串 `Frank`
+
+```js
+assert(phoneticLookup('foxtrot') === 'Frank');
+```
+
+`phoneticLookup("")` 應該等於 `undefined`。
+
+```js
+assert(typeof phoneticLookup('') === 'undefined');
+```
+
+請不要修改 `return` 語句
+
+```js
+assert(code.match(/return\sresult;/));
+```
+
+請不要使用 `case`、`switch`、`if` 語句
+
+```js
+assert(
+ !/case|switch|if/g.test(code.replace(/([/]{2}.*)|([/][*][^/*]*[*][/])/g, ''))
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// Setup
+function phoneticLookup(val) {
+ var result = "";
+
+ // Only change code below this line
+ switch(val) {
+ case "alpha":
+ result = "Adams";
+ break;
+ case "bravo":
+ result = "Boston";
+ break;
+ case "charlie":
+ result = "Chicago";
+ break;
+ case "delta":
+ result = "Denver";
+ break;
+ case "echo":
+ result = "Easy";
+ break;
+ case "foxtrot":
+ result = "Frank";
+ }
+
+ // Only change code above this line
+ return result;
+}
+
+phoneticLookup("charlie");
+```
+
+# --solutions--
+
+```js
+function phoneticLookup(val) {
+ var result = "";
+
+ var lookup = {
+ alpha: "Adams",
+ bravo: "Boston",
+ charlie: "Chicago",
+ delta: "Denver",
+ echo: "Easy",
+ foxtrot: "Frank"
+ };
+
+ result = lookup[val];
+
+ return result;
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/word-blanks.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/word-blanks.md
new file mode 100644
index 0000000000..533e82a3dd
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/word-blanks.md
@@ -0,0 +1,107 @@
+---
+id: 56533eb9ac21ba0edf2244bb
+title: 填詞造句
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/caqn8zuP'
+forumTopicId: 18377
+dashedName: word-blanks
+---
+
+# --description--
+
+現在，我們來用字符串的相關知識實現一個 "[Mad Libs](https://en.wikipedia.org/wiki/Mad_Libs)" 類的文字遊戲，稱爲 "Word Blanks"。 你將創建一個（可選幽默的）“填空”樣式句子。
+
+在 "Mad Libs" 遊戲中，提供一個缺少一些單詞的句子，缺少的單詞包括名詞、動詞、形容詞和副詞等。 然後，你選擇一些單詞填寫句子缺失的地方，使句子完整並且有意義。
+
+思考一下這句話 - It was really **\_\_\_\_**, and we **\_\_\_\_** ourselves **\_\_\_\_**。 這句話有三個缺失的部分 - 形容詞、動詞和副詞，選擇合適單詞填入完成它。 然後將完成的句子賦值給變量，如下所示：
+
+```js
+var sentence = "It was really " + "hot" + ", and we " + "laughed" + " ourselves " + "silly" + ".";
+```
+
+# --instructions--
+
+在這個挑戰中，我們爲你提供名詞、動詞、形容詞和副詞。 你需要使用合適單詞以及我們提供的單詞來形成完整的句子。
+
+你需要使用字符串連接運算符 `+` 來拼接字符串變量：`myNoun`、`myAdjective`、`myVerb` 和 `myAdverb` 來構建一個新字符串。 然後，將新字符串賦給 `wordBlanks` 變量。 您不應該更改分配給變量的單詞。
+
+你還需要考慮字符串中的空格，確保句子的所有單詞之間有空格。 結果應該是一個完整的句子。
+
+# --hints--
+
+`wordBlanks` 應該返回一個字符串。
+
+```js
+assert(typeof wordBlanks === 'string');
+```
+
+不能改變 `myNoun`、`myVerb`、`myAdjective` 或者 `myAdverb` 的值。
+
+```js
+assert(
+ myNoun === 'dog' &&
+ myVerb === 'ran' &&
+ myAdjective === 'big' &&
+ myAdverb === 'quickly'
+);
+```
+
+您不應該直接使用 `dog`、`ran`、`big` 或 `quickly` 來創建 `wordBlanks`。
+
+```js
+const newCode = removeAssignments(code);
+assert(
+ !/dog/.test(newCode) &&
+ !/ran/.test(newCode) &&
+ !/big/.test(newCode) &&
+ !/quickly/.test(newCode)
+);
+```
+
+`wordBlanks` 應包含賦值給變量 `myNoun`、`myVerb`、`myAdjective` 和 `myAdverb` 的所有單詞，並用非單詞字符（以及 madlib 中的其它單詞）分隔。
+
+```js
+assert(
+ /\bdog\b/.test(wordBlanks) &&
+ /\bbig\b/.test(wordBlanks) &&
+ /\bran\b/.test(wordBlanks) &&
+ /\bquickly\b/.test(wordBlanks)
+);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+const removeAssignments = str => str
+ .replace(/myNoun\s*=\s*["']dog["']/g, '')
+ .replace(/myAdjective\s*=\s*["']big["']/g, '')
+ .replace(/myVerb\s*=\s*["']ran["']/g, '')
+ .replace(/myAdverb\s*=\s*["']quickly["']/g, '');
+```
+
+## --seed-contents--
+
+```js
+var myNoun = "dog";
+var myAdjective = "big";
+var myVerb = "ran";
+var myAdverb = "quickly";
+
+// Only change code below this line
+var wordBlanks = ""; // Change this line
+// Only change code above this line
+```
+
+# --solutions--
+
+```js
+var myNoun = "dog";
+var myAdjective = "big";
+var myVerb = "ran";
+var myAdverb = "quickly";
+
+var wordBlanks = "Once there was a " + myNoun + " which was very " + myAdjective + ". ";
+wordBlanks += "It " + myVerb + " " + myAdverb + " around the yard.";
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/write-reusable-javascript-with-functions.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/write-reusable-javascript-with-functions.md
new file mode 100644
index 0000000000..efa8b30faf
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/basic-javascript/write-reusable-javascript-with-functions.md
@@ -0,0 +1,94 @@
+---
+id: 56bbb991ad1ed5201cd392cf
+title: 用函數編寫可重用代碼
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cL6dqfy'
+forumTopicId: 18378
+dashedName: write-reusable-javascript-with-functions
+---
+
+# --description--
+
+在 JavaScript 中，我們可以把代碼的重複部分抽取出來，放到一個函數 （functions ）中。
+
+舉個例子：
+
+```js
+function functionName() {
+ console.log("Hello World");
+}
+```
+
+你可以通過函數名加上後面的小括號來調用（invoke ）這個函數，就像這樣： `functionName();` 每次調用函數時，它都會在控制檯上打印消息 `Hello World`。 每次調用函數時，大括號之間的所有代碼都將被執行。
+
+# --instructions--
+
+先創建一個名爲 reusableFunction 的函數，這個函數可以打印 "Hi World" 到控制檯上。 然後調用這個函數。 /g));
+```
+
+你應該在整個字符串外圍保留雙引號。
+
+```js
+assert(code.match(/".*?<\/p>";/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let innerHtml = "
Click here to return home
";
+console.log(innerHtml);
+```
+
+# --solutions--
+
+```js
+let innerHtml = "Click here to return home
";
+console.log(innerHtml);
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/debugging/catch-off-by-one-errors-when-using-indexing.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/debugging/catch-off-by-one-errors-when-using-indexing.md
new file mode 100644
index 0000000000..0219990ac5
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/debugging/catch-off-by-one-errors-when-using-indexing.md
@@ -0,0 +1,93 @@
+---
+id: 587d7b86367417b2b2512b3b
+title: 捕獲使用索引的時候出現的錯誤
+challengeType: 1
+forumTopicId: 301189
+dashedName: catch-off-by-one-errors-when-using-indexing
+---
+
+# --description--
+
+當試圖訪問字符串或數組的特定索引（分割或訪問一個片段）或循環索引時，有時會出現 Off by one errors 錯誤（有時稱爲 OBOE）。 JavaScript 索引從 0 開始，而不是 1，這意味着最後一個索引總會比字符串或數組的長度少 1。 如果嘗試訪問等於長度的索引，程序可能會拋出“索引超出範圍”引用錯誤或打印出 `undefined`。
+
+當使用將索引範圍作爲參數的字符串或數組方法時，閱讀相關的文檔並瞭解參數中的索引的包含性（即是否考慮進返回值中）很重要。 以下是一些錯誤的示例：
+
+```js
+let alphabet = "abcdefghijklmnopqrstuvwxyz";
+let len = alphabet.length;
+for (let i = 0; i <= len; i++) {
+ console.log(alphabet[i]);
+}
+for (let j = 1; j < len; j++) {
+ console.log(alphabet[j]);
+}
+for (let k = 0; k < len; k++) {
+ console.log(alphabet[k]);
+}
+```
+
+第一個例子多了一次循環，第二個例子少了一次循環（漏掉了索引 0 處的字符）， 第三個例子是正確的。
+
+# --instructions--
+
+修復以下函數中的兩個索引錯誤，將 1 到 5 之間（包含 1 和 5）的所有數字打印到控制檯。
+
+# --hints--
+
+應該設置循環的初始條件，使循環從第一個索引開始。
+
+```js
+assert(code.match(/i\s*?=\s*?0\s*?;/g).length == 1);
+```
+
+應修復循環的初始條件，使循環從索引 0 開始。
+
+```js
+assert(!code.match(/i\s?=\s*?1\s*?;/g));
+```
+
+應該設置循環的終止條件，使循環在最後一個索引處停止。
+
+```js
+assert(code.match(/i\s*?<\s*?len\s*?;/g).length == 1);
+```
+
+應該修復循環的終止條件，使循環在索引爲字符串長度減 1 的位置停止。
+
+```js
+assert(!code.match(/i\s*?<=\s*?len;/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function countToFive() {
+ let firstFive = "12345";
+ let len = firstFive.length;
+ // Only change code below this line
+ for (let i = 1; i <= len; i++) {
+ // Only change code above this line
+ console.log(firstFive[i]);
+ }
+}
+
+countToFive();
+```
+
+# --solutions--
+
+```js
+function countToFive() {
+ let firstFive = "12345";
+ let len = firstFive.length;
+ // Only change code below this line
+ for (let i = 0; i < len; i++) {
+ // Only change code above this line
+ console.log(firstFive[i]);
+ }
+}
+
+countToFive();
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/debugging/catch-unclosed-parentheses-brackets-braces-and-quotes.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/debugging/catch-unclosed-parentheses-brackets-braces-and-quotes.md
new file mode 100644
index 0000000000..e9a3695c6d
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/debugging/catch-unclosed-parentheses-brackets-braces-and-quotes.md
@@ -0,0 +1,49 @@
+---
+id: 587d7b84367417b2b2512b36
+title: '捕獲未閉合的括號、方括號、大括號和引號'
+challengeType: 1
+forumTopicId: 301190
+dashedName: catch-unclosed-parentheses-brackets-braces-and-quotes
+---
+
+# --description--
+
+要注意的另一個語法錯誤是所有的小括號、方括號、花括號和引號都必須配對。 當你編輯代碼並插入新代碼其中帶有括號時，很容易忘記括號閉合。 此外，在將代碼塊嵌套到其他代碼塊時要小心，例如將回調函數作爲參數添加到方法中。
+
+避免這種錯誤的一種方法是，一次性輸入完這些符號，然後將光標移回它們之間繼續編寫。 好在現在大部分編輯器都會幫你自動補全。
+
+# --instructions--
+
+修復代碼中的兩個符號配對錯誤。
+
+# --hints--
+
+應該修復數組缺少的部分。
+
+```js
+assert(code.match(/myArray\s*?=\s*?\[\s*?1\s*?,\s*?2\s*?,\s*?3\s*?\];/g));
+```
+
+應該修復 `.reduce()` 方法缺少的部分。 控制檯應該輸出 `Sum of array values is: 6`。
+
+```js
+assert(arraySum === 6);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let myArray = [1, 2, 3;
+let arraySum = myArray.reduce((previous, current => previous + current);
+console.log(`Sum of array values is: ${arraySum}`);
+```
+
+# --solutions--
+
+```js
+let myArray = [1, 2, 3];
+let arraySum = myArray.reduce((previous, current) => previous + current);
+console.log(`Sum of array values is: ${arraySum}`);
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/debugging/catch-use-of-assignment-operator-instead-of-equality-operator.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/debugging/catch-use-of-assignment-operator-instead-of-equality-operator.md
new file mode 100644
index 0000000000..6f80b4306a
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/debugging/catch-use-of-assignment-operator-instead-of-equality-operator.md
@@ -0,0 +1,81 @@
+---
+id: 587d7b85367417b2b2512b38
+title: 捕獲使用賦值運算符而不是相等運算符
+challengeType: 1
+forumTopicId: 301191
+dashedName: catch-use-of-assignment-operator-instead-of-equality-operator
+---
+
+# --description--
+
+分支程序，即在滿足某些條件時執行不同操作的程序，依賴於 JavaScript 中的`if`，`else if`、`else`語句。 條件有時採取測試一個結果是否等於一個值的形式。
+
+這種邏輯可以表述爲“如果 x 等於 y ，則......”，聽起來像是可以使用 `=`（即賦值運算符）。 然而，這會導致程序中流程出問題。
+
+如前面的挑戰所述，JavaScript 中的賦值運算符 (`=`) 是用來爲變量名賦值的。 並且 `==` 和 `===` 運算符檢查相等性（三等號 `===` 是用來測試是否嚴格相等的，嚴格相等的意思是值和類型都必須相同）。
+
+下面的代碼將 `x` 賦值爲 2，表達式會在執行後得到 `true`。 JavaScript 會把大部分的值都視爲 `true`，除了所謂的 “falsy”值，即：`false`、`0`、`""`（空字符串）、`NaN`、`undefined` 和 `null`。
+
+```js
+let x = 1;
+let y = 2;
+if (x = y) {
+
+} else {
+
+}
+```
+
+在這個示例中，除非 `y` 值是假值，否則當 `y` 爲任何值時，`if` 語句中的代碼塊都會運行。 我們期望運行的 `else` 代碼塊實際上將不會運行。
+
+# --instructions--
+
+修復條件語句，以便程序運行正確的分支，並給 `result` 賦正確的值。
+
+# --hints--
+
+應該修復條件語句，使其判斷是否相等，而不是賦值。
+
+```js
+assert(result == 'Not equal!');
+```
+
+條件語句可以使用 `==` 或 `===` 來測試是否相等。
+
+```js
+assert(code.match(/x\s*?===?\s*?y/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let x = 7;
+let y = 9;
+let result = "to come";
+
+if(x = y) {
+ result = "Equal!";
+} else {
+ result = "Not equal!";
+}
+
+console.log(result);
+```
+
+# --solutions--
+
+```js
+let x = 7;
+let y = 9;
+let result = "to come";
+
+if(x === y) {
+ result = "Equal!";
+} else {
+ result = "Not equal!";
+}
+
+console.log(result);
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/debugging/prevent-infinite-loops-with-a-valid-terminal-condition.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/debugging/prevent-infinite-loops-with-a-valid-terminal-condition.md
new file mode 100644
index 0000000000..7a684f366c
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/debugging/prevent-infinite-loops-with-a-valid-terminal-condition.md
@@ -0,0 +1,63 @@
+---
+id: 587d7b86367417b2b2512b3d
+title: 使用有效的終止條件防止無限循環
+challengeType: 1
+forumTopicId: 301192
+dashedName: prevent-infinite-loops-with-a-valid-terminal-condition
+---
+
+# --description--
+
+最後一個話題是可怕的無限循環。 當需要程序運行代碼塊一定次數或滿足條件時，循環是很好的工具，但是它們需要終止條件來結束循環。 無限循環可能會使瀏覽器凍結或崩潰，並導致程序執行混亂，沒有人想要這樣的結果。
+
+在本節的介紹中有一個無限循環的例子——它沒有終止條件來擺脫`loopy()`內的`while`循環。 不要調用這個函數！
+
+```js
+function loopy() {
+ while(true) {
+ console.log("Hello, world!");
+ }
+}
+```
+
+程序員的工作是確保最終達到終止條件，該條件告訴程序何時跳出循環。 有一種錯誤是從終端條件向錯誤方向遞增或遞減計數器變量。 另一種是在循環代碼中意外重置計數器或索引變量，而不是遞增或遞減它。
+
+# --instructions--
+
+`myFunc()`函數包含一個無限循環，因爲終止條件`i != 4`永遠不會爲`false`(並中斷循環) -`i`將每次遞增 2，然後跳過 4，因爲`i`是從奇數開始遞增。 在終端條件中輸入比較運算符，使循環僅在`i`小於或等於 4 的情況下運行。
+
+# --hints--
+
+你應該在`for`循環的終止條件（中間部分）中更改比較運算符。
+
+```js
+assert(code.match(/i\s*?<=\s*?4;/g).length == 1);
+```
+
+你應該修改比較運算符來避免出現死循環。
+
+```js
+assert(!code.match(/i\s*?!=\s*?4;/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function myFunc() {
+ for (let i = 1; i != 4; i += 2) {
+ console.log("Still going!");
+ }
+}
+```
+
+# --solutions--
+
+```js
+function myFunc() {
+ for (let i = 1; i <= 4; i += 2) {
+ console.log("Still going!");
+ }
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/debugging/understanding-the-differences-between-the-freecodecamp-and-browser-console.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/debugging/understanding-the-differences-between-the-freecodecamp-and-browser-console.md
new file mode 100644
index 0000000000..fedfc3f26d
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/debugging/understanding-the-differences-between-the-freecodecamp-and-browser-console.md
@@ -0,0 +1,73 @@
+---
+id: 587d7b83367417b2b2512b37
+title: 瞭解 freeCodeCamp 和瀏覽器控制檯之間的差異
+challengeType: 1
+forumTopicId: 301193
+dashedName: understanding-the-differences-between-the-freecodecamp-and-browser-console
+---
+
+# --description--
+
+你可能已經注意到一些 freeCodeCamp JavaScript 的挑戰有自己的控制檯。 這些控制檯的行爲與上一次挑戰中使用的瀏覽器控制檯略有不同。
+
+以下挑戰旨在強調 freeCodeCamp 控制檯與瀏覽器控制檯之間的一些差異。
+
+當在瀏覽器中加載並運行 JavaScript 文件時，`console.log()` 語句會在控制檯中按照調用的次數準確地打印出要求的內容。
+
+在編輯器檢測到腳本中的更改之後，以及測試期間，freeCodeCamp 控制檯將打印 `console.log()` 語句。
+
+在運行測試之前，將清除 freeCodeCamp 控制檯，爲避免破壞，僅在第一次測試期間打印日誌（請參見下面的註釋）。
+
+如果你想看到每次測試的日誌，運行測試，並打開瀏覽器控制檯。 如果你喜歡使用瀏覽器控制檯，想要它模仿 freeCodeCamp 控制檯，請在其他 `console` 調用前加上 `console.clear()`，以清除瀏覽器控制檯。
+
+**注意：** 每次調用函數時，函數內的 `console.log` 都會被打印到 freeCodeCamp 控制檯。 這樣可以幫助在測試期間調試函數。
+
+# --instructions--
+
+首先，使用 `console.log` 打印 `output` 變量。 然後使用 `console.clear` 清除瀏覽器控制檯。
+
+# --hints--
+
+應該使用 `console.clear()` 清除瀏覽器控制檯。
+
+```js
+assert(
+ __helpers
+ .removeWhiteSpace(code)
+ .match(/console.clear\(\)/)
+);
+```
+
+應該使用 `console.log()` 打印 `output` 變量。
+
+```js
+assert(__helpers.removeWhiteSpace(code).match(/console\.log\(output\)/));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// Open your browser console.
+let output = "Get this to log once in the freeCodeCamp console and twice in the browser console";
+// Use console.log() to print the output variable.
+
+// Run the tests to see the difference between the two consoles.
+
+// Now, add console.clear() before your console.log() to clear the browser console, and pass the tests.
+```
+
+# --solutions--
+
+```js
+// Open your browser console.
+let output = "Get this to log once in the freeCodeCamp console and twice in the browser console";
+// Use console.log() to print the output variable.
+console.clear();
+console.log(output);
+
+// Run the tests to see the difference between the two consoles.
+
+// Now, add console.clear() before your console.log() to clear the browser console, and pass the tests.
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/debugging/use-caution-when-reinitializing-variables-inside-a-loop.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/debugging/use-caution-when-reinitializing-variables-inside-a-loop.md
new file mode 100644
index 0000000000..241c2fd49e
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/debugging/use-caution-when-reinitializing-variables-inside-a-loop.md
@@ -0,0 +1,89 @@
+---
+id: 587d7b86367417b2b2512b3c
+title: 重新初始化循環中的變量時要小心
+challengeType: 1
+forumTopicId: 301194
+dashedName: use-caution-when-reinitializing-variables-inside-a-loop
+---
+
+# --description--
+
+有時需要在循環中保存信息以增加計數器或重置變量。 一個潛在的問題是變量什麼時候該重新初始化，什麼時候不該重新初始化，反之亦然。 如果你不小心重置了用於終止條件的變量，導致無限循環，這將特別危險。
+
+使用`console.log()`在每個循環中打印變量值可以發現與重置相關的錯誤或者重置變量失敗。
+
+# --instructions--
+
+以下函數應該創建一個具有`m`行和`n`列“零”的二維數組。 不幸的是，它沒有產生預期的輸出，因爲`row`變量沒有在外部循環中重新初始化（設置回空數組）。 修改代碼，使其正確地返回包含 3 行 2 列“零”的二維數組，即`[[0, 0], [0, 0], [0, 0]]`。
+
+# --hints--
+
+應將變量 `matrix` 設置爲 3 行 2 列“零”的二維數組。
+
+```js
+assert(JSON.stringify(matrix) == '[[0,0],[0,0],[0,0]]');
+```
+
+變量 `matrix` 應有 3 行。
+
+```js
+assert(matrix.length == 3);
+```
+
+變量 `matrix` 每行應有 2 列。
+
+```js
+assert(
+ matrix[0].length == 2 && matrix[1].length === 2 && matrix[2].length === 2
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function zeroArray(m, n) {
+ // Creates a 2-D array with m rows and n columns of zeroes
+ let newArray = [];
+ let row = [];
+ for (let i = 0; i < m; i++) {
+ // Adds the m-th row into newArray
+
+ for (let j = 0; j < n; j++) {
+ // Pushes n zeroes into the current row to create the columns
+ row.push(0);
+ }
+ // Pushes the current row, which now has n zeroes in it, to the array
+ newArray.push(row);
+ }
+ return newArray;
+}
+
+let matrix = zeroArray(3, 2);
+console.log(matrix);
+```
+
+# --solutions--
+
+```js
+function zeroArray(m, n) {
+ // Creates a 2-D array with m rows and n columns of zeroes
+ let newArray = [];
+ for (let i = 0; i < m; i++) {
+ let row = [];
+ // Adds the m-th row into newArray
+
+ for (let j = 0; j < n; j++) {
+ // Pushes n zeroes into the current row to create the columns
+ row.push(0);
+ }
+ // Pushes the current row, which now has n zeroes in it, to the array
+ newArray.push(row);
+ }
+ return newArray;
+}
+
+let matrix = zeroArray(3, 2);
+console.log(matrix);
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/debugging/use-the-javascript-console-to-check-the-value-of-a-variable.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/debugging/use-the-javascript-console-to-check-the-value-of-a-variable.md
new file mode 100644
index 0000000000..60788da7dd
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/debugging/use-the-javascript-console-to-check-the-value-of-a-variable.md
@@ -0,0 +1,54 @@
+---
+id: 587d7b83367417b2b2512b33
+title: 使用控制檯檢查變量值
+challengeType: 1
+forumTopicId: 18372
+dashedName: use-the-javascript-console-to-check-the-value-of-a-variable
+---
+
+# --description--
+
+Chrome 和 Firefox 都有出色的 JavaScript 控制檯（也稱爲 DevTools），可以用來調試 JavaScript 代碼
+
+可以在 Chrome 的菜單中找到“開發者工具”或 FireFox 的菜單中的 “Web 控制檯”。 如果你使用其他瀏覽器或手機，我們強烈建議你切換到桌面版 Firefox 或 Chrome。
+
+`console.log()` 方法可能是最有用的調試工具，它可以將括號中的內容輸出到控制檯。 將它放在代碼中的關鍵點可以顯示變量在當時的值。 在查看輸出之前，最好先想清楚輸出應該是什麼。 在整個代碼中使用檢查點來查看計算狀態將有助於縮小問題的範圍。
+
+下面是輸出 `Hello world!` 字符串到控制檯的示例：
+
+```js
+console.log('Hello world!');
+```
+
+# --instructions--
+
+使用 `console.log()` 方法打印代碼中記錄的變量 `a` 的值。
+
+# --hints--
+
+應使用 `console.log()` 來檢查變量 `a` 的值。
+
+```js
+assert(code.match(/console\.log\(a\)/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let a = 5;
+let b = 1;
+a++;
+// Only change code below this line
+
+
+let sumAB = a + b;
+console.log(sumAB);
+```
+
+# --solutions--
+
+```js
+var a = 5; console.log(a);
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/debugging/use-typeof-to-check-the-type-of-a-variable.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/debugging/use-typeof-to-check-the-type-of-a-variable.md
new file mode 100644
index 0000000000..b4b97f145e
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/debugging/use-typeof-to-check-the-type-of-a-variable.md
@@ -0,0 +1,66 @@
+---
+id: 587d7b84367417b2b2512b34
+title: 使用 type of 檢查變量的類型
+challengeType: 1
+forumTopicId: 18374
+dashedName: use-typeof-to-check-the-type-of-a-variable
+---
+
+# --description--
+
+可以使用 `typeof` 檢查變量的數據結構或類型。 在處理多種數據類型時，這會對調試很有幫助。 如果想計算兩數之和，但實際傳入了一個字符串參數，則結果可能是錯誤的。 類型錯誤可能隱藏在計算或函數調用中。 當你以 JavaScript 對象（JSON）的形式訪問和使用外部數據時尤其要小心。
+
+下面是使用 `typeof` 的一些示例：
+
+```js
+console.log(typeof "");
+console.log(typeof 0);
+console.log(typeof []);
+console.log(typeof {});
+```
+
+控制檯將按順序顯示字符串 `string`、`number`、`object` 和 `object`。
+
+JavaScript 有六種原始（不可變）數據類型：`Boolean`、`Null`、`Undefined`、`Number`、`String` 和 `Symbol`（ES6 中新增的），和一種可變的數據類型：`Object`。 注意：在 JavaScript 中，數組在本質上是一種對象。
+
+# --instructions--
+
+添加兩個 `console.log()` 語句來檢查代碼中的兩個變量 `seven` 和 `three` 的 `typeof` 值。
+
+# --hints--
+
+應在兩個 `console.log()` 語句中使用 `typeof` 來檢查變量的類型。
+
+```js
+assert(code.match(/console\.log\(typeof[\( ].*\)?\)/g).length == 2);
+```
+
+應使用 `typeof` 來檢查變量 `seven` 的類型。
+
+```js
+assert(code.match(/typeof[\( ]seven\)?/g));
+```
+
+應使用 `typeof` 來檢查變量 `three` 的類型。
+
+```js
+assert(code.match(/typeof[\( ]three\)?/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let seven = 7;
+let three = "3";
+console.log(seven + three);
+// Only change code below this line
+```
+
+# --solutions--
+
+```js
+let seven = 7;let three = "3";console.log(typeof seven);
+console.log(typeof three);
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/compare-scopes-of-the-var-and-let-keywords.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/compare-scopes-of-the-var-and-let-keywords.md
new file mode 100644
index 0000000000..07c7b45bca
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/compare-scopes-of-the-var-and-let-keywords.md
@@ -0,0 +1,135 @@
+---
+id: 587d7b87367417b2b2512b40
+title: 比較 var 和 let 關鍵字的作用域
+challengeType: 1
+forumTopicId: 301195
+dashedName: compare-scopes-of-the-var-and-let-keywords
+---
+
+# --description--
+
+使用 `var` 關鍵字來聲明一個變量的時候，這個變量會被聲明成全局變量，或是函數內的局部變量。
+
+`let` 關鍵字的作用與此類似，但會有一些額外的特性。 如果在代碼塊、語句或表達式中使用關鍵字 `let` 聲明變量，這個變量的作用域就被限制在當前的代碼塊、語句或表達式之中。
+
+舉個例子：
+
+```js
+var numArray = [];
+for (var i = 0; i < 3; i++) {
+ numArray.push(i);
+}
+console.log(numArray);
+console.log(i);
+```
+
+這裏控制檯將顯示值 `[0, 1, 2]` 和 `3`。
+
+因爲使用了 `var` 關鍵字，`i` 被聲明爲全局變量。 所以當 `i++` 執行時，它會更新全局變量。 這個代碼和下方的代碼類似：
+
+```js
+var numArray = [];
+var i;
+for (i = 0; i < 3; i++) {
+ numArray.push(i);
+}
+console.log(numArray);
+console.log(i);
+```
+
+這裏控制檯將顯示值 `[0, 1, 2]` 和 `3`。
+
+如果你創建一個函數，將它存儲起來，稍後在使用 `i` 變量的 `for` 循環中使用。這麼做可能會出現問題。 這是因爲存儲的函數會總是指向更新後的全局 `i` 變量的值。
+
+```js
+var printNumTwo;
+for (var i = 0; i < 3; i++) {
+ if (i === 2) {
+ printNumTwo = function() {
+ return i;
+ };
+ }
+}
+console.log(printNumTwo());
+```
+
+這裏控制檯將顯示值 `3`。
+
+可以看到，`printNumTwo()` 打印了 3，而不是 2。 這是因爲賦值給 `i` 的值已經更新，`printNumTwo()` 返回全局的 `i`，而不是在 for 循環中創建函數時 `i` 的值。 `let` 關鍵字就不會出現這種現象：
+
+```js
+let printNumTwo;
+for (let i = 0; i < 3; i++) {
+ if (i === 2) {
+ printNumTwo = function() {
+ return i;
+ };
+ }
+}
+console.log(printNumTwo());
+console.log(i);
+```
+
+在這裏控制檯將顯示值 `2` 和一個錯誤提示 `i is not defined`。
+
+`i` 未定義，因爲它沒有在全局範圍內聲明。 它只在 `for` 循環語句中被聲明。 `printNumTwo()` 返回了正確的值，因爲 `let` 關鍵字在循環語句中使 `i` 變量產生了三個不同的值（分別爲 0、1、2）。
+
+# --instructions--
+
+修改這段代碼，使 `if` 語句中聲明的 `i` 變量與在函數的第一行聲明的 `i` 變量是彼此獨立的。 請注意不要在你的代碼的任何地方使用 `var` 關鍵字。
+
+這個練習旨在表明使用 `var` 與 `let` 關鍵字聲明變量時作用域之間的區別。 當編寫類似這個練習中的函數的時候，通常來說最好使用不同的變量名，以避免混淆。
+
+# --hints--
+
+代碼中不應該出現 `var`。
+
+```js
+(getUserInput) => assert(!getUserInput('index').match(/var/g));
+```
+
+`if` 語句中聲明的變量 `i` 應該等於字符串 `block scope`。
+
+```js
+(getUserInput) =>
+ assert(
+ getUserInput('index').match(/(i\s*=\s*).*\s*.*\s*.*\1('|")block\s*scope\2/g)
+ );
+```
+
+`checkScope()` 應該返回字符串 `function scope`。
+
+```js
+assert(checkScope() === 'function scope');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function checkScope() {
+ var i = 'function scope';
+ if (true) {
+ i = 'block scope';
+ console.log('Block scope i is: ', i);
+ }
+ console.log('Function scope i is: ', i);
+ return i;
+}
+```
+
+# --solutions--
+
+```js
+function checkScope() {
+ let i = 'function scope';
+ if (true) {
+ let i = 'block scope';
+ console.log('Block scope i is: ', i);
+ }
+
+ console.log('Function scope i is: ', i);
+ return i;
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/complete-a-promise-with-resolve-and-reject.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/complete-a-promise-with-resolve-and-reject.md
new file mode 100644
index 0000000000..51cd70743f
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/complete-a-promise-with-resolve-and-reject.md
@@ -0,0 +1,77 @@
+---
+id: 5cdafbc32913098997531680
+title: 通過 resolve 和 reject 完成 Promise
+challengeType: 1
+forumTopicId: 301196
+dashedName: complete-a-promise-with-resolve-and-reject
+---
+
+# --description--
+
+Promise 有三個狀態：`pending`、`fulfilled` 和 `rejected`。 上一個挑戰裏創建的 promise 一直阻塞在 `pending` 狀態裏，因爲沒有調用 promise 的完成方法。 Promise 提供的 `resolve` 和 `reject` 參數就是用來結束 promise 的。 Promise 成功時調用 `resolve`，promise 執行失敗時調用 `reject`， 如下文所述，這些方法需要有一個參數。
+
+```js
+const myPromise = new Promise((resolve, reject) => {
+ if(condition here) {
+ resolve("Promise was fulfilled");
+ } else {
+ reject("Promise was rejected");
+ }
+});
+```
+
+上面的示例使用字符串作爲這些函數的參數，但參數實際上可以是任何格式。 通常，它可能是一個包含數據的對象，你可以將它放在網站或其他地方。
+
+# --instructions--
+
+使 promise 可以處理成功和失敗情況。 如果 `responseFromServer` 是 `true`，調用 `resolve` 方法使 promise 成功。 給 `resolve` 傳遞值爲 `We got the data` 的字符串。 如果 `responseFromServer` 是 `false`， 使用 `reject` 方法並傳入值爲 `Data not received` 的字符串。
+
+# --hints--
+
+當 `if` 條件是 `true` 時應該執行 `resolve`。
+
+```js
+assert(
+ code.match(/if\s*\(\s*responseFromServer\s*\)\s*{\s*resolve\s*\(\s*('|"|`)We got the data\1\s*\)(\s*|\s*;\s*)}/g)
+);
+```
+
+當 `if` 條件是 `false` 時應該執行 `reject`。
+
+```js
+assert(
+ code.match(/}\s*else\s*{\s*reject\s*\(\s*('|"|`)Data not received\1\s*\)(\s*|\s*;\s*)}/g)
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+const makeServerRequest = new Promise((resolve, reject) => {
+ // responseFromServer represents a response from a server
+ let responseFromServer;
+
+ if(responseFromServer) {
+ // Change this line
+ } else {
+ // Change this line
+ }
+});
+```
+
+# --solutions--
+
+```js
+const makeServerRequest = new Promise((resolve, reject) => {
+ // responseFromServer represents a response from a server
+ let responseFromServer;
+
+ if(responseFromServer) {
+ resolve("We got the data");
+ } else {
+ reject("Data not received");
+ }
+});
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/create-a-javascript-promise.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/create-a-javascript-promise.md
new file mode 100644
index 0000000000..d1eb61c759
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/create-a-javascript-promise.md
@@ -0,0 +1,55 @@
+---
+id: 5cdafbb0291309899753167f
+title: 創建一個 JavaScript Promise
+challengeType: 1
+forumTopicId: 301197
+dashedName: create-a-javascript-promise
+---
+
+# --description--
+
+Promise 是異步編程的一種解決方案 - 它在未來的某時會生成一個值。 任務完成，分執行成功和執行失敗兩種情況。 `Promise` 是構造器函數，需要通過 `new` 關鍵字來創建。 構造器參數是一個函數，該函數有兩個參數 - `resolve` 和 `reject`。 通過它們來判斷 promise 的執行結果。 用法如下：
+
+```js
+const myPromise = new Promise((resolve, reject) => {
+
+});
+```
+
+# --instructions--
+
+創建一個名爲 `makeServerRequest` 的 promise。 給構造器函數傳入 `resolve` 和 `reject` 兩個參數。
+
+# --hints--
+
+應該給名爲 `makeServerRequest` 的變量指定一個 promise。
+
+```js
+assert(makeServerRequest instanceof Promise);
+```
+
+promise 應該接收一個函數做爲參數，該函數應該包含 `resolve` 和 `reject` 兩個參數。
+
+```js
+assert(
+ code.match(
+ /Promise\(\s*(function\s*\(\s*resolve\s*,\s*reject\s*\)\s*{|\(\s*resolve\s*,\s*reject\s*\)\s*=>\s*{)[^}]*}/g
+ )
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+
+```
+
+# --solutions--
+
+```js
+const makeServerRequest = new Promise((resolve, reject) => {
+
+});
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/create-a-module-script.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/create-a-module-script.md
new file mode 100644
index 0000000000..68837354ed
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/create-a-module-script.md
@@ -0,0 +1,73 @@
+---
+id: 5cddbfd622f1a59093ec611d
+title: 創建一個模塊腳本
+challengeType: 6
+forumTopicId: 301198
+dashedName: create-a-module-script
+---
+
+# --description--
+
+起初，JavaScript 幾乎只在 HTML web 扮演一個很小的角色。 今天，一切不同了，很多網站幾乎全是用 JavaScript 所寫。 爲了讓 JavaScript 更模塊化、更整潔以及更易於維護，ES6 引入了在多個 JavaScript 文件之間共享代碼的機制。 它可以導出文件的一部分供其它文件使用，然後在需要它的地方按需導入。 爲了使用這一功能， 需要在 HTML 文檔裏創建一個 `type` 爲 `module` 的腳本。 例子如下：
+
+```html
+
+```
+
+使用了 `module` 類型的腳本可以使用 `import` 和 `export` 特性（接下來的挑戰會介紹）。
+
+# --instructions--
+
+給 HTML 文檔添加 `module` 類型的腳本，指定源文件爲 `index.js`。
+
+# --hints--
+
+應該創建一個 `script` 標籤。
+
+```js
+assert(code.match(/<\s*script[^>]*>\s*<\/\s*script\s*>/g));
+```
+
+`script` 標籤應該有一個值爲 `module` 的 `type` 屬性。
+
+```js
+assert(
+ code.match(
+ /<\s*script\s+[^t]*type\s*=\s*('|")module\1[^>]*>\s*<\/\s*script\s*>/g
+ )
+);
+```
+
+`script` 標籤的 `src` 屬性應該爲 `index.js`。
+
+```js
+assert(
+ code.match(
+ /<\s*script\s+[^s]*src\s*=\s*('|")index\.js\1[^>]*>\s*<\/\s*script\s*>/g
+ )
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+
+
+
+
+
+
+```
+
+# --solutions--
+
+```html
+
+
+
+
+
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/create-an-export-fallback-with-export-default.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/create-an-export-fallback-with-export-default.md
new file mode 100644
index 0000000000..5dca83d5f7
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/create-an-export-fallback-with-export-default.md
@@ -0,0 +1,63 @@
+---
+id: 587d7b8c367417b2b2512b58
+title: 用 export default 創建一個默認導出
+challengeType: 1
+forumTopicId: 301199
+dashedName: create-an-export-fallback-with-export-default
+---
+
+# --description--
+
+在 `export` 的課程中，你學習了命名導出 語法， 這可以在其他文件中引用一些函數或者變量。
+
+還需要了解另外一種被稱爲默認導出 的 `export` 的語法。 在文件中只有一個值需要導出的時候，通常會使用這種語法。 它也常常用於給文件或者模塊創建返回值。
+
+下面是使用 `export default` 的例子：
+
+```js
+export default function add(x, y) {
+ return x + y;
+}
+
+export default function(x, y) {
+ return x + y;
+}
+```
+
+第一個是命名函數，第二個是匿名函數。
+
+`export default` 用於爲模塊或文件聲明一個返回值，在每個文件或者模塊中應當只默認導出一個值。 此外，你不能將 `export default` 與 `var`、`let` 或 `const` 同時使用。
+
+# --instructions--
+
+下面的函數應該在這個模塊中返回一個值。 請添加需要的代碼。
+
+# --hints--
+
+正確地使用 `export` 返回值。
+
+```js
+assert(
+ code.match(
+ /export\s+default\s+function(\s+subtract\s*|\s*)\(\s*x,\s*y\s*\)\s*{/g
+ )
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function subtract(x, y) {
+ return x - y;
+}
+```
+
+# --solutions--
+
+```js
+export default function subtract(x, y) {
+ return x - y;
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/create-strings-using-template-literals.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/create-strings-using-template-literals.md
new file mode 100644
index 0000000000..b6557f4d37
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/create-strings-using-template-literals.md
@@ -0,0 +1,116 @@
+---
+id: 587d7b8a367417b2b2512b4e
+title: 使用模板字面量創建字符串
+challengeType: 1
+forumTopicId: 301200
+dashedName: create-strings-using-template-literals
+---
+
+# --description--
+
+模板字符串是 ES6 的另外一項新的功能。 這是一種可以輕鬆構建複雜字符串的方法。
+
+模板字符串可以使用多行字符串和字符串插值功能。
+
+請看以下代碼：
+
+```js
+const person = {
+ name: "Zodiac Hasbro",
+ age: 56
+};
+
+const greeting = `Hello, my name is ${person.name}!
+I am ${person.age} years old.`;
+
+console.log(greeting);
+```
+
+控制檯將顯示字符串 `Hello, my name is Zodiac Hasbro!` 和 `I am 56 years old.`。
+
+這裏發生了許多事情。 首先，這個例子使用反引號（`` ` ``），而不是引號（`'` 或者 `"`）將字符串括起來。 其次，注意代碼和輸出中的字符串都是多行的。 不需要在字符串中插入 `\n`。 上面使用的 `${variable}` 語法是一個佔位符。 這樣一來，你將不再需要使用 `+` 運算符來連接字符串。 當需要在字符串裏增加變量的時候，你只需要在變量的外面括上 `${` 和 `}`，並將其放在模板字符串裏就可以了。 同樣，你可以在字符串中包含其他表達式，例如 `${a + b}`。 這個新的方式使你可以更靈活地創建複雜的字符串。
+
+# --instructions--
+
+使用模板字符串的反引號的語法創建一個包含條目（`li`）字符串的數組。 每個條目應該是 `result` 對象 `failure` 屬性的數組內的元素，並具有 `class` 屬性，值爲 `text-warning`。 `makeList` 函數應該返回列表項字符串的數組。
+
+使用遍歷方法（可以是任意形式的循環）輸出指定值（如下）。
+
+```js
+[
+ 'no-var ',
+ 'var-on-top ',
+ 'linebreak '
+]
+```
+
+# --hints--
+
+`failuresList` 應該是一個包含了 `result failure` 信息的數組。
+
+```js
+assert(
+ typeof makeList(result.failure) === 'object' && failuresList.length === 3
+);
+```
+
+`failuresList` 應該輸出指定的值。
+
+```js
+assert(
+ makeList(result.failure).every(
+ (v, i) =>
+ v === `${result.failure[i]} ` ||
+ v === `${result.failure[i]} `
+ )
+);
+```
+
+應使用模板字符串和表達式內插。
+
+```js
+(getUserInput) => assert(getUserInput('index').match(/(`.*\${.*}.*`)/));
+```
+
+應該使用遍歷。
+
+```js
+(getUserInput) =>
+ assert(getUserInput('index').match(/for|map|reduce|forEach|while/));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+const result = {
+ success: ["max-length", "no-amd", "prefer-arrow-functions"],
+ failure: ["no-var", "var-on-top", "linebreak"],
+ skipped: ["no-extra-semi", "no-dup-keys"]
+};
+function makeList(arr) {
+ // Only change code below this line
+ const failureItems = [];
+ // Only change code above this line
+
+ return failureItems;
+}
+
+const failuresList = makeList(result.failure);
+```
+
+# --solutions--
+
+```js
+const result = {
+ success: ["max-length", "no-amd", "prefer-arrow-functions"],
+ failure: ["no-var", "var-on-top", "linebreak"],
+ skipped: ["no-extra-semi", "no-dup-keys"]
+};
+function makeList(arr) {
+ return arr.map(val => `${val} `);
+}
+
+const failuresList = makeList(result.failure);
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/declare-a-read-only-variable-with-the-const-keyword.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/declare-a-read-only-variable-with-the-const-keyword.md
new file mode 100644
index 0000000000..8721bad970
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/declare-a-read-only-variable-with-the-const-keyword.md
@@ -0,0 +1,89 @@
+---
+id: 587d7b87367417b2b2512b41
+title: 用 const 關鍵字聲明只讀變量
+challengeType: 1
+forumTopicId: 301201
+dashedName: declare-a-read-only-variable-with-the-const-keyword
+---
+
+# --description--
+
+`let` 並不是唯一的新的聲明變量的方式。 在 ES6 裏面，你還可以使用 `const` 關鍵字來聲明變量。
+
+`const` 擁有 `let` 的所有優點，不同的是，通過 `const` 聲明的變量是隻讀的。 這意味着通過 `const` 聲明的變量只能被賦值一次，而不能被再次賦值。
+
+```js
+const FAV_PET = "Cats";
+FAV_PET = "Dogs";
+```
+
+控制檯將由於給 `FAV_PET` 重新賦值而顯示錯誤。
+
+可見，嘗試給用 `const` 聲明的變量重新賦值會報錯。 你應該使用 `const` 關鍵字來聲明所有不打算再次賦值的變量。 這有助於避免給一個常量進行額外的再次賦值。 一個最佳實踐是對所有常量的命名採用全大寫字母，並在單詞之間使用下劃線進行分隔。
+
+**注意：**通常，開發者會用大寫字母作爲常量標識符，用小寫字母或者駝峯命名作爲變量（對象或數組）標識符。 後面的挑戰會涉及到在數組中使用小寫變量標識符。
+
+# --instructions--
+
+改變以下代碼，使得所有的變量都使用 `let` 或 `const` 關鍵詞來聲明。 當變量將會改變的時候使用 `let` 關鍵字，當變量要保持常量的時候使用 `const` 關鍵字。 同時，對使用 `const` 聲明的變量按照最佳實踐重命名，變量名中的字母應該都是大寫的。
+
+# --hints--
+
+代碼中不應有 `var`。
+
+```js
+(getUserInput) => assert(!getUserInput('index').match(/var/g));
+```
+
+`SENTENCE` 應該是使用 `const` 聲明的常量。
+
+```js
+(getUserInput) => assert(getUserInput('index').match(/(const SENTENCE)/g));
+```
+
+`i` 應該是使用 `let`聲明的。
+
+```js
+(getUserInput) => assert(getUserInput('index').match(/(let i)/g));
+```
+
+`console.log` 應該修改爲用於打印 `SENTENCE` 變量。
+
+```js
+(getUserInput) =>
+ assert(getUserInput('index').match(/console\.log\(\s*SENTENCE\s*\)\s*;?/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function printManyTimes(str) {
+
+ // Only change code below this line
+
+ var sentence = str + " is cool!";
+ for (var i = 0; i < str.length; i+=2) {
+ console.log(sentence);
+ }
+
+ // Only change code above this line
+
+}
+printManyTimes("freeCodeCamp");
+```
+
+# --solutions--
+
+```js
+function printManyTimes(str) {
+
+ const SENTENCE = str + " is cool!";
+ for (let i = 0; i < str.length; i+=2) {
+ console.log(SENTENCE);
+ }
+
+}
+printManyTimes("freeCodeCamp");
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/explore-differences-between-the-var-and-let-keywords.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/explore-differences-between-the-var-and-let-keywords.md
new file mode 100644
index 0000000000..a9d177e8be
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/explore-differences-between-the-var-and-let-keywords.md
@@ -0,0 +1,91 @@
+---
+id: 587d7b87367417b2b2512b3f
+title: 探索 var 和 let 關鍵字之間的差異
+challengeType: 1
+forumTopicId: 301202
+dashedName: explore-differences-between-the-var-and-let-keywords
+---
+
+# --description--
+
+使用 `var` 關鍵字來聲明變量，會出現重複聲明導致變量被覆蓋卻不會報錯的問題。
+
+```js
+var camper = 'James';
+var camper = 'David';
+console.log(camper);
+```
+
+這裏控制檯將顯示字符串 `David`。
+
+在上面的代碼中，`camper` 變量的初始值爲 `James`，然後又被覆蓋成了 `David`。 在小型的應用中，你可能不會遇到這樣的問題。但是當你的代碼規模變得更加龐大的時候，就可能會在不經意間覆蓋了之前定義的變量。 因爲這樣的情況不會報錯，所以搜索和修復 bug 會變得非常困難。
+在 ES6 中引入了新的關鍵字 `let` 來解決 `var` 關鍵字帶來的潛在問題。 如果你在上面的代碼中使用 `let` 關鍵字來代替 `var` 關鍵字，結果會是一個報錯。
+
+```js
+let camper = 'James';
+let camper = 'David';
+```
+
+你可以在瀏覽器的控制檯裏看見這個錯誤。 與 `var` 不同的是，當使用 `let` 的時候，同一名字的變量只能被聲明一次。 請注意 `"use strict"`。 這代表着開啓了嚴格模式，用於檢測常見的代碼錯誤以及“不安全”的行爲， 例如：
+
+```js
+"use strict";
+x = 3.14;
+```
+
+這將顯示一個錯誤 `x is not defined`。
+
+# --instructions--
+
+請更新這段代碼，只使用 `let` 關鍵字。
+
+# --hints--
+
+代碼中不應有 `var`
+
+```js
+(getUserInput) => assert(!getUserInput('index').match(/var/g));
+```
+
+`catName` 變量的值應該爲 `Oliver`
+
+```js
+assert(catName === 'Oliver');
+```
+
+`quote` 變量的值應該爲 `Oliver says Meow!`
+
+```js
+assert(quote === 'Oliver says Meow!');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+var catName;
+var quote;
+function catTalk() {
+ "use strict";
+
+ catName = "Oliver";
+ quote = catName + " says Meow!";
+
+}
+catTalk();
+```
+
+# --solutions--
+
+```js
+let catName;
+let quote;
+function catTalk() {
+ 'use strict';
+
+ catName = 'Oliver';
+ quote = catName + ' says Meow!';
+}
+catTalk();
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/handle-a-fulfilled-promise-with-then.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/handle-a-fulfilled-promise-with-then.md
new file mode 100644
index 0000000000..5633ba14e4
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/handle-a-fulfilled-promise-with-then.md
@@ -0,0 +1,92 @@
+---
+id: 5cdafbd72913098997531681
+title: 用 then 處理 Promise 完成的情況
+challengeType: 1
+forumTopicId: 301203
+dashedName: handle-a-fulfilled-promise-with-then
+---
+
+# --description--
+
+當程序需要花費未知的時間才能完成時（比如一些異步操作），一般是服務器請求，promise 很有用。 服務器請求會花費一些時間，當結束時，需要根據服務器的響應執行一些操作。 這可以用 `then` 方法來實現， 當 promise 完成 `resolve` 時會觸發 `then` 方法。 例子如下：
+
+```js
+myPromise.then(result => {
+
+});
+```
+
+`result` 即傳入 `resolve` 方法的參數。
+
+# --instructions--
+
+給 promise 添加 `then` 方法。 用 `result` 做爲回調函數的參數並將 `result` 打印在控制檯。
+
+# --hints--
+
+應該給 promise 方法調用 `then` 方法。
+
+```js
+assert(
+ __helpers.removeWhiteSpace(code).match(/(makeServerRequest|\))\.then\(/g)
+);
+```
+
+`then` 方法應該有一個回調函數，回調函數參數爲 `result`。
+
+```js
+assert(resultIsParameter);
+```
+
+應該打印 `result` 到控制檯。
+
+```js
+assert(
+ resultIsParameter &&
+ __helpers
+ .removeWhiteSpace(code)
+ .match(/\.then\(.*?result.*?console.log\(result\).*?\)/)
+);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+const resultIsParameter = /\.then\((function\(result\){|result|\(result\)=>)/.test(__helpers.removeWhiteSpace(code));
+```
+
+## --seed-contents--
+
+```js
+const makeServerRequest = new Promise((resolve, reject) => {
+ // responseFromServer is set to true to represent a successful response from a server
+ let responseFromServer = true;
+
+ if(responseFromServer) {
+ resolve("We got the data");
+ } else {
+ reject("Data not received");
+ }
+});
+```
+
+# --solutions--
+
+```js
+const makeServerRequest = new Promise((resolve, reject) => {
+ // responseFromServer is set to true to represent a successful response from a server
+ let responseFromServer = true;
+
+ if(responseFromServer) {
+ resolve("We got the data");
+ } else {
+ reject("Data not received");
+ }
+});
+
+makeServerRequest.then(result => {
+ console.log(result);
+});
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/handle-a-rejected-promise-with-catch.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/handle-a-rejected-promise-with-catch.md
new file mode 100644
index 0000000000..e192c9f2cf
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/handle-a-rejected-promise-with-catch.md
@@ -0,0 +1,100 @@
+---
+id: 5cdafbe72913098997531682
+title: 使用 catch 處理 Promise 失敗的情況
+challengeType: 1
+forumTopicId: 301204
+dashedName: handle-a-rejected-promise-with-catch
+---
+
+# --description--
+
+當 promise 失敗時會調用 `catch` 方法。 當 promise 的 `reject` 方法執行時會直接調用。 用法如下：
+
+```js
+myPromise.catch(error => {
+
+});
+```
+
+`error` 是傳入 `reject` 方法的參數。
+
+# --instructions--
+
+給 promise 添加 `catch` 方法。 用 `error` 作爲回調函數的參數，並把 `error` 打印到控制檯。
+
+# --hints--
+
+應該在 promise 上調用 `catch` 方法。
+
+```js
+assert(
+ __helpers.removeWhiteSpace(code).match(/(makeServerRequest|\))\.catch\(/g)
+);
+```
+
+`catch` 方法應該有一個回調函數，回調函數參數爲 `error`。
+
+```js
+assert(errorIsParameter);
+```
+
+應該打印 `error` 到控制檯。
+
+```js
+assert(
+ errorIsParameter &&
+ __helpers
+ .removeWhiteSpace(code)
+ .match(/\.catch\(.*?error.*?console.log\(error\).*?\)/)
+);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+const errorIsParameter = /\.catch\((function\(error\){|error|\(error\)=>)/.test(__helpers.removeWhiteSpace(code));
+```
+
+## --seed-contents--
+
+```js
+const makeServerRequest = new Promise((resolve, reject) => {
+ // responseFromServer is set to false to represent an unsuccessful response from a server
+ let responseFromServer = false;
+
+ if(responseFromServer) {
+ resolve("We got the data");
+ } else {
+ reject("Data not received");
+ }
+});
+
+makeServerRequest.then(result => {
+ console.log(result);
+});
+```
+
+# --solutions--
+
+```js
+const makeServerRequest = new Promise((resolve, reject) => {
+ // responseFromServer is set to false to represent an unsuccessful response from a server
+ let responseFromServer = false;
+
+ if(responseFromServer) {
+ resolve("We got the data");
+ } else {
+ reject("Data not received");
+ }
+});
+
+makeServerRequest.then(result => {
+ console.log(result);
+});
+
+makeServerRequest.catch(error => {
+ console.log(error);
+});
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/import-a-default-export.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/import-a-default-export.md
new file mode 100644
index 0000000000..4e869300bd
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/import-a-default-export.md
@@ -0,0 +1,48 @@
+---
+id: 587d7b8d367417b2b2512b59
+title: 導入一個默認的導出
+challengeType: 1
+forumTopicId: 301205
+dashedName: import-a-default-export
+---
+
+# --description--
+
+在上一個挑戰裏，學習了 `export default` 的用法。 還需要一種 `import` 的語法來導入默認的導出。 在下面的例子裏，`add` 是 `math_functions.js` 文件的默認導出。 以下是如何導入它：
+
+```js
+import add from "./math_functions.js";
+```
+
+這個語法有一處特別的地方， 被導入的 `add` 值沒有被花括號（`{}`）所包圍。 `add` 只是一個變量的名字，對應 `math_functions.js` 文件的任何默認導出值。 在導入默認導出時，可以使用任何名字。
+
+# --instructions--
+
+在下面的代碼中，導入同一目錄中 `math_functions.js` 文件的默認導出。 導入變量的名字爲 `subtract`。
+
+# --hints--
+
+應從 `math_functions.js` 中正確導入 `subtract`。
+
+```js
+assert(code.match(/import\s+subtract\s+from\s+('|")\.\/math_functions\.js\1/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+
+// Only change code above this line
+
+subtract(7,4);
+```
+
+# --solutions--
+
+```js
+import subtract from "./math_functions.js";
+
+subtract(7,4);
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/mutate-an-array-declared-with-const.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/mutate-an-array-declared-with-const.md
new file mode 100644
index 0000000000..b3967b5311
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/mutate-an-array-declared-with-const.md
@@ -0,0 +1,89 @@
+---
+id: 587d7b87367417b2b2512b42
+title: 改變一個用 const 聲明的數組
+challengeType: 1
+forumTopicId: 301206
+dashedName: mutate-an-array-declared-with-const
+---
+
+# --description--
+
+在現代的 JavaScript 裏，`const` 聲明有很多用法。
+
+一些開發者傾向於默認使用 `const` 來聲明所有變量，除非他們打算後續重新給變量賦值， 那麼他們在聲明的時候就會用 `let`。
+
+然而，你要注意，對象（包括數組和函數）在使用 `const` 聲明的時候依然是可變的。 使用 `const` 來聲明只會保證變量不會被重新賦值。
+
+```js
+const s = [5, 6, 7];
+s = [1, 2, 3];
+s[2] = 45;
+console.log(s);
+```
+
+`s = [1, 2, 3]` 會導致一個錯誤。 `console.log` 會顯示值 `[5, 6, 45]`。
+
+可以發現，你可以改變對象 `[5, 6, 7]` 本身，而變量 `s` 會指向改變後的數組 `[5, 6, 45]`。 和所有數組一樣，數組 `s` 中的元素是可以被改變的，但是因爲使用了 `const` 關鍵字，你不能使用賦值操作符將變量標識 `s` 指向另外一個數組。
+
+# --instructions--
+
+這裏有一個使用 `const s = [5, 7, 2]` 聲明的數組。 使用對各元素賦值的方法將數組改成 `[2, 5, 7]`。
+
+# --hints--
+
+不要替換 `const` 關鍵字。
+
+```js
+(getUserInput) => assert(getUserInput('index').match(/const/g));
+```
+
+`s` 應該爲常量（使用 `const`）。
+
+```js
+(getUserInput) => assert(getUserInput('index').match(/const\s+s/g));
+```
+
+不要改變原數組的聲明。
+
+```js
+(getUserInput) =>
+ assert(
+ getUserInput('index').match(
+ /const\s+s\s*=\s*\[\s*5\s*,\s*7\s*,\s*2\s*\]\s*;?/g
+ )
+ );
+```
+
+`s` 應該等於 `[2, 5, 7]`。
+
+```js
+assert.deepEqual(s, [2, 5, 7]);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+const s = [5, 7, 2];
+function editInPlace() {
+ // Only change code below this line
+
+ // Using s = [2, 5, 7] would be invalid
+
+ // Only change code above this line
+}
+editInPlace();
+```
+
+# --solutions--
+
+```js
+const s = [5, 7, 2];
+function editInPlace() {
+ s[0] = 2;
+ s[1] = 5;
+ s[2] = 7;
+}
+editInPlace();
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/prevent-object-mutation.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/prevent-object-mutation.md
new file mode 100644
index 0000000000..85bfb530b5
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/prevent-object-mutation.md
@@ -0,0 +1,104 @@
+---
+id: 598f48a36c8c40764b4e52b3
+title: 防止對象改變
+challengeType: 1
+forumTopicId: 301207
+dashedName: prevent-object-mutation
+---
+
+# --description--
+
+通過之前的挑戰可以看出，`const` 聲明並不會真的保護數據不被改變。 爲了確保數據不被改變，JavaScript 提供了一個函數 `Object.freeze`。
+
+當一個對象被凍結的時候，你不能再對它的屬性再進行增、刪、改的操作。 任何試圖改變對象的操作都會被阻止，卻不會報錯。
+
+```js
+let obj = {
+ name:"FreeCodeCamp",
+ review:"Awesome"
+};
+Object.freeze(obj);
+obj.review = "bad";
+obj.newProp = "Test";
+console.log(obj);
+```
+
+`obj.review` 和 `obj.newProp` 賦值將導致錯誤，控制檯將顯示值 `{ name: "FreeCodeCamp", review: "Awesome" }`。
+
+# --instructions--
+
+在這個挑戰中，你將使用 `Object.freeze` 來防止數學常量被改變。 你需要凍結 `MATH_CONSTANTS` 對象，使得沒有人可以改變 `PI` 的值，或增加或刪除屬性。
+
+# --hints--
+
+不要替換 `const` 關鍵字。
+
+```js
+(getUserInput) => assert(getUserInput('index').match(/const/g));
+```
+
+`MATH_CONSTANTS` 應該爲一個常量（使用 `const`）。
+
+```js
+(getUserInput) =>
+ assert(getUserInput('index').match(/const\s+MATH_CONSTANTS/g));
+```
+
+不要改變 `MATH_CONSTANTS` 的原始聲明。
+
+```js
+(getUserInput) =>
+ assert(
+ getUserInput('index').match(
+ /const\s+MATH_CONSTANTS\s+=\s+{\s+PI:\s+3.14\s+};/g
+ )
+ );
+```
+
+`PI` 應等於 `3.14`。
+
+```js
+assert(PI === 3.14);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function freezeObj() {
+ const MATH_CONSTANTS = {
+ PI: 3.14
+ };
+ // Only change code below this line
+
+
+ // Only change code above this line
+ try {
+ MATH_CONSTANTS.PI = 99;
+ } catch(ex) {
+ console.log(ex);
+ }
+ return MATH_CONSTANTS.PI;
+}
+const PI = freezeObj();
+```
+
+# --solutions--
+
+```js
+function freezeObj() {
+ const MATH_CONSTANTS = {
+ PI: 3.14
+ };
+ Object.freeze(MATH_CONSTANTS);
+
+ try {
+ MATH_CONSTANTS.PI = 99;
+ } catch(ex) {
+ console.log(ex);
+ }
+ return MATH_CONSTANTS.PI;
+}
+const PI = freezeObj();
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/reuse-javascript-code-using-import.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/reuse-javascript-code-using-import.md
new file mode 100644
index 0000000000..81172e0f7e
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/reuse-javascript-code-using-import.md
@@ -0,0 +1,70 @@
+---
+id: 587d7b8c367417b2b2512b55
+title: 通過 import 複用 JavaScript 代碼
+challengeType: 1
+forumTopicId: 301208
+dashedName: reuse-javascript-code-using-import
+---
+
+# --description--
+
+`import` 可以導入文件或模塊的一部分。 在之前的課程裏，例子從 `math_functions.js` 文件裏導出了 `add`。 下面看一下如何在其它文件導入它：
+
+```js
+import { add } from './math_functions.js';
+```
+
+在這裏，`import` 會在 `math_functions.js` 裏找到 `add`，只導入這個函數，忽略剩餘的部分。 `./` 告訴程序在當前文件的相同目錄尋找 `math_functions.js` 文件。 用這種方式導入時，相對路徑（`./`）和文件擴展名（`.js`）都是必需的。
+
+通過在 `import` 語句裏添加項目，可以從文件裏導入多個項目，如下：
+
+```js
+import { add, subtract } from './math_functions.js';
+```
+
+# --instructions--
+
+添加 `import` 語句，使當前文件可以使用你在之前課程裏導出的 `uppercaseString` 和 `lowercaseString` 函數。 函數在當前路徑下的 `string_functions.js` 文件裏。
+
+# --hints--
+
+應該導入 `uppercaseString`。
+
+```js
+assert(
+ code.match(
+ /import\s*{\s*(uppercaseString[^}]*|[^,]*,\s*uppercaseString\s*)}\s+from\s+('|")\.\/string_functions\.js\2/g
+ )
+);
+```
+
+應該導入 `lowercaseString`。
+
+```js
+assert(
+ code.match(
+ /import\s*{\s*(lowercaseString[^}]*|[^,]*,\s*lowercaseString\s*)}\s+from\s+('|")\.\/string_functions\.js\2/g
+ )
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+
+// Only change code above this line
+
+uppercaseString("hello");
+lowercaseString("WORLD!");
+```
+
+# --solutions--
+
+```js
+import { uppercaseString, lowercaseString } from './string_functions.js';
+
+uppercaseString("hello");
+lowercaseString("WORLD!");
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/set-default-parameters-for-your-functions.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/set-default-parameters-for-your-functions.md
new file mode 100644
index 0000000000..e02bc73736
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/set-default-parameters-for-your-functions.md
@@ -0,0 +1,64 @@
+---
+id: 587d7b88367417b2b2512b46
+title: 設置函數的默認參數
+challengeType: 1
+forumTopicId: 301209
+dashedName: set-default-parameters-for-your-functions
+---
+
+# --description--
+
+ES6 裏允許給函數傳入默認參數 ，來構建更加靈活的函數。
+
+請看以下代碼：
+
+```js
+const greeting = (name = "Anonymous") => "Hello " + name;
+
+console.log(greeting("John"));
+console.log(greeting());
+```
+
+控制檯將顯示字符串 `Hello John` 和 `Hello Anonymous`。
+
+默認參數會在參數沒有被指定（值爲 undefined）的時候起作用。 在上面的例子中，參數 `name` 會在沒有得到新的值的時候，默認使用值 `Anonymous`。 你還可以給多個參數賦予默認值。
+
+# --instructions--
+
+給函數 `increment` 加上默認參數，使得在 `value` 沒有被賦值的時候，默認給 `number` 加上 1。
+
+# --hints--
+
+`increment(5, 2)` 的結果應該是 `7`。
+
+```js
+assert(increment(5, 2) === 7);
+```
+
+`increment(5)` 的結果應該是 `6`。
+
+```js
+assert(increment(5) === 6);
+```
+
+參數 `value` 的默認值是 `1`。
+
+```js
+assert(code.match(/value\s*=\s*1/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// Only change code below this line
+const increment = (number, value) => number + value;
+// Only change code above this line
+```
+
+# --solutions--
+
+```js
+const increment = (number, value = 1) => number + value;
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/use--to-import-everything-from-a-file.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/use--to-import-everything-from-a-file.md
new file mode 100644
index 0000000000..0a5d503aeb
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/use--to-import-everything-from-a-file.md
@@ -0,0 +1,60 @@
+---
+id: 587d7b8c367417b2b2512b57
+title: 用 * 從文件中導入所有內容
+challengeType: 1
+forumTopicId: 301210
+dashedName: use--to-import-everything-from-a-file
+---
+
+# --description--
+
+假設你有一個文件，你希望將其所有內容導入到當前文件中。 可以用 `import * as` 語法來實現。 下面是一個從同目錄下的 `math_functions.js` 文件中導入所有內容的例子：
+
+```js
+import * as myMathModule from "./math_functions.js";
+```
+
+上面的 `import` 語句會創建一個叫作 `myMathModule` 的對象。 這只是一個變量名，可以隨便命名。 對象包含 `math_functions.js` 文件裏的所有導出，可以像訪問對象的屬性那樣訪問裏面的函數。 下面是使用導入的 `add` 和 `subtract` 函數的例子：
+
+```js
+myMathModule.add(2,3);
+myMathModule.subtract(5,3);
+```
+
+# --instructions--
+
+下面的代碼需要從同目錄下的 `string_functions.js` 文件中導入所有內容。 使用 `import * as` 語法將文件的所有內容導入對象 `stringFunctions`。
+
+# --hints--
+
+正確使用 `import * as` 語法。
+
+```js
+assert(
+ code.match(
+ /import\s*\*\s*as\s+stringFunctions\s+from\s*('|")\.\/string_functions\.js\1/g
+ )
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+
+// Only change code above this line
+
+stringFunctions.uppercaseString("hello");
+stringFunctions.lowercaseString("WORLD!");
+```
+
+# --solutions--
+
+```js
+import * as stringFunctions from "./string_functions.js";
+
+// add code above this line
+stringFunctions.uppercaseString("hello");
+stringFunctions.lowercaseString("WORLD!");
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/use-arrow-functions-to-write-concise-anonymous-functions.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/use-arrow-functions-to-write-concise-anonymous-functions.md
new file mode 100644
index 0000000000..a7c5959e8d
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/use-arrow-functions-to-write-concise-anonymous-functions.md
@@ -0,0 +1,91 @@
+---
+id: 587d7b87367417b2b2512b43
+title: 使用箭頭函數編寫簡潔的匿名函數
+challengeType: 1
+forumTopicId: 301211
+dashedName: use-arrow-functions-to-write-concise-anonymous-functions
+---
+
+# --description--
+
+在 JavaScript 裏，我們會經常遇到不需要給函數命名的情況，尤其是在需要將一個函數作爲參數傳給另外一個函數的時候。 這時，我們會創建匿名函數。 因爲這些函數不會在其他地方複用，所以我們不需要給它們命名。
+
+這種情況下，我們通常會使用以下語法：
+
+```js
+const myFunc = function() {
+ const myVar = "value";
+ return myVar;
+}
+```
+
+ES6 提供了其他寫匿名函數的方式的語法糖。 你可以使用**箭頭函數**：
+
+```js
+const myFunc = () => {
+ const myVar = "value";
+ return myVar;
+}
+```
+
+當不需要函數體，只返回一個值的時候，箭頭函數允許你省略 `return` 關鍵字和外面的大括號。 這樣就可以將一個簡單的函數簡化成一個單行語句。
+
+```js
+const myFunc = () => "value";
+```
+
+這段代碼默認會返回字符串 `value`。
+
+# --instructions--
+
+使用箭頭函數的語法重寫賦給 `magic` 變量的函數，使其返回一個新的 Date() `new Date()`。 同時不要用 `var` 關鍵字來定義任何變量。
+
+# --hints--
+
+應該替換 `var` 關鍵字。
+
+```js
+(getUserInput) => assert(!getUserInput('index').match(/var/g));
+```
+
+`magic` 應該爲一個常量（使用 `const`）。
+
+```js
+(getUserInput) => assert(getUserInput('index').match(/const\s+magic/g));
+```
+
+`magic` 應該是一個函數 `function`。
+
+```js
+assert(typeof magic === 'function');
+```
+
+`magic()` 應該返回正確的日期。
+
+```js
+assert(magic().setHours(0, 0, 0, 0) === new Date().setHours(0, 0, 0, 0));
+```
+
+不要使用 `function` 關鍵字。
+
+```js
+(getUserInput) => assert(!getUserInput('index').match(/function/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+var magic = function() {
+ return new Date();
+};
+```
+
+# --solutions--
+
+```js
+const magic = () => {
+ return new Date();
+};
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/use-class-syntax-to-define-a-constructor-function.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/use-class-syntax-to-define-a-constructor-function.md
new file mode 100644
index 0000000000..18806c6610
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/use-class-syntax-to-define-a-constructor-function.md
@@ -0,0 +1,100 @@
+---
+id: 587d7b8b367417b2b2512b53
+title: 使用 class 語法定義構造函數
+challengeType: 1
+forumTopicId: 301212
+dashedName: use-class-syntax-to-define-a-constructor-function
+---
+
+# --description--
+
+ES6 提供了一個新的創建對象的語法，使用關鍵字 class 。
+
+值得注意的是，`class` 只是一個語法糖，它並不像 Java、Python 或者 Ruby 這一類的語言一樣，嚴格履行了面向對象的開發規範。
+
+在 ES5 裏面，我們通常會定義一個構造函數 `constructor`，然後使用 `new` 關鍵字來實例化一個對象：
+
+```js
+var SpaceShuttle = function(targetPlanet){
+ this.targetPlanet = targetPlanet;
+}
+var zeus = new SpaceShuttle('Jupiter');
+```
+
+`class` 語法只是簡單地替換了構造函數 `constructor` 的寫法：
+
+```js
+class SpaceShuttle {
+ constructor(targetPlanet) {
+ this.targetPlanet = targetPlanet;
+ }
+}
+const zeus = new SpaceShuttle('Jupiter');
+```
+
+應該注意 `class` 關鍵字聲明瞭一個新的函數，裏面添加了一個構造函數。 當用 `new` 創建一個新的對象時，構造函數會被調用。
+
+**注意：**首字母大寫駝峯命名法 UpperCamelCase 是 ES6 class 命名的慣例，就像上面的 `SpaceShuttle`。
+
+`constructor` 方法是一個特殊方法，用於創建和初始化 class 創建的對象。 在 JavaScript 算法和數據結構認證的面向對象編程章節裏會更深入介紹它。
+
+# --instructions--
+
+使用 `class` 關鍵詞，寫一個 `constructor` 來創建 `Vegetable` class。
+
+`Vegetable` 這個 class 可以創建 vegetable 對象，這個對象擁有一個在 `constructor` 中賦值的 `name` 屬性。
+
+# --hints--
+
+`Vegetable` 應該是一個 `class`，並在其中定義了 `constructor`。
+
+```js
+assert(
+ typeof Vegetable === 'function' && typeof Vegetable.constructor === 'function'
+);
+```
+
+應使用 `class` 關鍵字。
+
+```js
+assert(code.match(/class/g));
+```
+
+`Vegetable` 可以被實例化。
+
+```js
+assert(() => {
+ const a = new Vegetable('apple');
+ return typeof a === 'object';
+});
+```
+
+`carrot.name` 應該返回 `carrot`。
+
+```js
+assert(carrot.name == 'carrot');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// Only change code below this line
+
+// Only change code above this line
+
+const carrot = new Vegetable('carrot');
+console.log(carrot.name); // Should display 'carrot'
+```
+
+# --solutions--
+
+```js
+class Vegetable {
+ constructor(name) {
+ this.name = name;
+ }
+}
+const carrot = new Vegetable('carrot');
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/use-destructuring-assignment-to-assign-variables-from-arrays.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/use-destructuring-assignment-to-assign-variables-from-arrays.md
new file mode 100644
index 0000000000..f3886aa8e2
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/use-destructuring-assignment-to-assign-variables-from-arrays.md
@@ -0,0 +1,71 @@
+---
+id: 587d7b89367417b2b2512b4b
+title: 使用解構賦值從數組中分配變量
+challengeType: 1
+forumTopicId: 301213
+dashedName: use-destructuring-assignment-to-assign-variables-from-arrays
+---
+
+# --description--
+
+在 ES6 裏面，解構數組可以如同解構對象一樣簡單。
+
+與數組解構不同，數組的擴展運算會將數組裏的所有內容分解成一個由逗號分隔的列表。 所以，你不能選擇哪個元素來給變量賦值。
+
+而對數組進行解構卻可以讓我們做到這一點：
+
+```js
+const [a, b] = [1, 2, 3, 4, 5, 6];
+console.log(a, b);
+```
+
+控制檯將顯示 `a` 和 `b` 的值爲 `1, 2`。
+
+數組的第一個值被賦值給變量 `a`，數組的第二個值被賦值給變量 `b`。 我們甚至能在數組解構中使用逗號分隔符，來獲取任意一個想要的值：
+
+```js
+const [a, b,,, c] = [1, 2, 3, 4, 5, 6];
+console.log(a, b, c);
+```
+
+控制檯將顯示 `a`、`b` 和 `c` 的值爲 `1, 2, 5`。
+
+# --instructions--
+
+使用數組解構來交換變量 `a` 與 `b` 的值，使 `a` 接收 `b` 的值，而 `b` 接收 `a` 的值。
+
+# --hints--
+
+交換後，`a` 的值應該爲 `6`。
+
+```js
+assert(a === 6);
+```
+
+交換後，`b` 的值應該爲 `8`。
+
+```js
+assert(b === 8);
+```
+
+應使用數組解構來交換 `a` 和 `b` 的值。
+
+```js
+assert(/\[\s*(\w)\s*,\s*(\w)\s*\]\s*=\s*\[\s*\2\s*,\s*\1\s*\]/g.test(code));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let a = 8, b = 6;
+// Only change code below this line
+```
+
+# --solutions--
+
+```js
+let a = 8, b = 6;
+[a, b] = [b, a];
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/use-destructuring-assignment-to-assign-variables-from-nested-objects.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/use-destructuring-assignment-to-assign-variables-from-nested-objects.md
new file mode 100644
index 0000000000..eb1db1ed4b
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/use-destructuring-assignment-to-assign-variables-from-nested-objects.md
@@ -0,0 +1,106 @@
+---
+id: 587d7b89367417b2b2512b4a
+title: 使用解構賦值從嵌套對象中分配變量
+challengeType: 1
+forumTopicId: 301214
+dashedName: use-destructuring-assignment-to-assign-variables-from-nested-objects
+---
+
+# --description--
+
+你可以使用前兩節課程中相同的原則來解構嵌套對象中的值。
+
+使用與前面的例子中類似的對象：
+
+```js
+const user = {
+ johnDoe: {
+ age: 34,
+ email: 'johnDoe@freeCodeCamp.com'
+ }
+};
+```
+
+這是解構對象的屬性值賦值給具有相同名字的變量：
+
+```js
+const { johnDoe: { age, email }} = user;
+```
+
+這是將對象的屬性值賦值給具有不同名字的變量：
+
+```js
+const { johnDoe: { age: userAge, email: userEmail }} = user;
+```
+
+# --instructions--
+
+將兩個賦值語句替換成等價的解構賦值。 `lowToday` 和 `highToday` 應該爲 `LOCAL_FORECAST` 中 `today.low` 和 `today.high` 的值。
+
+# --hints--
+
+不能使用 ES5 的賦值語句。
+
+```js
+assert(
+ !code.match(/lowToday = LOCAL_FORECAST\.today\.low/g) &&
+ !code.match(/highToday = LOCAL_FORECAST\.today.high/g)
+);
+```
+
+應該使用解構創建 `lowToday` 變量。
+
+```js
+assert(
+ code.match(
+ /(var|const|let)\s*{\s*today\s*:\s*{\s*(low\s*:\s*lowToday[^}]*|[^,]*,\s*low\s*:\s*lowToday\s*)}\s*}\s*=\s*LOCAL_FORECAST(;|\s+|\/\/)/g
+ )
+);
+```
+
+應該使用解構創建 `highToday` 變量。
+
+```js
+assert(
+ code.match(
+ /(var|const|let)\s*{\s*today\s*:\s*{\s*(high\s*:\s*highToday[^}]*|[^,]*,\s*high\s*:\s*highToday\s*)}\s*}\s*=\s*LOCAL_FORECAST(;|\s+|\/\/)/g
+ )
+);
+```
+
+`lowToday` 應等於 `64`，`highToday` 應等於 `77`。
+
+```js
+assert(lowToday === 64 && highToday === 77);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+const LOCAL_FORECAST = {
+ yesterday: { low: 61, high: 75 },
+ today: { low: 64, high: 77 },
+ tomorrow: { low: 68, high: 80 }
+};
+
+// Only change code below this line
+
+const lowToday = LOCAL_FORECAST.today.low;
+const highToday = LOCAL_FORECAST.today.high;
+
+// Only change code above this line
+```
+
+# --solutions--
+
+```js
+const LOCAL_FORECAST = {
+ yesterday: { low: 61, high: 75 },
+ today: { low: 64, high: 77 },
+ tomorrow: { low: 68, high: 80 }
+};
+
+const { today: { low: lowToday, high: highToday }} = LOCAL_FORECAST;
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/use-destructuring-assignment-to-assign-variables-from-objects.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/use-destructuring-assignment-to-assign-variables-from-objects.md
new file mode 100644
index 0000000000..8b01d1547e
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/use-destructuring-assignment-to-assign-variables-from-objects.md
@@ -0,0 +1,97 @@
+---
+id: 587d7b89367417b2b2512b49
+title: 使用解構賦值從對象中分配變量
+challengeType: 1
+forumTopicId: 301215
+dashedName: use-destructuring-assignment-to-assign-variables-from-objects
+---
+
+# --description--
+
+可以給解構的值賦予一個新的變量名， 通過在賦值的時候將新的變量名放在冒號後面來實現。
+
+還是以上個例子的對象來舉例：
+
+```js
+const user = { name: 'John Doe', age: 34 };
+```
+
+這是指定新的變量名的例子：
+
+```js
+const { name: userName, age: userAge } = user;
+```
+
+你可以這麼理解這段代碼：獲取 `user.name` 的值，將它賦給一個新的變量 `userName`，等等。 `userName` 的值將是字符串 `John Doe`，`userAge` 的值將是數字 `34`。
+
+# --instructions--
+
+使用解構賦值語句替換兩個賦值語句。 將 `HIGH_TEMPERATURES` 的 `today` 和 `tomorrow` 的值賦值給 `highToday` 和 `highTomorrow`。
+
+# --hints--
+
+應該移除 ES5 賦值語句。
+
+```js
+assert(
+ !code.match(/highToday = HIGH_TEMPERATURES\.today/g) &&
+ !code.match(/highTomorrow = HIGH_TEMPERATURES\.tomorrow/g)
+);
+```
+
+應該使用解構賦值語句創建 `highToday` 變量。
+
+```js
+assert(
+ code.match(
+ /(var|const|let)\s*{\s*(today\s*:\s*highToday[^}]*|[^,]*,\s*today\s*:\s*highToday\s*)}\s*=\s*HIGH_TEMPERATURES(;|\s+|\/\/)/g
+ )
+);
+```
+
+應該使用解構賦值語句創建 `highTomorrow` 變量。
+
+```js
+assert(
+ code.match(
+ /(var|const|let)\s*{\s*(tomorrow\s*:\s*highTomorrow[^}]*|[^,]*,\s*tomorrow\s*:\s*highTomorrow\s*)}\s*=\s*HIGH_TEMPERATURES(;|\s+|\/\/)/g
+ )
+);
+```
+
+`highToday` 應該等於 `77`，`highTomorrow` 應該等於 `80`。
+
+```js
+assert(highToday === 77 && highTomorrow === 80);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+const HIGH_TEMPERATURES = {
+ yesterday: 75,
+ today: 77,
+ tomorrow: 80
+};
+
+// Only change code below this line
+
+const highToday = HIGH_TEMPERATURES.today;
+const highTomorrow = HIGH_TEMPERATURES.tomorrow;
+
+// Only change code above this line
+```
+
+# --solutions--
+
+```js
+const HIGH_TEMPERATURES = {
+ yesterday: 75,
+ today: 77,
+ tomorrow: 80
+};
+
+const { today: highToday, tomorrow: highTomorrow } = HIGH_TEMPERATURES;
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/use-destructuring-assignment-to-extract-values-from-objects.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/use-destructuring-assignment-to-extract-values-from-objects.md
new file mode 100644
index 0000000000..7c45dfb097
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/use-destructuring-assignment-to-extract-values-from-objects.md
@@ -0,0 +1,101 @@
+---
+id: 5cfa550e84205a357704ccb6
+title: 使用解構賦值來獲取對象的值
+challengeType: 1
+forumTopicId: 301216
+dashedName: use-destructuring-assignment-to-extract-values-from-objects
+---
+
+# --description--
+
+解構賦值 是 ES6 引入的新語法，用來從數組和對象中提取值，並優雅地對變量進行賦值。
+
+有如下 ES5 代碼：
+
+```js
+const user = { name: 'John Doe', age: 34 };
+
+const name = user.name;
+const age = user.age;
+```
+
+`name` 的值應該是字符串 `John Doe`， `age` 的值應該是數字 `34`。
+
+下面是使用 ES6 解構賦值語句，實現相同效果：
+
+```js
+const { name, age } = user;
+```
+
+同樣，`name` 的值應該是字符串 `John Doe`， `age` 的值應該是數字 `34`。
+
+在這裏，自動創建 `name` 和 `age` 變量，並將 `user` 對象相應屬性的值賦值給它們。 這個方法簡潔多了。
+
+你可以從對象中提取儘可能多或很少的值。
+
+# --instructions--
+
+把兩個賦值語句替換成效果相同的解構賦值語句。 `today` 和 `tomorrow` 的值應該還是 `HIGH_TEMPERATURES` 對象中 `today` 和 `tomorrow` 屬性的值。
+
+# --hints--
+
+應該移除 ES5 賦值語句。
+
+```js
+assert(
+ !code.match(/today\s*=\s*HIGH_TEMPERATURES\.(today|tomorrow)/g)
+);
+```
+
+應該使用解構賦值創建 `today` 變量。
+
+```js
+assert(
+ code.match(/(var|let|const)\s*{\s*(today[^}]*|[^,]*,\s*today)\s*}\s*=\s*HIGH_TEMPERATURES(;|\s+|\/\/)/g)
+);
+```
+
+應該使用解構賦值創建 `tomorrow` 變量。
+
+```js
+assert(
+ code.match(/(var|let|const)\s*{\s*(tomorrow[^}]*|[^,]*,\s*tomorrow)\s*}\s*=\s*HIGH_TEMPERATURES(;|\s+|\/\/)/g)
+);
+```
+
+`today` 應該等於 `77`，`tomorrow` 應該等於 `80`。
+
+```js
+assert(today === 77 && tomorrow === 80);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+const HIGH_TEMPERATURES = {
+ yesterday: 75,
+ today: 77,
+ tomorrow: 80
+};
+
+// Only change code below this line
+
+const today = HIGH_TEMPERATURES.today;
+const tomorrow = HIGH_TEMPERATURES.tomorrow;
+
+// Only change code above this line
+```
+
+# --solutions--
+
+```js
+const HIGH_TEMPERATURES = {
+ yesterday: 75,
+ today: 77,
+ tomorrow: 80
+};
+
+const { today, tomorrow } = HIGH_TEMPERATURES;
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/use-destructuring-assignment-to-pass-an-object-as-a-functions-parameters.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/use-destructuring-assignment-to-pass-an-object-as-a-functions-parameters.md
new file mode 100644
index 0000000000..b26e17b13f
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/use-destructuring-assignment-to-pass-an-object-as-a-functions-parameters.md
@@ -0,0 +1,94 @@
+---
+id: 587d7b8a367417b2b2512b4d
+title: 使用解構賦值將對象作爲函數的參數傳遞
+challengeType: 1
+forumTopicId: 301217
+dashedName: use-destructuring-assignment-to-pass-an-object-as-a-functions-parameters
+---
+
+# --description--
+
+在某些情況下，你可以在函數的參數裏直接解構對象。
+
+請看以下代碼：
+
+```js
+const profileUpdate = (profileData) => {
+ const { name, age, nationality, location } = profileData;
+
+}
+```
+
+上面的操作解構了傳給函數的對象。 這樣的操作也可以直接在參數裏完成：
+
+```js
+const profileUpdate = ({ name, age, nationality, location }) => {
+
+}
+```
+
+當 `profileData` 被傳遞到上面的函數時，從函數參數中解構出值以在函數內使用。
+
+# --instructions--
+
+對 `half` 的參數進行解構賦值，僅將 `max` 與 `min` 的值傳進函數。
+
+# --hints--
+
+`stats` 的類型應該是一個 `object`。
+
+```js
+assert(typeof stats === 'object');
+```
+
+`half(stats)` 應該等於 `28.015`。
+
+```js
+assert(half(stats) === 28.015);
+```
+
+應該使用解構賦值。
+
+```js
+assert(__helpers.removeWhiteSpace(code).match(/half=\({\w+,\w+}\)/));
+```
+
+應該使用解構參數。
+
+```js
+assert(!code.match(/stats\.max|stats\.min/));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+const stats = {
+ max: 56.78,
+ standard_deviation: 4.34,
+ median: 34.54,
+ mode: 23.87,
+ min: -0.75,
+ average: 35.85
+};
+
+// Only change code below this line
+const half = (stats) => (stats.max + stats.min) / 2.0;
+// Only change code above this line
+```
+
+# --solutions--
+
+```js
+const stats = {
+ max: 56.78,
+ standard_deviation: 4.34,
+ median: 34.54,
+ mode: 23.87,
+ min: -0.75,
+ average: 35.85
+};
+
+const half = ( {max, min} ) => (max + min) / 2.0;
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/use-destructuring-assignment-with-the-rest-parameter-to-reassign-array-elements.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/use-destructuring-assignment-with-the-rest-parameter-to-reassign-array-elements.md
new file mode 100644
index 0000000000..946c0d778a
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/use-destructuring-assignment-with-the-rest-parameter-to-reassign-array-elements.md
@@ -0,0 +1,85 @@
+---
+id: 587d7b8a367417b2b2512b4c
+title: >-
+ 使用解構賦值配合 rest 操作符來重新分配數組元素
+challengeType: 1
+forumTopicId: 301218
+dashedName: >-
+ use-destructuring-assignment-with-the-rest-parameter-to-reassign-array-elements
+---
+
+# --description--
+
+在解構數組的某些情況下，我們可能希望將剩下的元素放進另一個數組裏面。
+
+以下代碼的結果與使用 `Array.prototype.slice()` 類似：
+
+```js
+const [a, b, ...arr] = [1, 2, 3, 4, 5, 7];
+console.log(a, b);
+console.log(arr);
+```
+
+控制檯將顯示 `1, 2` 和 `[3, 4, 5, 7]`。
+
+變量 `a` 和 `b` 分別接收數組的第一個和第二個值。 之後，因爲 rest 操作符的存在，`arr` 獲取了原數組剩餘的元素的值。 rest 操作符只能對數組列表最後的元素起作用。 這意味着你不能使用 rest 操作符來截取原數組中間的元素作爲子數組。
+
+# --instructions--
+
+使用解構賦值以及 rest 操作符來進行和 `Array.prototype.slice()` 相同的操作，使 `arr` 是原數組 `source` 除開前兩個元素的子數組。
+
+# --hints--
+
+`arr` 應該是 `[3,4,5,6,7,8,9,10]`。
+
+```js
+assert(arr.every((v, i) => v === i + 3) && arr.length === 8);
+```
+
+`source` 應該是 `[1,2,3,4,5,6,7,8,9,10]`。
+
+```js
+assert(source.every((v, i) => v === i + 1) && source.length === 10);
+```
+
+不應該使用 `Array.slice()`。
+
+```js
+(getUserInput) => assert(!getUserInput('index').match(/slice/g));
+```
+
+應該對 `list` 進行解構賦值。
+
+```js
+assert(
+ __helpers
+ .removeWhiteSpace(code)
+ .match(/\[(([_$a-z]\w*)?,){1,}\.\.\.arr\]=list/i)
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+const source = [1,2,3,4,5,6,7,8,9,10];
+function removeFirstTwo(list) {
+ // Only change code below this line
+ const arr = list; // Change this line
+ // Only change code above this line
+ return arr;
+}
+const arr = removeFirstTwo(source);
+```
+
+# --solutions--
+
+```js
+const source = [1,2,3,4,5,6,7,8,9,10];
+function removeFirstTwo(list) {
+ const [, , ...arr] = list;
+ return arr;
+}
+const arr = removeFirstTwo(source);
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/use-export-to-share-a-code-block.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/use-export-to-share-a-code-block.md
new file mode 100644
index 0000000000..6747be0ae8
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/use-export-to-share-a-code-block.md
@@ -0,0 +1,85 @@
+---
+id: 587d7b8c367417b2b2512b56
+title: 用 export 來重用代碼塊
+challengeType: 1
+forumTopicId: 301219
+dashedName: use-export-to-share-a-code-block
+---
+
+# --description--
+
+假設有一個文件 `math_functions.js`，該文件包含了數學運算相關的一些函數。 其中一個存儲在變量 `add` 裏，該函數接受兩個數字作爲參數返回它們的和。 你想在幾個不同的 JavaScript 文件中使用這個函數。 要實現這個目的，就需要 `export` 它。
+
+```js
+export const add = (x, y) => {
+ return x + y;
+}
+```
+
+上面是導出單個函數常用方法，還可以這樣導出：
+
+```js
+const add = (x, y) => {
+ return x + y;
+}
+
+export { add };
+```
+
+導出變量和函數後，就可以在其它文件裏導入使用從而避免了代碼冗餘。 重複第一個例子的代碼可以導出多個對象或函數，在第二個例子裏面的導出語句中添加更多值也可以導出多項，例子如下：
+
+```js
+export { add, subtract };
+```
+
+# --instructions--
+
+編輯框中有兩個字符串相關的函數。 選用一種方法導出兩個函數。
+
+# --hints--
+
+應該導出 `uppercaseString` 變量。
+
+```js
+assert(
+ code.match(
+ /(export\s+const\s+uppercaseString|export\s*{\s*(uppercaseString[^}]*|[^,]*,\s*uppercaseString\s*)})/g
+ )
+);
+```
+
+應該導出 `lowercaseString` 變量。
+
+```js
+assert(
+ code.match(
+ /(export\s+const\s+lowercaseString|export\s*{\s*(lowercaseString[^}]*|[^,]*,\s*lowercaseString\s*)})/g
+ )
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+const uppercaseString = (string) => {
+ return string.toUpperCase();
+}
+
+const lowercaseString = (string) => {
+ return string.toLowerCase()
+}
+```
+
+# --solutions--
+
+```js
+export const uppercaseString = (string) => {
+ return string.toUpperCase();
+}
+
+export const lowercaseString = (string) => {
+ return string.toLowerCase()
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/use-getters-and-setters-to-control-access-to-an-object.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/use-getters-and-setters-to-control-access-to-an-object.md
new file mode 100644
index 0000000000..ed5d7fc2ed
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/use-getters-and-setters-to-control-access-to-an-object.md
@@ -0,0 +1,174 @@
+---
+id: 587d7b8c367417b2b2512b54
+title: 使用 getter 和 setter 來控制對象的訪問
+challengeType: 1
+forumTopicId: 301220
+dashedName: use-getters-and-setters-to-control-access-to-an-object
+---
+
+# --description--
+
+你可以從對象中獲得一個值，也可以給對象的屬性賦值。
+
+這些操作通常被稱爲 getters 以及 setters 。
+
+Getter 函數的作用是可以讓對象返回一個私有變量，而不需要直接去訪問私有變量。
+
+Setter 函數的作用是可以基於傳進的參數來修改對象中私有變量。 這些修改可以是計算，或者是直接替換之前的值。
+
+```js
+class Book {
+ constructor(author) {
+ this._author = author;
+ }
+ // getter
+ get writer() {
+ return this._author;
+ }
+ // setter
+ set writer(updatedAuthor) {
+ this._author = updatedAuthor;
+ }
+}
+const novel = new Book('anonymous');
+console.log(novel.writer);
+novel.writer = 'newAuthor';
+console.log(novel.writer);
+```
+
+控制檯將顯示字符串 `anonymous` 和 `newAuthor`。
+
+請注意用於調用 getter 和 setter 的語法。 它們甚至看起來不像是函數。 getter 和 setter 非常重要，因爲它們隱藏了內部的實現細節。
+
+**注意：**通常會在私有變量前添加下劃線（`_`）。 然而，這種做法本身並不是將變量變成私有的。
+
+# --instructions--
+
+使用 `class` 關鍵字創建一個 `Thermostat` class。 `constructor` 接收一個華氏溫度。
+
+在 class 中，創建一個 `getter` 來獲取攝氏溫度和一個 `setter` 來設置溫度值。
+
+記得在 `C = 5/9 * (F - 32)` 和 `F = C * 9.0 / 5 + 32` 中，`F` 是華氏溫度值，`C` 是攝氏溫度值。
+
+**注意：**完成這個挑戰後，應該在 class 中使用一個溫度標準，要麼是華氏溫度，要麼是攝氏溫度。
+
+這就是 getter 和 setter 的功能。 你正在爲別的用戶創建一個 API，不論你使用哪一個，用戶都將獲得正確的結果。
+
+或者說，你從用戶需求中抽象出了實現細節。
+
+# --hints--
+
+`Thermostat` 應該是一個具有 `constructor` 方法的 `class`。
+
+```js
+assert(
+ typeof Thermostat === 'function' &&
+ typeof Thermostat.constructor === 'function'
+);
+```
+
+應該使用 `class` 關鍵詞。
+
+```js
+assert(code.match(/class/g));
+```
+
+`Thermostat` 應該可以被實例化。
+
+```js
+assert(
+ (() => {
+ const t = new Thermostat(122);
+ return typeof t === 'object';
+ })()
+);
+```
+
+當實例化華氏溫度值時，`Thermostat` 應該被設置爲正確的 `temperature`。
+
+```js
+assert(
+ (() => {
+ const t = new Thermostat(122);
+ return t.temperature === 50;
+ })()
+);
+```
+
+應該定義一個 `getter`。
+
+```js
+assert(
+ (() => {
+ const desc = Object.getOwnPropertyDescriptor(
+ Thermostat.prototype,
+ 'temperature'
+ );
+ return !!desc && typeof desc.get === 'function';
+ })()
+);
+```
+
+應該定義一個 `setter`。
+
+```js
+assert(
+ (() => {
+ const desc = Object.getOwnPropertyDescriptor(
+ Thermostat.prototype,
+ 'temperature'
+ );
+ return !!desc && typeof desc.set === 'function';
+ })()
+);
+```
+
+調用帶有攝氏溫度值的 `setter` 應該設置 `temperature`。
+
+```js
+assert(
+ (() => {
+ const t = new Thermostat(32);
+ t.temperature = 26;
+ const u = new Thermostat(32);
+ u.temperature = 50;
+ return t.temperature === 26 && u.temperature === 50;
+ })()
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// Only change code below this line
+
+// Only change code above this line
+
+const thermos = new Thermostat(76); // Setting in Fahrenheit scale
+let temp = thermos.temperature; // 24.44 in Celsius
+thermos.temperature = 26;
+temp = thermos.temperature; // 26 in Celsius
+```
+
+# --solutions--
+
+```js
+class Thermostat {
+ constructor(fahrenheit) {
+ this._tempInCelsius = 5/9 * (fahrenheit - 32);
+ }
+ get temperature(){
+ return this._tempInCelsius;
+ }
+ set temperature(newTemp){
+ this._tempInCelsius = newTemp;
+ }
+}
+
+const thermos = new Thermostat(76); // Setting in Fahrenheit scale
+let temp = thermos.temperature; // 24.44 in Celsius
+thermos.temperature = 26;
+temp = thermos.temperature; // 26 in Celsius
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/use-the-rest-parameter-with-function-parameters.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/use-the-rest-parameter-with-function-parameters.md
new file mode 100644
index 0000000000..84f1103b65
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/use-the-rest-parameter-with-function-parameters.md
@@ -0,0 +1,80 @@
+---
+id: 587d7b88367417b2b2512b47
+title: 將 rest 操作符與函數參數一起使用
+challengeType: 1
+forumTopicId: 301221
+dashedName: use-the-rest-parameter-with-function-parameters
+---
+
+# --description--
+
+ES6 推出了用於函數參數的 rest 操作符 幫助我們創建更加靈活的函數。 rest 操作符可以用於創建有一個變量來接受多個參數的函數。 這些參數被儲存在一個可以在函數內部讀取的數組中。
+
+請看以下代碼：
+
+```js
+function howMany(...args) {
+ return "You have passed " + args.length + " arguments.";
+}
+console.log(howMany(0, 1, 2));
+console.log(howMany("string", null, [1, 2, 3], { }));
+```
+
+控制檯將顯示字符串 `You have passed 3 arguments.` 和 `You have passed 4 arguments.`。
+
+使用 rest 參數，就不需要查看 `args` 數組，並且允許我們在參數數組上使用 `map()`、`filter()` 和 `reduce()`。
+
+# --instructions--
+
+修改 `sum` 函數，使用 rest 參數，使 `sum` 函數可以接收任意數量的參數，並返回它們的總和。
+
+# --hints--
+
+`sum(0,1,2)` 的結果應是 3。
+
+```js
+assert(sum(0, 1, 2) === 3);
+```
+
+`sum(1,2,3,4)` 的結果應是 10。
+
+```js
+assert(sum(1, 2, 3, 4) === 10);
+```
+
+`sum(5)` 的結果應是 5。
+
+```js
+assert(sum(5) === 5);
+```
+
+`sum()` 的結果應是 0。
+
+```js
+assert(sum() === 0);
+```
+
+`sum` 應是一個箭頭函數，對 `args` 參數使用 rest 操作符語法（`...`）。
+
+```js
+assert(__helpers.removeWhiteSpace(code).match(/sum=\(\.\.\.args\)=>/));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+const sum = (x, y, z) => {
+ const args = [x, y, z];
+ return args.reduce((a, b) => a + b, 0);
+}
+```
+
+# --solutions--
+
+```js
+const sum = (...args) => {
+ return args.reduce((a, b) => a + b, 0);
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/use-the-spread-operator-to-evaluate-arrays-in-place.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/use-the-spread-operator-to-evaluate-arrays-in-place.md
new file mode 100644
index 0000000000..12f32c76b3
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/use-the-spread-operator-to-evaluate-arrays-in-place.md
@@ -0,0 +1,84 @@
+---
+id: 587d7b89367417b2b2512b48
+title: 使用 spread 運算符展開數組項
+challengeType: 1
+forumTopicId: 301222
+dashedName: use-the-spread-operator-to-evaluate-arrays-in-place
+---
+
+# --description--
+
+ES6 引入了展開操作符 ，可以展開數組以及需要多個參數或元素的表達式。
+
+下面的 ES5 代碼使用了 `apply()` 來計算數組的最大值：
+
+```js
+var arr = [6, 89, 3, 45];
+var maximus = Math.max.apply(null, arr);
+```
+
+`maximus` 的值爲 `89`。
+
+我們必須使用 `Math.max.apply(null, arr)`，因爲 `Math.max(arr)` 返回 `NaN`。 `Math.max()` 函數中需要傳入的是一系列由逗號分隔的參數，而不是一個數組。 展開操作符可以提升代碼的可讀性，使代碼易於維護。
+
+```js
+const arr = [6, 89, 3, 45];
+const maximus = Math.max(...arr);
+```
+
+`maximus` 的值應該是 `89`。
+
+`...arr` 返回一個解壓的數組。 也就是說，它*展開*數組。 然而，展開操作符只能夠在函數的參數中或者數組中使用。 下面的代碼將會報錯：
+
+```js
+const spreaded = ...arr;
+```
+
+# --instructions--
+
+使用展開操作符將 `arr1` 中的內容都複製到 `arr2` 中去。
+
+# --hints--
+
+`arr2` 應該是從 `arr1` 複製而來。
+
+```js
+assert(arr2.every((v, i) => v === arr1[i]) && arr2.length);
+```
+
+應使用展開操作符 `...` 來複制 `arr1`。
+
+```js
+assert(code.match(/Array\(\s*\.\.\.arr1\s*\)|\[\s*\.\.\.arr1\s*\]/));
+```
+
+當 `arr1` 改變的時候，`arr2` 應保持不變。
+
+```js
+assert((arr1, arr2) => {
+ arr1.push('JUN');
+ return arr2.length < arr1.length;
+});
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+const arr1 = ['JAN', 'FEB', 'MAR', 'APR', 'MAY'];
+let arr2;
+
+arr2 = []; // Change this line
+
+console.log(arr2);
+```
+
+# --solutions--
+
+```js
+const arr1 = ['JAN', 'FEB', 'MAR', 'APR', 'MAY'];
+let arr2;
+
+arr2 = [...arr1];
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/write-arrow-functions-with-parameters.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/write-arrow-functions-with-parameters.md
new file mode 100644
index 0000000000..c8a90480e6
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/write-arrow-functions-with-parameters.md
@@ -0,0 +1,94 @@
+---
+id: 587d7b88367417b2b2512b44
+title: 編寫帶參數的箭頭函數
+challengeType: 1
+forumTopicId: 301223
+dashedName: write-arrow-functions-with-parameters
+---
+
+# --description--
+
+和一般的函數一樣，你也可以給箭頭函數傳遞參數。
+
+```js
+const doubler = (item) => item * 2;
+doubler(4);
+```
+
+`doubler(4)` 將返回 `8`。
+
+如果箭頭函數只有一個參數，則可以省略參數外面的括號。
+
+```js
+const doubler = item => item * 2;
+```
+
+可以給箭頭函數傳遞多個參數。
+
+```js
+const multiplier = (item, multi) => item * multi;
+multiplier(4, 2);
+```
+
+`multiplier(4, 2)` 將返回 `8`。
+
+# --instructions--
+
+使用箭頭函數的語法重寫 `myConcat` 函數，將 `arr2` 的內容添加到 `arr1`。
+
+# --hints--
+
+應替換 `var` 關鍵詞。
+
+```js
+(getUserInput) => assert(!getUserInput('index').match(/var/g));
+```
+
+`myConcat` 應該是一個常量（使用`const`）。
+
+```js
+(getUserInput) => assert(getUserInput('index').match(/const\s+myConcat/g));
+```
+
+`myConcat` 應該是一個帶有兩個參數的箭頭函數。
+
+```js
+assert(
+ /myConcat=\(\w+,\w+\)=>/.test(code.replace(/\s/g, '')) &&
+ typeof myConcat === 'function'
+);
+```
+
+`myConcat()` 應該返回 `[1, 2, 3, 4, 5]`。
+
+```js
+assert.deepEqual(myConcat([1, 2], [3, 4, 5]), [1, 2, 3, 4, 5]);
+```
+
+不能使用 `function` 關鍵字。
+
+```js
+(getUserInput) => assert(!getUserInput('index').match(/function/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+var myConcat = function(arr1, arr2) {
+ return arr1.concat(arr2);
+};
+
+console.log(myConcat([1, 2], [3, 4, 5]));
+```
+
+# --solutions--
+
+```js
+const myConcat = (arr1, arr2) => {
+ return arr1.concat(arr2);
+};
+
+console.log(myConcat([1, 2], [3, 4, 5]));
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/write-concise-declarative-functions-with-es6.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/write-concise-declarative-functions-with-es6.md
new file mode 100644
index 0000000000..2af031b349
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/write-concise-declarative-functions-with-es6.md
@@ -0,0 +1,86 @@
+---
+id: 587d7b8b367417b2b2512b50
+title: 用 ES6 編寫簡潔的函數聲明
+challengeType: 1
+forumTopicId: 301224
+dashedName: write-concise-declarative-functions-with-es6
+---
+
+# --description--
+
+在 ES5 中，當我們需要在對象中定義一個函數的時候，必須像這樣使用 `function` 關鍵字：
+
+```js
+const person = {
+ name: "Taylor",
+ sayHello: function() {
+ return `Hello! My name is ${this.name}.`;
+ }
+};
+```
+
+用 ES6 的語法在對象中定義函數的時候，可以刪除 `function` 關鍵詞和冒號。 請看以下例子：
+
+```js
+const person = {
+ name: "Taylor",
+ sayHello() {
+ return `Hello! My name is ${this.name}.`;
+ }
+};
+```
+
+# --instructions--
+
+使用以上這種簡短的語法，重構在 `bicycle` 對象中的 `setGear` 函數。
+
+# --hints--
+
+不應使用傳統的函數定義方法。
+
+```js
+(getUserInput) => assert(!code.match(/function/));
+```
+
+`setGear` 應是一個聲明函數。
+
+```js
+assert(
+ typeof bicycle.setGear === 'function' && code.match(/setGear\s*\(.+\)\s*\{/)
+);
+```
+
+`bicycle.setGear(48)` 應將 `gear` 的值改爲 48。
+
+```js
+assert(new bicycle.setGear(48).gear === 48);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// Only change code below this line
+const bicycle = {
+ gear: 2,
+ setGear: function(newGear) {
+ this.gear = newGear;
+ }
+};
+// Only change code above this line
+bicycle.setGear(3);
+console.log(bicycle.gear);
+```
+
+# --solutions--
+
+```js
+const bicycle = {
+ gear: 2,
+ setGear(newGear) {
+ this.gear = newGear;
+ }
+};
+bicycle.setGear(3);
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/write-concise-object-literal-declarations-using-object-property-shorthand.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/write-concise-object-literal-declarations-using-object-property-shorthand.md
new file mode 100644
index 0000000000..fb53b60022
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/es6/write-concise-object-literal-declarations-using-object-property-shorthand.md
@@ -0,0 +1,75 @@
+---
+id: 587d7b8a367417b2b2512b4f
+title: 使用簡單字段編寫簡潔的對象字面量聲明
+challengeType: 1
+forumTopicId: 301225
+dashedName: write-concise-object-literal-declarations-using-object-property-shorthand
+---
+
+# --description--
+
+ES6 添加了一些很棒的功能，用於更方便地定義對象。
+
+請看以下代碼：
+
+```js
+const getMousePosition = (x, y) => ({
+ x: x,
+ y: y
+});
+```
+
+`getMousePosition` 簡單的函數，返回擁有兩個屬性的對象。 ES6 提供了一個語法糖，消除了類似 `x: x` 這種冗餘的寫法。 你可以只寫一次 `x`，解釋器會自動將其轉換成 `x: x`（或效果相同的內容）。 下面是使用這種語法重寫的同樣的函數：
+
+```js
+const getMousePosition = (x, y) => ({ x, y });
+```
+
+# --instructions--
+
+請使用簡單屬性對象的語法來創建並返回一個具有 `name`、`age` 和 `gender` 屬性的對象。
+
+# --hints--
+
+`createPerson("Zodiac Hasbro", 56, "male")` 應該返回 `{name: "Zodiac Hasbro", age: 56, gender: "male"}`。
+
+```js
+assert.deepEqual(
+ { name: 'Zodiac Hasbro', age: 56, gender: 'male' },
+ createPerson('Zodiac Hasbro', 56, 'male')
+);
+```
+
+不要使用 `key:value`。
+
+```js
+(getUserInput) => assert(!getUserInput('index').match(/:/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+const createPerson = (name, age, gender) => {
+ // Only change code below this line
+ return {
+ name: name,
+ age: age,
+ gender: gender
+ };
+ // Only change code above this line
+};
+```
+
+# --solutions--
+
+```js
+const createPerson = (name, age, gender) => {
+ return {
+ name,
+ age,
+ gender
+ };
+};
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/add-elements-to-the-end-of-an-array-using-concat-instead-of-push.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/add-elements-to-the-end-of-an-array-using-concat-instead-of-push.md
new file mode 100644
index 0000000000..ed76e10d95
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/add-elements-to-the-end-of-an-array-using-concat-instead-of-push.md
@@ -0,0 +1,88 @@
+---
+id: 587d7da9367417b2b2512b67
+title: 使用 concat 而不是 push 將元素添加到數組的末尾
+challengeType: 1
+forumTopicId: 301226
+dashedName: add-elements-to-the-end-of-an-array-using-concat-instead-of-push
+---
+
+# --description--
+
+函數式編程就是創建和使用具有不變性的函數。
+
+上一個挑戰介紹了 `concat` 方法，這是一種在不改變原始數組的前提下，將數組組合成新數組的方法。 將 `concat` 方法與 `push` 方法做比較。 `push` 將元素添加到調用它的數組的末尾，這樣會改變該數組。 舉個例子：
+
+```js
+var arr = [1, 2, 3];
+arr.push([4, 5, 6]);
+```
+
+`arr` 的值被修改爲 `[1, 2, 3, [4, 5, 6]]`，這不是函數編程方式。
+
+`concat` 方法可以將新項目添加到數組末尾，而不產生副作用。
+
+# --instructions--
+
+修改 `nonMutatingPush` 函數，用 `concat` 替代 `push` 將 `newItem` 添加到 `original` 末尾。 該函數應返回一個數組。
+
+# --hints--
+
+應該使用 `concat` 方法。
+
+```js
+assert(code.match(/\.concat/g));
+```
+
+不能使用 `push` 方法。
+
+```js
+assert(!code.match(/\.?[\s\S]*?push/g));
+```
+
+不能改變 `first` 數組。
+
+```js
+assert(JSON.stringify(first) === JSON.stringify([1, 2, 3]));
+```
+
+不能改變 `second` 數組。
+
+```js
+assert(JSON.stringify(second) === JSON.stringify([4, 5]));
+```
+
+`nonMutatingPush([1, 2, 3], [4, 5])` 應返回 `[1, 2, 3, 4, 5]`。
+
+```js
+assert(
+ JSON.stringify(nonMutatingPush([1, 2, 3], [4, 5])) ===
+ JSON.stringify([1, 2, 3, 4, 5])
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function nonMutatingPush(original, newItem) {
+ // Only change code below this line
+ return original.push(newItem);
+
+ // Only change code above this line
+}
+var first = [1, 2, 3];
+var second = [4, 5];
+nonMutatingPush(first, second);
+```
+
+# --solutions--
+
+```js
+function nonMutatingPush(original, newItem) {
+ return original.concat(newItem);
+}
+var first = [1, 2, 3];
+var second = [4, 5];
+nonMutatingPush(first, second);
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/apply-functional-programming-to-convert-strings-to-url-slugs.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/apply-functional-programming-to-convert-strings-to-url-slugs.md
new file mode 100644
index 0000000000..bb8fd38831
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/apply-functional-programming-to-convert-strings-to-url-slugs.md
@@ -0,0 +1,84 @@
+---
+id: 587d7dab367417b2b2512b6d
+title: 應用函數式編程將字符串轉換爲URL片段
+challengeType: 1
+forumTopicId: 301227
+dashedName: apply-functional-programming-to-convert-strings-to-url-slugs
+---
+
+# --description--
+
+最後幾個挑戰中涵蓋了許多符合函數式編程原則並在處理數組和字符串中非常有用的方法。 我們還學習了強大的、可以將問題簡化爲更簡單形式的 `reduce` 方法。 從計算平均值到排序，任何數組操作都可以用它來實現。 回想一下，`map` 和 `filter` 方法都是 `reduce` 的特殊實現。
+
+讓我們把學到的知識結合起來解決一個實際問題。
+
+許多內容管理站點（CMS）爲了讓添加書籤更簡單，會將帖子的標題添加到 URL 上。 舉個例子，如果你寫了一篇標題爲 `Stop Using Reduce` 的帖子，URL很可能會包含標題字符串的某種形式 (如：`.../stop-using-reduce`)。 你可能已經在 freeCodeCamp 網站上注意到了這一點。
+
+# --instructions--
+
+填寫 `urlSlug` 函數，將字符串 `title` 轉換成帶有連字符號的 URL。 您可以使用本節中介紹的任何方法，但不要用 `replace` 方法。 以下是本次挑戰的要求：
+
+輸入包含空格和標題大小寫單詞的字符串
+
+輸出字符串，單詞之間的空格用連字符 (`-`) 替換
+
+輸出應該是小寫字母
+
+輸出不應有任何空格
+
+# --hints--
+
+不能使用 `replace` 方法。
+
+```js
+assert(!code.match(/\.?[\s\S]*?replace/g));
+```
+
+`urlSlug("Winter Is Coming")` 應返回 `winter-is-coming`。
+
+```js
+assert(urlSlug('Winter Is Coming') === 'winter-is-coming');
+```
+
+`urlSlug(" Winter Is Coming")` 應返回 `winter-is-coming`。
+
+```js
+assert(urlSlug(' Winter Is Coming') === 'winter-is-coming');
+```
+
+`urlSlug("A Mind Needs Books Like A Sword Needs A Whetstone")` 應返回 `a-mind-needs-books-like-a-sword-needs-a-whetstone`。
+
+```js
+assert(
+ urlSlug('A Mind Needs Books Like A Sword Needs A Whetstone') ===
+ 'a-mind-needs-books-like-a-sword-needs-a-whetstone'
+);
+```
+
+`urlSlug("Hold The Door")` 應返回 `hold-the-door`。
+
+```js
+assert(urlSlug('Hold The Door') === 'hold-the-door');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// Only change code below this line
+function urlSlug(title) {
+
+
+}
+// Only change code above this line
+```
+
+# --solutions--
+
+```js
+// Only change code below this line
+function urlSlug(title) {
+ return title.trim().split(/\s+/).join("-").toLowerCase();
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/avoid-mutations-and-side-effects-using-functional-programming.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/avoid-mutations-and-side-effects-using-functional-programming.md
new file mode 100644
index 0000000000..3f67e299b9
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/avoid-mutations-and-side-effects-using-functional-programming.md
@@ -0,0 +1,78 @@
+---
+id: 587d7b8e367417b2b2512b5e
+title: 使用函數式編程避免變化和副作用
+challengeType: 1
+forumTopicId: 301228
+dashedName: avoid-mutations-and-side-effects-using-functional-programming
+---
+
+# --description--
+
+如果你還沒想通，上一個挑戰的問題出在 `tabClose()` 函數裏的 `splice`。 不幸的是，`splice` 修改了調用它的原始數組，所以第二次調用它時是基於修改後的數組，纔給出了意料之外的結果。
+
+這是一個小例子，還有更廣義的定義——在變量，數組或對象上調用一個函數，這個函數會改變對象中的變量或其他東西。
+
+函數式編程的核心原則之一是不改變任何東西。 變化會導致錯誤。 如果一個函數不改變傳入的參數、全局變量等數據，那麼它造成問題的可能性就會小很多。
+
+前面的例子沒有任何複雜的操作，但是 `splice` 方法改變了原始數組，導致 bug 產生。
+
+回想一下，在函數式編程中，改變或變更叫做 mutation ，這種改變的結果叫做“副作用”（side effect ）。 理想情況下，函數應該是不會產生任何副作用的 pure function 。
+
+讓我們嘗試掌握這個原則：不要改變代碼中的任何變量或對象。
+
+# --instructions--
+
+填寫 `incrementer` 函數的代碼，使其返回值爲全局變量 `fixedValue` 增加 1 。
+
+# --hints--
+
+`incrementer` 函數不能改變 `fixedValue` 的值（`4`）。
+
+```js
+incrementer();
+assert(fixedValue === 4);
+```
+
+`incrementer` 函數應返回比 `fixedValue` 變量更大的值。
+
+```js
+const __newValue = incrementer();
+assert(__newValue === 5);
+```
+
+你的 `incrementer` 函數返回的值應該基於全局變量 `fixedValue` 的值。
+
+```js
+(function () {
+ fixedValue = 10;
+ const newValue = incrementer();
+ assert(fixedValue === 10 && newValue === 11);
+ fixedValue = 4;
+})();
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// The global variable
+var fixedValue = 4;
+
+function incrementer () {
+ // Only change code below this line
+
+
+ // Only change code above this line
+}
+```
+
+# --solutions--
+
+```js
+var fixedValue = 4
+
+function incrementer() {
+ return fixedValue + 1
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/combine-an-array-into-a-string-using-the-join-method.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/combine-an-array-into-a-string-using-the-join-method.md
new file mode 100644
index 0000000000..f82e007c38
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/combine-an-array-into-a-string-using-the-join-method.md
@@ -0,0 +1,90 @@
+---
+id: 587d7daa367417b2b2512b6c
+title: 使用 join 方法將數組組合成字符串
+challengeType: 1
+forumTopicId: 18221
+dashedName: combine-an-array-into-a-string-using-the-join-method
+---
+
+# --description--
+
+`join` 方法用來把數組中的所有元素放入一個字符串。 並通過指定的分隔符參數進行分隔。
+
+舉個例子：
+
+```js
+var arr = ["Hello", "World"];
+var str = arr.join(" ");
+```
+
+`str` 的值應該是字符串 `Hello World`。
+# --instructions--
+
+在函數 `sentensify` 內用 `join` 方法（及其他方法）用字符串 `str` 中的單詞造句，這個函數應返回一個字符串。 該函數應返回一個數組。 舉個例子，`I-like-Star-Wars` 會被轉換成 `I like Star Wars`。 在此挑戰中請勿使用 `replace` 方法。
+
+# --hints--
+
+應使用 `join` 方法。
+
+```js
+assert(code.match(/\.join/g));
+```
+
+不能使用 `replace` 方法。
+
+```js
+assert(!code.match(/\.?[\s\S]*?replace/g));
+```
+
+`sentensify("May-the-force-be-with-you")` 應返回一個字符串。
+
+```js
+assert(typeof sentensify('May-the-force-be-with-you') === 'string');
+```
+
+`sentensify("May-the-force-be-with-you")` 應返回 `May the force be with you`。
+
+```js
+assert(sentensify('May-the-force-be-with-you') === 'May the force be with you');
+```
+
+`sentensify("The.force.is.strong.with.this.one")` 應返回 `The force is strong with this one`。
+
+```js
+assert(
+ sentensify('The.force.is.strong.with.this.one') ===
+ 'The force is strong with this one'
+);
+```
+
+`sentensify("There,has,been,an,awakening")` 應返回 `There has been an awakening`。
+
+```js
+assert(
+ sentensify('There,has,been,an,awakening') === 'There has been an awakening'
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function sentensify(str) {
+ // Only change code below this line
+
+
+ // Only change code above this line
+}
+sentensify("May-the-force-be-with-you");
+```
+
+# --solutions--
+
+```js
+function sentensify(str) {
+ // Only change code below this line
+ return str.split(/\W/).join(' ');
+ // Only change code above this line
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/combine-two-arrays-using-the-concat-method.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/combine-two-arrays-using-the-concat-method.md
new file mode 100644
index 0000000000..92a0001506
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/combine-two-arrays-using-the-concat-method.md
@@ -0,0 +1,79 @@
+---
+id: 587d7da9367417b2b2512b66
+title: 使用 concat 方法組合兩個數組
+challengeType: 1
+forumTopicId: 301229
+dashedName: combine-two-arrays-using-the-concat-method
+---
+
+# --description--
+
+Concatenation 意思是將元素連接到尾部。 同理，JavaScript 爲字符串和數組提供了`concat`方法。 對數組來說，在一個數組上調用 `concat` 方法，然後提供另一個數組作爲參數添加到第一個數組末尾。 它返回一個新數組，不會改變任何一個原始數組。 舉個例子：
+
+```js
+[1, 2, 3].concat([4, 5, 6]);
+```
+
+返回的數組將是 `[1, 2, 3, 4, 5, 6]`。
+
+# --instructions--
+
+在 `nonMutatingConcat` 函數裏使用 `concat`，將 `attach` 拼接到 `original` 尾部。 函數返回拼接後的數組。
+
+# --hints--
+
+應該使用 `concat` 方法。
+
+```js
+assert(code.match(/\.concat/g));
+```
+
+不應該改變 `first` 數組。
+
+```js
+assert(JSON.stringify(first) === JSON.stringify([1, 2, 3]));
+```
+
+不應該改變 `second` 數組。
+
+```js
+assert(JSON.stringify(second) === JSON.stringify([4, 5]));
+```
+
+`nonMutatingConcat([1, 2, 3], [4, 5])` 應該返回 `[1, 2, 3, 4, 5]`。
+
+```js
+assert(
+ JSON.stringify(nonMutatingConcat([1, 2, 3], [4, 5])) ===
+ JSON.stringify([1, 2, 3, 4, 5])
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function nonMutatingConcat(original, attach) {
+ // Only change code below this line
+
+
+ // Only change code above this line
+}
+var first = [1, 2, 3];
+var second = [4, 5];
+nonMutatingConcat(first, second);
+```
+
+# --solutions--
+
+```js
+function nonMutatingConcat(original, attach) {
+ // Only change code below this line
+ return original.concat(attach);
+ // Only change code above this line
+}
+var first = [1, 2, 3];
+var second = [4, 5];
+nonMutatingConcat(first, second);
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/implement-map-on-a-prototype.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/implement-map-on-a-prototype.md
new file mode 100644
index 0000000000..426f31fe7e
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/implement-map-on-a-prototype.md
@@ -0,0 +1,75 @@
+---
+id: 587d7b8f367417b2b2512b62
+title: 在原型上實現 map 方法
+challengeType: 1
+forumTopicId: 301230
+dashedName: implement-map-on-a-prototype
+---
+
+# --description--
+
+之前用到了 `Array.prototype.map()` 方法（即 `map()`），通過 `map` 返回一個與調用它的數組長度相同的數組。 只要它的回調函數不改變原始數組，它就不會改變原始數組。
+
+換句話說，`map` 是一個純函數，它的輸出僅取決於輸入的數組和作爲參數傳入的回調函數。 此外，它接收另一個函數作爲它的參數。
+
+實現一個 `map`，加深對它的瞭解。 你可以用 `for` 循環或者 `Array.prototype.forEach()` 方法。
+
+# --instructions--
+
+寫一個和 `Array.prototype.map()` 一樣的 `Array.prototype.myMap()`。 不能使用內置的 `map` 方法。 在 `myMap` 方法內，可以使用 `this` 訪問 `Array` 實例。
+
+# --hints--
+
+`new_s` 應該等於 `[46, 130, 196, 10]`。
+
+```js
+assert(JSON.stringify(new_s) === JSON.stringify([46, 130, 196, 10]));
+```
+
+不能使用 `map` 方法。
+
+```js
+assert(!code.match(/\.?[\s\S]*?map/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// The global variable
+var s = [23, 65, 98, 5];
+
+Array.prototype.myMap = function(callback) {
+ var newArray = [];
+ // Only change code below this line
+
+ // Only change code above this line
+ return newArray;
+};
+
+var new_s = s.myMap(function(item) {
+ return item * 2;
+});
+```
+
+# --solutions--
+
+```js
+// the global Array
+var s = [23, 65, 98, 5];
+
+Array.prototype.myMap = function(callback) {
+ var newArray = [];
+ // Only change code below this line
+ for (var elem of this) {
+ newArray.push(callback(elem));
+ }
+ // Only change code above this line
+ return newArray;
+};
+
+var new_s = s.myMap(function(item) {
+ return item * 2;
+});
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/implement-the-filter-method-on-a-prototype.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/implement-the-filter-method-on-a-prototype.md
new file mode 100644
index 0000000000..1e565f7af0
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/implement-the-filter-method-on-a-prototype.md
@@ -0,0 +1,70 @@
+---
+id: 587d7b8f367417b2b2512b64
+title: 在原型上實現 filter 方法
+challengeType: 1
+forumTopicId: 301231
+dashedName: implement-the-filter-method-on-a-prototype
+---
+
+# --description--
+
+爲了加深對 `filter` 的理解，可以自己實現一個。 可以用 `for` 循環或 `Array.prototype.forEach()`。
+
+# --instructions--
+
+編寫一個和 `Array.prototype.filter()` 功能一樣的 `Array.prototype.myFilter()` 方法。 不能使用內置的 `filter` 方法。 在 `myFilter` 方法內部，可以使用 `this` 訪問 `Array` 實例。
+
+# --hints--
+
+`new_s` 應該等於 `[23, 65, 5]`。
+
+```js
+assert(JSON.stringify(new_s) === JSON.stringify([23, 65, 5]));
+```
+
+不應該使用 `filter` 方法。
+
+```js
+assert(!code.match(/\.?[\s\S]*?filter/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// The global variable
+var s = [23, 65, 98, 5];
+
+Array.prototype.myFilter = function(callback) {
+ // Only change code below this line
+ var newArray = [];
+ // Only change code above this line
+ return newArray;
+};
+
+var new_s = s.myFilter(function(item) {
+ return item % 2 === 1;
+});
+```
+
+# --solutions--
+
+```js
+// the global Array
+var s = [23, 65, 98, 5];
+
+Array.prototype.myFilter = function(callback) {
+ var newArray = [];
+ // Only change code below this line
+ for (let i = 0; i < this.length; i++) {
+ if (callback(this[i])) newArray.push(this[i]);
+ }
+ // Only change code above this line
+ return newArray;
+};
+
+var new_s = s.myFilter(function(item) {
+ return item % 2 === 1;
+});
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/introduction-to-currying-and-partial-application.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/introduction-to-currying-and-partial-application.md
new file mode 100644
index 0000000000..26f1ee6652
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/introduction-to-currying-and-partial-application.md
@@ -0,0 +1,100 @@
+---
+id: 587d7dab367417b2b2512b70
+title: 函數柯里化和局部調用
+challengeType: 1
+forumTopicId: 301232
+dashedName: introduction-to-currying-and-partial-application
+---
+
+# --description--
+
+arity （參數個數）是函數所需的形參的數量。 函數柯里化（Currying ）意思是把接受多個 arity 的函數變換成接受單一 arity 的函數。
+
+換句話說，就是重構函數讓它接收一個參數，然後返回接收下一個參數的函數，依此類推。
+
+舉個例子：
+
+```js
+function unCurried(x, y) {
+ return x + y;
+}
+
+function curried(x) {
+ return function(y) {
+ return x + y;
+ }
+}
+
+const curried = x => y => x + y
+
+curried(1)(2)
+```
+
+`curried(1)(2)` 會返回 `3`。
+
+柯里化在不能一次爲函數提供所有參數情況下很有用。 因爲它可以將每個函數的調用保存到一個變量中，該變量將保存返回的函數引用，該引用在下一個參數可用時接受該參數。 下面是使用柯里化函數的例子：
+
+```js
+var funcForY = curried(1);
+console.log(funcForY(2)); // 3
+```
+
+類似地，局部調用（ partial application ）的意思是一次對一個函數應用幾個參數，然後返回另一個應用更多參數的函數。 這是一個示例：
+
+```js
+function impartial(x, y, z) {
+ return x + y + z;
+}
+var partialFn = impartial.bind(this, 1, 2);
+partialFn(10); // 13
+```
+
+# --instructions--
+
+填寫 `add` 函數主體部分，用柯里化添加參數 `x`，`y` 和 `z`.
+
+# --hints--
+
+`add(10)(20)(30)` 應返回 `60`。
+
+```js
+assert(add(10)(20)(30) === 60);
+```
+
+`add(1)(2)(3)` 應返回 `6`。
+
+```js
+assert(add(1)(2)(3) === 6);
+```
+
+`add(11)(22)(33)` 應返回 `66`。
+
+```js
+assert(add(11)(22)(33) === 66);
+```
+
+應返回 `x + y + z` 的最終結果。
+
+```js
+assert(code.match(/[xyz]\s*?\+\s*?[xyz]\s*?\+\s*?[xyz]/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function add(x) {
+ // Only change code below this line
+
+
+ // Only change code above this line
+}
+add(10)(20)(30);
+```
+
+# --solutions--
+
+```js
+const add = x => y => z => x + y + z
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/learn-about-functional-programming.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/learn-about-functional-programming.md
new file mode 100644
index 0000000000..61741c87bd
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/learn-about-functional-programming.md
@@ -0,0 +1,86 @@
+---
+id: 587d7b8d367417b2b2512b5b
+title: 學習函數式編程
+challengeType: 1
+forumTopicId: 301233
+dashedName: learn-about-functional-programming
+---
+
+# --description--
+
+函數式編程是一種方案簡單、功能獨立、對作用域外沒有任何副作用的編程範式：`INPUT -> PROCESS -> OUTPUT`。
+
+函數式編程：
+
+1）功能獨立——不依賴於程序的狀態（比如可能發生變化的全局變量）；
+
+2）純函數——同一個輸入永遠能得到同一個輸出；
+
+3）有限的副作用——可以嚴格地限制函數外部對狀態的更改。
+
+# --instructions--
+
+freeCodeCamp 的成員們愛喝茶。
+
+在代碼編輯器中，已經爲你定義好了`prepareTea`和`getTea`函數。 調用 `getTea` 函數爲團隊準備 40 杯茶，並將它們存儲在 `tea4TeamFCC` 變量裏。
+
+# --hints--
+
+`tea4TeamFCC` 變量裏應有 40 杯爲團隊準備的茶。
+
+```js
+assert(tea4TeamFCC.length === 40);
+```
+
+`tea4TeamFCC` 變量裏應有幾杯 greenTea（綠茶）。
+
+```js
+assert(tea4TeamFCC[0] === 'greenTea');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// Function that returns a string representing a cup of green tea
+const prepareTea = () => 'greenTea';
+
+/*
+Given a function (representing the tea type) and number of cups needed, the
+following function returns an array of strings (each representing a cup of
+a specific type of tea).
+*/
+const getTea = (numOfCups) => {
+ const teaCups = [];
+
+ for(let cups = 1; cups <= numOfCups; cups += 1) {
+ const teaCup = prepareTea();
+ teaCups.push(teaCup);
+ }
+ return teaCups;
+};
+
+// Only change code below this line
+const tea4TeamFCC = null;
+// Only change code above this line
+```
+
+# --solutions--
+
+```js
+const prepareTea = () => 'greenTea';
+
+const getTea = (numOfCups) => {
+ const teaCups = [];
+
+ for(let cups = 1; cups <= numOfCups; cups += 1) {
+ const teaCup = prepareTea();
+ teaCups.push(teaCup);
+ }
+
+ return teaCups;
+};
+
+const tea4TeamFCC = getTea(40);
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/pass-arguments-to-avoid-external-dependence-in-a-function.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/pass-arguments-to-avoid-external-dependence-in-a-function.md
new file mode 100644
index 0000000000..6364e9d889
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/pass-arguments-to-avoid-external-dependence-in-a-function.md
@@ -0,0 +1,80 @@
+---
+id: 587d7b8e367417b2b2512b5f
+title: 傳遞參數以避免函數中的外部依賴
+challengeType: 1
+forumTopicId: 301234
+dashedName: pass-arguments-to-avoid-external-dependence-in-a-function
+---
+
+# --description--
+
+上一個挑戰是更接近函數式編程原則的挑戰，但是仍然缺少一些東西。
+
+雖然我們沒有改變全局變量值，但在沒有全局變量 `fixedValue` 的情況下，`incrementer` 函數將不起作用。
+
+函數式編程的另一個原則是：總是顯式聲明依賴關係。 如果函數依賴於一個變量或對象，那麼將該變量或對象作爲參數直接傳遞到函數中。
+
+這樣做會有很多好處。 其中一點是讓函數更容易測試，因爲你確切地知道參數是什麼，並且這個參數也不依賴於程序中的任何其他內容。
+
+其次，這樣做可以讓你更加自信地更改，刪除或添加新代碼。 因爲你很清楚哪些是可以改的，哪些是不可以改的，這樣你就知道哪裏可能會有潛在的陷阱。
+
+最後，無論代碼的哪一部分執行它，函數總是會爲同一組輸入生成相同的輸出。
+
+# --instructions--
+
+更新 `incrementer` 函數，明確聲明其依賴項。
+
+編寫 `incrementer` 函數，獲取它的參數，然後將值增加 1。
+
+# --hints--
+
+`incrementer` 函數不能修改 `fixedValue` 的值（它的值是 `4`）。
+
+```js
+assert(fixedValue === 4);
+```
+
+`incrementer` 函數應該接收一個參數。
+
+```js
+assert(incrementer.length === 1);
+```
+
+`incrementer` 函數應返回比 `fixedValue` 更大的值。
+
+```js
+const __newValue = incrementer(fixedValue);
+assert(__newValue === 5);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// The global variable
+var fixedValue = 4;
+
+// Only change code below this line
+function incrementer () {
+
+
+ // Only change code above this line
+}
+```
+
+# --solutions--
+
+```js
+// The global variable
+var fixedValue = 4;
+
+// Only change code below this line
+function incrementer (fixedValue) {
+ return fixedValue + 1;
+
+ // Only change code above this line
+}
+
+
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/refactor-global-variables-out-of-functions.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/refactor-global-variables-out-of-functions.md
new file mode 100644
index 0000000000..069845644a
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/refactor-global-variables-out-of-functions.md
@@ -0,0 +1,141 @@
+---
+id: 587d7b8f367417b2b2512b60
+title: 在函數中重構全局變量
+challengeType: 1
+forumTopicId: 301235
+dashedName: refactor-global-variables-out-of-functions
+---
+
+# --description--
+
+目前爲止，我們已經看到了函數式編程的兩個原則：
+
+1) 不要更改變量或對象 - 創建新變量和對象，並在需要時從函數返回它們。 提示：使用類似 `var newArr = arrVar` 時 `arrVar` 是一個數組，代碼只是創建一個對現有變量的引用，而不是副本。 所以更改 `newArr` 中的值會同時更改 `arrVar` 中的值。
+
+2) 聲明函數參數 - 函數內的任何計算僅取決於參數，而不取決於任何全局對象或變量。
+
+給數字增加 1 不夠刺激，我們可以在處理數組或更復雜的對象時應用這些原則。
+
+# --instructions--
+
+重構代碼，使全局數組 `bookList` 在函數內部不會被改變。 `add` 函數可以將指定的 `bookName` 增加到數組末尾並返回一個新的數組（列表）。 `remove` 函數可以從數組中移除指定 `bookName`。
+
+**注意：** 兩個函數都應該返回一個數組，任何新參數都應該在 `bookName` 參數之前添加。
+
+# --hints--
+
+`bookList` 應等於 `["The Hound of the Baskervilles", "On The Electrodynamics of Moving Bodies", "Philosophiæ Naturalis Principia Mathematica", "Disquisitiones Arithmeticae"]`.
+
+```js
+assert(
+ JSON.stringify(bookList) ===
+ JSON.stringify([
+ 'The Hound of the Baskervilles',
+ 'On The Electrodynamics of Moving Bodies',
+ 'Philosophiæ Naturalis Principia Mathematica',
+ 'Disquisitiones Arithmeticae'
+ ])
+);
+```
+
+`newBookList` 應等於 `["The Hound of the Baskervilles", "On The Electrodynamics of Moving Bodies", "Philosophiæ Naturalis Principia Mathematica", "Disquisitiones Arithmeticae", "A Brief History of Time"]`.
+
+```js
+assert(
+ JSON.stringify(newBookList) ===
+ JSON.stringify([
+ 'The Hound of the Baskervilles',
+ 'On The Electrodynamics of Moving Bodies',
+ 'Philosophiæ Naturalis Principia Mathematica',
+ 'Disquisitiones Arithmeticae',
+ 'A Brief History of Time'
+ ])
+);
+```
+
+`newerBookList` 應等於 `["The Hound of the Baskervilles", "Philosophiæ Naturalis Principia Mathematica", "Disquisitiones Arithmeticae"]`.
+
+```js
+assert(
+ JSON.stringify(newerBookList) ===
+ JSON.stringify([
+ 'The Hound of the Baskervilles',
+ 'Philosophiæ Naturalis Principia Mathematica',
+ 'Disquisitiones Arithmeticae'
+ ])
+);
+```
+
+`newestBookList` 應等於 `["The Hound of the Baskervilles", "Philosophiæ Naturalis Principia Mathematica", "Disquisitiones Arithmeticae", "A Brief History of Time"]`.
+
+```js
+assert(
+ JSON.stringify(newestBookList) ===
+ JSON.stringify([
+ 'The Hound of the Baskervilles',
+ 'Philosophiæ Naturalis Principia Mathematica',
+ 'Disquisitiones Arithmeticae',
+ 'A Brief History of Time'
+ ])
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// The global variable
+var bookList = ["The Hound of the Baskervilles", "On The Electrodynamics of Moving Bodies", "Philosophiæ Naturalis Principia Mathematica", "Disquisitiones Arithmeticae"];
+
+// Change code below this line
+function add (bookName) {
+
+ bookList.push(bookName);
+ return bookList;
+
+ // Change code above this line
+}
+
+// Change code below this line
+function remove (bookName) {
+ var book_index = bookList.indexOf(bookName);
+ if (book_index >= 0) {
+
+ bookList.splice(book_index, 1);
+ return bookList;
+
+ // Change code above this line
+ }
+}
+
+var newBookList = add(bookList, 'A Brief History of Time');
+var newerBookList = remove(bookList, 'On The Electrodynamics of Moving Bodies');
+var newestBookList = remove(add(bookList, 'A Brief History of Time'), 'On The Electrodynamics of Moving Bodies');
+
+console.log(bookList);
+```
+
+# --solutions--
+
+```js
+// The global variable
+var bookList = ["The Hound of the Baskervilles", "On The Electrodynamics of Moving Bodies", "Philosophiæ Naturalis Principia Mathematica", "Disquisitiones Arithmeticae"];
+
+function add (bookList, bookName) {
+ return [...bookList, bookName];
+}
+
+function remove (bookList, bookName) {
+ const bookListCopy = [...bookList];
+ const bookNameIndex = bookList.indexOf(bookName);
+ if (bookNameIndex >= 0) {
+ bookListCopy.splice(bookNameIndex, 1);
+ }
+ return bookListCopy;
+}
+
+var newBookList = add(bookList, 'A Brief History of Time');
+var newerBookList = remove(bookList, 'On The Electrodynamics of Moving Bodies');
+var newestBookList = remove(add(bookList, 'A Brief History of Time'), 'On The Electrodynamics of Moving Bodies');
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/remove-elements-from-an-array-using-slice-instead-of-splice.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/remove-elements-from-an-array-using-slice-instead-of-splice.md
new file mode 100644
index 0000000000..b739782b24
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/remove-elements-from-an-array-using-slice-instead-of-splice.md
@@ -0,0 +1,86 @@
+---
+id: 9d7123c8c441eeafaeb5bdef
+title: 使用 slice 而不是 splice 從數組中移除元素
+challengeType: 1
+forumTopicId: 301236
+dashedName: remove-elements-from-an-array-using-slice-instead-of-splice
+---
+
+# --description--
+
+使用數組時經常遇到要刪除一些元素並保留數組剩餘部分的情況。 爲此，JavaScript 提供了 `splice` 方法，它接收兩個參數：從哪裏開始刪除項目的索引，和要刪除的項目數。 如果沒有提供第二個參數，默認情況下是移除一直到結尾的所有元素。 但 `splice` 方法會改變調用它的原始數組。 舉個例子：
+
+```js
+var cities = ["Chicago", "Delhi", "Islamabad", "London", "Berlin"];
+cities.splice(3, 1);
+```
+
+在這裏 `splice` 返回字符串 `London` 並從城市數組中刪除它。 `cities` 將有值 `["Chicago", "Delhi", "Islamabad", "Berlin"]`。
+
+正如我們在上一次挑戰中看到的那樣，`slice` 方法不會改變原始數組，而是返回一個可以保存到變量中的新數組。 回想一下，`slice` 方法接收兩個參數，從開始索引開始選取到結束（不包括該元素），並在新數組中返回這些元素。 使用 `slice` 方法替代 `splice` 有助於避免數組變化產生的副作用。
+
+# --instructions--
+
+用 `slice` 代替 `splice` 重寫 `nonMutatingSplice` 函數。 將 `cities` 數組長度限制爲 3，並返回一個僅包含前 3 項的新數組。
+
+不要改變提供給函數的原始數組。
+
+# --hints--
+
+你的代碼中應使用 `slice` 方法。
+
+```js
+assert(code.match(/\.slice/g));
+```
+
+不能使用 `splice` 方法。
+
+```js
+assert(!code.match(/\.?[\s\S]*?splice/g));
+```
+
+不能改變 `inputCities` 數組。
+
+```js
+assert(
+ JSON.stringify(inputCities) ===
+ JSON.stringify(['Chicago', 'Delhi', 'Islamabad', 'London', 'Berlin'])
+);
+```
+
+`nonMutatingSplice(["Chicago", "Delhi", "Islamabad", "London", "Berlin"])` 應返回 `["Chicago", "Delhi", "Islamabad"]`。
+
+```js
+assert(
+ JSON.stringify(
+ nonMutatingSplice(['Chicago', 'Delhi', 'Islamabad', 'London', 'Berlin'])
+ ) === JSON.stringify(['Chicago', 'Delhi', 'Islamabad'])
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function nonMutatingSplice(cities) {
+ // Only change code below this line
+ return cities.splice(3);
+
+ // Only change code above this line
+}
+var inputCities = ["Chicago", "Delhi", "Islamabad", "London", "Berlin"];
+nonMutatingSplice(inputCities);
+```
+
+# --solutions--
+
+```js
+function nonMutatingSplice(cities) {
+ // Only change code below this line
+ return cities.slice(0,3);
+ // Only change code above this line
+}
+var inputCities = ["Chicago", "Delhi", "Islamabad", "London", "Berlin"];
+nonMutatingSplice(inputCities);
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/return-a-sorted-array-without-changing-the-original-array.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/return-a-sorted-array-without-changing-the-original-array.md
new file mode 100644
index 0000000000..ed510eaa0f
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/return-a-sorted-array-without-changing-the-original-array.md
@@ -0,0 +1,91 @@
+---
+id: 587d7da9367417b2b2512b6a
+title: 在不更改原始數組的前提下返回排序後的數組
+challengeType: 1
+forumTopicId: 301237
+dashedName: return-a-sorted-array-without-changing-the-original-array
+---
+
+# --description--
+
+`sort` 方法會產生改變原始數組中元素順序的副作用。 換句話說，它會改變數組的位置。 避免這種情況的一種方法是先將空數組連接到正在排序的數組上（記住 `slice` 和 `concat` 返回一個新數組），再用`sort`方法。
+
+# --instructions--
+
+在 `nonMutatingSort` 函數中使用 `sort` 方法對數組中的元素按升序進行排列。 函數不能改變 `globalArray` 變量，應返回一個新數組。
+
+# --hints--
+
+應該使用 `sort` 方法。
+
+```js
+assert(nonMutatingSort.toString().match(/\.sort/g));
+```
+
+`globalArray` 變量不應該改變。
+
+```js
+assert(JSON.stringify(globalArray) === JSON.stringify([5, 6, 3, 2, 9]));
+```
+
+`nonMutatingSort(globalArray)` 應該返回 `[2, 3, 5, 6, 9]`。
+
+```js
+assert(
+ JSON.stringify(nonMutatingSort(globalArray)) ===
+ JSON.stringify([2, 3, 5, 6, 9])
+);
+```
+
+`nonMutatingSort(globalArray)` 不應被硬編碼。
+
+```js
+assert(!nonMutatingSort.toString().match(/[23569]/g));
+```
+
+函數應該返回一個新數組，而不是傳遞給它的數組。
+
+```js
+assert(nonMutatingSort(globalArray) !== globalArray);
+```
+
+`nonMutatingSort([1, 30, 4, 21, 100000])` 應該返回 `[1, 4, 21, 30, 100000]`
+
+```js
+assert(JSON.stringify(nonMutatingSort([1, 30, 4, 21, 100000])) ===
+ JSON.stringify([1, 4, 21, 30, 100000]))
+```
+
+`nonMutatingSort([140000, 104, 99])` 應該返回 `[99, 104, 140000]`。
+
+```js
+assert(JSON.stringify(nonMutatingSort([140000, 104, 99])) ===
+ JSON.stringify([99, 104, 140000]))
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+var globalArray = [5, 6, 3, 2, 9];
+function nonMutatingSort(arr) {
+ // Only change code below this line
+
+
+ // Only change code above this line
+}
+nonMutatingSort(globalArray);
+```
+
+# --solutions--
+
+```js
+var globalArray = [5, 6, 3, 2, 9];
+function nonMutatingSort(arr) {
+ // Only change code below this line
+ return [].concat(arr).sort((a,b) => a-b);
+ // Only change code above this line
+}
+nonMutatingSort(globalArray);
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/return-part-of-an-array-using-the-slice-method.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/return-part-of-an-array-using-the-slice-method.md
new file mode 100644
index 0000000000..4f2bc17be2
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/return-part-of-an-array-using-the-slice-method.md
@@ -0,0 +1,95 @@
+---
+id: 587d7b90367417b2b2512b65
+title: 使用 slice 方法返回數組的一部分
+challengeType: 1
+forumTopicId: 301239
+dashedName: return-part-of-an-array-using-the-slice-method
+---
+
+# --description--
+
+`slice` 方法可以從已有數組中返回指定元素。 它接受兩個參數，第一個規定從何處開始選取，第二個規定從何處結束選取（不包括該元素）。 如果沒有傳參，則默認爲從數組的開頭開始到結尾結束，這是複製整個數組的簡單方式。 `slice` 返回一個新數組，不會修改原始數組。
+
+舉個例子：
+
+```js
+var arr = ["Cat", "Dog", "Tiger", "Zebra"];
+var newArray = arr.slice(1, 3);
+```
+
+`newArray` 值爲 `["Dog", "Tiger"]`
+
+# --instructions--
+
+在 `sliceArray` 函數中使用 `slice` 方法，給出 `beginSlice` 和 `endSlice` 索引，返回 `anim` 數組的一部分。 這個函數應返回一個數組。
+
+# --hints--
+
+應該使用 `slice` 方法。
+
+```js
+assert(code.match(/\.slice/g));
+```
+
+不能改變 `inputAnim` 變量。
+
+```js
+assert(
+ JSON.stringify(inputAnim) ===
+ JSON.stringify(['Cat', 'Dog', 'Tiger', 'Zebra', 'Ant'])
+);
+```
+
+`sliceArray(["Cat", "Dog", "Tiger", "Zebra", "Ant"], 1, 3)` 應返回 `["Dog", "Tiger"]`。
+
+```js
+assert(
+ JSON.stringify(sliceArray(['Cat', 'Dog', 'Tiger', 'Zebra', 'Ant'], 1, 3)) ===
+ JSON.stringify(['Dog', 'Tiger'])
+);
+```
+
+`sliceArray(["Cat", "Dog", "Tiger", "Zebra", "Ant"], 0, 1)` 應返回 `["Cat"]`。
+
+```js
+assert(
+ JSON.stringify(sliceArray(['Cat', 'Dog', 'Tiger', 'Zebra', 'Ant'], 0, 1)) ===
+ JSON.stringify(['Cat'])
+);
+```
+
+`sliceArray(["Cat", "Dog", "Tiger", "Zebra", "Ant"], 1, 4)` 應返回 `["Dog", "Tiger", "Zebra"]`。
+
+```js
+assert(
+ JSON.stringify(sliceArray(['Cat', 'Dog', 'Tiger', 'Zebra', 'Ant'], 1, 4)) ===
+ JSON.stringify(['Dog', 'Tiger', 'Zebra'])
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function sliceArray(anim, beginSlice, endSlice) {
+ // Only change code below this line
+
+
+ // Only change code above this line
+}
+var inputAnim = ["Cat", "Dog", "Tiger", "Zebra", "Ant"];
+sliceArray(inputAnim, 1, 3);
+```
+
+# --solutions--
+
+```js
+function sliceArray(anim, beginSlice, endSlice) {
+ // Only change code below this line
+ return anim.slice(beginSlice, endSlice)
+ // Only change code above this line
+}
+var inputAnim = ["Cat", "Dog", "Tiger", "Zebra", "Ant"];
+sliceArray(inputAnim, 1, 3);
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/sort-an-array-alphabetically-using-the-sort-method.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/sort-an-array-alphabetically-using-the-sort-method.md
new file mode 100644
index 0000000000..6d92cb21a9
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/sort-an-array-alphabetically-using-the-sort-method.md
@@ -0,0 +1,101 @@
+---
+id: 587d7da9367417b2b2512b69
+title: 使用 sort 方法按字母順序給數組排序
+challengeType: 1
+forumTopicId: 18303
+dashedName: sort-an-array-alphabetically-using-the-sort-method
+---
+
+# --description--
+
+`sort` 方法可以根據回調函數對數組元素進行排序。
+
+舉個例子：
+
+```js
+function ascendingOrder(arr) {
+ return arr.sort(function(a, b) {
+ return a - b;
+ });
+}
+ascendingOrder([1, 5, 2, 3, 4]);
+```
+
+這將返回值 `[1, 2, 3, 4, 5]`。
+
+```js
+function reverseAlpha(arr) {
+ return arr.sort(function(a, b) {
+ return a === b ? 0 : a < b ? 1 : -1;
+ });
+}
+reverseAlpha(['l', 'h', 'z', 'b', 's']);
+```
+
+這將返回值 `['z', 's', 'l', 'h', 'b']`。
+
+JavaScript 的默認排序方法是 Unicode 值順序排序，有時可能會得到意想不到的結果。 因此，建議提供一個回調函數來指定如何對數組項目排序。 這個回調函數通常叫做 `compareFunction`，它根據 `compareFunction` 的返回值決定數組元素的排序方式： 如果兩個元素 `a` 和 `b`，`compareFunction(a,b)` 返回一個比 0 小的值，那麼 `a` 會在 `b` 的前面。 如果兩個元素 `a` 和 `b`，`compareFunction(a,b)` 返回一個比 0 大的值，那麼 `b` 會在 `a` 的前面。 如果兩個元素 `a` 和 `b`，`compareFunction(a,b)` 返回等於 0 的值，那麼 `a` 和 `b` 的位置保持不變。
+
+# --instructions--
+
+在 `alphabeticalOrder` 函數中使用 `sort` 方法對 `arr` 中的元素按照字母順序排列。
+
+# --hints--
+
+應該使用 `sort` 方法。
+
+```js
+assert(code.match(/\.sort/g));
+```
+
+`alphabeticalOrder(["a", "d", "c", "a", "z", "g"])` 應返回 `["a", "a", "c", "d", "g", "z"]`。
+
+```js
+assert(
+ JSON.stringify(alphabeticalOrder(['a', 'd', 'c', 'a', 'z', 'g'])) ===
+ JSON.stringify(['a', 'a', 'c', 'd', 'g', 'z'])
+);
+```
+
+`alphabeticalOrder(["x", "h", "a", "m", "n", "m"])`應返回`["a", "h", "m", "m", "n", "x"]`。
+
+```js
+assert(
+ JSON.stringify(alphabeticalOrder(['x', 'h', 'a', 'm', 'n', 'm'])) ===
+ JSON.stringify(['a', 'h', 'm', 'm', 'n', 'x'])
+);
+```
+
+`alphabeticalOrder(["a", "a", "a", "a", "x", "t"])` 應返回 `["a", "a", "a", "a", "t", "x"]`。
+
+```js
+assert(
+ JSON.stringify(alphabeticalOrder(['a', 'a', 'a', 'a', 'x', 't'])) ===
+ JSON.stringify(['a', 'a', 'a', 'a', 't', 'x'])
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function alphabeticalOrder(arr) {
+ // Only change code below this line
+
+
+ // Only change code above this line
+}
+alphabeticalOrder(["a", "d", "c", "a", "z", "g"]);
+```
+
+# --solutions--
+
+```js
+function alphabeticalOrder(arr) {
+ // Only change code below this line
+ return arr.sort();
+ // Only change code above this line
+}
+alphabeticalOrder(["a", "d", "c", "a", "z", "g"]);
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/split-a-string-into-an-array-using-the-split-method.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/split-a-string-into-an-array-using-the-split-method.md
new file mode 100644
index 0000000000..f7fd1cfc07
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/split-a-string-into-an-array-using-the-split-method.md
@@ -0,0 +1,88 @@
+---
+id: 587d7daa367417b2b2512b6b
+title: 使用 split 方法將字符串拆分成數組
+challengeType: 1
+forumTopicId: 18305
+dashedName: split-a-string-into-an-array-using-the-split-method
+---
+
+# --description--
+
+`split` 方法將一個字符串分割成一個字符串數組。 它需要一個參數作爲分隔符，它可以是用於拆分字符串或正則表達式的一個字符。 舉個例子，如果分隔符是空格，你會得到一個單詞數組；如果分隔符是空字符串，你會得到一個由字符串中每個字符組成的數組。
+
+下面是兩個用空格分隔一個字符串的例子，另一個是用數字的正則表達式分隔：
+
+```js
+var str = "Hello World";
+var bySpace = str.split(" ");
+
+var otherString = "How9are7you2today";
+var byDigits = otherString.split(/\d/);
+```
+
+`bySpace` 將有值 `["Hello", "World"]`，`byDigits` 將有值 `["How", "are", "you", "today"]`。
+
+因爲字符串是不可變的，`split` 方法操作它們更方便。
+
+# --instructions--
+
+在 `splitify` 函數中用 `split` 方法將 `str` 分割成單詞數組。 這個方法應該返回一個數組。 單詞不一定都是用空格分隔，所以數組中不應包含標點符號。
+
+# --hints--
+
+應該使用 `split` 方法。
+
+```js
+assert(code.match(/\.split/g));
+```
+
+`splitify("Hello World,I-am code")` 應返回 `["Hello", "World", "I", "am", "code"]`。
+
+```js
+assert(
+ JSON.stringify(splitify('Hello World,I-am code')) ===
+ JSON.stringify(['Hello', 'World', 'I', 'am', 'code'])
+);
+```
+
+`splitify("Earth-is-our home")` 應返回 `["Earth", "is", "our", "home"]`。
+
+```js
+assert(
+ JSON.stringify(splitify('Earth-is-our home')) ===
+ JSON.stringify(['Earth', 'is', 'our', 'home'])
+);
+```
+
+`splitify("This.is.a-sentence")` 應返回 `["This", "is", "a", "sentence"]`。
+
+```js
+assert(
+ JSON.stringify(splitify('This.is.a-sentence')) ===
+ JSON.stringify(['This', 'is', 'a', 'sentence'])
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function splitify(str) {
+ // Only change code below this line
+
+
+ // Only change code above this line
+}
+splitify("Hello World,I-am code");
+```
+
+# --solutions--
+
+```js
+function splitify(str) {
+ // Only change code below this line
+ return str.split(/\W/);
+ // Only change code above this line
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/understand-functional-programming-terminology.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/understand-functional-programming-terminology.md
new file mode 100644
index 0000000000..cde78462f2
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/understand-functional-programming-terminology.md
@@ -0,0 +1,112 @@
+---
+id: 587d7b8e367417b2b2512b5c
+title: 瞭解函數式編程術語
+challengeType: 1
+forumTopicId: 301240
+dashedName: understand-functional-programming-terminology
+---
+
+# --description--
+
+FCC 團隊需求有變更，現在想要兩種茶：綠茶（green tea）和紅茶（black tea）。 事實證明，用戶需求變更是很常見的。
+
+基於以上信息，我們需要重構上一節挑戰中的 `getTea` 函數來處理多種茶的請求。 我們可以修改 `getTea` 接受一個函數作爲參數，使它能夠修改茶的類型。 這讓 `getTea` 更靈活，也使需求變更時爲程序員提供更多控制權。
+
+首先，我們將介紹一些術語：
+
+Callbacks 是被傳遞到另一個函數中調用的函數。 你應該已經在其他函數中看過這個寫法，例如在 `filter` 中，回調函數告訴 JavaScript 以什麼規則過濾數組。
+
+函數就像其他正常值一樣，可以賦值給變量、傳遞給另一個函數，或從其它函數返回，這種函數叫做頭等 first class 函數。 在 JavaScript 中，所有函數都是頭等函數。
+
+將函數爲參數或返回值的函數叫做高階 ( higher order ) 函數。
+
+當函數傳遞給另一個函數或從另一個函數返回時，那些傳入或返回的函數可以叫做lambda 。
+
+# --instructions--
+
+準備 27 杯綠茶和 13 杯紅茶，分別存入 `tea4GreenTeamFCC` 和 `tea4BlackTeamFCC` 變量。 請注意，`getTea` 函數已經變了，現在它接收一個函數作爲第一個參數。
+
+注意：數據（茶的數量）作爲最後一個參數。 我們將在後面的課程中對此進行更多討論。
+
+# --hints--
+
+`tea4GreenTeamFCC` 變量應存有爲團隊準備的 27 杯茶。
+
+```js
+assert(tea4GreenTeamFCC.length === 27);
+```
+
+`tea4GreenTeamFCC` 變量應存有綠茶。
+
+```js
+assert(tea4GreenTeamFCC[0] === 'greenTea');
+```
+
+`tea4BlackTeamFCC` 變量應存有 13 杯紅茶。
+
+```js
+assert(tea4BlackTeamFCC.length === 13);
+```
+
+`tea4BlackTeamFCC` 變量應存有紅茶。
+
+```js
+assert(tea4BlackTeamFCC[0] === 'blackTea');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// Function that returns a string representing a cup of green tea
+const prepareGreenTea = () => 'greenTea';
+
+// Function that returns a string representing a cup of black tea
+const prepareBlackTea = () => 'blackTea';
+
+/*
+Given a function (representing the tea type) and number of cups needed, the
+following function returns an array of strings (each representing a cup of
+a specific type of tea).
+*/
+const getTea = (prepareTea, numOfCups) => {
+ const teaCups = [];
+
+ for(let cups = 1; cups <= numOfCups; cups += 1) {
+ const teaCup = prepareTea();
+ teaCups.push(teaCup);
+ }
+ return teaCups;
+};
+
+// Only change code below this line
+const tea4GreenTeamFCC = null;
+const tea4BlackTeamFCC = null;
+// Only change code above this line
+
+console.log(
+ tea4GreenTeamFCC,
+ tea4BlackTeamFCC
+);
+```
+
+# --solutions--
+
+```js
+const prepareGreenTea = () => 'greenTea';
+const prepareBlackTea = () => 'blackTea';
+
+const getTea = (prepareTea, numOfCups) => {
+ const teaCups = [];
+
+ for(let cups = 1; cups <= numOfCups; cups += 1) {
+ const teaCup = prepareTea();
+ teaCups.push(teaCup);
+ }
+ return teaCups;
+};
+
+const tea4BlackTeamFCC = getTea(prepareBlackTea, 13);
+const tea4GreenTeamFCC = getTea(prepareGreenTea, 27);
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/understand-the-hazards-of-using-imperative-code.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/understand-the-hazards-of-using-imperative-code.md
new file mode 100644
index 0000000000..86fdcb5998
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/understand-the-hazards-of-using-imperative-code.md
@@ -0,0 +1,145 @@
+---
+id: 587d7b8e367417b2b2512b5d
+title: 瞭解使用命令式編程的危害
+challengeType: 1
+forumTopicId: 301241
+dashedName: understand-the-hazards-of-using-imperative-code
+---
+
+# --description--
+
+使用函數式編程是一個好的習慣。 它使你的代碼易於管理，避免潛在的 bug。 但在開始之前，先看看命令式編程方法，以強調你可能有什麼問題。
+
+在英語 (以及許多其他語言) 中，命令式時態用來發出指令。 同樣，命令式編程是向計算機提供一套執行任務的聲明。
+
+命令式編程常常改變程序狀態，例如更新全局變量。 一個典型的例子是編寫 `for` 循環，它爲一個數組的索引提供了準確的迭代方向。
+
+相反，函數式編程是聲明式編程的一種形式。 通過調用方法或函數來告訴計算機要做什麼。
+
+JavaScript 提供了許多處理常見任務的方法，所以你無需寫出計算機應如何執行它們。 例如，你可以用 `map` 函數替代上面提到的 `for` 循環來處理數組迭代。 這有助於避免語義錯誤，如調試章節介紹的 "Off By One Errors"。
+
+考慮這樣的場景：你正在瀏覽器中瀏覽網頁，並想操作你打開的標籤。 下面我們來試試用面向對象的思路來描述這種情景。
+
+窗口對象由選項卡組成，通常會打開多個窗口。 窗口對象中每個打開網站的標題都保存在一個數組中。 在對瀏覽器進行了如打開新標籤、合併窗口、關閉標籤之類的操作後，你需要輸出所有打開的標籤。 關掉的標籤將從數組中刪除，新打開的標籤（爲簡單起見）則添加到數組的末尾。
+
+代碼編輯器中顯示了此功能的實現，其中包含 `tabOpen()`，`tabClose()`，和 `join()` 函數。 `tabs` 數組是窗口對象的一部分用於儲存打開頁面的名稱。
+
+# --instructions--
+
+在編輯器中運行代碼。 它使用了有副作用的方法，導致輸出錯誤。 存儲在 `finalTabs.tabs` 中的打開標籤的最終列表應該是 `['FB', 'Gitter', 'Reddit', 'Twitter', 'Medium', 'new tab', 'Netflix', 'YouTube', 'Vine', 'GMail', 'Work mail', 'Docs', 'freeCodeCamp', 'new tab']`，但輸出會略有不同。
+
+修改 `Window.prototype.tabClose` 使其刪除正確的標籤。
+
+# --hints--
+
+`finalTabs.tabs` 應該是 `['FB', 'Gitter', 'Reddit', 'Twitter', 'Medium', 'new tab', 'Netflix', 'YouTube', 'Vine', 'GMail', 'Work mail', 'Docs', 'freeCodeCamp', 'new tab']`
+
+```js
+assert.deepEqual(finalTabs.tabs, [
+ 'FB',
+ 'Gitter',
+ 'Reddit',
+ 'Twitter',
+ 'Medium',
+ 'new tab',
+ 'Netflix',
+ 'YouTube',
+ 'Vine',
+ 'GMail',
+ 'Work mail',
+ 'Docs',
+ 'freeCodeCamp',
+ 'new tab'
+]);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// tabs is an array of titles of each site open within the window
+var Window = function(tabs) {
+ this.tabs = tabs; // We keep a record of the array inside the object
+};
+
+// When you join two windows into one window
+Window.prototype.join = function (otherWindow) {
+ this.tabs = this.tabs.concat(otherWindow.tabs);
+ return this;
+};
+
+// When you open a new tab at the end
+Window.prototype.tabOpen = function (tab) {
+ this.tabs.push('new tab'); // Let's open a new tab for now
+ return this;
+};
+
+// When you close a tab
+Window.prototype.tabClose = function (index) {
+
+ // Only change code below this line
+
+ var tabsBeforeIndex = this.tabs.splice(0, index); // Get the tabs before the tab
+ var tabsAfterIndex = this.tabs.splice(index + 1); // Get the tabs after the tab
+
+ this.tabs = tabsBeforeIndex.concat(tabsAfterIndex); // Join them together
+
+ // Only change code above this line
+
+ return this;
+ };
+
+// Let's create three browser windows
+var workWindow = new Window(['GMail', 'Inbox', 'Work mail', 'Docs', 'freeCodeCamp']); // Your mailbox, drive, and other work sites
+var socialWindow = new Window(['FB', 'Gitter', 'Reddit', 'Twitter', 'Medium']); // Social sites
+var videoWindow = new Window(['Netflix', 'YouTube', 'Vimeo', 'Vine']); // Entertainment sites
+
+// Now perform the tab opening, closing, and other operations
+var finalTabs = socialWindow
+ .tabOpen() // Open a new tab for cat memes
+ .join(videoWindow.tabClose(2)) // Close third tab in video window, and join
+ .join(workWindow.tabClose(1).tabOpen());
+console.log(finalTabs.tabs);
+```
+
+# --solutions--
+
+```js
+// tabs is an array of titles of each site open within the window
+var Window = function(tabs) {
+ this.tabs = tabs; // We keep a record of the array inside the object
+};
+
+// When you join two windows into one window
+Window.prototype.join = function (otherWindow) {
+ this.tabs = this.tabs.concat(otherWindow.tabs);
+ return this;
+};
+
+// When you open a new tab at the end
+Window.prototype.tabOpen = function (tab) {
+ this.tabs.push('new tab'); // Let's open a new tab for now
+ return this;
+};
+
+// When you close a tab
+Window.prototype.tabClose = function (index) {
+ var tabsBeforeIndex = this.tabs.slice(0, index); // Get the tabs before the tab
+ var tabsAfterIndex = this.tabs.slice(index + 1); // Get the tabs after the tab
+
+ this.tabs = tabsBeforeIndex.concat(tabsAfterIndex); // Join them together
+ return this;
+ };
+
+// Let's create three browser windows
+var workWindow = new Window(['GMail', 'Inbox', 'Work mail', 'Docs', 'freeCodeCamp']); // Your mailbox, drive, and other work sites
+var socialWindow = new Window(['FB', 'Gitter', 'Reddit', 'Twitter', 'Medium']); // Social sites
+var videoWindow = new Window(['Netflix', 'YouTube', 'Vimeo', 'Vine']); // Entertainment sites
+
+// Now perform the tab opening, closing, and other operations
+var finalTabs = socialWindow
+ .tabOpen() // Open a new tab for cat memes
+ .join(videoWindow.tabClose(2)) // Close third tab in video window, and join
+ .join(workWindow.tabClose(1).tabOpen());
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/use-higher-order-functions-map-filter-or-reduce-to-solve-a-complex-problem.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/use-higher-order-functions-map-filter-or-reduce-to-solve-a-complex-problem.md
new file mode 100644
index 0000000000..74e96ac760
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/use-higher-order-functions-map-filter-or-reduce-to-solve-a-complex-problem.md
@@ -0,0 +1,97 @@
+---
+id: 587d7b88367417b2b2512b45
+title: '使用高階函數 map、filter 或者 reduce 來解決複雜問題'
+challengeType: 1
+forumTopicId: 301311
+dashedName: use-higher-order-functions-map-filter-or-reduce-to-solve-a-complex-problem
+---
+
+# --description--
+
+已經接觸了高階函數如 `map()`、 `filter()` 和 `reduce()`的使用，是時候用它們來完成一些複雜的挑戰了。
+
+# --instructions--
+
+已經定義了一個函數 `squareList`。 你需要使用 `map()`，`filter()` 和 `reduce()` 的任意組合來完成 `squareList` 函數的代碼。當傳入一個實數數組時，返回一個*僅*包含正整數（小數不是整數）的平方的新數組。 僅包含實數字的數組示例是 `[-3, 4.8, 5, 3, -3.2]`。
+
+**注意：** 函數不應該包含任何形式的 `for` 或者 `while` 循環或者 `forEach()` 函數。
+
+# --hints--
+
+`squareList` 應該是一個 `function`。
+
+```js
+assert.typeOf(squareList, 'function'),
+ 'squareList should be a function';
+```
+
+不應該使用 `for`、`while` 或者 `forEach`。
+
+```js
+assert(!code.match(/for|while|forEach/g));
+```
+
+應該使用 `map`、`filter` 或者 `reduce`。
+
+```js
+assert(
+ __helpers
+ .removeWhiteSpace(code)
+ .match(/\.(map|filter|reduce)\(/g)
+);
+```
+
+函數應該返回 `array`。
+
+```js
+assert(Array.isArray(squareList([4, 5.6, -9.8, 3.14, 42, 6, 8.34, -2])));
+```
+
+`squareList([4, 5.6, -9.8, 3.14, 42, 6, 8.34, -2])` 應該返回 `[16, 1764, 36]`。
+
+```js
+assert.deepStrictEqual(squareList([4, 5.6, -9.8, 3.14, 42, 6, 8.34, -2]), [
+ 16,
+ 1764,
+ 36
+]);
+```
+
+`squareList([-3.7, -5, 3, 10, 12.5, 7, -4.5, -17, 0.3])` 應該返回 `[9, 100, 49]`。
+
+```js
+assert.deepStrictEqual(squareList([-3.7, -5, 3, 10, 12.5, 7, -4.5, -17, 0.3]), [
+ 9,
+ 100,
+ 49
+]);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+const squareList = arr => {
+ // Only change code below this line
+ return arr;
+ // Only change code above this line
+};
+
+const squaredIntegers = squareList([-3, 4.8, 5, 3, -3.2]);
+console.log(squaredIntegers);
+```
+
+# --solutions--
+
+```js
+const squareList = arr => {
+ const positiveIntegers = arr.filter(num => {
+ return num >= 0 && Number.isInteger(num);
+ });
+ const squaredIntegers = positiveIntegers.map(num => {
+ return num ** 2;
+ });
+ return squaredIntegers;
+};
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/use-the-every-method-to-check-that-every-element-in-an-array-meets-a-criteria.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/use-the-every-method-to-check-that-every-element-in-an-array-meets-a-criteria.md
new file mode 100644
index 0000000000..1cf1fad926
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/use-the-every-method-to-check-that-every-element-in-an-array-meets-a-criteria.md
@@ -0,0 +1,77 @@
+---
+id: 587d7dab367417b2b2512b6e
+title: 使用 every 方法檢查數組中的每個元素是否符合條件
+challengeType: 1
+forumTopicId: 301312
+dashedName: use-the-every-method-to-check-that-every-element-in-an-array-meets-a-criteria
+---
+
+# --description--
+
+`every` 方法用於檢測數組中*所有*元素是否都符合指定條件。 如果所有元素滿足條件，返回布爾值 `true`，反之返回 `false`。
+
+舉個例子，下面的代碼檢測數組 `numbers` 的所有元素是否都小於 10：
+
+```js
+var numbers = [1, 5, 8, 0, 10, 11];
+numbers.every(function(currentValue) {
+ return currentValue < 10;
+});
+```
+
+`every` 方法在這裏會返回 `false`。
+
+# --instructions--
+
+在 `checkPositive` 函數中使用 `every` 方法檢查 `arr` 中是否所有元素都是正數。 函數應返回一個布爾值。
+
+# --hints--
+
+應使用`every`方法。
+
+```js
+assert(code.match(/\.every/g));
+```
+
+`checkPositive([1, 2, 3, -4, 5])` 應返回 `false`。
+
+```js
+assert.isFalse(checkPositive([1, 2, 3, -4, 5]));
+```
+
+`checkPositive([1, 2, 3, 4, 5])` 應返回 `true`。
+
+```js
+assert.isTrue(checkPositive([1, 2, 3, 4, 5]));
+```
+
+`checkPositive([1, -2, 3, -4, 5])` 應返回 `false`。
+
+```js
+assert.isFalse(checkPositive([1, -2, 3, -4, 5]));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function checkPositive(arr) {
+ // Only change code below this line
+
+
+ // Only change code above this line
+}
+checkPositive([1, 2, 3, -4, 5]);
+```
+
+# --solutions--
+
+```js
+function checkPositive(arr) {
+ // Only change code below this line
+ return arr.every(num => num > 0);
+ // Only change code above this line
+}
+checkPositive([1, 2, 3, -4, 5]);
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/use-the-filter-method-to-extract-data-from-an-array.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/use-the-filter-method-to-extract-data-from-an-array.md
new file mode 100644
index 0000000000..e6250d1c78
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/use-the-filter-method-to-extract-data-from-an-array.md
@@ -0,0 +1,317 @@
+---
+id: 587d7b8f367417b2b2512b63
+title: 使用 filter 方法從數組中提取數據
+challengeType: 1
+forumTopicId: 18179
+dashedName: use-the-filter-method-to-extract-data-from-an-array
+---
+
+# --description--
+
+另一個有用的數組方法是 `filter()`（即 `Array.prototype.filter()`）。
+
+`filter` 接收一個回調函數，將回調函數內的邏輯應用於數組的每個元素，新數組包含根據回調函數內條件返回 `true` 的元素。 換言之，它根據傳遞給它的函數過濾數組。 和 `map` 一樣，filter 不會改變原始數組。
+
+回調函數接收三個參數。 第一個參數是當前正在被處理的元素。 第二個參數是這個元素的索引，第三個參數是在其上調用 `filter` 方法的數組。
+
+看下在 `users` 上使用 `filter` 方法的例子，返回了一個包含了 30 歲以下的用戶新數組。 爲了簡化，例子裏只使用了回調函數的第一個參數。
+
+```js
+const users = [
+ { name: 'John', age: 34 },
+ { name: 'Amy', age: 20 },
+ { name: 'camperCat', age: 10 }
+];
+
+const usersUnder30 = users.filter(user => user.age < 30);
+console.log(usersUnder30);
+```
+
+控制檯將顯示值 `[ { name: 'Amy', age: 20 }, { name: 'camperCat', age: 10 } ]`
+
+# --instructions--
+
+`watchList` 變量中包含一組存有多部電影信息對象。 結合 `filter` 和 `map` 返回一個 `watchList` 只包含 `title` 和 `rating` 屬性的新數組。 新數組只包含 `imdbRating` 值大於或等於 8.0 的對象。 請注意，`rating` 值在對象中保存爲字符串，你可能需要將它轉換成數字來執行運算。
+
+# --hints--
+
+`watchList`應保持不變。
+
+```js
+assert(
+ watchList[0].Title === 'Inception' && watchList[4].Director == 'James Cameron'
+);
+```
+
+應使用 `filter` 方法。
+
+```js
+assert(code.match(/\s*\.\s*filter/g));
+```
+
+不能使用 `for` 循環。
+
+```js
+assert(!code.match(/for\s*?\([\s\S]*?\)/g));
+```
+
+`filteredList` 應等於 `[{"title": "Inception","rating": "8.8"},{"title": "Interstellar","rating": "8.6"},{"title": "The Dark Knight","rating": "9.0"},{"title": "Batman Begins","rating": "8.3"}]`。
+
+```js
+assert.deepEqual(filteredList, [
+ { title: 'Inception', rating: '8.8' },
+ { title: 'Interstellar', rating: '8.6' },
+ { title: 'The Dark Knight', rating: '9.0' },
+ { title: 'Batman Begins', rating: '8.3' }
+]);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// The global variable
+var watchList = [
+ {
+ "Title": "Inception",
+ "Year": "2010",
+ "Rated": "PG-13",
+ "Released": "16 Jul 2010",
+ "Runtime": "148 min",
+ "Genre": "Action, Adventure, Crime",
+ "Director": "Christopher Nolan",
+ "Writer": "Christopher Nolan",
+ "Actors": "Leonardo DiCaprio, Joseph Gordon-Levitt, Elliot Page, Tom Hardy",
+ "Plot": "A thief, who steals corporate secrets through use of dream-sharing technology, is given the inverse task of planting an idea into the mind of a CEO.",
+ "Language": "English, Japanese, French",
+ "Country": "USA, UK",
+ "Awards": "Won 4 Oscars. Another 143 wins & 198 nominations.",
+ "Poster": "http://ia.media-imdb.com/images/M/MV5BMjAxMzY3NjcxNF5BMl5BanBnXkFtZTcwNTI5OTM0Mw@@._V1_SX300.jpg",
+ "Metascore": "74",
+ "imdbRating": "8.8",
+ "imdbVotes": "1,446,708",
+ "imdbID": "tt1375666",
+ "Type": "movie",
+ "Response": "True"
+ },
+ {
+ "Title": "Interstellar",
+ "Year": "2014",
+ "Rated": "PG-13",
+ "Released": "07 Nov 2014",
+ "Runtime": "169 min",
+ "Genre": "Adventure, Drama, Sci-Fi",
+ "Director": "Christopher Nolan",
+ "Writer": "Jonathan Nolan, Christopher Nolan",
+ "Actors": "Ellen Burstyn, Matthew McConaughey, Mackenzie Foy, John Lithgow",
+ "Plot": "A team of explorers travel through a wormhole in space in an attempt to ensure humanity's survival.",
+ "Language": "English",
+ "Country": "USA, UK",
+ "Awards": "Won 1 Oscar. Another 39 wins & 132 nominations.",
+ "Poster": "http://ia.media-imdb.com/images/M/MV5BMjIxNTU4MzY4MF5BMl5BanBnXkFtZTgwMzM4ODI3MjE@._V1_SX300.jpg",
+ "Metascore": "74",
+ "imdbRating": "8.6",
+ "imdbVotes": "910,366",
+ "imdbID": "tt0816692",
+ "Type": "movie",
+ "Response": "True"
+ },
+ {
+ "Title": "The Dark Knight",
+ "Year": "2008",
+ "Rated": "PG-13",
+ "Released": "18 Jul 2008",
+ "Runtime": "152 min",
+ "Genre": "Action, Adventure, Crime",
+ "Director": "Christopher Nolan",
+ "Writer": "Jonathan Nolan (screenplay), Christopher Nolan (screenplay), Christopher Nolan (story), David S. Goyer (story), Bob Kane (characters)",
+ "Actors": "Christian Bale, Heath Ledger, Aaron Eckhart, Michael Caine",
+ "Plot": "When the menace known as the Joker wreaks havoc and chaos on the people of Gotham, the caped crusader must come to terms with one of the greatest psychological tests of his ability to fight injustice.",
+ "Language": "English, Mandarin",
+ "Country": "USA, UK",
+ "Awards": "Won 2 Oscars. Another 146 wins & 142 nominations.",
+ "Poster": "http://ia.media-imdb.com/images/M/MV5BMTMxNTMwODM0NF5BMl5BanBnXkFtZTcwODAyMTk2Mw@@._V1_SX300.jpg",
+ "Metascore": "82",
+ "imdbRating": "9.0",
+ "imdbVotes": "1,652,832",
+ "imdbID": "tt0468569",
+ "Type": "movie",
+ "Response": "True"
+ },
+ {
+ "Title": "Batman Begins",
+ "Year": "2005",
+ "Rated": "PG-13",
+ "Released": "15 Jun 2005",
+ "Runtime": "140 min",
+ "Genre": "Action, Adventure",
+ "Director": "Christopher Nolan",
+ "Writer": "Bob Kane (characters), David S. Goyer (story), Christopher Nolan (screenplay), David S. Goyer (screenplay)",
+ "Actors": "Christian Bale, Michael Caine, Liam Neeson, Katie Holmes",
+ "Plot": "After training with his mentor, Batman begins his fight to free crime-ridden Gotham City from the corruption that Scarecrow and the League of Shadows have cast upon it.",
+ "Language": "English, Urdu, Mandarin",
+ "Country": "USA, UK",
+ "Awards": "Nominated for 1 Oscar. Another 15 wins & 66 nominations.",
+ "Poster": "http://ia.media-imdb.com/images/M/MV5BNTM3OTc0MzM2OV5BMl5BanBnXkFtZTYwNzUwMTI3._V1_SX300.jpg",
+ "Metascore": "70",
+ "imdbRating": "8.3",
+ "imdbVotes": "972,584",
+ "imdbID": "tt0372784",
+ "Type": "movie",
+ "Response": "True"
+ },
+ {
+ "Title": "Avatar",
+ "Year": "2009",
+ "Rated": "PG-13",
+ "Released": "18 Dec 2009",
+ "Runtime": "162 min",
+ "Genre": "Action, Adventure, Fantasy",
+ "Director": "James Cameron",
+ "Writer": "James Cameron",
+ "Actors": "Sam Worthington, Zoe Saldana, Sigourney Weaver, Stephen Lang",
+ "Plot": "A paraplegic marine dispatched to the moon Pandora on a unique mission becomes torn between following his orders and protecting the world he feels is his home.",
+ "Language": "English, Spanish",
+ "Country": "USA, UK",
+ "Awards": "Won 3 Oscars. Another 80 wins & 121 nominations.",
+ "Poster": "http://ia.media-imdb.com/images/M/MV5BMTYwOTEwNjAzMl5BMl5BanBnXkFtZTcwODc5MTUwMw@@._V1_SX300.jpg",
+ "Metascore": "83",
+ "imdbRating": "7.9",
+ "imdbVotes": "876,575",
+ "imdbID": "tt0499549",
+ "Type": "movie",
+ "Response": "True"
+ }
+];
+
+// Only change code below this line
+
+var filteredList;
+
+// Only change code above this line
+
+console.log(filteredList);
+```
+
+# --solutions--
+
+```js
+// The global variable
+var watchList = [
+ {
+ "Title": "Inception",
+ "Year": "2010",
+ "Rated": "PG-13",
+ "Released": "16 Jul 2010",
+ "Runtime": "148 min",
+ "Genre": "Action, Adventure, Crime",
+ "Director": "Christopher Nolan",
+ "Writer": "Christopher Nolan",
+ "Actors": "Leonardo DiCaprio, Joseph Gordon-Levitt, Elliot Page, Tom Hardy",
+ "Plot": "A thief, who steals corporate secrets through use of dream-sharing technology, is given the inverse task of planting an idea into the mind of a CEO.",
+ "Language": "English, Japanese, French",
+ "Country": "USA, UK",
+ "Awards": "Won 4 Oscars. Another 143 wins & 198 nominations.",
+ "Poster": "http://ia.media-imdb.com/images/M/MV5BMjAxMzY3NjcxNF5BMl5BanBnXkFtZTcwNTI5OTM0Mw@@._V1_SX300.jpg",
+ "Metascore": "74",
+ "imdbRating": "8.8",
+ "imdbVotes": "1,446,708",
+ "imdbID": "tt1375666",
+ "Type": "movie",
+ "Response": "True"
+ },
+ {
+ "Title": "Interstellar",
+ "Year": "2014",
+ "Rated": "PG-13",
+ "Released": "07 Nov 2014",
+ "Runtime": "169 min",
+ "Genre": "Adventure, Drama, Sci-Fi",
+ "Director": "Christopher Nolan",
+ "Writer": "Jonathan Nolan, Christopher Nolan",
+ "Actors": "Ellen Burstyn, Matthew McConaughey, Mackenzie Foy, John Lithgow",
+ "Plot": "A team of explorers travel through a wormhole in space in an attempt to ensure humanity's survival.",
+ "Language": "English",
+ "Country": "USA, UK",
+ "Awards": "Won 1 Oscar. Another 39 wins & 132 nominations.",
+ "Poster": "http://ia.media-imdb.com/images/M/MV5BMjIxNTU4MzY4MF5BMl5BanBnXkFtZTgwMzM4ODI3MjE@._V1_SX300.jpg",
+ "Metascore": "74",
+ "imdbRating": "8.6",
+ "imdbVotes": "910,366",
+ "imdbID": "tt0816692",
+ "Type": "movie",
+ "Response": "True"
+ },
+ {
+ "Title": "The Dark Knight",
+ "Year": "2008",
+ "Rated": "PG-13",
+ "Released": "18 Jul 2008",
+ "Runtime": "152 min",
+ "Genre": "Action, Adventure, Crime",
+ "Director": "Christopher Nolan",
+ "Writer": "Jonathan Nolan (screenplay), Christopher Nolan (screenplay), Christopher Nolan (story), David S. Goyer (story), Bob Kane (characters)",
+ "Actors": "Christian Bale, Heath Ledger, Aaron Eckhart, Michael Caine",
+ "Plot": "When the menace known as the Joker wreaks havoc and chaos on the people of Gotham, the caped crusader must come to terms with one of the greatest psychological tests of his ability to fight injustice.",
+ "Language": "English, Mandarin",
+ "Country": "USA, UK",
+ "Awards": "Won 2 Oscars. Another 146 wins & 142 nominations.",
+ "Poster": "http://ia.media-imdb.com/images/M/MV5BMTMxNTMwODM0NF5BMl5BanBnXkFtZTcwODAyMTk2Mw@@._V1_SX300.jpg",
+ "Metascore": "82",
+ "imdbRating": "9.0",
+ "imdbVotes": "1,652,832",
+ "imdbID": "tt0468569",
+ "Type": "movie",
+ "Response": "True"
+ },
+ {
+ "Title": "Batman Begins",
+ "Year": "2005",
+ "Rated": "PG-13",
+ "Released": "15 Jun 2005",
+ "Runtime": "140 min",
+ "Genre": "Action, Adventure",
+ "Director": "Christopher Nolan",
+ "Writer": "Bob Kane (characters), David S. Goyer (story), Christopher Nolan (screenplay), David S. Goyer (screenplay)",
+ "Actors": "Christian Bale, Michael Caine, Liam Neeson, Katie Holmes",
+ "Plot": "After training with his mentor, Batman begins his fight to free crime-ridden Gotham City from the corruption that Scarecrow and the League of Shadows have cast upon it.",
+ "Language": "English, Urdu, Mandarin",
+ "Country": "USA, UK",
+ "Awards": "Nominated for 1 Oscar. Another 15 wins & 66 nominations.",
+ "Poster": "http://ia.media-imdb.com/images/M/MV5BNTM3OTc0MzM2OV5BMl5BanBnXkFtZTYwNzUwMTI3._V1_SX300.jpg",
+ "Metascore": "70",
+ "imdbRating": "8.3",
+ "imdbVotes": "972,584",
+ "imdbID": "tt0372784",
+ "Type": "movie",
+ "Response": "True"
+ },
+ {
+ "Title": "Avatar",
+ "Year": "2009",
+ "Rated": "PG-13",
+ "Released": "18 Dec 2009",
+ "Runtime": "162 min",
+ "Genre": "Action, Adventure, Fantasy",
+ "Director": "James Cameron",
+ "Writer": "James Cameron",
+ "Actors": "Sam Worthington, Zoe Saldana, Sigourney Weaver, Stephen Lang",
+ "Plot": "A paraplegic marine dispatched to the moon Pandora on a unique mission becomes torn between following his orders and protecting the world he feels is his home.",
+ "Language": "English, Spanish",
+ "Country": "USA, UK",
+ "Awards": "Won 3 Oscars. Another 80 wins & 121 nominations.",
+ "Poster": "http://ia.media-imdb.com/images/M/MV5BMTYwOTEwNjAzMl5BMl5BanBnXkFtZTcwODc5MTUwMw@@._V1_SX300.jpg",
+ "Metascore": "83",
+ "imdbRating": "7.9",
+ "imdbVotes": "876,575",
+ "imdbID": "tt0499549",
+ "Type": "movie",
+ "Response": "True"
+ }
+];
+
+// Only change code below this line
+let filteredList = watchList.filter(e => e.imdbRating >= 8).map( ({Title: title, imdbRating: rating}) => ({title, rating}) );
+// Only change code above this line
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/use-the-map-method-to-extract-data-from-an-array.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/use-the-map-method-to-extract-data-from-an-array.md
new file mode 100644
index 0000000000..0ad1d55612
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/use-the-map-method-to-extract-data-from-an-array.md
@@ -0,0 +1,330 @@
+---
+id: 587d7b8f367417b2b2512b61
+title: 使用 map 方法從數組中提取數據
+challengeType: 1
+forumTopicId: 18214
+dashedName: use-the-map-method-to-extract-data-from-an-array
+---
+
+# --description--
+
+目前爲止，我們已經學會了使用純函數來避免程序中的副作用。 此外，我們已經看到函數的值僅取決於其輸入參數。
+
+這僅僅是個開始。 顧名思義，函數式編程以函數理論爲中心。
+
+能夠將它們作爲參數傳遞給其他函數，從另一個函數返回一個函數是有意義的。 函數在 JavaScript 中被視爲 First Class Objects ，它們可以像任何其他對象一樣使用。 它們可以保存在變量中，存儲在對象中，也可以作爲函數參數傳遞。
+
+讓我們從一些簡單的數組函數開始，這些函數是數組對象原型上的方法。 在本練習中，我們來了解下數組的 `map` 方法（即 `Array.prototype.map()`）。
+
+請記住，`map`方法是迭代數組中每一項的方式之一。 在對每個元素應用回調函數後，它會創建一個新數組(不改變原來的數組)。 它這樣做時沒有改變原始數組。
+
+當調用回調函數時，傳入了三個參數。 第一個參數是當前正在處理的數組項。 第二個參數是當前數組項的索引值，第三個參數是在其上調用 `map` 方法的數組。
+
+看下在 `users` 上使用 `map` 方法的例子，返回了一個新數組只包含了用戶的名字。 爲了簡化，例子裏只使用了回調函數的第一個參數。
+
+```js
+const users = [
+ { name: 'John', age: 34 },
+ { name: 'Amy', age: 20 },
+ { name: 'camperCat', age: 10 }
+];
+
+const names = users.map(user => user.name);
+console.log(names);
+```
+
+控制檯將顯示值 `[ 'John', 'Amy', 'camperCat' ]`。
+
+# --instructions--
+
+`watchList` 數組保存了包含一些電影信息的對象。 使用 `map` 從 `watchList` 中提取標題（`title`）和評分（`rating`），並將新數組保存在 `ratings` 變量裏。 目前編輯器中的代碼是使用 `for` 循環實現，使用 `map` 表達式替換循環功能。
+
+# --hints--
+
+`watchList` 應保持不變。
+
+```js
+assert(
+ watchList[0].Title === 'Inception' && watchList[4].Director == 'James Cameron'
+);
+```
+
+不能使用 `for` 循環。
+
+```js
+assert(!code.match(/for\s*?\([\s\S]*?\)/));
+```
+
+你的代碼應使用 `map` 方法。
+
+```js
+assert(code.match(/\.map/g));
+```
+
+`ratings` 應等於 `[{"title":"Inception","rating":"8.8"},{"title":"Interstellar","rating":"8.6"},{"title":"The Dark Knight","rating":"9.0"},{"title":"Batman Begins","rating":"8.3"},{"title":"Avatar","rating":"7.9"}]`。
+
+```js
+assert.deepEqual(ratings, [
+ { title: 'Inception', rating: '8.8' },
+ { title: 'Interstellar', rating: '8.6' },
+ { title: 'The Dark Knight', rating: '9.0' },
+ { title: 'Batman Begins', rating: '8.3' },
+ { title: 'Avatar', rating: '7.9' }
+]);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// The global variable
+var watchList = [
+ {
+ "Title": "Inception",
+ "Year": "2010",
+ "Rated": "PG-13",
+ "Released": "16 Jul 2010",
+ "Runtime": "148 min",
+ "Genre": "Action, Adventure, Crime",
+ "Director": "Christopher Nolan",
+ "Writer": "Christopher Nolan",
+ "Actors": "Leonardo DiCaprio, Joseph Gordon-Levitt, Elliot Page, Tom Hardy",
+ "Plot": "A thief, who steals corporate secrets through use of dream-sharing technology, is given the inverse task of planting an idea into the mind of a CEO.",
+ "Language": "English, Japanese, French",
+ "Country": "USA, UK",
+ "Awards": "Won 4 Oscars. Another 143 wins & 198 nominations.",
+ "Poster": "http://ia.media-imdb.com/images/M/MV5BMjAxMzY3NjcxNF5BMl5BanBnXkFtZTcwNTI5OTM0Mw@@._V1_SX300.jpg",
+ "Metascore": "74",
+ "imdbRating": "8.8",
+ "imdbVotes": "1,446,708",
+ "imdbID": "tt1375666",
+ "Type": "movie",
+ "Response": "True"
+ },
+ {
+ "Title": "Interstellar",
+ "Year": "2014",
+ "Rated": "PG-13",
+ "Released": "07 Nov 2014",
+ "Runtime": "169 min",
+ "Genre": "Adventure, Drama, Sci-Fi",
+ "Director": "Christopher Nolan",
+ "Writer": "Jonathan Nolan, Christopher Nolan",
+ "Actors": "Ellen Burstyn, Matthew McConaughey, Mackenzie Foy, John Lithgow",
+ "Plot": "A team of explorers travel through a wormhole in space in an attempt to ensure humanity's survival.",
+ "Language": "English",
+ "Country": "USA, UK",
+ "Awards": "Won 1 Oscar. Another 39 wins & 132 nominations.",
+ "Poster": "http://ia.media-imdb.com/images/M/MV5BMjIxNTU4MzY4MF5BMl5BanBnXkFtZTgwMzM4ODI3MjE@._V1_SX300.jpg",
+ "Metascore": "74",
+ "imdbRating": "8.6",
+ "imdbVotes": "910,366",
+ "imdbID": "tt0816692",
+ "Type": "movie",
+ "Response": "True"
+ },
+ {
+ "Title": "The Dark Knight",
+ "Year": "2008",
+ "Rated": "PG-13",
+ "Released": "18 Jul 2008",
+ "Runtime": "152 min",
+ "Genre": "Action, Adventure, Crime",
+ "Director": "Christopher Nolan",
+ "Writer": "Jonathan Nolan (screenplay), Christopher Nolan (screenplay), Christopher Nolan (story), David S. Goyer (story), Bob Kane (characters)",
+ "Actors": "Christian Bale, Heath Ledger, Aaron Eckhart, Michael Caine",
+ "Plot": "When the menace known as the Joker wreaks havoc and chaos on the people of Gotham, the caped crusader must come to terms with one of the greatest psychological tests of his ability to fight injustice.",
+ "Language": "English, Mandarin",
+ "Country": "USA, UK",
+ "Awards": "Won 2 Oscars. Another 146 wins & 142 nominations.",
+ "Poster": "http://ia.media-imdb.com/images/M/MV5BMTMxNTMwODM0NF5BMl5BanBnXkFtZTcwODAyMTk2Mw@@._V1_SX300.jpg",
+ "Metascore": "82",
+ "imdbRating": "9.0",
+ "imdbVotes": "1,652,832",
+ "imdbID": "tt0468569",
+ "Type": "movie",
+ "Response": "True"
+ },
+ {
+ "Title": "Batman Begins",
+ "Year": "2005",
+ "Rated": "PG-13",
+ "Released": "15 Jun 2005",
+ "Runtime": "140 min",
+ "Genre": "Action, Adventure",
+ "Director": "Christopher Nolan",
+ "Writer": "Bob Kane (characters), David S. Goyer (story), Christopher Nolan (screenplay), David S. Goyer (screenplay)",
+ "Actors": "Christian Bale, Michael Caine, Liam Neeson, Katie Holmes",
+ "Plot": "After training with his mentor, Batman begins his fight to free crime-ridden Gotham City from the corruption that Scarecrow and the League of Shadows have cast upon it.",
+ "Language": "English, Urdu, Mandarin",
+ "Country": "USA, UK",
+ "Awards": "Nominated for 1 Oscar. Another 15 wins & 66 nominations.",
+ "Poster": "http://ia.media-imdb.com/images/M/MV5BNTM3OTc0MzM2OV5BMl5BanBnXkFtZTYwNzUwMTI3._V1_SX300.jpg",
+ "Metascore": "70",
+ "imdbRating": "8.3",
+ "imdbVotes": "972,584",
+ "imdbID": "tt0372784",
+ "Type": "movie",
+ "Response": "True"
+ },
+ {
+ "Title": "Avatar",
+ "Year": "2009",
+ "Rated": "PG-13",
+ "Released": "18 Dec 2009",
+ "Runtime": "162 min",
+ "Genre": "Action, Adventure, Fantasy",
+ "Director": "James Cameron",
+ "Writer": "James Cameron",
+ "Actors": "Sam Worthington, Zoe Saldana, Sigourney Weaver, Stephen Lang",
+ "Plot": "A paraplegic marine dispatched to the moon Pandora on a unique mission becomes torn between following his orders and protecting the world he feels is his home.",
+ "Language": "English, Spanish",
+ "Country": "USA, UK",
+ "Awards": "Won 3 Oscars. Another 80 wins & 121 nominations.",
+ "Poster": "http://ia.media-imdb.com/images/M/MV5BMTYwOTEwNjAzMl5BMl5BanBnXkFtZTcwODc5MTUwMw@@._V1_SX300.jpg",
+ "Metascore": "83",
+ "imdbRating": "7.9",
+ "imdbVotes": "876,575",
+ "imdbID": "tt0499549",
+ "Type": "movie",
+ "Response": "True"
+ }
+];
+
+// Only change code below this line
+
+var ratings = [];
+for(var i=0; i < watchList.length; i++){
+ ratings.push({title: watchList[i]["Title"], rating: watchList[i]["imdbRating"]});
+}
+
+// Only change code above this line
+
+console.log(JSON.stringify(ratings));
+```
+
+# --solutions--
+
+```js
+// The global variable
+var watchList = [
+ {
+ "Title": "Inception",
+ "Year": "2010",
+ "Rated": "PG-13",
+ "Released": "16 Jul 2010",
+ "Runtime": "148 min",
+ "Genre": "Action, Adventure, Crime",
+ "Director": "Christopher Nolan",
+ "Writer": "Christopher Nolan",
+ "Actors": "Leonardo DiCaprio, Joseph Gordon-Levitt, Elliot Page, Tom Hardy",
+ "Plot": "A thief, who steals corporate secrets through use of dream-sharing technology, is given the inverse task of planting an idea into the mind of a CEO.",
+ "Language": "English, Japanese, French",
+ "Country": "USA, UK",
+ "Awards": "Won 4 Oscars. Another 143 wins & 198 nominations.",
+ "Poster": "http://ia.media-imdb.com/images/M/MV5BMjAxMzY3NjcxNF5BMl5BanBnXkFtZTcwNTI5OTM0Mw@@._V1_SX300.jpg",
+ "Metascore": "74",
+ "imdbRating": "8.8",
+ "imdbVotes": "1,446,708",
+ "imdbID": "tt1375666",
+ "Type": "movie",
+ "Response": "True"
+ },
+ {
+ "Title": "Interstellar",
+ "Year": "2014",
+ "Rated": "PG-13",
+ "Released": "07 Nov 2014",
+ "Runtime": "169 min",
+ "Genre": "Adventure, Drama, Sci-Fi",
+ "Director": "Christopher Nolan",
+ "Writer": "Jonathan Nolan, Christopher Nolan",
+ "Actors": "Ellen Burstyn, Matthew McConaughey, Mackenzie Foy, John Lithgow",
+ "Plot": "A team of explorers travel through a wormhole in space in an attempt to ensure humanity's survival.",
+ "Language": "English",
+ "Country": "USA, UK",
+ "Awards": "Won 1 Oscar. Another 39 wins & 132 nominations.",
+ "Poster": "http://ia.media-imdb.com/images/M/MV5BMjIxNTU4MzY4MF5BMl5BanBnXkFtZTgwMzM4ODI3MjE@._V1_SX300.jpg",
+ "Metascore": "74",
+ "imdbRating": "8.6",
+ "imdbVotes": "910,366",
+ "imdbID": "tt0816692",
+ "Type": "movie",
+ "Response": "True"
+ },
+ {
+ "Title": "The Dark Knight",
+ "Year": "2008",
+ "Rated": "PG-13",
+ "Released": "18 Jul 2008",
+ "Runtime": "152 min",
+ "Genre": "Action, Adventure, Crime",
+ "Director": "Christopher Nolan",
+ "Writer": "Jonathan Nolan (screenplay), Christopher Nolan (screenplay), Christopher Nolan (story), David S. Goyer (story), Bob Kane (characters)",
+ "Actors": "Christian Bale, Heath Ledger, Aaron Eckhart, Michael Caine",
+ "Plot": "When the menace known as the Joker wreaks havoc and chaos on the people of Gotham, the caped crusader must come to terms with one of the greatest psychological tests of his ability to fight injustice.",
+ "Language": "English, Mandarin",
+ "Country": "USA, UK",
+ "Awards": "Won 2 Oscars. Another 146 wins & 142 nominations.",
+ "Poster": "http://ia.media-imdb.com/images/M/MV5BMTMxNTMwODM0NF5BMl5BanBnXkFtZTcwODAyMTk2Mw@@._V1_SX300.jpg",
+ "Metascore": "82",
+ "imdbRating": "9.0",
+ "imdbVotes": "1,652,832",
+ "imdbID": "tt0468569",
+ "Type": "movie",
+ "Response": "True"
+ },
+ {
+ "Title": "Batman Begins",
+ "Year": "2005",
+ "Rated": "PG-13",
+ "Released": "15 Jun 2005",
+ "Runtime": "140 min",
+ "Genre": "Action, Adventure",
+ "Director": "Christopher Nolan",
+ "Writer": "Bob Kane (characters), David S. Goyer (story), Christopher Nolan (screenplay), David S. Goyer (screenplay)",
+ "Actors": "Christian Bale, Michael Caine, Liam Neeson, Katie Holmes",
+ "Plot": "After training with his mentor, Batman begins his fight to free crime-ridden Gotham City from the corruption that Scarecrow and the League of Shadows have cast upon it.",
+ "Language": "English, Urdu, Mandarin",
+ "Country": "USA, UK",
+ "Awards": "Nominated for 1 Oscar. Another 15 wins & 66 nominations.",
+ "Poster": "http://ia.media-imdb.com/images/M/MV5BNTM3OTc0MzM2OV5BMl5BanBnXkFtZTYwNzUwMTI3._V1_SX300.jpg",
+ "Metascore": "70",
+ "imdbRating": "8.3",
+ "imdbVotes": "972,584",
+ "imdbID": "tt0372784",
+ "Type": "movie",
+ "Response": "True"
+ },
+ {
+ "Title": "Avatar",
+ "Year": "2009",
+ "Rated": "PG-13",
+ "Released": "18 Dec 2009",
+ "Runtime": "162 min",
+ "Genre": "Action, Adventure, Fantasy",
+ "Director": "James Cameron",
+ "Writer": "James Cameron",
+ "Actors": "Sam Worthington, Zoe Saldana, Sigourney Weaver, Stephen Lang",
+ "Plot": "A paraplegic marine dispatched to the moon Pandora on a unique mission becomes torn between following his orders and protecting the world he feels is his home.",
+ "Language": "English, Spanish",
+ "Country": "USA, UK",
+ "Awards": "Won 3 Oscars. Another 80 wins & 121 nominations.",
+ "Poster": "http://ia.media-imdb.com/images/M/MV5BMTYwOTEwNjAzMl5BMl5BanBnXkFtZTcwODc5MTUwMw@@._V1_SX300.jpg",
+ "Metascore": "83",
+ "imdbRating": "7.9",
+ "imdbVotes": "876,575",
+ "imdbID": "tt0499549",
+ "Type": "movie",
+ "Response": "True"
+ }
+];
+
+var ratings = watchList.map(function(movie) {
+ return {
+ title: movie["Title"],
+ rating: movie["imdbRating"]
+ }
+});
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/use-the-reduce-method-to-analyze-data.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/use-the-reduce-method-to-analyze-data.md
new file mode 100644
index 0000000000..eda4082cfb
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/use-the-reduce-method-to-analyze-data.md
@@ -0,0 +1,345 @@
+---
+id: 587d7da9367417b2b2512b68
+title: 使用 reduce 方法分析數據
+challengeType: 1
+forumTopicId: 301313
+dashedName: use-the-reduce-method-to-analyze-data
+---
+
+# --description--
+
+`reduce()`（即`Array.prototype.reduce()`），是 JavaScript 所有數組操作中最常用的方法。 幾乎可以用`reduce`方法解決所有數組處理問題。
+
+`reduce`方法是處理數組更通用的方式，而且`filter`和`map`方法都可以當作是`reduce`的特殊實現。 `reduce`方法遍歷數組中的每個項目並返回單個值（即字符串、數字、對象、數組）。 這是通過在每次迭代中調用一個回調函數來實現的。
+
+回調函數接受四個參數。 第一個參數稱爲疊加器，它是上一次迭代中回調函數的返回值，第二個參數是當前正在處理的數組元素，第三個參數是該參數的索引，第四個參數是在其上調用 `reduce` 方法的數組。
+
+除了回調函數，`reduce` 還有一個額外的參數做爲疊加器的初始值。 如果沒有第二個參數，會跳過第一次迭代，第二次迭代給疊加器傳入數組的第一個元素。
+
+見下面的例子，給 `users` 數組使用 `reduce` 方法，返回所有用戶數組的和。 爲了簡化，例子僅使用了回調函數的第一個參數和第二個參數。
+
+```js
+const users = [
+ { name: 'John', age: 34 },
+ { name: 'Amy', age: 20 },
+ { name: 'camperCat', age: 10 }
+];
+
+const sumOfAges = users.reduce((sum, user) => sum + user.age, 0);
+console.log(sumOfAges);
+```
+
+這裏控制檯將顯示值 `64`。
+
+在另一個例子裏，查看如何返回一個包含用戶名稱做爲屬性，其年齡做爲值的對象。
+
+```js
+const users = [
+ { name: 'John', age: 34 },
+ { name: 'Amy', age: 20 },
+ { name: 'camperCat', age: 10 }
+];
+
+const usersObj = users.reduce((obj, user) => {
+ obj[user.name] = user.age;
+ return obj;
+}, {});
+console.log(usersObj);
+```
+
+控制檯將顯示值 `{ John: 34, Amy: 20, camperCat: 10 }`。
+
+# --instructions--
+
+`watchList` 是包含一些電影信息的對象。 使用 `reduce` 查找由 `Christopher Nolan` 導演的電影的 IMDB 評級平均值。 回想一下之前的挑戰，如何 `filter` 數據，以及使用 `map` 來獲取你想要的數據。 您可能需要創建其他變量，並從 `getRating` 函數返回平均評分。 請注意，評級在對象中是字符串，需要將其轉換爲數字再用於數學運算。
+
+# --hints--
+
+`watchList` 應保持不變。
+
+```js
+assert(
+ watchList[0].Title === 'Inception' && watchList[4].Director == 'James Cameron'
+);
+```
+
+應該使用`reduce`方法。
+
+```js
+assert(code.match(/\.reduce/g));
+```
+
+`getRating(watchList)` 應該等於 8.675。
+
+```js
+assert(getRating(watchList) === 8.675);
+```
+
+不能使用 `for` 循環。
+
+```js
+assert(!code.match(/for\s*?\([\s\S]*?\)/g));
+```
+
+在修改 `watchList` 對象後應該返回正確的輸出。
+
+```js
+assert(getRating(watchList.filter((_, i) => i < 1 || i > 2)) === 8.55);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// The global variable
+var watchList = [
+ {
+ "Title": "Inception",
+ "Year": "2010",
+ "Rated": "PG-13",
+ "Released": "16 Jul 2010",
+ "Runtime": "148 min",
+ "Genre": "Action, Adventure, Crime",
+ "Director": "Christopher Nolan",
+ "Writer": "Christopher Nolan",
+ "Actors": "Leonardo DiCaprio, Joseph Gordon-Levitt, Elliot Page, Tom Hardy",
+ "Plot": "A thief, who steals corporate secrets through use of dream-sharing technology, is given the inverse task of planting an idea into the mind of a CEO.",
+ "Language": "English, Japanese, French",
+ "Country": "USA, UK",
+ "Awards": "Won 4 Oscars. Another 143 wins & 198 nominations.",
+ "Poster": "http://ia.media-imdb.com/images/M/MV5BMjAxMzY3NjcxNF5BMl5BanBnXkFtZTcwNTI5OTM0Mw@@._V1_SX300.jpg",
+ "Metascore": "74",
+ "imdbRating": "8.8",
+ "imdbVotes": "1,446,708",
+ "imdbID": "tt1375666",
+ "Type": "movie",
+ "Response": "True"
+ },
+ {
+ "Title": "Interstellar",
+ "Year": "2014",
+ "Rated": "PG-13",
+ "Released": "07 Nov 2014",
+ "Runtime": "169 min",
+ "Genre": "Adventure, Drama, Sci-Fi",
+ "Director": "Christopher Nolan",
+ "Writer": "Jonathan Nolan, Christopher Nolan",
+ "Actors": "Ellen Burstyn, Matthew McConaughey, Mackenzie Foy, John Lithgow",
+ "Plot": "A team of explorers travel through a wormhole in space in an attempt to ensure humanity's survival.",
+ "Language": "English",
+ "Country": "USA, UK",
+ "Awards": "Won 1 Oscar. Another 39 wins & 132 nominations.",
+ "Poster": "http://ia.media-imdb.com/images/M/MV5BMjIxNTU4MzY4MF5BMl5BanBnXkFtZTgwMzM4ODI3MjE@._V1_SX300.jpg",
+ "Metascore": "74",
+ "imdbRating": "8.6",
+ "imdbVotes": "910,366",
+ "imdbID": "tt0816692",
+ "Type": "movie",
+ "Response": "True"
+ },
+ {
+ "Title": "The Dark Knight",
+ "Year": "2008",
+ "Rated": "PG-13",
+ "Released": "18 Jul 2008",
+ "Runtime": "152 min",
+ "Genre": "Action, Adventure, Crime",
+ "Director": "Christopher Nolan",
+ "Writer": "Jonathan Nolan (screenplay), Christopher Nolan (screenplay), Christopher Nolan (story), David S. Goyer (story), Bob Kane (characters)",
+ "Actors": "Christian Bale, Heath Ledger, Aaron Eckhart, Michael Caine",
+ "Plot": "When the menace known as the Joker wreaks havoc and chaos on the people of Gotham, the caped crusader must come to terms with one of the greatest psychological tests of his ability to fight injustice.",
+ "Language": "English, Mandarin",
+ "Country": "USA, UK",
+ "Awards": "Won 2 Oscars. Another 146 wins & 142 nominations.",
+ "Poster": "http://ia.media-imdb.com/images/M/MV5BMTMxNTMwODM0NF5BMl5BanBnXkFtZTcwODAyMTk2Mw@@._V1_SX300.jpg",
+ "Metascore": "82",
+ "imdbRating": "9.0",
+ "imdbVotes": "1,652,832",
+ "imdbID": "tt0468569",
+ "Type": "movie",
+ "Response": "True"
+ },
+ {
+ "Title": "Batman Begins",
+ "Year": "2005",
+ "Rated": "PG-13",
+ "Released": "15 Jun 2005",
+ "Runtime": "140 min",
+ "Genre": "Action, Adventure",
+ "Director": "Christopher Nolan",
+ "Writer": "Bob Kane (characters), David S. Goyer (story), Christopher Nolan (screenplay), David S. Goyer (screenplay)",
+ "Actors": "Christian Bale, Michael Caine, Liam Neeson, Katie Holmes",
+ "Plot": "After training with his mentor, Batman begins his fight to free crime-ridden Gotham City from the corruption that Scarecrow and the League of Shadows have cast upon it.",
+ "Language": "English, Urdu, Mandarin",
+ "Country": "USA, UK",
+ "Awards": "Nominated for 1 Oscar. Another 15 wins & 66 nominations.",
+ "Poster": "http://ia.media-imdb.com/images/M/MV5BNTM3OTc0MzM2OV5BMl5BanBnXkFtZTYwNzUwMTI3._V1_SX300.jpg",
+ "Metascore": "70",
+ "imdbRating": "8.3",
+ "imdbVotes": "972,584",
+ "imdbID": "tt0372784",
+ "Type": "movie",
+ "Response": "True"
+ },
+ {
+ "Title": "Avatar",
+ "Year": "2009",
+ "Rated": "PG-13",
+ "Released": "18 Dec 2009",
+ "Runtime": "162 min",
+ "Genre": "Action, Adventure, Fantasy",
+ "Director": "James Cameron",
+ "Writer": "James Cameron",
+ "Actors": "Sam Worthington, Zoe Saldana, Sigourney Weaver, Stephen Lang",
+ "Plot": "A paraplegic marine dispatched to the moon Pandora on a unique mission becomes torn between following his orders and protecting the world he feels is his home.",
+ "Language": "English, Spanish",
+ "Country": "USA, UK",
+ "Awards": "Won 3 Oscars. Another 80 wins & 121 nominations.",
+ "Poster": "http://ia.media-imdb.com/images/M/MV5BMTYwOTEwNjAzMl5BMl5BanBnXkFtZTcwODc5MTUwMw@@._V1_SX300.jpg",
+ "Metascore": "83",
+ "imdbRating": "7.9",
+ "imdbVotes": "876,575",
+ "imdbID": "tt0499549",
+ "Type": "movie",
+ "Response": "True"
+ }
+];
+
+function getRating(watchList){
+ // Only change code below this line
+ var averageRating;
+
+
+ // Only change code above this line
+ return averageRating;
+}
+console.log(getRating(watchList));
+```
+
+# --solutions--
+
+```js
+// The global variable
+var watchList = [
+ {
+ "Title": "Inception",
+ "Year": "2010",
+ "Rated": "PG-13",
+ "Released": "16 Jul 2010",
+ "Runtime": "148 min",
+ "Genre": "Action, Adventure, Crime",
+ "Director": "Christopher Nolan",
+ "Writer": "Christopher Nolan",
+ "Actors": "Leonardo DiCaprio, Joseph Gordon-Levitt, Elliot Page, Tom Hardy",
+ "Plot": "A thief, who steals corporate secrets through use of dream-sharing technology, is given the inverse task of planting an idea into the mind of a CEO.",
+ "Language": "English, Japanese, French",
+ "Country": "USA, UK",
+ "Awards": "Won 4 Oscars. Another 143 wins & 198 nominations.",
+ "Poster": "http://ia.media-imdb.com/images/M/MV5BMjAxMzY3NjcxNF5BMl5BanBnXkFtZTcwNTI5OTM0Mw@@._V1_SX300.jpg",
+ "Metascore": "74",
+ "imdbRating": "8.8",
+ "imdbVotes": "1,446,708",
+ "imdbID": "tt1375666",
+ "Type": "movie",
+ "Response": "True"
+ },
+ {
+ "Title": "Interstellar",
+ "Year": "2014",
+ "Rated": "PG-13",
+ "Released": "07 Nov 2014",
+ "Runtime": "169 min",
+ "Genre": "Adventure, Drama, Sci-Fi",
+ "Director": "Christopher Nolan",
+ "Writer": "Jonathan Nolan, Christopher Nolan",
+ "Actors": "Ellen Burstyn, Matthew McConaughey, Mackenzie Foy, John Lithgow",
+ "Plot": "A team of explorers travel through a wormhole in space in an attempt to ensure humanity's survival.",
+ "Language": "English",
+ "Country": "USA, UK",
+ "Awards": "Won 1 Oscar. Another 39 wins & 132 nominations.",
+ "Poster": "http://ia.media-imdb.com/images/M/MV5BMjIxNTU4MzY4MF5BMl5BanBnXkFtZTgwMzM4ODI3MjE@._V1_SX300.jpg",
+ "Metascore": "74",
+ "imdbRating": "8.6",
+ "imdbVotes": "910,366",
+ "imdbID": "tt0816692",
+ "Type": "movie",
+ "Response": "True"
+ },
+ {
+ "Title": "The Dark Knight",
+ "Year": "2008",
+ "Rated": "PG-13",
+ "Released": "18 Jul 2008",
+ "Runtime": "152 min",
+ "Genre": "Action, Adventure, Crime",
+ "Director": "Christopher Nolan",
+ "Writer": "Jonathan Nolan (screenplay), Christopher Nolan (screenplay), Christopher Nolan (story), David S. Goyer (story), Bob Kane (characters)",
+ "Actors": "Christian Bale, Heath Ledger, Aaron Eckhart, Michael Caine",
+ "Plot": "When the menace known as the Joker wreaks havoc and chaos on the people of Gotham, the caped crusader must come to terms with one of the greatest psychological tests of his ability to fight injustice.",
+ "Language": "English, Mandarin",
+ "Country": "USA, UK",
+ "Awards": "Won 2 Oscars. Another 146 wins & 142 nominations.",
+ "Poster": "http://ia.media-imdb.com/images/M/MV5BMTMxNTMwODM0NF5BMl5BanBnXkFtZTcwODAyMTk2Mw@@._V1_SX300.jpg",
+ "Metascore": "82",
+ "imdbRating": "9.0",
+ "imdbVotes": "1,652,832",
+ "imdbID": "tt0468569",
+ "Type": "movie",
+ "Response": "True"
+ },
+ {
+ "Title": "Batman Begins",
+ "Year": "2005",
+ "Rated": "PG-13",
+ "Released": "15 Jun 2005",
+ "Runtime": "140 min",
+ "Genre": "Action, Adventure",
+ "Director": "Christopher Nolan",
+ "Writer": "Bob Kane (characters), David S. Goyer (story), Christopher Nolan (screenplay), David S. Goyer (screenplay)",
+ "Actors": "Christian Bale, Michael Caine, Liam Neeson, Katie Holmes",
+ "Plot": "After training with his mentor, Batman begins his fight to free crime-ridden Gotham City from the corruption that Scarecrow and the League of Shadows have cast upon it.",
+ "Language": "English, Urdu, Mandarin",
+ "Country": "USA, UK",
+ "Awards": "Nominated for 1 Oscar. Another 15 wins & 66 nominations.",
+ "Poster": "http://ia.media-imdb.com/images/M/MV5BNTM3OTc0MzM2OV5BMl5BanBnXkFtZTYwNzUwMTI3._V1_SX300.jpg",
+ "Metascore": "70",
+ "imdbRating": "8.3",
+ "imdbVotes": "972,584",
+ "imdbID": "tt0372784",
+ "Type": "movie",
+ "Response": "True"
+ },
+ {
+ "Title": "Avatar",
+ "Year": "2009",
+ "Rated": "PG-13",
+ "Released": "18 Dec 2009",
+ "Runtime": "162 min",
+ "Genre": "Action, Adventure, Fantasy",
+ "Director": "James Cameron",
+ "Writer": "James Cameron",
+ "Actors": "Sam Worthington, Zoe Saldana, Sigourney Weaver, Stephen Lang",
+ "Plot": "A paraplegic marine dispatched to the moon Pandora on a unique mission becomes torn between following his orders and protecting the world he feels is his home.",
+ "Language": "English, Spanish",
+ "Country": "USA, UK",
+ "Awards": "Won 3 Oscars. Another 80 wins & 121 nominations.",
+ "Poster": "http://ia.media-imdb.com/images/M/MV5BMTYwOTEwNjAzMl5BMl5BanBnXkFtZTcwODc5MTUwMw@@._V1_SX300.jpg",
+ "Metascore": "83",
+ "imdbRating": "7.9",
+ "imdbVotes": "876,575",
+ "imdbID": "tt0499549",
+ "Type": "movie",
+ "Response": "True"
+ }
+];
+
+function getRating(watchList){
+ var averageRating;
+ const rating = watchList
+ .filter(obj => obj.Director === "Christopher Nolan")
+ .map(obj => Number(obj.imdbRating));
+ averageRating = rating.reduce((accum, curr) => accum + curr)/rating.length;
+ return averageRating;
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/use-the-some-method-to-check-that-any-elements-in-an-array-meet-a-criteria.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/use-the-some-method-to-check-that-any-elements-in-an-array-meet-a-criteria.md
new file mode 100644
index 0000000000..47ab582cfb
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/functional-programming/use-the-some-method-to-check-that-any-elements-in-an-array-meet-a-criteria.md
@@ -0,0 +1,77 @@
+---
+id: 587d7dab367417b2b2512b6f
+title: 使用 some 方法檢查數組中是否有元素是否符合條件
+challengeType: 1
+forumTopicId: 301314
+dashedName: use-the-some-method-to-check-that-any-elements-in-an-array-meet-a-criteria
+---
+
+# --description--
+
+`some` 方法用於檢測數組中*任何*元素是否滿足指定條件。 如果有一個元素滿足條件，返回布爾值 `true`，反之返回 `false`。
+
+舉個例子，下面的代碼檢測數組`numbers`中是否有元素小於 10：
+
+```js
+var numbers = [10, 50, 8, 220, 110, 11];
+numbers.some(function(currentValue) {
+ return currentValue < 10;
+});
+```
+
+`some` 方法將返回 `true`。
+
+# --instructions--
+
+在 `checkPositive` 函數值中使用 `some` 檢查 `arr` 中是否有元素爲正數。 函數應返回一個布爾值。
+
+# --hints--
+
+應該使用 `some` 方法。
+
+```js
+assert(code.match(/\.some/g));
+```
+
+`checkPositive([1, 2, 3, -4, 5])` 應返回 `true`。
+
+```js
+assert(checkPositive([1, 2, 3, -4, 5]));
+```
+
+`checkPositive([1, 2, 3, 4, 5])` 應返回 `true`。
+
+```js
+assert(checkPositive([1, 2, 3, 4, 5]));
+```
+
+`checkPositive([-1, -2, -3, -4, -5])` 應返回 `false`。
+
+```js
+assert(!checkPositive([-1, -2, -3, -4, -5]));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function checkPositive(arr) {
+ // Only change code below this line
+
+
+ // Only change code above this line
+}
+checkPositive([1, 2, 3, -4, 5]);
+```
+
+# --solutions--
+
+```js
+function checkPositive(arr) {
+ // Only change code below this line
+ return arr.some(elem => elem > 0);
+ // Only change code above this line
+}
+checkPositive([1, 2, 3, -4, 5]);
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/arguments-optional.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/arguments-optional.md
new file mode 100644
index 0000000000..3f6562b0e2
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/arguments-optional.md
@@ -0,0 +1,91 @@
+---
+id: a97fd23d9b809dac9921074f
+title: 可選參數
+challengeType: 5
+forumTopicId: 14271
+dashedName: arguments-optional
+---
+
+# --description--
+
+創建一個將兩個參數相加的函數。 如果只提供了一個參數，則返回一個需要一個參數並返回總和的函數。
+
+比如，`addTogether(2, 3)` 應該返回 `5`。 而 `addTogether(2)` 應該返回一個函數。
+
+調用這個返回的函數，爲它傳入一個值，會返回兩個值的總和：
+
+```js
+var sumTwoAnd = addTogether(2);
+```
+
+`sumTwoAnd(3)` 應返回 `5`。
+
+如果任一參數不是有效數字，則返回 undefined。
+
+# --hints--
+
+`addTogether(2, 3)` 應返回 5。
+
+```js
+assert.deepEqual(addTogether(2, 3), 5);
+```
+
+`addTogether(23, 30)` 應返回 53。
+
+```js
+assert.deepEqual(addTogether(23, 30), 53);
+```
+
+`addTogether(5)(7)` 應返回 12。
+
+```js
+assert.deepEqual(addTogether(5)(7), 12);
+```
+
+`addTogether("http://bit.ly/IqT6zt")` 應返回 `undefined`。
+
+```js
+assert.isUndefined(addTogether('http://bit.ly/IqT6zt'));
+```
+
+`addTogether(2, "3")` 應返回 `undefined`。
+
+```js
+assert.isUndefined(addTogether(2, '3'));
+```
+
+`addTogether(2)([3])` 應返回 `undefined`。
+
+```js
+assert.isUndefined(addTogether(2)([3]));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function addTogether() {
+ return false;
+}
+
+addTogether(2,3);
+```
+
+# --solutions--
+
+```js
+function addTogether() {
+ var a = arguments[0];
+ if (toString.call(a) !== '[object Number]') return;
+ if (arguments.length === 1) {
+ return function(b) {
+ if (toString.call(b) !== '[object Number]') return;
+ return a + b;
+ };
+ }
+ var b = arguments[1];
+ if (toString.call(b) !== '[object Number]') return;
+ return a + arguments[1];
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/binary-agents.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/binary-agents.md
new file mode 100644
index 0000000000..ee3434c414
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/binary-agents.md
@@ -0,0 +1,57 @@
+---
+id: a8d97bd4c764e91f9d2bda01
+title: 翻譯二進制字符串
+challengeType: 5
+forumTopicId: 14273
+dashedName: binary-agents
+---
+
+# --description--
+
+請實現一個函數，把傳入的二進制字符串轉換成英文句子。
+
+二進制字符串會以空格分隔。
+
+# --hints--
+
+`binaryAgent("01000001 01110010 01100101 01101110 00100111 01110100 00100000 01100010 01101111 01101110 01100110 01101001 01110010 01100101 01110011 00100000 01100110 01110101 01101110 00100001 00111111")` 應返回 `Aren't bonfires fun!?`。
+
+```js
+assert.deepEqual(
+ binaryAgent(
+ '01000001 01110010 01100101 01101110 00100111 01110100 00100000 01100010 01101111 01101110 01100110 01101001 01110010 01100101 01110011 00100000 01100110 01110101 01101110 00100001 00111111'
+ ),
+ "Aren't bonfires fun!?"
+);
+```
+
+`binaryAgent("01001001 00100000 01101100 01101111 01110110 01100101 00100000 01000110 01110010 01100101 01100101 01000011 01101111 01100100 01100101 01000011 01100001 01101101 01110000 00100001")` 應返回 `I love FreeCodeCamp!`。
+
+```js
+assert.deepEqual(
+ binaryAgent(
+ '01001001 00100000 01101100 01101111 01110110 01100101 00100000 01000110 01110010 01100101 01100101 01000011 01101111 01100100 01100101 01000011 01100001 01101101 01110000 00100001'
+ ),
+ 'I love FreeCodeCamp!'
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function binaryAgent(str) {
+ return str;
+}
+
+binaryAgent("01000001 01110010 01100101 01101110 00100111 01110100 00100000 01100010 01101111 01101110 01100110 01101001 01110010 01100101 01110011 00100000 01100110 01110101 01101110 00100001 00111111");
+```
+
+# --solutions--
+
+```js
+function binaryAgent(str) {
+ return str.split(' ').map(function(s) { return parseInt(s, 2); }).map(function(b) { return String.fromCharCode(b);}).join('');
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/convert-html-entities.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/convert-html-entities.md
new file mode 100644
index 0000000000..832705447c
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/convert-html-entities.md
@@ -0,0 +1,89 @@
+---
+id: a6b0bb188d873cb2c8729495
+title: 轉換 HTML 字符實體
+challengeType: 5
+forumTopicId: 16007
+dashedName: convert-html-entities
+---
+
+# --description--
+
+請將字符串中的 `&`、`<`、`>`、`"`（雙引號）和 `'`（單引號）轉換爲相應的 HTML 字符實體。
+
+# --hints--
+
+`convertHTML("Dolce & Gabbana")` 應返回 `Dolce & Gabbana`。
+
+```js
+assert.match(convertHTML('Dolce & Gabbana'), /Dolce & Gabbana/);
+```
+
+`convertHTML("Hamburgers < Pizza < Tacos")` 應返回 `Hamburgers < Pizza < Tacos`。
+
+```js
+assert.match(
+ convertHTML('Hamburgers < Pizza < Tacos'),
+ /Hamburgers < Pizza < Tacos/
+);
+```
+
+`convertHTML("Sixty > twelve")` 應返回 `Sixty > twelve`。
+
+```js
+assert.match(convertHTML('Sixty > twelve'), /Sixty > twelve/);
+```
+
+`convertHTML('Stuff in "quotation marks"')` 應返回 `Stuff in "quotation marks"`。
+
+```js
+assert.match(
+ convertHTML('Stuff in "quotation marks"'),
+ /Stuff in "quotation marks"/
+);
+```
+
+`convertHTML("Schindler's List")` 應返回 `Schindler's List`。
+
+```js
+assert.match(convertHTML("Schindler's List"), /Schindler's List/);
+```
+
+`convertHTML("<>")` 應返回 `<>`。
+
+```js
+assert.match(convertHTML('<>'), /<>/);
+```
+
+`convertHTML("abc")` 應該返回字符串 `abc`。
+
+```js
+assert.strictEqual(convertHTML('abc'), 'abc');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function convertHTML(str) {
+ return str;
+}
+
+convertHTML("Dolce & Gabbana");
+```
+
+# --solutions--
+
+```js
+var MAP = { '&': '&',
+ '<': '<',
+ '>': '>',
+ '"': '"',
+ "'": '''};
+
+function convertHTML(str) {
+ return str.replace(/[&<>"']/g, function(c) {
+ return MAP[c];
+ });
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/diff-two-arrays.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/diff-two-arrays.md
new file mode 100644
index 0000000000..24c0a00232
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/diff-two-arrays.md
@@ -0,0 +1,190 @@
+---
+id: a5de63ebea8dbee56860f4f2
+title: 數組的對稱差
+challengeType: 5
+forumTopicId: 16008
+dashedName: diff-two-arrays
+---
+
+# --description--
+
+比較兩個數組並返回一個新數組，包含所有隻在其中一個數組中出現的元素，排除兩個數組都存在的元素。 換言之，我們需要返回兩個數組的對稱差。
+
+**注意：**返回數組中的元素順序不會影響挑戰的測試結果。
+
+# --hints--
+
+`diffArray([1, 2, 3, 5], [1, 2, 3, 4, 5])` 應返回一個數組。
+
+```js
+assert(typeof diffArray([1, 2, 3, 5], [1, 2, 3, 4, 5]) === 'object');
+```
+
+`["diorite", "andesite", "grass", "dirt", "pink wool", "dead shrub"], ["diorite", "andesite", "grass", "dirt", "dead shrub"]` 應返回 `["pink wool"]`。
+
+```js
+assert.sameMembers(
+ diffArray(
+ ['diorite', 'andesite', 'grass', 'dirt', 'pink wool', 'dead shrub'],
+ ['diorite', 'andesite', 'grass', 'dirt', 'dead shrub']
+ ),
+ ['pink wool']
+);
+```
+
+`["diorite", "andesite", "grass", "dirt", "pink wool", "dead shrub"], ["diorite", "andesite", "grass", "dirt", "dead shrub"]` 應返回一個長度爲 1 的數組。
+
+```js
+assert(
+ diffArray(
+ ['diorite', 'andesite', 'grass', 'dirt', 'pink wool', 'dead shrub'],
+ ['diorite', 'andesite', 'grass', 'dirt', 'dead shrub']
+ ).length === 1
+);
+```
+
+`["andesite", "grass", "dirt", "pink wool", "dead shrub"], ["diorite", "andesite", "grass", "dirt", "dead shrub"]` 應返回 `["diorite", "pink wool"]`。
+
+```js
+assert.sameMembers(
+ diffArray(
+ ['andesite', 'grass', 'dirt', 'pink wool', 'dead shrub'],
+ ['diorite', 'andesite', 'grass', 'dirt', 'dead shrub']
+ ),
+ ['diorite', 'pink wool']
+);
+```
+
+`["andesite", "grass", "dirt", "pink wool", "dead shrub"], ["diorite", "andesite", "grass", "dirt", "dead shrub"]` 應返回一個長度爲 2 的數組。
+
+```js
+assert(
+ diffArray(
+ ['andesite', 'grass', 'dirt', 'pink wool', 'dead shrub'],
+ ['diorite', 'andesite', 'grass', 'dirt', 'dead shrub']
+ ).length === 2
+);
+```
+
+`["andesite", "grass", "dirt", "dead shrub"], ["andesite", "grass", "dirt", "dead shrub"]` 應返回 `[]`。
+
+```js
+assert.sameMembers(
+ diffArray(
+ ['andesite', 'grass', 'dirt', 'dead shrub'],
+ ['andesite', 'grass', 'dirt', 'dead shrub']
+ ),
+ []
+);
+```
+
+`["andesite", "grass", "dirt", "dead shrub"], ["andesite", "grass", "dirt", "dead shrub"]` 應返回一個空數組。
+
+```js
+assert(
+ diffArray(
+ ['andesite', 'grass', 'dirt', 'dead shrub'],
+ ['andesite', 'grass', 'dirt', 'dead shrub']
+ ).length === 0
+);
+```
+
+`[1, 2, 3, 5], [1, 2, 3, 4, 5]` 應返回 `[4]`。
+
+```js
+assert.sameMembers(diffArray([1, 2, 3, 5], [1, 2, 3, 4, 5]), [4]);
+```
+
+`[1, 2, 3, 5], [1, 2, 3, 4, 5]` 應返回一個長度爲 1 的數組。
+
+```js
+assert(diffArray([1, 2, 3, 5], [1, 2, 3, 4, 5]).length === 1);
+```
+
+`[1, "calf", 3, "piglet"], [1, "calf", 3, 4]` 應返回 `["piglet", 4]`。
+
+```js
+assert.sameMembers(diffArray([1, 'calf', 3, 'piglet'], [1, 'calf', 3, 4]), [
+ 'piglet',
+ 4
+]);
+```
+
+`[1, "calf", 3, "piglet"], [1, "calf", 3, 4]` 應返回一個長度爲 2 的數組。
+
+```js
+assert(diffArray([1, 'calf', 3, 'piglet'], [1, 'calf', 3, 4]).length === 2);
+```
+
+`[], ["snuffleupagus", "cookie monster", "elmo"]` 應返回 `["snuffleupagus", "cookie monster", "elmo"]`。
+
+```js
+assert.sameMembers(diffArray([], ['snuffleupagus', 'cookie monster', 'elmo']), [
+ 'snuffleupagus',
+ 'cookie monster',
+ 'elmo'
+]);
+```
+
+`[], ["snuffleupagus", "cookie monster", "elmo"]` 應返回一個長度爲 3 的數組。
+
+```js
+assert(diffArray([], ['snuffleupagus', 'cookie monster', 'elmo']).length === 3);
+```
+
+`[1, "calf", 3, "piglet"], [7, "filly"]` 應返回 `[1, "calf", 3, "piglet", 7, "filly"]`。
+
+```js
+assert.sameMembers(diffArray([1, 'calf', 3, 'piglet'], [7, 'filly']), [
+ 1,
+ 'calf',
+ 3,
+ 'piglet',
+ 7,
+ 'filly'
+]);
+```
+
+`[1, "calf", 3, "piglet"], [7, "filly"]` 應返回一個長度爲 6 的數組。
+
+```js
+assert(diffArray([1, 'calf', 3, 'piglet'], [7, 'filly']).length === 6);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function diffArray(arr1, arr2) {
+ var newArr = [];
+ return newArr;
+}
+
+diffArray([1, 2, 3, 5], [1, 2, 3, 4, 5]);
+```
+
+# --solutions--
+
+```js
+function diffArray(arr1, arr2) {
+ var newArr = [];
+ var h1 = Object.create(null);
+ arr1.forEach(function(e) {
+ h1[e] = e;
+ });
+
+ var h2 = Object.create(null);
+ arr2.forEach(function(e) {
+ h2[e] = e;
+ });
+
+ Object.keys(h1).forEach(function(e) {
+ if (!(e in h2)) newArr.push(h1[e]);
+ });
+ Object.keys(h2).forEach(function(e) {
+ if (!(e in h1)) newArr.push(h2[e]);
+ });
+ return newArr;
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/dna-pairing.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/dna-pairing.md
new file mode 100644
index 0000000000..cb00fb35bf
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/dna-pairing.md
@@ -0,0 +1,83 @@
+---
+id: afd15382cdfb22c9efe8b7de
+title: DNA 配對
+challengeType: 5
+forumTopicId: 16009
+dashedName: dna-pairing
+---
+
+# --description--
+
+給出的 DNA 鏈上缺少配對元素。 請基於每個字符，獲取與其配對的元素，並將結果作爲二維數組返回。
+
+DNA 的[鹼基對](http://en.wikipedia.org/wiki/Base_pair) 有兩種形式：一種是 A 與 T，一種是 C 與 G。 請爲參數中給出的每個字符配對相應的鹼基。
+
+注意，參數中給出的字符應作爲每個子數組中的第一個元素返回。
+
+例如，傳入 `GCG` 時，應返回 `[["G", "C"], ["C","G"], ["G", "C"]]`。
+
+字符和它的配對組成一個數組中，所有配對數組放在一個數組裏。
+
+# --hints--
+
+`pairElement("ATCGA")` 應返回 `[["A","T"],["T","A"],["C","G"],["G","C"],["A","T"]]`。
+
+```js
+assert.deepEqual(pairElement('ATCGA'), [
+ ['A', 'T'],
+ ['T', 'A'],
+ ['C', 'G'],
+ ['G', 'C'],
+ ['A', 'T']
+]);
+```
+
+`pairElement("TTGAG")` 應返回 `[["T","A"],["T","A"],["G","C"],["A","T"],["G","C"]]`。
+
+```js
+assert.deepEqual(pairElement('TTGAG'), [
+ ['T', 'A'],
+ ['T', 'A'],
+ ['G', 'C'],
+ ['A', 'T'],
+ ['G', 'C']
+]);
+```
+
+`pairElement("CTCTA")` 應返回 `[["C","G"],["T","A"],["C","G"],["T","A"],["A","T"]]`。
+
+```js
+assert.deepEqual(pairElement('CTCTA'), [
+ ['C', 'G'],
+ ['T', 'A'],
+ ['C', 'G'],
+ ['T', 'A'],
+ ['A', 'T']
+]);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function pairElement(str) {
+ return str;
+}
+
+pairElement("GCG");
+```
+
+# --solutions--
+
+```js
+var lookup = Object.create(null);
+lookup.A = 'T';
+lookup.T = 'A';
+lookup.C = 'G';
+lookup.G = 'C';
+
+function pairElement(str) {
+ return str.split('').map(function(p) {return [p, lookup[p]];});
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/drop-it.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/drop-it.md
new file mode 100644
index 0000000000..c5d64336e9
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/drop-it.md
@@ -0,0 +1,104 @@
+---
+id: a5deed1811a43193f9f1c841
+title: 根據參數刪除數組元素
+challengeType: 5
+forumTopicId: 16010
+dashedName: drop-it
+---
+
+# --description--
+
+給定數組 `arr`，從數組的第一個元素開始，用函數 `func` 來檢查數組的每個元素是否返回 `true`。 如果返回 false，就把這個元素刪除。 持續執行刪除操作，直到某個元素傳入 func 時返回 true 爲止。
+
+然後在條件滿足後返回數組的其餘部分，否則， `arr` 應作爲空數組返回。
+
+# --hints--
+
+`dropElements([1, 2, 3, 4], function(n) {return n >= 3;})` 應返回 `[3, 4]`。
+
+```js
+assert.deepEqual(
+ dropElements([1, 2, 3, 4], function (n) {
+ return n >= 3;
+ }),
+ [3, 4]
+);
+```
+
+`dropElements([0, 1, 0, 1], function(n) {return n === 1;})` 應返回 `[1, 0, 1]`。
+
+```js
+assert.deepEqual(
+ dropElements([0, 1, 0, 1], function (n) {
+ return n === 1;
+ }),
+ [1, 0, 1]
+);
+```
+
+`dropElements([1, 2, 3], function(n) {return n > 0;})` 應返回 `[1, 2, 3]`。
+
+```js
+assert.deepEqual(
+ dropElements([1, 2, 3], function (n) {
+ return n > 0;
+ }),
+ [1, 2, 3]
+);
+```
+
+`dropElements([1, 2, 3, 4], function(n) {return n > 5;})` 應返回 `[]`。
+
+```js
+assert.deepEqual(
+ dropElements([1, 2, 3, 4], function (n) {
+ return n > 5;
+ }),
+ []
+);
+```
+
+`dropElements([1, 2, 3, 7, 4], function(n) {return n > 3;})` 應返回 `[7, 4]`。
+
+```js
+assert.deepEqual(
+ dropElements([1, 2, 3, 7, 4], function (n) {
+ return n > 3;
+ }),
+ [7, 4]
+);
+```
+
+`dropElements([1, 2, 3, 9, 2], function(n) {return n > 2;})` 應返回 `[3, 9, 2]`。
+
+```js
+assert.deepEqual(
+ dropElements([1, 2, 3, 9, 2], function (n) {
+ return n > 2;
+ }),
+ [3, 9, 2]
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function dropElements(arr, func) {
+ return arr;
+}
+
+dropElements([1, 2, 3], function(n) {return n < 3; });
+```
+
+# --solutions--
+
+```js
+function dropElements(arr, func) {
+ while (arr.length && !func(arr[0])) {
+ arr.shift();
+ }
+ return arr;
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/everything-be-true.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/everything-be-true.md
new file mode 100644
index 0000000000..b11a7b8784
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/everything-be-true.md
@@ -0,0 +1,155 @@
+---
+id: a10d2431ad0c6a099a4b8b52
+title: 一切都是True
+challengeType: 5
+forumTopicId: 16011
+dashedName: everything-be-true
+---
+
+# --description--
+
+檢查謂詞（第二個參數）在集合（第一個參數）的所有元素是否爲 truthy 。
+
+換句話說，你將獲得一個對象的數組集合。 如果數組中的每個對象裏，`pre` 對應屬性值均爲 `truthy`，則返回 `true`。 否則，返回 `false` 。
+
+JavaScript 中，如果一個值在 Boolean 的上下文中的執行結果爲 `true`，那麼我們稱這個值是 `truthy` 的。
+
+別忘了，你可以使用點號表示法或方括號表示法（`[]`）來訪問對象的屬性。
+
+# --hints--
+
+`truthCheck([{"user": "Tinky-Winky", "sex": "male"}, {"user": "Dipsy", "sex": "male"}, {"user": "Laa-Laa", "sex": "female"}, {"user": "Po", "sex": "female"}], "sex")` 應返回 `true`。
+
+```js
+assert.strictEqual(
+ truthCheck(
+ [
+ { user: 'Tinky-Winky', sex: 'male' },
+ { user: 'Dipsy', sex: 'male' },
+ { user: 'Laa-Laa', sex: 'female' },
+ { user: 'Po', sex: 'female' }
+ ],
+ 'sex'
+ ),
+ true
+);
+```
+
+`truthCheck([{"user": "Tinky-Winky", "sex": "male"}, {"user": "Dipsy"}, {"user": "Laa-Laa", "sex": "female"}, {"user": "Po", "sex": "female"}], "sex")` 應返回 `false`。
+
+```js
+assert.strictEqual(
+ truthCheck(
+ [
+ { user: 'Tinky-Winky', sex: 'male' },
+ { user: 'Dipsy' },
+ { user: 'Laa-Laa', sex: 'female' },
+ { user: 'Po', sex: 'female' }
+ ],
+ 'sex'
+ ),
+ false
+);
+```
+
+`truthCheck([{"user": "Tinky-Winky", "sex": "male", "age": 0}, {"user": "Dipsy", "sex": "male", "age": 3}, {"user": "Laa-Laa", "sex": "female", "age": 5}, {"user": "Po", "sex": "female", "age": 4}], "age")` 應返回 `false`。
+
+```js
+assert.strictEqual(
+ truthCheck(
+ [
+ { user: 'Tinky-Winky', sex: 'male', age: 2 },
+ { user: 'Dipsy', sex: 'male', age: 0 },
+ { user: 'Laa-Laa', sex: 'female', age: 5 },
+ { user: 'Po', sex: 'female', age: 4 }
+ ],
+ 'age'
+ ),
+ false
+);
+```
+
+`truthCheck([{"name": "Pete", "onBoat": true}, {"name": "Repeat", "onBoat": true}, {"name": "FastForward", "onBoat": null}], "onBoat")` 應返回 `false`。
+
+```js
+assert.strictEqual(
+ truthCheck(
+ [
+ { name: 'Pete', onBoat: true },
+ { name: 'Repeat', onBoat: true },
+ { name: 'FastForward', onBoat: null }
+ ],
+ 'onBoat'
+ ),
+ false
+);
+```
+
+`truthCheck([{"name": "Pete", "onBoat": true}, {"name": "Repeat", "onBoat": true, "alias": "Repete"}, {"name": "FastForward", "onBoat": true}], "onBoat")` 應返回 `true`。
+
+```js
+assert.strictEqual(
+ truthCheck(
+ [
+ { name: 'Pete', onBoat: true },
+ { name: 'Repeat', onBoat: true, alias: 'Repete' },
+ { name: 'FastForward', onBoat: true }
+ ],
+ 'onBoat'
+ ),
+ true
+);
+```
+
+`truthCheck([{"single": "yes"}], "single")` 應返回 `true`。
+
+```js
+assert.strictEqual(truthCheck([{ single: 'yes' }], 'single'), true);
+```
+
+`truthCheck([{"single": ""}, {"single": "double"}], "single")` 應返回 `false`。
+
+```js
+assert.strictEqual(
+ truthCheck([{ single: '' }, { single: 'double' }], 'single'),
+ false
+);
+```
+
+`truthCheck([{"single": "double"}, {"single": undefined}], "single")` 應返回 `false`。
+
+```js
+assert.strictEqual(
+ truthCheck([{ single: 'double' }, { single: undefined }], 'single'),
+ false
+);
+```
+
+`truthCheck([{"single": "double"}, {"single": NaN}], "single")` 應返回 `false`。
+
+```js
+assert.strictEqual(
+ truthCheck([{ single: 'double' }, { single: NaN }], 'single'),
+ false
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function truthCheck(collection, pre) {
+ return pre;
+}
+
+truthCheck([{"user": "Tinky-Winky", "sex": "male"}, {"user": "Dipsy", "sex": "male"}, {"user": "Laa-Laa", "sex": "female"}, {"user": "Po", "sex": "female"}], "sex");
+```
+
+# --solutions--
+
+```js
+function truthCheck(collection, pre) {
+ return collection.every(function(e) { return e[pre]; });
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/make-a-person.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/make-a-person.md
new file mode 100644
index 0000000000..d062d34ce7
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/make-a-person.md
@@ -0,0 +1,197 @@
+---
+id: a2f1d72d9b908d0bd72bb9f6
+title: 創建一個人員對象
+challengeType: 5
+forumTopicId: 16020
+dashedName: make-a-person
+---
+
+# --description--
+
+用以下方法填充對象構造函數：
+
+```js
+getFirstName()
+getLastName()
+getFullName()
+setFirstName(first)
+setLastName(last)
+setFullName(firstAndLast)
+```
+
+運行測試以查看每個方法的預期輸出。 方法接收一個參數，因此必須要有一個參數，並且其類型應該爲字符串。 這些方法必須是與對象交互的唯一可用方法。
+
+# --hints--
+
+`Object.keys(bob).length` 應返回 6。
+
+```js
+assert.deepEqual(Object.keys(bob).length, 6);
+```
+
+`bob instanceof Person` 應返回 `true`。
+
+```js
+assert.deepEqual(bob instanceof Person, true);
+```
+
+`bob.firstName` 應該返回 `undefined`。
+
+```js
+assert.deepEqual(bob.firstName, undefined);
+```
+
+`bob.lastName` 應該返回 `undefined`。
+
+```js
+assert.deepEqual(bob.lastName, undefined);
+```
+
+`bob.getFirstName()` 應該返回字符串 `Bob`.
+
+```js
+assert.deepEqual(bob.getFirstName(), 'Bob');
+```
+
+`bob.getLastName()` 應該返回字符串 `Ross`.
+
+```js
+assert.deepEqual(bob.getLastName(), 'Ross');
+```
+
+`bob.getFullName()` 應該返回字符串 `Bob Ross`.
+
+```js
+assert.deepEqual(bob.getFullName(), 'Bob Ross');
+```
+
+`bob.getFullName()` 應該在 `bob.setFirstName("Haskell")` 之後返回字符串 `Haskell Ross`。
+
+```js
+assert.strictEqual(
+ (function () {
+ bob.setFirstName('Haskell');
+ return bob.getFullName();
+ })(),
+ 'Haskell Ross'
+);
+```
+
+`bob.getFullName()` 應該在 `bob.setLastName("Curry")` 之後返回字符串 `Haskell Curry`。
+
+```js
+assert.strictEqual(
+ (function () {
+ var _bob = new Person('Haskell Ross');
+ _bob.setLastName('Curry');
+ return _bob.getFullName();
+ })(),
+ 'Haskell Curry'
+);
+```
+
+`bob.getFullName()` 應該返回字符串 `Haskell Curry` 之後的 `bob.setFullName("Haskell Curry")`。
+
+```js
+assert.strictEqual(
+ (function () {
+ bob.setFullName('Haskell Curry');
+ return bob.getFullName();
+ })(),
+ 'Haskell Curry'
+);
+```
+
+`bob.getFirstName()` 應該返回字符串 `Haskell` 之後的 `bob.setFullName("Haskell Curry")`。
+
+```js
+assert.strictEqual(
+ (function () {
+ bob.setFullName('Haskell Curry');
+ return bob.getFirstName();
+ })(),
+ 'Haskell'
+);
+```
+
+`bob.getLastName()` 應該返回字符串 `Curry` 之後 `bob.setFullName("Haskell Curry")`。
+
+```js
+assert.strictEqual(
+ (function () {
+ bob.setFullName('Haskell Curry');
+ return bob.getLastName();
+ })(),
+ 'Curry'
+);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+if(bob){
+ bob = new Person("Bob Ross");
+}
+```
+
+## --seed-contents--
+
+```js
+var Person = function(firstAndLast) {
+ // Only change code below this line
+ // Complete the method below and implement the others similarly
+ this.getFullName = function() {
+ return "";
+ };
+ return firstAndLast;
+};
+
+var bob = new Person('Bob Ross');
+bob.getFullName();
+```
+
+# --solutions--
+
+```js
+var Person = function(firstAndLast) {
+
+ var firstName, lastName;
+
+ function updateName(str) {
+ firstName = str.split(" ")[0];
+ lastName = str.split(" ")[1];
+ }
+
+ updateName(firstAndLast);
+
+ this.getFirstName = function(){
+ return firstName;
+ };
+
+ this.getLastName = function(){
+ return lastName;
+ };
+
+ this.getFullName = function(){
+ return firstName + " " + lastName;
+ };
+
+ this.setFirstName = function(str){
+ firstName = str;
+ };
+
+
+ this.setLastName = function(str){
+ lastName = str;
+ };
+
+ this.setFullName = function(str){
+ updateName(str);
+ };
+};
+
+var bob = new Person('Bob Ross');
+bob.getFullName();
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/map-the-debris.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/map-the-debris.md
new file mode 100644
index 0000000000..47eca19915
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/map-the-debris.md
@@ -0,0 +1,78 @@
+---
+id: af4afb223120f7348cdfc9fd
+title: 計算軌道週期
+challengeType: 5
+forumTopicId: 16021
+dashedName: map-the-debris
+---
+
+# --description--
+
+在這道題目中，我們需要寫一個計算天體軌道週期（單位是秒）的函數。
+
+它接收一個對象數組參數 arr，對象中包含表示天體名稱的 name 屬性，及表示天體表面平均海拔的 avgAlt 屬性。 就像這樣：`{name: 'name', avgAlt: avgAlt}`。
+
+你可以在這條[維基百科](http://en.wikipedia.org/wiki/Orbital_period)的鏈接中找到軌道週期的計算公式：
+
+最終的計算結果應取整到最接近的整數。 在這裏計算地球的軌道週期。
+
+地球半徑爲 6367.4447 公里，地球的 GM 值爲 398600.4418 km 3 s -2 。
+
+# --hints--
+
+`orbitalPeriod([{name : "sputnik", avgAlt : 35873.5553}])` 應返回 `[{name: "sputnik", orbitalPeriod: 86400}]` 。
+
+```js
+assert.deepEqual(orbitalPeriod([{ name: 'sputnik', avgAlt: 35873.5553 }]), [
+ { name: 'sputnik', orbitalPeriod: 86400 }
+]);
+```
+
+`orbitalPeriod([{name: "iss", avgAlt: 413.6}, {name: "hubble", avgAlt: 556.7}, {name: "moon", avgAlt: 378632.553}])` 應返回 `[{name : "iss", orbitalPeriod: 5557}, {name: "hubble", orbitalPeriod: 5734}, {name: "moon", orbitalPeriod: 2377399}]`。
+
+```js
+assert.deepEqual(
+ orbitalPeriod([
+ { name: 'iss', avgAlt: 413.6 },
+ { name: 'hubble', avgAlt: 556.7 },
+ { name: 'moon', avgAlt: 378632.553 }
+ ]),
+ [
+ { name: 'iss', orbitalPeriod: 5557 },
+ { name: 'hubble', orbitalPeriod: 5734 },
+ { name: 'moon', orbitalPeriod: 2377399 }
+ ]
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function orbitalPeriod(arr) {
+ var GM = 398600.4418;
+ var earthRadius = 6367.4447;
+ return arr;
+}
+
+orbitalPeriod([{name : "sputnik", avgAlt : 35873.5553}]);
+```
+
+# --solutions--
+
+```js
+function orbitalPeriod(arr) {
+ var GM = 398600.4418;
+ var earthRadius = 6367.4447;
+ var TAU = 2 * Math.PI;
+ return arr.map(function(obj) {
+ return {
+ name: obj.name,
+ orbitalPeriod: Math.round(TAU * Math.sqrt(Math.pow(obj.avgAlt+earthRadius, 3)/GM))
+ };
+ });
+}
+
+orbitalPeriod([{name : "sputkin", avgAlt : 35873.5553}]);
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/missing-letters.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/missing-letters.md
new file mode 100644
index 0000000000..4ce2cc7b24
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/missing-letters.md
@@ -0,0 +1,72 @@
+---
+id: af7588ade1100bde429baf20
+title: 尋找缺失的字母
+challengeType: 5
+forumTopicId: 16023
+dashedName: missing-letters
+---
+
+# --description--
+
+在這道題目中，我們需要寫一個函數，找出傳入的字符串裏缺失的字母並返回它。
+
+如果所有字母都在傳入的字符串範圍內，返回 `undefined`。
+
+# --hints--
+
+`fearNotLetter("abce")` 應該返回字符串 `d`。
+
+```js
+assert.deepEqual(fearNotLetter('abce'), 'd');
+```
+
+`fearNotLetter("abcdefghjklmno")` 應返回 `i`。
+
+```js
+assert.deepEqual(fearNotLetter('abcdefghjklmno'), 'i');
+```
+
+`fearNotLetter("stvwx")` 應該返回字符串 `u`。
+
+```js
+assert.deepEqual(fearNotLetter('stvwx'), 'u');
+```
+
+`fearNotLetter("bcdf")` 應該返回字符串 `e`。
+
+```js
+assert.deepEqual(fearNotLetter('bcdf'), 'e');
+```
+
+`fearNotLetter("abcdefghijklmnopqrstuvwxyz")` 應返回 `undefined`。
+
+```js
+assert.isUndefined(fearNotLetter('abcdefghijklmnopqrstuvwxyz'));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function fearNotLetter(str) {
+ return str;
+}
+
+fearNotLetter("abce");
+```
+
+# --solutions--
+
+```js
+function fearNotLetter (str) {
+ for (var i = str.charCodeAt(0); i <= str.charCodeAt(str.length - 1); i++) {
+ var letter = String.fromCharCode(i);
+ if (str.indexOf(letter) === -1) {
+ return letter;
+ }
+ }
+
+ return undefined;
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/pig-latin.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/pig-latin.md
new file mode 100644
index 0000000000..e5eb14b395
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/pig-latin.md
@@ -0,0 +1,93 @@
+---
+id: aa7697ea2477d1316795783b
+title: 兒童黑話
+challengeType: 5
+forumTopicId: 16039
+dashedName: pig-latin
+---
+
+# --description--
+
+兒童黑話也叫 Pig Latin，是一種英語語言遊戲。 規則如下：
+
+\- 如果單詞以輔音開頭，就把第一個輔音字母或第一組輔音簇移到單詞的結尾，並在後面加上 `ay`。
+
+\- 如果單詞以元音開頭，只需要在結尾加上 `way`。
+
+# --instructions--
+
+請把傳入的字符串根據上述規則翻譯成兒童黑話並返回結果。 輸入的字符串一定是一個小寫的英文單詞。
+
+# --hints--
+
+`translatePigLatin("california")` 應該返回字符串 `aliforniacay`。
+
+```js
+assert.deepEqual(translatePigLatin('california'), 'aliforniacay');
+```
+
+`translatePigLatin("paragraphs")` 應該返回字符串 `aragraphspay`。
+
+```js
+assert.deepEqual(translatePigLatin('paragraphs'), 'aragraphspay');
+```
+
+`translatePigLatin("glove")` 應該返回字符串 `oveglay`。
+
+```js
+assert.deepEqual(translatePigLatin('glove'), 'oveglay');
+```
+
+`translatePigLatin("algorithm")` 應該返回字符串 `algorithmway`。
+
+```js
+assert.deepEqual(translatePigLatin('algorithm'), 'algorithmway');
+```
+
+`translatePigLatin("eight")` 應該返回字符串 `eightway`。
+
+```js
+assert.deepEqual(translatePigLatin('eight'), 'eightway');
+```
+
+應該處理單詞的第一個元音在單詞中間的位置的情況。 `translatePigLatin("schwartz")` 應該返回字符串 `artzschway`。
+
+```js
+assert.deepEqual(translatePigLatin('schwartz'), 'artzschway');
+```
+
+應該處理不帶元音的單詞。 `translatePigLatin("rhythm")` 應該返回字符串 `rhythmay`。
+
+```js
+assert.deepEqual(translatePigLatin('rhythm'), 'rhythmay');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function translatePigLatin(str) {
+ return str;
+}
+
+translatePigLatin("consonant");
+```
+
+# --solutions--
+
+```js
+function translatePigLatin(str) {
+ if (isVowel(str.charAt(0))) return str + "way";
+ var front = [];
+ str = str.split('');
+ while (str.length && !isVowel(str[0])) {
+ front.push(str.shift());
+ }
+ return [].concat(str, front).join('') + 'ay';
+}
+
+function isVowel(c) {
+ return ['a', 'e', 'i', 'o', 'u'].indexOf(c.toLowerCase()) !== -1;
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/search-and-replace.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/search-and-replace.md
new file mode 100644
index 0000000000..8bb56641f9
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/search-and-replace.md
@@ -0,0 +1,100 @@
+---
+id: a0b5010f579e69b815e7c5d6
+title: 搜索與替換
+challengeType: 5
+forumTopicId: 16045
+dashedName: search-and-replace
+---
+
+# --description--
+
+在這道題目中，我們需要寫一個字符串的搜索與替換函數，它的返回值爲完成替換後的新字符串。
+
+這個函數接收的第一個參數爲待替換的句子。
+
+第二個參數爲句中需要被替換的單詞。
+
+第三個參數爲替換後的單詞。
+
+**注意：** 在更換原始單詞時保留原始單詞中第一個字符的大小寫。 即如果傳入的第二個參數爲 `Book`，第三個參數爲 `dog`，那麼替換後的結果應爲 `Dog`
+
+# --hints--
+
+`myReplace("Let us go to the store", "store", "mall")` 應返回 `Let us go to the mall`。
+
+```js
+assert.deepEqual(
+ myReplace('Let us go to the store', 'store', 'mall'),
+ 'Let us go to the mall'
+);
+```
+
+`myReplace("He is Sleeping on the couch", "Sleeping", "sitting")` 應返回 `He is Sitting on the couch`。
+
+```js
+assert.deepEqual(
+ myReplace('He is Sleeping on the couch', 'Sleeping', 'sitting'),
+ 'He is Sitting on the couch'
+);
+```
+
+`myReplace("I think we should look up there", "up", "Down")` 應返回 `I think we should look down there`。
+
+```js
+assert.deepEqual(
+ myReplace('I think we should look up there', 'up', 'Down'),
+ 'I think we should look down there'
+);
+```
+
+`myReplace("This has a spellngi error", "spellngi", "spelling")` 應返回 `This has a spelling error`。
+
+```js
+assert.deepEqual(
+ myReplace('This has a spellngi error', 'spellngi', 'spelling'),
+ 'This has a spelling error'
+);
+```
+
+`myReplace("His name is Tom", "Tom", "john")` 應返回 `His name is John`。
+
+```js
+assert.deepEqual(
+ myReplace('His name is Tom', 'Tom', 'john'),
+ 'His name is John'
+);
+```
+
+`myReplace("Let us get back to more Coding", "Coding", "algorithms")` 應返回 `Let us get back to more Algorithms`。
+
+```js
+assert.deepEqual(
+ myReplace('Let us get back to more Coding', 'Coding', 'algorithms'),
+ 'Let us get back to more Algorithms'
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function myReplace(str, before, after) {
+ return str;
+}
+
+myReplace("A quick brown fox jumped over the lazy dog", "jumped", "leaped");
+```
+
+# --solutions--
+
+```js
+function myReplace(str, before, after) {
+ if (before.charAt(0) === before.charAt(0).toUpperCase()) {
+ after = after.charAt(0).toUpperCase() + after.substring(1);
+ } else {
+ after = after.charAt(0).toLowerCase() + after.substring(1);
+ }
+ return str.replace(before, after);
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/seek-and-destroy.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/seek-and-destroy.md
new file mode 100644
index 0000000000..fd5d68b4f6
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/seek-and-destroy.md
@@ -0,0 +1,104 @@
+---
+id: a39963a4c10bc8b4d4f06d7e
+title: 過濾數組元素
+challengeType: 5
+forumTopicId: 16046
+dashedName: seek-and-destroy
+---
+
+# --description--
+
+你將獲得一個初始數組（`destroyer` 函數中的第一個參數），後跟一個或多個參數。 從初始數組中移除所有與後續參數相等的元素。
+
+**注意：** 你可以使用 `arguments` 對象。
+
+# --hints--
+
+`destroyer([1, 2, 3, 1, 2, 3], 2, 3)` 應返回 `[1, 1]`。
+
+```js
+assert.deepEqual(destroyer([1, 2, 3, 1, 2, 3], 2, 3), [1, 1]);
+```
+
+`destroyer([1, 2, 3, 5, 1, 2, 3], 2, 3)` 應返回 `[1, 5, 1]`。
+
+```js
+assert.deepEqual(destroyer([1, 2, 3, 5, 1, 2, 3], 2, 3), [1, 5, 1]);
+```
+
+`destroyer([3, 5, 1, 2, 2], 2, 3, 5)` 應返回 `[1]`。
+
+```js
+assert.deepEqual(destroyer([3, 5, 1, 2, 2], 2, 3, 5), [1]);
+```
+
+`destroyer([2, 3, 2, 3], 2, 3)` 應返回 `[]`。
+
+```js
+assert.deepEqual(destroyer([2, 3, 2, 3], 2, 3), []);
+```
+
+`destroyer(["tree", "hamburger", 53], "tree", 53)` 應返回 `["hamburger"]`。
+
+```js
+assert.deepEqual(destroyer(['tree', 'hamburger', 53], 'tree', 53), [
+ 'hamburger'
+]);
+```
+
+`destroyer(["possum", "trollo", 12, "safari", "hotdog", 92, 65, "grandma", "bugati", "trojan", "yacht"], "yacht", "possum", "trollo", "safari", "hotdog", "grandma", "bugati", "trojan")` 應返回 `[12,92,65]`。
+
+```js
+assert.deepEqual(
+ destroyer(
+ [
+ 'possum',
+ 'trollo',
+ 12,
+ 'safari',
+ 'hotdog',
+ 92,
+ 65,
+ 'grandma',
+ 'bugati',
+ 'trojan',
+ 'yacht'
+ ],
+ 'yacht',
+ 'possum',
+ 'trollo',
+ 'safari',
+ 'hotdog',
+ 'grandma',
+ 'bugati',
+ 'trojan'
+ ),
+ [12, 92, 65]
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function destroyer(arr) {
+ return arr;
+}
+
+destroyer([1, 2, 3, 1, 2, 3], 2, 3);
+```
+
+# --solutions--
+
+```js
+function destroyer(arr) {
+ var hash = Object.create(null);
+ [].slice.call(arguments, 1).forEach(function(e) {
+ hash[e] = true;
+ });
+ return arr.filter(function(e) { return !(e in hash);});
+}
+
+destroyer([1, 2, 3, 1, 2, 3], 2, 3);
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/smallest-common-multiple.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/smallest-common-multiple.md
new file mode 100644
index 0000000000..62fc10e71e
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/smallest-common-multiple.md
@@ -0,0 +1,90 @@
+---
+id: ae9defd7acaf69703ab432ea
+title: 找出數字範圍內的最小公倍數
+challengeType: 5
+forumTopicId: 16075
+dashedName: smallest-common-multiple
+---
+
+# --description--
+
+找到給定參數的最小公倍數，可以被這兩個參數整除，也可以被指定範圍內的所以整數整除。
+
+注意，較小數不一定總是出現在數組的第一個元素。
+
+例如，如果給定 1 和 3，找到 1 和 3 的最小公倍數，也可以被 1 到 3 *之間*的所有數字整除。 這裏的答案將是 6。
+
+# --hints--
+
+`smallestCommons([1, 5])` 應返回 a number。
+
+```js
+assert.deepEqual(typeof smallestCommons([1, 5]), 'number');
+```
+
+`smallestCommons([1, 5])` 應返回 60。
+
+```js
+assert.deepEqual(smallestCommons([1, 5]), 60);
+```
+
+`smallestCommons([5, 1])` 應返回 60。
+
+```js
+assert.deepEqual(smallestCommons([5, 1]), 60);
+```
+
+`smallestCommons([2, 10])` 應返回 2520。
+
+```js
+assert.deepEqual(smallestCommons([2, 10]), 2520);
+```
+
+`smallestCommons([1, 13])` 應返回 360360。
+
+```js
+assert.deepEqual(smallestCommons([1, 13]), 360360);
+```
+
+`smallestCommons([23, 18])` 應返回 6056820。
+
+```js
+assert.deepEqual(smallestCommons([23, 18]), 6056820);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function smallestCommons(arr) {
+ return arr;
+}
+
+
+smallestCommons([1,5]);
+```
+
+# --solutions--
+
+```js
+function gcd(a, b) {
+ while (b !== 0) {
+ a = [b, b = a % b][0];
+ }
+ return a;
+}
+
+function lcm(a, b) {
+ return (a * b) / gcd(a, b);
+}
+
+function smallestCommons(arr) {
+ arr.sort(function(a,b) {return a-b;});
+ var rng = [];
+ for (var i = arr[0]; i <= arr[1]; i++) {
+ rng.push(i);
+ }
+ return rng.reduce(lcm);
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/sorted-union.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/sorted-union.md
new file mode 100644
index 0000000000..5916f08f7d
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/sorted-union.md
@@ -0,0 +1,68 @@
+---
+id: a105e963526e7de52b219be9
+title: 集合排序
+challengeType: 5
+forumTopicId: 16077
+dashedName: sorted-union
+---
+
+# --description--
+
+編寫一個帶有兩個或更多數組的函數，並按原始提供的數組的順序返回一個新的唯一值數組。
+
+換句話說，所有數組中出現的所有值都應按其原始順序包括在內，但最終數組中不得重複。
+
+去重後的數字應按其出現在參數中的原始順序排序，最終數組不應按數字大小進行排序。
+
+如有疑問，請先瀏覽下方的測試用例。
+
+# --hints--
+
+`uniteUnique([1, 3, 2], [5, 2, 1, 4], [2, 1])` 應返回 `[1, 3, 2, 5, 4]`。
+
+```js
+assert.deepEqual(uniteUnique([1, 3, 2], [5, 2, 1, 4], [2, 1]), [1, 3, 2, 5, 4]);
+```
+
+`uniteUnique([1, 2, 3], [5, 2, 1])` 應返回 `[1, 2, 3, 5]`。
+
+```js
+assert.deepEqual(uniteUnique([1, 2, 3], [5, 2, 1]), [1, 2, 3, 5]);
+```
+
+`uniteUnique([1, 2, 3], [5, 2, 1, 4], [2, 1], [6, 7, 8])` 應返回 `[1, 2, 3, 5, 4, 6, 7, 8]`。
+
+```js
+assert.deepEqual(uniteUnique([1, 2, 3], [5, 2, 1, 4], [2, 1], [6, 7, 8]), [
+ 1,
+ 2,
+ 3,
+ 5,
+ 4,
+ 6,
+ 7,
+ 8
+]);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function uniteUnique(arr) {
+ return arr;
+}
+
+uniteUnique([1, 3, 2], [5, 2, 1, 4], [2, 1]);
+```
+
+# --solutions--
+
+```js
+function uniteUnique(arr) {
+ return [].slice.call(arguments).reduce(function(a, b) {
+ return [].concat(a, b.filter(function(e) {return a.indexOf(e) === -1;}));
+ }, []);
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/spinal-tap-case.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/spinal-tap-case.md
new file mode 100644
index 0000000000..fa62cbfb9b
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/spinal-tap-case.md
@@ -0,0 +1,70 @@
+---
+id: a103376db3ba46b2d50db289
+title: 短線連接格式
+challengeType: 5
+forumTopicId: 16078
+dashedName: spinal-tap-case
+---
+
+# --description--
+
+將字符串轉換爲短線連接格式。 短線連接格式是小寫單詞全部小寫並以破折號分隔。
+
+# --hints--
+
+`spinalCase("This Is Spinal Tap")` 應返回 `this-is-spinal-tap`。
+
+```js
+assert.deepEqual(spinalCase('This Is Spinal Tap'), 'this-is-spinal-tap');
+```
+
+`spinalCase("thisIsSpinalTap")` 應返回 `this-is-spinal-tap`。
+
+```js
+assert.strictEqual(spinalCase('thisIsSpinalTap'), 'this-is-spinal-tap');
+```
+
+`spinalCase("The_Andy_Griffith_Show")` 應返回 `the-andy-griffith-show`。
+
+```js
+assert.strictEqual(
+ spinalCase('The_Andy_Griffith_Show'),
+ 'the-andy-griffith-show'
+);
+```
+
+`spinalCase("Teletubbies say Eh-oh")` 應返回 `teletubbies-say-eh-oh`。
+
+```js
+assert.strictEqual(
+ spinalCase('Teletubbies say Eh-oh'),
+ 'teletubbies-say-eh-oh'
+);
+```
+
+`spinalCase("AllThe-small Things")` 應返回 `all-the-small-things`。
+
+```js
+assert.strictEqual(spinalCase('AllThe-small Things'), 'all-the-small-things');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function spinalCase(str) {
+ return str;
+}
+
+spinalCase('This Is Spinal Tap');
+```
+
+# --solutions--
+
+```js
+function spinalCase(str) {
+ str = str.replace(/([a-z](?=[A-Z]))/g, '$1 ');
+ return str.toLowerCase().replace(/\ |\_/g, '-');
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/steamroller.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/steamroller.md
new file mode 100644
index 0000000000..b4b46e7117
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/steamroller.md
@@ -0,0 +1,72 @@
+---
+id: ab306dbdcc907c7ddfc30830
+title: 數組扁平化
+challengeType: 5
+forumTopicId: 16079
+dashedName: steamroller
+---
+
+# --description--
+
+嵌套數組扁平化成一維數組。 必須考慮到各種深度的嵌套層級。
+
+# --hints--
+
+`steamrollArray([[["a"]], [["b"]]])` 應返回 `["a", "b"]`。
+
+```js
+assert.deepEqual(steamrollArray([[['a']], [['b']]]), ['a', 'b']);
+```
+
+`steamrollArray([1, [2], [3, [[4]]]])` 應返回 `[1, 2, 3, 4]`。
+
+```js
+assert.deepEqual(steamrollArray([1, [2], [3, [[4]]]]), [1, 2, 3, 4]);
+```
+
+`steamrollArray([1, [], [3, [[4]]]])` 應返回 `[1, 3, 4]`。
+
+```js
+assert.deepEqual(steamrollArray([1, [], [3, [[4]]]]), [1, 3, 4]);
+```
+
+`steamrollArray([1, {}, [3, [[4]]]])` 應返回 `[1, {}, 3, 4]`。
+
+```js
+assert.deepEqual(steamrollArray([1, {}, [3, [[4]]]]), [1, {}, 3, 4]);
+```
+
+代碼中不應使用 `Array.prototype.flat()` 或 `Array.prototype.flatMap()` 方法。
+
+```js
+assert(!code.match(/\.\s*flat\s*\(/) && !code.match(/\.\s*flatMap\s*\(/));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function steamrollArray(arr) {
+ return arr;
+}
+
+steamrollArray([1, [2], [3, [[4]]]]);
+```
+
+# --solutions--
+
+```js
+function steamrollArray(arr) {
+ if (!Array.isArray(arr)) {
+ return [arr];
+ }
+ var out = [];
+ arr.forEach(function(e) {
+ steamrollArray(e).forEach(function(v) {
+ out.push(v);
+ });
+ });
+ return out;
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/sum-all-numbers-in-a-range.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/sum-all-numbers-in-a-range.md
new file mode 100644
index 0000000000..91d0b24d00
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/sum-all-numbers-in-a-range.md
@@ -0,0 +1,70 @@
+---
+id: a3566b1109230028080c9345
+title: 範圍內的數字求和
+challengeType: 5
+forumTopicId: 16083
+dashedName: sum-all-numbers-in-a-range
+---
+
+# --description--
+
+我們會傳入一個由兩個數字組成的數組。 給出一個含有兩個數字的數組，我們需要寫一個函數，讓它返回這兩個數字間所有數字（包含這兩個數字）的總和。 最低的數字並不總是第一位。
+
+例如，`sumAll([4,1])` 應返回 `10`，因爲從 1 到 4（包含 1、4）的所有數字的和是 `10`。
+
+# --hints--
+
+`sumAll([1, 4])` 應返回一個數字。
+
+```js
+assert(typeof sumAll([1, 4]) === 'number');
+```
+
+`sumAll([1, 4])` 應返回 10。
+
+```js
+assert.deepEqual(sumAll([1, 4]), 10);
+```
+
+`sumAll([4, 1])` 應返回 10。
+
+```js
+assert.deepEqual(sumAll([4, 1]), 10);
+```
+
+`sumAll([5, 10])` 應返回 45。
+
+```js
+assert.deepEqual(sumAll([5, 10]), 45);
+```
+
+`sumAll([10, 5])` 應返回 45。
+
+```js
+assert.deepEqual(sumAll([10, 5]), 45);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function sumAll(arr) {
+ return 1;
+}
+
+sumAll([1, 4]);
+```
+
+# --solutions--
+
+```js
+function sumAll(arr) {
+ var sum = 0;
+ arr.sort(function(a,b) {return a-b;});
+ for (var i = arr[0]; i <= arr[1]; i++) {
+ sum += i;
+ }
+ return sum;
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/sum-all-odd-fibonacci-numbers.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/sum-all-odd-fibonacci-numbers.md
new file mode 100644
index 0000000000..bffad64474
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/sum-all-odd-fibonacci-numbers.md
@@ -0,0 +1,82 @@
+---
+id: a5229172f011153519423690
+title: 求斐波那契數列中的奇數之和
+challengeType: 5
+forumTopicId: 16084
+dashedName: sum-all-odd-fibonacci-numbers
+---
+
+# --description--
+
+在這道題目中，我們需要寫一個函數，參數爲一個正整數 `num`，返回值爲斐波那契數列中，小於或等於 `num` 的奇數之和。
+
+斐波那契數列中，第一和第二個數字都是 1。 後面的每個數字由之前兩數相加得出。 斐波那契數列的前六個數字分別爲：1、1、2、3、5、8。
+
+比如，`sumFibs(10)` 應該返回 `10`。 因爲斐波那契數列中，比 `10` 小的數字只有 1、1、3、5。
+
+# --hints--
+
+`sumFibs(1)` 應返回一個數字。
+
+```js
+assert(typeof sumFibs(1) === 'number');
+```
+
+`sumFibs(1000)` 應返回 1785。
+
+```js
+assert(sumFibs(1000) === 1785);
+```
+
+`sumFibs(4000000)` 應返回 4613732。
+
+```js
+assert(sumFibs(4000000) === 4613732);
+```
+
+`sumFibs(4)` 應返回 5。
+
+```js
+assert(sumFibs(4) === 5);
+```
+
+`sumFibs(75024)` 應返回 60696。
+
+```js
+assert(sumFibs(75024) === 60696);
+```
+
+`sumFibs(75025)` 應返回 135721。
+
+```js
+assert(sumFibs(75025) === 135721);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function sumFibs(num) {
+ return num;
+}
+
+sumFibs(4);
+```
+
+# --solutions--
+
+```js
+function sumFibs(num) {
+ var a = 1;
+ var b = 1;
+ var s = 0;
+ while (a <= num) {
+ if (a % 2 !== 0) {
+ s += a;
+ }
+ a = [b, b=b+a][0];
+ }
+ return s;
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/sum-all-primes.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/sum-all-primes.md
new file mode 100644
index 0000000000..73ce334b19
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/sum-all-primes.md
@@ -0,0 +1,75 @@
+---
+id: a3bfc1673c0526e06d3ac698
+title: 質數求和
+challengeType: 5
+forumTopicId: 16085
+dashedName: sum-all-primes
+---
+
+# --description--
+
+質數（prime number ）是大於 1 且僅可以被 1 和自己整除的數。 比如，2 就是一個質數，因爲它只可以被 1 和 2（它本身）整除。 相反，4 不是質數，因爲它可以被 1, 2 和 4 整除。
+
+請完成 `sumPrimes` 方法，使其返回小於等於傳入參數數字的所有質數之和。
+
+# --hints--
+
+`sumPrimes(10)` 應返回一個數字。
+
+```js
+assert.deepEqual(typeof sumPrimes(10), 'number');
+```
+
+`sumPrimes(10)` 應返回 17。
+
+```js
+assert.deepEqual(sumPrimes(10), 17);
+```
+
+`sumPrimes(977)` 應返回 73156。
+
+```js
+assert.deepEqual(sumPrimes(977), 73156);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function sumPrimes(num) {
+ return num;
+}
+
+sumPrimes(10);
+```
+
+# --solutions--
+
+```js
+function eratosthenesArray(n) {
+ var primes = [];
+ if (n > 2) {
+ var half = n>>1;
+ var sieve = Array(half);
+ for (var i = 1, limit = Math.sqrt(n)>>1; i <= limit; i++) {
+ if (!sieve[i]) {
+ for (var step = 2*i+1, j = (step*step)>>1; j < half; j+=step) {
+ sieve[j] = true;
+ }
+ }
+ }
+ primes.push(2);
+ for (var p = 1; p < half; p++) {
+ if (!sieve[p]) primes.push(2*p+1);
+ }
+ }
+ return primes;
+}
+
+function sumPrimes(num) {
+ return eratosthenesArray(num+1).reduce(function(a,b) {return a+b;}, 0);
+}
+
+sumPrimes(10);
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/wherefore-art-thou.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/wherefore-art-thou.md
new file mode 100644
index 0000000000..8eef2dc2a1
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/wherefore-art-thou.md
@@ -0,0 +1,130 @@
+---
+id: a8e512fbe388ac2f9198f0fa
+title: 找出包含特定鍵值對的對象
+challengeType: 5
+forumTopicId: 16092
+dashedName: wherefore-art-thou
+---
+
+# --description--
+
+創建一個查看對象數組（第一個參數）的函數，並返回具有匹配的名稱和值對的所有對象的數組（第二個參數）。 如果要包含在返回的數組中，則源對象的每個名稱和值對都必須存在於集合中的對象中。
+
+比如，如果第一個參數是 `[{ first: "Romeo", last: "Montague" }, { first: "Mercutio", last: null }, { first: "Tybalt", last: "Capulet" }]`，第二個參數是 `{ last: "Capulet" }`。
+
+# --hints--
+
+`whatIsInAName([{ first: "Romeo", last: "Montague" }, { first: "Mercutio", last: null }, { first: "Tybalt", last: "Capulet" }], { last: "Capulet" })` 應返回 `[{ first: "Tybalt", last: "Capulet" }]`。
+
+```js
+assert.deepEqual(
+ whatIsInAName(
+ [
+ { first: 'Romeo', last: 'Montague' },
+ { first: 'Mercutio', last: null },
+ { first: 'Tybalt', last: 'Capulet' }
+ ],
+ { last: 'Capulet' }
+ ),
+ [{ first: 'Tybalt', last: 'Capulet' }]
+);
+```
+
+`whatIsInAName([{ "apple": 1 }, { "apple": 1 }, { "apple": 1, "bat": 2 }], { "apple": 1 })` 應返回 `[{ "apple": 1 }, { "apple": 1 }, { "apple": 1, "bat": 2 }]`。
+
+```js
+assert.deepEqual(
+ whatIsInAName([{ apple: 1 }, { apple: 1 }, { apple: 1, bat: 2 }], {
+ apple: 1
+ }),
+ [{ apple: 1 }, { apple: 1 }, { apple: 1, bat: 2 }]
+);
+```
+
+`whatIsInAName([{ "apple": 1, "bat": 2 }, { "bat": 2 }, { "apple": 1, "bat": 2, "cookie": 2 }], { "apple": 1, "bat": 2 })` 應返回 `[{ "apple": 1, "bat": 2 }, { "apple": 1, "bat": 2, "cookie": 2 }]`。
+
+```js
+assert.deepEqual(
+ whatIsInAName(
+ [{ apple: 1, bat: 2 }, { bat: 2 }, { apple: 1, bat: 2, cookie: 2 }],
+ { apple: 1, bat: 2 }
+ ),
+ [
+ { apple: 1, bat: 2 },
+ { apple: 1, bat: 2, cookie: 2 }
+ ]
+);
+```
+
+`whatIsInAName([{ "apple": 1, "bat": 2 }, { "apple": 1 }, { "apple": 1, "bat": 2, "cookie": 2 }], { "apple": 1, "cookie": 2 })` 應返回 `[{ "apple": 1, "bat": 2, "cookie": 2 }]`。
+
+```js
+assert.deepEqual(
+ whatIsInAName(
+ [{ apple: 1, bat: 2 }, { apple: 1 }, { apple: 1, bat: 2, cookie: 2 }],
+ { apple: 1, cookie: 2 }
+ ),
+ [{ apple: 1, bat: 2, cookie: 2 }]
+);
+```
+
+`whatIsInAName([{ "apple": 1, "bat": 2 }, { "apple": 1 }, { "apple": 1, "bat": 2, "cookie": 2 }, { "bat":2 }], { "apple": 1, "bat": 2 })` 應返回 `[{ "apple": 1, "bat": 2 }, { "apple": 1, "bat": 2, "cookie":2 }]`。
+
+```js
+assert.deepEqual(
+ whatIsInAName(
+ [
+ { apple: 1, bat: 2 },
+ { apple: 1 },
+ { apple: 1, bat: 2, cookie: 2 },
+ { bat: 2 }
+ ],
+ { apple: 1, bat: 2 }
+ ),
+ [
+ { apple: 1, bat: 2 },
+ { apple: 1, bat: 2, cookie: 2 }
+ ]
+);
+```
+
+`whatIsInAName([{"a": 1, "b": 2, "c": 3}], {"a": 1, "b": 9999, "c": 3})` 應返回 `[]`。
+
+```js
+assert.deepEqual(
+ whatIsInAName([{ a: 1, b: 2, c: 3 }], { a: 1, b: 9999, c: 3 }),
+ []
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function whatIsInAName(collection, source) {
+ var arr = [];
+ // Only change code below this line
+
+
+ // Only change code above this line
+ return arr;
+}
+
+whatIsInAName([{ first: "Romeo", last: "Montague" }, { first: "Mercutio", last: null }, { first: "Tybalt", last: "Capulet" }], { last: "Capulet" });
+```
+
+# --solutions--
+
+```js
+function whatIsInAName(collection, source) {
+ var arr = [];
+ var keys = Object.keys(source);
+ collection.forEach(function(e) {
+ if(keys.every(function(key) {return e[key] === source[key];})) {
+ arr.push(e);
+ }
+ });
+ return arr;
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/javascript-algorithms-and-data-structures-projects/caesars-cipher.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/javascript-algorithms-and-data-structures-projects/caesars-cipher.md
new file mode 100644
index 0000000000..0348981cd0
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/javascript-algorithms-and-data-structures-projects/caesars-cipher.md
@@ -0,0 +1,89 @@
+---
+id: 56533eb9ac21ba0edf2244e2
+title: 凱撒密碼
+challengeType: 5
+forumTopicId: 16003
+dashedName: caesars-cipher
+---
+
+# --description--
+
+凱撒密碼（ Caesar cipher ）是最簡單且最廣爲人知的密碼（ciphers ），也被稱爲移位密碼（shift cipher ）。 在移位密碼中，明文中的字母通過按照一個固定數目進行偏移後被替換成新的字母。
+
+[ROT13](https://en.wikipedia.org/wiki/ROT13) 是一個被廣泛使用的加密技術，明文中的所有字母都被移動 13 位。 也就是， `A ↔ N`，`B ↔ O` 等等。
+
+編寫一個函數，它將 [ROT13](https://en.wikipedia.org/wiki/ROT13) 編碼的字符串作爲輸入並返回解碼字符串。
+
+所有解碼後的字母都必須爲字母大寫。 請不要解碼非字母的字符（例如，空格、標點符號），但你需要在結果中保留它們。
+
+# --hints--
+
+`rot13("SERR PBQR PNZC")` 應解碼爲 `FREE CODE CAMP`
+
+```js
+assert(rot13('SERR PBQR PNZC') === 'FREE CODE CAMP');
+```
+
+`rot13("SERR CVMMN!")` 應解碼爲 `FREE PIZZA!`
+
+```js
+assert(rot13('SERR CVMMN!') === 'FREE PIZZA!');
+```
+
+`rot13("SERR YBIR?")` 應解碼爲 `FREE LOVE?`
+
+```js
+assert(rot13('SERR YBIR?') === 'FREE LOVE?');
+```
+
+`rot13("GUR DHVPX OEBJA SBK WHZCF BIRE GUR YNML QBT.")` 應解碼爲 `THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG.`
+
+```js
+assert(
+ rot13('GUR DHVPX OEBJA SBK WHZCF BIRE GUR YNML QBT.') ===
+ 'THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG.'
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function rot13(str) {
+
+ return str;
+}
+
+rot13("SERR PBQR PNZC");
+```
+
+# --solutions--
+
+```js
+var lookup = {
+ 'A': 'N','B': 'O','C': 'P','D': 'Q',
+ 'E': 'R','F': 'S','G': 'T','H': 'U',
+ 'I': 'V','J': 'W','K': 'X','L': 'Y',
+ 'M': 'Z','N': 'A','O': 'B','P': 'C',
+ 'Q': 'D','R': 'E','S': 'F','T': 'G',
+ 'U': 'H','V': 'I','W': 'J','X': 'K',
+ 'Y': 'L','Z': 'M'
+};
+
+function rot13(encodedStr) {
+ var codeArr = encodedStr.split(""); // String to Array
+ var decodedArr = []; // Your Result goes here
+ // Only change code below this line
+
+ decodedArr = codeArr.map(function(letter) {
+ if(lookup.hasOwnProperty(letter)) {
+ letter = lookup[letter];
+ }
+ return letter;
+ });
+
+ // Only change code above this line
+ return decodedArr.join(""); // Array to String
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/javascript-algorithms-and-data-structures-projects/cash-register.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/javascript-algorithms-and-data-structures-projects/cash-register.md
new file mode 100644
index 0000000000..ae714a7516
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/javascript-algorithms-and-data-structures-projects/cash-register.md
@@ -0,0 +1,249 @@
+---
+id: aa2e6f85cab2ab736c9a9b24
+title: 計算找零
+challengeType: 5
+forumTopicId: 16012
+dashedName: cash-register
+---
+
+# --description--
+
+請編寫一個用於收銀機的函數 `checkCashRegister()`：它的第一個參數爲售價 `price`、第二個參數爲支付金額 `cash`、第三個參數爲收銀機內的金額 `cid`。
+
+`cid` 是包含貨幣面值的二維數組。
+
+函數 `checkCashRegister()` 應返回含有 `status` 屬性和 `change` 屬性的對象。
+
+如果收銀機內的金額少於應找回的零錢數，或者你無法返回確切的數目時，返回 `{status: "INSUFFICIENT_FUNDS", change: []}`。
+
+如果收銀機內的金額恰好等於應找回的零錢數，返回 `{status: "CLOSED", change: [...]}`，其中 `change` 的屬性值就是收銀機內的金額。
+
+否則，返回 `{status: "OPEN", change: [...]}`，其中 `change` 鍵值是應找回的零錢數，並將找零的面值由高到低排序。
+
+ 貨幣單位 Unit 面值 Penny 0.01 美元（PENNY） Nickel 0.05 美元（NICKEL） Dime 0.1 美元（DIME） Quarter 0.25 美元（QUARTER） Dollar 1 美元（ONE） Five Dollars 5 美元（五） Ten Dollars 10 美元（TEN） Twenty Dollars 20 美元（TWENTY） One-hundred Dollars 100美元（ONE HUNDRED）
+
+下面的抽屜裏現金數組示例：
+
+```js
+[
+ ["PENNY", 1.01],
+ ["NICKEL", 2.05],
+ ["DIME", 3.1],
+ ["QUARTER", 4.25],
+ ["ONE", 90],
+ ["FIVE", 55],
+ ["TEN", 20],
+ ["TWENTY", 60],
+ ["ONE HUNDRED", 100]
+]
+```
+
+# --hints--
+
+`checkCashRegister(19.5, 20, [["PENNY", 1.01], ["NICKEL", 2.05], ["DIME", 3.1], ["QUARTER", 4.25], ["ONE", 90], ["FIVE", 55], ["TEN", 20], ["TWENTY", 60], ["ONE HUNDRED", 100]])` 應返回一個對象。
+
+```js
+assert.deepEqual(
+ Object.prototype.toString.call(
+ checkCashRegister(19.5, 20, [
+ ['PENNY', 1.01],
+ ['NICKEL', 2.05],
+ ['DIME', 3.1],
+ ['QUARTER', 4.25],
+ ['ONE', 90],
+ ['FIVE', 55],
+ ['TEN', 20],
+ ['TWENTY', 60],
+ ['ONE HUNDRED', 100]
+ ])
+ ),
+ '[object Object]'
+);
+```
+
+`checkCashRegister(19.5, 20, [["PENNY", 1.01], ["NICKEL", 2.05], ["DIME", 3.1], ["QUARTER", 4.25], ["ONE", 90], ["FIVE", 55], ["TEN", 20], ["TWENTY", 60], ["ONE HUNDRED", 100]])` 應返回 `{status: "OPEN", change: [["QUARTER", 0.5]]}`。
+
+```js
+assert.deepEqual(
+ checkCashRegister(19.5, 20, [
+ ['PENNY', 1.01],
+ ['NICKEL', 2.05],
+ ['DIME', 3.1],
+ ['QUARTER', 4.25],
+ ['ONE', 90],
+ ['FIVE', 55],
+ ['TEN', 20],
+ ['TWENTY', 60],
+ ['ONE HUNDRED', 100]
+ ]),
+ { status: 'OPEN', change: [['QUARTER', 0.5]] }
+);
+```
+
+`checkCashRegister(3.26, 100, [["PENNY", 1.01], ["NICKEL", 2.05], ["DIME", 3.1], ["QUARTER", 4.25], ["ONE", 90], ["FIVE", 55], ["TEN", 20], ["TWENTY", 60], ["ONE HUNDRED", 100]])` 應返回 `{status: "OPEN", change: [["TWENTY", 60], ["TEN", 20], ["FIVE", 15], ["ONE", 1], ["QUARTER", 0.5], ["DIME", 0.2], ["PENNY", 0.04]]}`。
+
+```js
+assert.deepEqual(
+ checkCashRegister(3.26, 100, [
+ ['PENNY', 1.01],
+ ['NICKEL', 2.05],
+ ['DIME', 3.1],
+ ['QUARTER', 4.25],
+ ['ONE', 90],
+ ['FIVE', 55],
+ ['TEN', 20],
+ ['TWENTY', 60],
+ ['ONE HUNDRED', 100]
+ ]),
+ {
+ status: 'OPEN',
+ change: [
+ ['TWENTY', 60],
+ ['TEN', 20],
+ ['FIVE', 15],
+ ['ONE', 1],
+ ['QUARTER', 0.5],
+ ['DIME', 0.2],
+ ['PENNY', 0.04]
+ ]
+ }
+);
+```
+
+`checkCashRegister(19.5, 20, [["PENNY", 0.01], ["NICKEL", 0], ["DIME", 0], ["QUARTER", 0], ["ONE", 0], ["FIVE", 0], ["TEN", 0], ["TWENTY", 0], ["ONE HUNDRED", 0]])` 應返回 `{status: "INSUFFICIENT_FUNDS", change: []}`。
+
+```js
+assert.deepEqual(
+ checkCashRegister(19.5, 20, [
+ ['PENNY', 0.01],
+ ['NICKEL', 0],
+ ['DIME', 0],
+ ['QUARTER', 0],
+ ['ONE', 0],
+ ['FIVE', 0],
+ ['TEN', 0],
+ ['TWENTY', 0],
+ ['ONE HUNDRED', 0]
+ ]),
+ { status: 'INSUFFICIENT_FUNDS', change: [] }
+);
+```
+
+`checkCashRegister(19.5, 20, [["PENNY", 0.01], ["NICKEL", 0], ["DIME", 0], ["QUARTER", 0], ["ONE", 1], ["FIVE", 0], ["TEN", 0], ["TWENTY", 0], ["ONE HUNDRED", 0]])` 應返回 `{status: "INSUFFICIENT_FUNDS", change: []}`。
+
+```js
+assert.deepEqual(
+ checkCashRegister(19.5, 20, [
+ ['PENNY', 0.01],
+ ['NICKEL', 0],
+ ['DIME', 0],
+ ['QUARTER', 0],
+ ['ONE', 1],
+ ['FIVE', 0],
+ ['TEN', 0],
+ ['TWENTY', 0],
+ ['ONE HUNDRED', 0]
+ ]),
+ { status: 'INSUFFICIENT_FUNDS', change: [] }
+);
+```
+
+`checkCashRegister(19.5, 20, [["PENNY", 0.5], ["NICKEL", 0], ["DIME", 0], ["QUARTER", 0], ["ONE", 0], ["FIVE", 0], ["TEN", 0], ["TWENTY", 0], ["ONE HUNDRED", 0]])` 應返回 `{status: "CLOSED", change: [["PENNY", 0.5], ["NICKEL", 0], ["DIME", 0], ["QUARTER", 0], ["ONE", 0], ["FIVE", 0], ["TEN", 0], ["TWENTY", 0], ["ONE HUNDRED", 0]]}`。
+
+```js
+assert.deepEqual(
+ checkCashRegister(19.5, 20, [
+ ['PENNY', 0.5],
+ ['NICKEL', 0],
+ ['DIME', 0],
+ ['QUARTER', 0],
+ ['ONE', 0],
+ ['FIVE', 0],
+ ['TEN', 0],
+ ['TWENTY', 0],
+ ['ONE HUNDRED', 0]
+ ]),
+ {
+ status: 'CLOSED',
+ change: [
+ ['PENNY', 0.5],
+ ['NICKEL', 0],
+ ['DIME', 0],
+ ['QUARTER', 0],
+ ['ONE', 0],
+ ['FIVE', 0],
+ ['TEN', 0],
+ ['TWENTY', 0],
+ ['ONE HUNDRED', 0]
+ ]
+ }
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function checkCashRegister(price, cash, cid) {
+ var change;
+ return change;
+}
+
+checkCashRegister(19.5, 20, [["PENNY", 1.01], ["NICKEL", 2.05], ["DIME", 3.1], ["QUARTER", 4.25], ["ONE", 90], ["FIVE", 55], ["TEN", 20], ["TWENTY", 60], ["ONE HUNDRED", 100]]);
+```
+
+# --solutions--
+
+```js
+var denom = [
+ { name: 'ONE HUNDRED', val: 100},
+ { name: 'TWENTY', val: 20},
+ { name: 'TEN', val: 10},
+ { name: 'FIVE', val: 5},
+ { name: 'ONE', val: 1},
+ { name: 'QUARTER', val: 0.25},
+ { name: 'DIME', val: 0.1},
+ { name: 'NICKEL', val: 0.05},
+ { name: 'PENNY', val: 0.01}
+];
+
+function checkCashRegister(price, cash, cid) {
+ var output = {status: null, change: []};
+ var change = cash - price;
+ var register = cid.reduce(function(acc, curr) {
+ acc.total += curr[1];
+ acc[curr[0]] = curr[1];
+ return acc;
+ }, {total: 0});
+ if(register.total === change) {
+ output.status = 'CLOSED';
+ output.change = cid;
+ return output;
+ }
+ if(register.total < change) {
+ output.status = 'INSUFFICIENT_FUNDS';
+ return output;
+ }
+ var change_arr = denom.reduce(function(acc, curr) {
+ var value = 0;
+ while(register[curr.name] > 0 && change >= curr.val) {
+ change -= curr.val;
+ register[curr.name] -= curr.val;
+ value += curr.val;
+ change = Math.round(change * 100) / 100;
+ }
+ if(value > 0) {
+ acc.push([ curr.name, value ]);
+ }
+ return acc;
+ }, []);
+ if(change_arr.length < 1 || change > 0) {
+ output.status = 'INSUFFICIENT_FUNDS';
+ return output;
+ }
+ output.status = 'OPEN';
+ output.change = change_arr;
+ return output;
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/javascript-algorithms-and-data-structures-projects/palindrome-checker.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/javascript-algorithms-and-data-structures-projects/palindrome-checker.md
new file mode 100644
index 0000000000..fc5a19b8e7
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/javascript-algorithms-and-data-structures-projects/palindrome-checker.md
@@ -0,0 +1,127 @@
+---
+id: aaa48de84e1ecc7c742e1124
+title: 迴文檢查器
+challengeType: 5
+forumTopicId: 16004
+dashedName: palindrome-checker
+---
+
+# --description--
+
+如果傳入的字符串是迴文字符串，則返回 `true`。 否則返回 `false`
+
+迴文 palindrome ，指在忽略標點符號、大小寫和空格的前提下，正着讀和反着讀一模一樣。
+
+**注意：**檢查迴文時，你需要先去除**所有非字母數字的字符**（標點、空格和符號），並將所有字母都轉換成大寫或都轉換成小寫。
+
+我們會傳入具有不同格式的字符串，如 `racecar`、`RaceCar` 和 `race CAR` 等等。
+
+我們也會傳入一些包含特殊符號的字符串，例如 `2A3*3a2`、`2A3 3a2`、`2_A3*3#A2`。
+
+# --hints--
+
+`palindrome("eye")` 應返回一個布爾值。
+
+```js
+assert(typeof palindrome('eye') === 'boolean');
+```
+
+`palindrome("eye")` 應返回 `true`。
+
+```js
+assert(palindrome('eye') === true);
+```
+
+`palindrome("_eye")` 應返回 `true`。
+
+```js
+assert(palindrome('_eye') === true);
+```
+
+`palindrome("race car")` 應返回 `true`。
+
+```js
+assert(palindrome('race car') === true);
+```
+
+`palindrome("not a palindrome")` 應返回 `false`。
+
+```js
+assert(palindrome('not a palindrome') === false);
+```
+
+`palindrome("A man, a plan, a canal. Panama")` 應返回 `true`。
+
+```js
+assert(palindrome('A man, a plan, a canal. Panama') === true);
+```
+
+`palindrome("never odd or even")` 應返回 `true`。
+
+```js
+assert(palindrome('never odd or even') === true);
+```
+
+`palindrome("nope")` 應該返回 `false`。
+
+```js
+assert(palindrome('nope') === false);
+```
+
+`palindrome("almostomla")` 應返回 `false`。
+
+```js
+assert(palindrome('almostomla') === false);
+```
+
+`palindrome("My age is 0, 0 si ega ym.")` 應返回 `true`。
+
+```js
+assert(palindrome('My age is 0, 0 si ega ym.') === true);
+```
+
+`palindrome("1 eye for of 1 eye.")` 應返回 `false`。
+
+```js
+assert(palindrome('1 eye for of 1 eye.') === false);
+```
+
+`palindrome("0_0 (: /-\ :) 0-0")` 應返回 `true`。
+
+```js
+assert(palindrome('0_0 (: /- :) 0-0') === true);
+```
+
+`palindrome("five|\_/|four")` 應返回 `false`。
+
+```js
+assert(palindrome('five|_/|four') === false);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function palindrome(str) {
+ return true;
+}
+
+
+
+palindrome("eye");
+```
+
+# --solutions--
+
+```js
+function palindrome(str) {
+ var string = str.toLowerCase().split(/[^A-Za-z0-9]/gi).join('');
+ var aux = string.split('');
+ if (aux.join('') === aux.reverse().join('')){
+ return true;
+ }
+
+ return false;
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/javascript-algorithms-and-data-structures-projects/roman-numeral-converter.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/javascript-algorithms-and-data-structures-projects/roman-numeral-converter.md
new file mode 100644
index 0000000000..6b006547bc
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/javascript-algorithms-and-data-structures-projects/roman-numeral-converter.md
@@ -0,0 +1,199 @@
+---
+id: a7f4d8f2483413a6ce226cac
+title: 羅馬數字轉換器
+challengeType: 5
+forumTopicId: 16044
+dashedName: roman-numeral-converter
+---
+
+# --description--
+
+把傳入的數字轉爲羅馬數字。
+
+轉換後的[羅馬數字](http://www.mathsisfun.com/roman-numerals.html)字母必須都是大寫。
+
+# --hints--
+
+`convertToRoman(2)` 應該返回字符串 `II`。
+
+```js
+assert.deepEqual(convertToRoman(2), 'II');
+```
+
+`convertToRoman(3)` 應該返回字符串 `III`。
+
+```js
+assert.deepEqual(convertToRoman(3), 'III');
+```
+
+`convertToRoman(4)` 應該返回字符串 `IV`。
+
+```js
+assert.deepEqual(convertToRoman(4), 'IV');
+```
+
+`convertToRoman(5)` 應該返回字符串 `V`。
+
+```js
+assert.deepEqual(convertToRoman(5), 'V');
+```
+
+`convertToRoman(9)` 應該返回字符串 `IX`。
+
+```js
+assert.deepEqual(convertToRoman(9), 'IX');
+```
+
+`convertToRoman(12)` 應該返回字符串 `XII`。
+
+```js
+assert.deepEqual(convertToRoman(12), 'XII');
+```
+
+`convertToRoman(16)` 應該返回字符串 `XVI`。
+
+```js
+assert.deepEqual(convertToRoman(16), 'XVI');
+```
+
+`convertToRoman(29)` 應該返回字符串 `XXIX`。
+
+```js
+assert.deepEqual(convertToRoman(29), 'XXIX');
+```
+
+`convertToRoman(44)` 應該返回字符串 `XLIV`.
+
+```js
+assert.deepEqual(convertToRoman(44), 'XLIV');
+```
+
+`convertToRoman(45)` 應該返回字符串 `XLV`。
+
+```js
+assert.deepEqual(convertToRoman(45), 'XLV');
+```
+
+`convertToRoman(68)` 應該返回字符串 `LXVIII`
+
+```js
+assert.deepEqual(convertToRoman(68), 'LXVIII');
+```
+
+`convertToRoman(83)` 應該返回字符串 `LXXXIII`
+
+```js
+assert.deepEqual(convertToRoman(83), 'LXXXIII');
+```
+
+`convertToRoman(97)` 應該返回字符串 `XCVII`
+
+```js
+assert.deepEqual(convertToRoman(97), 'XCVII');
+```
+
+`convertToRoman(99)` 應該返回字符串 `XCIX`
+
+```js
+assert.deepEqual(convertToRoman(99), 'XCIX');
+```
+
+`convertToRoman(400)` 應該返回字符串 `CD`
+
+```js
+assert.deepEqual(convertToRoman(400), 'CD');
+```
+
+`convertToRoman(500)` 應該返回字符串 `D`
+
+```js
+assert.deepEqual(convertToRoman(500), 'D');
+```
+
+`convertToRoman(501)` 應該返回字符串 `DI`
+
+```js
+assert.deepEqual(convertToRoman(501), 'DI');
+```
+
+`convertToRoman(649)` 應該返回字符串 `DCXLIX`
+
+```js
+assert.deepEqual(convertToRoman(649), 'DCXLIX');
+```
+
+`convertToRoman(798)` 應該返回字符串 `DCCXCVIII`
+
+```js
+assert.deepEqual(convertToRoman(798), 'DCCXCVIII');
+```
+
+`convertToRoman(891)` 應該返回字符串 `DCCCXCI`
+
+```js
+assert.deepEqual(convertToRoman(891), 'DCCCXCI');
+```
+
+`convertToRoman(1000)` 應該返回字符串 `M`
+
+```js
+assert.deepEqual(convertToRoman(1000), 'M');
+```
+
+`convertToRoman(1004)` 應該返回字符串 `MIV`
+
+```js
+assert.deepEqual(convertToRoman(1004), 'MIV');
+```
+
+`convertToRoman(1006)` 應該返回字符串 `MVI`
+
+```js
+assert.deepEqual(convertToRoman(1006), 'MVI');
+```
+
+`convertToRoman(1023)` 應該返回字符串 `MXXIII`
+
+```js
+assert.deepEqual(convertToRoman(1023), 'MXXIII');
+```
+
+`convertToRoman(2014)` 應該返回字符串 `MMXIV`
+
+```js
+assert.deepEqual(convertToRoman(2014), 'MMXIV');
+```
+
+`convertToRoman(3999)` 應該返回字符串 `MMMCMXCIX`
+
+```js
+assert.deepEqual(convertToRoman(3999), 'MMMCMXCIX');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function convertToRoman(num) {
+ return num;
+}
+
+convertToRoman(36);
+```
+
+# --solutions--
+
+```js
+function convertToRoman(num) {
+ var ref = [['M', 1000], ['CM', 900], ['D', 500], ['CD', 400], ['C', 100], ['XC', 90], ['L', 50], ['XL', 40], ['X', 10], ['IX', 9], ['V', 5], ['IV', 4], ['I', 1]];
+ var res = [];
+ ref.forEach(function(p) {
+ while (num >= p[1]) {
+ res.push(p[0]);
+ num -= p[1];
+ }
+ });
+ return res.join('');
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/javascript-algorithms-and-data-structures-projects/telephone-number-validator.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/javascript-algorithms-and-data-structures-projects/telephone-number-validator.md
new file mode 100644
index 0000000000..0cbe1c4c60
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/javascript-algorithms-and-data-structures-projects/telephone-number-validator.md
@@ -0,0 +1,205 @@
+---
+id: aff0395860f5d3034dc0bfc9
+title: 電話號碼檢查器
+challengeType: 5
+forumTopicId: 16090
+dashedName: telephone-number-validator
+---
+
+# --description--
+
+如果傳入的字符串是一個有效的美國電話號碼格式，則返回 `true`。
+
+只要是有效的美國電話號碼的格式，用戶可以按照他們的方式填寫表單中的電話號碼。 以下是一些正確的例子（其他格式變形請參考以下例子）：
+
+555-555-5555
+
+在這個挑戰中，參數可能是 `800-692-7753` 或者 `8oo-six427676;laskdjf` 的號碼。 你的任務是根據上面不同的格式組合，判斷它是否爲有效的電話號碼。 其中，地區碼（電話號碼中的前三位）是必須的。 如果提供國家代碼，則國家代碼只能爲 `1`。 如果傳入的參數是有效的美國電話號碼就返回 `true`，否則返回 `false`。
+
+# --hints--
+
+`telephoneCheck("555-555-5555")` 應返回一個布爾值。
+
+```js
+assert(typeof telephoneCheck('555-555-5555') === 'boolean');
+```
+
+`telephoneCheck("1 555-555-5555")` 應返回 `true`。
+
+```js
+assert(telephoneCheck('1 555-555-5555') === true);
+```
+
+`telephoneCheck("1 (555) 555-5555")` 應返回 `true`。
+
+```js
+assert(telephoneCheck('1 (555) 555-5555') === true);
+```
+
+`telephoneCheck("5555555555")` 應返回 `true`。
+
+```js
+assert(telephoneCheck('5555555555') === true);
+```
+
+`telephoneCheck("555-555-5555")` 應返回 `true`。
+
+```js
+assert(telephoneCheck('555-555-5555') === true);
+```
+
+`telephoneCheck("(555)555-5555")` 應返回 `true`。
+
+```js
+assert(telephoneCheck('(555)555-5555') === true);
+```
+
+`telephoneCheck("1(555)555-5555")` 應返回 `true`。
+
+```js
+assert(telephoneCheck('1(555)555-5555') === true);
+```
+
+`telephoneCheck("555-5555")` 應返回 `false`。
+
+```js
+assert(telephoneCheck('555-5555') === false);
+```
+
+`telephoneCheck("5555555")` 應返回 `false`。
+
+```js
+assert(telephoneCheck('5555555') === false);
+```
+
+`telephoneCheck("1 555)555-5555")` 應返回 `false`。
+
+```js
+assert(telephoneCheck('1 555)555-5555') === false);
+```
+
+`telephoneCheck("1 555 555 5555")` 應返回 `true`。
+
+```js
+assert(telephoneCheck('1 555 555 5555') === true);
+```
+
+`telephoneCheck("1 456 789 4444")` 應返回 `true`。
+
+```js
+assert(telephoneCheck('1 456 789 4444') === true);
+```
+
+`telephoneCheck("123**&!!asdf#")` 應返回 `false`。
+
+```js
+assert(telephoneCheck('123**&!!asdf#') === false);
+```
+
+`telephoneCheck("55555555")` 應返回 `false`。
+
+```js
+assert(telephoneCheck('55555555') === false);
+```
+
+`telephoneCheck("(6054756961)")` 應返回 `false`。
+
+```js
+assert(telephoneCheck('(6054756961)') === false);
+```
+
+`telephoneCheck("2 (757) 622-7382")` 應返回 `false`。
+
+```js
+assert(telephoneCheck('2 (757) 622-7382') === false);
+```
+
+`telephoneCheck("0 (757) 622-7382")` 應返回 `false`。
+
+```js
+assert(telephoneCheck('0 (757) 622-7382') === false);
+```
+
+`telephoneCheck("-1 (757) 622-7382")` 應返回 `false`。
+
+```js
+assert(telephoneCheck('-1 (757) 622-7382') === false);
+```
+
+`telephoneCheck("2 757 622-7382")` 應返回 `false`。
+
+```js
+assert(telephoneCheck('2 757 622-7382') === false);
+```
+
+`telephoneCheck("10 (757) 622-7382")` 應返回 `false`。
+
+```js
+assert(telephoneCheck('10 (757) 622-7382') === false);
+```
+
+`telephoneCheck("27576227382")` 應返回 `false`。
+
+```js
+assert(telephoneCheck('27576227382') === false);
+```
+
+`telephoneCheck("(275)76227382")` 應返回 `false`。
+
+```js
+assert(telephoneCheck('(275)76227382') === false);
+```
+
+`telephoneCheck("2(757)6227382")` 應返回 `false`。
+
+```js
+assert(telephoneCheck('2(757)6227382') === false);
+```
+
+`telephoneCheck("2(757)622-7382")` 應返回 `false`。
+
+```js
+assert(telephoneCheck('2(757)622-7382') === false);
+```
+
+`telephoneCheck("555)-555-5555")` 應返回 `false`。
+
+```js
+assert(telephoneCheck('555)-555-5555') === false);
+```
+
+`telephoneCheck("(555-555-5555")` 應返回 `false`。
+
+```js
+assert(telephoneCheck('(555-555-5555') === false);
+```
+
+`telephoneCheck("(555)5(55?)-5555")` 應返回 `false`。
+
+```js
+assert(telephoneCheck('(555)5(55?)-5555') === false);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function telephoneCheck(str) {
+ return true;
+}
+
+telephoneCheck("555-555-5555");
+```
+
+# --solutions--
+
+```js
+var re = /^([+]?1[\s]?)?((?:[(](?:[2-9]1[02-9]|[2-9][02-8][0-9])[)][\s]?)|(?:(?:[2-9]1[02-9]|[2-9][02-8][0-9])[\s.-]?)){1}([2-9]1[02-9]|[2-9][02-9]1|[2-9][02-9]{2}[\s.-]?){1}([0-9]{4}){1}$/;
+
+function telephoneCheck(str) {
+ return re.test(str);
+}
+
+telephoneCheck("555-555-5555");
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/object-oriented-programming/add-methods-after-inheritance.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/object-oriented-programming/add-methods-after-inheritance.md
new file mode 100644
index 0000000000..3126f34c36
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/object-oriented-programming/add-methods-after-inheritance.md
@@ -0,0 +1,133 @@
+---
+id: 587d7db1367417b2b2512b87
+title: 繼承後添加方法
+challengeType: 1
+forumTopicId: 301315
+dashedName: add-methods-after-inheritance
+---
+
+# --description--
+
+從超類構造函數繼承其 `prototype` 對象的構造函數，除了繼承的方法外，還可以擁有自己的方法。
+
+請看舉例：`Bird` 是一個構造函數，它繼承了 `Animal` 的 `prototype`：
+
+```js
+function Animal() { }
+Animal.prototype.eat = function() {
+ console.log("nom nom nom");
+};
+function Bird() { }
+Bird.prototype = Object.create(Animal.prototype);
+Bird.prototype.constructor = Bird;
+```
+
+除了從 `Animal` 構造函數繼承的行爲之外，還需要給 `Bird` 對象添加它獨有的行爲。 這裏，我們給 `Bird` 對象添加一個 `fly()` 函數。 函數會以一種與其他構造函數相同的方式添加到 `Bird's` 的 `prototype` 中：
+
+```js
+Bird.prototype.fly = function() {
+ console.log("I'm flying!");
+};
+```
+
+現在 `Bird` 的實例中就有了 `eat()` 和 `fly()` 這兩個方法：
+
+```js
+let duck = new Bird();
+duck.eat();
+duck.fly();
+```
+
+`duck.eat()` 將在控制檯中顯示字符串 `nom nom nom`， `duck.fly()` 將顯示字符串 `I'm flying!`。
+
+# --instructions--
+
+添加必要的代碼，使得 `Dog` 對象繼承 `Animal`，並且把 `Dog` 的 `prototype`上的 constructor 屬性設置爲 `Dog`。 然後給 `Dog` 對象添加一個 `bark()` 方法，這樣的話，`beagle` 將同時擁有 `eat()` 和 `bark()` 這兩個方法。 `bark()` 方法中應該輸出 `Woof!` 到控制檯。
+
+# --hints--
+
+`Animal` 應該沒有 `bark()` 方法。
+
+```js
+assert(typeof Animal.prototype.bark == 'undefined');
+```
+
+`Dog` 應該繼承了 `Animal` 的 `eat()` 方法。
+
+```js
+assert(typeof Dog.prototype.eat == 'function');
+```
+
+`Dog` 應該有一個 `bark()` 方法作爲 `own` 屬性。
+
+```js
+assert(Dog.prototype.hasOwnProperty('bark'));
+```
+
+`beagle` 應該是 `Animal` 的一個 `instanceof`。
+
+```js
+assert(beagle instanceof Animal);
+```
+
+`beagle` 的 constructor 屬性應該被設置爲 `Dog`。
+
+```js
+assert(beagle.constructor === Dog);
+```
+
+`beagle.eat()` 應該記錄字符串 `nom nom nom`
+
+```js
+console.log = function (msg) {
+ throw msg;
+};
+assert.throws(() => beagle.eat(), 'nom nom nom');
+```
+
+`beagle.bark()` 應該將字符串 `Woof!` 打印到控制檯
+
+```js
+console.log = function (msg) {
+ throw msg;
+};
+assert.throws(() => beagle.bark(), 'Woof!');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function Animal() { }
+Animal.prototype.eat = function() { console.log("nom nom nom"); };
+
+function Dog() { }
+
+// Only change code below this line
+
+
+
+
+// Only change code above this line
+
+let beagle = new Dog();
+```
+
+# --solutions--
+
+```js
+function Animal() { }
+Animal.prototype.eat = function() { console.log("nom nom nom"); };
+
+function Dog() { }
+Dog.prototype = Object.create(Animal.prototype);
+Dog.prototype.constructor = Dog;
+Dog.prototype.bark = function () {
+ console.log('Woof!');
+};
+let beagle = new Dog();
+
+beagle.eat();
+beagle.bark();
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/object-oriented-programming/change-the-prototype-to-a-new-object.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/object-oriented-programming/change-the-prototype-to-a-new-object.md
new file mode 100644
index 0000000000..4879f135ce
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/object-oriented-programming/change-the-prototype-to-a-new-object.md
@@ -0,0 +1,103 @@
+---
+id: 587d7daf367417b2b2512b7f
+title: 將原型更改爲新對象
+challengeType: 1
+forumTopicId: 301316
+dashedName: change-the-prototype-to-a-new-object
+---
+
+# --description--
+
+到目前爲止，你已經可以單獨給 `prototype` 添加屬性了：
+
+```js
+Bird.prototype.numLegs = 2;
+```
+
+需要添加多個屬性的，這未免會顯得拖沓。
+
+```js
+Bird.prototype.eat = function() {
+ console.log("nom nom nom");
+}
+
+Bird.prototype.describe = function() {
+ console.log("My name is " + this.name);
+}
+```
+
+一種更有效的方法就是給對象的 `prototype` 設置爲一個已經包含了屬性的新對象。 這樣一來，所有屬性都可以一次性添加進來：
+
+```js
+Bird.prototype = {
+ numLegs: 2,
+ eat: function() {
+ console.log("nom nom nom");
+ },
+ describe: function() {
+ console.log("My name is " + this.name);
+ }
+};
+```
+
+# --instructions--
+
+通過給 `prototype` 設置一個對象，在 `Dog` 構造函數的 `prototype` 上添加一個屬性 `numLegs` 以及兩個方法：`eat()` 和 `describe()`。
+
+# --hints--
+
+`Dog.prototype` 應該被設置爲一個新對象。
+
+```js
+assert(/Dog\.prototype\s*?=\s*?{/.test(code));
+```
+
+`Dog.prototype` 應該擁有屬性 `numLegs`。
+
+```js
+assert(Dog.prototype.numLegs !== undefined);
+```
+
+`Dog.prototype` 應該擁有方法 `eat()`。
+
+```js
+assert(typeof Dog.prototype.eat === 'function');
+```
+
+`Dog.prototype` 應該擁有方法 `describe()`。
+
+```js
+assert(typeof Dog.prototype.describe === 'function');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function Dog(name) {
+ this.name = name;
+}
+
+Dog.prototype = {
+ // Only change code below this line
+
+};
+```
+
+# --solutions--
+
+```js
+function Dog(name) {
+ this.name = name;
+}
+Dog.prototype = {
+numLegs: 4,
+ eat () {
+ console.log('nom nom nom');
+ },
+ describe () {
+ console.log('My name is ' + this.name);
+ }
+};
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/object-oriented-programming/create-a-basic-javascript-object.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/object-oriented-programming/create-a-basic-javascript-object.md
new file mode 100644
index 0000000000..cba6085131
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/object-oriented-programming/create-a-basic-javascript-object.md
@@ -0,0 +1,69 @@
+---
+id: 587d7dac367417b2b2512b73
+title: 創建一個基本的 JavaScript 對象
+challengeType: 1
+forumTopicId: 301317
+dashedName: create-a-basic-javascript-object
+---
+
+# --description--
+
+想想我們在生活中每天都可見到的事物：比如汽車、商店以及小鳥等。 它們都是對象 ：即人們可以觀察和與之互動的實體事物。
+
+這些物體的性質是什麼？ 汽車有輪子。 商店銷售物品。 鳥兒有翅膀。
+
+這些特徵，或者說是屬性 定義了一個對象由什麼構成的。 需要注意的是：那些相似的對象可以擁有相同的屬性，但是這些屬性可能會有不同的值。 舉個例子：所有的汽車都有輪子，但並不是所有汽車的輪子個數都是一樣的。
+
+JavaScript 中的對象可以用來描述現實世界中的物體，並賦予他們屬性和行爲，就像它們在現實世界中的對應物一樣。 下面是使用這些概念來創建一個 `duck` 對象的示例：
+
+```js
+let duck = {
+ name: "Aflac",
+ numLegs: 2
+};
+```
+
+這個 `duck` 對象有兩組鍵值對：一個是 `name` 屬性，它的值是 `Aflac`；另一個是 `numLegs` 屬性，它的值是 2。
+
+# --instructions--
+
+創建一個 `dog` 對象，並給這個對象添加兩個屬性：`name` 和 `numLegs`，同時把這兩個屬性的值分別設爲字符串和數字。
+
+# --hints--
+
+`dog` 應該是一個 object。
+
+```js
+assert(typeof dog === 'object');
+```
+
+`dog` 應該有一個 `name` 屬性且它的值是一個字符串。
+
+```js
+assert(typeof dog.name === 'string');
+```
+
+`dog` 應該有一個 `numLegs` 屬性且它的值是一個數字。
+
+```js
+assert(typeof dog.numLegs === 'number');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let dog = {
+
+};
+```
+
+# --solutions--
+
+```js
+let dog = {
+ name: '',
+ numLegs: 4
+};
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/object-oriented-programming/create-a-method-on-an-object.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/object-oriented-programming/create-a-method-on-an-object.md
new file mode 100644
index 0000000000..7b97dbaabb
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/object-oriented-programming/create-a-method-on-an-object.md
@@ -0,0 +1,70 @@
+---
+id: 587d7dad367417b2b2512b75
+title: 在對象上創建方法
+challengeType: 1
+forumTopicId: 301318
+dashedName: create-a-method-on-an-object
+---
+
+# --description--
+
+對象可以有一個叫做 method 的特殊屬性。
+
+方法屬性也就是函數。 這給對象添加了不同的行爲。 以下就是一個帶有方法屬性的 `duck` 示例：
+
+```js
+let duck = {
+ name: "Aflac",
+ numLegs: 2,
+ sayName: function() {return "The name of this duck is " + duck.name + ".";}
+};
+duck.sayName();
+```
+
+示例添加了 `sayName` 方法，函數返回包含 `duck` 名字的一個句子。 注意：這個方法在返回語句中使用 `duck.name` 的方式來獲取 `name` 的屬性值。 在下一個挑戰中我們將會使用另外一種方法來實現。
+
+# --instructions--
+
+給 `dog` 對象設置一個名爲 `sayLegs` 的方法。 並讓它返回 `This dog has 4 legs.` 這句話。
+
+# --hints--
+
+`dog.sayLegs()` 應該是一個函數。
+
+```js
+assert(typeof dog.sayLegs === 'function');
+```
+
+`dog.sayLegs()` 應該返回給定的字符串，需要注意標點和間距的問題。
+
+```js
+assert(dog.sayLegs() === 'This dog has 4 legs.');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let dog = {
+ name: "Spot",
+ numLegs: 4,
+
+};
+
+dog.sayLegs();
+```
+
+# --solutions--
+
+```js
+let dog = {
+ name: "Spot",
+ numLegs: 4,
+ sayLegs () {
+ return 'This dog has ' + this.numLegs + ' legs.';
+ }
+};
+
+dog.sayLegs();
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/object-oriented-programming/define-a-constructor-function.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/object-oriented-programming/define-a-constructor-function.md
new file mode 100644
index 0000000000..ac006e7bd8
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/object-oriented-programming/define-a-constructor-function.md
@@ -0,0 +1,67 @@
+---
+id: 587d7dad367417b2b2512b77
+title: 定義構造函數
+challengeType: 1
+forumTopicId: 16804
+dashedName: define-a-constructor-function
+---
+
+# --description--
+
+Constructors 是創建對象的函數。 函數給這個新對象定義屬性和行爲。 可將它們視爲創建的新對象的藍圖。
+
+以下就是一個構造函數的示例：
+
+```js
+function Bird() {
+ this.name = "Albert";
+ this.color = "blue";
+ this.numLegs = 2;
+}
+```
+
+這個構造函數定義了一個 `Bird` 對象，其屬性 `name`、`color` 和 `numLegs` 的值分別被設置爲 Albert、blue 和 2。 構造函數遵循一些慣例規則：
+
+構造函數函數名的首字母大寫，這是爲了方便我們區分構造函數（ constructors）和其他非構造函數。 構造函數使用 this 關鍵字來給它將創建的這個對象設置新的屬性。 在構造函數裏面，this 指向的就是它新創建的這個對象。 構造函數定義了屬性和行爲就可創建對象，而不是像其他函數一樣需要設置返回值。 自身屬性 和 `prototype` 屬性。 自身屬性是直接在對象上定義的。 而 `prototype` 屬性是定義在 `prototype` 上的。
+
+```js
+function Bird(name) {
+ this.name = name; //own property
+}
+
+Bird.prototype.numLegs = 2; // prototype property
+
+let duck = new Bird("Donald");
+```
+
+這個示例會告訴你如何將 `duck` 的自身屬性和 `prototype` 屬性分別添加到 `ownProps` 數組和 `prototypeProps` 數組裏面：
+
+```js
+let ownProps = [];
+let prototypeProps = [];
+
+for (let property in duck) {
+ if(duck.hasOwnProperty(property)) {
+ ownProps.push(property);
+ } else {
+ prototypeProps.push(property);
+ }
+}
+
+console.log(ownProps);
+console.log(prototypeProps);
+```
+
+`console.log(ownProps)` 將在控制檯中顯示 `["name"]` ，`console.log(prototypeProps)` 將顯示 `["numLegs"]`。
+
+# --instructions--
+
+將 `beagle` 的自身屬性都添加到 `ownProps` 數組裏面去。 將 `Dog` 中所有的 `prototype` 屬性都添加到 `prototypeProps` 數組中。
+
+# --hints--
+
+`ownProps` 數組應該包含 `name`。
+
+```js
+assert.deepEqual(ownProps, ['name']);
+```
+
+`prototypeProps` 數組應該包含 `numLegs`。
+
+```js
+assert.deepEqual(prototypeProps, ['numLegs']);
+```
+
+在不使用內置方法 `Object.keys()` 的前提下完成這個挑戰。
+
+```js
+assert(!/\Object.keys/.test(code));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function Dog(name) {
+ this.name = name;
+}
+
+Dog.prototype.numLegs = 4;
+
+let beagle = new Dog("Snoopy");
+
+let ownProps = [];
+let prototypeProps = [];
+
+// Only change code below this line
+```
+
+# --solutions--
+
+```js
+function Dog(name) {
+ this.name = name;
+}
+
+Dog.prototype.numLegs = 4;
+
+let beagle = new Dog("Snoopy");
+
+let ownProps = [];
+let prototypeProps = [];
+for (let prop in beagle) {
+ if (beagle.hasOwnProperty(prop)) {
+ ownProps.push(prop);
+ } else {
+ prototypeProps.push(prop);
+ }
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/object-oriented-programming/make-code-more-reusable-with-the-this-keyword.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/object-oriented-programming/make-code-more-reusable-with-the-this-keyword.md
new file mode 100644
index 0000000000..83353dac14
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/object-oriented-programming/make-code-more-reusable-with-the-this-keyword.md
@@ -0,0 +1,75 @@
+---
+id: 587d7dad367417b2b2512b76
+title: 使用 this 關鍵字提高代碼重用性
+challengeType: 1
+forumTopicId: 301321
+dashedName: make-code-more-reusable-with-the-this-keyword
+---
+
+# --description--
+
+在上一個挑戰中我們瞭解了該如何給 `duck` 對象設置一個方法。 然後在 return 語句裏，我們通過使用 “點號表示法” `duck.name` 來獲取 `name` 的屬性值：
+
+```js
+sayName: function() {return "The name of this duck is " + duck.name + ".";}
+```
+
+雖然這是訪問對象屬性的有效方法，但是這裏有一個陷阱。 如果變量名發生了改變，那麼引用了原始名稱的任何代碼都需要更新。 在一個簡短的對象定義中，這並不是問題，但是如果對象有很多對其屬性的引用，那麼發生錯誤的可能性就更大了。
+
+我們可以使用 `this` 關鍵字來避免這一問題：
+
+```js
+let duck = {
+ name: "Aflac",
+ numLegs: 2,
+ sayName: function() {return "The name of this duck is " + this.name + ".";}
+};
+```
+
+`this` 是一個很複雜的知識點，而上面那個例子也只是使用它的一種方法而已。 在當前的上下文環境中，`this` 指向的就是與這個方法有關聯的 `duck` 對象。 如果把對象的變量名改爲 `mallard`，那使用 this 後就沒有必要在代碼中找到所有指向 `duck` 的部分。 這樣可以使得代碼更具有可讀性和複用性。
+
+# --instructions--
+
+修改 `dog.sayLegs` 方法，以將所有直接對 `dog` 的引用刪除。 可以參考上面 `duck` 的例子。
+
+# --hints--
+
+`dog.sayLegs()` 應該返回一個指定的字符串。
+
+```js
+assert(dog.sayLegs() === 'This dog has 4 legs.');
+```
+
+應該使用 `this` 關鍵字來訪問 `dog` 對象的 `numLegs` 屬性值。
+
+```js
+assert(code.match(/this\.numLegs/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let dog = {
+ name: "Spot",
+ numLegs: 4,
+ sayLegs: function() {return "This dog has " + dog.numLegs + " legs.";}
+};
+
+dog.sayLegs();
+```
+
+# --solutions--
+
+```js
+let dog = {
+ name: "Spot",
+ numLegs: 4,
+ sayLegs () {
+ return 'This dog has ' + this.numLegs + ' legs.';
+ }
+};
+
+dog.sayLegs();
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/object-oriented-programming/override-inherited-methods.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/object-oriented-programming/override-inherited-methods.md
new file mode 100644
index 0000000000..d37606af3c
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/object-oriented-programming/override-inherited-methods.md
@@ -0,0 +1,100 @@
+---
+id: 587d7db1367417b2b2512b88
+title: 重寫繼承的方法
+challengeType: 1
+forumTopicId: 301322
+dashedName: override-inherited-methods
+---
+
+# --description--
+
+在上一個挑戰中，我們學習了一個對象可以通過引用另一個對象的 `prototype` 來繼承其屬性和行爲（或方法）：
+
+```js
+ChildObject.prototype = Object.create(ParentObject.prototype);
+```
+
+然後，`ChildObject` 將自己的方法鏈接到它的 `prototype`中：
+
+```js
+ChildObject.prototype.methodName = function() {...};
+```
+
+我們還可以重寫繼承的方法。 以同樣的方式 - 通過使用一個與需要重寫的方法相同的方法名，向`ChildObject.prototype` 中添加方法。 請看下面的舉例：`Bird` 重寫了從 `Animal` 繼承來的 `eat()` 方法：
+
+```js
+function Animal() { }
+Animal.prototype.eat = function() {
+ return "nom nom nom";
+};
+function Bird() { }
+
+Bird.prototype = Object.create(Animal.prototype);
+
+Bird.prototype.eat = function() {
+ return "peck peck peck";
+};
+```
+
+如果你有一個實例：`let duck = new Bird();`，然後你調用了 `duck.eat()`，以下就是 JavaScript 在 `duck’s` 的 `prototype` 鏈上尋找方法的過程：
+
+1. `duck` => `eat()` 是定義在這裏嗎？ 不是。
+2. `Bird` => `eat()` 是定義在這裏嗎？ => 是的。 執行它並停止往上搜索。
+3. `Animal` => 這裏也定義了 `eat()` 方法，但是 JavaScript 在到達這層原型鏈之前已停止了搜索。
+4. Object => JavaScript 在到達這層原型鏈之前也已經停止了搜索。
+
+# --instructions--
+
+重寫 `Penguin` 的 `fly()` 方法，使其返回字符串 `Alas, this is a flightless bird.`
+
+# --hints--
+
+`penguin.fly()` 方法應該返回字符串 `Alas, this is a flightless bird.`
+
+```js
+assert(penguin.fly() === 'Alas, this is a flightless bird.');
+```
+
+The `bird.fly()`方法應該返回字符串 `I am flying!`
+
+```js
+assert(new Bird().fly() === 'I am flying!');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function Bird() { }
+
+Bird.prototype.fly = function() { return "I am flying!"; };
+
+function Penguin() { }
+Penguin.prototype = Object.create(Bird.prototype);
+Penguin.prototype.constructor = Penguin;
+
+// Only change code below this line
+
+
+
+// Only change code above this line
+
+let penguin = new Penguin();
+console.log(penguin.fly());
+```
+
+# --solutions--
+
+```js
+function Bird() { }
+
+Bird.prototype.fly = function() { return "I am flying!"; };
+
+function Penguin() { }
+Penguin.prototype = Object.create(Bird.prototype);
+Penguin.prototype.constructor = Penguin;
+Penguin.prototype.fly = () => 'Alas, this is a flightless bird.';
+let penguin = new Penguin();
+console.log(penguin.fly());
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/object-oriented-programming/remember-to-set-the-constructor-property-when-changing-the-prototype.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/object-oriented-programming/remember-to-set-the-constructor-property-when-changing-the-prototype.md
new file mode 100644
index 0000000000..e43321bf8e
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/object-oriented-programming/remember-to-set-the-constructor-property-when-changing-the-prototype.md
@@ -0,0 +1,86 @@
+---
+id: 587d7daf367417b2b2512b80
+title: 更改原型時，記得設置構造函數屬性
+challengeType: 1
+forumTopicId: 301323
+dashedName: remember-to-set-the-constructor-property-when-changing-the-prototype
+---
+
+# --description--
+
+手動設置一個新對象的原型有一個重要的副作用。 它清除了 `constructor` 屬性！ 此屬性可以用來檢查是哪個構造函數創建了實例，但由於該屬性已被覆蓋，它現在給出了錯誤的結果：
+
+```js
+duck.constructor === Bird;
+duck.constructor === Object;
+duck instanceof Bird;
+```
+
+按順序，這些表達式會返回 `false`、`true` 和 `true`。
+
+爲了解決這個問題，凡是手動給新對象重新設置過原型對象的，都別忘記在原型對象中定義一個 `constructor` 屬性：
+
+```js
+Bird.prototype = {
+ constructor: Bird,
+ numLegs: 2,
+ eat: function() {
+ console.log("nom nom nom");
+ },
+ describe: function() {
+ console.log("My name is " + this.name);
+ }
+};
+```
+
+# --instructions--
+
+給 `Dog` 的 `prototype` 對象定義一個 `constructor` 屬性。
+
+# --hints--
+
+`Dog.prototype` 應該定義一個 `constructor` 屬性。
+
+```js
+assert(Dog.prototype.constructor === Dog);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function Dog(name) {
+ this.name = name;
+}
+
+// Only change code below this line
+Dog.prototype = {
+
+ numLegs: 4,
+ eat: function() {
+ console.log("nom nom nom");
+ },
+ describe: function() {
+ console.log("My name is " + this.name);
+ }
+};
+```
+
+# --solutions--
+
+```js
+function Dog(name) {
+ this.name = name;
+}
+Dog.prototype = {
+ constructor: Dog,
+ numLegs: 4,
+ eat: function() {
+ console.log("nom nom nom");
+ },
+ describe: function() {
+ console.log("My name is " + this.name);
+ }
+};
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/object-oriented-programming/reset-an-inherited-constructor-property.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/object-oriented-programming/reset-an-inherited-constructor-property.md
new file mode 100644
index 0000000000..f6050c1f3e
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/object-oriented-programming/reset-an-inherited-constructor-property.md
@@ -0,0 +1,91 @@
+---
+id: 587d7db1367417b2b2512b86
+title: 重置一個繼承的構造函數屬性
+challengeType: 1
+forumTopicId: 301324
+dashedName: reset-an-inherited-constructor-property
+---
+
+# --description--
+
+當一個對象從另一個對象那裏繼承了其 `prototype` 時，那它也繼承了父類的 constructor 屬性。
+
+請看下面的舉例：
+
+```js
+function Bird() { }
+Bird.prototype = Object.create(Animal.prototype);
+let duck = new Bird();
+duck.constructor
+```
+
+但是 `duck` 和其他所有 `Bird` 的實例都應該表明它們是由 `Bird` 創建的，而不是由 `Animal` 創建的。 爲此，你可以手動把 `Bird's` 的 constructor 屬性設置爲 `Bird` 對象：
+
+```js
+Bird.prototype.constructor = Bird;
+duck.constructor
+```
+
+# --instructions--
+
+修改你的代碼，使得 `duck.constructor` 和 `beagle.constructor` 返回各自的構造函數。
+
+# --hints--
+
+`Bird.prototype` 應該是 `Animal` 的一個實例。
+
+```js
+assert(Animal.prototype.isPrototypeOf(Bird.prototype));
+```
+
+`duck.constructor` 應該返回 `Bird`。
+
+```js
+assert(duck.constructor === Bird);
+```
+
+`Dog.prototype` 應該是 `Animal` 的一個實例。
+
+```js
+assert(Animal.prototype.isPrototypeOf(Dog.prototype));
+```
+
+`beagle.constructor` 應該返回 `Dog`。
+
+```js
+assert(beagle.constructor === Dog);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function Animal() { }
+function Bird() { }
+function Dog() { }
+
+Bird.prototype = Object.create(Animal.prototype);
+Dog.prototype = Object.create(Animal.prototype);
+
+// Only change code below this line
+
+
+
+let duck = new Bird();
+let beagle = new Dog();
+```
+
+# --solutions--
+
+```js
+function Animal() { }
+function Bird() { }
+function Dog() { }
+Bird.prototype = Object.create(Animal.prototype);
+Dog.prototype = Object.create(Animal.prototype);
+Dog.prototype.constructor = Dog;
+Bird.prototype.constructor = Bird;
+let duck = new Bird();
+let beagle = new Dog();
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/object-oriented-programming/set-the-childs-prototype-to-an-instance-of-the-parent.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/object-oriented-programming/set-the-childs-prototype-to-an-instance-of-the-parent.md
new file mode 100644
index 0000000000..8fb1372d62
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/object-oriented-programming/set-the-childs-prototype-to-an-instance-of-the-parent.md
@@ -0,0 +1,79 @@
+---
+id: 587d7db1367417b2b2512b85
+title: 將子輩的原型設置爲父輩的實例
+challengeType: 1
+forumTopicId: 301325
+dashedName: set-the-childs-prototype-to-an-instance-of-the-parent
+---
+
+# --description--
+
+在上一個挑戰中，我們學習了從超類（或者叫父類） `Animal` 繼承其行爲的第一個步驟：創建一個 `Animal` 的新實例。
+
+這一節挑戰我們將學習第二個步驟：給子類型（或者子類）設置 `prototype`。 這樣一來，`Bird` 就是 `Animal` 的一個實例了。
+
+```js
+Bird.prototype = Object.create(Animal.prototype);
+```
+
+請記住，`prototype` 類似於創建對象的“配方”。 從某種意義上來說，`Bird` 對象的配方包含了 `Animal` 的所有關鍵“成分”。
+
+```js
+let duck = new Bird("Donald");
+duck.eat();
+```
+
+`duck` 繼承了`Animal` 的所有屬性，其中包括了 `eat` 方法。
+
+# --instructions--
+
+修改你的代碼，實現一個繼承自 `Animal` 的 `Dog` 實例。
+
+# --hints--
+
+`Dog.prototype` 應該是 `Animal` 的一個實例。
+
+```js
+assert(Animal.prototype.isPrototypeOf(Dog.prototype));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function Animal() { }
+
+Animal.prototype = {
+ constructor: Animal,
+ eat: function() {
+ console.log("nom nom nom");
+ }
+};
+
+function Dog() { }
+
+// Only change code below this line
+
+
+let beagle = new Dog();
+```
+
+# --solutions--
+
+```js
+function Animal() { }
+
+Animal.prototype = {
+ constructor: Animal,
+ eat: function() {
+ console.log("nom nom nom");
+ }
+};
+
+function Dog() { }
+Dog.prototype = Object.create(Animal.prototype);
+
+let beagle = new Dog();
+beagle.eat();
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/object-oriented-programming/understand-own-properties.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/object-oriented-programming/understand-own-properties.md
new file mode 100644
index 0000000000..69089faba7
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/object-oriented-programming/understand-own-properties.md
@@ -0,0 +1,104 @@
+---
+id: 587d7dae367417b2b2512b7b
+title: 瞭解自有屬性
+challengeType: 1
+forumTopicId: 301326
+dashedName: understand-own-properties
+---
+
+# --description--
+
+請看下面的實例，`Bird` 構造函數定義了兩個屬性：`name` 和 `numLegs`：
+
+```js
+function Bird(name) {
+ this.name = name;
+ this.numLegs = 2;
+}
+
+let duck = new Bird("Donald");
+let canary = new Bird("Tweety");
+```
+
+`name` 和 `numLegs` 被叫做 自身屬性 ，因爲它們是直接在實例對象上定義的。 這就意味着 `duck` 和 `canary` 這兩個對象分別擁有這些屬性的獨立副本。 事實上，`Bird` 的所有實例都將擁有這些屬性的獨立副本。 下面的代碼將 `duck` 的所有自身屬性都存到一個叫作 `ownProps` 的數組裏面：
+
+```js
+let ownProps = [];
+
+for (let property in duck) {
+ if(duck.hasOwnProperty(property)) {
+ ownProps.push(property);
+ }
+}
+
+console.log(ownProps);
+```
+
+控制檯將顯示值 `["name", "numLegs"]`。
+
+# --instructions--
+
+將 `canary` 的自身屬性添加到 `ownProps` 數組裏面。
+
+# --hints--
+
+`ownProps` 應該包含 `numLegs` 和 `name` 兩個屬性的值。
+
+```js
+assert(ownProps.indexOf('name') !== -1 && ownProps.indexOf('numLegs') !== -1);
+```
+
+在不使用內置方法 `Object.keys()` 的前提下完成這個挑戰。
+
+```js
+assert(!/Object(\.keys|\[(['"`])keys\2\])/.test(code));
+```
+
+你應該解決這個挑戰，而不是硬編碼 `ownProps` 數組。
+
+```js
+assert(
+ !/\[\s*(?:'|")(?:name|numLegs)|(?:push|concat)\(\s*(?:'|")(?:name|numLegs)/.test(
+ code
+ )
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function Bird(name) {
+ this.name = name;
+ this.numLegs = 2;
+}
+
+let canary = new Bird("Tweety");
+let ownProps = [];
+// Only change code below this line
+```
+
+# --solutions--
+
+```js
+function Bird(name) {
+ this.name = name;
+ this.numLegs = 2;
+}
+
+let canary = new Bird("Tweety");
+function getOwnProps (obj) {
+ const props = [];
+
+ for (let prop in obj) {
+ if (obj.hasOwnProperty(prop)) {
+ props.push(prop);
+ }
+ }
+
+ return props;
+}
+
+const ownProps = getOwnProps(canary);
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/object-oriented-programming/understand-the-constructor-property.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/object-oriented-programming/understand-the-constructor-property.md
new file mode 100644
index 0000000000..36d37b86b2
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/object-oriented-programming/understand-the-constructor-property.md
@@ -0,0 +1,85 @@
+---
+id: 587d7daf367417b2b2512b7e
+title: 瞭解構造函數屬性
+challengeType: 1
+forumTopicId: 301327
+dashedName: understand-the-constructor-property
+---
+
+# --description--
+
+在上一個挑戰中創建的實例對象 `duck` 和 `beagle` 都有一個特殊的 `constructor` 屬性：
+
+```js
+let duck = new Bird();
+let beagle = new Dog();
+
+console.log(duck.constructor === Bird);
+console.log(beagle.constructor === Dog);
+```
+
+這兩次 `console.log` 調用都將在控制檯中顯示 `true`。
+
+需要注意到的是這個 `constructor` 屬性是對創建這個實例的構造函數的一個引用。 `constructor` 屬性的一個好處是可以通過檢查這個屬性來找出它是一個什麼對象。 下面是一個例子，來看看是怎麼使用的：
+
+```js
+function joinBirdFraternity(candidate) {
+ if (candidate.constructor === Bird) {
+ return true;
+ } else {
+ return false;
+ }
+}
+```
+
+**注意：** 由於 `constructor` 屬性可以被重寫（在下面兩節挑戰中將會遇到），所以最好使用`instanceof` 方法來檢查對象的類型。
+
+# --instructions--
+
+寫一個 `joinDogFraternity` 函數，傳入一個 `candidate` 參數並使用 `constructor` 屬性來判斷傳入的 candidate 是不是 `Dog` 創建的對象實例，如果是，就返回 `true`，否則返回 `false`。
+
+# --hints--
+
+`joinDogFraternity` 應該被定義爲一個函數。
+
+```js
+assert(typeof joinDogFraternity === 'function');
+```
+
+如果 `candidate` 是 `Dog` 的一個對象實例，則 `joinDogFraternity` 函數應該返回 `true`。
+
+```js
+assert(joinDogFraternity(new Dog('')) === true);
+```
+
+`joinDogFraternity` 中應該用到 `constructor` 屬性。
+
+```js
+assert(/\.constructor/.test(code) && !/instanceof/.test(code));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function Dog(name) {
+ this.name = name;
+}
+
+// Only change code below this line
+function joinDogFraternity(candidate) {
+
+}
+```
+
+# --solutions--
+
+```js
+function Dog(name) {
+ this.name = name;
+}
+function joinDogFraternity(candidate) {
+ return candidate.constructor === Dog;
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/object-oriented-programming/understand-the-immediately-invoked-function-expression-iife.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/object-oriented-programming/understand-the-immediately-invoked-function-expression-iife.md
new file mode 100644
index 0000000000..27f17a5c19
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/object-oriented-programming/understand-the-immediately-invoked-function-expression-iife.md
@@ -0,0 +1,83 @@
+---
+id: 587d7db2367417b2b2512b8b
+title: 瞭解立即調用函數表達（IIFE）
+challengeType: 1
+forumTopicId: 301328
+dashedName: understand-the-immediately-invoked-function-expression-iife
+---
+
+# --description--
+
+JavaScript 中的一個常見模式就是，函數在聲明後立刻執行：
+
+```js
+(function () {
+ console.log("Chirp, chirp!");
+})();
+```
+
+這是一個匿名函數表達式，立即執行並輸出 `Chirp, chirp!`。
+
+請注意，函數沒有名稱，也不存儲在變量中。 函數表達式末尾的兩個括號（）會讓它被立即執行或調用。 這種模式被叫做立即調用函數表達式（immediately invoked function expression ) 或者IIFE 。
+
+# --instructions--
+
+重寫函數 `makeNest`，並刪除它的調用，取而代之是一個匿名的立即調用函數表達式（IIFE）。
+
+# --hints--
+
+該函數應該是匿名的。
+
+```js
+assert(/\((function|\(\))(=>|\(\)){?/.test(code.replace(/\s/g, '')));
+```
+
+函數應該在表達式的末尾有括號，以便立即調用它。
+
+```js
+assert(/\(.*(\)\(|\}\(\))\)/.test(code.replace(/[\s;]/g, '')));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function makeNest() {
+ console.log("A cozy nest is ready");
+}
+
+makeNest();
+```
+
+# --solutions--
+
+```js
+(function () {
+ console.log("A cozy nest is ready");
+})();
+```
+
+---
+
+```js
+(function () {
+ console.log("A cozy nest is ready");
+}());
+```
+
+---
+
+```js
+(() => {
+ console.log("A cozy nest is ready");
+})();
+```
+
+---
+
+```js
+(() =>
+ console.log("A cozy nest is ready")
+)();
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/object-oriented-programming/understand-the-prototype-chain.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/object-oriented-programming/understand-the-prototype-chain.md
new file mode 100644
index 0000000000..b954e0d84c
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/object-oriented-programming/understand-the-prototype-chain.md
@@ -0,0 +1,74 @@
+---
+id: 587d7db0367417b2b2512b82
+title: 瞭解原型鏈
+challengeType: 1
+forumTopicId: 301329
+dashedName: understand-the-prototype-chain
+---
+
+# --description--
+
+JavaScript 中所有的對象（除了少數例外）都有自己的 `prototype`。 而且，對象的 `prototype` 本身也是一個對象。
+
+```js
+function Bird(name) {
+ this.name = name;
+}
+
+typeof Bird.prototype;
+```
+
+正因爲 `prototype` 是一個對象，所以 `prototype` 對象也有它自己的 `prototype`！ 這樣看來的話，`Bird.prototype` 的 `prototype` 就是 `Object.prototype`：
+
+```js
+Object.prototype.isPrototypeOf(Bird.prototype);
+```
+
+這有什麼作用呢？ 你可能還記得我們在上一個挑戰中學到的 `hasOwnProperty` 方法：
+
+```js
+let duck = new Bird("Donald");
+duck.hasOwnProperty("name");
+```
+
+`hasOwnProperty` 是定義在 `Object.prototype` 上的一個方法，儘管在 `Bird.prototype` 和 `duck`上並沒有定義該方法，但是我們依然可以在這兩個對象上訪問到。 這就是 `prototype` 鏈的一個例子。 在這個`prototype` 鏈中，`Bird` 是 `duck` 的 `supertype`，而 `duck` 是 `subtype`。 `Object` 則是 `Bird` 和 `duck` 實例共同的 `supertype`。 `Object` 是 JavaScript 中所有對象的 `supertype`，也就是原型鏈的最頂層。 因此，所有對象都可以訪問 `hasOwnProperty` 方法。
+
+# --instructions--
+
+修改以下代碼使其展示出正確的原型鏈。
+
+# --hints--
+
+你的代碼應該展示 `Object.prototype` 是 `Dog.prototype` 的原型。
+
+```js
+assert(/Object\.prototype\.isPrototypeOf/.test(code));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function Dog(name) {
+ this.name = name;
+}
+
+let beagle = new Dog("Snoopy");
+
+Dog.prototype.isPrototypeOf(beagle); // yields true
+
+// Fix the code below so that it evaluates to true
+???.isPrototypeOf(Dog.prototype);
+```
+
+# --solutions--
+
+```js
+function Dog(name) {
+ this.name = name;
+}
+let beagle = new Dog("Snoopy");
+Dog.prototype.isPrototypeOf(beagle);
+Object.prototype.isPrototypeOf(Dog.prototype);
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/object-oriented-programming/understand-where-an-objects-prototype-comes-from.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/object-oriented-programming/understand-where-an-objects-prototype-comes-from.md
new file mode 100644
index 0000000000..bd8ebc432c
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/object-oriented-programming/understand-where-an-objects-prototype-comes-from.md
@@ -0,0 +1,63 @@
+---
+id: 587d7db0367417b2b2512b81
+title: 瞭解對象的原型來自哪裏
+challengeType: 1
+forumTopicId: 301330
+dashedName: understand-where-an-objects-prototype-comes-from
+---
+
+# --description--
+
+就像人們從父母那裏繼承基因一樣，對象也可直接從創建它的構造函數那裏繼承其 `prototype`。 請看下面的例子：`Bird` 構造函數創建了一個 `duck` 對象：
+
+```js
+function Bird(name) {
+ this.name = name;
+}
+
+let duck = new Bird("Donald");
+```
+
+`duck` 從 `Bird` 構造函數那裏繼承了它的 `prototype`。 你可以使用 `isPrototypeOf` 方法來驗證他們之間的關係：
+
+```js
+Bird.prototype.isPrototypeOf(duck);
+```
+
+這將返回 `true`。
+
+# --instructions--
+
+使用 `isPrototypeOf` 方法驗證 `beagle` 的 `prototype`。
+
+# --hints--
+
+`Dog.prototype` 應該是 `beagle` 的 `prototype`。
+
+```js
+assert(/Dog\.prototype\.isPrototypeOf\(beagle\)/.test(code));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function Dog(name) {
+ this.name = name;
+}
+
+let beagle = new Dog("Snoopy");
+
+// Only change code below this line
+```
+
+# --solutions--
+
+```js
+function Dog(name) {
+ this.name = name;
+}
+let beagle = new Dog("Snoopy");
+Dog.prototype.isPrototypeOf(beagle);
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/object-oriented-programming/use-a-constructor-to-create-objects.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/object-oriented-programming/use-a-constructor-to-create-objects.md
new file mode 100644
index 0000000000..b678702e55
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/object-oriented-programming/use-a-constructor-to-create-objects.md
@@ -0,0 +1,80 @@
+---
+id: 587d7dad367417b2b2512b78
+title: 使用構造函數創建對象
+challengeType: 1
+forumTopicId: 18233
+dashedName: use-a-constructor-to-create-objects
+---
+
+# --description--
+
+在上一個挑戰中，我們用所學到的知識創建了一個 `Bird` 構造函數：
+
+```js
+function Bird() {
+ this.name = "Albert";
+ this.color = "blue";
+ this.numLegs = 2;
+}
+
+let blueBird = new Bird();
+```
+
+**注意：** 構造函數內的 `this` 總是指被創建的對象。
+
+注意：通過構造函數創建對象的時候要使用 `new` 操作符。 因爲只有這樣，JavaScript 才知道要給 `Bird` 這個構造函數創建一個新的實例：`blueBird`。 如果不使用 `new` 操作符來新建對象，那麼構造函數裏面的 `this` 就無法指向新創建的這個對象實例，從而產生不可預見的錯誤。 現在 `blueBird` 這個實例就繼承了`Bird` 構造函數的所有屬性，如下：
+
+```js
+blueBird.name;
+blueBird.color;
+blueBird.numLegs;
+```
+
+由構造函數創建的實例也和其他對象一樣，它的屬性可以被訪問和修改：
+
+```js
+blueBird.name = 'Elvira';
+blueBird.name;
+```
+
+# --instructions--
+
+使用上一個挑戰中的 `Dog` 構造函數創建一個 `Dog` 的新實例，並把它賦值給變量 `hound`。
+
+# --hints--
+
+`hound` 應該是通過 `Dog` 構造函數來創建的。
+
+```js
+assert(hound instanceof Dog);
+```
+
+你的代碼中應該使用 `new` 操作符來創建 `Dog` 構造函數的新實例。
+
+```js
+assert(code.match(/new/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function Dog() {
+ this.name = "Rupert";
+ this.color = "brown";
+ this.numLegs = 4;
+}
+// Only change code below this line
+```
+
+# --solutions--
+
+```js
+function Dog() {
+ this.name = "Rupert";
+ this.color = "brown";
+ this.numLegs = 4;
+}
+const hound = new Dog();
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/object-oriented-programming/use-a-mixin-to-add-common-behavior-between-unrelated-objects.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/object-oriented-programming/use-a-mixin-to-add-common-behavior-between-unrelated-objects.md
new file mode 100644
index 0000000000..7d6656f533
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/object-oriented-programming/use-a-mixin-to-add-common-behavior-between-unrelated-objects.md
@@ -0,0 +1,111 @@
+---
+id: 587d7db2367417b2b2512b89
+title: 使用 Mixin 在不相關對象之間添加共同行爲
+challengeType: 1
+forumTopicId: 301331
+dashedName: use-a-mixin-to-add-common-behavior-between-unrelated-objects
+---
+
+# --description--
+
+正如你所見，行爲是可以通過繼承來共享的。 然而，在有些情況下，繼承不是最好的解決方案。 繼承不適用於不相關的對象，比如 `Bird` 和 `Airplane`。 雖然它們都可以飛行，但是 `Bird` 並不是一種 `Airplane`，反之亦然。
+
+對於不相關的對象，更好的方法是使用 mixins 。 mixin 允許其他對象使用函數集合。
+
+```js
+let flyMixin = function(obj) {
+ obj.fly = function() {
+ console.log("Flying, wooosh!");
+ }
+};
+```
+
+`flyMixin` 能接受任何對象，併爲其提供 `fly` 方法。
+
+```js
+let bird = {
+ name: "Donald",
+ numLegs: 2
+};
+
+let plane = {
+ model: "777",
+ numPassengers: 524
+};
+
+flyMixin(bird);
+flyMixin(plane);
+```
+
+這裏的 `flyMixin` 接收了`bird` 和 `plane` 對象，然後將 `fly` 方法分配給了每一個對象。 現在 `bird` 和 `plane` 都可以飛行了：
+
+```js
+bird.fly();
+plane.fly();
+```
+
+控制檯將顯示字符串 `Flying, wooosh!` 兩次，每 `.fly()` 調用都會顯示。
+
+注意觀察 mixin 是如何允許相同的 `fly` 方法被不相關的對象 `bird` 和 `plane` 重用的。
+
+# --instructions--
+
+創建一個名爲 `glideMixin` 的 mixin，並定義一個 `glide` 方法。 然後使用 `glideMixin` 來給 `bird` 和 `boat` 賦予滑行（glide）的能力。
+
+# --hints--
+
+你應該聲明一個變量名爲 `glideMixin` 的函數。
+
+```js
+assert(typeof glideMixin === 'function');
+```
+
+你應該在 `bird`上使用 `glideMixin`，以提供 `glide` 方法。
+
+```js
+assert(typeof bird.glide === 'function');
+```
+
+你應該在 `boat` 上使用 `glideMixin`，以爲其提供 `glide` 方法。
+
+```js
+assert(typeof boat.glide === 'function');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let bird = {
+ name: "Donald",
+ numLegs: 2
+};
+
+let boat = {
+ name: "Warrior",
+ type: "race-boat"
+};
+
+// Only change code below this line
+```
+
+# --solutions--
+
+```js
+let bird = {
+ name: "Donald",
+ numLegs: 2
+};
+
+let boat = {
+ name: "Warrior",
+ type: "race-boat"
+};
+function glideMixin (obj) {
+ obj.glide = () => 'Gliding!';
+}
+
+glideMixin(bird);
+glideMixin(boat);
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/object-oriented-programming/use-an-iife-to-create-a-module.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/object-oriented-programming/use-an-iife-to-create-a-module.md
new file mode 100644
index 0000000000..63208cbddb
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/object-oriented-programming/use-an-iife-to-create-a-module.md
@@ -0,0 +1,106 @@
+---
+id: 587d7db2367417b2b2512b8c
+title: 使用 IIFE 創建一個模塊
+challengeType: 1
+forumTopicId: 301332
+dashedName: use-an-iife-to-create-a-module
+---
+
+# --description--
+
+一個立即調用函數表達式（IIFE）通常用於將相關功能分組到單個對象或者是 module 中。 例如，先前的挑戰中定義了兩個 mixins：
+
+```js
+function glideMixin(obj) {
+ obj.glide = function() {
+ console.log("Gliding on the water");
+ };
+}
+function flyMixin(obj) {
+ obj.fly = function() {
+ console.log("Flying, wooosh!");
+ };
+}
+```
+
+我們可以將這些 mixins 分成以下模塊：
+
+```js
+let motionModule = (function () {
+ return {
+ glideMixin: function(obj) {
+ obj.glide = function() {
+ console.log("Gliding on the water");
+ };
+ },
+ flyMixin: function(obj) {
+ obj.fly = function() {
+ console.log("Flying, wooosh!");
+ };
+ }
+ }
+})();
+```
+
+注意：一個立即調用函數表達式（IIFE）返回了一個 `motionModule` 對象。 返回的這個對象包含了作爲對象屬性的所有 mixin 行爲。 module 模式的優點是，所有的運動相關的行爲都可以打包成一個對象，然後由代碼的其他部分使用。 下面是一個使用它的例子：
+
+```js
+motionModule.glideMixin(duck);
+duck.glide();
+```
+
+# --instructions--
+
+創建一個名爲 `funModule` 的模塊，將這兩個 mixins：`isCuteMixin` 和 `singMixin` 包裝起來。 `funModule` 應該返回一個對象。
+
+# --hints--
+
+`funModule` 應該被定義並返回一個對象。
+
+```js
+assert(typeof funModule === 'object');
+```
+
+`funModule.isCuteMixin` 應該訪問一個函數。
+
+```js
+assert(typeof funModule.isCuteMixin === 'function');
+```
+
+`funModule.singMixin` 應該訪問一個函數。
+
+```js
+assert(typeof funModule.singMixin === 'function');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let isCuteMixin = function(obj) {
+ obj.isCute = function() {
+ return true;
+ };
+};
+let singMixin = function(obj) {
+ obj.sing = function() {
+ console.log("Singing to an awesome tune");
+ };
+};
+```
+
+# --solutions--
+
+```js
+const funModule = (function () {
+ return {
+ isCuteMixin: obj => {
+ obj.isCute = () => true;
+ },
+ singMixin: obj => {
+ obj.sing = () => console.log("Singing to an awesome tune");
+ }
+ };
+})();
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/object-oriented-programming/use-closure-to-protect-properties-within-an-object-from-being-modified-externally.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/object-oriented-programming/use-closure-to-protect-properties-within-an-object-from-being-modified-externally.md
new file mode 100644
index 0000000000..24d56e44e2
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/object-oriented-programming/use-closure-to-protect-properties-within-an-object-from-being-modified-externally.md
@@ -0,0 +1,81 @@
+---
+id: 587d7db2367417b2b2512b8a
+title: >-
+ 使用閉包保護對象內的屬性不被外部修改
+challengeType: 1
+forumTopicId: 18234
+dashedName: >-
+ use-closure-to-protect-properties-within-an-object-from-being-modified-externally
+---
+
+# --description--
+
+在上一次挑戰中，`bird` 有一個公共屬性 `name`。 公共屬性的定義就是：它可以在 `bird` 的定義範圍之外被訪問和更改。
+
+```js
+bird.name = "Duffy";
+```
+
+因此，代碼的任何地方都可以輕鬆地將 `bird` 的 name 屬性更改爲任意值。 想想密碼和銀行賬戶之類的東西，如果代碼庫的任何部分都可以輕易改變他們。 那麼將會引起很多問題。
+
+使屬性私有化最簡單的方法就是在構造函數中創建變量。 可以將該變量範圍限定在構造函數中，而不是全局可用。 這樣，屬性只能由構造函數中的方法訪問和更改。
+
+```js
+function Bird() {
+ let hatchedEgg = 10;
+
+ this.getHatchedEggCount = function() {
+ return hatchedEgg;
+ };
+}
+let ducky = new Bird();
+ducky.getHatchedEggCount();
+```
+
+這裏的 `getHatchedEggCount` 是一種特權方法，因爲它可以訪問私有屬性 `hatchedEgg`。 這是因爲 `hatchedEgg` 是在與 `getHatchedEggCount` 相同的上下文中聲明的。 在 JavaScript 中，函數總是可以訪問創建它的上下文。 這就叫做 `closure`。
+
+# --instructions--
+
+更改在 `Bird` 函數中聲明的 `weight` 方法，使其成爲私有變量。 然後，創建一個返回 `weight` 值 15 的 `getWeight` 方法。
+
+# --hints--
+
+`weight` 屬性應該是一個私有變量，值應該是 `15`。
+
+```js
+assert(code.match(/(var|let|const)\s+weight\s*\=\s*15\;?/g));
+```
+
+你的代碼應該在 `Bird` 中創建一個名爲 `getWeight` 方法，該方法返回私有變量 `weight`。
+
+```js
+assert(new Bird().getWeight() === 15);
+```
+
+你的 `getWeight` 函數應該返回私有變量 `weight`。
+
+```js
+assert(code.match(/((return\s+)|(\(\s*\)\s*\=\>\s*))weight\;?/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function Bird() {
+ this.weight = 15;
+
+
+}
+```
+
+# --solutions--
+
+```js
+function Bird() {
+ let weight = 15;
+
+ this.getWeight = () => weight;
+}
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/object-oriented-programming/use-dot-notation-to-access-the-properties-of-an-object.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/object-oriented-programming/use-dot-notation-to-access-the-properties-of-an-object.md
new file mode 100644
index 0000000000..e4d0062429
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/object-oriented-programming/use-dot-notation-to-access-the-properties-of-an-object.md
@@ -0,0 +1,62 @@
+---
+id: 587d7dac367417b2b2512b74
+title: 使用點符號來訪問對象的屬性
+challengeType: 1
+forumTopicId: 301333
+dashedName: use-dot-notation-to-access-the-properties-of-an-object
+---
+
+# --description--
+
+最後一個挑戰創建了一個具有各種屬性的對象。 現在你會看到如何訪問這些屬性的值。 下面是一個示例：
+
+```js
+let duck = {
+ name: "Aflac",
+ numLegs: 2
+};
+console.log(duck.name);
+```
+
+我們可以用“點號表示法”來訪問對象的屬性，`duck` 後面加上點號以及屬性名 `name`，來訪問到 `Aflac`。
+
+# --instructions--
+
+請在控制檯裏面輸出 `dog` 對象中兩個屬性的值。
+
+# --hints--
+
+你應該使用 `console.log` 來將 `dog` 對象的 `name` 屬性值輸出到控制檯。
+
+```js
+assert(/console.log\(.*dog\.name.*\)/g.test(code));
+```
+
+你應該使用 `console.log` 來將 `dog` 對象的 `numLegs` 屬性值輸出到控制檯。
+
+```js
+assert(/console.log\(.*dog\.numLegs.*\)/g.test(code));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let dog = {
+ name: "Spot",
+ numLegs: 4
+};
+// Only change code below this line
+```
+
+# --solutions--
+
+```js
+let dog = {
+ name: "Spot",
+ numLegs: 4
+};
+console.log(dog.name);
+console.log(dog.numLegs);
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/object-oriented-programming/use-inheritance-so-you-dont-repeat-yourself.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/object-oriented-programming/use-inheritance-so-you-dont-repeat-yourself.md
new file mode 100644
index 0000000000..0370a9eb1e
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/object-oriented-programming/use-inheritance-so-you-dont-repeat-yourself.md
@@ -0,0 +1,142 @@
+---
+id: 587d7db0367417b2b2512b83
+title: 使用繼承避免重複
+challengeType: 1
+forumTopicId: 301334
+dashedName: use-inheritance-so-you-dont-repeat-yourself
+---
+
+# --description--
+
+有一條原則叫做：Don't Repeat Yourself 。常以縮寫形式 DRY 出現，意思是“不要自己重複”。 編寫重複代碼會產生的問題是：任何改變都需要去多個地方修復所有重複的代碼。 這通常意味着我們需要做更多的工作，會產生更高的出錯率。
+
+請觀察下面的示例，`Bird` 和 `Dog` 共享 `describe` 方法：
+
+```js
+Bird.prototype = {
+ constructor: Bird,
+ describe: function() {
+ console.log("My name is " + this.name);
+ }
+};
+
+Dog.prototype = {
+ constructor: Dog,
+ describe: function() {
+ console.log("My name is " + this.name);
+ }
+};
+```
+
+我們可以看到 `describe` 方法在兩個地方重複定義了。 根據以上所說的 DRY 原則，我們可以通過創建一個 `Animal` `supertype`（或者父類）來重寫這段代碼：
+
+```js
+function Animal() { };
+
+Animal.prototype = {
+ constructor: Animal,
+ describe: function() {
+ console.log("My name is " + this.name);
+ }
+};
+```
+
+`Animal` 構造函數中定義了 `describe` 方法，可將 `Bird` 和 `Dog` 這兩個構造函數的方法刪除掉：
+
+```js
+Bird.prototype = {
+ constructor: Bird
+};
+
+Dog.prototype = {
+ constructor: Dog
+};
+```
+
+# --instructions--
+
+`Cat` 和 `Bear` 重複定義了 `eat` 方法。 本着 DRY 的原則，通過將 `eat` 方法移動到 `Animal``supertype` 中來重寫你的代碼。
+
+# --hints--
+
+`Animal.prototype` 應該有 `eat` 屬性。
+
+```js
+assert(Animal.prototype.hasOwnProperty('eat'));
+```
+
+`Bear.prototype` 不應該有 `eat` 屬性。
+
+```js
+assert(!Bear.prototype.hasOwnProperty('eat'));
+```
+
+`Cat.prototype` 不應該有 `eat` 屬性。
+
+```js
+assert(!Cat.prototype.hasOwnProperty('eat'));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function Cat(name) {
+ this.name = name;
+}
+
+Cat.prototype = {
+ constructor: Cat,
+ eat: function() {
+ console.log("nom nom nom");
+ }
+};
+
+function Bear(name) {
+ this.name = name;
+}
+
+Bear.prototype = {
+ constructor: Bear,
+ eat: function() {
+ console.log("nom nom nom");
+ }
+};
+
+function Animal() { }
+
+Animal.prototype = {
+ constructor: Animal,
+
+};
+```
+
+# --solutions--
+
+```js
+function Cat(name) {
+ this.name = name;
+}
+
+Cat.prototype = {
+ constructor: Cat
+};
+
+function Bear(name) {
+ this.name = name;
+}
+
+Bear.prototype = {
+ constructor: Bear
+};
+
+function Animal() { }
+
+Animal.prototype = {
+ constructor: Animal,
+ eat: function() {
+ console.log("nom nom nom");
+ }
+};
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/object-oriented-programming/use-prototype-properties-to-reduce-duplicate-code.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/object-oriented-programming/use-prototype-properties-to-reduce-duplicate-code.md
new file mode 100644
index 0000000000..3afd16da7a
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/object-oriented-programming/use-prototype-properties-to-reduce-duplicate-code.md
@@ -0,0 +1,77 @@
+---
+id: 587d7dae367417b2b2512b7c
+title: 使用原型屬性來減少重複代碼
+challengeType: 1
+forumTopicId: 301336
+dashedName: use-prototype-properties-to-reduce-duplicate-code
+---
+
+# --description--
+
+所有 `Bird` 實例可能會有相同的 `numLegs` 值，所以在每一個 `Bird` 的實例中本質上都有一個重複的變量 `numLegs`。
+
+當只有兩個實例時可能並不是什麼問題，但想象一下如果有數百萬個實例。 這將會產生許許多多重複的變量。
+
+這裏有一個更好的方法可以解決上述問題，那就是使用 `Bird’s` 的 `prototype`。 `prototype` 是一個可以在所有 `Bird` 實例之間共享的對象。 以下是一個在 `Bird prototype` 中添加 `numLegs` 屬性的示例：
+
+```js
+Bird.prototype.numLegs = 2;
+```
+
+現在所有的 `Bird` 實例都擁有了共同的 `numLegs` 屬性值。
+
+```js
+console.log(duck.numLegs);
+console.log(canary.numLegs);
+```
+
+由於所有的實例都可以繼承 `prototype` 上的屬性，所以可以把 `prototype` 看作是創建對象的 "配方"。 請注意：`duck` 和 `canary` 的 `prototype` 屬於 `Bird` 的構造函數，即 Bird 的原型 `Bird.prototype`。 JavaScript 中幾乎所有的對象都有一個 `prototype` 屬性，這個屬性是屬於它所在的構造函數。
+
+# --instructions--
+
+給 `Dog` 的 `prototype` 添加一個 `numLegs` 屬性。
+
+# --hints--
+
+`beagle` 應該有一個 `numLegs` 屬性。
+
+```js
+assert(beagle.numLegs !== undefined);
+```
+
+`beagle.numLegs` 應該是一個數字。
+
+```js
+assert(typeof beagle.numLegs === 'number');
+```
+
+`numLegs` 應該是一個 `prototype` 屬性而不是一個 `own` 屬性。
+
+```js
+assert(beagle.hasOwnProperty('numLegs') === false);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function Dog(name) {
+ this.name = name;
+}
+
+
+
+// Only change code above this line
+let beagle = new Dog("Snoopy");
+```
+
+# --solutions--
+
+```js
+function Dog (name) {
+ this.name = name;
+}
+Dog.prototype.numLegs = 4;
+let beagle = new Dog("Snoopy");
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/object-oriented-programming/verify-an-objects-constructor-with-instanceof.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/object-oriented-programming/verify-an-objects-constructor-with-instanceof.md
new file mode 100644
index 0000000000..2247013e73
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/object-oriented-programming/verify-an-objects-constructor-with-instanceof.md
@@ -0,0 +1,79 @@
+---
+id: 587d7dae367417b2b2512b7a
+title: 使用 instanceof 驗證對象的構造函數
+challengeType: 1
+forumTopicId: 301337
+dashedName: verify-an-objects-constructor-with-instanceof
+---
+
+# --description--
+
+凡是通過構造函數創建出的新對象，這個對象都叫做這個構造函數的 instance 。 JavaScript 提供了一種很簡便的方法來驗證這個事實，那就是通過 `instanceof` 操作符。 `instanceof` 允許你將對象與構造函數之間進行比較，根據對象是否由這個構造函數創建的返回 `true` 或者 `false`。 以下是一個示例：
+
+```js
+let Bird = function(name, color) {
+ this.name = name;
+ this.color = color;
+ this.numLegs = 2;
+}
+
+let crow = new Bird("Alexis", "black");
+
+crow instanceof Bird;
+```
+
+`instanceof` 方法會返回 `true`.
+
+如果一個對象不是使用構造函數創建的，那麼 `instanceof` 將會驗證這個對象不是構造函數的實例：
+
+```js
+let canary = {
+ name: "Mildred",
+ color: "Yellow",
+ numLegs: 2
+};
+
+canary instanceof Bird;
+```
+
+`instanceof` 方法會返回 `false`。
+
+# --instructions--
+
+給 `House` 構造函數創建一個新實例，取名爲 `myHouse` 並且傳遞一個數字給 bedrooms 參數。 然後使用 `instanceof` 操作符驗證這個對象是否爲 `House` 的實例。
+
+# --hints--
+
+`myHouse` 應該有一個 `numBedrooms` 屬性值被賦爲一個數字。
+
+```js
+assert(typeof myHouse.numBedrooms === 'number');
+```
+
+應該使用 `instanceof` 操作符驗證 `myHouse` 這個對象是 `House` 構造函數的一個實例。
+
+```js
+assert(/myHouse\s*instanceof\s*House/.test(code));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function House(numBedrooms) {
+ this.numBedrooms = numBedrooms;
+}
+
+// Only change code below this line
+```
+
+# --solutions--
+
+```js
+function House(numBedrooms) {
+ this.numBedrooms = numBedrooms;
+}
+const myHouse = new House(4);
+console.log(myHouse instanceof House);
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/check-for-all-or-none.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/check-for-all-or-none.md
new file mode 100644
index 0000000000..d3c2ad8737
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/check-for-all-or-none.md
@@ -0,0 +1,77 @@
+---
+id: 587d7dba367417b2b2512ba8
+title: 檢查全部或無
+challengeType: 1
+forumTopicId: 301338
+dashedName: check-for-all-or-none
+---
+
+# --description--
+
+有時，想要搜尋的匹配模式可能有不確定是否存在的部分。 儘管如此，還是想檢查它們。
+
+爲此，可以使用問號 `?` 指定可能存在的元素。 這將檢查前面的零個或一個元素。 可以將此符號視爲前面的元素是可選的。
+
+例如，美式英語和英式英語略有不同，可以使用問號來匹配兩種拼寫。
+
+```js
+let american = "color";
+let british = "colour";
+let rainbowRegex= /colou?r/;
+rainbowRegex.test(american);
+rainbowRegex.test(british);
+```
+
+上面的 `test` 都會返回 `true`。
+
+# --instructions--
+
+修改正則表達式 `favRegex` 以匹配美式英語（`favorite`）和英式英語（`favourite`）的單詞版本。
+
+# --hints--
+
+你的正則表達式應該使用可選符號 `?`。
+
+```js
+favRegex.lastIndex = 0;
+assert(favRegex.source.match(/\?/).length > 0);
+```
+
+你的正則表達式應該匹配 `favorite`。
+
+```js
+favRegex.lastIndex = 0;
+assert(favRegex.test('favorite'));
+```
+
+你的正則表達式應該匹配 `favourite`。
+
+```js
+favRegex.lastIndex = 0;
+assert(favRegex.test('favourite'));
+```
+
+你的正則表達式不應該匹配 `fav`。
+
+```js
+favRegex.lastIndex = 0;
+assert(!favRegex.test('fav'));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let favWord = "favorite";
+let favRegex = /change/; // Change this line
+let result = favRegex.test(favWord);
+```
+
+# --solutions--
+
+```js
+let favWord = "favorite";
+let favRegex = /favou?r/;
+let result = favRegex.test(favWord);
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/check-for-mixed-grouping-of-characters.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/check-for-mixed-grouping-of-characters.md
new file mode 100644
index 0000000000..3dc2787c4c
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/check-for-mixed-grouping-of-characters.md
@@ -0,0 +1,90 @@
+---
+id: 5c3dda8b4d8df89bea71600f
+title: 檢查混合字符組
+challengeType: 1
+forumTopicId: 301339
+dashedName: check-for-mixed-grouping-of-characters
+---
+
+# --description--
+
+有時候我們想使用正則表達式裏的括號 `()` 來檢查字符組。
+
+如果想在字符串找到 `Penguin` 或 `Pumpkin`，可以用這個正則表達式：`/P(engu|umpk)in/g`。
+
+然後使用 `test()` 方法檢查 test 字符串裏面是否包含字符組。
+
+```js
+let testStr = "Pumpkin";
+let testRegex = /P(engu|umpk)in/;
+testRegex.test(testStr);
+```
+
+`test` 方法會返回 `true`。
+
+# --instructions--
+
+完善正則表達式，使其以區分大小寫的方式檢查 `Franklin Roosevelt` 或 `Eleanor Roosevelt` 的名字，並且應該忽略 middle names。
+
+然後完善代碼，使創建的正則檢查 `myString`，根據正則是否匹配返回 `true` 或 `false`。
+
+# --hints--
+
+正則 `myRegex` 測試 `Franklin D. Roosevelt` 應該返回 `true`。
+
+```js
+myRegex.lastIndex = 0;
+assert(myRegex.test('Franklin D. Roosevelt'));
+```
+
+正則 `myRegex` 測試 `Eleanor Roosevelt` 應該返回 `true`。
+
+```js
+myRegex.lastIndex = 0;
+assert(myRegex.test('Eleanor Roosevelt'));
+```
+
+正則 `myRegex` 測試 `Franklin Rosevelt` 應該返回 `false`。
+
+```js
+myRegex.lastIndex = 0;
+assert(!myRegex.test('Franklin Rosevelt'));
+```
+
+正則 `myRegex` 測試 `Frank Roosevelt` 應該返回 `false`。
+
+```js
+myRegex.lastIndex = 0;
+assert(!myRegex.test('Frank Roosevelt'));
+```
+
+你應該使用 `.test()` 方法來檢測正則表達式。
+
+```js
+assert(code.match(/myRegex.test\(\s*myString\s*\)/));
+```
+
+你的返回結果應該爲 `true`。
+
+```js
+assert(result === true);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let myString = "Eleanor Roosevelt";
+let myRegex = /False/; // Change this line
+let result = false; // Change this line
+// After passing the challenge experiment with myString and see how the grouping works
+```
+
+# --solutions--
+
+```js
+let myString = "Eleanor Roosevelt";
+let myRegex = /(Franklin|Eleanor).*Roosevelt/;
+let result = myRegex.test(myString);
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/extract-matches.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/extract-matches.md
new file mode 100644
index 0000000000..04deb9c7a6
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/extract-matches.md
@@ -0,0 +1,73 @@
+---
+id: 587d7db4367417b2b2512b92
+title: 提取匹配項
+challengeType: 1
+forumTopicId: 301340
+dashedName: extract-matches
+---
+
+# --description--
+
+到目前爲止，只是檢查了一個匹配模式是否存在於字符串中。 還可以使用 `.match()` 方法來提取找到的實際匹配項。
+
+可以使用字符串來調用 `.match()` 方法，並在括號內傳入正則表達式。
+
+請看下面的舉例：
+
+```js
+"Hello, World!".match(/Hello/);
+let ourStr = "Regular expressions";
+let ourRegex = /expressions/;
+ourStr.match(ourRegex);
+```
+
+這裏第一個 `match` 將返回 `["Hello"]` 第二個將返回 `["expressions"]`。
+
+請注意， `.match` 語法是目前爲止一直使用的 `.test` 方法中的“反向”：
+
+```js
+'string'.match(/regex/);
+/regex/.test('string');
+```
+
+# --instructions--
+
+利用 `.match()` 方法提取單詞 `coding`。
+
+# --hints--
+
+`result` 應該有字符串 `coding`
+
+```js
+assert(result.join() === 'coding');
+```
+
+您的 regex `codingRegex` 應該搜索字符串 `coding`
+
+```js
+assert(codingRegex.source === 'coding');
+```
+
+您應該使用 `.match()` 方法。
+
+```js
+assert(code.match(/\.match\(.*\)/));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let extractStr = "Extract the word 'coding' from this string.";
+let codingRegex = /change/; // Change this line
+let result = extractStr; // Change this line
+```
+
+# --solutions--
+
+```js
+let extractStr = "Extract the word 'coding' from this string.";
+let codingRegex = /coding/; // Change this line
+let result = extractStr.match(codingRegex); // Change this line
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/find-characters-with-lazy-matching.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/find-characters-with-lazy-matching.md
new file mode 100644
index 0000000000..368b5f1d30
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/find-characters-with-lazy-matching.md
@@ -0,0 +1,61 @@
+---
+id: 587d7db6367417b2b2512b9b
+title: 用惰性匹配來查找字符
+challengeType: 1
+forumTopicId: 301341
+dashedName: find-characters-with-lazy-matching
+---
+
+# --description--
+
+在正則表達式中，貪婪（greedy ）匹配會匹配到符合正則表達式匹配模式的字符串的最長可能部分，並將其作爲匹配項返回。 另一種方案稱爲懶惰（lazy ）匹配，它會匹配到滿足正則表達式的字符串的最小可能部分。
+
+可以將正則表達式 `/t[a-z]*i/` 應用於字符串 `"titanic"`。 這個正則表達式是一個以 `t` 開始，以 `i` 結束，並且中間有一些字母的匹配模式。
+
+正則表達式默認是貪婪匹配，因此匹配返回爲 `["titani"]`。 它會匹配到適合該匹配模式的最大子字符串。
+
+但是，你可以使用 `?` 字符來將其變成懶惰匹配。 調整後的正則表達式 `/t[a-z]*?i/` 匹配字符串 `"titanic"` 返回 `["ti"]`。
+
+**注意：**應該避免使用正則表達式解析 HTML，但是可以用正則表達式匹配 HTML 字符串。
+
+# --instructions--
+
+修復正則表達式 `/<.*>/`，讓它返回 HTML 標籤 ``，而不是文本 `"Winter is coming "`。 請記得在正則表達式中使用通配符 `.` 來匹配任意字符。
+
+# --hints--
+
+`result` 變量應該是一個包含 `` 的數組
+
+```js
+assert(result[0] == '');
+```
+
+`myRegex` 應該使用懶惰匹配
+
+```js
+assert(/\?/g.test(myRegex));
+```
+
+`myRegex` 不應包含字符串 `h1`
+
+```js
+assert(!myRegex.source.match('h1'));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let text = "Winter is coming ";
+let myRegex = /<.*>/; // Change this line
+let result = text.match(myRegex);
+```
+
+# --solutions--
+
+```js
+let text = "Winter is coming ";
+let myRegex = /<.*?>/; // Change this line
+let result = text.match(myRegex);
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/find-more-than-the-first-match.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/find-more-than-the-first-match.md
new file mode 100644
index 0000000000..43101d69ee
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/find-more-than-the-first-match.md
@@ -0,0 +1,85 @@
+---
+id: 587d7db4367417b2b2512b93
+title: 全局匹配
+challengeType: 1
+forumTopicId: 301342
+dashedName: find-more-than-the-first-match
+---
+
+# --description--
+
+到目前爲止，只能提取或搜尋一次模式匹配。
+
+```js
+let testStr = "Repeat, Repeat, Repeat";
+let ourRegex = /Repeat/;
+testStr.match(ourRegex);
+```
+
+在這裏 `match` 將返回 `["Repeat"]`。
+
+若要多次搜尋或提取模式匹配，可以使用 `g` 標誌。
+
+```js
+let repeatRegex = /Repeat/g;
+testStr.match(repeatRegex);
+```
+
+這裏 `match` 返回值 `["Repeat", "Repeat", "Repeat"]`
+
+# --instructions--
+
+使用正則表達式 `starRegex`，從字符串 `twinkleStar` 中匹配所有的 `Twinkle` 單詞並提取出來。
+
+**注意：**
+在正則表達式上可以有多個標誌，比如 `/search/gi`
+
+# --hints--
+
+你的正則表達式 `starRegex` 應該使用全局標誌 `g`
+
+```js
+assert(starRegex.flags.match(/g/).length == 1);
+```
+
+你的正則表達式 `starRegex` 應該使用忽略大小寫標誌 `i`
+
+```js
+assert(starRegex.flags.match(/i/).length == 1);
+```
+
+你的匹配應該匹配單詞 `Twinkle` 的兩個匹配項
+
+```js
+assert(
+ result.sort().join() ==
+ twinkleStar
+ .match(/twinkle/gi)
+ .sort()
+ .join()
+);
+```
+
+你的匹配 `result` 應該包含兩個元素
+
+```js
+assert(result.length == 2);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let twinkleStar = "Twinkle, twinkle, little star";
+let starRegex = /change/; // Change this line
+let result = twinkleStar; // Change this line
+```
+
+# --solutions--
+
+```js
+let twinkleStar = "Twinkle, twinkle, little star";
+let starRegex = /twinkle/gi;
+let result = twinkleStar.match(starRegex);
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/find-one-or-more-criminals-in-a-hunt.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/find-one-or-more-criminals-in-a-hunt.md
new file mode 100644
index 0000000000..379c49aeba
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/find-one-or-more-criminals-in-a-hunt.md
@@ -0,0 +1,106 @@
+---
+id: 587d7db7367417b2b2512b9c
+title: 在狩獵中找到一個或多個罪犯
+challengeType: 1
+forumTopicId: 301343
+dashedName: find-one-or-more-criminals-in-a-hunt
+---
+
+# --description--
+
+是時候停一停來測試你的正則表達式使用能力了。 一羣罪犯越獄逃跑了，但你不知道有多少人。 然而，你知道他們不在一起時會保持緊密聯繫。 你有責任立刻找到所有的罪犯。
+
+這裏有一個示例來提示如何做到這一點：
+
+當字母`z`在一行中出現一次或連續多次時，正則表達式`/z+/`會匹配到它。 它會在以下所有字符串中找到匹配項：
+
+```js
+"z"
+"zzzzzz"
+"ABCzzzz"
+"zzzzABC"
+"abczzzzzzzzzzzzzzzzzzzzzabc"
+```
+
+但是它不會在以下字符串中找到匹配項，因爲它們中沒有字母`z`：
+
+```js
+""
+"ABC"
+"abcabc"
+```
+
+# --instructions--
+
+編寫一個貪婪正則表達式，在一組其他人中匹配到一個或多個罪犯。 罪犯由大寫字母`C`表示。
+
+# --hints--
+
+您的正則表達式應該匹配字符串 `C` 中的一個罪犯(`C`)
+
+```js
+assert('C'.match(reCriminals) && 'C'.match(reCriminals)[0] == 'C');
+```
+
+您的正則表達式應該匹配字符串 `CC` 中的兩個罪犯(`CC`)
+
+```js
+assert('CC'.match(reCriminals) && 'CC'.match(reCriminals)[0] == 'CC');
+```
+
+您的正則表達式應該在字符串 `P1P5P4CCCcP2P6P3` 中匹配三個罪犯(`CCC`)。
+
+```js
+assert(
+ 'P1P5P4CCCcP2P6P3'.match(reCriminals) &&
+ 'P1P5P4CCCcP2P6P3'.match(reCriminals)[0] == 'CCC'
+);
+```
+
+您的正則表達式應該在字符串 `P6P2P7P4P5CCCCCP3P1`中匹配五個罪犯(`CCCCC`)
+
+```js
+assert(
+ 'P6P2P7P4P5CCCCCP3P1'.match(reCriminals) &&
+ 'P6P2P7P4P5CCCCCP3P1'.match(reCriminals)[0] == 'CCCCC'
+);
+```
+
+你的正則表達式在`""`中不應該匹配到任何罪犯
+
+```js
+assert(!reCriminals.test(''));
+```
+
+你的正則表達式在`P1P2P3`中不應該匹配到任何罪犯
+
+```js
+assert(!reCriminals.test('P1P2P3'));
+```
+
+你的正則表達式應該在`P2P1P5P4CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCP3`中匹配五十個 罪犯（'`CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC`'）。
+
+```js
+assert(
+ 'P2P1P5P4CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCP3'.match(
+ reCriminals
+ ) &&
+ 'P2P1P5P4CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCP3'.match(
+ reCriminals
+ )[0] == 'CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC'
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let reCriminals = /./; // Change this line
+```
+
+# --solutions--
+
+```js
+let reCriminals = /C+/; // Change this line
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/ignore-case-while-matching.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/ignore-case-while-matching.md
new file mode 100644
index 0000000000..ec4a85432d
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/ignore-case-while-matching.md
@@ -0,0 +1,99 @@
+---
+id: 587d7db4367417b2b2512b91
+title: 匹配時忽略大小寫
+challengeType: 1
+forumTopicId: 301344
+dashedName: ignore-case-while-matching
+---
+
+# --description--
+
+到目前爲止，已經瞭解瞭如何用正則表達式來執行字符串的匹配。 但有時候，並不關注匹配字母的大小寫。
+
+大小寫即大寫字母和小寫字母。 大寫字母如 `A`、`B` 和 `C`。 小寫字母如 `a`、`b` 和 `c`。
+
+可以使用標誌（flag）來匹配這兩種情況。 標誌有很多，不過這裏我們只關注忽略大小寫的標誌——`i`。 可以通過將它附加到正則表達式之後來使用它。 這裏給出使用該標誌的一個實例 `/ignorecase/i`。 這個字符串可以匹配字符串 `ignorecase`、`igNoreCase` 和 `IgnoreCase`。
+
+# --instructions--
+
+編寫正則表達式 `fccRegex` 以匹配 `freeCodeCamp`，忽略大小寫。 正則表達式不應與任何縮寫或帶有空格的變體匹配。
+
+# --hints--
+
+你的正則表達式應該匹配 `freeCodeCamp`
+
+```js
+assert(fccRegex.test('freeCodeCamp'));
+```
+
+你的正則表達式應該匹配 `FreeCodeCamp`
+
+```js
+assert(fccRegex.test('FreeCodeCamp'));
+```
+
+你的正則表達式應該匹配 `FreecodeCamp`
+
+```js
+assert(fccRegex.test('FreecodeCamp'));
+```
+
+你的正則表達式應該匹配 `FreeCodecamp`
+
+```js
+assert(fccRegex.test('FreeCodecamp'));
+```
+
+你的正則表達式不應該匹配 `Free Code Camp`
+
+```js
+assert(!fccRegex.test('Free Code Camp'));
+```
+
+您的正則表達式應該匹配字符串 `FreeCOdeCamp`
+
+```js
+assert(fccRegex.test('FreeCOdeCamp'));
+```
+
+你的正則表達式不應該匹配 `FCC`
+
+```js
+assert(!fccRegex.test('FCC'));
+```
+
+你的正則表達式應該匹配字符串 `FrEeCoDeCamp`
+
+```js
+assert(fccRegex.test('FrEeCoDeCamp'));
+```
+
+你的正則表達式應該匹配字符串 `FrEeCodECamp`
+
+```js
+assert(fccRegex.test('FrEeCodECamp'));
+```
+
+你的正則表達式應該匹配字符串 `FReeCodeCAmp`
+
+```js
+assert(fccRegex.test('FReeCodeCAmp'));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let myString = "freeCodeCamp";
+let fccRegex = /change/; // Change this line
+let result = fccRegex.test(myString);
+```
+
+# --solutions--
+
+```js
+let myString = "freeCodeCamp";
+let fccRegex = /freecodecamp/i; // Change this line
+let result = fccRegex.test(myString);
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/match-a-literal-string-with-different-possibilities.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/match-a-literal-string-with-different-possibilities.md
new file mode 100644
index 0000000000..f1ecce39fa
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/match-a-literal-string-with-different-possibilities.md
@@ -0,0 +1,83 @@
+---
+id: 587d7db4367417b2b2512b90
+title: 同時用多種模式匹配文字字符串
+challengeType: 1
+forumTopicId: 301345
+dashedName: match-a-literal-string-with-different-possibilities
+---
+
+# --description--
+
+使用正則表達式`/coding/`，你可以在其他字符串中查找`coding`。
+
+這對於搜尋單個字符串非常有用，但僅限於一種匹配模式。 你可以使用 `alternation` 或 `OR` 操作符搜索多個模式： `|`
+
+此操作符匹配操作符前面或後面的字符。 例如，如果你想匹配 `yes` 或 `no`，你需要的正則表達式是 `/yes|no/`。
+
+你還可以匹配多個規則，這可以通過添加更多的匹配模式來實現。 這些匹配模式將包含更多的 `OR` 操作符來分隔它們，比如`/yes|no|maybe/`。
+
+# --instructions--
+
+完成正則表達式 `petRegex` 以匹配 `dog`、`cat`、`bird` 或者 `fish`。
+
+# --hints--
+
+對於字符串 `John has a pet dog.`，你的正則表達式`petRegex` 應該返回 `true`
+
+```js
+assert(petRegex.test('John has a pet dog.'));
+```
+
+對於字符串 `Emma has a pet rock.`，你的正則表達式 `petRegex` 的應該返回 `false`
+
+```js
+assert(!petRegex.test('Emma has a pet rock.'));
+```
+
+對於字符串 `Emma has a pet bird.`，你的正則表達式 `petRegex` 應該返回 `true`
+
+```js
+assert(petRegex.test('Emma has a pet bird.'));
+```
+
+對於字符串 `Liz has a pet cat.`，你的正則表達式 `petRegex` 應該返回 `true`
+
+```js
+assert(petRegex.test('Liz has a pet cat.'));
+```
+
+對於字符串 `Kara has a pet dolphin.`，你的正則表達式 `petRegex` 應該返回 `false`
+
+```js
+assert(!petRegex.test('Kara has a pet dolphin.'));
+```
+
+對於字符串 `Alice has a pet fish.`，你的正則表達式 `petRegex` 應該返回 `true`。
+
+```js
+assert(petRegex.test('Alice has a pet fish.'));
+```
+
+對於字符串 `Jimmy has a pet computer.`，你的正則表達式 `petRegex` 應該返回 `false`。
+
+```js
+assert(!petRegex.test('Jimmy has a pet computer.'));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let petString = "James has a pet cat.";
+let petRegex = /change/; // Change this line
+let result = petRegex.test(petString);
+```
+
+# --solutions--
+
+```js
+let petString = "James has a pet cat.";
+let petRegex = /dog|cat|bird|fish/; // Change this line
+let result = petRegex.test(petString);
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/match-all-letters-and-numbers.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/match-all-letters-and-numbers.md
new file mode 100644
index 0000000000..4beff2f098
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/match-all-letters-and-numbers.md
@@ -0,0 +1,98 @@
+---
+id: 587d7db7367417b2b2512b9f
+title: 匹配所有的字母和數字
+challengeType: 1
+forumTopicId: 301346
+dashedName: match-all-letters-and-numbers
+---
+
+# --description--
+
+使用元字符，可以使用 `[a-z]` 搜尋字母表中的所有字母。 這種元字符是很常見的，它有一個縮寫，但這個縮寫也包含額外的字符。
+
+JavaScript 中與字母表匹配的最接近的元字符是`\w`。 這個縮寫等同於`[A-Za-z0-9_]`。 此字符類匹配上面字母和小寫字母以及數字。 注意，這個字符類也包含下劃線字符 (`_`)。
+
+```js
+let longHand = /[A-Za-z0-9_]+/;
+let shortHand = /\w+/;
+let numbers = "42";
+let varNames = "important_var";
+longHand.test(numbers);
+shortHand.test(numbers);
+longHand.test(varNames);
+shortHand.test(varNames);
+```
+
+上面的 `test` 都會返回 `true`。
+
+這些元字符縮寫也被稱爲短語元字符 shorthand character classes 。
+
+# --instructions--
+
+使用元字符 `\w` 來計算所有引號中字母和數字字符的數量。
+
+# --hints--
+
+您的正則表達式應該使用全局標識。
+
+```js
+assert(alphabetRegexV2.global);
+```
+
+正則表達式應該使用元字符r `\w` 來匹配非字母字符。
+
+```js
+assert(/\\w/.test(alphabetRegexV2.source));
+```
+
+你的正則表達式應該在 `The five boxing wizards jump quickly.` 中匹配到 31 個非字母數字字符。
+
+```js
+assert(
+ 'The five boxing wizards jump quickly.'.match(alphabetRegexV2).length === 31
+);
+```
+
+你的正則表達式應該在 `Pack my box with five dozen liquor jugs.` 中匹配到 32 個非字母數字字符。
+
+```js
+assert(
+ 'Pack my box with five dozen liquor jugs.'.match(alphabetRegexV2).length ===
+ 32
+);
+```
+
+你的正則表達式應該在 `How vexingly quick daft zebras jump!` 中匹配到 30 個非字母數字字符。
+
+```js
+assert(
+ 'How vexingly quick daft zebras jump!'.match(alphabetRegexV2).length === 30
+);
+```
+
+你的正則表達式應該在字符串 `123 456 7890 ABC def GHI jkl MNO pqr STU vwx YZ.` 中找到36個字母數字字符。
+
+```js
+assert(
+ '123 456 7890 ABC def GHI jkl MNO pqr STU vwx YZ.'.match(alphabetRegexV2)
+ .length === 36
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let quoteSample = "The five boxing wizards jump quickly.";
+let alphabetRegexV2 = /change/; // Change this line
+let result = quoteSample.match(alphabetRegexV2).length;
+```
+
+# --solutions--
+
+```js
+let quoteSample = "The five boxing wizards jump quickly.";
+let alphabetRegexV2 = /\w/g; // Change this line
+let result = quoteSample.match(alphabetRegexV2).length;
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/match-all-non-numbers.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/match-all-non-numbers.md
new file mode 100644
index 0000000000..13b583d2a6
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/match-all-non-numbers.md
@@ -0,0 +1,85 @@
+---
+id: 587d7db8367417b2b2512ba1
+title: 匹配所有非數字
+challengeType: 1
+forumTopicId: 301347
+dashedName: match-all-non-numbers
+---
+
+# --description--
+
+上一項挑戰中展示瞭如何使用帶有小寫 `d` 的縮寫 `\d` 來搜尋數字。 也可以使用類似的縮寫來搜尋非數字，該縮寫使用大寫的 `D`。
+
+查找非數字字符的縮寫是 `\D`。 這等同於字符串 `[^0-9]`，它查找不是 0 - 9 之間數字的單個字符。
+
+# --instructions--
+
+使用非數字縮寫 `\D` 來計算電影標題中有多少非數字。
+
+# --hints--
+
+你的正則表達式應該使用縮寫來匹配非數字字符。
+
+```js
+assert(/\\D/.test(noNumRegex.source));
+```
+
+你的正則表達式應該使用全局標識。
+
+```js
+assert(noNumRegex.global);
+```
+
+你的正則表達式在 `9` 中應該匹配不到非數字。
+
+```js
+assert('9'.match(noNumRegex) == null);
+```
+
+你的正則表達式應該在 `Catch 22` 中匹配到 6 個非數字。
+
+```js
+assert('Catch 22'.match(noNumRegex).length == 6);
+```
+
+你的正則表達式應該在 `101 Dalmatians` 中匹配到 11 個非數字。
+
+```js
+assert('101 Dalmatians'.match(noNumRegex).length == 11);
+```
+
+你的正則表達式應該在 `One, Two, Three` 中匹配到 15 個非數字。
+
+```js
+assert('One, Two, Three'.match(noNumRegex).length == 15);
+```
+
+你的正則表達式應該在 `21 Jump Street` 中匹配到 12 個非數字。
+
+```js
+assert('21 Jump Street'.match(noNumRegex).length == 12);
+```
+
+你的正則表達式應該在 `2001: A Space Odyssey` 中匹配到 17 個非數字。
+
+```js
+assert('2001: A Space Odyssey'.match(noNumRegex).length == 17);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let movieName = "2001: A Space Odyssey";
+let noNumRegex = /change/; // Change this line
+let result = movieName.match(noNumRegex).length;
+```
+
+# --solutions--
+
+```js
+let movieName = "2001: A Space Odyssey";
+let noNumRegex = /\D/g; // Change this line
+let result = movieName.match(noNumRegex).length;
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/match-all-numbers.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/match-all-numbers.md
new file mode 100644
index 0000000000..98fae780d2
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/match-all-numbers.md
@@ -0,0 +1,85 @@
+---
+id: 5d712346c441eddfaeb5bdef
+title: 匹配所有數字
+challengeType: 1
+forumTopicId: 18181
+dashedName: match-all-numbers
+---
+
+# --description--
+
+已經瞭解了常見字符串匹配模式的元字符，如字母數字。 另一個常見的匹配模式是隻尋找數字。
+
+查找數字字符的縮寫是 `\d`，注意是小寫的 `d`。 這等同於元字符 `[0-9]`，它查找 0 到 9 之間任意數字的單個字符。
+
+# --instructions--
+
+使用縮寫 `\d` 來計算電影標題中有多少個數字。 書面數字（"six" 而不是 6）不計算在內。
+
+# --hints--
+
+你的正則表達式應該使用縮寫來匹配數字字符。
+
+```js
+assert(/\\d/.test(numRegex.source));
+```
+
+您的正則表達式應該使用全局標識。
+
+```js
+assert(numRegex.global);
+```
+
+你的正則表達式應該在 `9` 中匹配到 1 個數字。
+
+```js
+assert('9'.match(numRegex).length == 1);
+```
+
+你的正則表達式應該在 `Catch 22` 中匹配到 2 個數字。
+
+```js
+assert('Catch 22'.match(numRegex).length == 2);
+```
+
+你的正則表達式應該在 `101 Dalmatians` 中匹配到 3 個數字。
+
+```js
+assert('101 Dalmatians'.match(numRegex).length == 3);
+```
+
+你的正則表達式在 `One, Two, Three` 中應該匹配不到數字。
+
+```js
+assert('One, Two, Three'.match(numRegex) == null);
+```
+
+你的正則表達式應該在 `21 Jump Street` 中匹配到 2 個數字。
+
+```js
+assert('21 Jump Street'.match(numRegex).length == 2);
+```
+
+你的正則表達式應該在 `2001: A Space Odyssey` 中匹配到 4 個數字。
+
+```js
+assert('2001: A Space Odyssey'.match(numRegex).length == 4);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let movieName = "2001: A Space Odyssey";
+let numRegex = /change/; // Change this line
+let result = movieName.match(numRegex).length;
+```
+
+# --solutions--
+
+```js
+let movieName = "2001: A Space Odyssey";
+let numRegex = /\d/g; // Change this line
+let result = movieName.match(numRegex).length;
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/match-anything-with-wildcard-period.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/match-anything-with-wildcard-period.md
new file mode 100644
index 0000000000..aadbaa0ecd
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/match-anything-with-wildcard-period.md
@@ -0,0 +1,119 @@
+---
+id: 587d7db5367417b2b2512b94
+title: 用通配符匹配任何內容
+challengeType: 1
+forumTopicId: 301348
+dashedName: match-anything-with-wildcard-period
+---
+
+# --description--
+
+有時不（或不需要）知道匹配模式中的確切字符。 如果要精確匹配到完整的單詞，那出現一個拼寫錯誤就會匹配不到。 幸運的是，可以使用通配符 `.` 來處理這種情況。
+
+通配符 `.` 將匹配任何一個字符。 通配符也叫 `dot` 或 `period`。 可以像使用正則表達式中任何其他字符一樣使用通配符。 例如，如果想匹配 `hug`、`huh`、`hut` 和 `hum`，可以使用正則表達式 `/hu./` 匹配以上四個單詞。
+
+```js
+let humStr = "I'll hum a song";
+let hugStr = "Bear hug";
+let huRegex = /hu./;
+huRegex.test(humStr);
+huRegex.test(hugStr);
+```
+
+上面的 `test` 都會返回 `true`。
+
+# --instructions--
+
+完成正則表達式 `unRegex` 以匹配字符串 `run`、`sun`、`fun`、`pun`、`nun` 和 `bun`。 正則表達式中應該使用通配符。
+
+# --hints--
+
+你應該使用 `.test()` 方法。
+
+```js
+assert(code.match(/\.test\(.*\)/));
+```
+
+你應該在你的正則表達式 `unRegex` 中使用通配符。
+
+```js
+assert(/\./.test(unRegex.source));
+```
+
+你的正則表達式 `unRegex` 應該在字符串 `Let us go on a run.` 中匹配到 `run` 單詞。
+
+```js
+unRegex.lastIndex = 0;
+assert(unRegex.test('Let us go on a run.'));
+```
+
+你的正則表達式 `unRegex` 應該在字符串 `The sun is out today.` 中匹配到 `sun` 單詞。
+
+```js
+unRegex.lastIndex = 0;
+assert(unRegex.test('The sun is out today.'));
+```
+
+你的正則表達式 `unRegex` 應該在字符串 `Coding is a lot of fun.` 中匹配到 `fun` 單詞。
+
+```js
+unRegex.lastIndex = 0;
+assert(unRegex.test('Coding is a lot of fun.'));
+```
+
+你的正則表達式 `unRegex` 應該在字符串 `Seven days without a pun makes one weak.` 中匹配到 `pun`單詞。
+
+```js
+unRegex.lastIndex = 0;
+assert(unRegex.test('Seven days without a pun makes one weak.'));
+```
+
+你的正則表達式 `unRegex` 應該在字符串 `One takes a vow to be a nun.` 中匹配到 `nun` 單詞。
+
+```js
+unRegex.lastIndex = 0;
+assert(unRegex.test('One takes a vow to be a nun.'));
+```
+
+你的正則表達式 `unRegex` 應該在字符串 `She got fired from the hot dog stand for putting her hair in a bun.` 中匹配到 `bun` 單詞。
+
+```js
+unRegex.lastIndex = 0;
+assert(
+ unRegex.test(
+ 'She got fired from the hot dog stand for putting her hair in a bun.'
+ )
+);
+```
+
+你的正則表達式 `unRegex` 不應該匹配 `There is a bug in my code.`。
+
+```js
+unRegex.lastIndex = 0;
+assert(!unRegex.test('There is a bug in my code.'));
+```
+
+你的正則表達式 `unRegex` 不應該匹配 `Catch me if you can.`。
+
+```js
+unRegex.lastIndex = 0;
+assert(!unRegex.test('Catch me if you can.'));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let exampleStr = "Let's have fun with regular expressions!";
+let unRegex = /change/; // Change this line
+let result = unRegex.test(exampleStr);
+```
+
+# --solutions--
+
+```js
+let exampleStr = "Let's have fun with regular expressions!";
+let unRegex = /.un/; // Change this line
+let result = unRegex.test(exampleStr);
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/match-beginning-string-patterns.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/match-beginning-string-patterns.md
new file mode 100644
index 0000000000..47f5c00866
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/match-beginning-string-patterns.md
@@ -0,0 +1,71 @@
+---
+id: 587d7db7367417b2b2512b9d
+title: 匹配字符串的開頭
+challengeType: 1
+forumTopicId: 301349
+dashedName: match-beginning-string-patterns
+---
+
+# --description--
+
+回顧一下之前的挑戰，正則表達式可以用於查找多項匹配。 還可以查詢字符串中符合指定匹配模式的字符。
+
+在之前的挑戰中，使用字符集中前插入符號（`^`）來創建一個否定字符集，形如 `[^thingsThatWillNotBeMatched]`。 除了在字符集中使用之外，脫字符還用於匹配字符串的開始位置。
+
+```js
+let firstString = "Ricky is first and can be found.";
+let firstRegex = /^Ricky/;
+firstRegex.test(firstString);
+let notFirst = "You can't find Ricky now.";
+firstRegex.test(notFirst);
+```
+
+第一次 `test` 調用將返回 `true`，而第二次調用將返回 `false`。
+
+# --instructions--
+
+在正則表達式中使用脫字符來找到 `Cal` 在字符串 `rickyAndCal` 中的開始位置。
+
+# --hints--
+
+你的正則表達式應該搜尋首字母大寫的 `Cal`。
+
+```js
+assert(calRegex.source == '^Cal');
+```
+
+你的正則表達式不應該使用任何標誌。
+
+```js
+assert(calRegex.flags == '');
+```
+
+你的正則表達式應該匹配字符串 `Cal` 的開始位置。
+
+```js
+assert(calRegex.test('Cal and Ricky both like racing.'));
+```
+
+你的正則表達式不應該匹配中間包含 `Cal` 的字符串。
+
+```js
+assert(!calRegex.test('Ricky and Cal both like racing.'));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let rickyAndCal = "Cal and Ricky both like racing.";
+let calRegex = /change/; // Change this line
+let result = calRegex.test(rickyAndCal);
+```
+
+# --solutions--
+
+```js
+let rickyAndCal = "Cal and Ricky both like racing.";
+let calRegex = /^Cal/; // Change this line
+let result = calRegex.test(rickyAndCal);
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/match-characters-that-occur-one-or-more-times.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/match-characters-that-occur-one-or-more-times.md
new file mode 100644
index 0000000000..699c91b625
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/match-characters-that-occur-one-or-more-times.md
@@ -0,0 +1,59 @@
+---
+id: 587d7db6367417b2b2512b99
+title: 匹配出現一次或多次的字符
+challengeType: 1
+forumTopicId: 301350
+dashedName: match-characters-that-occur-one-or-more-times
+---
+
+# --description--
+
+有時，需要匹配出現一次或者連續多次的的字符（或字符組）。 這意味着它至少出現一次，並且可能重複出現。
+
+可以使用 `+` 符號來檢查情況是否如此。 記住，字符或匹配模式必須一個接一個地連續出現。 這就是說，字符必須一個接一個地重複。
+
+例如，`/a+/g` 會在 `abc` 中匹配到一個匹配項，並且返回 `["a"]`。 因爲 `+` 的存在，它也會在 `aabc` 中匹配到一個匹配項，然後返回 `["aa"]`。
+
+如果它是檢查字符串 `abab`，它將匹配到兩個匹配項並且返回`["a", "a"]`，因爲`a`字符不連續，在它們之間有一個`b`字符。 最後，因爲在字符串 `bcd` 中沒有 `a`，因此找不到匹配項。
+
+# --instructions--
+
+想要在字符串 `Mississippi` 中匹配到出現一次或多次的字母 `s` 的匹配項。 編寫一個使用 `+` 符號的正則表達式。
+
+# --hints--
+
+你的正則表達式 `myRegex` 應該使用 `+` 符號來匹配一個或多個 `s` 字符。
+
+```js
+assert(/\+/.test(myRegex.source));
+```
+
+你的正則表達式 `myRegex` 應該匹配兩項。
+
+```js
+assert(result.length == 2);
+```
+
+`result` 變量應該是一個數組，兩個匹配的 `ss`
+
+```js
+assert(result[0] == 'ss' && result[1] == 'ss');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let difficultSpelling = "Mississippi";
+let myRegex = /change/; // Change this line
+let result = difficultSpelling.match(myRegex);
+```
+
+# --solutions--
+
+```js
+let difficultSpelling = "Mississippi";
+let myRegex = /s+/g; // Change this line
+let result = difficultSpelling.match(myRegex);
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/match-characters-that-occur-zero-or-more-times.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/match-characters-that-occur-zero-or-more-times.md
new file mode 100644
index 0000000000..55842b0cb5
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/match-characters-that-occur-zero-or-more-times.md
@@ -0,0 +1,96 @@
+---
+id: 587d7db6367417b2b2512b9a
+title: 匹配出現零次或多次的字符
+challengeType: 1
+forumTopicId: 301351
+dashedName: match-characters-that-occur-zero-or-more-times
+---
+
+# --description--
+
+上一次的挑戰中使用了加號 `+` 來查找出現一次或多次的字符。 還有一個選項可以匹配出現零次或多次的字符。
+
+執行該操作的字符叫做星號，即`*`。
+
+```js
+let soccerWord = "gooooooooal!";
+let gPhrase = "gut feeling";
+let oPhrase = "over the moon";
+let goRegex = /go*/;
+soccerWord.match(goRegex);
+gPhrase.match(goRegex);
+oPhrase.match(goRegex);
+```
+
+按順序排列，三次 `match` 調用將返回值 `["goooooooo"]`，`["g"]` 和 `null`。
+
+# --instructions--
+
+在這個挑戰裏，`chewieQuote` 已經被初始化爲 `Aaaaaaaaaaaaaaaarrrgh!`。 創建一個變量爲 `chewieRegex` 的正則表達式，使用 `*` 在 `chewieQuote` 中匹配 `A` 及其之後出現的零個或多個`a`。 你的正則表達式不需要使用修飾符，也不需要匹配引號。
+
+# --hints--
+
+你的正則表達式 `chewieRegex` 應該使用 `*` 字符來匹配零或更多的 `a` 字符。
+
+```js
+assert(/\*/.test(chewieRegex.source));
+```
+
+正則表達式應當匹配 `chewieQuote` 裏的 `A`。
+
+```js
+assert(result[0][0] === 'A');
+```
+
+你的正則表達式應該與 `chewieQuote` 中的字符串 `Aaaaaaaaaaaaaaaa` 匹配。
+
+```js
+assert(result[0] === 'Aaaaaaaaaaaaaaaa');
+```
+
+你的正則表達式 `chewieRegex` 應該匹配 `chewieQuote` 中的 16 個字符。
+
+```js
+assert(result[0].length === 16);
+```
+
+你的正則表達式不應該有任何匹配，在字符 `He made a fair move. Screaming about it can't help you.`
+
+```js
+assert(
+ !"He made a fair move. Screaming about it can't help you.".match(chewieRegex)
+);
+```
+
+你的正則表達式不應該有任何匹配，在字符 `Let him have it. It's not wise to upset a Wookiee.`
+
+```js
+assert(
+ !"Let him have it. It's not wise to upset a Wookiee.".match(chewieRegex)
+);
+```
+
+# --seed--
+
+## --before-user-code--
+
+```js
+const chewieQuote = "Aaaaaaaaaaaaaaaarrrgh!";
+```
+
+## --seed-contents--
+
+```js
+// Only change code below this line
+let chewieRegex = /change/; // Change this line
+// Only change code above this line
+
+let result = chewieQuote.match(chewieRegex);
+```
+
+# --solutions--
+
+```js
+ let chewieRegex = /Aa*/;
+ let result = chewieQuote.match(chewieRegex);
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/match-ending-string-patterns.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/match-ending-string-patterns.md
new file mode 100644
index 0000000000..825f6b3ac7
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/match-ending-string-patterns.md
@@ -0,0 +1,65 @@
+---
+id: 587d7db7367417b2b2512b9e
+title: 匹配字符串的末尾
+challengeType: 1
+forumTopicId: 301352
+dashedName: match-ending-string-patterns
+---
+
+# --description--
+
+在上一個挑戰中，學習了使用脫字符號來搜尋字符串的開始位置。 還有一種方法可以搜尋字符串末尾的匹配模式。
+
+可以使用正則表達式的美元符號 `$` 來搜尋字符串的結尾。
+
+```js
+let theEnding = "This is a never ending story";
+let storyRegex = /story$/;
+storyRegex.test(theEnding);
+let noEnding = "Sometimes a story will have to end";
+storyRegex.test(noEnding);
+```
+
+第一次 `test` 調用將返回 `true`, 而第二次調用將返回 `false`。
+
+# --instructions--
+
+使用錨點字符 `$` 來匹配字符串 `caboose` 在字符串末尾 `caboose`。
+
+# --hints--
+
+你應該在正則表達式使用美元符號 `$` 來搜尋 `caboose`。
+
+```js
+assert(lastRegex.source == 'caboose$');
+```
+
+你的正則表達式不應該使用任何標誌。
+
+```js
+assert(lastRegex.flags == '');
+```
+
+你應該在字符串 `The last car on a train is the caboose` 的末尾匹配 `caboose`。
+
+```js
+assert(lastRegex.test('The last car on a train is the caboose'));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let caboose = "The last car on a train is the caboose";
+let lastRegex = /change/; // Change this line
+let result = lastRegex.test(caboose);
+```
+
+# --solutions--
+
+```js
+let caboose = "The last car on a train is the caboose";
+let lastRegex = /caboose$/; // Change this line
+let result = lastRegex.test(caboose);
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/match-everything-but-letters-and-numbers.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/match-everything-but-letters-and-numbers.md
new file mode 100644
index 0000000000..62c3ec187d
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/match-everything-but-letters-and-numbers.md
@@ -0,0 +1,92 @@
+---
+id: 587d7db8367417b2b2512ba0
+title: 匹配除了字母和數字的所有符號
+challengeType: 1
+forumTopicId: 301353
+dashedName: match-everything-but-letters-and-numbers
+---
+
+# --description--
+
+已經瞭解到可以使用縮寫 `\w` 來匹配字母和數字 `[A-Za-z0-9_]`。 不過，有可能想要搜尋的匹配模式是非字母數字字符。
+
+可以使用 `\W` 搜尋和 `\w` 相反的匹配模式。 注意，相反匹配模式使用大寫字母。 此縮寫與 `[^A-Za-z0-9_]` 是一樣的。
+
+```js
+let shortHand = /\W/;
+let numbers = "42%";
+let sentence = "Coding!";
+numbers.match(shortHand);
+sentence.match(shortHand);
+```
+
+第一次 `match` 調用將返回值 `["%"]` 而第二次調用將返回 `["!"]`。
+
+# --instructions--
+
+使用縮寫 `\W` 來計算引號中所有非字符字母和數字字符的數量。
+
+# --hints--
+
+你的正則表達式應該使用全局標識。
+
+```js
+assert(nonAlphabetRegex.global);
+```
+
+你的正則表達式應該在 `The five boxing wizards jump quickly.` 中匹配到 6 個非字母數字字符。
+
+```js
+assert(
+ 'The five boxing wizards jump quickly.'.match(nonAlphabetRegex).length == 6
+);
+```
+
+正則表達式應該使用元字符來匹配非字母字符。
+
+```js
+assert(/\\W/.test(nonAlphabetRegex.source));
+```
+
+你的正則表達式應該在 `Pack my box with five dozen liquor jugs.` 中匹配到 8 個非字母數字字符。
+
+```js
+assert(
+ 'Pack my box with five dozen liquor jugs.'.match(nonAlphabetRegex).length == 8
+);
+```
+
+你的正則表達式應該在 `How vexingly quick daft zebras jump!` 中匹配到 6 個非字母數字字符。
+
+```js
+assert(
+ 'How vexingly quick daft zebras jump!'.match(nonAlphabetRegex).length == 6
+);
+```
+
+你的正則表達式應該在字符串 `123 456 7890 ABC def GHI jkl MNO pqr STU vwx YZ.` 中找到12個非字母數字字符。
+
+```js
+assert(
+ '123 456 7890 ABC def GHI jkl MNO pqr STU vwx YZ.'.match(nonAlphabetRegex)
+ .length == 12
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let quoteSample = "The five boxing wizards jump quickly.";
+let nonAlphabetRegex = /change/; // Change this line
+let result = quoteSample.match(nonAlphabetRegex).length;
+```
+
+# --solutions--
+
+```js
+let quoteSample = "The five boxing wizards_jump quickly.";
+let nonAlphabetRegex = /\W/g; // Change this line
+let result = quoteSample.match(nonAlphabetRegex).length;
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/match-letters-of-the-alphabet.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/match-letters-of-the-alphabet.md
new file mode 100644
index 0000000000..fd1904769e
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/match-letters-of-the-alphabet.md
@@ -0,0 +1,71 @@
+---
+id: 587d7db5367417b2b2512b96
+title: 匹配字母表中的字母
+challengeType: 1
+forumTopicId: 301354
+dashedName: match-letters-of-the-alphabet
+---
+
+# --description--
+
+瞭解瞭如何使用字符集（character sets ）來指定要匹配的一組字符串，但是有時需要匹配大量字符（例如，字母表中的每個字母）。 有一種寫法可以讓實現這個功能變得簡短。
+
+在字符集中，可以使用連字符（`-`）來定義要匹配的字符範圍。
+
+例如，要匹配小寫字母 `a` 到 `e`，你可以使用 `[a-e]`。
+
+```js
+let catStr = "cat";
+let batStr = "bat";
+let matStr = "mat";
+let bgRegex = /[a-e]at/;
+catStr.match(bgRegex);
+batStr.match(bgRegex);
+matStr.match(bgRegex);
+```
+
+按順序排列，三次 `match` 調用將返回值 `["cat"]`，`["bat"]` 和 `null`。
+
+# --instructions--
+
+匹配字符串 `quoteSample` 中的所有字母。
+
+**注意**：一定要同時匹配大小寫字母。
+
+# --hints--
+
+你的正則表達式 `alphabetRegex` 應該匹配 35 項。
+
+```js
+assert(result.length == 35);
+```
+
+你的正則表達式 `alphabetRegex` 應該使用全局標識。
+
+```js
+assert(alphabetRegex.flags.match(/g/).length == 1);
+```
+
+你的正則表達式 `alphabetRegex` 應該使用忽略大小寫標誌。
+
+```js
+assert(alphabetRegex.flags.match(/i/).length == 1);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let quoteSample = "The quick brown fox jumps over the lazy dog.";
+let alphabetRegex = /change/; // Change this line
+let result = alphabetRegex; // Change this line
+```
+
+# --solutions--
+
+```js
+let quoteSample = "The quick brown fox jumps over the lazy dog.";
+let alphabetRegex = /[a-z]/gi; // Change this line
+let result = quoteSample.match(alphabetRegex); // Change this line
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/match-literal-strings.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/match-literal-strings.md
new file mode 100644
index 0000000000..dea404d5f1
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/match-literal-strings.md
@@ -0,0 +1,72 @@
+---
+id: 587d7db3367417b2b2512b8f
+title: 匹配文字字符串
+challengeType: 1
+forumTopicId: 301355
+dashedName: match-literal-strings
+---
+
+# --description--
+
+在上一個挑戰中，使用正則表達式 `/Hello/` 搜索到了字符串 `Hello`。 那個正則表達式在字符串中搜尋 `Hello` 的文字匹配。 下面是另一個在字符串中搜尋 `Kevin` 的示例：
+
+```js
+let testStr = "Hello, my name is Kevin.";
+let testRegex = /Kevin/;
+testRegex.test(testStr);
+```
+
+`test` 方法會返回 `true`。
+
+任何其他形式的 `Kevin` 都不會被匹配。 例如，正則表達式 `/Kevin/` 不會匹配 `kevin` 或者`KEVIN`。
+
+```js
+let wrongRegex = /kevin/;
+wrongRegex.test(testStr);
+```
+
+此 `test` 調用將返回 `false`。
+
+後續的挑戰將爲你展示如何匹配其他形式的字符串。
+
+# --instructions--
+
+完成正則表達式 `waldoRegex`，在字符串 `waldoIsHiding` 中匹配到文本 `"Waldo"`。
+
+# --hints--
+
+你的正則表達式 `waldoRegex` 應該匹配到 `Waldo`。
+
+```js
+assert(waldoRegex.test(waldoIsHiding));
+```
+
+你的正則表達式 `waldoRegex` 不應該搜尋其他的任何內容。
+
+```js
+assert(!waldoRegex.test('Somewhere is hiding in this text.'));
+```
+
+你應該使用你的正則表達式對字符串執行文字匹配。
+
+```js
+assert(!/\/.*\/i/.test(code));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let waldoIsHiding = "Somewhere Waldo is hiding in this text.";
+let waldoRegex = /search/; // Change this line
+let result = waldoRegex.test(waldoIsHiding);
+```
+
+# --solutions--
+
+```js
+let waldoIsHiding = "Somewhere Waldo is hiding in this text.";
+let waldoRegex = /Waldo/; // Change this line
+let result = waldoRegex.test(waldoIsHiding);
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/match-non-whitespace-characters.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/match-non-whitespace-characters.md
new file mode 100644
index 0000000000..aaa44b4739
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/match-non-whitespace-characters.md
@@ -0,0 +1,78 @@
+---
+id: 587d7db9367417b2b2512ba4
+title: 匹配非空白字符
+challengeType: 1
+forumTopicId: 18210
+dashedName: match-non-whitespace-characters
+---
+
+# --description--
+
+已經學會了如何使用帶有小寫 `s` 的縮寫 `\s` 來搜尋空白字符。 還可以搜尋除了空格之外的所有內容。
+
+使用 `\S` 搜尋非空白字符，其中 `s` 是大寫。 此匹配模式將不匹配空格、回車符、製表符、換頁符和換行符。 可以認爲這類似於元字符 `[^ \r\t\f\n\v]`。
+
+```js
+let whiteSpace = "Whitespace. Whitespace everywhere!"
+let nonSpaceRegex = /\S/g;
+whiteSpace.match(nonSpaceRegex).length;
+```
+
+返回值的 `.length` 應該是 `32`。
+
+# --instructions--
+
+修改正則表達式 `countNonWhiteSpace` 以查找字符串中的多個非空字符。
+
+# --hints--
+
+您的正則表達式應該使用全局標識。
+
+```js
+assert(countNonWhiteSpace.global);
+```
+
+你的正則表達式應該使用簡寫字符 `\S` 來匹配所有非空白字符。
+
+```js
+assert(/\\S/.test(countNonWhiteSpace.source));
+```
+
+您的正則表達式應該在字符串 `Men are from Mars and women are from Venus.` 中找到 35 個非空格字符。
+
+```js
+assert(
+ 'Men are from Mars and women are from Venus.'.match(countNonWhiteSpace)
+ .length == 35
+);
+```
+
+你的正則表達式應該在 `Space: the final frontier.` 中匹配到 23 個非空白字符。
+
+```js
+assert('Space: the final frontier.'.match(countNonWhiteSpace).length == 23);
+```
+
+你的正則表達式應該在 `MindYourPersonalSpace` 中匹配到 21 個非空白字符。
+
+```js
+assert('MindYourPersonalSpace'.match(countNonWhiteSpace).length == 21);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let sample = "Whitespace is important in separating words";
+let countNonWhiteSpace = /change/; // Change this line
+let result = sample.match(countNonWhiteSpace);
+```
+
+# --solutions--
+
+```js
+let sample = "Whitespace is important in separating words";
+let countNonWhiteSpace = /\S/g; // Change this line
+let result = sample.match(countNonWhiteSpace);
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/match-numbers-and-letters-of-the-alphabet.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/match-numbers-and-letters-of-the-alphabet.md
new file mode 100644
index 0000000000..8e6fa4d4d6
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/match-numbers-and-letters-of-the-alphabet.md
@@ -0,0 +1,63 @@
+---
+id: 587d7db5367417b2b2512b97
+title: 匹配字母表中的數字和字母
+challengeType: 1
+forumTopicId: 301356
+dashedName: match-numbers-and-letters-of-the-alphabet
+---
+
+# --description--
+
+使用連字符（`-`）匹配字符範圍並不僅限於字母。 它還可以匹配一系列數字。
+
+例如，`/[0-5]/` 匹配 `0` 和 `5` 之間的任意數字，包含 `0` 和 `5`。
+
+此外，還可以在單個字符集中組合一系列字母和數字。
+
+```js
+let jennyStr = "Jenny8675309";
+let myRegex = /[a-z0-9]/ig;
+jennyStr.match(myRegex);
+```
+
+# --instructions--
+
+創建一個正則表達式，使其可以匹配 `h` 和 `s` 之間的一系列字母，以及 `2` 和 `6` 之間的一系列數字。 請記得在正則表達式中包含恰當的標誌。
+
+# --hints--
+
+你的正則表達式 `myRegex` 應該匹配 17 項。
+
+```js
+assert(result.length == 17);
+```
+
+你的正則表達式 `myRegex` 應該使用全局標誌。
+
+```js
+assert(myRegex.flags.match(/g/).length == 1);
+```
+
+你的正則表達式 `myRegex` 應該使用忽略大小寫的標誌。
+
+```js
+assert(myRegex.flags.match(/i/).length == 1);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let quoteSample = "Blueberry 3.141592653s are delicious.";
+let myRegex = /change/; // Change this line
+let result = myRegex; // Change this line
+```
+
+# --solutions--
+
+```js
+let quoteSample = "Blueberry 3.141592653s are delicious.";
+let myRegex = /[h-s2-6]/gi; // Change this line
+let result = quoteSample.match(myRegex); // Change this line
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/match-single-character-with-multiple-possibilities.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/match-single-character-with-multiple-possibilities.md
new file mode 100644
index 0000000000..e1ebd609ef
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/match-single-character-with-multiple-possibilities.md
@@ -0,0 +1,85 @@
+---
+id: 587d7db5367417b2b2512b95
+title: 將單個字符與多種可能性匹配
+challengeType: 1
+forumTopicId: 301357
+dashedName: match-single-character-with-multiple-possibilities
+---
+
+# --description--
+
+已經瞭解了文字匹配模式（`/literal/`）和通配符（`/./`）。 這是正則表達式的兩種極端情況，一種是精確匹配，而另一種則是匹配所有。 在這兩種極端情況之間有一個平衡選項。
+
+可以使用字符集 （character classes ）更靈活的匹配字符。 可以把字符集放在方括號（`[` 和 `]`）之間來定義一組需要匹配的字符串。
+
+例如，如果想要匹配 `bag`、`big` 和 `bug`，但是不想匹配 `bog`。 可以創建正則表達式 `/b[aiu]g/` 來執行此操作。 `[aiu]` 是隻匹配字符 `a`、`i` 或者 `u` 的字符集。
+
+```js
+let bigStr = "big";
+let bagStr = "bag";
+let bugStr = "bug";
+let bogStr = "bog";
+let bgRegex = /b[aiu]g/;
+bigStr.match(bgRegex);
+bagStr.match(bgRegex);
+bugStr.match(bgRegex);
+bogStr.match(bgRegex);
+```
+
+按順序排列，四次 `match` 調用將返回值 `["big"]`、`["bag"]`、`["bug"]` 和 `null`。
+
+# --instructions--
+
+使用元音字符集（`a`、`e`、`i`、`o`、`u`）在正則表達式 `vowelRegex` 中匹配到字符串 `quoteSample` 中的所有元音。
+
+**注意:**一定要同時匹配大小寫元音。
+
+# --hints--
+
+你應該匹配到所有25個元音。
+
+```js
+assert(result.length == 25);
+```
+
+你的正則表達式 `vowelRegex` 應該使用字符集。
+
+```js
+assert(/\[.*\]/.test(vowelRegex.source));
+```
+
+你的正則表達式 `vowelRegex` 應該使用全局標誌。
+
+```js
+assert(vowelRegex.flags.match(/g/).length == 1);
+```
+
+你的正則表達式 `vowelRegex` 應該使用忽略大小寫標誌。
+
+```js
+assert(vowelRegex.flags.match(/i/).length == 1);
+```
+
+你的正則表達式不應該匹配任何輔音。
+
+```js
+assert(!/[b-df-hj-np-tv-z]/gi.test(result.join()));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let quoteSample = "Beware of bugs in the above code; I have only proved it correct, not tried it.";
+let vowelRegex = /change/; // Change this line
+let result = vowelRegex; // Change this line
+```
+
+# --solutions--
+
+```js
+let quoteSample = "Beware of bugs in the above code; I have only proved it correct, not tried it.";
+let vowelRegex = /[aeiou]/gi; // Change this line
+let result = quoteSample.match(vowelRegex); // Change this line
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/match-single-characters-not-specified.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/match-single-characters-not-specified.md
new file mode 100644
index 0000000000..1ce88fffad
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/match-single-characters-not-specified.md
@@ -0,0 +1,57 @@
+---
+id: 587d7db6367417b2b2512b98
+title: 匹配單個未指定的字符
+challengeType: 1
+forumTopicId: 301358
+dashedName: match-single-characters-not-specified
+---
+
+# --description--
+
+到目前爲止，已經創建了一個想要匹配的字符集合，但也可以創建一個不想匹配的字符集合。 這些類型的字符集稱爲否定字符集（ negated character sets ）。
+
+要創建否定字符集，需要在開始括號後面和不想匹配的字符前面放置脫字符（即`^`）。
+
+例如，`/[^aeiou]/gi` 匹配所有非元音字符。 注意，字符 `.`、`!`、`[`、`@`、`/` 和空白字符等也會被匹配，該否定字符集僅排除元音字符。
+
+# --instructions--
+
+創建一個匹配所有非數字或元音字符的正則表達式。 請記得在正則表達式中包含恰當的標誌。
+
+# --hints--
+
+你的正則表達式 `myRegex` 應該匹配 9 項。
+
+```js
+assert(result.length == 9);
+```
+
+你的正則表達式 `myRegex` 應該使用全局標誌。
+
+```js
+assert(myRegex.flags.match(/g/).length == 1);
+```
+
+你的正則表達式 `myRegex` 應該使用忽略大小寫標誌。
+
+```js
+assert(myRegex.flags.match(/i/).length == 1);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let quoteSample = "3 blind mice.";
+let myRegex = /change/; // Change this line
+let result = myRegex; // Change this line
+```
+
+# --solutions--
+
+```js
+let quoteSample = "3 blind mice.";
+let myRegex = /[^0-9aeiou]/gi; // Change this line
+let result = quoteSample.match(myRegex); // Change this line
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/match-whitespace.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/match-whitespace.md
new file mode 100644
index 0000000000..c8b624df4f
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/match-whitespace.md
@@ -0,0 +1,77 @@
+---
+id: 587d7db8367417b2b2512ba3
+title: 匹配空白字符
+challengeType: 1
+forumTopicId: 301359
+dashedName: match-whitespace
+---
+
+# --description--
+
+迄今爲止的挑戰包括匹配字母和數字。 還可以匹配字符之間的空格。
+
+可以使用 `\s` 搜尋空格，其中 `s` 是小寫。 此匹配模式將匹配空格、回車符、製表符、換頁符和換行符。 可以認爲這類似於元字符 `[ \r\t\f\n\v]`。
+
+```js
+let whiteSpace = "Whitespace. Whitespace everywhere!"
+let spaceRegex = /\s/g;
+whiteSpace.match(spaceRegex);
+```
+
+這個 `match` 調用將返回 `[" ", " "]`。
+# --instructions--
+
+修改正則表達式 `countWhiteSpace` 查找字符串中的多個空白字符。
+
+# --hints--
+
+你的正則表達式應該使用全局標識。
+
+```js
+assert(countWhiteSpace.global);
+```
+
+正則表達式應該使用元字符 `\s` 匹配所有的空白。
+
+```js
+assert(/\\s/.test(countWhiteSpace.source));
+```
+
+你的正則表達式應該在字符串 `Men are from Mars and women are from Venus.` 中找到 8 個非空格字符。
+
+```js
+assert(
+ 'Men are from Mars and women are from Venus.'.match(countWhiteSpace).length ==
+ 8
+);
+```
+
+你的正則表達式應該在 `Space: the final frontier.` 中匹配到 3 個非空白字符。
+
+```js
+assert('Space: the final frontier.'.match(countWhiteSpace).length == 3);
+```
+
+你的正則表達式在 `MindYourPersonalSpace` 中應該匹配不到空白字符。
+
+```js
+assert('MindYourPersonalSpace'.match(countWhiteSpace) == null);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let sample = "Whitespace is important in separating words";
+let countWhiteSpace = /change/; // Change this line
+let result = sample.match(countWhiteSpace);
+```
+
+# --solutions--
+
+```js
+let sample = "Whitespace is important in separating words";
+let countWhiteSpace = /\s/g;
+let result = sample.match(countWhiteSpace);
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/positive-and-negative-lookahead.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/positive-and-negative-lookahead.md
new file mode 100644
index 0000000000..8e307ccd4f
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/positive-and-negative-lookahead.md
@@ -0,0 +1,114 @@
+---
+id: 587d7dba367417b2b2512ba9
+title: 正向先行斷言和負向先行斷言
+challengeType: 1
+forumTopicId: 301360
+dashedName: positive-and-negative-lookahead
+---
+
+# --description--
+
+先行斷言 （Lookaheads ）是告訴 JavaScript 在字符串中向前查找的匹配模式。 當想要在同一個字符串上搜尋多個匹配模式時，這可能非常有用。
+
+有兩種先行斷言：正向先行斷言（positive lookahead ）和負向先行斷言（negative lookahead ）。
+
+正向先行斷言會查看並確保搜索匹配模式中的元素存在，但實際上並不匹配。 正向先行斷言的用法是 `(?=...)`，其中 `...` 就是需要存在但不會被匹配的部分。
+
+另一方面，負向先行斷言會查看並確保搜索匹配模式中的元素不存在。 負向先行斷言的用法是 `(?!...)`，其中 `...` 是希望不存在的匹配模式。 如果負向先行斷言部分不存在，將返回匹配模式的其餘部分。
+
+儘管先行斷言有點兒令人困惑，但是這些示例會有所幫助。
+
+```js
+let quit = "qu";
+let noquit = "qt";
+let quRegex= /q(?=u)/;
+let qRegex = /q(?!u)/;
+quit.match(quRegex);
+noquit.match(qRegex);
+```
+
+這兩次 `match` 調用都將返回 `["q"]`。
+
+先行斷言的更實際用途是檢查一個字符串中的兩個或更多匹配模式。 這裏有一個簡單的密碼檢查器，密碼規則是 3 到 6 個字符且至少包含一個數字：
+
+```js
+let password = "abc123";
+let checkPass = /(?=\w{3,6})(?=\D*\d)/;
+checkPass.test(password);
+```
+
+# --instructions--
+
+在正則表達式 `pwRegex` 中使用先行斷言以匹配大於 5 個字符且有兩個連續數字的密碼。
+
+# --hints--
+
+你的正則表達式應該使用兩個正向先行斷言（ `lookaheads`）。
+
+```js
+assert(pwRegex.source.match(/\(\?=.*?\)\(\?=.*?\)/) !== null);
+```
+
+您的正則表達式不應匹配字符串 `astronaut`
+
+```js
+assert(!pwRegex.test('astronaut'));
+```
+
+你的正則表達式不應匹配字符串 `banan1`
+
+```js
+assert(!pwRegex.test('banan1'));
+```
+
+你的正則表達式應該匹配字符串 `bana12`
+
+```js
+assert(pwRegex.test('bana12'));
+```
+
+你的正則表達式應該匹配字符串 `abc123`
+
+```js
+assert(pwRegex.test('abc123'));
+```
+
+你的正則表達式不應匹配字符串 `12345`
+
+```js
+assert(!pwRegex.test('12345'));
+```
+
+你的正則表達式應該匹配字符串 `8pass99`
+
+```js
+assert(pwRegex.test('8pass99'));
+```
+
+你的正表達式不應匹配字符串 `1a2bcde`
+
+```js
+assert(!pwRegex.test('1a2bcde'));
+```
+
+你的正則表達式應該匹配字符串 `astr1on11aut`
+
+```js
+assert(pwRegex.test('astr1on11aut'));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let sampleWord = "astronaut";
+let pwRegex = /change/; // Change this line
+let result = pwRegex.test(sampleWord);
+```
+
+# --solutions--
+
+```js
+let pwRegex = /(?=\w{6})(?=\w*\d{2})/;
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/remove-whitespace-from-start-and-end.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/remove-whitespace-from-start-and-end.md
new file mode 100644
index 0000000000..2159723436
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/remove-whitespace-from-start-and-end.md
@@ -0,0 +1,55 @@
+---
+id: 587d7dbb367417b2b2512bac
+title: 刪除開頭和結尾的空白
+challengeType: 1
+forumTopicId: 301362
+dashedName: remove-whitespace-from-start-and-end
+---
+
+# --description--
+
+有時字符串周圍存在的空白字符並不是必需的。 字符串的典型處理是刪除字符串開頭和結尾處的空格。
+
+# --instructions--
+
+編寫一個正則表達式並使用適當的字符串方法刪除字符串開頭和結尾的空格。
+
+**注意：** `String.prototype.trim()` 方法在這裏也可以實現同樣的效果，但是你需要使用正則表達式來完成此項挑戰。
+
+# --hints--
+
+`result` 應該等於 `Hello, World!`
+
+```js
+assert(result == 'Hello, World!');
+```
+
+你不應該使用 `String.prototype.trim()` 方法。
+
+```js
+assert(!code.match(/\.?[\s\S]*?trim/));
+```
+
+`result` 變量不應該設置爲等於字符串。
+
+```js
+assert(!code.match(/result\s*=\s*".*?"/));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let hello = " Hello, World! ";
+let wsRegex = /change/; // Change this line
+let result = hello; // Change this line
+```
+
+# --solutions--
+
+```js
+let hello = " Hello, World! ";
+let wsRegex = /^(\s+)(.+[^\s])(\s+)$/;
+let result = hello.replace(wsRegex, '$2');
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/restrict-possible-usernames.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/restrict-possible-usernames.md
new file mode 100644
index 0000000000..282e9dc959
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/restrict-possible-usernames.md
@@ -0,0 +1,123 @@
+---
+id: 587d7db8367417b2b2512ba2
+title: 限制可能的用戶名
+challengeType: 1
+forumTopicId: 301363
+dashedName: restrict-possible-usernames
+---
+
+# --description--
+
+用戶名在互聯網上隨處可見。 它們是用戶在自己喜歡的網站上的唯一身份。
+
+需要檢索數據庫中的所有用戶名。 以下是用戶在創建用戶名時必須遵守的一些簡單規則。
+
+1) 用戶名只能是數字字母字符。
+
+2) 用戶名中的數字必須在最後。 數字可以有零個或多個。 用戶名不能以數字開頭。
+
+3) 用戶名字母可以是小寫字母和大寫字母。
+
+4) 用戶名長度必須至少爲兩個字符。 兩位用戶名只能使用字母。
+
+# --instructions--
+
+修改正則表達式 `userCheck` 以滿足上面列出的約束。
+
+# --hints--
+
+你的正則表達式應該匹配字符串 `JACK`
+
+```js
+assert(userCheck.test('JACK'));
+```
+
+你的正則表達式不應匹配字符串 `J`
+
+```js
+assert(!userCheck.test('J'));
+```
+
+你的正則表達式應該匹配字符串 `Jo`
+
+```js
+assert(userCheck.test('Jo'));
+```
+
+你的正則表達式應該匹配字符串 `Oceans11`
+
+```js
+assert(userCheck.test('Oceans11'));
+```
+
+你的正則表達式應該匹配字符串 `RegexGuru`
+
+```js
+assert(userCheck.test('RegexGuru'));
+```
+
+你的正則表達式不應匹配字符串 `007`
+
+```js
+assert(!userCheck.test('007'));
+```
+
+你的正則表達式不應匹配字符串 `9`
+
+```js
+assert(!userCheck.test('9'));
+```
+
+你的正則表達式不應匹配字符串 `A1`
+
+```js
+assert(!userCheck.test('A1'));
+```
+
+你的正則表達式不應匹配字符串 `BadUs3rnam3`
+
+```js
+assert(!userCheck.test('BadUs3rnam3'));
+```
+
+你的正則表達式應該匹配字符串 `Z97`
+
+```js
+assert(userCheck.test('Z97'));
+```
+
+你的正則表達式不應匹配字符串 `c57bT3`
+
+```js
+assert(!userCheck.test('c57bT3'));
+```
+
+你的正則表達式應該匹配字符串 `AB1`
+
+```js
+assert(userCheck.test('AB1'));
+```
+
+你的正則表達式不應匹配字符串 `J%4`
+
+```js
+assert(!userCheck.test('J%4'))
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let username = "JackOfAllTrades";
+let userCheck = /change/; // Change this line
+let result = userCheck.test(username);
+```
+
+# --solutions--
+
+```js
+let username = "JackOfAllTrades";
+const userCheck = /^[a-z]([0-9]{2,}|[a-z]+\d*)$/i;
+let result = userCheck.test(username);
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/reuse-patterns-using-capture-groups.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/reuse-patterns-using-capture-groups.md
new file mode 100644
index 0000000000..b3d0c5e515
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/reuse-patterns-using-capture-groups.md
@@ -0,0 +1,106 @@
+---
+id: 587d7dbb367417b2b2512baa
+title: 使用捕獲組重用模式
+challengeType: 1
+forumTopicId: 301364
+dashedName: reuse-patterns-using-capture-groups
+---
+
+# --description--
+
+一些你所搜尋的匹配模式會在字符串中出現多次。 手動重複該正則表達式顯得不夠簡潔。 當字符串中出現多個重複子字符串時，有一種更好的方式來編寫模式。
+
+可以使用捕獲組（capture groups ）搜尋重複的子字符串。 括號 `(` 和 `)` 可以用來匹配重複的子字符串。 把需要重複匹配的模式放在括號中即可。
+
+要指定重複字符串將出現的位置，可以使用反斜槓（`\`）後接一個數字。 這個數字從 1 開始，隨着你使用的每個捕獲組的增加而增加。 這裏有一個示例，`\1` 可以匹配第一個組。
+
+下面的示例展示的是匹配被空格隔開的兩個相同單詞：
+
+```js
+let repeatStr = "regex regex";
+let repeatRegex = /(\w+)\s\1/;
+repeatRegex.test(repeatStr);
+repeatStr.match(repeatRegex);
+```
+
+`test` 調用將返回 `true`，`match` 調用將返回 `["regex regex", "regex"]`。
+
+在字符串上調用 `.match()` 方法將返回一個數組，其中包含它最終匹配到的字符串及其捕獲組。
+
+# --instructions--
+
+在 `reRegex` 中使用捕獲組來匹配一個只由相同的數字重複三次組成的由空格分隔字符串。
+
+# --hints--
+
+你的正則表達式應該使用數字的簡寫字符類。
+
+```js
+assert(reRegex.source.match(/\\d/));
+```
+
+你的正則表達式應該使用捕獲組兩次。
+
+```js
+assert(reRegex.source.match(/\\1|\\2/g).length >= 2);
+```
+
+你的正則表達式應該匹配字符串 `42 42 42`。
+
+```js
+assert(reRegex.test('42 42 42'));
+```
+
+你的正則表達式應該匹配字符串 `100 100 100`。
+
+```js
+assert(reRegex.test('100 100 100'));
+```
+
+你的正則表達式不應匹配字符串 `42 42 42 42`。
+
+```js
+assert.equal('42 42 42 42'.match(reRegex.source), null);
+```
+
+你的正則表達式不應該匹配字符串 `42 42`。
+
+```js
+assert.equal('42 42'.match(reRegex.source), null);
+```
+
+你的正則表達式不應該匹配字符串 `101 102 103`。
+
+```js
+assert(!reRegex.test('101 102 103'));
+```
+
+你的正則表達式不應匹配字符串 `1 2 3`。
+
+```js
+assert(!reRegex.test('1 2 3'));
+```
+
+你的正則表達式不應匹配字符串 `10 10 10`。
+
+```js
+assert(reRegex.test('10 10 10'));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let repeatNum = "42 42 42";
+let reRegex = /change/; // Change this line
+let result = reRegex.test(repeatNum);
+```
+
+# --solutions--
+
+```js
+let repeatNum = "42 42 42";
+let reRegex = /^(\d+)\s\1\s\1$/;
+let result = reRegex.test(repeatNum);
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/specify-exact-number-of-matches.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/specify-exact-number-of-matches.md
new file mode 100644
index 0000000000..7da8542fae
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/specify-exact-number-of-matches.md
@@ -0,0 +1,92 @@
+---
+id: 587d7db9367417b2b2512ba7
+title: 指定匹配的確切數量
+challengeType: 1
+forumTopicId: 301365
+dashedName: specify-exact-number-of-matches
+---
+
+# --description--
+
+可以使用帶有花括號的數量說明符來指定匹配模式的上下限。 但有時只需要特定數量的匹配。
+
+要指定一定數量的匹配模式，只需在大括號之間放置一個數字。
+
+例如，要只匹配字母 `a` 出現 `3` 次的單詞`hah`，正則表達式應爲`/ha{3}h/`。
+
+```js
+let A4 = "haaaah";
+let A3 = "haaah";
+let A100 = "h" + "a".repeat(100) + "h";
+let multipleHA = /ha{3}h/;
+multipleHA.test(A4);
+multipleHA.test(A3);
+multipleHA.test(A100);
+```
+
+按順序排列，三次 `test` 調用將返回值 `false`，`true` 和 `false`。
+
+# --instructions--
+
+修改正則表達式`timRegex`，以匹配僅有四個字母 `m` 的單詞 `Timber`。
+
+# --hints--
+
+你的正則表達式應該使用花括號。
+
+```js
+assert(timRegex.source.match(/{.*?}/).length > 0);
+```
+
+你的正則表達式不應匹配字符串 `Timber`
+
+```js
+timRegex.lastIndex = 0;
+assert(!timRegex.test('Timber'));
+```
+
+你的正則表達式不應匹配字符串 `Timmber`
+
+```js
+timRegex.lastIndex = 0;
+assert(!timRegex.test('Timmber'));
+```
+
+你的正則表達式不應匹配字符串 `Timmmber`
+
+```js
+timRegex.lastIndex = 0;
+assert(!timRegex.test('Timmmber'));
+```
+
+你的正則表達式應該匹配字符串 `Timmmmber`
+
+```js
+timRegex.lastIndex = 0;
+assert(timRegex.test('Timmmmber'));
+```
+
+你的正則表達式不應該匹配包含 30 個字母 `m` 的 `Timber`。
+
+```js
+timRegex.lastIndex = 0;
+assert(!timRegex.test('Ti' + 'm'.repeat(30) + 'ber'));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let timStr = "Timmmmber";
+let timRegex = /change/; // Change this line
+let result = timRegex.test(timStr);
+```
+
+# --solutions--
+
+```js
+let timStr = "Timmmmber";
+let timRegex = /Tim{4}ber/; // Change this line
+let result = timRegex.test(timStr);
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/specify-only-the-lower-number-of-matches.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/specify-only-the-lower-number-of-matches.md
new file mode 100644
index 0000000000..ba6da44f89
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/specify-only-the-lower-number-of-matches.md
@@ -0,0 +1,93 @@
+---
+id: 587d7db9367417b2b2512ba6
+title: 只指定匹配的下限
+challengeType: 1
+forumTopicId: 301366
+dashedName: specify-only-the-lower-number-of-matches
+---
+
+# --description--
+
+可以使用帶有花括號的數量說明符來指定匹配模式的上下限。 但有時候只想指定匹配模式的下限而不需要指定上限。
+
+爲此，在第一個數字後面跟一個逗號即可。
+
+例如，要匹配至少出現 `3` 次字母 `a` 的字符串 `hah`，正則表達式應該是 `/ha{3,}h/`。
+
+```js
+let A4 = "haaaah";
+let A2 = "haah";
+let A100 = "h" + "a".repeat(100) + "h";
+let multipleA = /ha{3,}h/;
+multipleA.test(A4);
+multipleA.test(A2);
+multipleA.test(A100);
+```
+
+按順序排列，三次 `test` 調用將返回值 `true`，`false` 和 `true`。
+
+# --instructions--
+
+修改正則表達式 `haRegex`，匹配包含四個或更多字母 `z` 的單詞 `Hazzah`。
+
+# --hints--
+
+你的正則表達式應該使用花括號。
+
+```js
+assert(haRegex.source.match(/{.*?}/).length > 0);
+```
+
+你的正則表達式不應匹配字符串 `Hazzah`
+
+```js
+assert(!haRegex.test('Hazzah'));
+```
+
+你的正則表達式不應匹配字符串 `Hazzzah`
+
+```js
+assert(!haRegex.test('Hazzzah'));
+```
+
+你的正則表達式應該匹配字符串 `Hazzzzah`
+
+```js
+assert('Hazzzzah'.match(haRegex)[0].length === 8);
+```
+
+你的正則表達式應該匹配字符串 `Hazzzzzah`
+
+```js
+assert('Hazzzzzah'.match(haRegex)[0].length === 9);
+```
+
+你的正則表達式應該匹配字符串 `Hazzzzzzah`
+
+```js
+assert('Hazzzzzzah'.match(haRegex)[0].length === 10);
+```
+
+你的正則表達式應該匹配包含 30 個字母 `z` 的 `Hazzah`。
+
+```js
+assert('Hazzzzzzzzzzzzzzzzzzzzzzzzzzzzzzah'.match(haRegex)[0].length === 34);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let haStr = "Hazzzzah";
+let haRegex = /change/; // Change this line
+let result = haRegex.test(haStr);
+```
+
+# --solutions--
+
+```js
+let haStr = "Hazzzzah";
+let haRegex = /Haz{4,}ah/; // Change this line
+let result = haRegex.test(haStr);
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/specify-upper-and-lower-number-of-matches.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/specify-upper-and-lower-number-of-matches.md
new file mode 100644
index 0000000000..45332abd5a
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/specify-upper-and-lower-number-of-matches.md
@@ -0,0 +1,91 @@
+---
+id: 587d7db9367417b2b2512ba5
+title: 指定匹配的上限和下限
+challengeType: 1
+forumTopicId: 301367
+dashedName: specify-upper-and-lower-number-of-matches
+---
+
+# --description--
+
+回想一下，使用加號 `+` 查找一個或多個字符，使用星號 `*` 查找零個或多個字符。 這些都很方便，但有時需要匹配一定範圍的匹配模式。
+
+可以使用數量說明符（quantity specifiers ）指定匹配模式的上下限。 數量說明符與花括號（`{` 和 `}`）一起使用。 可以在花括號之間放兩個數字，這兩個數字代表匹配模式的上限和下限。
+
+例如，要匹配出現 `3` 到 `5` 次字母 `a` 的在字符串 `ah`，正則表達式應爲`/a{3,5}h/`。
+
+```js
+let A4 = "aaaah";
+let A2 = "aah";
+let multipleA = /a{3,5}h/;
+multipleA.test(A4);
+multipleA.test(A2);
+```
+
+第一次 `test` 調用將返回 `true`，而第二次調用將返回 `false`。
+
+# --instructions--
+
+修改正則表達式 `ohRegex` 以匹配出現 `3` 到 `6` 次字母 `h` 的字符串 `Oh no`。
+
+# --hints--
+
+你的正則表達式應該使用花括號。
+
+```js
+assert(ohRegex.source.match(/{.*?}/).length > 0);
+```
+
+你的正則表達式不應匹配字符串 `Ohh no`
+
+```js
+assert(!ohRegex.test('Ohh no'));
+```
+
+你的正則表達式應該匹配字符串 `Ohhh no`
+
+```js
+assert('Ohhh no'.match(ohRegex)[0].length === 7);
+```
+
+你的正則表達式應該匹配字符串 `Ohhhh no`
+
+```js
+assert('Ohhhh no'.match(ohRegex)[0].length === 8);
+```
+
+你的正則表達式應該匹配字符串 `Ohhhhh no`
+
+```js
+assert('Ohhhhh no'.match(ohRegex)[0].length === 9);
+```
+
+你的正則表達式應該匹配字符串 `Ohhhhhh no`
+
+```js
+assert('Ohhhhhh no'.match(ohRegex)[0].length === 10);
+```
+
+你的正則表達式應該匹配字符串 `Ohhhhhhh no`
+
+```js
+assert(!ohRegex.test('Ohhhhhhh no'));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let ohStr = "Ohhh no";
+let ohRegex = /change/; // Change this line
+let result = ohRegex.test(ohStr);
+```
+
+# --solutions--
+
+```js
+let ohStr = "Ohhh no";
+let ohRegex = /Oh{3,6} no/; // Change this line
+let result = ohRegex.test(ohStr);
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/use-capture-groups-to-search-and-replace.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/use-capture-groups-to-search-and-replace.md
new file mode 100644
index 0000000000..f7ca692246
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/use-capture-groups-to-search-and-replace.md
@@ -0,0 +1,88 @@
+---
+id: 587d7dbb367417b2b2512bab
+title: 使用捕獲組搜索和替換
+challengeType: 1
+forumTopicId: 301368
+dashedName: use-capture-groups-to-search-and-replace
+---
+
+# --description--
+
+搜索功能是很有用的。 但是，當搜索同時也執行更改（或替換）匹配文本的操作時，搜索功能就會顯得更加強大。
+
+可以在字符串上使用 `.replace()` 方法來搜索並替換字符串中的文本。 `.replace()` 的輸入首先是想要搜索的正則表達式匹配模式。 第二個參數是用於替換匹配的字符串或用於執行某些操作的函數。
+
+```js
+let wrongText = "The sky is silver.";
+let silverRegex = /silver/;
+wrongText.replace(silverRegex, "blue");
+```
+
+`replace` 調用將返回字符串 `The sky is blue.`。
+
+你還可以使用美元符號（`$`）訪問替換字符串中的捕獲組。
+
+```js
+"Code Camp".replace(/(\w+)\s(\w+)/, '$2 $1');
+```
+
+調用 `replace` 將返回字符串 `Camp Code`。
+
+# --instructions--
+
+使用三個捕獲組編寫一個正則表達式 `fixRegex`，這三個捕獲組將搜索字符串 `one two three` 中的每個單詞。 然後更新 `replaceText` 變量，以字符串 `three two one` 替換 `one two three`，並將結果分配給 `result` 變量。 確保使用美元符號（`$`）語法在替換字符串中使用捕獲組。
+
+# --hints--
+
+你應該使用 `.replace()` 搜索並替換。
+
+```js
+assert(code.match(/\.replace\(.*\)/));
+```
+
+你的正則表達式應該將字符串 `one two three` 更改爲字符串 `three two one`
+
+```js
+assert(result === 'three two one');
+```
+
+你不應該改變最後一行。
+
+```js
+assert(code.match(/result\s*=\s*str\.replace\(.*?\)/));
+```
+
+`fixRegex` 應該至少使用三個抓取組。
+
+```js
+assert(new RegExp(fixRegex.source + '|').exec('').length - 1 >= 3);
+```
+
+`replaceText` 應該使用括號化的子匹配字符串（例如：nth 括號化的子匹配字符串, $n, 對應於第 n 個捕獲組）。
+
+```js
+{
+ const re = /(\$\d{1,2})+(?:[\D]|\b)/g;
+ assert(replaceText.match(re).length >= 3);
+}
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let str = "one two three";
+let fixRegex = /change/; // Change this line
+let replaceText = ""; // Change this line
+let result = str.replace(fixRegex, replaceText);
+```
+
+# --solutions--
+
+```js
+let str = "one two three";
+let fixRegex = /(\w+) (\w+) (\w+)/g; // Change this line
+let replaceText = "$3 $2 $1"; // Change this line
+let result = str.replace(fixRegex, replaceText);
+```
diff --git a/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/using-the-test-method.md b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/using-the-test-method.md
new file mode 100644
index 0000000000..cf1b4193fa
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/02-javascript-algorithms-and-data-structures/regular-expressions/using-the-test-method.md
@@ -0,0 +1,59 @@
+---
+id: 587d7db3367417b2b2512b8e
+title: 使用測試方法
+challengeType: 1
+forumTopicId: 301369
+dashedName: using-the-test-method
+---
+
+# --description--
+
+在編程語言中，正則表達式用於匹配指定的字符串。 通過正則表達式創建匹配模式（規則）可以幫你完成指定匹配。
+
+如果想要在字符串 `The dog chased the cat` 中匹配到 `the` 這個單詞，可以使用如下正則表達式：`/the/`。 注意，正則表達式中不需要引號。
+
+JavaScript 中有多種使用正則表達式的方法。 測試正則表達式的一種方法是使用 `.test()` 方法。 `.test()` 方法會把編寫的正則表達式和字符串（即括號內的內容）匹配，如果成功匹配到字符，則返回 `true`，反之，返回 `false`。
+
+```js
+let testStr = "freeCodeCamp";
+let testRegex = /Code/;
+testRegex.test(testStr);
+```
+
+`test` 方法會返回 `true`。
+
+# --instructions--
+
+使用 `.test()` 方法，檢測字符串 `myString` 是否符合正則表達式 `myRegex` 定義的規則。
+
+# --hints--
+
+你應該使用 `.test()` 方法來檢測正則表達式。
+
+```js
+assert(code.match(/myRegex.test\(\s*myString\s*\)/));
+```
+
+你的返回結果應該爲 `true`。
+
+```js
+assert(result === true);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let myString = "Hello, World!";
+let myRegex = /Hello/;
+let result = myRegex; // Change this line
+```
+
+# --solutions--
+
+```js
+let myString = "Hello, World!";
+let myRegex = /Hello/;
+let result = myRegex.test(myString); // Change this line
+```
diff --git a/curriculum/challenges/chinese-traditional/03-front-end-libraries/bootstrap/add-elements-within-your-bootstrap-wells.md b/curriculum/challenges/chinese-traditional/03-front-end-libraries/bootstrap/add-elements-within-your-bootstrap-wells.md
new file mode 100644
index 0000000000..ff807297a1
--- /dev/null
+++ b/curriculum/challenges/chinese-traditional/03-front-end-libraries/bootstrap/add-elements-within-your-bootstrap-wells.md
@@ -0,0 +1,90 @@
+---
+id: bad87fee1348bd9aec908849
+title: 在 Bootstrap Wells 中添加元素
+challengeType: 0
+forumTopicId: 16636
+dashedName: add-elements-within-your-bootstrap-wells
+---
+
+# --description--
+
+現在的每一行的列都已經有了 `div` 元素。 這已經足夠了， 現在讓我們添加 `button` 元素吧。
+
+每一個 class 屬性爲 `well` 的 `div` 元素內都應該放三個 `button` 元素。
+
+# --hints--
+
+每一個 class 屬性爲 `well` 的 `div` 元素內都應該放三個 `button` 元素。
+
+```js
+assert(
+ $('div.well:eq(0)').children('button').length === 3 &&
+ $('div.well:eq(1)').children('button').length === 3
+);
+```
+
+總共有 6 個 `button` 元素。
+
+```js
+assert($('button') && $('button').length > 5);
+```
+
+確保所有 `button` 元素都有閉合標籤。
+
+```js
+assert(
+ code.match(/<\/button>/g) &&
+ code.match(//g).length === code.match(/
+ jQuery Playground
+
+ 
+```
+
+視覺障礙用戶無法通過視覺獲取信息，而是通過屏幕閱讀器將網頁內容轉換爲音頻以獲取信息。 他們無法通過直觀的呈現理解信息。 屏幕閱讀器可以識別 `alt` 屬性，朗讀其中的內容，來告知用戶圖片包含的關鍵信息。
+
+`alt` 文本可以爲屏幕閱讀器提供圖片的描述信息， 所以你應始終爲圖片添加 `alt` 屬性。 另外，根據最新的 HTML5 標準，爲圖片添加這個屬性是必須的。
+
+# --instructions--
+
+碰巧，Camper Cat 是忍者中寫代碼最厲害的，他正在建立一個可以分享忍者知識的網站。 他打算使用的個人資料圖片可以展示他的技能，且應得到所有網站訪問者的讚賞。 請給 `img` 標籤添加一個 `alt` 屬性，說明 Camper Cat 正在學習空手道 （圖片的 `src` 屬性指向的是一個不存在的文件，因此你會看到 `alt` 屬性中的文本出現在頁面上）
+
+# --hints--
+
+`img` 標籤應該包含一個非空的 `alt` 屬性。
+
+```js
+assert($('img').attr('alt'));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+```
+
+# --solutions--
+
+```html
+
+ 
+ 
+```
+
+比如，背景圖片通常起裝飾作用。 但這些圖片通常都是通過 CSS 規則而非 HTML 引入的，因此屏幕閱讀器毋需讀取。
+
+**注意：**對於有標題的圖片，依然需要添加 `alt` 文本，因爲這樣有助於搜索引擎記錄圖片內容。
+
+# --instructions--
+
+Camper Cat 已經大體寫好了博客頁面。 他打算在他的兩篇文章之間添加一個武士劍裝飾圖片，作爲兩篇文章之間的分割線。 爲 `img` 標籤添加 `alt` 屬性，把它的屬性值設爲空 （注意：這裏圖片的 `src` 屬性提供的鏈接是無效的，因此頁面上不會顯示任何武士刀的圖片，不用擔心）。
+
+# --hints--
+
+`img` 標籤應具有 `alt` 屬性。
+
+```js
+assert(!($('img').attr('alt') == undefined));
+```
+
+`alt` 的屬性值應爲空。
+
+```js
+assert($('img').attr('alt') == '');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+