Antwoord.

Achtergrond:

TypeScript implementeert statische typechecking, dus soms is het nodig om expliciet het ene type naar een ander type te converteren. Bijvoorbeeld wanneer de ontwikkelaar de datastructuur beter kent dan de compiler of wanneer men moet werken met een getypeerde API waarvan de terugkerende types niet overeenkomen met de verwachte. Dit wordt bereikt met het type casting mechanisme, of type assertions.

Probleem:

Type casting in TypeScript voert geen waardeconversies uit op runtime: het vertelt de compiler alleen "vertrouw me maar". Dit kan leiden tot fouten als de opgegeven cast niet overeenkomt met de werkelijke inhoud van de gegevens. Fouten zullen alleen op runtime zichtbaar worden, en de compiler detecteert ze niet.

Oplossing:

TypeScript bevat twee syntaxes voor type casting: angle-bracket (verouderd, niet aanbevolen voor JSX) en as-syntax (aanbevolen).

Codevoorbeeld:

// Syntaxis via angle brackets (niet voor .tsx)
let someValue: any = "Hello World";
let strLength: number = (<string>someValue).length;

// Syntaxis via as
let strLength2: number = (someValue as string).length;

// Object type casting (onveilig!)
interface Cat { meow(): void; }
interface Dog { bark(): void; }
let dog: Dog = { bark() {} };
let cat = dog as unknown as Cat; // dit kan, maar dit omzeilt de typechecking!

Belangrijke kenmerken:

Type casting (assertion) verandert de inhoud van de variabele niet op runtime, het verwijdert alleen de beperkingen van het type.
Het wordt aangeraden om de as-syntax te gebruiken - deze is consistent voor alle platforms (en conflicteert niet met JSX).
Onjuiste type casting leidt tot "gaten" in de typeveiligheid en fouten op runtime.

Vragen met een val.

Voert type assertion automatische conversie van waarden uit op runtime, zoals in C# of Java?

Nee, type assertion vertelt alleen de compiler dat de variabele dit type is. Er vindt geen waardeconversie plaats - de verantwoordelijkheid ligt volledig bij de ontwikkelaar.

Kun je type A naar type B casten zonder een gedeelde structuur?

TypeScript staat dit toe (via dubbele cast, zoals any of unknown), maar dit ondermijnt de typeveiligheid en kan leiden tot fouten tijdens de uitvoering.

const a = 5 as unknown as string; // niet veilig!

Is het veilig om any naar een complex type te casten?

Nee, any schakelt typechecking uit: het casten van any naar een ander type is mogelijk, maar TypeScript kan discrepanties niet opvangen, en eventuele fouten zullen zich alleen tijdens de uitvoering manifesteren.

Typefouten en anti-patronen

Ondoordacht casten via any/unknown, waarbij het hele type systeem wordt omzeild.
Gebruik van angle brackets met .tsx/JSX (syntaxfout).
Casten van incompatibele types zonder structuurcontroles.

Voorbeeld uit de praktijk

Negatieve case

Een ontwikkelaar ontvangt een object van de server zonder de structuur te controleren, cast het naar het verwachte type met een eenvoudige as SomeType en gebruikt het in de business logica. Bij een wijziging in de API of een bug op de server crasht de applicatie op runtime, zonder fouten tijdens de build.

Voordelen:

Snel, eenvoudig, omzeilt de typische "strengheid".

Nadelen:

Verlies van typeveiligheid, runtimefouten, onmogelijkheid voor veilige herstructurering.

Positieve case

Een ontwikkelaar valideert vooraf de structuur van het verkregen object, gebruikt een gebruikersdefinieerde type guard functie, en alleen na een succesvolle controle vindt type assertion plaats.