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

Typowanie Komponentów Funkcyjnych

4 min czytania ·
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:

  1. 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
  2. Jawne typowanie jest bardziej czytelne - widać dokładnie, co komponent przyjmuje
  3. 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. 1. Jakie rozszerzenie pliku używa się dla komponentów React napisanych w TypeScript?

  2. 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:

  1. PytanieRozszerzenie plików React z TypeScript
  2. Zadanie z kodemPraktyka: Interfejsy i typowanie podstawowe
  3. PytanieReact.FC vs jawne typowanie
  4. Kliknij w kolejnościDefinicja interfejsu TypeScript

Przydatne artykuły