Introduktion til TypeScript Type Guards

Typevagter er en kraftfuld funktion i TypeScript, der giver udviklere mulighed for at udføre runtime-tjek for at indsnævre typen af ​​en variabel. Dette sikrer mere præcis typeinformation, hvilket fører til sikrere og mere forudsigelig kode. Denne artikel undersøger, hvilken type vagter er, og hvordan man bruger dem effektivt.

Hvad er typebeskyttere?

Typevagter er udtryk, der udfører runtime-tjek og tillader TypeScript at udlede en mere specifik type for en variabel. De hjælper med at skelne mellem forskellige typer, især når de har at gøre med fagforeningstyper. Typebeskyttere kan implementeres ved hjælp af forskellige teknikker, herunder:

• Brugerdefinerede typeprædikater
• Type påstande
• Instanstjek
• Brug af typeof operatoren
• Brug af in operatoren

Brugerdefinerede typeprædikater

Brugerdefinerede typeprædikater er funktioner, der returnerer en boolesk værdi og har en speciel returtype, der angiver typen af ​​den variable, der kontrolleres. Sådan opretter og bruger 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 brugerdefineret typeprædikat, der hjælper TypeScript med at forstå, at værdi er en streng i if-blokken.

Type påstande

Typepåstande fortæller TypeScript at behandle en variabel som en bestemt type. Denne metode udfører ikke et runtime-tjek, men informerer TypeScript-kompileren om typen. For eksempel:

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

I dette eksempel fortæller værdi som streng TypeScript at antage, at værdi er en streng uden at udføre en kørselstidskontrol.

Forekomstkontrol

Forekomstkontrol bruges til at bestemme, om et objekt er en forekomst af en bestemt klasse. Dette er nyttigt til at indsnævre typer, når du arbejder 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 eksempel hjælper operatoren instanceof TypeScript med at udlede typen af ​​animal baseret på dens klasse.

Brug af type-operatøren

Operatoren typeof kan bruges til at kontrollere primitive typer såsom streng, tal og boolean:

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 bruges typeof til at kontrollere, om værdi er en streng eller et tal og indsnævrer typen tilsvarende.

Brug af in operatøren

Operatoren in kontrollerer tilstedeværelsen af ​​en egenskab i et objekt. Dette er nyttigt til at skelne mellem typer, der deler fælles egenskaber:

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 eksempel hjælper in-operatoren TypeScript med at bestemme, om væsen er en Bird eller en Fish baseret på tilstedeværelsen af ​​en metode.

Konklusion

TypeScript-typeafskærmninger er vigtige værktøjer til at arbejde med typer på en fleksibel og sikker måde. De giver mulighed for mere præcis typekontrol og kan forhindre runtime-fejl ved at sikre, at den korrekte type bruges i forskellige scenarier. At forstå og bruge typebeskyttelser effektivt kan føre til mere robust og vedligeholdelig TypeScript-kode.