Add typeof section

Author: sanshi

doc/zh/function/arguments.md

@@ -47,7 +47,8 @@ JavaScript 中每个函数内都能访问一个特别变量 `arguments`。这个
         Function.call.apply(Foo.prototype.method, arguments);
     };
 
-译者注：上面的 `Foo.method` 函数和下面代码的效果是一样的。
+	
+[译者注][30]：上面的 `Foo.method` 函数和下面代码的效果是一样的:
 
 	Foo.method = function() {
 		var args = Array.prototype.slice.call(arguments);
@@ -84,9 +85,10 @@ JavaScript 中每个函数内都能访问一个特别变量 `arguments`。这个
 
 > **ES5 提示:** 这些 *getters* 和 *setters* 在严格模式下（strict mode）不会被创建。
 
-译者注：在 [MDC][2] 中对 `strict mode` 模式下 `arguments` 的描述有助于我们的理解。
 
-	// 译者注：来自 [MDC][2] 的代码，说明在 ES5 的严格模式下 `arguments` 的特性。
+[译者注][30]：在 [MDC][2] 中对 `strict mode` 模式下 `arguments` 的描述有助于我们的理解，请看下面代码：
+
+	// 阐述在 ES5 的严格模式下 `arguments` 的特性
 	function f(a)
 	{
 	  "use strict";
@@ -110,7 +112,7 @@ JavaScript 中每个函数内都能访问一个特别变量 `arguments`。这个
         }
     }
 
-上面代码中，`foo` 不再是一个单纯的内联函数 [inlining][1]（译者注：这里指的是解析器可以做内联处理），
+上面代码中，`foo` 不再是一个单纯的内联函数 [inlining][1]（[译者注][30]：这里指的是解析器可以做内联处理），
 因为它需要知道它自己和它的调用者。
 这不仅抵消了内联函数带来的性能提升，而且破坏了封装，因此现在函数可能要依赖于特定的上下文。
 
@@ -121,4 +123,4 @@ JavaScript 中每个函数内都能访问一个特别变量 `arguments`。这个
 
 [1]: http://en.wikipedia.org/wiki/Inlining
 [2]: https://developer.mozilla.org/en/JavaScript/Strict_mode
-
+[30]: http://cnblogs.com/sanshi/

doc/zh/function/closures.md

@@ -57,7 +57,7 @@ copying the value of the loops index variable.）。
 
 ### 避免引用错误（Avoiding the reference problem）
 
-为了正确的获得循环序号，最好使用 [匿名包裹器](#scopes)（译者注：其实就是我们通常说的自执行匿名函数）。
+为了正确的获得循环序号，最好使用 [匿名包裹器](#scopes)（[译者注][30]：其实就是我们通常说的自执行匿名函数）。
 
     for(var i = 0; i < 10; i++) {
         (function(e) {
@@ -81,3 +81,5 @@ copying the value of the loops index variable.）。
         })(i), 1000)
     }
 
+	
+[30]: http://cnblogs.com/sanshi/

doc/zh/function/constructors.md

@@ -27,25 +27,29 @@ JavaScript 中的构造函数和其它语言中的构造函数是不同的。
     }
     new Bar(); // 返回新创建的对象
 
-	// 译者注：new Bar() 返回的是新创建的对象，而不是数字的字面值 2。
-	// 因此 new Bar().constructor === Bar
-	// 但是如果返回的是数字对象，结果就不同了
-	// function Bar() {
-    //    return new Number(2);
-    // }
-    // new Bar().constructor === Number
-	
-	
-    function Test() {
+	function Test() {
         this.value = 2;
 
         return {
             foo: 1
         };
     }
     new Test(); // 返回的对象
-	// 译者注：这里得到的是函数返回的对象，而不是通过 new 关键字新创建的对象
-	// 所有 (new Test()).value 为 undefined，但是 (new Test()).foo === 1。
+
+	
+[译者注][30]：new Bar() 返回的是新创建的对象，而不是数字的字面值 2。
+因此 new Bar().constructor === Bar，但是如果返回的是数字对象，结果就不同了，如下所示
+	
+	function Bar() {
+		return new Number(2);
+    }
+    new Bar().constructor === Number
+	
+	
+[译者注][30]：这里得到的（new Test()）是函数返回的对象，而不是通过 new 关键字新创建的对象，因此：
+	(new Test()).value === undefined
+	(new Test()).foo === 1
+
 
 如果 `new` 被遗漏了，则函数**不会**返回新创建的对象。
 
@@ -80,12 +84,13 @@ JavaScript 中的构造函数和其它语言中的构造函数是不同的。
 其实这里创建了一个[闭包](#function.closures)。
 
 
-还需要注意，`new Bar()` 并**不会**改变返回对象的原型（译者注：也就是返回对象的原型不会指向 Bar.prototype）。
-因为构造函数的原型会被指向到刚刚创建的新对象，而这里的 `Bar` 没有把这个新对象返回（译者注：而是返回了一个包含 `method` 属性的自定义对象）。 
+还需要注意，`new Bar()` 并**不会**改变返回对象的原型（[译者注][30]：也就是返回对象的原型不会指向 Bar.prototype）。
+因为构造函数的原型会被指向到刚刚创建的新对象，而这里的 `Bar` 没有把这个新对象返回（[译者注][30]：而是返回了一个包含 `method` 属性的自定义对象）。 
 
 在上面的例子中，使用或者不使用 `new` 关键字没有功能性的区别。
 
-	// 译者注：上面两种方式创建的对象不能访问 Bar 原型链上的属性
+[译者注][30]：上面两种方式创建的对象不能访问 Bar 原型链上的属性，如下所示：
+	
 	var bar1 = new Bar();
 	typeof(bar1.method); // "function"
 	typeof(bar1.foo); // "undefined"
@@ -129,3 +134,5 @@ JavaScript 中的构造函数和其它语言中的构造函数是不同的。
 虽然遗漏 `new` 关键字可能会导致问题，但这并**不是**放弃使用原型链的借口。
 最终使用哪种方式取决于应用程序的需求，选择一种代码书写风格并**坚持**下去才是最重要的。
 
+
+[30]: http://cnblogs.com/sanshi/

doc/zh/function/general.md

@@ -39,3 +39,6 @@
 `bar` 函数声明外是不可见的，这是因为我们已经把函数赋值给了 `foo`；
 然而在 `bar` 内部依然可见。这是由于 JavaScript 的 [命名处理](#scopes) 所致，
 函数名在函数内*总是*可见的。
+
+
+[30]: http://cnblogs.com/sanshi/

doc/zh/function/scopes.md

@@ -13,7 +13,7 @@
 > **注意:** 如果不是在赋值语句中，而是在 return 表达式或者函数参数中，`{...}` 将会作为代码段解析，
 > 而不是作为对象的字面语法解析。如果考虑到 [自动分号插入](#semicolon)，这可能会导致一些不易察觉的错误。
 
-译者注：如果 return 对象的左括号和 return 不在一行上就会出错。
+[译者注][30]：如果 return 对象的左括号和 return 不在一行上就会出错。
 
 	// 译者注：下面输出 undefined
 	function add(a, b) {
@@ -157,7 +157,7 @@ JavaScript 会**提升**变量声明。这意味着 `var` 表达式和 `function
     }
 
 
-译者注：在 Nettuts+ 网站有一篇介绍 hoisting 的[文章][1]，其中的代码很有启发性。
+[译者注][30]：在 Nettuts+ 网站有一篇介绍 hoisting 的[文章][1]，其中的代码很有启发性。
 
 	// 译者注：来自 Nettuts+ 的一段代码，生动的阐述了 JavaScript 中变量声明提升规则
 	var myvar = 'my value';  
@@ -188,7 +188,7 @@ JavaScript 中的所有作用域，包括*全局作用域*，都有一个特别
 只有一个全局作用域导致的常见错误是命名冲突。在 JavaScript中，这可以通过 *匿名包装器* 轻松解决。
 
     (function() {
-        // 函数创建一个命名空间（译者注：也就是作用域）
+        // 函数创建一个命名空间
         
         window.foo = function() {
             // 对外公开的函数，创建了闭包
@@ -211,10 +211,11 @@ JavaScript 中的所有作用域，包括*全局作用域*，都有一个特别
 
 ### 结论（In conclusion）
 
-推荐使用*匿名包装器*（译者注：也就是自执行的匿名函数）来创建命名空间。这样不仅可以防止命名冲突，
+推荐使用*匿名包装器*（[译者注][30]：也就是自执行的匿名函数）来创建命名空间。这样不仅可以防止命名冲突，
 而且有利于程序的模块化。
 
 另外，使用全局变量被认为是**不好的习惯**。这样的代码倾向于产生错误和带来高的维护成本。
 
 
-[1]: http://net.tutsplus.com/tutorials/javascript-ajax/quick-tip-javascript-hoisting-explained/
+[1]: http://net.tutsplus.com/tutorials/javascript-ajax/quick-tip-javascript-hoisting-explained/
+[30]: http://cnblogs.com/sanshi/

doc/zh/function/this.md

@@ -8,7 +8,9 @@ JavaScript 有一套完全不同于其它语言的对 `this` 的处理机制。
     this;
 
 当在全部范围内使用 `this`，它将会指向*全局*对象。
-（译者注：浏览器中运行的JavaScript脚本，这个全局对象是 window）
+
+[译者注][30]：浏览器中运行的JavaScript脚本，这个全局对象是 window。
+
 
 ### 函数调用（Calling a function）
 
@@ -18,7 +20,7 @@ JavaScript 有一套完全不同于其它语言的对 `this` 的处理机制。
 
 > **ES5 注意:** 在严格模式下（strict mode），不存在全局变量。
 > 这种情况下 `this` 将会是 `undefined`。
->（译者注：ES5指的是ECMAScript 5，是2009-12发布的最新的 JavaScript 版本。）
+> [译者注][30]：ES5指的是ECMAScript 5，是 2009-12 发布的最新的 JavaScript 版本。
 
 ### 方法调用（Calling a method）
 
@@ -48,16 +50,16 @@ JavaScript 有一套完全不同于其它语言的对 `this` 的处理机制。
 
 > **注意:** 在对象的字面声明语法中，`this` **不能**用来指向对象本身。
 > 因此 `var obj = {me: this}` 中的 `me` 不会指向 `obj`，因为 `this` 只可能出现在上述的五种情况中。
-> （译者注：这个例子中，如果是在浏览器中运行，obj.me等于window对象。）
+> [译者注][30]：这个例子中，如果是在浏览器中运行，obj.me等于window对象。
 
 ### 常见误解（Common pitfalls）
 
-尽管大部分的情况都说的过去，不过第一个规则（译者注：这里指的应该是第二个规则，也就是直接调用函数时，`this` 指向全局对象）
+尽管大部分的情况都说的过去，不过第一个规则（[译者注][30]：这里指的应该是第二个规则，也就是直接调用函数时，`this` 指向全局对象）
 被认为是JavaScript语言另一个错误设计的地方，因为它**从来**就没有实际的用途。
 
     Foo.method = function() {
         function test() {
-            // this 将会被设置为全局对象（译者注：浏览器环境中也就是 window 对象）
+            // this 将会被设置为全局对象（[译者注][30]：浏览器环境中也就是 window 对象）
         }
         test();
     }
@@ -97,3 +99,6 @@ JavaScript 有一套完全不同于其它语言的对 `this` 的处理机制。
     new Bar().method();
 
 当 `method` 被调用时，`this` 将会指向 `Bar` 的实例对象。
+
+
+[30]: http://cnblogs.com/sanshi/

doc/zh/intro/contributors.md

@@ -4,8 +4,13 @@
  - [Andreas Blixt][2] （语言修正）
 
 ## 中文翻译
- - [三生石上][3]
+ - [三生石上][29]
+
+此中文翻译由[三生石上][29]独立完成，[博客园][30]首发，转载请注明出处。
+ 
 
 [1]: https://github.com/caio
 [2]: https://github.com/blixt
-[3]: http://cnblogs.com/sanshi/
+
+[29]: http://sanshi.me/
+[30]: http://cnblogs.com/sanshi/

doc/zh/object/forinloop.md

@@ -39,4 +39,5 @@
 
 
 [1]: http://www.prototypejs.org/
+[30]: http://cnblogs.com/sanshi/
 

doc/zh/object/general.md

@@ -48,8 +48,9 @@ JavaScript 的对象可以作为[*哈希表*][1]使用，主要用来保存命
 
 两种语法是等价的，但是中括号操作符在下面两种情况下依然有效
  - 动态设置属性
- - 属性名不是一个有效的变量名（译者注：比如属性名中包含空格，或者属性名是JS的关键词）
-（译者注：在 [JSLint][2] 语法检测工具中，点操作符是推荐做法）
+ - 属性名不是一个有效的变量名（[译者注][30]：比如属性名中包含空格，或者属性名是JS的关键词）
+
+[译者注][30]：在 [JSLint][2] 语法检测工具中，点操作符是推荐做法。
 
 ### 删除属性（Deleting properties）
 
@@ -88,3 +89,5 @@ JavaScript 的对象可以作为[*哈希表*][1]使用，主要用来保存命
 
 [1]: http://en.wikipedia.org/wiki/Hashmap
 [2]: http://www.jslint.com/
+[30]: http://cnblogs.com/sanshi/
+

doc/zh/object/hasownproperty.md

@@ -45,3 +45,4 @@ JavaScript **不会**保护 `hasOwnProperty` 被非法占用，因此如果一
 同时在使用 [`for in` loop](#forinloop) 遍历对象时，推荐**总是**使用 `hasOwnProperty` 方法，
 这将会避免[原型](#prototype)对象扩展带来的干扰。
 
+[30]: http://cnblogs.com/sanshi/

doc/zh/object/prototype.md

@@ -48,9 +48,9 @@ other way around is a far more difficult task.）
 `Foo` instance, since that property gets defined in the [constructor](#constructor)
 of `Foo`. But this constructor has to be called explicitly.）
 
-（译者注：我认为这个描述是错误的，test.value 是可以访问的。
+[译者注][30]：我认为这个描述是错误的，test.value 是可以访问的。
 因为在设置 Bar.prototype = new Foo(); 时，`value` 也就成为 Bar.prototype 上的一个属性。
-如果你有不同观点，可以到[我的博客][4]评论。）
+如果你有不同观点，可以到[我的博客][30]评论。
 
 > **注意:** **不要**使用 `Bar.prototype = Foo`，因为这不会执行 `Foo` 的原型，而是指向函数 `Foo`。
 > 因此原型链将会回溯到 `Function.prototype` 而不是 `Foo.prototype`，因此 `method` 将不会在 Bar 的原型链上。
@@ -85,7 +85,9 @@ of `Foo`. But this constructor has to be called explicitly.）
 但是我仍然不认为为内置类型添加一些*非标准*的函数是个好主意。
 
 扩展内置类型的**唯一**理由是为了和新的 JavaScript 保持一致，比如 [`Array.forEach`][3]。
-（译者注：这是编程领域常用的一种方式，称之为 [Backport][5]，也就是将新的补丁添加到老版本中。）
+
+[译者注][30]：这是编程领域常用的一种方式，称之为 [Backport][5]，也就是将新的补丁添加到老版本中。
+
 
 ### 总结（In conclusion）
 
@@ -97,6 +99,6 @@ of `Foo`. But this constructor has to be called explicitly.）
 [1]: http://en.wikipedia.org/wiki/Monkey_patch
 [2]: http://prototypejs.org/
 [3]: https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/forEach
-[4]: http://cnblogs.com/sanshi/
 [5]: http://en.wikipedia.org/wiki/Backport 
+[30]: http://cnblogs.com/sanshi/
 

doc/zh/types/casting.md

@@ -68,3 +68,5 @@ By using the **not** operator twice, a value can be converted a boolean.
     !!true;    // true
 
 
+
+[30]: http://cnblogs.com/sanshi/

doc/zh/types/equality.md

@@ -60,3 +60,7 @@ JavaScript 是*弱类型*语言，这就意味着，等于操作符会为了比
 
 强烈推荐使用**严格的等于操作符**。如果类型需要转换，应该在比较之前[显式](#types.casting)的转换，
 而不是使用语言本身复杂的强制转换规则。
+
+
+
+[30]: http://cnblogs.com/sanshi/

doc/zh/types/instanceof.md

@@ -36,3 +36,5 @@ The `instanceof` operator should **only** be used when dealing with custom made
 objects that origin from the same JavaScript context. Just like the
 [`typeof`](#types.typeof) operator, every other use of it should be **avoided**.
 
+
+[30]: http://cnblogs.com/sanshi/