Introducere în TypeScript Type Guards

Protecțiile de tip sunt o funcție puternică în TypeScript care le permite dezvoltatorilor să efectueze verificări de rulare pentru a restrânge tipul unei variabile. Acest lucru asigură informații de tip mai precise, ceea ce duce la un cod mai sigur și mai previzibil. Acest articol explorează ce tip de gărzi sunt și cum să le folosești eficient.

Ce sunt gărzile de tip?

Gardienele de tip sunt expresii care efectuează verificări de rulare și permit TypeScript să deducă un tip mai specific pentru o variabilă. Ele ajută la discriminarea între diferitele tipuri, în special atunci când avem de-a face cu tipuri de sindicat. Protecțiile de tip pot fi implementate folosind diferite tehnici, inclusiv:

• Predicate de tip definite de utilizator
• Aserțiuni de tip
• Verificări ale instanțelor
• Folosind operatorul typeof
• Folosind operatorul in

Predicate de tip definite de utilizator

Predicatele de tip definit de utilizator sunt funcții care returnează o valoare booleană și au un tip de returnare special care indică tipul variabilei care este verificată. Iată cum să le creați și să le utilizați:

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

În exemplul de mai sus, isString este un predicat de tip definit de utilizator care ajută TypeScript să înțeleagă că value este un șir din blocul if.

Tip Aserțiuni

Aserțiunile de tip îi spun TypeScript să trateze o variabilă ca un anumit tip. Această metodă nu efectuează o verificare de rulare, dar informează compilatorul TypeScript despre tip. De exemplu:

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

În acest exemplu, value as string îi spune TypeScript să presupună că value este un șir fără a efectua o verificare de rulare.

Verificări de instanță

Verificările de instanță sunt utilizate pentru a determina dacă un obiect este o instanță a unei anumite clase. Acest lucru este util pentru restrângerea tipurilor atunci când lucrați cu clase:

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

În acest exemplu, operatorul instanceof ajută TypeScript să deducă tipul de animal pe baza clasei sale.

Folosind operatorul typeof

Operatorul typeof poate fi folosit pentru a verifica tipurile primitive, cum ar fi string, number și 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
  }
}

Aici, typeof este folosit pentru a verifica dacă value este un string sau un number și restrânge tipul în consecință.

Folosind operatorul in

Operatorul in verifică prezența unei proprietăți într-un obiect. Acest lucru este util pentru a distinge tipurile care au proprietăți comune:

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

În acest exemplu, operatorul in ajută TypeScript să determine dacă creature este un Bird sau un Fish pe baza prezenței unei metode.

Concluzie

Protecțiile de tip TypeScript sunt instrumente esențiale pentru a lucra cu tipuri într-un mod flexibil și sigur. Acestea permit verificarea mai precisă a tipului și pot preveni erorile de rulare, asigurându-se că tipul corect este utilizat în diferite scenarii. Înțelegerea și utilizarea eficientă a gardienilor de tip poate duce la un cod TypeScript mai robust și mai ușor de întreținut.