functions.arguments + minor fixes in functions.*

Author: shamansir

doc/ru/function/arguments.md

@@ -4,17 +4,17 @@
 
 > **Замечание:** В случае, если переменная `arguments` уже была объявлена в области видимости функции либо путём присвоения через выражение `var`, либо являясь формальным параметром, объект `arguments` не будет создан.
 
-Объект `arguments` **не** является наследником `Array`. Он, конечно же, очень похож на массив, и даже содержит свойство `length` — но он не наследует `Array.prototype`, а представляет собой `Object`.
+Объект `arguments` **не** является ни экземпляром, ни наследником `Array`. Он, конечно же, очень похож на массив, и даже содержит свойство `length` — но он не наследует `Array.prototype`, и если внимательно присмотреться, он окажется обычным `Object`.
 
-По этой причине, у объекта `arguments` **отсутствуют** стандартные методы массивов, такие как `push`, `pop` или `slice`. Хотя итерация с использованием обычного цикла `for` по агрументам работает вполне корректно, вам придётся конвертировать этот объект в настоящий массив типа `Array`, чтобы применять к нему стандартные методы массивов.
+По этой причине, у объекта `arguments` **отсутствуют** стандартные методы массивов, такие как `push`, `pop` или `slice`. Пусть перебор с использованием обычного цикла `for` по аргументам работает вполне корректно, но вам придётся конвертировать этот объект в настоящий массив типа `Array`, чтобы применять к нему стандартные методы массивов.
 
 ### Конвертация в массив
 
-Указанный код вернёт новый массив типа `Array`, содержащий все элементы объекта `arguments`.
+Этот код вернёт новый массив типа `Array`, содержащий все элементы объекта `arguments`.
 
     Array.prototype.slice.call(arguments);
 
-Эта конвертация занимает **много времени** и использовать её в критических частях кода **не рекомендуется**.
+Будьте внимательны — это преобразование занимает **много времени** и использовать его в чувствительных к производительности частях кода **не рекомендуется**.
 
 ### Передача аргументов
 
@@ -27,7 +27,7 @@
         // делаем здесь что-нибудь
     }
 
-Другой трюк — использовать и `call` и `apply` вместе, чтобы быстро создать несвязанную обёртку:
+Другой трюк — использовать и `call` и `apply` вместе, чтобы создать отвязанную от объекта обёртку, выполняющуюся приемлемо быстро:
 
     function Foo() {}
 
@@ -47,9 +47,9 @@
 
 ### Формальные аргументы и индексы аргументов
 
-Объект `arguments` создаёт по *геттеру* и *сеттеру* и для всех своих свойств и для формальных параметров функции.
+Объект `arguments` создаёт по одному *геттеру* и по одному *сеттеру* как для всех своих свойств, так и для формальных параметров функции.
 
-В результате, изменение формального параметра также изменит значение соответствующего свойства объекта `arguments` и наоборот.
+В результате, изменение формального параметра повлечёт за собой изменение значения соответствующего свойства объекта `arguments` и наоборот.
 
     function foo(a, b, c) {
         arguments[0] = 2;
@@ -64,15 +64,15 @@
     }
     foo(1, 2, 3);
 
-### Мифы и правда о производительности
+### Мифы и истина о производительности
 
-Объект `arguments` создаётся во всех случаях, лишь за двумя исключениями — когда он переопределён внутри функции (по имени) или когда одним из её параметров является переменная с таким именем. Неважно, используется при этом сам объект или нет.
+Объект `arguments` создаётся во всех случаях, лишь одним исключением — когда он переопределён по имени внутри функции или когда одним из её параметров является переменная с таким именем. Неважно, используется при этом сам объект в коде функции или нет.
 
-*Геттеры* и *сеттеры* создаются **всегда**; так что, их использование практически никак не влияет на производительность.
+*Геттеры* и *сеттеры* создаются **всегда**; так что их использование практически никак не влияет на производительность, и тем более никак не влияет на неё в реальном коде, где обычно происходят вещи поважнее обычных прочтений и переопределений свойств объекта `arguments`.
 
 > **ES5 Замечание:** Эти *геттеры* и *сеттеры* не создаются в strict-режиме.
 
-Однако, есть один момент, который может радикально понизить производительность современных движков JavaScript. Этот момент — использование `arguments.callee`.
+Однако, есть одна такая тайна, незнание которой автором кода может радикально понизить его производительность в современных движках JavaScript. Эта тайна — опасность использования `arguments.callee`.
 
     function foo() {
         arguments.callee; // сделать что-либо с этим объектом функции
@@ -81,11 +81,11 @@
 
     function bigLoop() {
         for(var i = 0; i < 100000; i++) {
-            foo(); // При обычных условиях должна бы была быть развёрнута...
+            foo(); // должна была бы «развернуться»
         }
     }
 
-В коде выше, функция `foo` не может [быть развёрнута][1] (а могла бы), потому что для корректной работы ей необходима ссылка и на себя и на вызвавший её объект. Это не только кладёт на лопатки механизм развёртывания, но и нарушает принцип инкапсуляции, поскольку функция становится зависима от конкретного контекста вызова.
+В коде выше, функция `foo` не может [быть «развёрнута»][1] (а могла бы), потому что для корректной работы ей необходима ссылка и на себя и на вызвавший её объект. Такой код не только кладёт на лопатки механизм развёртывания, но и нарушает принцип инкапсуляции, поскольку функция становится зависима от конкретного контекста вызова.
 
 **Крайне не рекомендуется** использовать `arguments.callee` или какое-либо из его свойств. **Никогда**.
 

doc/ru/function/closures.md

@@ -50,7 +50,7 @@
 
 Для получения желаемого результата необходимо создать **копию** переменной `i`.
 
-### Обход проблемы с ссылкой
+### Обход проблемы со ссылкой
 
 Для того, чтобы скопировать значение индекса из цикла, лучше всего использовать другую [анонимную функцию](#function.scopes) как обёртку.
 

doc/ru/function/general.md

@@ -1,4 +1,4 @@
-## Про объявление функций и выражения с ними
+## Про объявление функций и о выражениях с ними
 
 Функции в JavaScript являются объектами. Следовательно, их можно передавать и присваивать точно так же, как и любой другой объект. Популярным сбособом использования этого свойства является передача *анонимной функции* в качестве функции обратного вызова в некую другую функцию — к примеру, при описании асинхронных вызовов.
 
@@ -23,7 +23,7 @@
     foo(); // вызовет TypeError
     var foo = function() {};
 
-Поскольку выражение с `var` *резервирует* имя переменной `foo` ещё до запуска кода, `foo` уже имеет некое значение во время его исполнения (отсутствует ошибка «`foo` is not defined»).
+Поскольку выражение с применением `var` *резервирует* имя переменной `foo` ещё до запуска кода, `foo` уже имеет некое значение во время его исполнения (отсутствует ошибка «`foo` is not defined»).
 
 Но поскольку сами *присвоения* исполняются только непосредственно во время работы кода, `foo` по умолчанию будет иметь лишь значение [`undefined`](#core.undefined) (до обработки строки с определением функции).
 

doc/ru/function/scopes.md

@@ -186,6 +186,12 @@ JavaScript **высасывает** определения. Это значит,
     +function(){}();
     (function(){}());
 
+<!--
+
+> **На заметку:** ''прим. перев.'' в JavaScript кроме прочего существует конструкция `new function() {}`, она очень редко используется, но позволяет создать **новый экземпляр** анонимной функции. Например, если вы присваивате нескольким объектам одну и ту же анонимную функцию-конструктор, то `instanceof` перестаёт работать, здесь вам и поможет `new function()`.
+
+-->
+
 ### Заключение
 
 Рекомендуется всегда использовать *анонимную обёртку* для заключения кода в его собственное пространство имён. Это не только защищает код от совпадений имён, но и позволяет создавать более модульные программы.