Merge pull request #1522 from Rnbsov/patch-12

Обновление статьи "Function Expression" в соответствии с английской версией учебника.

Author: Alexandre887

1-js/02-first-steps/16-function-expressions/article.md

@@ -12,19 +12,31 @@ function sayHi() {
 
 Существует ещё один синтаксис создания функций, который называется *Function Expression* (Функциональное Выражение).
 
-Оно выглядит вот так:
+Данный синтаксис позволяет нам создавать новую функцию в середине любого выражения.
+
+Это выглядит следующим образом:
 
 ```js
 let sayHi = function() {
   alert( "Привет" );
 };
 ```
 
-В коде выше функция создаётся и явно присваивается переменной, как любое другое значение. По сути без разницы, как мы определили функцию, это просто значение, хранимое в переменной `sayHi`.
+Здесь мы можем видеть переменную `sayHi`, получающую значение, новую функцию, созданную как `function() { alert("Привет"); }`.
+
+Поскольку создание функции происходит в контексте выражения присваивания (с правой стороны от `=`), это *Function Expression*.
+
+Обратите внимание, что после ключевого слова `function` нет имени. Для Function Expression допускается его отсутствие.
+
+Здесь мы сразу присваиваем её переменной, так что смысл этих примеров кода один и тот же: "создать функцию и поместить её в переменную `sayHi`".
+
+В более сложных ситуациях, с которыми мы столкнёмся позже, функция может быть создана и немедленно вызвана, или запланирована для дальнейшего выполнения, нигде не сохраняясь, таким образом, оставаясь анонимной.
 
-Смысл обоих примеров кода одинаков: "создать функцию и поместить её значение в переменную `sayHi`".
+## Функция - это значение
 
-Мы можем даже вывести это значение с помощью `alert`:
+Давайте повторим: независимо от того, как создаётся функция - она является значением. В обоих приведённых выше примерах функция хранится в переменной `sayHi`.
+
+Мы даже можем вывести это значение с помощью `alert`:
 
 ```js run
 function sayHi() {
@@ -35,14 +47,13 @@ function sayHi() {
 alert( sayHi ); // выведет код функции
 */!*
 ```
+Обратите внимание, что последняя строка не вызывает функцию, потому что после `sayHi` нет круглых скобок. Существуют языки программирования, в которых любое упоминание имени функции приводит к её выполнению, но JavaScript к таким не относится.
 
-Обратите внимание, что последняя строка не вызывает функцию `sayHi`, после её имени нет круглых скобок. Существуют языки программирования, в которых любое упоминание имени функции совершает её вызов. JavaScript - не один из них.
-
-В JavaScript функции - это значения, поэтому мы и обращаемся с ними, как со значениями. Код выше выведет строковое представление функции, которое является её исходным кодом.
+В JavaScript функция - это значение, поэтому мы можем обращаться с ней как со значением. Приведённый выше код показывает её строковое представление, которое является её исходным кодом.
 
-Конечно, функция - не обычное значение, в том смысле, что мы можем вызвать его при помощи скобок: `sayHi()`.
+Конечно, функция - это особое значение, в том смысле, что мы можем вызвать её как `sayHi()`.
 
-Но всё же это значение. Поэтому мы можем делать с ним то же самое, что и с любым другим значением.
+Но всё же это значение. Поэтому мы можем работать с ней так же, как и с другими видами значений.
 
 Мы можем скопировать функцию в другую переменную:
 
@@ -53,28 +64,28 @@ function sayHi() {   // (1) создаём
 
 let func = sayHi;    // (2) копируем
 
-func(); // Привет    // (3) вызываем копию (работает)!
-sayHi(); // Привет   //     прежняя тоже работает (почему бы нет)
+func(); // Привет     // (3) вызываем копию (работает)!
+sayHi(); // Привет    //     эта тоже все ещё работает (почему бы и нет)
 ```
 
 Давайте подробно разберём всё, что тут произошло:
 
-1. Объявление Function Declaration `(1)` создало функцию и присвоило её значение переменной с именем `sayHi`.
+1. Объявление Function Declaration `(1)` создаёт функцию и помещает её в переменную с именем `sayHi`.
 2. В строке `(2)` мы скопировали её значение в переменную `func`. Обратите внимание (ещё раз): нет круглых скобок после `sayHi`. Если бы они были, то выражение `func = sayHi()` записало бы *результат вызова* `sayHi()` в переменную `func`, а не саму *функцию* `sayHi`.
-3. Теперь функция может быть вызвана с помощью обеих переменных `sayHi()` и `func()`.
+3. Теперь функция может вызываться как `sayHi()`, так и `func()`. 
 
-Заметим, что мы могли бы использовать и Function Expression для того, чтобы создать `sayHi` в первой строке:
+Мы также могли бы использовать Function Expression для объявления `sayHi` в первой строке:
 
 ```js
-let sayHi = function() {
+let sayHi = function() { // (1) создаём
   alert( "Привет" );
 };
 
 let func = sayHi;
 // ...
 ```
 
-Результат был бы таким же.
+Всё будет работать так же.
 
 ````smart header="Зачем нужна точка с запятой в конце?"
 У вас мог возникнуть вопрос: Почему в Function Expression ставится точка с запятой `;` на конце, а в Function Declaration нет:
@@ -89,14 +100,14 @@ let sayHi = function() {
 }*!*;*/!*
 ```
 
-Ответ прост:
-- Нет необходимости в `;` в конце блоков кода и синтаксических конструкций, которые их используют, таких как `if { ... }`, `for {  }`, `function f { }` и т.д.
-- Function Expression использует внутри себя инструкции присваивания `let sayHi = ...;` как значение. Это не блок кода, а выражение с присваиванием. Таким образом, точка с запятой не относится непосредственно к Function Expression, она лишь завершает инструкцию.
+Ответ прост: Function Expression создаётся здесь как `function(...) {...}` внутри выражения присваивания: `let sayHi = …;`. Точку с запятой `;` рекомендуется ставить в конце выражения, она не является частью синтаксиса функции.
+
+Точка с запятой нужна там для более простого присваивания, такого как `let sayHi = 5;`, а также для присваивания функции.
 ````
 
 ## Функции-"колбэки"
 
-Рассмотрим ещё примеры функциональных выражений и передачи функции как значения.
+Давайте рассмотрим больше примеров передачи функции в виде значения и использования функциональных выражений.
 
 Давайте напишем функцию `ask(question, yes, no)` с тремя параметрами:
 
@@ -133,7 +144,7 @@ ask("Вы согласны?", showOk, showCancel);
 
 На практике подобные функции очень полезны. Основное отличие "реальной" функции `ask` от примера выше будет в том, что она использует более сложные способы взаимодействия с пользователем, чем простой вызов `confirm`. В браузерах такие функции обычно отображают красивые диалоговые окна. Но это уже другая история.
 
-**Аргументы функции `ask` ещё называют *функциями-колбэками* или просто *колбэками*.**
+**Аргументы `showOk` и `showCancel` функции `ask` называются *функциями-колбэками* или просто *колбэками*.**
 
 Ключевая идея в том, что мы передаём функцию и ожидаем, что она вызовется обратно (от англ. "call back" - обратный вызов) когда-нибудь позже, если это будет необходимо. В нашем случае, `showOk` становится *колбэком* для ответа "yes", а `showCancel` -- для ответа "no".
 
@@ -164,7 +175,7 @@ ask(
 ```smart header="Функция - это значение, представляющее \"действие\""
 Обычные значения, такие как строки или числа представляют собой *данные*.
 
-Функции, с другой стороны, можно воспринимать как "действия".
+Функции, с другой стороны, можно воспринимать как *действия*.
 
 Мы можем передавать их из переменной в переменную и запускать, когда захотим.
 ```
@@ -174,17 +185,17 @@ ask(
 
 Давайте разберём ключевые отличия Function Declaration от Function Expression.
 
-Во-первых, синтаксис: как определить, что есть что в коде.
+Во-первых, синтаксис: как отличить их друг от друга в коде.
 
-- Function Declaration: функция объявляется отдельной конструкцией "function..." в основном потоке кода.
+- *Function Declaration*: функция объявляется отдельной конструкцией "function..." в основном потоке кода.
 
     ```js
     // Function Declaration
     function sum(a, b) {
       return a + b;
     }
     ```
-- Function Expression: функция, созданная внутри другого выражения или синтаксической конструкции. В данном случае функция создаётся в правой части "выражения присваивания" `=`:
+- *Function Expression*: функция, созданная внутри другого выражения или синтаксической конструкции. В данном случае функция создаётся в правой части "выражения присваивания" `=`:
 
     ```js
     // Function Expression
@@ -201,7 +212,7 @@ ask(
 
 С Function Declaration всё иначе.
 
-**Function Declaration можно использовать во всем скрипте (или блоке кода, если функция объявлена в блоке).**
+**Function Declaration может быть вызвана раньше, чем она объявлена.**
 
 Другими словами, когда движок JavaScript *готовится* выполнять скрипт или блок кода, прежде всего он ищет в нём Function Declaration и создаёт все такие функции.  Можно считать этот процесс "стадией инициализации".
 
@@ -241,9 +252,9 @@ let sayHi = function(name) {  // (*) магии больше нет
 
 **В строгом режиме, когда Function Declaration находится в блоке `{...}`, функция доступна везде внутри блока. Но не снаружи него.**
 
-Для примера давайте представим, что нам нужно создать функцию `welcome()` в зависимости от значения переменной `age`, которое мы получим во время выполнения кода. И затем запланируем использовать её когда-нибудь в будущем.
+Для примера давайте представим, что нам нужно объявить функцию `welcome()` в зависимости от значения переменной `age`, которое мы получим во время выполнения кода. И затем запланируем использовать её когда-нибудь в будущем.
 
-Такой код, использующий Function Declaration, работать не будет:
+Если мы попробуем использовать Function Declaration, это не заработает так, как задумывалось:
 
 ```js run
 let age = prompt("Сколько Вам лет?", 18);
@@ -274,7 +285,7 @@ welcome(); // Error: welcome is not defined
 Вот ещё один пример:
 
 ```js run
-let age = 16; // присвоим для примера 16
+let age = 16; // возьмём для примера 16
 
 if (age < 18) {
 *!*
@@ -308,7 +319,7 @@ welcome(); // Ошибка: welcome is not defined
 
 Верным подходом будет воспользоваться функцией, объявленной при помощи Function Expression, и присвоить значение `welcome` переменной, объявленной снаружи `if`, что обеспечит нам нужную видимость.
 
-Такой код работает, как ожидалось:
+Такой код заработает, как ожидалось:
 
 ```js run
 let age = prompt("Сколько Вам лет?", 18);
@@ -334,7 +345,7 @@ welcome(); // теперь всё в порядке
 */!*
 ```
 
-Можно упростить этот код ещё сильнее, используя условный оператор `?`:
+Или мы могли бы упростить это ещё сильнее, используя условный оператор `?`:
 
 ```js run
 let age = prompt("Сколько Вам лет?", 18);
@@ -354,17 +365,17 @@ welcome(); // теперь всё в порядке
 
 Также функции вида `function f(…) {…}` чуть более заметны в коде, чем `let f = function(…) {…}`. Function Declaration легче "ловятся глазами".
 
-...Но если Function Declaration нам не подходит по какой-то причине (мы рассмотрели это в примере выше), то можно использовать объявление при помощи Function Expression.
+...Но если Function Declaration нам не подходит по какой-то причине, или нам нужно условное объявление (мы рассмотрели это в примере выше), то следует использовать Function Expression.
 ```
 
 ## Итого
 
 - Функции - это значения. Они могут быть присвоены, скопированы или объявлены в любом месте кода.
-- Если функция объявлена как отдельная инструкция в основном потоке кода, то это Function Declaration.
-- Если функция была создана как часть выражения, то считается, что эта функция объявлена при помощи Function Expression.
+- Если функция объявлена как отдельная инструкция в основном потоке кода, то это “Function Declaration”.
+- Если функция была создана как часть выражения, то это “Function Expression”.
 - Function Declaration обрабатываются перед выполнением блока кода. Они видны во всём блоке.
-- Функции, объявленные при помощи Function Expression, создаются, только когда поток выполнения достигает их.
+- Функции, объявленные при помощи Function Expression, создаются только когда поток выполнения достигает их.
 
-В большинстве случаев, когда нам нужно создать функцию, предпочтительно использовать Function Declaration, т.к. функция будет видима до своего объявления в коде. Это позволяет более гибко организовывать код и улучшает его читаемость.
+В большинстве случаев, когда нам нужно объявить функцию, Function Declaration предпочтительнее, т.к функция будет видна до своего объявления в коде. Это даёт нам больше гибкости в организации кода и, как правило, делает его более читабельным.
 
-Таким образом, мы должны прибегать к объявлению функций при помощи Function Expression в случае, когда синтаксис Function Declaration не подходит для нашей задачи. Мы рассмотрели несколько таких примеров в этой главе, и рассмотрим их ещё больше в будущем.
+Исходя из этого, мы должны использовать Function Expression только тогда, когда Function Declaration не подходит для нашей задачи. Мы рассмотрели несколько таких примеров в этой главе, и увидим ещё больше в будущем.