Стрелочные функции TypeScript и this

Стрелочные функции — важная возможность, появившаяся в ES6, и распространённый синтаксис в TypeScript.

Самое большое отличие от обычных функций заключается в том, что стрелочные функции не привязывают собственный this, а захватывают this из контекста, в котором они определены.

Это решает распространённую проблему привязки this в JavaScript.


SVG-диаграмма: привязка this в стрелочной функции Background Title Arrow function this binding mechanism Ordinary function Ordinary function setTimeout(function() { console.log(this.name); }, 100); this points to window/undefined Arrow vs Arrow function Arrow function setTimeout(() => { console.log(this.name); }, 100); this points to the context at definition time Lower part: syntax description Arrow function syntax Syntax 1 Multiple parameters: (a, b) => a + b Syntax 2 Single parameter: n => n * 2 Syntax 3 No parameters: () => 42 Arrow marker

Зачем нужны стрелочные функции

В JavaScript привязка this часто вызывает путаницу.

this в обычных функциях зависит от того, как функция вызывается, а не от того, как она определена.

Это часто приводит к неправильной привязке this в таких сценариях, как функции обратного вызова и обработка событий.

Появление стрелочных функций решило эту проблему, сделав такое поведение более предсказуемым.

Пояснение концепции:Стрелочные функции используют=>синтаксис для определения; они не связывают собственный this, а наследуют this из внешней области видимости.


Основы стрелочных функций

Стрелочные функции предоставляют более краткий синтаксис для определения функций.

Они могут опускать фигурные скобки и ключевое слово return (когда тело функции состоит из одного выражения).

Пример

// Традиционное определение функции
var add1 = function(a: number, b: number): число {
    return a + b;
};

// Стрелочная функция: в однострочных функциях можно опустить фигурные скобки и return
var add2 = (a: number, b: number): number => a + b;

// Для одного параметра можно опустить скобки
var double = (n: number): number => n * 2;

// Функция без параметров
var getRandom = (): number => Math.random();

console.log("add1: " + add1(1, 2));
console.log("add2: " + add2(3, 4));
console.log("double: " + double(5));
console.log("random: " + getRandom().toFixed(2));

Результат выполнения:

add1: 3
add2: 7
double: 10
random: 0.xx

Пояснение синтаксиса:Если параметр только один, скобки можно опустить; но если параметров нет или их больше одного, скобки обязательны.


Стрелочные функции и this

Самая главная особенность стрелочных функций заключается в том, что они не привязывают собственный this.

Они захватывают this из внешней области видимости, где они определены, и сохраняют его неизменным.

Это решает проблему путаницы с привязкой this в обычных функциях.

Пример

// Использование обычной функции
function Person1() {
    this.name = "Alice";

    // Обычная функция создаёт собственный this
    // В колбэке setTimeout this указывает на window (в браузерах) или undefined (в строгом режиме)
    setTimeout(function() {
        console.log("Обычная функция: " + this.name);  // this.name равно undefined
    }, 100);
}

// Использование стрелочной функции
function Person2() {
    this.name = "Bob";

    // Стрелочные функции не создают собственный this
    // Они захватывают внешний this, поэтому могут корректно обращаться к name
    setTimeout(() => {
        console.log("Стрелочная функция: " + this.name);  // this.name — это "Bob"
    }, 100);
}

// Тест
new Person1();
new Person2();

Результат выполнения:

普通函数: undefined
箭头函数: Bob

Ключевое различие:this обычной функции определяется во время вызова, тогда как this стрелочной функции определяется во время определения. Это самое главное различие между ними.


Стрелочные функции в классах

В классах TypeScript стрелочные функции можно использовать как методы класса или свойства.

Это гарантирует, что когда метод передаётся или используется в качестве обратного вызова, this по-прежнему указывает на экземпляр класса.

Пример

// Определить класс счётчика
class Counter {
    // Текущее значение счётчика
    count: number = 0;

    // Использовать стрелочную функцию как свойство класса
    // Каждый раз при создании экземпляра создаётся новая функция
    // this указывает на экземпляр
    increment = () => {
        this.count++;
        console.log("Текущее значение: " + this.count);
    };

    // Обычный метод
    decrement() {
        this.count--;
        console.log("Текущее значение: " + this.count);
    }
}

// Создать экземпляр счётчика
var counter = new Counter();

// Вызов метода стрелочной функции
counter.increment();
counter.increment();

// Вызов обычного метода
counter.decrement();

Результат выполнения:

当前计数: 1
当前计数: 2
当前计数: 1

Компромисс:Свойства-стрелочные функции создают новую функцию в каждом экземпляре, что может увеличить накладные расходы памяти. Но когда метод нужно передать как функцию обратного вызова, это лучший выбор.


this в функциях обратного вызова

Стрелочные функции особенно полезны в функциях обратного вызова методов массивов (map, filter, reduce и т. д.).

Они гарантируют, что функция обратного вызова может корректно получить доступ к внешнему this.

Пример

// Определить объект обработчика
var handler = {
    // Имя обработчика
    name: "Handler",
    // Массив чисел
    numbers: [1, 2, 3],

    // Метод обработки
    processAll: функция() {
        // Колбэк с использованием стрелочной функции
        // Стрелочная функция захватывает внешний this, поэтому к this.name можно корректно обратиться
        this.numbers.forEach((n) => {
            console.log(this.name + ": " + n);
        });
    }
};

// Вызвать метод обработки
handler.processAll();

Результат выполнения:

Handler: 1
Handler: 2
Handler: 3

Лучшая практика:В методах обратного вызова классов, колбэках методов массивов и функциях обработчиков событий предпочитайте стрелочные функции, чтобы избежать проблем с this.


Типы стрелочных функций

Аннотации типов для стрелочных функций в TypeScript используют другой синтаксис.

Используйте=>вместо двоеточия для определения типов функций.

Пример

// Непосредственно определить тип стрелочной функции
// (a: number, b: number) => number означает, что функция принимает два параметра типа number и возвращает number
var add: (a: number, b: number) => number = (a, b) => a + b;

// Используйте интерфейс для определения типа стрелочной функции
// Этот подход больше подходит для повторного использования в интерфейсах или псевдонимах типов
interface MathOperation {
    // Определите сигнатуру функции
    (a: number, b: number): number;
}

// Используйте тип интерфейса
var multiply: MathOperation = (a, b) => a * b;

console.log("Сложение: " + add(2, 3));
console.log("Умножение: " + multiply(4, 5));

Результат выполнения:

加法: 5
乘法: 20

Примечание:Синтаксис типов стрелочных функций:(params) => returnType, а не традиционная(params): returnType。


Когда использовать стрелочные функции

Хотя стрелочные функции лаконичны, они подходят не для всех сценариев.

Знание того, когда использовать стрелочные функции, может помочь вам писать более качественный код.

  • Когда нужно сохранить контекст this:Например, функции обратного вызова, обработка событий, методы массивов
  • Простые однострочные функции:Например, функции обратного вызова для map, filter, reduce
  • Когда нужно передавать методы класса:Передаются как функции обратного вызова в другие функции

Предупреждение:Не используйте стрелочные функции в сценариях, требующих динамического this (например, когда нужно получить цель события в функциях-обработчиках событий), потому что this уже зафиксирован в этот момент.


Примечания

  • Не привязывает arguments:Стрелочные функции не привязывают собственный объект arguments
  • Не могут использоваться как конструкторы:Стрелочные функции нельзя вызывать с ключевым словом new
  • Не могут использоваться как методы:При использовании в качестве метода в литерале объекта this может вести себя не так, как ожидается
  • Подходят для функций обратного вызова:Предпочитайте использовать их в сценариях, где нужно сохранить контекст this

Лучшая практика:Выбирайте в зависимости от сценария: используйте стрелочные функции, когда нужна привязка this, используйте обычные функции, когда нужен динамический this.


Итог

Стрелочные функции — незаменимая особенность в современной разработке на JavaScript/TypeScript.

  • Краткий синтаксис:Используйте=>синтаксис
  • Не привязывает this:Захватывает контекст в момент определения
  • Подходит для колбэков:Сценарии вроде методов массивов, обработки событий и т. д.
  • Использование в классах:Стрелочные методы-свойства решают проблему передачи
  • Аннотации типов:Использование=>Синтаксис определения типов

Рекомендация:При разработке на TypeScript полноценное использование особенности привязки this стрелочных функций поможет вам писать более безопасный и удобный в сопровождении код.

Другие расширения