Typy generyczne

Witamy na kolejnej lekcji! W tej lekcji dowie się Pan/Pani o typach generycznych — zaawansowanej funkcji TypeScript, która pozwala tworzyć komponenty wielokrotnego użytku i bezpieczne typowo. Zaczynajmy!

Czym są typy generyczne?

Typy generyczne pozwalają pisać kod wielokrotnego użytku, który działa z dowolnym typem. Działają jako symbole zastępcze typów, które można określić podczas ich używania.

Przykład: funkcja generyczna:

Zadanie: Napisz funkcję generyczną, która przyjmuje argument i zwraca go bez zmian.

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

console.log(identity<string>("Hello")); 
// Output: Hello
console.log(identity<number>(42)); 
// Output: 42

Dlaczego używać typów generycznych?

Typy generyczne pomagają:

• Pisać kod wielokrotnego użytku: Funkcje i klasy mogą działać z różnymi typami.
• Zapewniać bezpieczeństwo typów: Można wymuszać określone typy bez utraty elastyczności.
• Ograniczać powtórzenia: Można uniknąć pisania osobnych wersji tej samej funkcji lub klasy dla różnych typów.

Wskazówka: Korzystaj z typów generycznych, aby pisać bardziej elastyczny i łatwiejszy w utrzymaniu kod.

Funkcje generyczne

Typów generycznych można używać do tworzenia elastycznych funkcji. Przykład:

Zadanie: Napisz funkcję generyczną, która scala dwa obiekty i zwraca wynik.

function merge<T, U>(obj1: T, obj2: U): T & U {
  return { ...obj1, ...obj2 };
}

let merged = merge({ name: "Alice" }, { age: 25 });
console.log(merged); 
// Output: { name: "Alice", age: 25 }

Klasy generyczne

Typów generycznych można używać w klasach, aby były wielokrotnego użytku dla różnych typów. Przykład:

class Box<T> {
  private contents: T;

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

  getContents(): T {
    return this.contents;
  }
}

let stringBox = new Box<string>("Hello");
console.log(stringBox.getContents()); 
// Output: Hello

let numberBox = new Box<number>(42);
console.log(numberBox.getContents()); 
// Output: 42

Interfejsy generyczne

Interfejsy również mogą używać typów generycznych, aby wymuszać strukturę dla różnych typów. Przykład:

Zadanie: Zdefiniuj generyczny interfejs i utwórz obiekt, który go implementuje.

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

let coordinates: Pair<number, number> = { first: 10, second: 20 };
console.log(coordinates); 
// Output: { first: 10, second: 20 }

Ograniczenia typów generycznych

Do typów generycznych można dodawać ograniczenia, aby zapewnić, że będą działać tylko z określonymi typami. Przykład:

function printLength<T extends { length: number }>(item: T): void {
  console.log(`Length: ${item.length}`);
}

printLength("Hello"); 
// Output: Length: 5
printLength([1, 2, 3]); 
// Output: Length: 3
// printLength(42); 
// Error: Argument of type 'number' is not assignable to parameter of type '{ length: number }'.

Domyślne typy generyczne

Można określić domyślne typy dla typów generycznych, jeśli nie podano typu. Przykład:

Zadanie: Utwórz funkcję generyczną z typem domyślnym i przetestuj ją z różnymi typami.

function wrap<T = string>(value: T): T[] {
  return [value];
}

console.log(wrap("Hello")); // Output: ["Hello"]
console.log(wrap(42)); // Output: [42]

Świetna robota!

Gratulacje! Nauczył(a) się Pan/Pani, jak używać typów generycznych w TypeScript do tworzenia wielokrotnego użytku i bezpiecznych typowo funkcji, klas oraz interfejsów. Typy generyczne są potężnym narzędziem do pisania elastycznego i skalowalnego kodu. W następnej lekcji pozna Pan/Pani zaawansowane typy, takie jak typy mapowane i warunkowe. Kontynuujmy programowanie!