Direct naar de hoofdinhoud
Module 3 · Les 2 van 26/14 in de cursus~15 min
Modulelessen (2/2)

Fundamentele generieken

Generics (algemene programmering) zijn een van de krachtigste functies van TypeScript. Hiermee kunt u flexibele, herbruikbare componenten, functies en interfaces schrijven die met verschillende gegevenstypen kunnen werken, terwijl de maximale typeveiligheid behouden blijft en het gebruik van any wordt vermeden.


Generieke functies

Beschouw een generiek als een variabele voor typen. Laten we een functie bekijken die de waarde retourneert die eraan is doorgegeven als argument:

TS
function identity<T>(arg: T): T {
  return arg;
}

De letter T (afkorting van Type) is een tijdelijke aanduiding voor het type. Wanneer we identity aanroepen, legt TypeScript het type van het doorgegeven argument vast en stelt T automatisch in op dat type:

TS
const str = identity<string>('Hello'); // T is string
const num = identity(42); // T is number (automatically inferred!)

Generieke interfaces en aliassen

Generieke gegevens kunnen ook worden toegepast op interfaces en typealiassen om generieke containers of datastructuren te definiëren:

TS
interface Box<T> {
  content: T;
}

const stringBox: Box<string> = { content: 'TypeScript' };
const numberBox: Box<number> = { content: 42 };

Meerdere typeparameters

We kunnen functies of typen definiëren die meerdere typevariabelen gebruiken (bijvoorbeeld T en U):

TS
function mergeObjects<T, U>(obj1: T, obj2: U): T & U {
  return { ...obj1, ...obj2 };
}

Algemene beperkingen

Soms willen we de typen beperken die door een generiek geneesmiddel worden geaccepteerd. We kunnen het trefwoord extends gebruiken om een ​​beperking toe te voegen.

Als we bijvoorbeeld willen dat het generieke type altijd de eigenschap length heeft (zoals strings of arrays):

TS
interface HasLength {
  length: number;
}

function logLength<T extends HasLength>(arg: T): void {
  console.log(arg.length); // Safe! We know arg has 'length'
}

logLength('Hello'); // Valid
logLength([1, 2, 3]); // Valid
// logLength(42); // Error: number does not have a length property!

Probeer het zelf

Oefening 1: Generieke identiteitsfunctie

Oefening#ts.m3.l2.e1
Pogingen: 0Laden…

Voltooi de generieke identiteitsfunctie zodat deze een waardeparameter van het generieke type T accepteert en deze zonder wijziging retourneert.

Editor laden…
Toon hint

Het retourtype moet van hetzelfde generieke type T zijn als de parameter.

Oplossing beschikbaar na 3 pogingen

Oefening 2: Generieke dozenverpakking

Oefening#ts.m3.l2.e2
Pogingen: 0Laden…

Definieer een generieke interface met de naam Box die een typeparameter T accepteert en een enkele eigenschap heeft met de naam content van het type T.

Editor laden…
Toon hint

Gebruik de interface Box<T> { inhoud: T; } syntaxis.

Oplossing beschikbaar na 3 pogingen

Oefening 3: Algemene beperking

Oefening#ts.m3.l2.e3
Pogingen: 0Laden…

Schrijf een algemene functie met de naam getLength die een parameter arg accepteert. arg moet worden beperkt tot een interface die een lengte-eigenschap (nummer) heeft. De functie moet arg.length retourneren.

Editor laden…
Toon hint

Declareer de functie als getLength<T extends HasLength>(arg: T): getal en retourneer arg.length.

Oplossing beschikbaar na 3 pogingen

Oefening 4: Generiek paar

Oefening#ts.m3.l2.e4
Pogingen: 0Laden…

Definieer een generieke interface Pair<T, U> met twee eigenschappen: de eerste van het type T en de tweede van het type U. Maak vervolgens een generieke functie makePair die de eerste (van het type T) en de tweede (van het type U) accepteert en een object retourneert dat Pair<T, U> implementeert.

Editor laden…
Toon hint

Gebruik de syntaxis voor twee generieke parameters Pair<T, U> en definieer makePair dienovereenkomstig.

Oplossing beschikbaar na 3 pogingen