TypeScript Academy · Lekcja

Props i children; obsługa zdarzeń; refs

Definiowanie typowanych props i children, bezpieczne podłączanie obsługi zdarzeń oraz tworzenie i używanie refs do uzyskiwania dostępu do węzłów DOM

Lekcja 1 z 38 kroki

Props i children; obsługa zdarzeń; refs to bezpłatna lekcja TypeScript Academy na CoddyKit. To lekcja 1 z 3. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej TypeScript Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs TypeScript Academy zawiera 3 lekcji w sumie.

Wprowadzenie

Cel: Tworzyć typowane komponenty React: definiować propsy (wraz z children), dołączać handlery zdarzeń z precyzyjnymi typami oraz ustawiać fokus na polu wejściowym za pomocą refów.

  • Interfejsy typowanych propsów
  • Typy handlerów zdarzeń
  • Refy do dostępu do DOM

Typowane propsy

Zadeklaruj interfejs propsów; używaj opcjonalnych propsów i zawężaj ich typ za pomocą literałów unii. Wartości domyślne umieszczaj wewnątrz komponentu.

import React from "react"

interface BadgeProps {
  text: string
  color?: "primary" | "success" | "warning"
}

export function Badge({ text, color = "primary" }: BadgeProps) {
  const bg = color === "success" ? "#16a34a" : color === "warning" ? "#d97706" : "#2563eb"
  return <span style={{ backgroundColor: bg, color: "white", padding: 4, borderRadius: 6 }}>{text}</span>
}

export default function App() {
  return (
    <div style={{ display: "grid", gap: 8 }}>
      <Badge text="Saved" color="success" />
      <Badge text="Warn" color="warning" />
    </div>
  )
}

Children

Użyj PropsWithChildren<T> (lub React.PropsWithChildren), aby dodać do propsów typowany slot children.

import React, { PropsWithChildren } from "react"

type CardProps = PropsWithChildren<{ title: string }>

function Card({ title, children }: CardProps) {
  return (
    <div style={{ border: "1px solid #e5e7eb", padding: 12, borderRadius: 8 }}>
      <h3 style={{ margin: 0 }}>{title}</h3>
      <div>{children}</div>
    </div>
  )
}

export default function App() {
  return (
    <Card title="Dashboard">
      <p>Children are typed automatically.</p>
    </Card>
  )
}

Handlery zdarzeń

Preferuj React.MouseEvent<Element> i React.ChangeEvent<HTMLInputElement>. Udostępniają one typowane właściwości target/currentTarget.

import React from "react"

export default function App() {
  const handleClick = (e: React.MouseEvent<HTMLButtonElement>) => {
    console.log("clicked", e.currentTarget.name)
  }

  const handleChange = (e: React.ChangeEvent<HTMLInputElement>) => {
    console.log("value", e.target.value)
  }

  return (
    <div style={{ display: "grid", gap: 8 }}>
      <input name="n" onChange={handleChange} placeholder="Type here" />
      <button name="ok" onClick={handleClick}>Confirm</button>
    </div>
  )
}

Refy: dostęp do DOM

useRef<HTMLInputElement>(null) zachowuje ref jako wartość nullowalną; używaj opcjonalnego łańcuchowania, aby bezpiecznie uzyskać dostęp do węzła DOM.

import React, { useRef } from "react"

export default function App() {
  const inputRef = useRef<HTMLInputElement>(null)

  const focusInput = () => {
    inputRef.current?.focus()
  }

  return (
    <div style={{ display: "grid", gap: 8 }}>
      <input ref={inputRef} placeholder="Focus me" />
      <button onClick={focusInput}>Focus</button>
    </div>
  )
}

Przekazywanie refów

forwardRef pozwala komponentom nadrzędnym uzyskać dostęp do węzła DOM komponentu podrzędnego. Podaj typ elementu, aby uzyskać precyzyjne typowanie.

import React, { forwardRef } from "react"

type TextInputProps = { label: string }

const TextInput = forwardRef<HTMLInputElement, TextInputProps>(function TextInput({ label }, ref) {
  return (
    <label style={{ display: "grid", gap: 4 }}>
      <span>{label}</span>
      <input ref={ref} />
    </label>
  )
})

export default function App() {
  const setRef = (el: HTMLInputElement | null) => { if (el) el.focus() }
  return <TextInput ref={setRef} label="Auto focus" />
}

Sprawdzanie typowania zdarzeń

Szybkie sprawdzenie: jaki jest poprawny typ handlera kliknięcia przycisku?

Podsumowanie

Podsumowanie: Definiuj propsy (wraz z children), precyzyjnie typuj zdarzenia i używaj refów (w tym forwardRef), aby bezpiecznie uzyskiwać dostęp do węzłów DOM.

Bezpłatny start

Ucz się TypeScript dzięki korepetycjom AI — za darmo

Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.

Kursy
101
Lekcje
352

Często zadawane pytania

Czy lekcja „Props i children; obsługa zdarzeń; refs” jest bezpłatna?

Tak — pełny tekst „Props i children; obsługa zdarzeń; refs” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu TypeScript Academy, przejdź na CoddyKit PRO. Kurs TypeScript Academy zawiera 3 lekcji w sumie.

Co nauczysz się w „Props i children; obsługa zdarzeń; refs”?

Definiowanie typowanych props i children, bezpieczne podłączanie obsługi zdarzeń oraz tworzenie i używanie refs do uzyskiwania dostępu do węzłów DOM Ćwiczysz TypeScript Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć TypeScript Academy?

Nie wymagamy żadnego doświadczenia. TypeScript Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 3.

Ile czasu zajmuje lekcja „Props i children; obsługa zdarzeń; refs”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji TypeScript Academy?

Tak. Każda lekcja TypeScript Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Props i children; obsługa zdarzeń; refs
  2. Stan i reducery; typowanie Context
  3. Generyki komponentów — wprowadzenie
← Powrót do TypeScript Academy