TypeScript-typskydd

Typskydd är en kraftfull funktion i TypeScript som låter utvecklare utföra körtidskontroller för att begränsa typen av en variabel. Detta säkerställer mer exakt typinformation, vilket leder till säkrare och mer förutsägbar kod. Den här artikeln utforskar vilken typ av skydd är och hur man använder dem effektivt.

Vad är typskydd?

Typskydd är uttryck som utför körtidskontroller och tillåter TypeScript att sluta sig till en mer specifik typ för en variabel. De hjälper till att skilja mellan olika typer, särskilt när det handlar om fackföreningstyper. Typskydd kan implementeras med olika tekniker, inklusive:

• Användardefinierade typpredikat
• Typ påståenden
• Instanskontroller
• Använder operatorn typeof
• Använda in operatorn

Användardefinierade typpredikat

Användardefinierade typpredikat är funktioner som returnerar ett booleskt värde och har en speciell returtyp som anger vilken typ av variabel som kontrolleras. Så här skapar och använder 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 exemplet ovan är isString ett användardefinierat typpredikat som hjälper TypeScript att förstå att värde är en sträng inom if-blocket.

Typ påståenden

Typpåståenden säger till TypeScript att behandla en variabel som en viss typ. Den här metoden utför ingen körtidskontroll utan informerar TypeScript-kompilatorn om typen. Till exempel:

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

I det här exemplet säger värde som sträng till TypeScript att anta att värde är en sträng utan att utföra en körtidskontroll.

Instanskontroller

Instanskontroller används för att avgöra om ett objekt är en instans av en viss klass. Detta är användbart för att begränsa typerna när du arbetar 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 det här exemplet hjälper operatorn instanceof TypeScript att härleda typen av djur baserat på dess klass.

Använda typeof Operator

Operatorn typeof kan användas för att kontrollera primitiva typer som string, number och 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
  }
}

Här används typ för att kontrollera om värde är en sträng eller ett nummer och begränsar typen därefter.

Använda in Operator

Operatorn in kontrollerar förekomsten av en egenskap i ett objekt. Detta är användbart för att skilja mellan typer som delar gemensamma 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 det här exemplet hjälper operatorn in TypeScript att avgöra om creature är en Bird eller en Fish baserat på förekomsten av en metod.

Slutsats

TypeScript-typskydd är viktiga verktyg för att arbeta med typer på ett flexibelt och säkert sätt. De möjliggör mer exakt typkontroll och kan förhindra körtidsfel genom att säkerställa att rätt typ används i olika scenarier. Att förstå och använda typskydd effektivt kan leda till mer robust och underhållbar TypeScript-kod.