Стрелочные функции TypeScript и this
Стрелочные функции — важная возможность, появившаяся в ES6, и распространённый синтаксис в TypeScript.
Самое большое отличие от обычных функций заключается в том, что стрелочные функции не привязывают собственный this, а захватывают this из контекста, в котором они определены.
Это решает распространённую проблему привязки this в JavaScript.
SVG-диаграмма: привязка this в стрелочной функции
Зачем нужны стрелочные функции
В 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 стрелочных функций поможет вам писать более безопасный и удобный в сопровождении код.