Antwoord.

Geschiedenis van de vraag

TypeScript is ontwikkeld met de nadruk op veilige ontwikkeling zonder overmatig gebruik van expliciete types: de meeste types van variabelen, parameters en geretourneerde waardes kunnen automatisch door de compiler worden afgeleid. Het type-inferentiesysteem stelt ontwikkelaars in staat om code te schrijven die bijna lijkt op JavaScript, maar met behoud van strikte typing, wat de ontwikkeling aanzienlijk versnelt en het aantal fouten vermindert.

Probleem

Type-inferentie garandeert niet altijd dat het type dat de ontwikkelaar verwacht correct is. Er kunnen situaties ontstaan waarin het type te breed is (any of unknown), of omgekeerd - te strikt. Dit leidt tot onnodige beperkingen of ontbrekende typecontroles, wat in beide gevallen onveilig is.

Oplossing

TypeScript leidt automatisch het type af op basis van toewijzing of van de geretourneerde waarde van een functie, als het type niet expliciet is gespecificeerd. Het afleiden kan worden beheerd door expliciet een type aan te geven, type assertion, generics en speciale hulpen (ReturnType, Parameters, enz.). Werken met complexe structuren vereist bijzondere controle: als het type complex of onduidelijk is, is het beter om het expliciet aan te geven.

Voorbeeldcode:

let a = 5; // number (wordt automatisch afgeleid)

function sum(x = 4, y = 3) { // x: number, y: number
  return x + y; // return: number
}

// Type-inferentiefout
function getData(flag) {
  if (flag) return 123;
  // geen return in de andere vertakking — return type: number | undefined
}

// Beter expliciet:
function getData(flag: boolean): number | undefined {
  if (flag) return 123;
}

Belangrijke kenmerken:

TypeScript leidt type van variabelen af op basis van initialisatie en waarde.
Voor functies en objecten kunnen types te breed worden zonder expliciete vermelding.
Voor generics en complexe structuren is het beter om het type altijd expliciet op te geven.

Vragen met een valstrik.

Waar/onwaar: Type-inferentie geeft altijd het type dat de ontwikkelaar verwacht

Onwaar. Soms is het type breder of smaller, vooral voor arrays/objecten/unions van geretourneerde waardes (number | undefined — een veel voorkomende verrassing).

Als je het type in een object niet opgeeft, behoudt TypeScript altijd de exacte structuur

Nee, zonder as const zal de structuur "verbreed" zijn (widened), met as const zal het readonly zijn met letterlijke types.

const obj = { kind: "duck" };
// obj: { kind: string }
const obj2 = { kind: "duck" } as const;
// obj2: { readonly kind: "duck" }

Als je het type voor een array niet opgeeft, weet TS altijd de samenstelling

Nee, standaard maakt TypeScript de array zo "breed" mogelijk — bijvoorbeeld, let arr = [1, 'a'] zal (string | number)[] zijn, en niet tuple.

Typfouten en anti-patronen

Vertrouwen op type-inferentie voor functieparameters (vooral API's) — types kunnen veranderen bij wijzigingen.
Type van geretourneerde waarden van functies niet opgeven — moeilijk te onderhouden.
Geen gebruik maken van as const of expliciete types voor constante objecten.

Voorbeeld uit het leven

Negatief geval

De backend retourneert een antwoordobject { data: [] }, het type is niet expliciet opgegeven, TypeScript leidt het type data: any[]. Op een bepaald moment wordt data een array van strings — de fout komt pas naar voren in productie.

Voordelen:

Je hoeft geen types handmatig op te geven voor eenvoudige gevallen.

Nadelen:

Onvoorziene fouten bij complexe structuren.
Automatische inferentie kan een probleem "verhullen".

Positief geval

In het project is het gebruikelijk om altijd expliciet het type van geretourneerde waarden van functies en complexe structuren aan te geven, en as const te gebruiken voor constanten. Elke wijziging in de structuur wordt door de compiler gecontroleerd.