core translation

Author: shamansir

doc/ru/core/delete.md

@@ -0,0 +1,76 @@
+## Оператор `delete`
+
+Если кратко — в JavaScript невозможно удалить глобальную переменную или функцию или какую-либо другую сущность, у которой установлен атрибут `DontDelete`.
+
+### Глобальный код и код внутри функций
+
+Когда переменная или функция определена в глобальной области видимости или в [области видимости функции](#function.scopes), её судьба предопределена: (''прим. перев.'' — где-то внутри движка JavaScript) она является свойством либо объекта Activation, либо объекта Global. Каждое из таких свойств имеет по набору атрибутов, среди которых присутствует и `DontDelete`. Переменные и объявления функций, обнаруженные движком в глобальной области или в коде функции, создаются с атрибутом `DontDelete` и, посему, не могут быть удалены.
+
+    // глобальная переменная:
+    var a = 1; // установлен DontDelete
+    delete a; // false
+    a; // 1
+
+    // обычная функция:
+    function f() {} // установлен DontDelete
+    delete f; // false
+    typeof f; // "function"
+
+    // переопределение не помогает:
+    f = 1;
+    delete f; // false
+    f; // 1
+
+### Установленные пользователем свойства
+
+Свойства, установленные явно, могут быть удалены без помех:
+
+    // явно установим свойства:
+    var obj = {x: 1};
+    obj.y = 2;
+    delete obj.x; // true
+    delete obj.y; // true
+    obj.x; // undefined
+    obj.y; // undefined
+
+В приведённом примере свойства `obj.x` и `obj.y` могут быть удалены, поскольку у них отсутствует атрибут `DontDelete`. По этой же причине работает и пример ниже:
+
+    // работает нормально, но не в IE
+    var GLOBAL_OBJECT = this;
+    GLOBAL_OBJECT.a = 1;
+    a === GLOBAL_OBJECT.a; // true - просто глобальная переменная
+    delete GLOBAL_OBJECT.a; // true
+    GLOBAL_OBJECT.a; // undefined
+
+Здесь, чтобы удалить `a`, мы используем трюк. В этом коде [`this`](#function.this) ссылается на объект Global и мы явно описываем переменную `a` под видом его свойства, что позволяет нам её успешно удалить.
+
+В IE (по крайней мере, с 6-го по 8-й), есть парочка багов, из-за которых такой код не заработает.
+
+### Аргументы функций и встроенные свойства
+
+Обычные аргументы функций, [объект `arguments`](#function.arguments), а также встроенные свойства, объединены общей особенностью: у них у всех установен атрибут `DontDelete`.
+
+    // аргументы функций и свойства:
+    (function (x) {
+
+      delete arguments; // false
+      typeof arguments; // "object"
+
+      delete x; // false
+      x; // 1
+
+      function f(){}
+      delete f.length; // false
+      typeof f.length; // "number"
+
+    })(1);
+
+### Хост-объекты
+
+(''прим. перев.'' — Хост-объекты — объекты, которые, в неком окружении, дополняют функциональность языка JavaScript, не являясь частью его спецификации. В случае браузера это объекты `window`, `document`, `setTimeout` и т.п.)
+
+Поведение оператора `delete` может быть абсолютно непредсказуемым при применении его к хост-объектам. С позволения спецификации, хост-объекты вольны вести себя как им только вздумается.
+
+### Заключение
+
+Оператор `delete` часто ведёт себя непредсказуемо и надёжно может использоваться только для удаления пользовательских свойств обычных объектов.

doc/ru/core/semicolon.md

@@ -1,8 +1,8 @@
 ## Автоматическая вставка точек с запятой
 
-Хоть JavaScript и имеет синтаксис, подобный языкам семейства C, он при этом **не** принуждает вас ставить точки с запятой в исходном коде — вы всегда можете их опустить.
+Несмотря на то, что JavaScript имеет синтаксис, подобный языкам семейства C, он никоим образом **не принуждает** вас ставить точки с запятой в исходном коде — вы всегда вольны их опустить.
 
-При этом JavaScript — не язык без точек с запятой, они на самом деле нужны ему, чтобы он мог разобраться в вашем коде. Поэтому парсер JavaScript **автоматически** вставляет их в те места, где сталкивается с ошибкой парсинга из-за их отсутствия.
+При этом JavaScript — вовсе не язык с полным отсутствием точек с запятой: они на самом деле нужны ему для того, чтобы он мог разобраться в вашем коде. Поэтому парсер JavaScript **автоматически** вставляет их в те места, где сталкивается с ошибкой парсинга по причине их отсутствия.
 
     var foo = function() {
     } // ошибка разбора, ожидается точка с запятой
@@ -14,15 +14,15 @@
     }; // ошибки нет, парсер продолжает
     test()
 
-Автоматическая вставка точек с запятой считается одним из **наибольших** упущений в проекте языка, поскольку она *может* изменить поведение кода.
+Автоматическая вставка точек с запятой считается одним из **наибольших** упущений в проекте языка, поскольку она *действительно может* влиять на поведение кода.
 
 ### Как это работает
 
 Приведённый код не содержит точек с запятой, так что места для их вставки остаются на совести парсера:
 
     (function(window, undefined) {
         function test(options) {
-            log('тестируем!')
+            log('проверяем!')
 
             (options.list || []).forEach(function(i) {
 
@@ -78,22 +78,22 @@
 
     })(window); //<- вставлена
 
-> **Замечание:** Парсер JavaScript некорректно обрабатывает оператор `return`, за которым следует новая строка; кстати, причина может быть и не в автоматической вставке точек с запятой, но это в любом случае нежелательный побочный эффект
+> **Замечание:** Парсер JavaScript некорректно обрабатывает оператор `return`, за которым следует новая строка; Причина может быть и не в автоматической вставке точек с запятой, но без сомнений, это нежелательный побочный эффект.
 
-Парсер радикально подменил поведение изначального кода, а в определённых случаях он сделал **абсолютно неправильные выводы**.
+Парсер радикально поменял поведение изначального кода, а в определённых случаях он вообще сделал **абсолютно неправильные выводы**.
 
 ### «Висящие» скобки
 
-Если парсер встречает «висящую» скобку, то он **не** вставляет точку с запятой.
+Если парсер встречает «висящую» открывающую скобку, то он **не** вставляет точку с запятой.
 
     log('тестируем!')
     (options.list || []).forEach(function(i) {})
 
-Такой код трасформируется в строку
+Такой код трасформируется в одну склеенную строку.
 
     log('тестируем!')(options.list || []).forEach(function(i) {})
 
-**Чрезвычайно** высоки шансы, что `log` возращает **не** функцию; таким образом, эта строка вызовет `TypeError` с сообщением о том, что `undefined не является функцией`.
+**Чрезвычайно** высоки шансы, что `log` **не** возращает *никаких* функций; таким образом, выполнение кода с такой строкой породит `TypeError` с сообщением о том, что `undefined не является функцией`.
 
 ### Заключение
 

doc/ru/core/undefined.md

@@ -15,19 +15,19 @@
  - При попытке доступа к глобальной переменной `undefined` (если она не была переопределена).
  - При попытке доступа к переменной, которая *ещё не была* инициализирована каким-либо значением.
  - Неявный возврат из функции при отсутствии в ней оператора `return`.
- - Из операторов `return`, которые не возвращают явных значений.
- - В результате поиска несуществующего свойства у объекта (и доступа к нему).
- - При доступе к аргументам функции, которые явно не были в неё переданы.
- - При доступе ко всему, чьим значением является `undefined`.
- - В результате вычисления любого выражения в форме `void(выражение)`.
+ - Из оператора `return`, который не возвращает явного значения.
+ - В результате поиска несуществующего свойства у объекта (и/или доступа к нему).
+ - При попытке доступа к аргументу функции, который не был передан в неё явно.
+ - При попытке доступа ко всему, чьим значением является `undefined`.
+ - В результате вычисления любого выражения, соответствующего форме `void(выражение)`.
 
-### Обработка изменений значения `undefined`
+### Защита от потенциальных изменений значения `undefined`
 
-Поскольку глобальная переменная `undefined` содержит копию настоящего *значения* `undefined`, присвоение этой переменной нового значения **не** изменяет значения *типа* `undefined`.
+Поскольку глобальная переменная `undefined` содержит копию реального *значения* `undefined`, присвоение этой переменной нового значения **не** изменяет значения у *типа* `undefined`.
 
-Но при этом, чтобы сравнить что-либо со *значением* `undefined` прежде нужно получить значение самой *переменной* `undefined`.
+Получается, чтобы проверить нечто с типом `undefined` на соответствие значению `undefined`, прежде нужно узнать изначальное значение переменной `undefined`.
 
-Чтобы защитить код от переопределения переменной `undefined`, часто используется техника [анонимной обёртки](#function.scopes), которая использует отсутствующий аргумент.
+Чтобы защитить код от переопределения переменной `undefined`, часто используют технику [анонимной обёртки](#function.scopes), в которую добавляют аргумент и намеренно не передают его значение.
 
     var undefined = 123;
     (function(something, foo, undefined) {
@@ -45,11 +45,11 @@
 
     })('Hello World', 42);
 
-Единственная разница между этими вариантами в том, что последняя версия будет больше на 4 байта при минификации, а в первом случае внутри анонимной обёртки нет дополнительного оператора `var`.
+Единственная разница между этими вариантами в том, что последняя версия будет больше на 4 байта при минификации, и в первом случае внутри анонимной обёртки нет дополнительного оператора `var`.
 
-### Использование `null`
+### Применение `null`
 
-Хотя `undefined` в контексте языка JavaScript чаще используется в качестве традиционного *null*, настоящий `null` (и тип и литерал) является в большей или меньшей степени просто другим типом данных.
+Хотя `undefined` в контексте языка JavaScript чаще используется в роли традиционного *null*, настоящий `null` (и тип и литерал) является, в некоторой степени, просто другим типом данных.
 
-Он используется во внутренних механизмах JavaScript (например для определения конца цепочки прототипов засчёт присваивания `Foo.prototype = null`). Но в большинстве случаев тип `null` может быть заменён на `undefined`.
+Он используется во внутренних механизмах JavaScript (в случаях вроде установки конца цепочки прототипов через присваивание `Foo.prototype = null`). Но почти во всех случаях тип `null` может быть заменён на `undefined`.