Antwoord.

Intersectietypen (Intersection Types) in TypeScript stellen je in staat om samengestelde typen te creëren die de eigenschappen en methoden van alle oorspronkelijke typen combineren. Dit is een krachtig hulpmiddel voor het bouwen van flexibele en uitbreidbare datastructuren zonder overmatige klasse-erfelijkheid. De constructie wordt gerealiseerd met de operator & tussen typen.

Geschiedenis van de vraag

TypeScript ondersteunt sinds de eerste versies unietypen (|) voor het uitdrukken van “of”, maar vaak komt de behoefte op om een object te beschrijven met meerdere eigenschappen uit verschillende onafhankelijke interfaces of typen. Dan wordt intersectie (&) gebruikt — het object moet voldoen aan alle interfaces voor alle eigenschappen.

Probleem

Een van de belangrijkste complicaties is de conflict van dezelfde eigenschapsnamen in de intersecterende typen, het verschil in hun typificatie, evenals de correctheid van het uiteindelijke gecombineerde type als klassen met privé of beschermde velden worden samengevoegd. Ook wordt vaak intersectie van typen verward met unie (union types), wat leidt tot onduidelijke compilatiefouten ofwerken met het object.

Oplossing

Intersectietypen aggregeren alle eigenschappen uit de te combineren typen, en voor elke eigenschap is overeenstemming van beide typen vereist als de naam overeenkomt. Het wordt zowel voor interfaces als voor type-aliases gebruikt.

interface A {
  foo: string;
}
interface B {
  bar: number;
}

type AB = A & B;

const item: AB = {
  foo: "hello",
  bar: 123
}; // Correct

Als de eigenschappen met dezelfde naam overlappen, moet het type overeenkomen, anders ontstaat er een fout:

interface X {
  val: string;
}
interface Y {
  val: number;
}
// type Z = X & Y; // Fout: incompatibiliteit van val

Belangrijkste kenmerken:

• De operator & combineert alle eigenschappen van beide types (interfaces en type-aliases).
• Als een eigenschap in beide types aanwezig is, is het uiteindelijke type hun intersectie (het moet gelijktijdig aan beide voldoen).
• Het wordt gebruikt voor flexibele combinatie van functionaliteit zonder nieuwe klassen of hiërarchieën te creëren.

Vragen met een valstrik.

Wat gebeurt er als de types intersecteren, maar sommige eigenschappen onverenigbare types hebben? (Bijvoorbeeld, een eigenschap string, een ander number)

Er zal een compilatiefout zijn, omdat de eigenschap niet tegelijkertijd zowel string als number kan zijn.

Kun je klassen met privé of beschermde eigenschappen intersecteren?

Ja, maar als er zulke velden met dezelfde namen en verschillende toegangsmodi zijn, zal het resultaat ongeldig zijn en geeft TypeScript een foutmelding.

Wat is het verschil tussen intersectietype en unietype (|)?

Intersectie (A & B) vereist dat het object tegelijkertijd van beide typen is, terwijl unie (A | B) vereist dat het ten minste één van beiden is. Bijvoorbeeld:

type U = A | B; // Kan foo of bar of beide zijn
type I = A & B; // Beide eigenschappen zijn verplicht

Typfouten en antipatronen

• Intersectie van onverenigbare types of eigenschapconflicten met verschillende types zullen leiden tot fouten.
• Misbruik van intersectie om strikte typificatie te omzeilen maakt de code verwarrend.

Voorbeeld uit het leven

Negatief geval

Een ontwikkelaar maakt een type door intersectie van verschillende onsamenhangende interfaces; eigenschappen conflicteren, en er ontstaan moeilijk te debuggen typfouten.

Voordelen: De mogelijkheid om snel functionaliteiten van verschillende types te combineren.

Nadelen: De code compileert niet of bevat impliciete bugs, debugging is moeilijk.

Positief geval

Functies splitsen in onafhankelijke interfaces en zorgvuldig combineren via intersectietype om uiteindelijke samengestelde objecten te vormen.

Voordelen: Schaalbaarheid, eenvoud in testen en uitbreiding, strikte contracten.

Nadelen: Extra werk bij het ontwerpen van interfaces en hun afstemming.