Fixed broken links, outdated translation

Author: ZhangYiJiang

doc/zh/function/closures.md

@@ -1,7 +1,7 @@
 ##闭包和引用
 
 闭包是 JavaScript 一个非常重要的特性，这意味着当前作用域**总是**能够访问外部作用域中的变量。
-因为 [函数](#scopes) 是 JavaScript 中唯一拥有自身作用域的结构，因此闭包的创建依赖于函数。
+因为 [函数](#function.scopes) 是 JavaScript 中唯一拥有自身作用域的结构，因此闭包的创建依赖于函数。
 
 ###模拟私有变量
 
@@ -56,7 +56,7 @@
 
 ###避免引用错误
 
-为了正确的获得循环序号，最好使用 [匿名包裹器](#scopes)（**[译者注][30]：**其实就是我们通常说的自执行匿名函数）。
+为了正确的获得循环序号，最好使用 [匿名包裹器](#function.scopes)（**[译者注][30]：**其实就是我们通常说的自执行匿名函数）。
 
     for(var i = 0; i < 10; i++) {
         (function(e) {

doc/zh/function/general.md

@@ -7,7 +7,7 @@
 
     function foo() {}
 
-上面的方法会在执行前被 [解析（hoisted）](#scopes)，因此它存在于当前上下文的*任意*一个地方，
+上面的方法会在执行前被 [解析(hoisted)](#function.scopes)，因此它存在于当前上下文的*任意*一个地方，
 即使在函数定义体的上面被调用也是对的。 
 
     foo(); // 正常运行，因为foo在代码运行前已经被创建
@@ -25,7 +25,7 @@
 
 由于 `var` 定义了一个声明语句，对变量 `foo` 的解析是在代码运行之前，因此 `foo` 变量在代码运行时已经被定义过了。
 
-但是由于赋值语句只在运行时执行，因此在相应代码执行之前， `foo` 的值缺省为 [undefined](#undefined)。
+但是由于赋值语句只在运行时执行，因此在相应代码执行之前， `foo` 的值缺省为 [undefined](#core.undefined)。
 
 ###命名函数的赋值表达式
 
@@ -37,7 +37,7 @@
     bar(); // 出错：ReferenceError
 
 `bar` 函数声明外是不可见的，这是因为我们已经把函数赋值给了 `foo`；
-然而在 `bar` 内部依然可见。这是由于 JavaScript 的 [命名处理](#scopes) 所致，
+然而在 `bar` 内部依然可见。这是由于 JavaScript 的 [命名处理](#function.scopes) 所致，
 函数名在函数内*总是*可见的。
 
 [30]: http://cnblogs.com/sanshi/

doc/zh/function/scopes.md

@@ -11,7 +11,7 @@
     }
 
 > **注意:** 如果不是在赋值语句中，而是在 return 表达式或者函数参数中，`{...}` 将会作为代码段解析，
-> 而不是作为对象的字面语法解析。如果考虑到 [自动分号插入](#semicolon)，这可能会导致一些不易察觉的错误。
+> 而不是作为对象的字面语法解析。如果考虑到 [自动分号插入](#core.semicolon)，这可能会导致一些不易察觉的错误。
 
 **[译者注][30]：**如果 `return` 对象的左括号和 `return` 不在一行上就会出错。
 
@@ -52,15 +52,15 @@ JavaScript 中没有显式的命名空间定义，这就意味着所有对象都
 起初这看起来并不是大问题，但是当有成千上万行代码时，不使用 `var` 声明变量将会带来难以跟踪的 BUG。
 
     // 全局作用域
-    var items = [/* some list */];
+    var items = [/* 数组 */];
     for(var i = 0; i < 10; i++) {
         subLoop();
     }
 
     function subLoop() {
         // subLoop 函数作用域
         for(i = 0; i < 10; i++) { // 没有使用 var 声明变量
-            // do amazing stuff!
+            // 干活
         }
     }
 
@@ -70,7 +70,7 @@ JavaScript 中没有显式的命名空间定义，这就意味着所有对象都
 
 ###局部变量
 
-JavaScript 中局部变量只可能通过两种方式声明，一个是作为[函数](#functions)参数，另一个是通过 `var` 关键字声明。
+JavaScript 中局部变量只可能通过两种方式声明，一个是作为[函数](#function)参数，另一个是通过 `var` 关键字声明。
 
     // 全局变量
     var foo = 1;
@@ -88,7 +88,7 @@ JavaScript 中局部变量只可能通过两种方式声明，一个是作为[
 
 `foo` 和 `i` 是函数 `test` 内的局部变量，而对 `bar` 的赋值将会覆盖全局作用域内的同名变量。
 
-### 变量声明提升（Hoisting）
+###变量声明提升（Hoisting）
 
 JavaScript 会**提升**变量声明。这意味着 `var` 表达式和 `function` 声明都将会被提升到当前作用域的顶部。
 
@@ -170,9 +170,9 @@ JavaScript 会**提升**变量声明。这意味着 `var` 表达式和 `function
 
 ###名称解析顺序
 
-JavaScript 中的所有作用域，包括*全局作用域*，都有一个特别的名称 [`this`](#this) 指向当前对象。
+JavaScript 中的所有作用域，包括*全局作用域*，都有一个特别的名称 [`this`](#function.this) 指向当前对象。
 
-函数作用域内也有默认的变量 [`arguments`](#arguments)，其中包含了传递到函数中的参数。
+函数作用域内也有默认的变量 [`arguments`](#function.arguments)，其中包含了传递到函数中的参数。
 
 比如，当访问函数内的 `foo` 变量时，JavaScript 会按照下面顺序查找：
 
@@ -196,7 +196,7 @@ JavaScript 中的所有作用域，包括*全局作用域*，都有一个特别
 
     })(); // 立即执行此匿名函数
 
-匿名函数被认为是 [表达式](#functions)；因此为了可调用性，它们首先会被执行。
+匿名函数被认为是 [表达式](#function)；因此为了可调用性，它们首先会被执行。
 
     ( // 小括号内的函数首先被执行
     function() {}

doc/zh/function/this.md

@@ -19,7 +19,6 @@ JavaScript 有一套完全不同于其它语言的对 `this` 的处理机制。
 
 > **ES5 注意:** 在严格模式下（strict mode），不存在全局变量。
 > 这种情况下 `this` 将会是 `undefined`。
-> [译者注][30]：ES5指的是ECMAScript 5，是 2009-12 发布的最新的 JavaScript 版本。
 
 ###方法调用
 
@@ -31,7 +30,7 @@ JavaScript 有一套完全不同于其它语言的对 `this` 的处理机制。
 
     new foo(); 
 
-如果函数倾向于和 `new` 关键词一块使用，则我们称这个函数是 [构造函数](#constructors)。
+如果函数倾向于和 `new` 关键词一块使用，则我们称这个函数是 [构造函数](#function.constructors)。
 在函数内部，`this` 指向*新创建*的对象。
 
 ###显式的设置 `this`
@@ -76,7 +75,7 @@ JavaScript 有一套完全不同于其它语言的对 `this` 的处理机制。
     }
 
 `that` 只是我们随意起的名字，不过这个名字被广泛的用来指向外部的 `this` 对象。
-在 [闭包](#closures) 一节，我们可以看到 `that` 可以作为参数传递。
+在 [闭包](#function.closures) 一节，我们可以看到 `that` 可以作为参数传递。
 
 ###方法的赋值表达式
 
@@ -87,7 +86,7 @@ JavaScript 有一套完全不同于其它语言的对 `this` 的处理机制。
 
 上例中，`test` 就像一个普通的函数被调用；因此，函数内的 `this` 将不再被指向到 `someObject` 对象。
 
-虽然 `this` 的晚绑定特性似乎并不友好，但是这确实[基于原型继承](#prototype)赖以生存的土壤。
+虽然 `this` 的晚绑定特性似乎并不友好，但是这确实[基于原型继承](#object.prototype)赖以生存的土壤。
 
     function Foo() {}
     Foo.prototype.method = function() {};

doc/zh/intro/index.md

@@ -7,5 +7,8 @@
 JavaScript 秘密花园**不是**用来教你 JavaScript。为了更好的理解这篇文章的内容，
 你需要事先学习 JavaScript 的基础知识。在 Mozilla 开发者网络中有一系列非常棒的 JavaScript 学习[向导][1]。
 
+> **ES5 注意:** **译者注：** ES5 指的是ECMAScript 5，是 ECMAScript 标准语言的下一版本，正在开发中。
+JavaScript 是此标准语言的一个方言。
+
 [1]: https://developer.mozilla.org/en/JavaScript/Guide
 

doc/zh/intro/license.md

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

doc/zh/object/general.md

@@ -1,6 +1,6 @@
 ##对象使用和属性
 
-JavaScript 中所有变量都是对象，除了两个例外 [`null`](#undefined) 和 [`undefined`](#undefined)。
+JavaScript 中所有变量都是对象，除了两个例外 [`null`](#core.undefined) 和 [`undefined`](#core.undefined)。
 
     false.toString() // 'false'
     [1, 2, 3].toString(); // '1,2,3'
@@ -25,7 +25,7 @@ JavaScript 中所有变量都是对象，除了两个例外 [`null`](#undefined)
 JavaScript 的对象可以作为[*哈希表*][1]使用，主要用来保存命名的键与值的对应关系。
 
 使用对象的字面语法 - `{}` - 可以创建一个简单对象。这个新创建的对象从 `Object.prototype`
-[继承](#prototype)下面，没有任何[自定义属性](#hasownproperty)。
+[继承](#object.prototype)下面，没有任何[自定义属性](#object.hasownproperty)。
 
     var foo = {}; // 一个空对象
 

doc/zh/object/hasownproperty.md

@@ -1,6 +1,6 @@
 ##`hasOwnProperty` 函数
 
-为了判断一个对象是否包含*自定义*属性而*不是*[原型链](#prototype)上的属性，
+为了判断一个对象是否包含*自定义*属性而*不是*[原型链](#object.prototype)上的属性，
 我们需要使用继承自 `Object.prototype` 的 `hasOwnProperty` 方法。
 
 > **注意:** 通过判断一个属性是否 `undefined` 是**不够**的。
@@ -41,7 +41,7 @@ JavaScript **不会**保护 `hasOwnProperty` 被非法占用，因此如果一
 ###结论
 
 当检查对象上某个属性是否存在时，`hasOwnProperty` 是**唯一**可用的方法。
-同时在使用 [`for in` loop](#forinloop) 遍历对象时，推荐**总是**使用 `hasOwnProperty` 方法，
-这将会避免[原型](#prototype)对象扩展带来的干扰。
+同时在使用 [`for in` loop](#object.forinloop) 遍历对象时，推荐**总是**使用 `hasOwnProperty` 方法，
+这将会避免[原型](#object.prototype)对象扩展带来的干扰。
 
 [30]: http://cnblogs.com/sanshi/

doc/zh/object/prototype.md

@@ -40,17 +40,11 @@ other way around is a far more difficult task.)
                 {method: ...};
                 Object.prototype
                     {toString: ... /* etc. */};
-
+*
 上面的例子中，`test` 对象从 `Bar.prototype` 和 `Foo.prototype` 继承下来；因此，
-它能否访问 `Foo` 的原型方法 `method`。但是它不能访问 `Foo` 的实例属性 `value`，
-因为这个属性在`Foo`的[构造函数](#constructor)中定义。
-(But it will not have access to the property `value` of a 
-`Foo` instance, since that property gets defined in the [constructor](#constructor)
-of `Foo`. But this constructor has to be called explicitly.)
-
-> **[译者注][30]：**我认为这个描述是错误的，`test.value` 是可以访问的。
-因为在设置 `Bar.prototype = new Foo();` 时，`value` 也就成为 `Bar.prototype` 上的一个属性。
-如果你有不同观点，可以到[我的博客][30]评论。
+它能访问 `Foo` 的原型方法 `method`。它也同时能够访问那**一个**作为它原型的 `Foo` 实例
+的属性 `value`。需要注意的是 `new Bar()` **不会**创造出一个新的 `Foo` 实例，而是
+重新使用设定为它的原型的实例；也就是说，所有的 `Bar` 实例都将会有**同样**的 `value` 属性。
 
 > **注意:** **不要**使用 `Bar.prototype = Foo`，因为这不会执行 `Foo` 的原型，而是指向函数 `Foo`。
 > 因此原型链将会回溯到 `Function.prototype` 而不是 `Foo.prototype`，因此 `method` 将不会在 Bar 的原型链上。
@@ -59,7 +53,7 @@ of `Foo`. But this constructor has to be called explicitly.)
 
 当查找一个对象的属性时，JavaScript 会**向上**遍历原型链，直到找到给定名称的属性为止。
 
-到查找到达原型链的顶部 - 也就是 `Object.prototype` - 但是仍然没有找到指定的属性，就会返回 [undefined](#undefined)。
+到查找到达原型链的顶部 - 也就是 `Object.prototype` - 但是仍然没有找到指定的属性，就会返回 [undefined](#core.undefined)。
 
 ###原型属性
 
@@ -75,7 +69,7 @@ of `Foo`. But this constructor has to be called explicitly.)
 
 如果一个属性在原型链的上端，则对于查找时间将带来不利影响。特别的，试图获取一个不存在的属性将会遍历整个原型链。
 
-并且，当使用 [`for in`](#the-for-in-loop) 循环遍历对象的属性时，原型链上的**所有**属性都将被访问。
+并且，当使用 [`for in`](#object.forinloop) 循环遍历对象的属性时，原型链上的**所有**属性都将被访问。
 
 ###扩展内置类型的原型
 
@@ -100,4 +94,3 @@ of `Foo`. But this constructor has to be called explicitly.)
 [3]: https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/forEach
 [5]: http://en.wikipedia.org/wiki/Backport 
 [30]: http://cnblogs.com/sanshi/
-