Kurs JavaScript i React · Moduł 12: React i TypeScript

Komponenty Generyczne - Uniwersalne Systemy Nawigacji

5 min czytania ·
W tej lekcji5

Masz komponent listy planet. Po tygodniu potrzebujesz listy gwiazd, potem członków załogi, potem statków. Kopiujesz komponent czwarty raz i zmieniasz tylko typ - a każdy błąd trzeba odtąd poprawiać w czterech miejscach. Wyobraź sobie zamiast tego uniwersalny system nawigacji na statku kosmicznym, który może wyświetlać dane o planetach, gwiazdach, statkach - cokolwiek mu podasz. W TypeScript takie "uniwersalne" komponenty tworzymy dzięki generykom.

Czym są generyki?

Generyki to parametry typów - pozwalają tworzyć komponenty i funkcje, które działają z różnymi typami danych, zachowując pełną kontrolę typów. Parametr typu zapisujesz w nawiasach ostrych, zwykle jedną wielką literą T (od "type"). To miejsce na typ, który zostanie podany dopiero przy użyciu - jak zmienna, tylko dla typów.

W przykładzie używamy interfejsów Planet i Star z lekcji o props, a planets i stars to tablice takich obiektów:

// Bez generyków - trzeba pisać osobne funkcje
function getFirstPlanet(items: Planet[]): Planet {
  return items[0];
}
function getFirstStar(items: Star[]): Star {
  return items[0];
}

Obie funkcje robią dokładnie to samo, różnią się tylko typem. Generyk zamienia je w jedną:

// Z generykami - jedna funkcja dla wszystkich typów
function getFirst<T>(items: T[]): T {
  return items[0];
}

const planet = getFirst<Planet>(planets);  // zwraca Planet
const star = getFirst<Star>(stars);        // zwraca Star
const name = getFirst<string>(["a", "b"]); // zwraca string

Zapis getFirst<T>(items: T[]): T czytamy: "dla dowolnego typu T przyjmij tablicę T i zwróć jedno T". Typ nie ginie po drodze - planet ma typ Planet, więc edytor podpowie jego pola. W praktyce nawiasy przy wywołaniu możesz pominąć, bo TypeScript wydedukuje T z argumentu: getFirst(planets) da ten sam wynik.

Generyczny komponent listy

Jednym z najczęstszych zastosowań generyków w React jest uniwersalny komponent listy. Lista potrzebuje jednej gwarancji: każdy element musi mieć id, bo React wymaga unikalnego key. Taką gwarancję zapisujemy słowem extends - zapis T extends HasId oznacza "T może być czymkolwiek, byle miało pole id". To tak zwane ograniczenie (constraint).

// Każdy element musi mieć id do użycia jako key
interface HasId {
  id: number | string;
}

interface ListProps<T extends HasId> {
  items: T[];
  renderItem: (item: T) => React.ReactNode;
  emptyMessage?: string;
}

Props renderItem to tak zwany render prop: funkcja, którą rodzic przekazuje, aby zdecydować, jak narysować pojedynczy element. Sama lista nie wie nic o planetach - wie tylko, jak je ułożyć:

function List<T extends HasId>({ items, renderItem, emptyMessage = "Brak danych" }: ListProps<T>) {
  if (items.length === 0) {
    return <p>{emptyMessage}</p>;
  }

  return (
    <ul>
      {items.map(item => (
        <li key={item.id}>{renderItem(item)}</li>
      ))}
    </ul>
  );
}

Dzięki ograniczeniu item.id jest dozwolone w key. Gdybyś spróbował odczytać item.name, TypeScript zaprotestuje - lista nie ma gwarancji, że takie pole istnieje. Uwaga techniczna: w pliku .tsx funkcja strzałkowa z generykiem wymaga zapisu <T,> z przecinkiem, żeby kompilator nie pomylił jej ze znacznikiem JSX. Deklaracja function tego problemu nie ma.

Użycie generycznego komponentu

Przygotujmy dwa różne rodzaje danych. Planety mają id liczbowe, członkowie załogi - tekstowe, i oba warianty spełniają HasId:

interface Planet {
  id: number;
  name: string;
  type: string;
}

interface CrewMember {
  id: string;
  name: string;
  rank: string;
}

Teraz ten sam komponent List wyświetla obie kolekcje. Zapis <List<Planet> jawnie podaje typ, choć TypeScript wydedukowałby go z items:

function Dashboard() {
  const planets: Planet[] = [
    { id: 1, name: "Mars", type: "skalista" },
    { id: 2, name: "Jupiter", type: "gazowy" }
  ];

  const crew: CrewMember[] = [
    { id: "c1", name: "Nova", rank: "Kapitan" },
    { id: "c2", name: "Ra", rank: "Nawigator" }
  ];

  return (
    <div>
      <h2>Planety</h2>
      <List<Planet>
        items={planets}
        renderItem={(planet) => <span>{planet.name} ({planet.type})</span>}
      />

      <h2>Załoga</h2>
      <List<CrewMember>
        items={crew}
        renderItem={(member) => <span>{member.name} - {member.rank}</span>}
      />
    </div>
  );
}

W renderItem parametr planet ma typ Planet, a member - CrewMember, bez żadnych adnotacji. Komponent List nie zmienił się ani o linijkę.

Generyczny komponent Select

Ten sam wzorzec działa dla pola wyboru. Ograniczenie wymaga pól value i label, a onChange oddaje rodzicowi cały wybrany obiekt, z zachowaniem jego dokładnego typu. Handler zmiany korzysta z ChangeEvent z poprzedniej lekcji:

interface SelectOption {
  value: string;
  label: string;
}

interface SelectProps<T extends SelectOption> {
  options: T[];
  value: string;
  onChange: (option: T) => void;
  placeholder?: string;
}

function Select<T extends SelectOption>({
  options, value, onChange, placeholder
}: SelectProps<T>) {
  const handleChange = (e: React.ChangeEvent<HTMLSelectElement>) => {
    const selected = options.find(opt => opt.value === e.target.value);
    if (selected) onChange(selected);
  };

  return (
    <select value={value} onChange={handleChange}>
      {placeholder && <option value="">{placeholder}</option>}
      {options.map(opt => (
        <option key={opt.value} value={opt.value}>
          {opt.label}
        </option>
      ))}
    </select>
  );
}

Metoda find może zwrócić undefined, dlatego if (selected) jest konieczne - TypeScript nie pozwoli przekazać możliwego undefined do onChange.

Ograniczenia generyków (constraints)

Słowo kluczowe extends pozwala ograniczyć, jakie typy są akceptowane. Ograniczeniem może być typ zapisany w miejscu albo nazwany interfejs:

// T musi mieć pole 'name'
function displayName<T extends { name: string }>(item: T): string {
  return item.name;
}

// T musi implementować interfejs Sortable
interface Sortable {
  sortOrder: number;
}

function sortItems<T extends Sortable>(items: T[]): T[] {
  return [...items].sort((a, b) => a.sortOrder - b.sortOrder);
}

Ograniczenie to minimum, nie dokładny kształt: obiekt może mieć dodatkowe pola i zostaną one zachowane w typie wyniku. [...items] tworzy kopię, więc sortowanie nie modyfikuje oryginalnej tablicy. Moja rada: sięgaj po generyk dopiero wtedy, gdy ten sam komponent naprawdę obsługuje dwa różne typy danych - wcześniej wystarczy zwykły interfejs. W projekcie końcowym zbudujesz generyczną tabelę danych.

Kod do tej lekcji: App.tsx
import React, { useState } from 'react';

// Ograniczenie generyczne - kazdy element musi miec id
interface HasId {
  id: number | string;
}

// Generyczny komponent listy
interface ListProps<T extends HasId> {
  items: T[];
  renderItem: (item: T) => React.ReactNode;
  title: string;
  emptyMessage?: string;
}

function List<T extends HasId>({ items, renderItem, title, emptyMessage = "Brak elementow" }: ListProps<T>) {
  return (
    <div className="list-container">
      <h2>{title} ({items.length})</h2>
      {items.length === 0 ? (
        <p className="empty">{emptyMessage}</p>
      ) : (
        <ul className="list">
          {items.map(item => (
            <li key={item.id} className="list-item">{renderItem(item)}</li>
          ))}
        </ul>
      )}
    </div>
  );
}

// Rozne typy danych
interface Planet {
  id: number;
  name: string;
  type: string;
  habitable: boolean;
}

interface CrewMember {
  id: string;
  name: string;
  rank: string;
  specialization: string;
}

interface Mission {
  id: number;
  codeName: string;
  status: "planned" | "active" | "completed";
  destination: string;
}

function App() {
  const [planets] = useState<Planet[]>([
    { id: 1, name: "Kepler-442b", type: "skalista", habitable: true },
    { id: 2, name: "HD 209458 b", type: "gazowa", habitable: false },
    { id: 3, name: "Proxima Centauri b", type: "skalista", habitable: true },
  ]);

  const [crew] = useState<CrewMember[]>([
    { id: "c1", name: "Nova", rank: "Kapitan", specialization: "Nawigacja" },
    { id: "c2", name: "Ra", rank: "Nawigator", specialization: "Astrofizyka" },
    { id: "c3", name: "Astro", rank: "Inzynier", specialization: "Silniki" },
  ]);

  const [missions] = useState<Mission[]>([
    { id: 1, codeName: "DAWN", status: "active", destination: "Mars" },
    { id: 2, codeName: "HORIZON", status: "planned", destination: "Jupiter" },
  ]);

  const statusColors = { planned: "#f59e0b", active: "#22c55e", completed: "#6b7280" };

  return (
    <div className="app">
      <h1>Generyczne Komponenty</h1>

      <List<Planet>
        title="Planety"
        items={planets}
        renderItem={(planet) => (
          <div className="item-content">
            <strong>{planet.name}</strong>
            <span className="detail">{planet.type}</span>
            <span className={"badge " + (planet.habitable ? "green" : "red")}>
              {planet.habitable ? "Zamieszkiwalna" : "Niezamieszkiwalna"}
            </span>
          </div>
        )}
      />

      <List<CrewMember>
        title="Zaloga"
        items={crew}
        renderItem={(member) => (
          <div className="item-content">
            <strong>{member.name}</strong>
            <span className="detail">{member.rank}</span>
            <span className="spec">{member.specialization}</span>
          </div>
        )}
      />

      <List<Mission>
        title="Misje"
        items={missions}
        renderItem={(mission) => (
          <div className="item-content">
            <strong>{mission.codeName}</strong>
            <span className="detail">{mission.destination}</span>
            <span style={{ color: statusColors[mission.status] }}>
              {mission.status.toUpperCase()}
            </span>
          </div>
        )}
      />
    </div>
  );
}

export default App;

Pamiętaj: generyk to uniwersalne dokowanie - każdy statek, który spełnia wymagania portu, zadokuje bez przebudowy stacji.

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. Co oznacza zapis <T> w deklaracji function getFirst<T>(items: T[]): T?

  2. 2. Co oznacza zapis <T extends { id: number }> w generycznym komponencie React?

Zadania praktyczne w grze

  • Układanie w pionie

    Ułóż kolejność kroków tworzenia generycznego komponentu listy:

  • Edytor kodu

    Generyczny komponent Select z ograniczeniami

  • Układanie w poziomie

    Ułóż składnię ograniczenia generycznego (constraint) w TypeScript:

  • Edytor kodu

    Generyczny komponent z render prop i filtrowaniem

  1. PytanieGeneryki w TypeScript
  2. Ułóż w kolejnościTworzenie generycznego komponentu
  3. Zadanie z kodemPraktyka: Generyczny komponent Select
  4. PytanieOgraniczenie generyczne (constraint)
  5. Ułóż w kolejnościSkładnia ograniczenia generycznego
  6. Zadanie z kodemPraktyka: Generyczna lista z filtrowaniem

Przydatne artykuły