Fonctions fléchées et this en TypeScript
Les fonctions fléchées sont une fonctionnalité importante introduite dans ES6 et une syntaxe courante en TypeScript.
La plus grande différence avec les fonctions classiques est que les fonctions fléchées ne lient pas leur propre this, mais capturent le this du contexte où elles sont définies.
Cela résout le problème courant de liaison de this en JavaScript.
Diagramme SVG : liaison de this dans les fonctions fléchées
Pourquoi les fonctions fléchées sont nécessaires
En JavaScript, la liaison de this est souvent source de confusion.
Le this dans les fonctions ordinaires dépend de la manière dont la fonction est appelée, et non de la manière dont elle est définie.
Cela conduit souvent à une liaison incorrecte de this dans des scénarios tels que les fonctions de rappel et la gestion d’événements.
L’apparition des fonctions fléchées a résolu ce problème, rendant ce comportement plus prévisible.
Explication du concept :Les fonctions fléchées utilisent
=>la syntaxe de définition ; elles ne lient pas leur propre this, mais héritent du this de la portée externe.
Bases des fonctions fléchées
Les fonctions fléchées offrent une syntaxe plus concise pour définir des fonctions.
Elles peuvent omettre les accolades et le mot-clé return (lorsque le corps de la fonction est une seule expression).
Exemple
var add1 = function(a: number, b: number): nombre {
return a + b;
};
// Fonction fléchée : les fonctions d'une seule ligne peuvent omettre les accolades et le return
var add2 = (a: number, b: number): number => a + b;
// Un seul paramètre peut omettre les parenthèses
var double = (n: number): number => n * 2;
// Fonction sans paramètre
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));
Résultat de l'exécution :
add1: 3 add2: 7 double: 10 random: 0.xx
Explication de la syntaxe :Lorsqu'il n'y a qu'un seul paramètre, les parenthèses peuvent être omises ; mais lorsqu'il n'y a aucun paramètre ou plus d'un paramètre, les parenthèses doivent être utilisées.
Fonctions fléchées et this
La caractéristique la plus fondamentale des fonctions fléchées est qu'elles ne lient pas leur propre this.
Elles capturent le this de la portée extérieure où elles sont définies et le gardent inchangé.
Cela résout le problème de la liaison confuse de this dans les fonctions ordinaires.
Exemple
function Person1() {
this.name = "Alice";
// Une fonction ordinaire crée son propre this
// Dans la fonction de rappel setTimeout, this pointe vers window (dans les navigateurs) ou undefined (en mode strict)
setTimeout(function() {
console.log("Fonction ordinaire : " + this.name); // this.name est undefined
}, 100);
}
// Utilisation d'une fonction fléchée
function Person2() {
this.name = "Bob";
// Les fonctions fléchées ne créent pas leur propre this
// Elles capturent le this extérieur, donc elles peuvent accéder correctement à name
setTimeout(() => {
console.log("Fonction fléchée : " + this.name); // this.name est "Bob"
}, 100);
}
// Test
new Person1();
new Person2();
Résultat de l'exécution :
普通函数: undefined 箭头函数: Bob
Différence clé :Le this d'une fonction ordinaire est déterminé au moment de l'appel, tandis que le this d'une fonction fléchée est déterminé au moment de la définition. C'est la différence la plus fondamentale entre les deux.
Fonctions fléchées dans les classes
Dans les classes TypeScript, les fonctions fléchées peuvent être utilisées comme méthodes ou propriétés de classe.
Cela garantit que lorsque la méthode est passée ou utilisée comme callback, this pointe toujours vers l'instance de la classe.
Exemple
class Counter {
// La valeur actuelle du compteur
count: number = 0;
// Utiliser une fonction fléchée comme propriété de classe
// Chaque fois qu'une instance est créée, une nouvelle fonction est créée
// this pointe vers l'instance
increment = () => {
this.count++;
console.log("Nombre actuel : " + this.count);
};
// Méthode ordinaire
decrement() {
this.count--;
console.log("Nombre actuel : " + this.count);
}
}
// Créer une instance de compteur
var counter = new Counter();
// Appeler la méthode de fonction fléchée
counter.increment();
counter.increment();
// Appeler la méthode ordinaire
counter.decrement();
Résultat de l'exécution :
当前计数: 1 当前计数: 2 当前计数: 1
Compromis :Les propriétés de fonction fléchée créent une nouvelle fonction dans chaque instance, ce qui peut augmenter la surcharge mémoire. Mais lorsque la méthode doit être passée comme fonction de rappel, c'est le meilleur choix.
this dans les fonctions de rappel
Les fonctions fléchées sont particulièrement utiles dans les fonctions de rappel des méthodes de tableau (map, filter, reduce, etc.).
Elles garantissent que la fonction de rappel peut accéder correctement au this externe.
Exemple
var handler = {
// Nom du gestionnaire
name: "Handler",
// Tableau de nombres
numbers: [1, 2, 3],
// Méthode de traitement
processAll: function() {
// Callback utilisant une fonction fléchée
// La fonction fléchée capture le this externe, donc on peut accéder correctement à this.name
this.numbers.forEach((n) => {
console.log(this.name + ": " + n);
});
}
};
// Appeler la méthode de traitement
handler.processAll();
Résultat de l'exécution :
Handler: 1 Handler: 2 Handler: 3
Bonne pratique :Dans les méthodes de rappel de classe, les fonctions de rappel des méthodes de tableau et les fonctions de gestion d'événements, préférez les fonctions fléchées pour éviter les problèmes liés à this.
Types de fonctions fléchées
Les annotations de type pour les fonctions fléchées dans TypeScript utilisent une syntaxe différente.
Utiliser=>au lieu d'un deux-points pour définir les types de fonction.
Exemple
// (a: number, b: number) => number signifie qu'elle prend deux paramètres de type number et renvoie un number
var add: (a: number, b: number) => number = (a, b) => a + b;
// Utiliser une interface pour définir le type d'une fonction fléchée
// Cette approche est plus adaptée à la réutilisation dans des interfaces ou des alias de type
interface MathOperation {
// Définir la signature de la fonction
(a: number, b: number): number;
}
// Utiliser le type de l'interface
var multiply: MathOperation = (a, b) => a * b;
console.log("Addition: " + add(2, 3));
console.log("Multiplication: " + multiply(4, 5));
Résultat de l'exécution :
加法: 5 乘法: 20
Remarque :La syntaxe des types de fonctions fléchées est
(params) => returnType, pas la traditionnelle(params): returnType。
Quand utiliser les fonctions fléchées
Bien que les fonctions fléchées soient concises, elles ne conviennent pas à tous les scénarios.
Savoir quand utiliser les fonctions fléchées peut vous aider à écrire un meilleur code.
- Lorsque vous devez préserver le contexte this :Comme les fonctions de rappel, la gestion des événements, les méthodes de tableau
- Fonctions simples sur une ligne :Comme les fonctions de rappel pour map, filter, reduce
- Lorsque les méthodes de classe doivent être passées :Passées en tant que fonctions de rappel à d'autres fonctions
Avertissement :N'utilisez pas les fonctions fléchées dans les scénarios qui nécessitent un this dynamique (comme le besoin d'obtenir la cible de l'événement dans les fonctions de gestionnaire d'événements), car this est déjà fixé à ce moment-là.
Notes
- Ne lie pas arguments :Les fonctions fléchées ne lient pas leur propre objet arguments
- Ne peuvent pas être utilisées comme constructeurs :Les fonctions fléchées ne peuvent pas être appelées avec le mot-clé new
- Ne peuvent pas être utilisées comme méthodes :Lorsqu'elles sont utilisées comme méthode dans un littéral d'objet, this peut ne pas se comporter comme prévu
- Adaptées aux fonctions de rappel :Priorisez leur utilisation dans les scénarios où le contexte this doit être préservé
Bonne pratique :Choisissez en fonction du scénario : utilisez les fonctions fléchées lorsque la liaison de this est nécessaire, utilisez les fonctions ordinaires lorsque this dynamique est nécessaire.
Résumé
Les fonctions fléchées sont une fonctionnalité indispensable dans le développement JavaScript/TypeScript moderne.
- Syntaxe concise :Utilisez
=>syntaxe - Ne lie pas this :Capture le contexte au moment de la définition
- Adapté aux callbacks :Scénarios comme les méthodes de tableau, la gestion d'événements, etc.
- Utilisation dans les classes :Les méthodes de propriété fléchées résolvent le problème de passage
- Annotations de type :Utilisation
=>Syntaxe pour définir des types
Autres extensionsRecommandation :Dans le développement TypeScript, tirer pleinement parti de la fonctionnalité de liaison de this des fonctions fléchées peut vous aider à écrire un code plus sûr et plus maintenable.