Kurs JavaScript i React · Moduł 12: React i TypeScript
Typowanie Komponentów Funkcyjnych
W tej lekcji3
Zbudowałeś moduł statku, podłączyłeś go do reszty, a po tygodniu ktoś z załogi przekazuje mu liczbę tam, gdzie moduł oczekiwał tekstu. Nikt tego nie zauważył, bo komponent nie miał żadnej instrukcji obsługi. W React każdy komponent to funkcja. TypeScript pozwala nam precyzyjnie określić, co ta funkcja przyjmuje (props) i co zwraca (JSX). To jak instrukcja obsługi każdego modułu na statku kosmicznym.
React.FC vs jawne typowanie
Istnieją dwa popularne sposoby typowania komponentów funkcyjnych w React. Oba spotkasz w cudzym kodzie, więc warto rozumieć każdy z nich, zanim wybierzesz swój.
Sposób 1: React.FC (Function Component)
React.FC (skrót od React.FunctionComponent) to typ generyczny: w nawiasach ostrych podajesz typ props, a on opisuje całą funkcję komponentu. Przypisujesz go do stałej, nie do parametru. Aby użyć nazwy React.FC, trzeba zaimportować React (albo sam typ FC).
import React from 'react';
// React.FC opisuje całą funkcję komponentu (props + zwracany typ)
const StarInfo: React.FC = () => {
return <p>Informacje o gwieździe</p>;
};Bez parametru generycznego React.FC oznacza komponent bez props. Gdy props są potrzebne, najpierw opisujemy je interfejsem StarProps, a potem podajemy ten interfejs w nawiasach ostrych:
// React.FC z propsami
interface StarProps {
name: string;
brightness: number;
}
const StarCard: React.FC<StarProps> = ({ name, brightness }) => {
return (
<div>
<h3>{name}</h3>
<p>Jasność: {brightness}</p>
</div>
);
};TypeScript wie teraz, że name to tekst, a brightness to liczba, choć w samej destrukturyzacji nie ma żadnych typów - przyszły z adnotacji na stałej StarCard.
Sposób 2: Jawne typowanie (zalecane)
Drugi sposób polega na otypowaniu samego parametru funkcji, dokładnie tak jak w zwykłej funkcji TypeScript. Typ zwracany możesz zapisać jako React.JSX.Element, czyli "element JSX".
// Jawne typowanie - bardziej przejrzyste i elastyczne
interface StarProps {
name: string;
brightness: number;
}
function StarCard({ name, brightness }: StarProps): React.JSX.Element {
return (
<div>
<h3>{name}</h3>
<p>Jasność: {brightness}</p>
</div>
);
}Ten sam zapis działa w funkcji strzałkowej - typ props nadal stoi przy parametrze, a nie przy stałej:
// Lub jako arrow function
const StarCardArrow = ({ name, brightness }: StarProps): React.JSX.Element => {
return (
<div>
<h3>{name}</h3>
<p>Jasność: {brightness}</p>
</div>
);
};JSX w środku nie zmienił się ani o znak w porównaniu ze sposobem 1. Różnica jest wyłącznie w tym, gdzie stoi informacja o typach.
Dlaczego jawne typowanie jest zalecane?
Społeczność React w dużej mierze odeszła od React.FC z kilku powodów:
- Historycznie React.FC dodawał children - do @types/react 17 każdy komponent React.FC "przyjmował"
children, nawet gdy ich nie używał. Od @types/react 18 już tak nie jest, ale wiele starych artykułów wciąż to powtarza - Jawne typowanie jest bardziej czytelne - widać dokładnie, co komponent przyjmuje
- Lepsza kompatybilność - działa identycznie z function i arrow function, a także z komponentami generycznymi, których React.FC nie obsługuje
Zobacz, jak wygląda próba użycia children w obu podejściach we współczesnym React:
// React.FC - od @types/react 18 children NIE jest dodawane automatycznie
const Badge: React.FC<{ label: string }> = ({ label, children }) => {
return <span>{label}{children}</span>; // BŁĄD: Property 'children' does not exist
};
// Jawne typowanie - children trzeba jawnie dodać
interface BadgeProps {
label: string;
}
function Badge({ label }: BadgeProps): React.JSX.Element {
return <span>{label}</span>; // nie ma children, bo nie jest w props
}W obu przypadkach, jeśli komponent ma przyjmować children, musisz dopisać je do typu props - zrobimy to w następnej lekcji. Moja rada: pisz jawne typy przy parametrze. Jest to krótsze, czytelniejsze i zgodne z przykładami na react.dev.
Zwracany typ komponentu
Komponent React może zwracać różne rzeczy: element JSX, tekst, liczbę albo null, gdy nie ma nic do pokazania. Każdej z tych możliwości odpowiada inny typ:
// React.JSX.Element - najczęściej używany
function Planet(): React.JSX.Element {
return <div>Mars</div>;
}
// React.ReactElement - bardziej ogólny typ elementu React
function Planet(): React.ReactElement {
return <div>Mars</div>;
}Ważna poprawka do starszych tutoriali: zapis JSX.Element bez przedrostka korzystał z globalnej przestrzeni nazw JSX, która w typach React 19 została usunięta. Pisz React.JSX.Element - działa w React 18 i 19. Jeśli komponent może zwrócić null lub tekst, użyj najszerszego typu:
// React.ReactNode - najbardziej elastyczny (JSX, string, number, null)
function MaybeContent(): React.ReactNode {
return null; // może zwrócić null
}
// W praktyce najczęściej pomijamy typ zwracany
// TypeScript sam go wydedukuje
function Planet() {
return <div>Mars</div>; // TypeScript wie, że to React.JSX.Element
}Komponent zwracający React.ReactNode możesz używać w JSX od TypeScript 5.1. W codziennej pracy najczęściej po prostu pomijasz typ zwracany i pozwalasz kompilatorowi go wydedukować - otypowane props to ta część, która naprawdę chroni Twój statek.
Poćwicz oba style w edytorze. W kolejnej lekcji rozbudujemy interfejs props o pola opcjonalne i children.
Kod do tej lekcji: App.tsx
import React from 'react';
// Interfejs propsow
interface CrewMemberProps {
name: string;
rank: string;
specialization: string;
yearsInSpace: number;
}
// Sposob 1: React.FC (Function Component)
const CrewBadgeFC: React.FC<CrewMemberProps> = ({ name, rank, specialization, yearsInSpace }) => {
return (
<div className="badge-card">
<div className="badge-header">FC</div>
<h3>{name}</h3>
<p className="rank">{rank}</p>
<p>Specjalizacja: {specialization}</p>
<p>Lata w kosmosie: {yearsInSpace}</p>
</div>
);
};
// Sposob 2: Jawne typowanie (zalecane)
function CrewBadgeExplicit({ name, rank, specialization, yearsInSpace }: CrewMemberProps): JSX.Element {
return (
<div className="badge-card">
<div className="badge-header">Explicit</div>
<h3>{name}</h3>
<p className="rank">{rank}</p>
<p>Specjalizacja: {specialization}</p>
<p>Lata w kosmosie: {yearsInSpace}</p>
</div>
);
}
// Sposob 3: Arrow function z jawnym typem
const CrewBadgeArrow = ({ name, rank, specialization, yearsInSpace }: CrewMemberProps): JSX.Element => {
return (
<div className="badge-card">
<div className="badge-header">Arrow</div>
<h3>{name}</h3>
<p className="rank">{rank}</p>
<p>Specjalizacja: {specialization}</p>
<p>Lata w kosmosie: {yearsInSpace}</p>
</div>
);
};
function App() {
const member: CrewMemberProps = {
name: "Nova",
rank: "Kapitan",
specialization: "Nawigacja",
yearsInSpace: 15
};
return (
<div className="app">
<h1>Sposoby typowania komponentow</h1>
<div className="cards">
<CrewBadgeFC {...member} />
<CrewBadgeExplicit {...member} />
<CrewBadgeArrow {...member} />
</div>
<p className="note">Wszystkie trzy sposoby daja ten sam rezultat. Zalecany jest sposob z jawnym typowaniem (Explicit).</p>
</div>
);
}
export default App;Pamiętaj: typ props to instrukcja obsługi modułu - przyklej ją do parametru, a każdy członek załogi wie, jak go podłączyć.
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. Jakie rozszerzenie pliku używa się dla komponentów React napisanych w TypeScript?
2. Który sposób typowania komponentów funkcyjnych jest obecnie zalecany przez społeczność React?
Zadania praktyczne w grze
- Edytor kodu
Podstawowe typowanie interfejsów i komponentów
- Klikanie w kolejności
Ułóż składnię definicji interfejsu w TypeScript: