corrections

Author: mykhaliuk

1-js/06-advanced-functions/06-function-object/5-sum-many-brackets/solution.md

@@ -1,5 +1,5 @@
 
-1. В общем, чтобы это *хоть как-нибудь* заработало результат, возвращаемый `sum`, должен быть функцией.
+1. В общем, чтобы это *хоть как-нибудь* заработало, результат, возвращаемый `sum`, должен быть функцией.
 2. Между вызовами эта функция должна удерживать в памяти текущее значение счётчика.
 3. Согласно заданию, функция должна преобразовываться в число когда она используется в операции `==`. Функции -- объекты, так что преобразование происходит как описано в главе <info:object-toprimitive>, и мы можем предоставить наш собственный метод, возвращающий число.
 
@@ -52,4 +52,4 @@ function f(b) {
 }
 ```
 
-Функция `f` будет использоваться в последующем вызове, и снова возвращать себя столько раз, сколько будет необходимо. Затем, при использовании в качестве числа или строки, метод `toString` возвращает `currentSum` -- число. Также здесь мы можем использовать `Symbol.toPrimitive` или `valueOf` для преобразования.
+Функция `f` будет использоваться в последующем вызове, и снова возвращать себя столько раз, сколько будет необходимо. Затем при использовании в качестве числа или строки, метод `toString` возвращает `currentSum` -- число. Также здесь мы можем использовать `Symbol.toPrimitive` или `valueOf` для преобразования.

1-js/06-advanced-functions/06-function-object/article.md

@@ -1,5 +1,5 @@
 
-# Функциональный объект, Именованные Функциональные Выражения
+# Функциональный объект, NFE
 
 Как мы уже знаем, в JavaScript функции -- это значения.
 
@@ -44,7 +44,7 @@ function f(sayHi = function() {}) {
 f();
 ```
 
-В спецификации, это называется "контекстное имя". Если функция не предоставляет этого свойства, то его значение определяется из контекста.
+В спецификации это называется "контекстное имя". Если функция не предоставляет этого свойства, то его значение определяется из контекста.
 
 Также имена имеют и методы объекта:
 
@@ -68,11 +68,11 @@ alert(user.sayBye.name); // sayBye
 В этом нет никакой магии. Бывает, что корректное имя определить невозможно. В таких случаях свойство name имеет пустое значение. Например:
 
 ```js
- // функция объявлена внутри массива
+// функция объявлена внутри массива
 let arr = [function() {}];
 
 alert( arr[0].name ); // <пустая строка>
-// здесь отсутствует возможность определить имя, поэтому оно неопределено 
+// здесь отсутствует возможность определить имя, поэтому его нет
 ```
 
 Тем не менее, на практике большинство функций имена имеют.
@@ -84,22 +84,23 @@ alert( arr[0].name ); // <пустая строка>
 ```js run
 function f1(a) {}
 function f2(a, b) {}
-function many(a, b, ...more) {},
+function many(a, b, ...more) {}
 
 alert(f1.length); // 1
 alert(f2.length); // 2
 alert(many.length); // 2
 ```
 
-Как мы видим, объект рест-параметров не считается.
+Как мы видим, оставшиеся параметры не считаются.
 
 Свойство `length` иногда используется для [интроспекций](https://ru.wikipedia.org/wiki/Интроспекция_(программирование)) в функциях, которые работают с другими функциями.
 
-Например, в коде ниже, функция `ask` принимает параметр `question` чтобы задать вопрос, и произвольное количество функций-обработчиков `handler`.
+Например, в коде ниже функция `ask` принимает параметр `question` чтобы задать вопрос, а также `handler`, произвольное количество функций-обработчиков.
+
 
 Когда пользователь отвечает на вопрос, функция вызывает обработчики. Мы можем передать два типа обработчиков:
 
-- Функцию без аргументов, которая будет вызываться только в случае позитивного ответа.
+- Функцию без аргументов, которая будет вызываться только в случае положительного ответа.
 - Функцию с аргументами, которая будет вызываться в обоих случаях и возвращать ответ.
 
 Идея состоит в том, что у нас есть простой синтаксис обработчика без аргументов для положительных ответов (наиболее распространённый случай), и, также реализована возможность передавать универсальные обработчики. 
@@ -205,11 +206,11 @@ alert( counter() ); // 10
 
 Поэтому выбор реализации зависит от наших целей.
 
-## Именованные Функциональные Выражения
+## Named Function Expression
 
-Именованные Функциональные Выражения -- это термин для функциональных выражений у которых есть имя.
+Named Function Expression, или NFE -- это термин для Function Expression у которого есть имя.
 
-Например, давайте объявим обычное Функциональное Выражение:
+Например, давайте объявим Function Expression:
 
 ```js
 let sayHi = function(who) {
@@ -227,7 +228,7 @@ let sayHi = function *!*func*/!*(who) {
 
 Чего мы здесь достигли? Какова цель этого дополнительного имени `func`?
 
-Для начала отметим, что у нас все ещё есть Функциональное Выражение. Добавление `"func"` после `function` не делает функцию декларативной, потому, что она все еще является частью выражения присваивания.
+Для начала отметим, что у нас все ещё есть Function Expression. Добавление `"func"` после `function` не превращает его в Function Declaration, потому что оно все еще является частью выражения присваивания.
 
 Также и добавление такого имени ничего ломает.
 
@@ -246,7 +247,7 @@ sayHi("John"); // Hello, John
 1. Оно позволяет функции ссылаться на себя же.
 2. Оно не доступно за пределами функции.
 
-Например, ниже, функция `sayHi` вызывает себя с `"Guest"`, если не передан параметр `who`:
+Например, ниже функция `sayHi` вызывает себя с `"Guest"`, если не передан параметр `who`:
 
 ```js run
 let sayHi = function *!*func*/!*(who) {
@@ -262,10 +263,10 @@ let sayHi = function *!*func*/!*(who) {
 sayHi(); // Hello, Guest
 
 // Но это не сработает в случае:
-func(); // Ошибка, func неопределена (недоступна вне функции)
+func(); // Ошибка, func не определена (недоступна вне функции)
 ```
 
-Почему мы используем `func`? Почему, просто ни использовать `sayHi` для вложенного вызова?
+Почему мы используем `func`? Почему просто не использовать `sayHi` для вложенного вызова?
 
 На самом деле, в большинстве случаев это возможно:
 
@@ -302,9 +303,9 @@ welcome(); // Ошибка, вложенный вызов sayHi больше н
 
 Так происходит потому, что функция берет `sayHi` из её внешнего лексического окружения. Так как локальная переменная `sayHi` отсутствует, используется внешняя. И на момент вызова эта внешняя `sayHi` равна `null`.
 
-Опциональное имя, которое мы можем вставить в Функциональное Выражение, как раз и призвано решать такого рода проблемы.
+Необязательное имя, которое можно вставить в Function Expression, как раз и призвано решать такого рода проблемы.
 
-Давайте используем его чтобы все исправить:
+Давайте зададим имя функции, чтобы исправить код:
 
 ```js run
 let sayHi = function *!*func*/!*(who) {
@@ -327,10 +328,10 @@ welcome(); // Hello, Guest (вложенный вызов работает)
 
 Внешний код все еще содержит переменные `sayHi` и `welcome`, но теперь `func` -- это "внутреннее имя функции", таким образом она может вызвать себя изнутри.
 
-```smart header="С Декларативными Функциями это не работает"
-Трюк с "внутренним" именем, описанный выше, работает только для Функционального Выражения, и *не* работает для Декларарованных Функций. Для последних, синтаксис не предусматривает возможность объявить "дополнительное внутреннее" имя.
+```smart header="Это не работает с Function Declaration"
+Трюк с "внутренним" именем, описанный выше, работает только для Function Expression, и *не* работает для Function Declaration. Для Function Declaration, синтаксис не предусматривает возможность объявить "дополнительное внутреннее" имя.
 
-Зачастую, когда нам нужно надёжное "внутреннее" имя, стоит переписать Декларированную Функцию на Именованное Функциональное Выражение.
+Зачастую, когда нам нужно надёжное "внутреннее" имя, стоит переписать Function Declaration на Named Function Expression.
 ```
 
 ## Итого
@@ -340,9 +341,9 @@ welcome(); // Hello, Guest (вложенный вызов работает)
 Их свойства:
 
 - `name` -- имя функции. Устанавливается при декларативном объявлении функции, и может быть установлено как значение свойства объекта.
-- `length` -- количество аргументов в объявлении функции. Объект рест-параметров не считается.
+- `length` -- количество аргументов в объявлении функции. Оставшиеся параметры не считаются.
 
-Если функция объявлена как Функциональное Выражение (вне основного потока кода), и имеет имя, тогда это называется Именованным Функциональным Выражением. Это имя может быть использовано для ссылки на себя же, для рекурсивных вызовов и т.п.
+Если функция объявлена как Function Expression (вне основного потока кода), и имеет имя, тогда это называется Именованным Функциональным Выражением. Это имя может быть использовано для ссылки на себя же, для рекурсивных вызовов и т.п.
 
 Также, функции могут содержать дополнительные свойства. Многие широко известные JavaScript библиотеки искусно используют эту возможность.