Hvordan bruke TypeScript Type Assertions

Typepåstander i TypeScript er en måte å fortelle kompilatoren at du vet mer om typen til en verdi enn den gjør. Dette kan være nyttig når du arbeider med verdier som har usikre eller brede typer, og du ønsker å begrense dem for bedre typekontroll og kodelesbarhet. I denne artikkelen skal vi utforske hvordan du bruker TypeScript-påstander effektivt.

Hva er Type Assertion?

Type assertion er en mekanisme i TypeScript som lar deg overstyre standardtypeslutningen som er laget av TypeScript-kompilatoren. Det endrer ikke den faktiske kjøretidstypen, men hjelper kompilatoren til å forstå typen av en variabel for typesjekkingens skyld. Typepåstander ligner på typecasting på andre språk som C# eller Java, men uten noen kjøretidspåvirkning.

Syntaks for typepåstander

Det er to måter å bruke typepåstander på i TypeScript:

• Bruk av søkeordet as (anbefalt)
• Bruk av vinkelbraketter <>

Bruke as nøkkelordet

Den vanligste måten å bruke typepåstander på er med søkeordet as:

let someValue: unknown = "Hello, TypeScript!";
let strLength: number = (someValue as string).length;

console.log(strLength); // Output: 17

I dette eksemplet forteller vi TypeScript at someValue er av typen string, slik at vi kan bruke egenskapen length.

Bruk av vinkelbraketter <>

Den alternative syntaksen for typepåstander bruker vinkelparenteser:

let someValue: unknown = "Hello, TypeScript!";
let strLength: number = (someValue).length;

console.log(strLength); // Output: 17

Denne syntaksen oppnår samme resultat som as-syntaksen. Det anbefales imidlertid ikke i miljøer der JSX (som React) brukes, da det er i konflikt med syntaksen for JSX-elementer.

Vanlige brukstilfeller for typepåstander

Typepåstander brukes ofte i flere scenarier:

• Når du arbeider med typen ukjent
• Ved håndtering av DOM-elementer
• Ved innsnevring av fagforeningstyper
• Når du samhandler med tredjepartsbiblioteker som mangler typedefinisjoner

Eksempel: Å påstå typer med typen ukjent

ukjent-typen er nyttig når du vil godta en hvilken som helst type, men fortsatt trenger å sjekke litt før du bruker den. Typepåstander hjelper med å begrense typen:

function getLength(value: unknown): number {
  if (typeof value === "string") {
    return (value as string).length;
  } else if (Array.isArray(value)) {
    return (value as any[]).length;
  }
  return 0;
}

console.log(getLength("Hello")); // Output: 5
console.log(getLength([1, 2, 3])); // Output: 3
console.log(getLength(42)); // Output: 0

I dette eksemplet bruker vi typepåstander for å fortelle TypeScript at verdi er en streng eller en en hvilken som helst[]-matrise.

Eksempel: Håndtering av DOM-elementer

Når du manipulerer DOM, trenger TypeScript å kjenne den spesifikke typen til et element for å gi passende egenskaper og metoder. Typepåstander er nyttige her:

const inputElement = document.getElementById("user-input") as HTMLInputElement;
inputElement.value = "Hello, TypeScript!";

Her bruker vi type assertion for å fortelle TypeScript at inputElement er et HTMLInputElement, noe som gir oss direkte tilgang til value-egenskapen.

Typepåstand vs. Typecasting

Det er viktig å forstå forskjellen mellom typepåstand og typestøping. I TypeScript endrer ikke typepåstander den faktiske typen under kjøring; de forteller bare TypeScript-kompilatoren hvordan den skal behandles på kompileringstidspunktet. I motsetning til dette kan typecasting på andre språk som C# eller Java innebære å konvertere en verdi fra en type til en annen under kjøring, noe som kan påvirke ytelsen og oppførselen.

Forsiktig ved bruk av typepåstander

Selv om typepåstander kan være kraftige, kan misbruk føre til kjøretidsfeil. Her er noen tips for å bruke dem trygt:

• Unngå å bruke påstander for å tvangskonvertere inkompatible typer.
• Bruk alltid påstander med forsiktighet og foretrekk innsnevringstyper ved å bruke TypeScripts typebeskyttelse.
• Bruk påstander når du er sikker på typen og når det ikke er mulig å begrense den ellers.

Eksempel på feil typepåstand

Her er et eksempel på en farlig type påstand:

let someValue: string = "Hello, TypeScript!";
let numValue: number = (someValue as unknown as number); // Dangerous!

console.log(numValue); // Output: Hello, TypeScript! (incorrect)

Denne koden kompileres uten feil, men den vil føre til uventet oppførsel under kjøring fordi strengen blir feilaktig behandlet som et tall.

Konklusjon

Typepåstander i TypeScript gir en måte å overstyre de utledede typene når du vet mer om en verdis type enn TypeScript gjør. De er nyttige når du arbeider med usikre typer, samhandler med tredjepartsbiblioteker eller arbeider med DOM-elementer. De bør imidlertid brukes med forsiktighet for å unngå kjøretidsfeil og sikre typesikkerhet i koden din.

Ved å mestre typepåstander kan du skrive mer uttrykksfull og robust TypeScript-kode. Øv deg på å bruke dem i ulike scenarier for å bli mer komfortabel med denne kraftige funksjonen.