Kurs JavaScript i TypeScript · Moduł 6: Podstawy TypeScript

Funkcje generyczne

13 min czytania ·
W tej lekcji11

Witaj ponownie w najbardziej zaawansowanym laboratorium genetycznym Parku Jurajskiego! Dr. Henry Wu dziś zaprasza nas do zgłębienia jednego z najpotężniejszych mechanizmów TypeScript - funkcji generycznych. Podobnie jak zaawansowana inżynieria genetyczna pozwala nam tworzyć nowe gatunki dinozaurów z różnym DNA, funkcje generyczne pozwalają na tworzenie elastycznych, wielokrotnego użytku rozwiązań, które działają z różnymi typami danych, zachowując jednocześnie pełne bezpieczeństwo typów.

Czym są funkcje generyczne?

Funkcje generyczne to funkcje, które mogą pracować z różnymi typami danych, zachowując przy tym pełną kontrolę typów. Zamiast definiować konkretny typ parametru i zwracanej wartości, używamy parametrów typu (oznaczonych zwykle jako T, U, K itp.), które są "wypełniane" konkretnymi typami w momencie wywołania funkcji.

Wyobraź sobie, że zamiast tworzyć osobną funkcję dla każdego gatunku dinozaura, możesz stworzyć jedną generyczną funkcję, która będzie działała z każdym gatunkiem!

Podstawowa składnia funkcji generycznych

Przyjrzyjmy się, jak definiuje się i używa funkcji generycznych w TypeScript:

// Prosta funkcja generyczna - zwraca ten sam element, który został przekazany
function identycznośćGenetyczna<T>(obiekt: T): T {
  return obiekt;
}

// Użycie z różnymi typami
const łańcuchDNA: string = identycznośćGenetyczna<string>("ACGTACGT");
const wiekTriceratopsa: number = identycznośćGenetyczna<number>(12);
const aktywnyStatus: boolean = identycznośćGenetyczna<boolean>(true);

// TypeScript często może wywnioskować typ generyczny na podstawie przekazanego argumentu
const poziomAgresji = identycznośćGenetyczna(7); // TypeScript wnioskuje T jako number

W powyższym przykładzie:

  1. Definiujemy funkcję generyczną identycznośćGenetyczna z parametrem typu T
  2. Funkcja przyjmuje argument typu T i zwraca wartość tego samego typu
  3. Używamy funkcji z różnymi typami: string, number, boolean
  4. W ostatnim przykładzie TypeScript automatycznie wnioskuje typ generyczny na podstawie przekazanego argumentu

Funkcje generyczne z wieloma parametrami typu

Funkcje generyczne mogą mieć wiele parametrów typu, co pozwala na bardziej złożone operacje:

// Funkcja generyczna z dwoma parametrami typu
function parujDaneDinozaurów<T, U>(pierwsze: T, drugie: U): [T, U] {
  return [pierwsze, drugie];
}

// Przykładowe użycie
interface DanePodstawoweDinozaura {
  nazwa: string;
  gatunek: string;
  wiek: number;
}

interface DaneZdrowotne {
  temperaturaCiała: number;
  tętno: number;
  poziomEnergii: number;
}

const rexPodstawowe: DanePodstawoweDinozaura = {
  nazwa: "Rex",
  gatunek: "Tyrannosaurus",
  wiek: 7
};

const rexZdrowie: DaneZdrowotne = {
  temperaturaCiała: 38.2,
  tętno: 76,
  poziomEnergii: 8.5
};

// Łączenie różnych typów danych
const pełneDaneRexa = parujDaneDinozaurów<DanePodstawoweDinozaura, DaneZdrowotne>(
  rexPodstawowe,
  rexZdrowie
);

console.log(`${pełneDaneRexa[0].nazwa} ma temperaturę ciała ${pełneDaneRexa[1].temperaturaCiała}°C`);

Ograniczenia generyczne (Generic Constraints)

Czasami chcemy, aby nasze funkcje generyczne działały tylko z określonymi typami danych, które spełniają pewne wymagania. Możemy to osiągnąć za pomocą ograniczeń generycznych poprzez słowo kluczowe extends:

// Definiujemy interfejs opisujący minimalne wymagania
interface PodstawoweInformacjeDinozaura {
  id: string;
  nazwa: string;
  gatunek: string;
}

// Funkcja generyczna z ograniczeniem - T musi zawierać co najmniej właściwości z PodstawoweInformacjeDinozaura
function wyświetlInformacjeDinozaura<T extends PodstawoweInformacjeDinozaura>(dino: T): void {
  console.log(`ID: ${dino.id}`);
  console.log(`Nazwa: ${dino.nazwa}`);
  console.log(`Gatunek: ${dino.gatunek}`);

  // Możemy również uzyskać dostęp do dodatkowych właściwości, które mogą być obecne w T
  console.log("Dodatkowe informacje:");
  const podstawoweKlucze = Object.keys({} as PodstawoweInformacjeDinozaura);
  Object.entries(dino).forEach(([klucz, wartość]) => {
    if (!podstawoweKlucze.includes(klucz)) {
      console.log(`- ${klucz}: ${wartość}`);
    }
  });
}

// Przykład użycia z różnymi typami spełniającymi ograniczenie
interface TRex extends PodstawoweInformacjeDinozaura {
  siłaUgryzienia: number;
  prędkośćBiegu: number;
}

const rex: TRex = {
  id: "TREX-001",
  nazwa: "Rexy",
  gatunek: "Tyrannosaurus Rex",
  siłaUgryzienia: 12800,
  prędkośćBiegu: 32
};

interface Velociraptor extends PodstawoweInformacjeDinozaura {
  inteligencja: number;
  polowanieWGrupie: boolean;
}

const raptor: Velociraptor = {
  id: "VELOC-001",
  nazwa: "Blue",
  gatunek: "Velociraptor",
  inteligencja: 9,
  polowanieWGrupie: true
};

// Obie funkcje zadziałają, ponieważ oba typy rozszerzają PodstawoweInformacjeDinozaura
wyświetlInformacjeDinozaura(rex);
wyświetlInformacjeDinozaura(raptor);

// To nie zadziała, ponieważ brakuje wymaganych właściwości
// wyświetlInformacjeDinozaura({ waga: 5000, wiek: 12 });

W powyższym przykładzie:

  1. Definiujemy interfejs PodstawoweInformacjeDinozaura z minimalnymi wymaganiami
  2. Tworzymy funkcję generyczną, która działa tylko z typami rozszerzającymi ten interfejs
  3. Funkcja może bezpiecznie korzystać z właściwości wymaganych przez interfejs
  4. Możemy użyć funkcji z różnymi typami dinozaurów, o ile spełniają podstawowe wymagania

Ograniczenia z kluczami (keyof constraint)

Słowo kluczowe keyof pozwala na ograniczenie parametru generycznego do kluczy innego typu. Jest to niezwykle przydatne przy tworzeniu funkcji, które operują na kluczach obiektów:

// Funkcja pobierająca wartość właściwości na podstawie jej klucza
function pobierzWłaściwośćDinozaura<T, K extends keyof T>(obiekt: T, klucz: K): T[K] {
  return obiekt[klucz];
}

// Przykładowe dane dinozaura
interface DaneDinozaura {
  id: string;
  nazwa: string;
  gatunek: string;
  wiek: number;
  waga: number;
  drapieżnik: boolean;
  cechy: string[];
}

const triceratops: DaneDinozaura = {
  id: "TRIC-001",
  nazwa: "Tricky",
  gatunek: "Triceratops",
  wiek: 15,
  waga: 9000,
  drapieżnik: false,
  cechy: ["rogi", "tarcza na głowie", "silne nogi"]
};

// Użycie funkcji z różnymi kluczami
const nazwaTriceratopsa = pobierzWłaściwośćDinozaura(triceratops, "nazwa");
console.log(`Nazwa: ${nazwaTriceratopsa}`); // TypeScript wie, że to string

const wiekTriceratopsa = pobierzWłaściwośćDinozaura(triceratops, "wiek");
console.log(`Wiek: ${wiekTriceratopsa} lat`); // TypeScript wie, że to number

const cechy = pobierzWłaściwośćDinozaura(triceratops, "cechy");
console.log(`Cechy: ${cechy.join(", ")}`); // TypeScript wie, że to string[]

// To nie zadziała, ponieważ "nieistniejącaWłaściwość" nie jest kluczem DaneDinozaura
// pobierzWłaściwośćDinozaura(triceratops, "nieistniejącaWłaściwość");

W tym przykładzie:

  1. Tworzymy funkcję pobierzWłaściwośćDinozaura, która przyjmuje obiekt typu T i klucz K, ograniczony do kluczy T
  2. Funkcja zwraca wartość właściwości o danym kluczu, a TypeScript wie dokładnie, jakiego typu będzie zwrócona wartość
  3. Użycie funkcji z nieistniejącym kluczem zostanie wychwycone przez TypeScript na etapie kompilacji

Domyślne parametry typu

Podobnie jak funkcje mogą mieć wartości domyślne dla swoich parametrów, funkcje generyczne mogą mieć domyślne typy dla parametrów typu:

// Funkcja generyczna z domyślnym parametrem typu
function utworzRaportDinozaura<T = DaneDinozaura>(dane: T, etykieta: string = "Raport standardowy"): { dane: T, etykieta: string, timestamp: Date } {
  return {
    dane,
    etykieta,
    timestamp: new Date()
  };
}

// Użycie z domyślnym typem
const raportStandardowy = utworzRaportDinozaura(triceratops);
console.log(`Raport: ${raportStandardowy.etykieta}`);
console.log(`Dane dla: ${raportStandardowy.dane.nazwa}`);

// Użycie z innym typem
interface DaneKlimatyczne {
  temperatura: number;
  wilgotność: number;
  ciśnienie: number;
  lokalizacja: string;
}

const daneKlimatyczneWybiegu: DaneKlimatyczne = {
  temperatura: 28.5,
  wilgotność: 72,
  ciśnienie: 1013,
  lokalizacja: "Wybieg Triceratopsów"
};

const raportKlimatyczny = utworzRaportDinozaura<DaneKlimatyczne>(
  daneKlimatyczneWybiegu,
  "Raport klimatyczny"
);

console.log(`Raport: ${raportKlimatyczny.etykieta}`);
console.log(`Temperatura: ${raportKlimatyczny.dane.temperatura}°C`);

Generyczne typy tablicowe i operacje na kolekcjach

Funkcje generyczne są szczególnie przydatne przy pracy z tablicami i kolekcjami danych:

// Funkcja generyczna do filtrowania tablicy
function filtrujKolekcję<T>(kolekcja: T[], predykat: (element: T) => boolean): T[] {
  return kolekcja.filter(predykat);
}

// Przykładowe dane dinozaurów
interface KrótkaInformacjaDinozaura {
  id: string;
  nazwa: string;
  gatunek: string;
  drapieżnik: boolean;
  waga: number;
}

const dinozaury: KrótkaInformacjaDinozaura[] = [
  { id: "TREX-001", nazwa: "Rex", gatunek: "Tyrannosaurus", drapieżnik: true, waga: 8000 },
  { id: "VEL-001", nazwa: "Blue", gatunek: "Velociraptor", drapieżnik: true, waga: 150 },
  { id: "TRIC-001", nazwa: "Tricky", gatunek: "Triceratops", drapieżnik: false, waga: 9000 },
  { id: "STEG-001", nazwa: "Spike", gatunek: "Stegosaurus", drapieżnik: false, waga: 5000 },
  { id: "BRACH-001", nazwa: "Brachie", gatunek: "Brachiosaurus", drapieżnik: false, waga: 40000 }
];

// Filtrowanie dinozaurów drapieżnych
const drapieżniki = filtrujKolekcję<KrótkaInformacjaDinozaura>(
  dinozaury,
  dino => dino.drapieżnik
);

console.log("Drapieżniki w parku:");
drapieżniki.forEach(dino => console.log(`- ${dino.nazwa} (${dino.gatunek})`));

// Filtrowanie dinozaurów cięższych niż 10000 kg
const ciężkieDinozaury = filtrujKolekcję<KrótkaInformacjaDinozaura>(
  dinozaury,
  dino => dino.waga > 10000
);

console.log("\nCiężkie dinozaury:");
ciężkieDinozaury.forEach(dino => console.log(`- ${dino.nazwa}: ${dino.waga} kg`));

// Bardziej zaawansowana funkcja generyczna do mapowania tablicy
function przekształćKolekcję<T, U>(kolekcja: T[], transformacja: (element: T) => U): U[] {
  return kolekcja.map(transformacja);
}

// Tworzenie prostszych obiektów na podstawie dinozaurów
const etykietyDinozaurów = przekształćKolekcję<KrótkaInformacjaDinozaura, { nazwa: string, typ: string }>(
  dinozaury,
  dino => ({
    nazwa: dino.nazwa,
    typ: dino.drapieżnik ? "drapieżnik" : "roślinożerca"
  })
);

console.log("\nEtykiety dinozaurów:");
etykietyDinozaurów.forEach(etykieta => console.log(`- ${etykieta.nazwa}: ${etykieta.typ}`));

Generyczne klasy i metody

Nie tylko funkcje mogą być generyczne - klasy i ich metody również mogą wykorzystywać tę potężną funkcjonalność:

// Generyczna klasa Kolekcja - może przechowywać dane dowolnego typu
class Kolekcja<T> {
  private elementy: T[] = [];

  // Metoda dodająca element do kolekcji
  dodaj(element: T): void {
    this.elementy.push(element);
  }

  // Metoda pobierająca element o danym indeksie
  pobierz(indeks: number): T | undefined {
    if (indeks >= 0 && indeks < this.elementy.length) {
      return this.elementy[indeks];
    }
    return undefined;
  }

  // Metoda zwracająca wszystkie elementy
  wszystkie(): T[] {
    return [...this.elementy];
  }

  // Metoda filtrująca elementy
  filtruj(predykat: (element: T) => boolean): T[] {
    return this.elementy.filter(predykat);
  }

  // Generyczna metoda mapująca do innego typu
  mapuj<U>(transformacja: (element: T) => U): U[] {
    return this.elementy.map(transformacja);
  }

  // Metoda zwracająca liczbę elementów
  liczbaElementów(): number {
    return this.elementy.length;
  }
}

// Przykład użycia z dinozaurami
const kolekcjaDinozaurów = new Kolekcja<KrótkaInformacjaDinozaura>();

// Dodawanie dinozaurów do kolekcji
dinozaury.forEach(dino => kolekcjaDinozaurów.dodaj(dino));

// Pobieranie konkretnego dinozaura
const pierwszy = kolekcjaDinozaurów.pobierz(0);
if (pierwszy) {
  console.log(`Pierwszy dinozaur: ${pierwszy.nazwa} (${pierwszy.gatunek})`);
}

// Filtrowanie kolekcji
const małeDinozaury = kolekcjaDinozaurów.filtruj(dino => dino.waga < 1000);
console.log(`Liczba małych dinozaurów: ${małeDinozaury.length}`);

// Mapowanie do raportów zdrowia
interface RaportZdrowia {
  id: string;
  nazwa: string;
  statusZdrowia: string;
  uwagi: string;
}

const raportyZdrowia = kolekcjaDinozaurów.mapuj<RaportZdrowia>(dino => ({
  id: dino.id,
  nazwa: dino.nazwa,
  statusZdrowia: "dobry", // Symulacja - w rzeczywistości pobieralibyśmy dane z bazy
  uwagi: dino.drapieżnik
    ? "Zachować szczególną ostrożność"
    : "Standardowe procedury"
}));

console.log("\nRaporty zdrowia:");
raportyZdrowia.forEach(raport => {
  console.log(`- ${raport.nazwa}: ${raport.statusZdrowia} (${raport.uwagi})`);
});

Generyczne interfejsy i typy

Podobnie jak funkcje i klasy, również interfejsy i typy mogą być generyczne:

// Generyczny interfejs dla systemu przechowywania
interface System<T> {
  dodaj(element: T): void;
  pobierz(id: string): T | null;
  aktualizuj(id: string, element: T): boolean;
  usuń(id: string): boolean;
  wszystkie(): T[];
}

// Implementacja generycznego systemu przechowywania dla dinozaurów
class BazaDanychDinozaurów<T extends { id: string }> implements System<T> {
  private dane: Map<string, T> = new Map();

  dodaj(element: T): void {
    this.dane.set(element.id, element);
  }

  pobierz(id: string): T | null {
    return this.dane.has(id) ? this.dane.get(id)! : null;
  }

  aktualizuj(id: string, element: T): boolean {
    if (this.dane.has(id)) {
      this.dane.set(id, element);
      return true;
    }
    return false;
  }

  usuń(id: string): boolean {
    return this.dane.delete(id);
  }

  wszystkie(): T[] {
    return Array.from(this.dane.values());
  }
}

// Definiowanie typów z użyciem generycznego typu
type DaneZPrzypisanym<T> = {
  dane: T;
  przypisanyPracownik: string;
  ostatniaAktualizacja: Date;
};

// Użycie generycznego typu
type DinozaurZOpiekunem = DaneZPrzypisanym<KrótkaInformacjaDinozaura>;

// Tworzenie bazy danych dla dinozaurów z przypisanymi opiekunami
const bazaDanychZOpiekunami = new BazaDanychDinozaurów<DinozaurZOpiekunem>();

// Dodawanie rekordów
bazaDanychZOpiekunami.dodaj({
  dane: dinozaury[0],
  przypisanyPracownik: "Owen Grady",
  ostatniaAktualizacja: new Date(),
  id: dinozaury[0].id
});

bazaDanychZOpiekunami.dodaj({
  dane: dinozaury[1],
  przypisanyPracownik: "Dr. Henry Wu",
  ostatniaAktualizacja: new Date(),
  id: dinozaury[1].id
});

// Pobieranie danych
const rexZOpiekunem = bazaDanychZOpiekunami.pobierz("TREX-001");
if (rexZOpiekunem) {
  console.log(`\nDinozaur ${rexZOpiekunem.dane.nazwa} jest pod opieką ${rexZOpiekunem.przypisanyPracownik}`);
  console.log(`Ostatnia aktualizacja: ${rexZOpiekunem.ostatniaAktualizacja.toLocaleDateString()}`);
}

Praktyczny przykład: System zarządzania parkiem

Przyjrzyjmy się kompleksowemu przykładowi, jak funkcje generyczne mogą być wykorzystane w systemie zarządzania Parkiem Jurajskim:

// ===== SYSTEM ZARZĄDZANIA PARKIEM JURAJSKIM =====

// Podstawowe interfejsy
interface ElementParku {
  id: string;
  nazwa: string;
  typElementu: string;
}

interface ObszarParku extends ElementParku {
  typElementu: "obszar";
  współrzędne: [number, number];
  powierzchnia: number; // w hektarach
  poziomBezpieczeństwa: 1 | 2 | 3 | 4 | 5;
}

interface WybiegDinozaurów extends ObszarParku {
  typElementu: "wybieg";
  mieszkańcy: string[]; // ID dinozaurów
  typŚrodowiska: "las" | "sawanna" | "bagno" | "wybrzeże" | "akwen";
  statusOgrodzenia: "aktywne" | "nieaktywne" | "w naprawie";
}

interface DinozaurParku extends ElementParku {
  typElementu: "dinozaur";
  gatunek: string;
  wiek: number;
  waga: number;
  drapieżnik: boolean;
  lokalizacja: string; // ID obszaru
  statusZdrowia: "doskonały" | "dobry" | "wymaga uwagi" | "chory" | "krytyczny";
}

interface PracownikParku extends ElementParku {
  typElementu: "pracownik";
  stanowisko: string;
  poziomDostępu: 1 | 2 | 3 | 4 | 5;
  specjalizacja: string[];
}

// Generyczna klasa repozytorium
class Repozytorium<T extends ElementParku> {
  private elementy: Map<string, T> = new Map();

  dodaj(element: T): void {
    this.elementy.set(element.id, element);
  }

  pobierz(id: string): T | undefined {
    return this.elementy.get(id);
  }

  wszystkie(): T[] {
    return Array.from(this.elementy.values());
  }

  aktualizuj(id: string, dane: Partial<T>): boolean {
    if (this.elementy.has(id)) {
      const element = this.elementy.get(id)!;
      this.elementy.set(id, { ...element, ...dane });
      return true;
    }
    return false;
  }

  usuń(id: string): boolean {
    return this.elementy.delete(id);
  }

  filtruj(predykat: (element: T) => boolean): T[] {
    return this.wszystkie().filter(predykat);
  }
}

// Generyczna funkcja do znajdowania powiązań między elementami
function znajdźPowiązania<T extends ElementParku, U extends ElementParku>(
  źródła: T[],
  cele: U[],
  predykat: (źródło: T, cel: U) => boolean
): Array<[T, U[]]> {
  return źródła.map(źródło => {
    const powiązaneCele = cele.filter(cel => predykat(źródło, cel));
    return [źródło, powiązaneCele] as [T, U[]];
  });
}

// Generyczna funkcja do tworzenia raportów
function generujRaport<T extends ElementParku>(
  nazwa: string,
  elementy: T[],
  formatujElement: (element: T) => string
): string {
  let raport = `=== ${nazwa} ===\n`;
  raport += `Data wygenerowania: ${new Date().toLocaleString()}\n`;
  raport += `Liczba elementów: ${elementy.length}\n\n`;

  if (elementy.length === 0) {
    raport += "Brak danych do wyświetlenia.\n";
  } else {
    elementy.forEach(element => {
      raport += formatujElement(element) + "\n";
    });
  }

  return raport;
}

// Symulacja danych parku
// Tworzenie repozytoriów
const repoDinozaurów = new Repozytorium<DinozaurParku>();
const repoObszarów = new Repozytorium<ObszarParku>();
const repoWybiegów = new Repozytorium<WybiegDinozaurów>();
const repoPracowników = new Repozytorium<PracownikParku>();

// Dodawanie danych do repozytoriów
// Obszary
const obszarCentralny: ObszarParku = {
  id: "OBS-001",
  nazwa: "Obszar Centralny",
  typElementu: "obszar",
  współrzędne: [20.123, -75.456],
  powierzchnia: 25,
  poziomBezpieczeństwa: 1
};
repoObszarów.dodaj(obszarCentralny);

// Wybiegi
const wybiegTRex: WybiegDinozaurów = {
  id: "WYB-001",
  nazwa: "Wybieg T-Rex",
  typElementu: "wybieg",
  współrzędne: [20.145, -75.460],
  powierzchnia: 8,
  poziomBezpieczeństwa: 5,
  mieszkańcy: ["DINO-001"],
  typŚrodowiska: "las",
  statusOgrodzenia: "aktywne"
};
repoWybiegów.dodaj(wybiegTRex);

const wybiegRaptory: WybiegDinozaurów = {
  id: "WYB-002",
  nazwa: "Wybieg Raptorów",
  typElementu: "wybieg",
  współrzędne: [20.150, -75.465],
  powierzchnia: 5,
  poziomBezpieczeństwa: 5,
  mieszkańcy: ["DINO-002", "DINO-003", "DINO-004", "DINO-005"],
  typŚrodowiska: "sawanna",
  statusOgrodzenia: "aktywne"
};
repoWybiegów.dodaj(wybiegRaptory);

// Dinozaury
const trex: DinozaurParku = {
  id: "DINO-001",
  nazwa: "Rexy",
  typElementu: "dinozaur",
  gatunek: "Tyrannosaurus Rex",
  wiek: 7,
  waga: 8000,
  drapieżnik: true,
  lokalizacja: "WYB-001",
  statusZdrowia: "dobry"
};
repoDinozaurów.dodaj(trex);

const raptor1: DinozaurParku = {
  id: "DINO-002",
  nazwa: "Blue",
  typElementu: "dinozaur",
  gatunek: "Velociraptor",
  wiek: 4,
  waga: 150,
  drapieżnik: true,
  lokalizacja: "WYB-002",
  statusZdrowia: "doskonały"
};
repoDinozaurów.dodaj(raptor1);

// Pracownicy
const trener: PracownikParku = {
  id: "PRAC-001",
  nazwa: "Owen Grady",
  typElementu: "pracownik",
  stanowisko: "Treser Raptorów",
  poziomDostępu: 4,
  specjalizacja: ["Behawioryzm", "Tresura dinozaurów", "Operacje terenowe"]
};
repoPracowników.dodaj(trener);

const naukowiec: PracownikParku = {
  id: "PRAC-002",
  nazwa: "Dr. Henry Wu",
  typElementu: "pracownik",
  stanowisko: "Główny Genetyk",
  poziomDostępu: 5,
  specjalizacja: ["Genetyka", "Inżynieria genetyczna", "Klonowanie"]
};
repoPracowników.dodaj(naukowiec);

// Przykładowe użycie generycznych funkcji

// 1. Znajdowanie dinozaurów w określonych wybiegach
const dinozauryWWybiegach = znajdźPowiązania<WybiegDinozaurów, DinozaurParku>(
  repoWybiegów.wszystkie(),
  repoDinozaurów.wszystkie(),
  (wybieg, dino) => wybieg.mieszkańcy.includes(dino.id)
);

// 2. Generowanie raportu o stanie wybiegów
const raportWybiegów = generujRaport<WybiegDinozaurów>(
  "RAPORT STANU WYBIEGÓW",
  repoWybiegów.wszystkie(),
  wybieg => {
    const liczbaMieszkańców = wybieg.mieszkańcy.length;
    return `${wybieg.nazwa} (ID: ${wybieg.id})
    - Typ środowiska: ${wybieg.typŚrodowiska}
    - Powierzchnia: ${wybieg.powierzchnia} ha
    - Status ogrodzenia: ${wybieg.statusOgrodzenia}
    - Poziom bezpieczeństwa: ${wybieg.poziomBezpieczeństwa}
    - Liczba mieszkańców: ${liczbaMieszkańców}`;
  }
);

// 3. Generowanie raportu o stanie zdrowia dinozaurów
const raportZdrowiaDinozaurów = generujRaport<DinozaurParku>(
  "RAPORT ZDROWIA DINOZAURÓW",
  repoDinozaurów.wszystkie(),
  dino => {
    const lokalizacja = repoWybiegów.pobierz(dino.lokalizacja)?.nazwa || "Nieznana";
    return `${dino.nazwa} (${dino.gatunek})
    - ID: ${dino.id}
    - Wiek: ${dino.wiek} lat
    - Waga: ${dino.waga} kg
    - Status zdrowia: ${dino.statusZdrowia}
    - Lokalizacja: ${lokalizacja}`;
  }
);

// Wyświetlanie raportów
console.log("=== DINOZAURY W WYBIEGACH ===");
dinozauryWWybiegach.forEach(([wybieg, dinozaury]) => {
  console.log(`Wybieg: ${wybieg.nazwa}`);
  if (dinozaury.length === 0) {
    console.log("  Brak mieszkańców");
  } else {
    dinozaury.forEach(dino => {
      console.log(`  - ${dino.nazwa} (${dino.gatunek}): ${dino.statusZdrowia}`);
    });
  }
});

console.log("\n" + raportWybiegów);
console.log("\n" + raportZdrowiaDinozaurów);

Podsumowanie

Funkcje generyczne to niezwykle potężne narzędzie w TypeScript, które pozwala na tworzenie elastycznych, wielokrotnego użytku komponentów, zachowując jednocześnie pełne bezpieczeństwo typów. Podobnie jak zaawansowane techniki genetyczne Dr. Wu, funkcje generyczne pozwalają na tworzenie wysoce adaptacyjnych rozwiązań, które mogą działać z różnymi typami danych.

TechnikaZastosowanie w Parku Jurajskim
Podstawowe funkcje generyczneObsługa różnych typów danych dinozaurów
Wieloparametrowe funkcje generyczneŁączenie danych o dinozaurach z różnych źródeł
Ograniczenia generyczneZapewnienie, że funkcje działają tylko z odpowiednimi typami dinozaurów
Ograniczenia z keyofBezpieczny dostęp do właściwości dinozaurów
Domyślne parametry typuUproszczenie pracy z najczęściej używanymi typami danych
Generyczne operacje na kolekcjachEfektywne zarządzanie grupami dinozaurów
Generyczne klasy i metodyTworzenie elastycznych systemów zarządzania okazami
Generyczne interfejsy i typyDefiniowanie spójnych kontraktów dla różnych podsystemów parku

Dr. Wu podsumowuje: "Tak jak nasze przełomowe techniki genetyczne pozwoliły nam przywrócić do życia gatunki, które zniknęły z Ziemi 65 milionów lat temu, tak generyczne funkcje TypeScript pozwalają programistom tworzyć elastyczne, adaptacyjne rozwiązania, które mogą ewoluować wraz z potrzebami systemu. Pamiętaj jednak, że z wielką mocą wiąże się wielka odpowiedzialność - zarówno w inżynierii genetycznej, jak i w programowaniu."

Kod do tej lekcji: index.ts
// Funkcje generyczne w Parku Jurajskim
console.log("Funkcje generyczne TypeScript\n");

// ===========================================
// 1. Podstawowe funkcje generyczne
// ===========================================
console.log("=== PODSTAWOWE GENERICS ===");

// Prosta funkcja generyczna
function identity<T>(value: T): T {
  return value;
}

const stringValue = identity<string>("Tyrannosaurus Rex");
const numberValue = identity<number>(8000);
const boolValue = identity<boolean>(true);

console.log("String:", stringValue);
console.log("Number:", numberValue);
console.log("Boolean:", boolValue);

// Type inference - TypeScript wywnioskuje typ
const autoString = identity("Auto string"); // T = string
const autoNumber = identity(42); // T = number

console.log("Auto string:", autoString);
console.log("Auto number:", autoNumber);

// ===========================================
// 2. Generics z tablicami
// ===========================================
console.log("\n=== GENERICS Z TABLICAMI ===");

function getFirst<T>(array: T[]): T | undefined {
  return array[0];
}

const dinosaurs = ["T-Rex", "Velociraptor", "Triceratops"];
const weights = [8000, 350, 5000];

console.log("First dinosaur:", getFirst(dinosaurs));
console.log("First weight:", getFirst(weights));

function getLast<T>(array: T[]): T | undefined {
  return array[array.length - 1];
}

console.log("Last dinosaur:", getLast(dinosaurs));

// ===========================================
// 3. Generics z wieloma typami
// ===========================================
console.log("\n=== WIELE TYPÓW GENERYCZNYCH ===");

function createPair<K, V>(key: K, value: V): { key: K; value: V } {
  return { key, value };
}

const pair1 = createPair<string, number>("age", 5);
const pair2 = createPair<number, string>(1, "Rexy");
const pair3 = createPair("weight", 8000); // type inference

console.log("Pair 1:", pair1);
console.log("Pair 2:", pair2);
console.log("Pair 3:", pair3);

// ===========================================
// 4. Generic constraints
// ===========================================
console.log("\n=== GENERIC CONSTRAINTS ===");

interface HasName {
  name: string;
}

// T musi mieć właściwość 'name'
function logName<T extends HasName>(entity: T): T {
  console.log(`Name: ${entity.name}`);
  return entity;
}

interface Dinosaur {
  name: string;
  species: string;
}

const trex: Dinosaur = {
  name: "Rexy",
  species: "Tyrannosaurus Rex"
};

logName(trex);
// logName({ age: 5 }); // Error: no 'name' property

// Constraint z extends
function getLength<T extends { length: number }>(value: T): number {
  return value.length;
}

console.log("String length:", getLength("Hello"));
console.log("Array length:", getLength([1, 2, 3]));
// console.log(getLength(123)); // Error: no 'length' property

// ===========================================
// 5. Generic z interfejsami
// ===========================================
console.log("\n=== GENERICS Z INTERFEJSAMI ===");

interface Container<T> {
  value: T;
  getValue(): T;
  setValue(value: T): void;
}

class DinosaurContainer implements Container<Dinosaur> {
  value: Dinosaur;

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

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

  setValue(value: Dinosaur): void {
    this.value = value;
  }
}

const dinoContainer = new DinosaurContainer(trex);
console.log("Container value:", dinoContainer.getValue());

// ===========================================
// 6. Generic Repository Pattern
// ===========================================
console.log("\n=== REPOSITORY PATTERN ===");

interface Repository<T> {
  items: T[];
  add(item: T): void;
  remove(item: T): void;
  find(predicate: (item: T) => boolean): T | undefined;
  getAll(): T[];
}

class DinosaurRepository implements Repository<Dinosaur> {
  items: Dinosaur[] = [];

  add(dinosaur: Dinosaur): void {
    this.items.push(dinosaur);
    console.log(`Added ${dinosaur.name} to repository`);
  }

  remove(dinosaur: Dinosaur): void {
    const index = this.items.findIndex(d => d.name === dinosaur.name);
    if (index !== -1) {
      this.items.splice(index, 1);
      console.log(`Removed ${dinosaur.name} from repository`);
    }
  }

  find(predicate: (dinosaur: Dinosaur) => boolean): Dinosaur | undefined {
    return this.items.find(predicate);
  }

  getAll(): Dinosaur[] {
    return [...this.items];
  }
}

const dinoRepo = new DinosaurRepository();
dinoRepo.add(trex);
dinoRepo.add({ name: "Blue", species: "Velociraptor" });

const foundDino = dinoRepo.find(d => d.name === "Blue");
console.log("Found:", foundDino);

console.log("All dinosaurs:", dinoRepo.getAll().map(d => d.name));

// ===========================================
// 7. Generic funkcje Array
// ===========================================
console.log("\n=== GENERIC ARRAY FUNCTIONS ===");

function map<T, U>(array: T[], fn: (item: T) => U): U[] {
  const result: U[] = [];
  for (const item of array) {
    result.push(fn(item));
  }
  return result;
}

const dinoNames = ["Rexy", "Blue", "Charlie"];
const upperNames = map(dinoNames, name => name.toUpperCase());
const nameLengths = map(dinoNames, name => name.length);

console.log("Upper names:", upperNames);
console.log("Name lengths:", nameLengths);

function filter<T>(array: T[], predicate: (item: T) => boolean): T[] {
  const result: T[] = [];
  for (const item of array) {
    if (predicate(item)) {
      result.push(item);
    }
  }
  return result;
}

const longNames = filter(dinoNames, name => name.length > 4);
console.log("Long names:", longNames);

// ===========================================
// 8. Generic Promise
// ===========================================
console.log("\n=== GENERIC PROMISE ===");

function fetchDinosaur(id: number): Promise<Dinosaur> {
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve({
        name: `Dinosaur-${id}`,
        species: "Unknown"
      });
    }, 100);
  });
}

async function getDinosaurData(): Promise<void> {
  const dino = await fetchDinosaur(1);
  console.log("Fetched dinosaur:", dino);
}

getDinosaurData();

// ===========================================
// 9. Generic Default Types
// ===========================================
console.log("\n=== DEFAULT TYPES ===");

interface Response<T = any> {
  status: number;
  data: T;
  message: string;
}

const stringResponse: Response<string> = {
  status: 200,
  data: "Success",
  message: "OK"
};

const dinoResponse: Response<Dinosaur> = {
  status: 200,
  data: trex,
  message: "Dinosaur found"
};

const defaultResponse: Response = {
  status: 404,
  data: null,
  message: "Not found"
};

console.log("String response:", stringResponse);
console.log("Dino response:", dinoResponse.data.name);

// ===========================================
// 10. Keyof operator z Generic
// ===========================================
console.log("\n=== KEYOF OPERATOR ===");

function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
  return obj[key];
}

const blue: Dinosaur = {
  name: "Blue",
  species: "Velociraptor"
};

const dinoName = getProperty(blue, "name"); // string
const dinoSpecies = getProperty(blue, "species"); // string
// const invalid = getProperty(blue, "age"); // Error

console.log("Property 'name':", dinoName);
console.log("Property 'species':", dinoSpecies);

// ===========================================
// 11. Generic Utility Functions
// ===========================================
console.log("\n=== UTILITY FUNCTIONS ===");

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

const basicInfo = { name: "Rexy", age: 5 };
const detailedInfo = { species: "T-Rex", weight: 8000 };

const fullInfo = merge(basicInfo, detailedInfo);
console.log("Merged:", fullInfo);

function partial<T>(obj: T): Partial<T> {
  return { ...obj };
}

const partialDino = partial(trex);
console.log("Partial:", partialDino);

// ===========================================
// 12. Podsumowanie
// ===========================================
console.log("\n=== PODSUMOWANIE ===");
console.log("Funkcje generyczne - <T>");
console.log("Wiele typów - <K, V>");
console.log("Constraints - <T extends Type>");
console.log("Generic interfejsy - Interface<T>");
console.log("Repository pattern - uniwersalne repozytorium");
console.log("Generic Promise - asynchroniczne typy");
console.log("Keyof operator - dostęp do kluczy");
console.log("Utility functions - uniwersalne narzędzia");

console.log("\nFunkcje generyczne opanowane!");

Hasła z dokumentacji w tej lekcji

Widzisz błąd w tej lekcji?

Sprawdź się

Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.

  1. 1. Czym jest funkcja generyczna w TypeScript?

  2. 2. Jak ograniczyć parametr generyczny T, aby akceptował tylko typy z właściwością 'id'?

Zadania praktyczne w grze

  • Edytor kodu

    Zaimplementuj generyczną funkcję findById<T> przyjmującą tablicę obiektów z polem id i zwracającą element lub undefined.

  • Edytor kodu

    Zaimplementuj generyczną funkcję filterByProperty<T, K> przyjmującą tablicę, klucz i wartość, zwracającą przefiltrowane elementy.

  • Klikanie w kolejności

    Ułóż elementy generycznej funkcji TypeScript:

  • Układanie w pionie

    Uporządkuj koncepty generyczne od najprostszych do najbardziej zaawansowanych:

  1. PytanieCzym są funkcje generyczne
  2. PytanieOgraniczenia generyczne (constraints)
  3. Zadanie z kodemPraktyka: Generyczna funkcja
  4. Zadanie z kodemPraktyka: Generyczna funkcja wyszukiwania
  5. Kliknij w kolejnościSortowanie: Generyczna funkcja
  6. Ułóż w kolejnościOd prostych do zaawansowanych generyków

Przydatne artykuły