fix typo

Author: poppinlp

doc/zh/function/arguments.md

@@ -9,7 +9,7 @@ JavaScript 中每个函数内都能访问一个特别变量 `arguments`。这个
 `arguments` 变量**不是**一个数组（`Array`）。
 尽管在语法上它有数组相关的属性 `length`，但它不从 `Array.prototype` 继承，实际上它是一个对象（`Object`）。
 
-因此，无法对 `arguments` 变量使用标准的数组方法，比如 `push`, `pop` 或者 `slice`。
+因此，无法对 `arguments` 变量使用标准的数组方法，比如 `push`、`pop` 或者 `slice`。
 虽然使用 `for` 循环遍历也是可以的，但是为了更好的使用数组方法，最好把它转化为一个真正的数组。
 
 ###转化为数组
@@ -99,13 +99,13 @@ JavaScript 中每个函数内都能访问一个特别变量 `arguments`。这个
 然而，的确有一种情况会显著的影响现代 JavaScript 引擎的性能。这就是使用 `arguments.callee`。
 
     function foo() {
-        arguments.callee; // do something with this function object
-        arguments.callee.caller; // and the calling function object
+        arguments.callee; // 使用这个函数对象
+        arguments.callee.caller; // 以及这个函数对象的调用者
     }
 
     function bigLoop() {
         for(var i = 0; i < 100000; i++) {
-            foo(); // Would normally be inlined...
+            foo(); // 通常情况会作为内联函数...
         }
     }
 

doc/zh/function/closures.md

@@ -3,6 +3,8 @@
 闭包是 JavaScript 一个非常重要的特性，这意味着当前作用域**总是**能够访问外部作用域中的变量。
 因为 [函数](#function.scopes) 是 JavaScript 中唯一拥有自身作用域的结构，因此闭包的创建依赖于函数。
 
+> 译者注：ES2015 中增加了块级作用域。
+
 ###模拟私有变量
 
     function Counter(start) {
@@ -23,7 +25,7 @@
     foo.get(); // 5
 
 这里，`Counter` 函数返回两个闭包，函数 `increment` 和函数 `get`。 这两个函数都维持着
-对外部作用域 `Counter` 的引用，因此总可以访问此作用域内定义的变量 `count`.
+对外部作用域 `Counter` 的引用，因此总可以访问此作用域内定义的变量 `count`。
 
 ###为什么不可以在外部访问私有变量
 
@@ -44,13 +46,13 @@
 
     for(var i = 0; i < 10; i++) {
         setTimeout(function() {
-            console.log(i);  
+            console.log(i);
         }, 1000);
     }
 
 上面的代码不会输出数字 `0` 到 `9`，而是会输出数字 `10` 十次。
 
-当 `console.log` 被调用的时候，*匿名*函数保持对外部变量 `i` 的引用，此时 `for`循环已经结束， `i` 的值被修改成了 `10`. 
+当 `console.log` 被调用的时候，*匿名*函数保持对外部变量 `i` 的引用，此时 `for`循环已经结束， `i` 的值被修改成了 `10`。
 
 为了得到想要的结果，需要在每次循环中创建变量 `i` 的**拷贝**。
 
@@ -61,7 +63,7 @@
     for(var i = 0; i < 10; i++) {
         (function(e) {
             setTimeout(function() {
-                console.log(e);  
+                console.log(e);
             }, 1000);
         })(i);
     }
@@ -76,8 +78,8 @@
         setTimeout((function(e) {
             return function() {
                 console.log(e);
-            }
-        })(i), 1000)
+            };
+        })(i), 1000);
     }
 
 

doc/zh/function/general.md

@@ -1,16 +1,16 @@
 ##函数声明与表达式
 
-函数是JavaScript中的一等对象，这意味着可以把函数像其它值一样传递。
+函数是 JavaScript 中的一等对象，这意味着可以把函数像其它值一样传递。
 一个常见的用法是把*匿名函数*作为回调函数传递到异步函数中。
 
 ###函数声明
 
     function foo() {}
 
 上面的方法会在执行前被 [解析(hoisted)](#function.scopes)，因此它存在于当前上下文的*任意*一个地方，
-即使在函数定义体的上面被调用也是对的。 
+即使在函数定义体的上面被调用也是对的。
 
-    foo(); // 正常运行，因为foo在代码运行前已经被创建
+    foo(); // 正常运行，因为 foo 在代码运行前已经被创建
     function foo() {}
 
 ### 函数赋值表达式
@@ -39,7 +39,6 @@
 `bar` 函数声明外是不可见的，这是因为我们已经把函数赋值给了 `foo`；
 然而在 `bar` 内部依然可见。这是由于 JavaScript 的 [命名处理](#function.scopes) 所致，
 函数名在函数内*总是*可见的。
-> **注意:**在IE8及IE8以下版本浏览器bar在外部也是可见的，是因为浏览器对命名函数赋值表达式进行了错误的解析，
+> **注意: **在 IE8 及 IE8 以下版本浏览器 bar 在外部也是可见的，是因为浏览器对命名函数赋值表达式进行了错误的解析，
 > 解析成两个函数 `foo` 和 `bar`
 
-[30]: http://cnblogs.com/sanshi/

doc/zh/function/this.md

@@ -9,7 +9,8 @@ JavaScript 有一套完全不同于其它语言的对 `this` 的处理机制。
 
 当在全部范围内使用 `this`，它将会指向*全局*对象。
 
-> **[译者注][30]：**浏览器中运行的 JavaScript 脚本，这个全局对象是 `window`。
+> **[译者注][30]：**浏览器中运行的 JavaScript 脚本，这个全局对象是 `window`；
+> 在 nodejs 环境中运行的 Javascript 脚本，这个全局对象是 `global`。
 
 ###函数调用
 
@@ -22,13 +23,13 @@ JavaScript 有一套完全不同于其它语言的对 `this` 的处理机制。
 
 ###方法调用
 
-    test.foo(); 
+    test.foo();
 
 这个例子中，`this` 指向 `test` 对象。
 
 ###调用构造函数
 
-    new foo(); 
+    new foo();
 
 如果函数倾向于和 `new` 关键词一块使用，则我们称这个函数是 [构造函数](#function.constructors)。
 在函数内部，`this` 指向*新创建*的对象。
@@ -39,7 +40,7 @@ JavaScript 有一套完全不同于其它语言的对 `this` 的处理机制。
                           
     var bar = {};
     foo.apply(bar, [1, 2, 3]); // 数组将会被扩展，如下所示
-    foo.call(bar, 1, 2, 3); // 传递到foo的参数是：a = 1, b = 2, c = 3
+    foo.call(bar, 1, 2, 3); // 传递到 foo 的参数是：a = 1, b = 2, c = 3
 
 当使用 `Function.prototype` 上的 `call` 或者 `apply` 方法时，函数内的 `this` 将会被
 **显式设置**为函数调用的第一个参数。
@@ -53,7 +54,7 @@ JavaScript 有一套完全不同于其它语言的对 `this` 的处理机制。
 ###常见误解
 
 尽管大部分的情况都说的过去，不过第一个规则（**[译者注][30]：**这里指的应该是第二个规则，也就是直接调用函数时，`this` 指向全局对象）
-被认为是JavaScript语言另一个错误设计的地方，因为它**从来**就没有实际的用途。
+被认为是 JavaScript 语言另一个错误设计的地方，因为它**从来**就没有实际的用途。
 
     Foo.method = function() {
         function test() {

doc/zh/intro/license.md

@@ -1,7 +1,7 @@
 ##许可
 
 JavaScript 秘密花园在 [MIT license][1] 许可协议下发布，并存放在 [GitHub][2] 开源社区。
-如果你发现错误或者打字错误，请[新建一个任务单][3]或者发一个抓取请求。
+如果你发现错误，请[新建一个任务单][3]或者发一个抓取请求（Pull Request）。
 你也可以在 Stack Overflow 的 [JavaScript 聊天室][4]找到我们。
 
 [1]: https://github.com/BonsaiDen/JavaScript-Garden/blob/next/LICENSE

doc/zh/object/forinloop.md

@@ -37,5 +37,4 @@
 推荐**总是**使用 `hasOwnProperty`。不要对代码运行的环境做任何假设，不要假设原生对象是否已经被扩展了。
 
 [1]: http://www.prototypejs.org/
-[30]: http://cnblogs.com/sanshi/
 

doc/zh/object/general.md

@@ -25,7 +25,7 @@ JavaScript 中所有变量都可以当作对象使用，除了两个例外 [`nul
 JavaScript 的对象可以作为[*哈希表*][1]使用，主要用来保存命名的键与值的对应关系。
 
 使用对象的字面语法 - `{}` - 可以创建一个简单对象。这个新创建的对象从 `Object.prototype`
-[继承](#object.prototype)下面，没有任何[自定义属性](#object.hasownproperty)。
+[继承](#object.prototype)下来，没有任何[自定义属性](#object.hasownproperty)。
 
     var foo = {}; // 一个空对象
 
@@ -34,7 +34,7 @@ JavaScript 的对象可以作为[*哈希表*][1]使用，主要用来保存命
 
 ### 访问属性
 
-有两种方式来访问对象的属性，点操作符或者中括号操作符。
+有两种方式来访问对象的属性，点操作符和中括号操作符。
 
     var foo = {name: 'kitten'}
     foo.name; // kitten

doc/zh/object/hasownproperty.md

@@ -8,8 +8,8 @@
 
 `hasOwnProperty` 是 JavaScript 中唯一一个处理属性但是**不**查找原型链的函数。
 
-    // 修改Object.prototype
-    Object.prototype.bar = 1; 
+    // 修改 Object.prototype
+    Object.prototype.bar = 1;
     var foo = {goo: undefined};
 
     foo.bar; // 1
@@ -18,8 +18,8 @@
     foo.hasOwnProperty('bar'); // false
     foo.hasOwnProperty('goo'); // true
 
-只有 `hasOwnProperty` 可以给出正确和期望的结果，这在遍历对象的属性时会很有用。
-**没有**其它方法可以用来排除原型链上的属性，而不是定义在对象*自身*上的属性。
+只有 `hasOwnProperty` 可以给出正确和期望的结果。可以查看 [`for in` 循环](#object.forinloop)
+章节来获取关于在迭代遍历对象属性的时候，何时使用 `hasOwnProperty` 的更多信息。
 
 ###`hasOwnProperty` 作为属性
 
@@ -35,7 +35,7 @@ JavaScript **不会**保护 `hasOwnProperty` 被非法占用，因此如果一
 
     foo.hasOwnProperty('bar'); // 总是返回 false
 
-    // 使用其它对象的 hasOwnProperty，并将其上下文设置为foo
+    // 使用其它对象的 hasOwnProperty，并将其上下文设置为 foo
     ({}).hasOwnProperty.call(foo, 'bar'); // true
 
 ###结论
@@ -44,4 +44,3 @@ JavaScript **不会**保护 `hasOwnProperty` 被非法占用，因此如果一
 同时在使用 [`for in` loop](#object.forinloop) 遍历对象时，推荐**总是**使用 `hasOwnProperty` 方法，
 这将会避免[原型](#object.prototype)对象扩展带来的干扰。
 
-[30]: http://cnblogs.com/sanshi/

doc/zh/object/prototype.md

@@ -23,14 +23,14 @@ other way around is a far more difficult task.)
 
     function Bar() {}
 
-    // 设置Bar的prototype属性为Foo的实例对象
+    // 设置 Bar 的 prototype 属性为 Foo 的实例对象
     Bar.prototype = new Foo();
     Bar.prototype.foo = 'Hello World';
 
-    // 修正Bar.prototype.constructor为Bar本身
+    // 修正 Bar.prototype.constructor 为 Bar 本身
     Bar.prototype.constructor = Bar;
 
-    var test = new Bar() // 创建Bar的一个新实例
+    var test = new Bar(); // 创建Bar的一个新实例
 
     // 原型链
     test [Bar的实例]
@@ -58,7 +58,7 @@ other way around is a far more difficult task.)
 ###原型属性
 
 当原型属性用来创建原型链时，可以把**任何**类型的值赋给它（prototype）。
-然而将原子类型赋给 prototype 的操作将会被忽略。
+然而将原子类型（primitives）赋给 prototype 的操作将会被忽略。
 
     function Foo() {}
     Foo.prototype = 1; // 无效
@@ -67,16 +67,16 @@ other way around is a far more difficult task.)
 
 ###性能
 
-如果一个属性在原型链的上端，则对于查找时间将带来不利影响。特别的，试图获取一个不存在的属性将会遍历整个原型链。
+如果一个属性在原型链的上端，则对于查找时间将带来不利影响。注意，试图获取一个不存在的属性将会遍历整个原型链。
 
 并且，当使用 [`for in`](#object.forinloop) 循环遍历对象的属性时，原型链上的**所有**属性都将被访问。
 
 ###扩展内置类型的原型
 
-一个错误特性被经常使用，那就是扩展 `Object.prototype` 或者其他内置类型的原型对象。
+扩展 `Object.prototype` 或者其他内置类型的原型对象，作为一个错误特性，经常被使用。
 
 这种技术被称之为 [monkey patching][1] 并且会破坏*封装*。虽然它被广泛的应用到一些 JavaScript 类库中比如 [Prototype][2],
-但是我仍然不认为为内置类型添加一些*非标准*的函数是个好主意。
+但是我仍然不赞同为内置类型添加一些*非标准*的函数。
 
 扩展内置类型的**唯一**理由是为了和新的 JavaScript 保持一致，比如 [`Array.forEach`][3]。