Cum să utilizați aserțiuni de tip TypeScript

Aserțiunile de tip în TypeScript sunt o modalitate de a spune compilatorului că știți mai multe despre tipul unei valori decât știe el. Acest lucru poate fi util atunci când lucrați cu valori care au tipuri incerte sau largi și doriți să le restrângeți pentru o mai bună verificare a tipului și o mai bună citire a codului. În acest articol, vom explora cum să folosim în mod eficient afirmațiile de tip TypeScript.

Ce este Type Assertion?

Type assertion este un mecanism în TypeScript care vă permite să suprascrieți inferența de tip implicită făcută de compilatorul TypeScript. Nu schimbă tipul real de rulare, dar ajută compilatorul să înțeleagă tipul unei variabile de dragul verificării tipului. Afirmațiile de tip sunt similare cu turnarea tipului în alte limbi precum C# sau Java, dar fără niciun impact asupra timpului de execuție.

Sintaxa aserțiunilor de tip

Există două moduri de a utiliza aserțiuni de tip în TypeScript:

• Folosind cuvântul cheie as (recomandat)
• Folosind paranteze unghiulare <>

Folosind cuvântul cheie as

Cel mai obișnuit mod de a folosi afirmațiile de tip este cu cuvântul cheie as:

let someValue: unknown = "Hello, TypeScript!";
let strLength: number = (someValue as string).length;

console.log(strLength); // Output: 17

În acest exemplu, îi spunem TypeScript că someValue este de tip string, permițându-ne să folosim proprietatea length.

Folosind paranteze unghiulare <>

Sintaxa alternativă pentru aserțiunile de tip utilizează paranteze unghiulare:

let someValue: unknown = "Hello, TypeScript!";
let strLength: number = (someValue).length;

console.log(strLength); // Output: 17

Această sintaxă obține același rezultat ca și sintaxa as. Cu toate acestea, nu este recomandat în mediile în care este utilizat JSX (cum ar fi React), deoarece intră în conflict cu sintaxa elementelor JSX.

Cazuri de utilizare obișnuite pentru aserțiuni de tip

Aserțiunile de tip sunt utilizate în mod obișnuit în mai multe scenarii:

• Când lucrați cu tipul necunoscut
• La manipularea elementelor DOM
• La restrângerea tipurilor de uniuni
• Când interacționați cu biblioteci terțe care nu au definiții de tip

Exemplu: Afirmarea tipurilor cu tipul necunoscut

Tipul necunoscut este util atunci când doriți să acceptați orice tip, dar trebuie totuși să verificați tipul înainte de a-l folosi. Aserțiunile de tip ajută la restrângerea tipului:

function getLength(value: unknown): number {
  if (typeof value === "string") {
    return (value as string).length;
  } else if (Array.isArray(value)) {
    return (value as any[]).length;
  }
  return 0;
}

console.log(getLength("Hello")); // Output: 5
console.log(getLength([1, 2, 3])); // Output: 3
console.log(getLength(42)); // Output: 0

În acest exemplu, folosim aserțiuni de tip pentru a spune TypeScript că value este un string sau o matrice any[].

Exemplu: manipularea elementelor DOM

Când manipulează DOM, TypeScript trebuie să cunoască tipul specific al unui element pentru a oferi proprietăți și metode adecvate. Aserțiunile de tip sunt utile aici:

const inputElement = document.getElementById("user-input") as HTMLInputElement;
inputElement.value = "Hello, TypeScript!";

Aici, folosim type assertion pentru a spune TypeScript că inputElement este un HTMLInputElement, permițându-ne să accesăm direct proprietatea value.

Type Assertion vs. Type Casting

Este esențial să înțelegeți diferența dintre afirmarea tipului și turnarea tipului. În TypeScript, aserțiunile de tip nu schimbă tipul real în timpul execuției; ei spun doar compilatorului TypeScript cum să trateze tipul în timpul compilării. În schimb, turnarea tipului în alte limbi precum C# sau Java poate implica conversia unei valori de la un tip la altul în timpul execuției, ceea ce ar putea afecta performanța și comportamentul.

Precauții la utilizarea aserțiilor de tip

În timp ce afirmațiile de tip pot fi puternice, utilizarea greșită poate duce la erori de rulare. Iată câteva sfaturi pentru a le folosi în siguranță:

• Evitați utilizarea aserțiilor pentru a converti cu forță tipurile incompatibile.
• Folosiți întotdeauna aserțiunile cu precauție și preferați tipurile de restrângere folosind protecțiile de tip TypeScript.
• Utilizați aserțiuni atunci când sunteți sigur de tip și când nu este posibil să le restrângeți altfel.

Exemplu de afirmație de tip incorect

Iată un exemplu de afirmație de tip periculos:

let someValue: string = "Hello, TypeScript!";
let numValue: number = (someValue as unknown as number); // Dangerous!

console.log(numValue); // Output: Hello, TypeScript! (incorrect)

Acest cod se compilează fără erori, dar va duce la un comportament neașteptat în timpul execuției, deoarece șirul este tratat incorect ca un număr.

Concluzie

Aserțiunile de tip în TypeScript oferă o modalitate de a suprascrie tipurile deduse atunci când știți mai multe despre tipul unei valori decât știe TypeScript. Ele sunt utile atunci când aveți de-a face cu tipuri incerte, când interacționați cu biblioteci terțe sau când lucrați cu elemente DOM. Cu toate acestea, acestea ar trebui să fie utilizate cu precauție pentru a evita erorile de rulare și pentru a asigura siguranța tipului în codul dvs.

Prin stăpânirea aserțiilor de tip, puteți scrie cod TypeScript mai expresiv și mai robust. Exersați utilizarea lor în diferite scenarii pentru a vă simți mai confortabil cu această funcție puternică.