Generic TypeScript cu exemple

Genericele TypeScript sunt o caracteristică puternică care vă permite să creați componente reutilizabile și sigure pentru tipărire. Genericurile oferă o modalitate de a crea clase, funcții și interfețe care funcționează cu o varietate de tipuri, menținând în același timp siguranța puternică a tipului. Acest articol vă va prezenta generice și vă va demonstra cum să le utilizați cu exemple practice.

Înțelegerea genericelor

Genericurile vă permit să definiți o componentă cu un substituent pentru tipul pe care operează. În loc să specificați un tip de beton, utilizați un parametru de tip generic care poate fi înlocuit cu orice tip atunci când componenta este utilizată.

Sintaxa de bază

Sintaxa de bază pentru definirea unui tip generic este de a folosi paranteze unghiulare <> cu un nume de parametru de tip. Iată un exemplu simplu:

function identity(value: T): T {
  return value;
}

const stringIdentity = identity("Hello"); // string
const numberIdentity = identity(123); // number

În acest exemplu, identity este o funcție generică care preia un parametru value de tip T și returnează o valoare de același tip. Parametrul de tip T este înlocuit cu tipul real atunci când funcția este apelată.

Generic cu clase

Genericurile pot fi folosite și cu clase pentru a crea structuri de date flexibile și reutilizabile. Iată un exemplu de clasă generică:

class Box {
  private value: T;

  constructor(value: T) {
    this.value = value;
  }

  getValue(): T {
    return this.value;
  }
}

const stringBox = new Box("TypeScript");
console.log(stringBox.getValue()); // Output: TypeScript

const numberBox = new Box(42);
console.log(numberBox.getValue()); // Output: 42

În acest exemplu, clasa Box este definită cu un parametru de tip generic T. Clasa are o proprietate privată value de tip T și o metodă getValue care returnează valoarea tipului T.

Generic cu interfețe

Genericurile pot fi folosite cu interfețe pentru a crea interfețe flexibile și sigure pentru tipare. Iată un exemplu:

interface Pair<T, U> {
  first: T;
  second: U;
}

const pair: Pair<string, number> = {
  first: "Age",
  second: 30
};

console.log(pair.first); // Output: Age
console.log(pair.second); // Output: 30

În acest exemplu, interfața Pair este definită cu doi parametri de tip generic T și U. Interfața reprezintă o pereche de valori cu tipurile T și, respectiv, U.

Generic în Funcții

Genericurile pot fi folosite în funcții pentru a gestiona mai multe tipuri, menținând în același timp siguranța tipului. Iată un exemplu de funcție generică care funcționează cu matrice:

function reverseArray(items: T[]): T[] {
  return items.reverse();
}

const reversedStringArray = reverseArray(["one", "two", "three"]);
console.log(reversedStringArray); // Output: ["three", "two", "one"]

const reversedNumberArray = reverseArray([1, 2, 3]);
console.log(reversedNumberArray); // Output: [3, 2, 1]

În acest exemplu, funcția reverseArray preia o matrice de tip T și returnează o matrice inversată de același tip. Parametrul de tip T asigură că funcția funcționează cu matrice de orice tip, menținând în același timp siguranța tipului.

Constrângeri asupra genericelor

Uneori poate fi necesar să impuneți constrângeri asupra parametrului de tip generic pentru a vă asigura că are anumite proprietăți. Acest lucru se face folosind constrângeri:

function logLength(item: T): void {
  console.log(item.length);
}

logLength("Hello, TypeScript"); // Output: 16
logLength([1, 2, 3]); // Output: 3
// logLength(123); // Error: number does not have a length property

În acest exemplu, funcția logLength este constrânsă la tipuri care au o proprietate length. Acest lucru permite funcției să accepte șiruri și matrice, dar nu numere sau alte tipuri fără o proprietate length.

Concluzie

Genericurile din TypeScript oferă o modalitate puternică de a crea componente flexibile și reutilizabile, menținând în același timp siguranța puternică a tipului. Prin înțelegerea și utilizarea genericelor, puteți scrie cod mai generic și adaptabil, îmbunătățind calitatea generală și mentenabilitatea aplicațiilor dvs. TypeScript.

Experimentați cu generice în proiectele dvs. pentru a vedea beneficiile acestora în acțiune și pentru a vă îmbunătăți abilitățile de programare TypeScript.