finished function/ closures, general

Author: howardchi

doc/zh-TW/function/closures.md

@@ -1,11 +1,10 @@
-## Closures and References
+## Closures 和 References
 
-One of JavaScript's most powerful features is the availability of *closures*.
-With closures, scopes **always** keep access to the outer scope, in which they
-were defined. Since the only scoping that JavaScript has is 
-[function scope](#function.scopes), all functions, by default, act as closures.
+JavaScript 有一個很重要的特徵就是 **closures**
+因為有 Closures，所以作用域 **永遠** 能夠去訪問作用區間外面的變數。
+[函數區間](#function.scopes) 是JavaScript 中唯一擁有自生作用域的結構，因此 Closures 的創立需要依賴函數
 
-### Emulating private variables
+### 模仿私有變數
 
     function Counter(start) {
         var count = start;
@@ -24,51 +23,39 @@ were defined. Since the only scoping that JavaScript has is
     foo.increment();
     foo.get(); // 5
 
-Here, `Counter` returns **two** closures: the function `increment` as well as 
-the function `get`. Both of these functions keep a **reference** to the scope of 
-`Counter` and, therefore, always keep access to the `count` variable that was 
-defined in that scope.
+這裡，`Counter` 返回兩個 Closures，函數 `increment` 還有 `get`。這兩個函數都維持著對外部作用域 `Counter` 的引用，因此總可以訪問作用域的變數 `count`。
 
-### Why Private Variables Work
 
-Since it is not possible to reference or assign scopes in JavaScript, there is 
-**no** way of accessing the variable `count` from the outside. The only way to 
-interact with it is via the two closures.
+### 為什麼不可以在外部訪問私有變數
+
+因為 Javascript **不可以** 對作用域進行引用或賦值。因此外部的地方沒有辦法訪問 `count` 變數。
+唯一的途徑就是經過那兩個 Closures
 
     var foo = new Counter(4);
     foo.hack = function() {
         count = 1337;
     };
 
-The above code will **not** change the variable `count` in the scope of `Counter`, 
-since `foo.hack` was not defined in **that** scope. It will instead create - or 
-override - the *global* variable `count`.
+在上面的例子中 `count` **不會** 改變到 `Counter` 裡面的 `count` 的值。因為 `foo.hack` 沒有在 **那個** 作用域內被宣告。它只有會覆蓋或者建立在一個 **全域** 的變數 `count`
 
-### Closures Inside Loops
+### 在循環內的 Closures 
 
-One often made mistake is to use closures inside of loops, as if they were
-copying the value of the loop's index variable.
+一個常見的錯誤就是在 Closures 中使用迴圈，假設我們要使用每次迴圈中所使用的進入變數
 
     for(var i = 0; i < 10; i++) {
         setTimeout(function() {
             console.log(i);  
         }, 1000);
     }
 
-The above will **not** output the numbers `0` through `9`, but will simply print
-the number `10` ten times.
-
-The *anonymous* function keeps a **reference** to `i`. At the time 
-`console.log` gets called, the `for loop` has already finished, and the value of 
-`i` as been set to `10`.
-
-In order to get the desired behavior, it is necessary to create a **copy** of 
-the value of `i`.
+在上面的例子中它 **不會** 輸出數字從 `0` 到 `9`，但只會出現數字 `10` 十次。
+在 `console.log` 被呼叫的時候，這個 *匿名* 函數中保持一個 **參考** 到 i ，此時 `for`迴圈已經結束， `i` 的值被修改成了 `10`。
+為了要達到想要的結果，需要在每次創造 **副本** 來儲存 `i` 的變數。
 
-### Avoiding the Reference Problem
+### 避免引用錯誤
 
-In order to copy the value of the loop's index variable, it is best to use an 
-[anonymous wrapper](#function.scopes).
+為了要有達到正確的效果，最好是把它包在一個
+[匿名函數](#function.scopes).
 
     for(var i = 0; i < 10; i++) {
         (function(e) {
@@ -78,15 +65,9 @@ In order to copy the value of the loop's index variable, it is best to use an
         })(i);
     }
 
-The anonymous outer function gets called immediately with `i` as its first 
-argument and will receive a copy of the **value** of `i` as its parameter `e`.
-
-The anonymous function that gets passed to `setTimeout` now has a reference to 
-`e`, whose value does **not** get changed by the loop.
-
-There is another possible way of achieving this, which is to return a function 
-from the anonymous wrapper that will then have the same behavior as the code 
-above.
+匿名外部的函數被呼叫，並把 `i` 作為它第一個參數，此時函數內 `e` 變數就擁有了一個 `i` 的拷貝。
+當傳遞給 `setTimeout` 這個匿名函數執行時，它就擁有了對 `e` 的引用，而這個值 **不會** 被循環改變。
+另外有一個方法也可以完成這樣的工作，那就是在匿名函數中返回一個函數，這和上面的程式碼有同樣的效果。
 
     for(var i = 0; i < 10; i++) {
         setTimeout((function(e) {

doc/zh-TW/function/general.md

@@ -1,48 +1,43 @@
-## Function Declarations and Expressions
+## 函式的宣告和表達方式
 
-Functions in JavaScript are first class objects. That means they can be 
-passed around like any other value. One common use of this feature is to pass
-an *anonymous function* as a callback to another, possibly an asynchronous function.
+函式在 JavaScript 是第一等物件。這表示他們可以把函式當做值一樣傳遞。
+一個常見的用法是用 *匿名函式* 當做一個回傳去呼叫另一個函式，這是一種非同步函式
 
-### The `function` Declaration
+### 函式的宣告
 
     function foo() {}
 
-The above function gets [hoisted](#function.scopes) before the execution of the
-program starts; thus, it is available *everywhere* in the scope it was
-*defined*, even if called before the actual definition in the source.
+上面的函式在被執行之前會被 [解析(hoisted)](#function.scopes)，因此它可以在 **任意** 的地方都是 *有宣告的* ，就算是在比這個函式還早呼叫。
 
-    foo(); // Works because foo was created before this code runs
+
+    foo(); // 可以執行，因為 foo 已經在運行前就被建立
     function foo() {}
 
-### The `function` Expression
+### `function` 的表達式
 
     var foo = function() {};
 
-This example assigns the unnamed and *anonymous* function to the variable `foo`. 
+這個例子把一個 *匿名* 函式賦值給變數 `foo`。
 
     foo; // 'undefined'
-    foo(); // this raises a TypeError
+    foo(); // 錯誤: TypeError
     var foo = function() {};
 
-Due to the fact that `var` is a declaration that hoists the variable name `foo` 
-before the actual execution of the code starts, `foo` is already defined when 
-the script gets executed.
+由於 `var` 已經宣告變數 `foo` 在所有的程式碼執行之前。
+所以 `foo`已經在程式運行前就已經被定義過了。
+但是因為賦值只會在運行時去職情，所以在程式碼執行前，`foo` 的值還沒被宣告所以為 [undefined](#core.undefined)。
 
-But since assignments only happen at runtime, the value of `foo` will default
-to [undefined](#core.undefined) before the corresponding code is executed.
 
-### Named Function Expression
+### 命名函式的賦值表達式
 
-Another special case is the assignment of named functions.
+另一個特殊狀況就勢將一個命名函式賦值給一個變數。
 
     var foo = function bar() {
-        bar(); // Works
+        bar(); // 可以運行
     }
-    bar(); // ReferenceError
+    bar(); // 錯誤：ReferenceError
 
-Here, `bar` is not available in the outer scope, since the function only gets
-assigned to `foo`; however, inside of `bar`, it is available. This is due to 
-how [name resolution](#function.scopes) in JavaScript works, the name of the 
-function is *always* made available in the local scope of the function itself.
+`bar` 不可以在外部的區域被執行，因為它只有在 `foo` 的函式內才可以去執行。
+然而在 `bar` 內部還是可以看見。這是由於 JavaScript的 [命名處理](#function.scopes)所致。
+函式名在函式內 *都* 可以去使用。