Verstehe die Auflösung von Überladungen, den Pseudoparameter this und die Varianzregeln, die die Zuweisbarkeit von Funktionen bestimmen.
Diese Lektion in Kodokon öffnenEine überladene Funktion stellt eine Liste öffentlicher Signaturen bereit, gefolgt von einer einzigen Implementierungssignatur. Ein wesentlicher Punkt der Spezifikation: Letztere ist von außen unsichtbar; aufrufbar sind nur die deklarierten Überladungen. Die Auflösung geht die Signaturen von oben nach unten durch und behält die erste passende: Stelle die spezifischste Signatur immer nach vorn, sonst wird sie nie ausgewählt.
function parse(input: string): number;
function parse(input: string[]): number[];
function parse(input: string | string[]) {
return Array.isArray(input)
? input.map((s) => s.length)
: input.length;
}
const single = parse("abc"); // number
const many = parse(["a", "bb"]); // number[]TypeScript erlaubt dir, an erster Stelle einen Pseudoparameter this zu deklarieren. Er wird im erzeugten JavaScript vollständig gelöscht: Es handelt sich um eine rein statische Einschränkung des Aufrufkontexts, die bei aktiviertem noImplicitThis geprüft wird. Mit den Hilfstypen ThisParameterType und OmitThisParameter kannst du ihn herausziehen oder entfernen, was für das Typisieren von Funktionen unerlässlich ist, die mit call, apply oder bind verwendet werden sollen.
function greet(this: { name: string }, msg: string) {
return `${msg}, ${this.name}`;
}
type Ctx = ThisParameterType<typeof greet>;
// { name: string }
type Fn = OmitThisParameter<typeof greet>;
// (msg: string) => string
const user = { name: "Ada", greet };
user.greet("Hello"); // "Hello, Ada"
// greet("Hi"); // error: missing this contextVarianz beschreibt, wie sich die Zuweisbarkeit durch einen Typkonstruktor fortpflanzt. Bei Funktionen sind Rückgabetypen kovariant und die Parameter mit strictFunctionTypes kontravariant: Eine Funktion, die einen weiteren Typ akzeptiert, kann eine Funktion ersetzen, die einen engeren Typ akzeptiert, niemals umgekehrt. Eine bewusste Ausnahme: Die Parameter von Methoden, die in der Kurzschreibweise deklariert sind, bleiben bivariant, ein historischer Kompromiss, ohne den Array<Dog> nicht an Array<Animal> zuweisbar wäre. Seit 4.7 kannst du die erwartete Varianz mit in und out annotieren, zum Beispiel interface Producer<out T>, und der Compiler überprüft sie.
interface Animal { name: string }
interface Dog extends Animal { bark(): void }
declare let f: (a: Dog) => void;
declare let g: (a: Animal) => void;
f = g; // OK: g accepts a wider type, that is safe
// g = f; // error with strictFunctionTypes
interface Sink { accept(a: Animal): void }
interface DogSink { accept(a: Dog): void }
declare let s: Sink;
declare let d: DogSink;
d = s; s = d; // both compile: bivariance!this einer Funktion im erzeugten JavaScript?