Kurs JavaScript i React · Moduł 12: React i TypeScript
Komponenty Generyczne - Uniwersalne Systemy Nawigacji
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 stringZapis 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. Co oznacza zapis <T> w deklaracji function getFirst<T>(items: T[]): T?
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