```js run

'use strict';

let numbers = [2, 3, 15];

let max = Math.max(*!*...numbers*/!*);

alert( max ); // 15

Формально говоря, эти два вызова делают одно и то же:

Math.max(...numbers);

Math.max.apply(Math, numbers);

Похоже, что первый -- короче и красивее.

В свойстве `name` у функции находится её имя.

Например:

'use strict';

function f() {} // f.name == "f"

let g = function g() {}; // g.name == "g"

alert(f.name + ' ' + g.name) // f g

В примере выше показаны Function Declaration и Named Function Expression. В синтаксисе выше довольно очевидно, что у этих функций есть имя `name`. В конце концов, оно указано в объявлении.

Но современный JavaScript идёт дальше, он старается даже анонимным функциям дать разумные имена.

Например, при создании анонимной функции с одновременной записью в переменную или свойство -- её имя равно названию переменной (или свойства).

Например:

'use strict';

let g = function() {};

let user = {

// свойство user.sayHi.name == "sayHi"

sayHi: function() {}

};

Объявление функции Function Declaration, сделанное в блоке, видно только в этом блоке.

Например:

```js run

'use strict';

if (true) {

sayHi(); // работает

function sayHi() {

alert("Привет!");

}

sayHi(); // ошибка, функции не существует

То есть, иными словами, такое объявление -- ведёт себя в точности как если бы `let sayHi = function() {…}` было сделано в начале блока.

Появился новый синтаксис для задания функций через "стрелку" `=>`.

Его простейший вариант выглядит так:

```js run

'use strict';

let inc = x => x+1;

alert( inc(1) ); // 2

Эти две записи -- примерно аналогичны:

let inc = x => x+1;

let inc = function(x) { return x + 1; };

Если аргументов несколько, то нужно обернуть их в скобки, вот так:

'use strict';

let sum = (a,b) => a + b;

alert( sum(1, 2) ); // 3

Если нужно задать функцию без аргументов, то также используются скобки, в этом случае -- пустые:

```js run

'use strict';

let getTime = () => new Date().getHours() + ':' + new Date().getMinutes();

alert( getTime() ); // текущее время

Когда тело функции достаточно большое, то можно его обернуть в фигурные скобки `{…}`:

'use strict';

let getTime = () => {

let date = new Date();

let hours = date.getHours();

let minutes = date.getMinutes();

return hourse + ':' + minutes;

};

alert( getTime() ); // текущее время

Заметим, что как только тело функции оборачивается в `{…}`, то её результат уже не возвращается автоматически. Такая функция должна делать явный `return`, как в примере выше, если конечно хочет что-либо возвратить.

Функции-стрелки очень удобны в качестве коллбеков, например:

```js run

`use strict`;

let arr = [5, 8, 3];

let sorted = arr.sort( (a,b) => a - b );

alert(sorted); // 3, 5, 8

Такая запись -- коротка и понятна. Далее мы познакомимся с дополнительными преимуществами использования функций-стрелок для этой цели.

Внутри функций-стрелок -- тот же `this`, что и снаружи.

Это очень удобно в обработчиках событий и коллбэках, например:

```js run

'use strict';

let group = {

title: "Наш курс",

students: ["Вася", "Петя", "Даша"],

showList: function() {

this.students.forEach(

student => alert(this.title + ': ' + student)

)

}

}

group.showList();

Здесь в `forEach` была использована функция-стрелка, поэтому `this.title` в коллбэке -- тот же, что и во внешней функции `showList`. То есть, в данном случае -- `group.title`.

Если бы в `forEach` вместо функции-стрелки была обычная функция, то была бы ошибка:

```js run

'use strict';

let group = {

title: "Наш курс",

students: ["Вася", "Петя", "Даша"],

showList: function() {

this.students.forEach(function(student) {

alert(this.title + ': ' + student); // будет ошибка

})

}

}

group.showList();

При запуске будет "попытка прочитать свойство `title` у `undefined`", так как `.forEach(f)` при запуске `f` не ставит `this`. То есть, `this` внутри `forEach` будет `undefined`.

```warn header="Функции стрелки нельзя запускать с `new`"

Отсутствие у функции-стрелки "своего `this`" влечёт за собой естественное ограничение: такие функции нельзя использовать в качестве конструктора, то есть нельзя вызывать через `new`.

В качестве `arguments` используются аргументы внешней "обычной" функции.

Например:

```js run

'use strict';

function f() {

let showArg = () => alert(arguments[0]);

showArg();

}

f(1); // 1

Вызов `showArg()` выведет `1`, получив его из аргументов функции `f`. Функция-стрелка здесь вызвана без параметров, но это не важно: `arguments` всегда берутся из внешней "обычной" функции.

Сохранение внешнего `this` и `arguments` удобно использовать для форвардинга вызовов и создания декораторов.

Например, декоратор `defer(f, ms)` ниже получает функцию `f` и возвращает обёртку вокруг неё, откладывающую вызов на `ms` миллисекунд:

```js run

'use strict';

function defer(f, ms) {

return function() {

setTimeout(() => f.apply(this, arguments), ms)

}

}

function sayHi(who) {

alert('Привет, ' + who);

}

let sayHiDeferred = defer(sayHi, 2000);

sayHiDeferred("Вася"); // Привет, Вася через 2 секунды

Аналогичная реализация без функции-стрелки выглядела бы так:

function defer(f, ms) {

return function() {

let args = arguments;

let ctx = this;

setTimeout(function() {

return f.apply(ctx, args);

}, ms);

}

}

В этом коде пришлось создавать дополнительные переменные `args` и `ctx` для передачи внешних аргументов и контекста через замыкание.