Introduksjon til TypeScript Type Guards

Typevakter er en kraftig funksjon i TypeScript som lar utviklere utføre kjøretidskontroller for å begrense typen til en variabel. Dette sikrer mer presis typeinformasjon, noe som fører til sikrere og mer forutsigbar kode. Denne artikkelen utforsker hva slags beskyttelser er og hvordan du bruker dem effektivt.

Hva er typebeskyttere?

Typevakter er uttrykk som utfører kjøretidskontroller og lar TypeScript utlede en mer spesifikk type for en variabel. De hjelper til med å skille mellom ulike typer, spesielt når de har å gjøre med fagforeningstyper. Typebeskyttere kan implementeres ved hjelp av ulike teknikker, inkludert:

• Brukerdefinerte typepredikater
• Skriv påstander
• Forekomstsjekker
• Bruke typeof-operatoren
• Bruke in operatoren

Brukerdefinerte typepredikater

Brukerdefinerte typepredikater er funksjoner som returnerer en boolsk verdi og har en spesiell returtype som indikerer hvilken type variabel som kontrolleres. Slik lager og bruker du dem:

function isString(value: any): value is string {
  return typeof value === 'string';
}

function printString(value: any) {
  if (isString(value)) {
    console.log(value.toUpperCase()); // TypeScript knows value is a string here
  } else {
    console.log('Not a string');
  }
}

I eksemplet ovenfor er isString et brukerdefinert typepredikat som hjelper TypeScript å forstå at verdi er en streng innenfor if-blokken.

Skriv påstander

Typepåstander forteller TypeScript å behandle en variabel som en bestemt type. Denne metoden utfører ikke en kjøretidssjekk, men informerer TypeScript-kompilatoren om typen. For eksempel:

function printLength(value: any) {
  console.log((value as string).length); // Assert value is a string
}

I dette eksemplet forteller verdi som streng TypeScript å anta at verdi er en streng uten å utføre en kjøretidssjekk.

Forekomstsjekker

Forekomstsjekker brukes til å bestemme om et objekt er en forekomst av en bestemt klasse. Dette er nyttig for å begrense typer når du arbeider med klasser:

class Dog {
  bark() { console.log('Woof'); }
}

class Cat {
  meow() { console.log('Meow'); }
}

function speak(animal: Dog | Cat) {
  if (animal instanceof Dog) {
    animal.bark(); // TypeScript knows animal is a Dog here
  } else {
    animal.meow(); // TypeScript knows animal is a Cat here
  }
}

I dette eksemplet hjelper instanceof-operatoren TypeScript med å utlede typen animal basert på klassen.

Bruke type-operatøren

Operatoren typeof kan brukes til å sjekke primitive typer som streng, tall og boolsk:

function processValue(value: string | number) {
  if (typeof value === 'string') {
    console.log(value.toUpperCase()); // TypeScript knows value is a string here
  } else {
    console.log(value.toFixed(2)); // TypeScript knows value is a number here
  }
}

Her brukes type for å sjekke om verdi er en streng eller et tall og begrenser typen tilsvarende.

Bruke in-operatøren

Operatoren in sjekker for tilstedeværelsen av en egenskap i et objekt. Dette er nyttig for å skille mellom typer som deler felles egenskaper:

interface Bird {
  fly: () => void;
}

interface Fish {
  swim: () => void;
}

function move(creature: Bird | Fish) {
  if ('fly' in creature) {
    creature.fly(); // TypeScript knows creature is a Bird here
  } else {
    creature.swim(); // TypeScript knows creature is a Fish here
  }
}

I dette eksemplet hjelper in-operatoren TypeScript med å bestemme om skapning er en Fugl eller en Fish basert på tilstedeværelsen av en metode.

Konklusjon

TypeScript type guards er viktige verktøy for å arbeide med typer på en fleksibel og sikker måte. De tillater mer presis typekontroll og kan forhindre kjøretidsfeil ved å sikre at riktig type brukes i forskjellige scenarier. Å forstå og bruke typevakter effektivt kan føre til mer robust og vedlikeholdbar TypeScript-kode.