Updates from the Russian translation

doc/ru/array/constructor.md

@@ -9,17 +9,17 @@
     new Array(3); // Результат: []
     new Array('3') // Результат: ['3']
 
-В случае, когда в конструктор `Array` передаётся один аргумент и этот аргумент имеет тип `Number`, конструктор возвращает новый, *заполненный случайными значениями*, массив, имеющий длину равную значению переданного аргумента. Стоит заметить, что в этом случае будет установлено только свойство `length` нового массива, индексы массива фактически не будут проинициализированы.
+В случае, когда в конструктор `Array` передаётся только один аргумент, и этот аргумент имеет тип `Number` — конструктор возвращает новый, *разреженный* (_прим. перев._ — *заполненный случайными значениями*) массив, имеющий длину, равную значению переданного аргумента. Стоит заметить, что в этом случае будет установлено лишь свойство `length` нового массива, а реальные индексы массива не будут инициализированы.
 
     var arr = new Array(3);
     arr[1]; // не определён, undefined
     1 in arr; // false, индекс не был установлен
 
-Поведение, которое позволяет изначально установить только размер массива, может пригодиться лишь в нескольких случаях, таких как повторение строк, за счёт чего избегается использование цикла `for`.
+Возможность заранее установить размер массива может пригодиться лишь в некоторых случаях — например, для повторения строки — так вы сможете обойтись без использования цикла `for`.
 
     new Array(count + 1).join(stringToRepeat);
 
 ### Заключение
 
-Использование конструктора `Array` нужно избегать, насколько это возможно. Литералы определённо предпочтительнее — это краткая запись и она имеет более понятный синтаксис, так что при этом даже улучшается читабельность кода.
+Использования конструктора `Array` следует избегать. Литералы, безусловно, намного предпочтительнее — это краткая запись, её синтаксис «чище» — а это, в свою очередь, повышает читабельность кода.
 

doc/ru/array/general.md

@@ -1,29 +1,29 @@
-##  Итерации по массивам и свойства
+## Перебор массивов и свойств объектов
 
-Несмотря на то, что массивы в JavaScript являются объектами, нет достаточных оснований для использования [цикла `for in`](#object.forinloop) для итерации по элементам массива. Фактически, существует несколько весомых причин **против** использования `for in` в массивах.
+Несмотря на то, что массивы в JavaScript являются объектами, **нельзя найти** весомых аргументов использовать [цикл `for in`](#object.forinloop) для перебора элементов массива. Наоборот, есть множество убедительных причин **против** использования циклов `for in` при переборе массивов.
 
-> **Замечание:** Массивы в JavaScript **не** являются *ассоциативными массивами*. Для связывания ключей и значений в JavaScript есть только [объекты](#object.general). И при том, что ассоциативные массивы **сохраняют** заданный порядок, объекты **не** делают этого.
+> **Замечание:** Массивы в JavaScript **не** являются *ассоциативными массивами*. Для группировки ключей и значений по парам в JavaScript есть только [объекты](#object.general). При этом, ассоциативные массивы по определению **сохраняют** заданный порядок свойств, объекты JavaScript этого **не** делают.
 
-Во время выполнения `for in` циклически перебираются все свойства объекта, находящиеся в цепочке прототипов. Единственный способ исключить ненужные свойства — использовать [`hasOwnProperty`](#object.hasownproperty), а это **в 20 раз** медленнее обычного цикла `for`.
+Поскольку во время выполнения `for in` циклически перебираются все свойства объекта, находящиеся в его цепочке прототипов, а единственный способ исключить ненужные свойства — использовать [`hasOwnProperty`](#object.hasownproperty) — в действии такой цикл **до 20 раз** медленнее обычного цикла `for`.
 
 ### Итерирование
 
-Для достижения лучшей производительности при итерации по массивам, лучше всего использовать обычный цикл `for`.
+Наилучшей производительности при переборе массивов можно достичь используя обычный цикл `for`.
 
     var list = [1, 2, 3, 4, 5, ...... 100000000];
     for(var i = 0, l = list.length; i < l; i++) {
         console.log(list[i]);
     }
 
-В примере выше есть один дополнительный приём, с помощью которого кэшируется величина длины массива: `l = list.length`.
+В примере выше есть один дополнительный приём, которым кэшируется длина массива: `l = list.length`.
 
-Несмотря на то, что свойство `length` определено в самом массиве, поиск этого свойства накладывает дополнительные расходы на каждой итерации цикла. Пусть в этом случае новые движки JavaScript теоретически **могут** применить оптимизацию, но нет никакого способа узнать, будет оптимизирован код на новом движке или нет.
+Несмотря на то, что свойство `length` определено в самом массиве, поиск этого свойства в прототипе объекта накладывает дополнительные расходы на каждую итерацию цикла. Да, в этом случае современные движки JavaScript и **теоретически** могут применить оптимизацию, но нет способа предугадать наверняка, будет ли оптимизирован код на используемом движке, или нет.
 
-Фактически, отсутствие кэширования может привести к выполнению цикла в **два раза медленнее**, чем при кэшировании длины
+Фактически, цикл без кэширования может выполняться в **два раза медленнее**, нежели цикл с закэшированной длиной.
 
 ### Свойство `length`
 
-Хотя *геттер* свойства `length` просто возвращает количество элементов содержащихся в массиве, *сеттер* можно использовать для **обрезания** массива.
+Хотя *геттер* свойства `length` просто возвращает количество элементов содержащихся в массиве, его *сеттер* можно использовать для **обрезания** массива.
 
     var foo = [1, 2, 3, 4, 5, 6];
     foo.length = 3;
@@ -32,9 +32,9 @@
     foo.length = 6;
     foo; // [1, 2, 3]
 
-Присвоение свойству `length` меньшей величины урезает массив, однако присвоение большего значения не даст никакого эффекта.
+Присвоение свойству `length` величины, меньшей чем текущая его длина, урезает массив, однако присвоение большего значения не производит никакого эффекта.
 
 ### Заключение
 
-Для оптимальной работы кода рекомендуется всегда использовать простой цикл `for` и кэшировать свойство `length`. Использование `for in` с массивами является признаком плохого кода, обладающего предпосылками к ошибкам и может привести к низкой скорости его выполнения.
+Для оптимальной работы кода рекомендуется всегда использовать обычный цикл `for` и кэшировать свойство `length`. Использование `for in` с массивами является признаком плохого кода, содержащего потенциальные ошибки, а также приводит к низкой скорости его выполнения.
 

doc/ru/core/delete.md

@@ -1,66 +1,56 @@
 ## Оператор `delete`
 
-Если говорить коротко, то JavaScript *невозможно* удалить глобальную переменную, функцию или любой другой объект, которому задан атрибут `DontDelete` .
+Если говорить кратко — в JavaScript невозможно удалить глобальную переменную или функцию или любую другую сущность, у которой установлен атрибут `DontDelete`.
 
-### Глобальный код и код функции
+### Глобальный код и код внутри функций
 
-Если переменная или функция определена в глобальной области видимости (scope) или в
-[области видимости функции](#function.scopes), это значит что она является
-свойством (property) глобального или же Activation объекта.
-Подобные свойства имеют набор атрибутов, одним из которых и является
-упомянутый ранее `DontDelete`. Объявление переменных и функций в коде
-функции или глобально всегда создает свойство с атрибутом `DontDelete`, и поэтому
-не может быть удалено.
+Когда переменная или функция определена в глобальной области видимости или в [области видимости функции](#function.scopes), её судьба предопределена: (_прим. перев._ — внутри движка JavaScript) она является свойством (`property`) либо объекта `Activation`, либо объекта `Global`. Подобные сущности имеют набор внутренних атрибутов, одним из которых и является упомянутый ранее `DontDelete`. Переменные и объявления функций, замеченные движком в глобальной области или в коде функций, создаются с атрибутом `DontDelete` и поэтому не могут быть удалены.
 
     // глобальная переменная:
-    var a = 1; // задается DontDelete
+    var a = 1; // установлен DontDelete
     delete a; // false
     a; // 1
 
     // обычная функция:
-    function f() {} // задается DontDelete
+    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`. Именно поэтому следующий пример тоже сработает.
+В приведённом примере свойства `obj.x` и `obj.y` могут быть удалены, поскольку у них отсутствует атрибут `DontDelete`. По этой же причине работает и пример ниже:
 
-    // работает хорошо везде, кроме IE:
+    // работает нормально, но не в 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) здесь
-относится к глобальному объекту и мы явно указали удаление переменной `a` как свойства
-глобального объекта, что и позволи нам ее удалить.
+Здесь, чтобы удалить `a`, мы используем один трюк. В этом коде [`this`](#function.this) ссылается на объект `Global` и мы явно описываем переменную `a` под видом его свойства, что и позволяет нам её успешно удалить.
 
-Из-за нескольких багов в IE (как минимум 6-8) предыдущий код работать в нем не будет.
+Internet Explorer (по крайней мере, с 6-го по 8-й) содержит баги, из-за которых такой код не сработает.
 
-### Аргументы функций и встроенные модули (built-ins)
+### Аргументы функций и встроенные свойства
 
-Обычным аргументам функций [`arguments` objects](#function.arguments) и
-встроенным свойствам также задан атрибут `DontDelete`.
+Обычные аргументы функций, [объект `arguments`](#function.arguments), а также встроенные свойства, объединены общей особенностью: у всех у них установен атрибут `DontDelete`.
 
-    // аргументы функции и свойства:
+    // аргументы функций и свойства:
     (function (x) {
 
       delete arguments; // false
@@ -75,14 +65,12 @@
 
     })(1);
 
-### Host объекты
+### Хост-объекты
 
-Host объект - это объект, предоставляемый окружением. К таким объектам относятся `window`,
-`document`, `location` и так далее.
-Для host объектов поведение оператора `delete` может быть непредсказуемым.
-Согласно спецификации, таким объектам позволено реализовывать любой вид поведения.
+(_прим. перев._ — Хост-объекты — это объекты, которые, в неком окружении, дополняют функциональность языка JavaScript, не являясь частью его спецификации. В случае браузера это объекты `window`, `document`, `setTimeout` и т.п.)
+
+Поведение оператора `delete` может быть полностью непредсказуемым, когда вы примененяете его к таким хост-объектам. С позволения спецификации, хост-объекты вольны вести себя как им только вздумается.
 
 ### Заключение
 
-Оператор `delete` часто обладает непредсказуемым поведением и безопасно использовать
-его можно лишь для удаления явно заданных свойств обычных объектов.
+Оператор `delete` часто ведёт себя непредсказуемо и может использоваться относительно безопасно только для удаления пользовательских свойств у обычных объектов.