types.* fixed

Author: shamansir

doc/ru/types/casting.md

@@ -1,36 +1,36 @@
 ## Приведение типов
 
-JavaScript *слабо типизированный* язык, поэтому *преобразование типов* будет применяться **везде**, где это возможно.
+JavaScript — *слабо типизированный* язык, поэтому *преобразование типов* будет применяться **везде**, где оно возможно.
 
-    // Эти равенства — истинны
+    // Эти равенства возвращают true
     new Number(10) == 10; // Number.toString() преобразуется
                           // обратно в число
 
-    10 == '10';           // Strings преобразуется в Number
+    10 == '10';           // Строки преобразуются в Number
     10 == '+10 ';         // Ещё чуток строко-безумия
     10 == '010';          // и ещё
     isNaN(null) == false; // null преобразуется в 0,
                           // который, конечно же, не NaN
 
-    // Эти равенства — ложь
+    // Эти равенства возвращают false
     10 == 010;
     10 == '-10';
 
 > **ES5 Замечание:** Числовые литералы, которые начинаются с 0 интерпретируются как восьмеричные (Base 8). В ECMAScript 5 strict mode **удалена** поддержка восьмеричной системы.
 
-Для того, чтобы избежать этого, **настоятельно** рекомендуется использовать [оператор строгого равенства](#types.equality). Впрочем, хотя это и позволяет избежать многих распространенных ошибок, существует ещё много дополнительных вопросов, которые возникают из-за слабости типизации JavaScript.
+Для того, чтобы избежать такого поведения, **настоятельно** рекомендуется использовать [оператор строгого равенства](#types.equality). Впрочем, хотя это и позволяет избежать многих распространенных ошибок, существует ещё много дополнительных проблем, возникающих по вине слабой типизации JavaScript.
 
 ### Конструкторы встроенных типов
 
-Конструкторы встроенных типов, например, `Number` и `String` ведут себя различным образом, в зависимости от того вызываются они с ключевым словом `new` или без.
+Конструкторы встроенных типов, например, `Number` и `String` ведут себя различным образом, в зависимости от того, вызываются они с ключевым словом `new` или без.
 
-    new Number(10) === 10;     // False, Object и Number
-    Number(10) === 10;         // True, Number и Number
-    new Number(10) + 0 === 10; // True, из-за неявного преобразования
+    new Number(10) === 10;     // False: Object и Number
+    Number(10) === 10;         // True: Number и Number
+    new Number(10) + 0 === 10; // True: из-за неявного преобразования
 
-Использование встроенных типов, например `Number`, с конструктором создаёт новый экземпляр объекта Number, но использование без ключевого слова `new` создаст функцию `Number`, которая будет вести себя как конвертер.
+Использование встроенных типов, таких как `Number`, с конструктором, создаёт новый экземпляр объекта `Number`, но использование без ключевого слова `new` создаёт функцию `Number`, которая будет вести себя в равенствах как конвертер.
 
-Кроме того, присутствие литералов или переменных, которые не являются объектами приведет к еще большему насилию над типами.
+Кроме того, присутствие в равенствах литералов или переменных, которые не являются объектами, повлечёт лишь более серьёзное насилие над типами.
 
 Лучший вариант — это **явное** приведение к одному из трех возможных типов.
 
@@ -44,11 +44,11 @@ JavaScript *слабо типизированный* язык, поэтому *
 
     +'10' === 10; // true
 
-Используя **унарный** оператор плюс можно преобразовать значение в число.
+Используя **унарный** оператор плюс, можно преобразовать значение в число.
 
 ### Приведение к булеву типу
 
-Используя оператор **not** (**`!`**) дважды, значение может быть приведено к логическому (булеву) типу.
+Использование оператора **not** (`!`) дважды поможет привести значение к логическому (булеву) типу.
 
     !!'foo';   // true
     !!'';      // false

doc/ru/types/instanceof.md

@@ -1,6 +1,6 @@
 ## Оператор `instanceof`
 
-Оператор `instanceof` сравнивает конструкторы двух операндов. Это полезно только когда сравниваются пользовательские объекты. Использование на встроенных типах почти так же бесполезно, как и [оператор typeof](#types.typeof).
+Оператор `instanceof` сравнивает конструкторы двух операндов. Работает это только тогда, когда сравниваются пользовательские объекты. Использование же на встроенных типах почти так же бесполезно, как и [оператор typeof](#types.typeof).
 
 ### Сравнение пользовательских объектов
 
@@ -11,7 +11,7 @@
     new Bar() instanceof Bar; // true
     new Bar() instanceof Foo; // true
 
-    // Всего лишь присваиваем Bar.prototype объект функции Foo,
+    // Банально присваиваем Bar.prototype объект функции Foo,
     // но не экземпляра Foo
     Bar.prototype = Foo;
     new Bar() instanceof Foo; // false
@@ -24,9 +24,9 @@
     'foo' instanceof String; // false
     'foo' instanceof Object; // false
 
-Здесь надо отметить одну важную вещь: `instanceof` не работает на объектах, которые происходят из разных контекстов JavaScript (например, из различных документов в web-браузере), так как их конструкторы и правда не будут конструкторами *тех самых* объектов.
+Здесь надо отметить одну важную вещь: `instanceof` не работает на объектах, которые происходят из разных контекстов JavaScript (например, из различных документов в web-браузере), так как их конструкторы и правда не будут конструкторами *тех же самых* объектов.
 
 ### Заключение
 
-Оператор `instanceof` должен использоваться **только** при обращении к пользовательским объектам, происходящим из одного контекста JavaScript. Так же, как и в случае оператора `typeof`, любое другое использование необходимо **избегать**.
+Оператор `instanceof` должен использоваться **только** при обращении к пользовательским объектам, происходящим из одного контекста JavaScript. Так же, как и в случае оператора `typeof`, любого другого использования `instanceof` необходимо **избегать**.
 

doc/ru/types/typeof.md

@@ -1,8 +1,8 @@
 ## Оператор `typeof`
 
-Оператор `typeof` (вместе с [`instanceof`](#types.instanceof)) — это, вероятно, самая большая недоделка в JavaScript, поскольку с течением опыта выясняется, что он **поломан разве что не полностью**.
+Оператор `typeof` (вместе с [`instanceof`](#types.instanceof)) — это, вероятно, самая большая недоделка в JavaScript, поскольку с накоплением опыта выясняется, что он **поломан, разве что не полностью**.
 
-Хотя `instanceof` используется достаточно редко, `typeof` вообще имеет только один практический случай применения, который при всём при этом, неожиданно,.. **не** оказывается проверкой типа объекта.
+При том, число поводов для применения `instanceof` ограничено, `typeof` вообще имеет *один-единственный* практический случай применения, который при всём при этом, неожиданно,.. **не** оказывается проверкой типа объекта.
 
 > **Замечаение:** Хотя для вызова `typeof` также можно использовать синтаксис функции, т.е. `typeof(obj)`, на самом деле это вовсе не функция. Да — двойные круглые скобки будут работать нормально и возвращаемое значение будет использоваться как операнд оператора `typeof`, но функции `typeof` — **не существует**.
 
@@ -32,7 +32,7 @@
 
 > **Из спецификации:** Значением `[[Class]]` может быть одна из следующих строк: `Arguments`, `Array`, `Boolean`, `Date`, `Error`, `Function`, `JSON`, `Math`, `Number`, `Object`, `RegExp`, `String`.
 
-Чтобы получить значение `[[Class]]` нужно применить к объекту метод `toString` из `Object.prototype`.
+Чтобы получить значение `[[Class]]`, нужно применить к объекту метод `toString` из `Object.prototype`.
 
 ### Класс объекта
 
@@ -54,11 +54,11 @@
 
     typeof foo !== 'undefined'
 
-Этим выражением удостоверяется, была ли переменная `foo` действительно объявлена; явное обращение к несуществующей переменной в коде породит `ReferenceError`. Вот это единственное, чем на самом деле полезен `typeof`.
+Данное выражение позволяет удостовериться, была ли объявлена переменная `foo`; явное обращение к несуществующей переменной в коде породит `ReferenceError`. И вот это — единственное, чем на самом деле полезен `typeof`.
 
 ### Заключение
 
-Для проверки типа объекта настоятельно рекомендуется использовать `Object.prototype.toString` — это единственный и надежный способ. Как показано выше в таблице типов, некоторые значения, возвращаемые `typeof`, не описаны в спецификации: таким образом, они могут отличаться в различных реализациях.
+Для проверки типа объекта настоятельно рекомендуется использовать `Object.prototype.toString` — это единственный и надежный способ. Как показано выше в таблице типов, некоторые значения, возвращаемые `typeof`, не описаны в спецификации: следовательно, они могут различаться в разных реализациях.
 
-Кроме случая проверки, была ли определена переменная, `typeof` следует избегать.
+За исключением случаев проверки, была ли определена переменная, использования `typeof` следует избегать.