TypeScript-Pfeilfunktionen und this
Pfeilfunktionen sind ein wichtiges in ES6 eingeführtes Feature und eine gängige Syntax in TypeScript.
Der größte Unterschied zu gewöhnlichen Funktionen besteht darin, dass Pfeilfunktionen kein eigenes this binden, sondern das this des Kontexts erfassen, in dem sie definiert sind.
Dies löst das in JavaScript häufige Problem der this-Bindung.
SVG-Diagramm: this-Bindung bei Pfeilfunktionen
Warum Pfeilfunktionen benötigt werden
In JavaScript ist die Bindung von this oft verwirrend.
Das this in gewöhnlichen Funktionen hängt davon ab, wie die Funktion aufgerufen wird, nicht davon, wie sie definiert ist.
Dies führt oft zu einer falschen this-Bindung in Szenarien wie Callback-Funktionen und Ereignisbehandlung.
Das Aufkommen der Pfeilfunktionen löste dieses Problem und machte dieses Verhalten vorhersehbarer.
Konzepterklärung:Pfeilfunktionen verwenden
=>Syntax zur Definition; sie binden kein eigenes this, sondern erben this aus dem äußeren Gültigkeitsbereich.
Grundlagen der Pfeilfunktionen
Pfeilfunktionen bieten eine prägnantere Syntax zum Definieren von Funktionen.
Sie können geschweifte Klammern und das Schlüsselwort return weglassen (wenn der Funktionskörper aus einem einzigen Ausdruck besteht).
Beispiel
var add1 = function(a: number, b: number): number {
return a + b;
};
// Arrow-Funktion: Einzeilige Funktionen können geschweifte Klammern und return weglassen
var add2 = (a: number, b: number): number => a + b;
// Bei einem einzelnen Parameter können Klammern weggelassen werden
var double = (n: number): number => n * 2;
// Funktion ohne Parameter
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));
Run result:
add1: 3 add2: 7 double: 10 random: 0.xx
Syntaxerklärung:Wenn nur ein einzelner Parameter vorhanden ist, können die Klammern weggelassen werden; wenn jedoch keine Parameter oder mehr als ein Parameter vorhanden sind, müssen Klammern verwendet werden.
Arrow-Funktionen und this
Das wesentlichste Merkmal von Pfeilfunktionen ist, dass sie kein eigenes this binden.
Sie übernehmen das this aus dem äußeren Gültigkeitsbereich, in dem sie definiert sind, und behalten es unverändert.
Dies löst das Problem der verwirrenden this-Bindung in gewöhnlichen Funktionen.
Beispiel
function Person1() {
this.name = "Alice";
// Eine gewöhnliche Funktion erzeugt ihr eigenes this
// Im setTimeout-Callback zeigt this auf window (in Browsern) oder undefined (im Strict-Modus)
setTimeout(function() {
console.log("Gewöhnliche Funktion: " + this.name); // this.name ist undefined
}, 100);
}
// Verwendung einer Pfeilfunktion
function Person2() {
this.name = "Bob";
// Arrow-Funktionen erzeugen kein eigenes this
// Sie erfassen das äußere this, sodass sie korrekt auf name zugreifen können
setTimeout(() => {
console.log("Arrow-Funktion: " + this.name); // this.name ist "Bob"
}, 100);
}
// Test
new Person1();
new Person2();
Run result:
普通函数: undefined 箭头函数: Bob
Hauptunterschied:Das this einer gewöhnlichen Funktion wird zur Aufrufzeit bestimmt, während das this einer Arrow-Funktion zur Definitionszeit bestimmt wird. Dies ist der grundlegendste Unterschied zwischen den beiden.
Arrow-Funktionen in Klassen
In TypeScript-Klassen können Arrow-Funktionen als Klassenmethoden oder Eigenschaften verwendet werden.
Dies stellt sicher, dass this, wenn die Methode übergeben oder als Callback verwendet wird, weiterhin auf die Klasseninstanz zeigt.
Beispiel
class Counter {
// Der aktuelle Wert des Zählers
count: number = 0;
// Eine Arrow-Funktion als Klasseneigenschaft verwenden
// Jedes Mal, wenn eine Instanz erstellt wird, wird eine neue Funktion erstellt
// this verweist auf die Instanz
increment = () => {
this.count++;
console.log("Aktueller Zählerstand: " + this.count);
};
// Gewöhnliche Methode
decrement() {
this.count--;
console.log("Aktueller Zählerstand: " + this.count);
}
}
// Eine Zählerinstanz erstellen
var counter = new Counter();
// Arrow-Funktionsmethode aufrufen
counter.increment();
counter.increment();
// Normale Methode aufrufen
counter.decrement();
Run result:
当前计数: 1 当前计数: 2 当前计数: 1
Abwägung:Arrow-Funktions-Eigenschaften erzeugen in jeder Instanz eine neue Funktion, was den Speicher-Overhead erhöhen kann. Wenn die Methode jedoch als Callback übergeben werden muss, ist dies die beste Wahl.
this in Callback-Funktionen
Arrow-Funktionen sind besonders nützlich in Callbacks von Array-Methoden (map, filter, reduce, usw.).
Sie stellen sicher, dass der Callback korrekt auf das äußere this zugreifen kann.
Beispiel
var handler = {
// Handler-Name
name: "Handler",
// Zahlen-Array
numbers: [1, 2, 3],
// Verarbeitungsmethode
processAll: Funktion() {
// Callback mit einer Arrow-Funktion
// Die Arrow-Funktion erfasst das äußere this, sodass korrekt auf this.name zugegriffen werden kann
this.numbers.forEach((n) => {
console.log(this.name + ": " + n);
});
}
};
// Verarbeitungsmethode aufrufen
handler.processAll();
Run result:
Handler: 1 Handler: 2 Handler: 3
Bewährte Vorgehensweise:Verwenden Sie in Callback-Methoden von Klassen, in Callbacks von Array-Methoden und in Event-Handler-Funktionen bevorzugt Arrow-Funktionen, um diese this-Probleme zu vermeiden.
Arrow-Funktionstypen
Typannotationen für Arrow-Funktionen in TypeScript verwenden eine andere Syntax.
Verwenden Sie=>anstelle eines Doppelpunkts zum Definieren von Funktionstypen.
Beispiel
// (a: number, b: number) => number bedeutet, dass es zwei number-Parameter entgegennimmt und eine number zurückgibt
var add: (a: number, b: number) => number = (a, b) => a + b;
// Verwende ein Interface, um den Typ einer Arrow-Funktion zu definieren
// Dieser Ansatz eignet sich besser zur Wiederverwendung in Interfaces oder Typ-Aliasen
interface MathOperation {
// Definiere die Funktionssignatur
(a: number, b: number): number;
}
// Verwende den Interface-Typ
var multiply: MathOperation = (a, b) => a * b;
console.log("Addition: " + add(2, 3));
console.log("Multiplikation: " + multiply(4, 5));
Run result:
加法: 5 乘法: 20
Hinweis:Die Syntax für Arrow-Funktionstypen ist
(params) => returnType, nicht die traditionellen(params): returnType。
Wann Sie Pfeilfunktionen verwenden sollten
Obwohl Pfeilfunktionen prägnant sind, sind sie nicht für alle Szenarien geeignet.
Zu wissen, wann man Pfeilfunktionen verwenden sollte, kann helfen, besseren Code zu schreiben.
- Wenn Sie den this-Kontext beibehalten müssen:Zum Beispiel Callback-Funktionen, Event-Handling, Array-Methoden
- Einfache einzeilige Funktionen:Zum Beispiel Callbacks für map, filter, reduce
- Wenn Klassenmethoden übergeben werden müssen:Als Callbacks an andere Funktionen übergeben
Warnung:Verwenden Sie keine Pfeilfunktionen in Szenarien, die ein dynamisches this erfordern (z. B. wenn Sie in Event-Handler-Funktionen das Event-Ziel abrufen müssen), da this an dieser Stelle bereits festgelegt ist.
Hinweise
- Bindet arguments nicht:Pfeilfunktionen binden kein eigenes arguments-Objekt
- Können nicht als Konstruktoren verwendet werden:Pfeilfunktionen können nicht mit dem new-Schlüsselwort aufgerufen werden
- Können nicht als Methoden verwendet werden:Wenn sie als Methode in einem Objektliteral verwendet werden, verhält sich this möglicherweise nicht wie erwartet
- Für Callbacks geeignet:Bevorzugen Sie ihre Verwendung in Szenarien, in denen der this-Kontext beibehalten werden muss
Bewährte Vorgehensweise:Wählen Sie je nach Szenario: Verwenden Sie Arrow-Funktionen, wenn eine this-Bindung erforderlich ist, und normale Funktionen, wenn ein dynamisches this erforderlich ist.
Zusammenfassung
Arrow-Funktionen sind ein unverzichtbares Feature in der modernen JavaScript-/TypeScript-Entwicklung.
- Prägnante Syntax:Verwenden Sie
=>Syntax - Bindet this nicht:Erfasst den Kontext zum Zeitpunkt der Definition
- Geeignet für Callbacks:Szenarien wie Array-Methoden, Ereignisbehandlung usw.
- Verwendung in Klassen:Arrow-Property-Methoden lösen das Übergabeproblem
- Typannotationen:Verwendung
=>Syntax zum Definieren von Typen
Weitere ErweiterungenEmpfehlung:In der TypeScript-Entwicklung kann die volle Nutzung der this-Bindung von Arrow-Funktionen Ihnen helfen, sichereren und besser wartbaren Code zu schreiben.