Typargumente

Wenn du erstes(namen) aufrufst, sagst du nicht, was T ist: TypeScript ermittelt es aus dem Argument. Das ist wieder Typinferenz, diesmal für einen Typparameter. Du kannst den Typ auch selbst schreiben, in spitzen Klammern zwischen dem Namen der Funktion und den runden Klammern:

const anfuehrer = erstes<string>(namen);

Der Typ in den spitzen Klammern ist ein Typargument. Er geht in den Typparameter T, so wie das Argument namen in den Parameter elemente geht. Hier ändert er nichts, denn TypeScript würde ohnehin string wählen. Aber TypeScript prüft die Argumente jetzt gegen den Typ, den du geschrieben hast:

function erstes<T>(elemente: T[]): T | undefined {
    return elemente[0];
}
const traenke = ["Heiltrank", "Manatrank"];
console.log(erstes<string>(traenke));
console.log(erstes<number>(traenke));

TypeScript meldet:

main.ts(6,28): error TS2345: Argument of type 'string[]' is not assignable to parameter of type 'number[]'.
  Type 'string' is not assignable to type 'number'.

Mit T gleich number wird der Parameter elemente: T[] zu einem number[], und ein Array von Texten passt nicht. Die eingerückte zweite Zeile sagt, warum: Ein Text ist keine Zahl. Längere Meldungen haben oft solche Zeilen; lies sie von oben, jede geht mehr ins Detail.

Ein Typparameter kann an mehreren Stellen vorkommen, und alle müssen zusammenpassen:

function paarBilden<T>(erstes: T, zweites: T): T[] {
    return [erstes, zweites];
}

console.log(paarBilden("Kira", "Bruno"));
console.log(paarBilden("Kira", 5));

TypeScript meldet:

main.ts(6,32): error TS2345: Argument of type 'number' is not assignable to parameter of type 'string'.

Aus dem ersten Argument, "Kira", hat TypeScript geschlossen, dass T gleich string ist, also muss auch das zweite Argument ein Text sein.

Eine Funktion kann auch mehrere Typparameter haben, durch Kommas getrennt. Diese macht aus zwei beliebigen Werten ein Tupel (Lektion 2):

function paar<A, B>(erstes: A, zweites: B): [A, B] {
    return [erstes, zweites];
}

const trankAnzahl = paar("Heiltrank", 3);
console.log(trankAnzahl);

Das gibt aus:

["Heiltrank", 3]

Hier ist A gleich string und B gleich number, also ist trankAnzahl ein [string, number].

Wann du Typargumente schreibst. Meistens nicht: Lass TypeScript sie ableiten. Du brauchst sie, wenn TypeScript einen zu engen Typ ableiten würde. Diese Funktion füllt drei Rucksackfächer mit einem Wert, und Kira beginnt mit leeren Fächern, null:

function fuelle<T>(wert: T): T[] {
    return [wert, wert, wert];
}

const faecher = fuelle(null);
faecher[1] = "Schild";
console.log(faecher);

TypeScript meldet:

main.ts(6,1): error TS2322: Type '"Schild"' is not assignable to type 'null'.

Aus null hat TypeScript geschlossen, dass T gleich null ist, also ist faecher ein Array, das immer nur null enthalten kann. Schreibe den Typ, den du meinst, als Typargument, const faecher = fuelle<string | null>(null);, und die Fächer können Texte oder null enthalten. Das Programm gibt dann aus:

[null, "Schild", null]