Merge remote-tracking branch 'upstream/master'

Author: kreikenbaum

CONTRIBUTING.md

@@ -9,7 +9,7 @@ Thank you for being kind enough to help out!
 
 ## Testing locally
 
-1. Run `npm run build.js` to build
+1. Run `npm run build` to build
 1. Run a webserver from the root of the repo to view
 
 ## Getting changes merged

doc/en/function/closures.md

@@ -36,12 +36,12 @@ Since it is not possible to reference or assign scopes in JavaScript, there is
 interact with it is via the two closures.
 
     var foo = new Counter(4);
-    foo.hack = function() {
+    foo.hackFail = 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 
+since `foo.hackFail` was not defined in **that** scope. It will instead create - or 
 override - the *global* variable `count`.
 
 ### Closures Inside Loops

doc/en/function/scopes.md

@@ -220,6 +220,7 @@ which, while different in syntax, behave the same way.
     !function(){}()
     +function(){}()
     (function(){}());
+    void function(){}();
     // and so on...
 
 ### In Conclusion

doc/en/object/general.md

@@ -20,7 +20,7 @@ There are a couple of workarounds that can be used to make number literals act
 as objects too.
 
     2..toString(); // the second point is correctly recognized
-    2 .toString(); // note the space left to the dot
+    2 .toString(); // note the space left of the dot
     (2).toString(); // 2 is evaluated first
 
 ### Objects as a Data Type

doc/it/types/casting.md

@@ -25,7 +25,7 @@ una *conversione di tipo* **ovunque** sia possibile.
 Per evitare i problemi appena visti, l'uso
 dell'[operatore di uguaglianza stretta](#types.equality) è **altamente**
 raccomandato. Sebbene questo eviti molti dei comuni problemi, ci sono ancora
-molti ulteriori problemi che possono essere generati dal sistema debolemente
+molti ulteriori problemi che possono essere generati dal sistema debolmente
 tipizzato di JavaScript.
 
 ### Costruttori di tipi interni

doc/it/types/instanceof.md

@@ -34,7 +34,7 @@ esattamente lo stesso oggetto.
 
 ### In conclusione
 
-L'operatore `instanceof` dovrebbe essere usto **solo** quando si ha a che fare
+L'operatore `instanceof` dovrebbe essere usato **solo** quando si ha a che fare
 con oggetti personalizzati creati dal programmatore, che provengono dallo
 stesso contesto JavaScript. Proprio come per l'operatore [`typeof`](#types.typeof),
 ogni altro tipo di utilizzo dovrebbe essere **evitato**.

doc/ru/array/constructor.md

@@ -15,7 +15,7 @@
     arr[1]; // не определён, undefined
     1 in arr; // false, индекс не был установлен
 
-Поведение, которое позволяет изначально установить только размер массива, может пригодиться лишь в нескольких случаях, таких как повторение строк, за счёт чего избегается использование цикла `for loop`.
+Поведение, которое позволяет изначально установить только размер массива, может пригодиться лишь в нескольких случаях, таких как повторение строк, за счёт чего избегается использование цикла `for`.
 
     new Array(count + 1).join(stringToRepeat);
 

doc/ru/object/general.md

@@ -73,7 +73,7 @@
 
     var test = {
         'case': 'Я — ключевое слово, поэтому меня надо записывать строкой',
-        delete: 'Я тоже ключевое слово, так что я' // бросаю SyntaxError
+        delete: 'Я тоже ключевое слово, так что я' // не является ошибкой, бросает SyntaxError только в версиях ECMAScript ниже 5ой версии
     };
 
 Свойства объектов могут записываться как явно символами, так и в виде закавыченных строк. В связи с другим упущением в парсере JavaScript, этот код выбросит `SyntaxError` во всех версиях ранее ECMAScript 5.

doc/ru/object/hasownproperty.md

@@ -16,7 +16,7 @@
     foo.hasOwnProperty('bar'); // false
     foo.hasOwnProperty('goo'); // true
 
-Только используя ｀hasOwnProperty｀ можно гарантировать правильный результат при переборе свойств объекта. И **нет** иного способа для определения свойств, которые определены в *самом* объекте, а не где-то в цепочке его прототипов.
+Только используя `hasOwnProperty` можно гарантировать правильный результат при переборе свойств объекта. И **нет** иного способа для определения свойств, которые определены в *самом* объекте, а не где-то в цепочке его прототипов.
 
 ### `hasOwnProperty` как свойство
 
@@ -38,4 +38,3 @@ JavaScript **не** резервирует свойство с именем `has
 ### Заключение
 
 **Единственным** способом проверить существование свойства у объекта является использование метода `hasOwnProperty`. При этом рекомендуется использовать этот метод в **каждом** [цикле `for in`](#object.forinloop) вашего проекта, чтобы избежать возможных ошибок с ошибочным заимствованием свойств из [прототипов](#object.prototype) родительских объектов. Также вы можете использовать конструкцию `{}.hasOwnProperty.call(...)` на случай, если кто-то вздумает расширить [прототипы](#object.prototype) встроенных объектов.
-

doc/ru/object/prototype.md

@@ -10,17 +10,19 @@
 
 > **Замечание:** В результате выполнения конструкции `Bar.prototype = Foo.prototype` оба объекта будут делить друг с другом **один и тот же** прототип. Так что изменение прототипа одного из объектов повлечёт за собой изменение прототипа другого и наоборот — вряд ли это окажется тем, чего вы ожидали.
 
+> **Замечание:** Для объявления наследования вместо `Bar.prototype = Object.create(Foo.prototype)` можно воспользоваться конструкций `Bar.prototype = new Foo()`, но у нее есть пару недостатков: 1) как правило требуется унаследовать только методы и свойства прототипа, а не создавать для этого новый объект; 2) создание объекта может требовать обязательные аргументы.
+
+> **Примечание:** Метод `Object.create` отсутствует в IE8 и ниже, но его легко реализовать созданием своей такой функции или же можно подключить библиотеку для поддержки старых IE [*es5-shim*][5]
+
     function Foo() {
         this.value = 42;
     }
-    Foo.prototype = {
-        method: function() {}
-    };
+    Foo.prototype.method = function() {}
 
     function Bar() {}
 
-    // Установим значением прототипа Bar новый экземпляр Foo
-    Bar.prototype = new Foo();
+    // Зададим наследование от Foo
+    Bar.prototype = Object.create(Foo.prototype);
     Bar.prototype.foo = 'Hello World';
 
     // Убедимся, что Bar является действующим конструктором
@@ -81,4 +83,5 @@
 [2]: http://en.wikipedia.org/wiki/Monkey_patch
 [3]: http://prototypejs.org/
 [4]: https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/forEach
+[5]: https://github.com/es-shims/es5-shim
 

doc/zh/object/prototype.md

@@ -3,7 +3,7 @@
 JavaScript 不包含传统的类继承模型，而是使用 *prototype* 原型模型。
 
 虽然这经常被当作是 JavaScript 的缺点被提及，其实基于原型的继承模型比传统的类继承还要强大。
-实现传统的类继承模型是很简单，但是实现 JavaScript 中的原型继承则要困难的多。
+例如，很容易通过原型继承实现传统的类继承模型，但是反过来，通过传统的类继承模型来实现原型继承模型就困难得多。
 (It is for example fairly trivial to build a classic model on top of it, while the
 other way around is a far more difficult task.)
 

doc/zhtw/core/eval.md

@@ -32,7 +32,7 @@
 ### 安全上的顧慮
 
 `eval` 同樣有安全上的問題，因為所有的程式碼都可以被直接執行。
-而他不應去執行一串未知的字串或是來自不幸任的來源。
+而他不應去執行一串未知的字串或是來自不信任的來源。
 
 ### 結語
 

doc/zhtw/function/general.md

@@ -25,19 +25,19 @@
 
 由於 `var` 已經宣告變數 `foo` 在所有的程式碼執行之前。
 所以 `foo`已經在程式運行前就已經被定義過了。
-但是因為賦值只會在運行時去職情，所以在程式碼執行前，`foo` 的值還沒被宣告所以為 [undefined](#core.undefined)。
+但是因為賦值只會在運行時去執行，所以在程式碼執行前，`foo` 的值還沒被宣告所以為 [undefined](#core.undefined)。
 
 
 ### 命名函式的賦值表達式
 
-另一個特殊狀況就勢將一個命名函式賦值給一個變數。
+另一個特殊狀況是將一個命名函式賦值給一個變數。
 
     var foo = function bar() {
         bar(); // 可以運行
     }
     bar(); // 錯誤：ReferenceError
 
-`bar` 不可以在外部的區域被執行，因為它只有在 `foo` 的函式內才可以去執行。
+`bar` 不可以在外部的區域被執行，因為它只有在 `foo` 的函式內才可以執行。
 然而在 `bar` 內部還是可以看見。這是由於 JavaScript的 [命名處理](#function.scopes)所致。
-函式名在函式內 *都* 可以去使用。
+函式名在函式內 *都* 可以使用。
 

doc/zhtw/function/this.md

@@ -1,7 +1,7 @@
 ## `this` 的工作原理
 
 JavaScript 有移到完全部屬於其他語言處理 `this` 的處理機制。
-在 **五** 種物同的情況下， `this` 指向的個不相同
+在 **五** 種不同的情況下， `this` 指向的各不相同
 
 ### 全域變數
 
@@ -14,12 +14,12 @@ JavaScript 有移到完全部屬於其他語言處理 `this` 的處理機制。
 
     foo();
 
-這裡 `this` 也會指向 *全域* 對象。
+這裡 `this` 也會指向 *全域* 物件。
 
 > **ES5 注意:** 在嚴格模式下，不存在全域變數。
 > `this` 將會是 `undefined`。
 
-### 方法調用
+### 呼叫一個方法
 
     test.foo(); 
 

doc/zhtw/object/forinloop.md

@@ -27,10 +27,10 @@
     }
 
 這個版本的程式碼是唯一正確的寫法。由於我們使用了 `hasOwnProperty`，這次 **只** 輸出 `moo`。
-如果不只用這個程式碼在原型物件中(比如 `Object.prototype`)被擴展可能會出錯。
+如果不使用這個程式碼在原型物件中(比如 `Object.prototype`)被擴展可能會出錯。
 
-一個廣泛的模組 [Prototype][1]就礦展了圓型的 JavaScript 物件。
-因此，但這模組包含在頁面中時，不使用 `hasOwnProperty` 過濾的 `for in` 尋難免會出問題。
+一個廣泛使用的舊函式庫 [Prototype][1]就擴展了原型的 JavaScript 物件。
+因此，當這個函式庫包含在頁面中時，不使用 `hasOwnProperty` 過濾的 `for in` 迴圈難免會出問題。
 
 ### 總結
 

doc/zhtw/object/hasownproperty.md

@@ -1,6 +1,6 @@
 ## `hasOwnProperty`
 
-為了判斷一個物件是否包含 *自定義* 屬性而 *不是* [原形](#object.prototype)上的屬性，我們需要使用繼承 `Object.prototype` 的 `hasOwnProperty` 方法。
+為了判斷一個物件是否包含 *自定義* 屬性而 *不是* [原型](#object.prototype)上的屬性，我們需要使用繼承 `Object.prototype` 的 `hasOwnProperty` 方法。
 
 > **注意:** 判斷一個屬性是否 `undefined` 是 **不夠的**。
 > 因為一個屬性可能存在，但是它的值被設成 `undefined`。
@@ -42,4 +42,4 @@ JavaScript **不會** 保護 `hasOwnProperty`被占用，因此如果碰到存
 
 當檢查一個物件是否存在的時候， `hasOwnProperty` 是 **唯一** 可用的方法。
 同時在使用 [`for in loop`](#object.forinloop)
-建議使用 `hasOwnProperty` 避免 [原型](#object.prototype)所帶來的干擾。
+建議使用 `hasOwnProperty` 避免 [原型](#object.prototype)所帶來的干擾。

doc/zhtw/object/prototype.md

@@ -72,14 +72,14 @@ JavaScript 不包含傳統繼承的模型，它使用的是*原型*模型。
 
 一個經常發生的錯誤，那就是擴展 `Object.prototype` 或者是其他內建類型的原型物件。
 
-這種技術叫做 [monkey patching][1] 並且會破壞 *封裝*。雖然被廣泛的應用到一些 Javascript 的架構，像是 [Prototype](http://prototypejs.org) ， 但仍然沒有好的理由新增一個 *非標準* 的功能去搞亂內建型別
+這種技術叫做 [monkey patching][1] 並且會破壞 *封裝*。雖然被廣泛的應用到一些 Javascript 的架構，像是 [Prototype](http://prototypejs.org) ， 但仍然沒有好的理由新增一個 *非標準* 的功能去搞亂內建型別。
 
 擴展內置類型的 **唯一** 理由是為了和新的 JavaScript 保持一致，比如說 [`Array.forEach`][3]
 
 ### 總結
 
 在寫複雜的程式碼的時候，要 **充分理解** 所有程式繼承的屬性還有原型鏈。
-還要堤防原型鏈過長帶來的性能問題，並知道如何通過縮短原型鏈來提高性能。
+還要提防原型鏈過長帶來的性能問題，並知道如何通過縮短原型鏈來提高性能。
 絕對 **不要使用** `native prototype` 除非是為了和新的 JavaScript 引擎作兼容。
 
 [1]: http://en.wikipedia.org/wiki/Monkey_patch