TypeScript-typebewakers

Typeguards zijn een krachtige functie in TypeScript waarmee ontwikkelaars runtime-controles kunnen uitvoeren om het type van een variabele te verfijnen. Dit zorgt voor nauwkeurigere type-informatie, wat leidt tot veiligere en meer voorspelbare code. Dit artikel onderzoekt wat typeguards zijn en hoe u ze effectief kunt gebruiken.

Wat zijn typeguards?

Typeguards zijn expressies die runtime-controles uitvoeren en TypeScript toestaan ​​om een ​​specifieker type voor een variabele af te leiden. Ze helpen bij het onderscheiden tussen verschillende typen, met name bij het omgaan met union-typen. Typeguards kunnen worden geïmplementeerd met behulp van verschillende technieken, waaronder:

• Door de gebruiker gedefinieerde typepredicaten
• Type-asserties
• Instantiecontroles
• De operator typeof gebruiken
• De operator in gebruiken

Door de gebruiker gedefinieerde typepredicaten

Door de gebruiker gedefinieerde typepredicaten zijn functies die een booleaanse waarde retourneren en een speciaal retourtype hebben dat het type van de gecontroleerde variabele aangeeft. Hier leest u hoe u ze kunt maken en gebruiken:

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');
  }
}

In het bovenstaande voorbeeld is isString een door de gebruiker gedefinieerd typepredikaat dat TypeScript helpt begrijpen dat value een tekenreeks is binnen het if-blok.

Type-asserties

Type-asserties vertellen TypeScript om een ​​variabele als een bepaald type te behandelen. Deze methode voert geen runtime-controle uit, maar informeert de TypeScript-compiler over het type. Bijvoorbeeld:

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

In dit voorbeeld vertelt waarde als string TypeScript om aan te nemen dat waarde een string is, zonder een runtime-controle uit te voeren.

Instantiecontroles

Instantiecontroles worden gebruikt om te bepalen of een object een instantie is van een bepaalde klasse. Dit is handig om typen te beperken bij het werken met klassen:

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
  }
}

In dit voorbeeld helpt de operator instanceof TypeScript bij het afleiden van het type van animal op basis van de klasse.

De operator typeof gebruiken

De operator typeof kan worden gebruikt om primitieve typen te controleren, zoals string, number en 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
  }
}

Hier wordt typeof gebruikt om te controleren of value een string of een number is en wordt het type dienovereenkomstig beperkt.

Het gebruik van de in operator

De operator in controleert op de aanwezigheid van een eigenschap in een object. Dit is handig om onderscheid te maken tussen typen die gemeenschappelijke eigenschappen delen:

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
  }
}

In dit voorbeeld helpt de operator in TypeScript te bepalen of creature een Bird of een Fish is, op basis van de aanwezigheid van een methode.

Conclusie

TypeScript-typeguards zijn essentiële tools om op een flexibele en veilige manier met types te werken. Ze maken nauwkeurigere typecontrole mogelijk en kunnen runtimefouten voorkomen door ervoor te zorgen dat het juiste type in verschillende scenario's wordt gebruikt. Het begrijpen en effectief gebruiken van typeguards kan leiden tot robuustere en onderhoudbare TypeScript-code.