Merge pull request BonsaiDen#226 from appleboy/patch

some translatation for chinese

Author: timruffles

doc/zhtw/function/closures.md

@@ -1,79 +1,85 @@
-## Closures 和 References
-
-JavaScript 有一個很重要的特徵就是 **closures**
-因為有 Closures，所以作用域 **永遠** 能夠去訪問作用區間外面的變數。
-[函數區間](#function.scopes) 是JavaScript 中唯一擁有自生作用域的結構，因此 Closures 的創立需要依賴函數
-
-### 模仿私有變數
-
-    function Counter(start) {
-        var count = start;
-        return {
-            increment: function() {
-                count++;
-            },
-
-            get: function() {
-                return count;
-            }
-        }
-    }
-
-    var foo = Counter(4);
-    foo.increment();
-    foo.get(); // 5
-
-這裡，`Counter` 返回兩個 Closures，函數 `increment` 還有 `get`。這兩個函數都維持著對外部作用域 `Counter` 的引用，因此總可以訪問作用域的變數 `count`。
-
-
-### 為什麼不可以在外部訪問私有變數
-
-因為 Javascript **不可以** 對作用域進行引用或賦值。因此外部的地方沒有辦法訪問 `count` 變數。
-唯一的途徑就是經過那兩個 Closures
-
-    var foo = new Counter(4);
-    foo.hack = function() {
-        count = 1337;
-    };
-
-在上面的例子中 `count` **不會** 改變到 `Counter` 裡面的 `count` 的值。因為 `foo.hack` 沒有在 **那個** 作用域內被宣告。它只有會覆蓋或者建立在一個 **全域** 的變數 `count`
-
-### 在循環內的 Closures 
-
-一個常見的錯誤就是在 Closures 中使用迴圈，假設我們要使用每次迴圈中所使用的進入變數
-
-    for(var i = 0; i < 10; i++) {
-        setTimeout(function() {
-            console.log(i);  
-        }, 1000);
-    }
-
-在上面的例子中它 **不會** 輸出數字從 `0` 到 `9`，但只會出現數字 `10` 十次。
-在 `console.log` 被呼叫的時候，這個 *匿名* 函數中保持一個 **參考** 到 i ，此時 `for`迴圈已經結束， `i` 的值被修改成了 `10`。
-為了要達到想要的結果，需要在每次創造 **副本** 來儲存 `i` 的變數。
-
-### 避免引用錯誤
-
-為了要有達到正確的效果，最好是把它包在一個
-[匿名函數](#function.scopes).
-
-    for(var i = 0; i < 10; i++) {
-        (function(e) {
-            setTimeout(function() {
-                console.log(e);  
-            }, 1000);
-        })(i);
-    }
-
-匿名外部的函數被呼叫，並把 `i` 作為它第一個參數，此時函數內 `e` 變數就擁有了一個 `i` 的拷貝。
-當傳遞給 `setTimeout` 這個匿名函數執行時，它就擁有了對 `e` 的引用，而這個值 **不會** 被循環改變。
-另外有一個方法也可以完成這樣的工作，那就是在匿名函數中返回一個函數，這和上面的程式碼有同樣的效果。
-
-    for(var i = 0; i < 10; i++) {
-        setTimeout((function(e) {
-            return function() {
-                console.log(e);
-            }
-        })(i), 1000)
-    }
-
+## Closures 和 References
+
+JavaScript 有一個很重要的特徵就是 **closures**
+因為有 Closures，所以作用域 **永遠** 能夠去訪問作用區間外面的變數。
+[函數區間](#function.scopes) 是JavaScript 中唯一擁有自生作用域的結構，因此 Closures 的創立需要依賴函數
+
+### 模仿私有變數
+
+    function Counter(start) {
+        var count = start;
+        return {
+            increment: function() {
+                count++;
+            },
+
+            get: function() {
+                return count;
+            }
+        }
+    }
+
+    var foo = Counter(4);
+    foo.increment();
+    foo.get(); // 5
+
+這裡，`Counter` 返回兩個 Closures，函數 `increment` 還有 `get`。這兩個函數都維持著對外部作用域 `Counter` 的引用，因此總可以訪問作用域的變數 `count`。
+
+
+### 為什麼不可以在外部訪問私有變數
+
+因為 Javascript **不可以** 對作用域進行引用或賦值。因此外部的地方沒有辦法訪問 `count` 變數。
+唯一的途徑就是經過那兩個 Closures
+
+    var foo = new Counter(4);
+    foo.hack = function() {
+        count = 1337;
+    };
+
+在上面的例子中 `count` **不會** 改變到 `Counter` 裡面的 `count` 的值。因為 `foo.hack` 沒有在 **那個** 作用域內被宣告。它只有會覆蓋或者建立在一個 **全域** 的變數 `count`
+
+### 在循環內的 Closures
+
+一個常見的錯誤就是在 Closures 中使用迴圈，假設我們要使用每次迴圈中所使用的進入變數
+
+    for(var i = 0; i < 10; i++) {
+        setTimeout(function() {
+            console.log(i);
+        }, 1000);
+    }
+
+在上面的例子中它 **不會** 輸出數字從 `0` 到 `9`，但只會出現數字 `10` 十次。
+在 `console.log` 被呼叫的時候，這個 *匿名* 函數中保持一個 **參考** 到 i ，此時 `for`迴圈已經結束， `i` 的值被修改成了 `10`。
+為了要達到想要的結果，需要在每次創造 **副本** 來儲存 `i` 的變數。
+
+### 避免引用錯誤
+
+為了要有達到正確的效果，最好是把它包在一個
+[匿名函數](#function.scopes).
+
+    for(var i = 0; i < 10; i++) {
+        (function(e) {
+            setTimeout(function() {
+                console.log(e);
+            }, 1000);
+        })(i);
+    }
+
+匿名外部的函數被呼叫，並把 `i` 作為它第一個參數，此時函數內 `e` 變數就擁有了一個 `i` 的拷貝。
+當傳遞給 `setTimeout` 這個匿名函數執行時，它就擁有了對 `e` 的引用，而這個值 **不會** 被循環改變。
+另外有一個方法也可以完成這樣的工作，那就是在匿名函數中返回一個函數，這和上面的程式碼有同樣的效果。
+
+    for(var i = 0; i < 10; i++) {
+        setTimeout((function(e) {
+            return function() {
+                console.log(e);
+            }
+        })(i), 1000)
+    }
+
+另外也可以透過 `.bind` 完成此工作，它可以將 `this` 及參數傳入函數內，行為就如同上面程式碼一樣。
+
+    for(var i = 0; i < 10; i++) {
+        setTimeout(console.log.bind(console, i), 1000);
+    }
+

doc/zhtw/index.json

@@ -1,5 +1,5 @@
 {
-    "title": "JavaScript 庭院",
+    "title": "JavaScript Garden",
     "langTitle": "JavaScript Garden 繁體中文翻譯",
     "description": "JavaScript 語言中古怪用法及缺點的文件總集",
     "sections": [

doc/zhtw/intro/index.md

@@ -1,18 +1,20 @@
 ## 簡介
 
-JavaScript 庭院 是一個不斷更新的文件，最主要是要去了解一些 Javascript 比較古怪的部份。
+JavaScript Garden 是一個不斷更新的文件，最主要是要去了解一些 Javascript 比較古怪的部份。
 給一些意見來防止遇到一些常見的錯誤和一些難以發現的問題，以及性能問題和不好的習慣。
 初學者也可以藉此去了解 Javascript 這項語言的特性。
 
-JavaScript 庭院 並 **不是** 要教導你 Javascript 的語言。
+JavaScript Garden 並 **不是** 要教導你 Javascript 的語言。
 如果要能夠理解這篇文章的內容，你需要事先學習 JavaScript 的基礎知識。
 在 Mozilla 開發者網路中有一系列非常棒的學習[guide][1]。
 
 
 ## 作者
 
 這個使用手冊是來自於 [Stack Overflow][2] 的使用者, [Ivo Wetzel][3]
-(寫作) 和 [Zhang Yi Jiang][4] (設計).
+(寫作) 和 [Zhang Yi Jiang][4] (設計)。
+
+目前為 [Tim Ruffles](http://truffles.me.uk) 維護此專案。
 
 ## 貢獻者
 
@@ -22,15 +24,17 @@ JavaScript 庭院 並 **不是** 要教導你 Javascript 的語言。
 
  - [紀力榮][29]
  - [張仲威][30]
+ - [Bo-Yi Wu][31]
 
-## 存在
+## 存放空間
 
-JavaScript 庭院 存在於 GitHub, 但是 [Cramer Development][7] 讓我們有一個存放地 [JavaScriptGarden.info][8].
+JavaScript Garden 目前存放於 GitHub，但是 [Cramer Development][7] 讓我們有另一個存放位置在 [JavaScriptGarden.info][8]。
 
 ## 許可
 
-JavaScript 庭院是在 [MIT license][9] 許可協議下發佈，並存在於
-[GitHub][10]. 如果你有發現錯誤或是打字上的錯誤 [新增一個任務][11] 或者發一個請求。 你也可以在 StackOverflow 的 [JavaScript room][12] 上面找到我們。
+JavaScript Garden 是在 [MIT license][9] 許可協議下發佈，並存在於
+[GitHub][10]，如果你有發現錯誤或是打字上的錯誤 [新增一個任務][11] 或者發一個請求。
+你也可以在 StackOverflow 的 [JavaScript room][12] 上面找到我們。
 
 [1]: https://developer.mozilla.org/en/JavaScript/Guide
 [2]: http://stackoverflow.com/
@@ -44,5 +48,6 @@ JavaScript 庭院是在 [MIT license][9] 許可協議下發佈，並存在於
 [10]: https://github.com/BonsaiDen/JavaScript-Garden
 [11]: https://github.com/BonsaiDen/JavaScript-Garden/issues
 [12]: http://chat.stackoverflow.com/rooms/17/javascript
-[29]: http://github.com/chilijung
-[30]: http://github.com/wwwy3y3
+[29]: https://github.com/chilijung
+[30]: https://github.com/wwwy3y3
+[31]: https://github.com/appleboy

doc/zhtw/object/forinloop.md

@@ -2,8 +2,8 @@
 
 就像其他的 `in` 操作符一樣， `for in` 循環也進入所有在物件中的屬性
 
-> **注意: ** `for in` 迴圈 **不會** 進入那些 `enumerable` 屬性是 `false`，舉例來說， 陣列中 `length` 的屬性
-    
+> **注意: ** `for in` 迴圈 **不會** 進入那些 `enumerable` 屬性是 `false`，舉例來說，陣列中 `length` 的屬性
+
     // 修改 Object.prototype
     Object.prototype.bar = 1;
 
@@ -34,7 +34,7 @@
 
 ### 總結
 
-推薦 **總是** 使用 `hasOwnProperty`。不要對程式碼的環境做任何假設，不要假設原生的對象是否被擴張
+推薦 **總是** 使用 `hasOwnProperty`。不要對程式碼的環境做任何假設，不要假設原生的對象是否被擴張。
 
 [1]: http://www.prototypejs.org/
 

doc/zhtw/object/hasownproperty.md

@@ -1,4 +1,4 @@
-## `hasOwnProperty` 
+## `hasOwnProperty`
 
 為了判斷一個物件是否包含 *自定義* 屬性而 *不是* [原形](#object.prototype)上的屬性，我們需要使用繼承 `Object.prototype` 的 `hasOwnProperty` 方法。
 
@@ -8,9 +8,9 @@
 `hasOwnProperty` 是 JavaScript 中唯一一個處理屬性但是 **不** 找原型鏈的函式。
 
     // 修改 Object.prototype
-    Object.prototype.bar = 1; 
+    Object.prototype.bar = 1;
     var foo = {goo: undefined};
-    
+
     foo.bar; // 1
     'bar' in foo; // true
 
@@ -35,6 +35,8 @@ JavaScript **不會** 保護 `hasOwnProperty`被占用，因此如果碰到存
     // 使用其他對象的 hasOwnProperty，並將其上下設置為 foo
     ({}).hasOwnProperty.call(foo, 'bar'); // true
 
+    // 也可以透過原生 Object prototype 的 hasOwnProperty 函數來達成目的
+    Object.prototype.hasOwnProperty.call(foo, 'bar'); // true
 
 ### 結論
 

doc/zhtw/object/prototype.md

@@ -1,6 +1,6 @@
 ## Prototype
- 
-JavaScript 不包含原本繼承的模型。然而它使用的是*原型*模型*。
+
+JavaScript 不包含原本繼承的模型。然而它使用的是*原型*模型。
 
 然而常常有人提及 JavaScript 的缺點，就是基於原本繼承模型比類繼承更強大。
 現實傳統的類繼承模型是很簡單。但是在 JavaScript 中實現元繼承則要困難很多。
@@ -28,11 +28,11 @@ JavaScript 不包含原本繼承的模型。然而它使用的是*原型*模型*
     // 修正 Bar.prototype.constructor 為 Bar 本身
     Bar.prototype.constructor = Bar;
 
-    var test = new Bar() // 開啟一個新的實例
+    var test = new Bar(); // 開啟一個新的實例
 
     // 原型鏈
     test [instance of Bar]
-        Bar.prototype [instance of Foo] 
+        Bar.prototype [instance of Foo]
             { foo: 'Hello World' }
             Foo.prototype
                 { method: ... }
@@ -80,9 +80,8 @@ JavaScript 不包含原本繼承的模型。然而它使用的是*原型*模型*
 
 在寫複雜的程式碼的時候，要 **充分理解** 所有程式繼承的屬性還有原型鏈。
 還要堤防原型鏈過長帶來的性能問題，並知道如何通過縮短原型鏈來提高性能。
-絕對 **不要使用** native prototype` 除非是為了和新的 JavaScript 引擎作兼容。
+絕對 **不要使用** `native prototype` 除非是為了和新的 JavaScript 引擎作兼容。
 
 [1]: http://en.wikipedia.org/wiki/Monkey_patch
 [2]: http://prototypejs.org/
 [3]: https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/forEach
-